自学教程：C++ GET_LOCK函数代码示例

/*---------------------------------------------------------------------------*/static intsend(const void *payload, unsigned short payload_len){	int res = 0;	GET_LOCK();	cc2520ll_prepare(payload, payload_len);	RELEASE_LOCK();	GET_LOCK();	res =  cc2520ll_transmit();	RELEASE_LOCK();	return res;}

/*---------------------------------------------------------------------------*/voiduz2400_set_pan_addr(unsigned pan,                    unsigned addr,                    const cyg_uint8 *ieee_addr){    cyg_uint16 f = 0;      GET_LOCK();/*    UzSetPanId(pan);*/  uz_set_panId(pan);/*   UzSetNwkAddr(addr);  */  uz_set_nwk_addr(addr);  if(ieee_addr != NULL) {       cyg_uint8 addr[8];    /* LSB first, MSB last for 802.15.4 addresses in UZ2400 */      for (f = 0; f < 8; f++) {          addr[7-f] = ieee_addr[f];        }/*	      UzSetMacAddress(addr);*/    uz_set_mac_address(addr);      }    RELEASE_LOCK();}

intchannel_clear(void){	  int cca;	  int radio_was_off = 0;	  PRINTF("CCA/n");	  /* If the radio is locked by an underlying thread (because we are	     being invoked through an interrupt), we preted that the coast is	     clear (i.e., no packet is currently being transmitted by a	     neighbor). */	  if(locked) {	    return 1;	  }	  GET_LOCK();	  if(!receive_on) {	    radio_was_off = 1;	    cc2520_on();	  }	  /* Make sure that the radio really got turned on. */	  if(!receive_on) {	    RELEASE_LOCK();	    if(radio_was_off) {	      cc2520_off();	    }	    return 1;	  }	  cca = cc2520ll_channel_clear();	  if(radio_was_off) {	    cc2520_off();	  }	  RELEASE_LOCK();	  return cca;}

/*---------------------------------------------------------------------------*/voidcc2520_set_cca_threshold(int value){  GET_LOCK();  setreg(CC2520_CCACTRL0, value & 0xff);  RELEASE_LOCK();}

/*---------------------------------------------------------------------------*/intcc2520_off(void){	PRINTF("OFF/n");  /* Don't do anything if we are already turned off. */  if(receive_on == 0) {	  //PRINTF("DONT CALL OFF WAS OFF/n");    return 1;  }  /* If we are called when the driver is locked, we indicate that the     radio should be turned off when the lock is unlocked. */  if(locked) {    /*    PRINTF("Off when locked (%d)/n", locked);*/    lock_off = 1;    //PRINTF("DONT CALL OFF WAS LOCKED SCHEDULE OFF/n");    return 1;  }  GET_LOCK();  /* If we are currently receiving a packet (indicated by SFD == 1),     we don't actually switch the radio off now, but signal that the     driver should switch off the radio once the packet has been     received and processed, by setting the 'lock_off' variable. */  if(cc2520ll_rxtx_packet()) {	  //PRINTF("DONT CALL OFF WAS LOCKED SCHEDULE OFF BUSY/n");    lock_off = 1;  } else {	  //PRINTF("CALL OFF WAS ON/n");    off();  }  RELEASE_LOCK();  return 1;}

/*---------------------------------------------------------------------------*/intcc2520_off(void){  /* Don't do anything if we are already turned off. */  if(receive_on == 0) {    return 1;  }  /* If we are called when the driver is locked, we indicate that the     radio should be turned off when the lock is unlocked. */  if(locked) {    /*    printf("Off when locked (%d)/n", locked);*/    lock_off = 1;    return 1;  }  GET_LOCK();  /* If we are currently receiving a packet (indicated by SFD == 1),     we don't actually switch the radio off now, but signal that the     driver should switch off the radio once the packet has been     received and processed, by setting the 'lock_off' variable. */  if(status() & BV(CC2520_TX_ACTIVE)) {    lock_off = 1;  } else {    off();  }  RELEASE_LOCK();  return 1;}

/*---------------------------------------------------------------------------*/static intcc2520_prepare(const void *payload, unsigned short payload_len){  uint8_t total_len;  GET_LOCK();  PRINTF("cc2520: sending %d bytes/n", payload_len);  /*int i;  for(i = 0; i < payload_len;i++)	  printf("%x",((uint8_t *) payload)[i]);  printf("/n");*/  RIMESTATS_ADD(lltx);  /* Wait for any previous transmission to finish. */  /*  while(status() & BV(CC2520_TX_ACTIVE));*/  /* Write packet to TX FIFO. */  strobe(CC2520_INS_SFLUSHTX);  total_len = payload_len + FOOTER_LEN;  CC2520_WRITE_FIFO_BUF(&total_len, 1);  CC2520_WRITE_FIFO_BUF(payload, payload_len);  RELEASE_LOCK();  return 0;}

/*---------------------------------------------------------------------------*/voidcc2520_set_pan_addr(unsigned pan,                    unsigned addr,                    const uint8_t *ieee_addr){  uint8_t tmp[2];  GET_LOCK();  /*   * Writing RAM requires crystal oscillator to be stable.   */  BUSYWAIT_UNTIL(status() & (BV(CC2520_XOSC16M_STABLE)), RTIMER_SECOND / 10);  tmp[0] = pan & 0xff;  tmp[1] = pan >> 8;  CC2520_WRITE_RAM(&tmp, CC2520RAM_PANID, 2);  tmp[0] = addr & 0xff;  tmp[1] = addr >> 8;  CC2520_WRITE_RAM(&tmp, CC2520RAM_SHORTADDR, 2);  if(ieee_addr != NULL) {    int f;    uint8_t tmp_addr[8];    // LSB first, MSB last for 802.15.4 addresses in CC2520    for (f = 0; f < 8; f++) {      tmp_addr[7 - f] = ieee_addr[f];    }    CC2520_WRITE_RAM(tmp_addr, CC2520RAM_IEEEADDR, 8);  }  RELEASE_LOCK();}

/*---------------------------------------------------------------------------*/intcc2520_set_channel(int c){  uint16_t f;  GET_LOCK();  /*   * Subtract the base channel (11), multiply by 5, which is the   * channel spacing. 357 is 2405-2048 and 0x4000 is LOCK_THR = 1.   */  channel = c;  f = MIN_CHANNEL + ((channel - MIN_CHANNEL) * CHANNEL_SPACING);  /*   * Writing RAM requires crystal oscillator to be stable.   */  BUSYWAIT_UNTIL((status() & (BV(CC2520_XOSC16M_STABLE))), RTIMER_SECOND / 10);  /* Wait for any transmission to end. */  BUSYWAIT_UNTIL(!(status() & BV(CC2520_TX_ACTIVE)), RTIMER_SECOND / 10);  /* Define radio channel (between 11 and 25) */  setreg(CC2520_FREQCTRL, f);  /* If we are in receive mode, we issue an SRXON command to ensure     that the VCO is calibrated. */  if(receive_on) {    strobe(CC2520_INS_SRXON);  }  RELEASE_LOCK();  return 1;}

/*---------------------------------------------------------------------------*/voidcc2520_set_txpower(uint8_t power){  GET_LOCK();  set_txpower(power);  RELEASE_LOCK();}

/* * Called by the CURRENT thread to load a word-sized value in a unit transaction. */stm_word_t stm_unit_load(volatile stm_word_t *addr, stm_word_t *timestamp){  volatile stm_word_t *lock;  stm_word_t l, l2, value;  PRINT_DEBUG2("==> stm_unit_load(a=%p)/n", addr);  /* Get reference to lock */  lock = GET_LOCK(addr);  /* Read lock, value, lock */ restart:  l = ATOMIC_LOAD_ACQ(lock); restart_no_load:  if (LOCK_GET_OWNED(l)) {    /* Locked: wait until lock is free */    sched_yield();    goto restart;  }  /* Not locked */  value = ATOMIC_LOAD_ACQ(addr);  l2 = ATOMIC_LOAD_ACQ(lock);  if (l != l2) {    l = l2;    goto restart_no_load;  }  if (timestamp != NULL)    *timestamp = LOCK_GET_TIMESTAMP(l);  return value;}

/*---------------------------------------------------------------------------*/intcc2520_rssi(void){  int rssi;  int radio_was_off = 0;  if(locked) {    return 0;  }  GET_LOCK();  if(!receive_on) {    radio_was_off = 1;    cc2520_on();  }  BUSYWAIT_UNTIL(status() & BV(CC2520_RSSI_VALID), RTIMER_SECOND / 100);  rssi = (int)((signed char)getreg(CC2520_RSSI));  if(radio_was_off) {    cc2520_off();  }  RELEASE_LOCK();  return rssi;}

/*---------------------------------------------------------------------------*/static intcc2420_prepare(const void *payload, unsigned short payload_len){  uint8_t total_len;#if CC2420_CONF_CHECKSUM  uint16_t checksum;#endif /* CC2420_CONF_CHECKSUM */  GET_LOCK();  PRINTF("cc2420: sending %d bytes/n", payload_len);  RIMESTATS_ADD(lltx);  /* Wait for any previous transmission to finish. */  /*  while(status() & BV(CC2420_TX_ACTIVE));*/  /* Write packet to TX FIFO. */  strobe(CC2420_SFLUSHTX);#if CC2420_CONF_CHECKSUM  checksum = crc16_data(payload, payload_len, 0);#endif /* CC2420_CONF_CHECKSUM */  total_len = payload_len + AUX_LEN;  CC2420_WRITE_FIFO_BUF(&total_len, 1);  CC2420_WRITE_FIFO_BUF(payload, payload_len);#if CC2420_CONF_CHECKSUM  CC2420_WRITE_FIFO_BUF(&checksum, CHECKSUM_LEN);#endif /* CC2420_CONF_CHECKSUM */  RELEASE_LOCK();  return 0;}

/*---------------------------------------------------------------------------*/intcc2420_set_channel(int c){  uint16_t f;  GET_LOCK();  /*   * Subtract the base channel (11), multiply by 5, which is the   * channel spacing. 357 is 2405-2048 and 0x4000 is LOCK_THR = 1.   */  channel = c;  f = 5 * (c - 11) + 357 + 0x4000;  /*   * Writing RAM requires crystal oscillator to be stable.   */  BUSYWAIT_UNTIL((status() & (BV(CC2420_XOSC16M_STABLE))), RTIMER_SECOND / 10);  /* Wait for any transmission to end. */  BUSYWAIT_UNTIL(!(status() & BV(CC2420_TX_ACTIVE)), RTIMER_SECOND / 10);  setreg(CC2420_FSCTRL, f);  /* If we are in receive mode, we issue an SRXON command to ensure     that the VCO is calibrated. */  if(receive_on) {    strobe(CC2420_SRXON);  }  RELEASE_LOCK();  return 1;}

/*---------------------------------------------------------------------------*/voidcc2420_set_cca_threshold(int value){  uint16_t shifted = value << 8;  GET_LOCK();  setreg(CC2420_RSSI, shifted);  RELEASE_LOCK();}

/*---------------------------------------------------------------------------*/voiduz2400_set_txpower(cyg_uint8 power){  GET_LOCK();/*     UzSetTxPower(power);*/ uz_set_tx_power(power);   RELEASE_LOCK();}

/*---------------------------------------------------------------------------*/intcc2420_get_txpower(void){  int power;  GET_LOCK();  power = (int)(getreg(CC2420_TXCTRL) & 0x001f);  RELEASE_LOCK();  return power;}

/*---------------------------------------------------------------------------*/intcc2520_get_txpower(void){  uint8_t power;  GET_LOCK();  power = getreg(CC2520_TXPOWER);  RELEASE_LOCK();  return power;}

/*---------------------------------------------------------------------------*/voiduz2400_set_cca_threshold(int value){  cyg_uint16 shifted = value << 8;  GET_LOCK();/*   setreg(UZ2400_RSSI, shifted);*/    RELEASE_LOCK();}

static intread(void *buf, unsigned short buf_len){	 int res = 0;	 PRINTF("READ/n");	 GET_LOCK();	 res =  cc2520ll_packetReceive(buf, buf_len) - 2;	 RELEASE_LOCK();	 return res;}

/*---------------------------------------------------------------------------*/voidcc2420_set_txpower(uint8_t power){  uint16_t reg;  GET_LOCK();  reg = getreg(CC2420_TXCTRL);  reg = (reg & 0xffe0) | (power & 0x1f);  setreg(CC2420_TXCTRL, reg);  RELEASE_LOCK();}

/*---------------------------------------------------------------------------*/static intuz2400_prepare(const void *payload, unsigned short payload_len){  GET_LOCK();  PRINTF("uz2400: sending %d bytes/n", payload_len);  UzPrepare(payload, payload_len);  RELEASE_LOCK();  return 0;}

/*---------------------------------------------------------------------------*/intcc2520_cca_valid(void){  int valid;  if(locked) {    return 1;  }  GET_LOCK();  valid = !!(status() & BV(CC2520_RSSI_VALID));  RELEASE_LOCK();  return valid;}

/* * Store a word-sized value in a unit transaction. */static INLINE intstm_unit_write(volatile stm_word_t *addr, stm_word_t value, stm_word_t mask, stm_word_t *timestamp){#ifdef UNIT_TX    volatile stm_word_t *lock;    stm_word_t l;    PRINT_DEBUG2("==> stm_unit_write(a=%p,d=%p-%lu,m=0x%lx)/n",                 addr, (void *)value, (unsigned long)value, (unsigned long)mask);    /* Get reference to lock */    lock = GET_LOCK(addr);    /* Try to acquire lock */restart:    l = ATOMIC_LOAD_ACQ(lock);    if (LOCK_GET_OWNED(l)) {        /* Locked: wait until lock is free */#ifdef WAIT_YIELD        sched_yield();#endif /* WAIT_YIELD */        goto restart;    }    /* Not locked */    if (timestamp != NULL && LOCK_GET_TIMESTAMP(l) > *timestamp) {        /* Return current timestamp */        *timestamp = LOCK_GET_TIMESTAMP(l);        return 0;    }    /* TODO: would need to store thread ID to be able to kill it (for wait freedom) */    if (ATOMIC_CAS_FULL(lock, l, LOCK_UNIT) == 0)        goto restart;    ATOMIC_STORE(addr, value);    /* Update timestamp with newer value (may exceed VERSION_MAX by up to MAX_THREADS) */    l = FETCH_INC_CLOCK + 1;    if (timestamp != NULL)        *timestamp = l;    /* Make sure that lock release becomes visible */    ATOMIC_STORE_REL(lock, LOCK_SET_TIMESTAMP(l));    if (unlikely(l >= VERSION_MAX)) {        /* Block all transactions and reset clock (current thread is not in active transaction) */        stm_quiesce_barrier(NULL, rollover_clock, NULL);    }    return 1;#else /* ! UNIT_TX */    fprintf(stderr, "Unit transaction is not enabled/n");    exit(-1);    return 1;#endif /* ! UNIT_TX */}

/*---------------------------------------------------------------------------*/intuz2400_cca_valid(void){  int valid;  if(locked) {    return 1;  }  GET_LOCK();/*    valid = !!(status() & BV(UZ2400_RSSI_VALID));*/    RELEASE_LOCK();  return valid;}

/*---------------------------------------------------------------------------*/static intuz2400_transmit(unsigned short payload_len){   GET_LOCK();//  printf("Before uz2400_transmit    !/n");   int ret = UzTransmit(payload_len);////////modified for contiki mac layer // printf("After uz2400_transmit    !/n");  PRINTF("uz2400_transmit    !/n");   RELEASE_LOCK();   return ret;}

inttransmit(unsigned short transmit_len){	cc2520_on();	PRINTF(" transmit: /n");	u16_t res = 0;	GET_LOCK();	//PRINTF("Lock acquired/n");	//PRINTF("start transmit2: %u /n", RTIMER_NOW());	res = cc2520ll_transmit();	//PRINTF("end transmit2: %u /n", RTIMER_NOW());	RELEASE_LOCK();	//cc2520_off();	return res;}

/*---------------------------------------------------------------------------*/intcc2520_on(void){  if(receive_on) {    return 1;  }  if(locked) {    lock_on = 1;    return 1;  }  GET_LOCK();  on();  RELEASE_LOCK();  return 1;}

/*---------------------------------------------------------------------------*/intcc2420_on(void){  if(receive_on) {    return 1;  }  if(locked) {    LEDS_ON(LEDS_GREEN + LEDS_RED);    lock_on = 1;    return 1;  }  GET_LOCK();  on();  RELEASE_LOCK();  return 1;}

stm_word_thytm_load(TXPARAMS volatile stm_word_t *addr){    volatile stm_word_t *lock;    stm_word_t l;    lock = GET_LOCK(addr);    /* Load descriptor using ASF */    l = asf_lock_load64((long unsigned int *)lock);    if (unlikely(LOCK_GET_WRITE(l))) {        /* a software transaction is currently using this descriptor */        asf_abort(ASF_RETRY);        /* unreachable */        return 0;    }    /* addr can return inconsistent value but will be abort after few cycles */    return *addr;}