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

/********************************************************************* * @fn      osal_start_system * * @brief * *   This function is the main loop function of the task system.  It *   will look through all task events and call the task_event_processor() *   function for the task with the event.  If there are no events (for *   all tasks), this function puts the processor into Sleep. *   This Function doesn't return. * * @param   void * * @return  none */void osal_start_system( void ){  uint16 events;  uint16 retEvents;  while(1)  {    TaskActive = osalNextActiveTask();    if ( TaskActive )    {      HAL_ENTER_CRITICAL_SECTION();      events = TaskActive->events;      // Clear the Events for this task      TaskActive->events = 0;      HAL_EXIT_CRITICAL_SECTION();      if ( events != 0 )      {        // Call the task to process the event(s)        if ( TaskActive->pfnEventProcessor )        {          retEvents = (TaskActive->pfnEventProcessor)( TaskActive->taskID, events );          // Add back unprocessed events to the current task          HAL_ENTER_CRITICAL_SECTION();          TaskActive->events |= retEvents;          HAL_EXIT_CRITICAL_SECTION();        }      }    }  }}

/************************************************************************************************** * @fn          macBackoffTimerCount * * @brief       Returns the current backoff count. * * @param       none * * @return      current backoff count ************************************************************************************************** */uint32 macBackoffTimerCount(void){  halIntState_t  s;  uint32 backoffCount;  HAL_ENTER_CRITICAL_SECTION(s);  backoffCount = MAC_RADIO_BACKOFF_COUNT();  HAL_EXIT_CRITICAL_SECTION(s);  #ifdef MAC_RADIO_FEATURE_HARDWARE_OVERFLOW_NO_ROLLOVER  /*   *  Extra processing is required if the radio has a special hardware overflow   *  count feature.  Unfortunately this feature does not provide for setting a   *  rollover value.  This must be done manually.   *   *  This means there is a small window in time when reading the hardware count   *  will be inaccurate.  It's possible it could be one more than the allowable   *  count.  This happens if the count has just incremented beyond the maximum   *  and is queried before the ISR has a chance to run and reset the backoff   *  count back to zero.  (Pure software implementation of backoff count does   *  not have this problem.)   *   *  To solve this, before returning a value for the backoff count, the value   *  must be tested to see if it is beyond the maximum value.  If so, a rollover   *  interrupt that will set backoff count to zero is imminent.  In that case,   *  the correct backoff count of zero is returned.   */  if (backoffCount >= backoffTimerRollover)  {    return(0);  }#endif    return(backoffCount);}

/************************************************************************************************** * @fn          macBackoffTimerCancelTrigger * * @brief       Cancels the trigger for the backoff counter - obselete for CC253x and CC26xx. *              For CC253x and CC26xx, the timer trigger should never be late, therefore, no *              need to cancel. * * @param       none * * @return      none ************************************************************************************************** */MAC_INTERNAL_API void macBackoffTimerCancelTrigger(void){  MAC_RADIO_BACKOFF_COMPARE_CLEAR_INTERRUPT();#if defined USE_ICALL || defined OSAL_PORT2TIRTOS  /* backoffTimerTrigger must be set to a value   * to properly use rollover value for the next wakeup time.   */  {    halIntState_t intState;    HAL_ENTER_CRITICAL_SECTION(intState);    /* This code assumes that backoff timer callback does not cause     * a problem when the callback is made at the rollover even if     * no timer is associated with it. At the time the following     * code is written, mac_timer.c can live with such a callback.     * Setting backoff comparator value one greater than rollver value     * might be conceived here to lift the above constraint,     * but it would have to ensure that rollover value is never     * the highest counter value, which is a more dangerous assumption.     */    backoffTimerTrigger = macBackoffTimerRollover;    /* Note that MAC_RADIO_BACKOFF_COMPARE_CLEAR_INTERRUPT() is not implemented     * correctly and hence backoff timer trigger interrupt can still occur.     * Instead of fixing MAC_RADIO_BACKOFF_COMPARE_CLEAR_INTERRUPT() macro,     * comparator is set again, to simplify interrupt handling.     */    MAC_RADIO_BACKOFF_SET_COMPARE(backoffTimerTrigger);    MAC_BACKOFF_TIMER_UPDATE_WAKEUP();    HAL_EXIT_CRITICAL_SECTION(intState);  }#endif /* defined USE_ICALL || defined OSAL_PORT2TIRTOS */}

/************************************************************************************************** * @fn          macBackoffTimerPeriodIsr * * @brief       Interrupt service routine that fires when the backoff count rolls over on *              overflow period. * * @param       none * * @return      none ************************************************************************************************** */MAC_INTERNAL_API void macBackoffTimerPeriodIsr(void){  halIntState_t s;  uint32 macRatCount           =  MAC_RAT_COUNT;  uint32 backoffRolloverRat    =  macBackoffTimerRollover * MAC_BACKOFF_TO_RAT_RATIO;  uint32 ratCompensation       = (macRatCount - macPrevPeriodRatCount) % MAC_BACKOFF_TO_RAT_RATIO;        MAC_ASSERT( macBackoffTimerRollover <= MAC_BACKOFF_MAXIMUM_ROLLOVER );  if (macRatCount < backoffRolloverRat)  {    /* RAT wraparound has occurred. This would occur once in a blue moon (1073.74 seconds).     */    DBG_PRINTL1(DBGSYS, "!!! RAT wraparound !!! RAT = %u", macRatCount);  }  DBG_PRINTL2(DBGSYS, "macRatChanA Period ISR, Rollover Period = %u, RAT Compensation = %u", macBackoffTimerRollover, ratCompensation);    /* Convert count to RAT count and set MAC Channel A Compare. The modulus calculation will    * compensate the math or interrupt latency error and prevent it from being accumulated.   * Note that MAC_BACKOFF_TO_RAT_RATIO is used as part of compensation. This means the    * maximum error that can be compensated is 320us. If the interrupt latency is greater    * than 320us, more elaborated compensation scheme must be used for Beacon mode.    * Non-beacon mode does not require absolute timing. Longer interrupt latency can be    * tolerated.   */  macPrevPeriodRatCount = macRatCount - ratCompensation;  macSetupRATChanCompare( macRatChanA, backoffRolloverRat + macPrevPeriodRatCount );  macBackoffTimerRolloverCallback();  HAL_ENTER_CRITICAL_SECTION(s);  MAC_BACKOFF_TIMER_UPDATE_WAKEUP();  HAL_EXIT_CRITICAL_SECTION(s);}

/************************************************************************************ @fn           halUartPollRx** @brief        Poll for data from USB.** @param        none** @return       none*/void halUartPollRx(void){  uint8 cnt;  uint8 ep = USBFW_GET_SELECTED_ENDPOINT();  USBFW_SELECT_ENDPOINT(4);  /* If the OUT endpoint has received a complete packet. */  if (USBFW_OUT_ENDPOINT_DISARMED())  {    halIntState_t intState;    HAL_ENTER_CRITICAL_SECTION(intState);    /* Get length of USB packet, this operation must not be interrupted. */    cnt = USBFW_GET_OUT_ENDPOINT_COUNT_LOW();    cnt += USBFW_GET_OUT_ENDPOINT_COUNT_HIGH() >> 8;    HAL_EXIT_CRITICAL_SECTION(intState);    while (cnt--)    {      halUartRxQ[halUartRxT++] = HWREG(USB_F4);    }    USBFW_ARM_OUT_ENDPOINT();    /* If the USB has transferred in more Rx bytes, reset the Rx idle timer. */    /* Re-sync the shadow on any 1st byte(s) received. */    if (rxTick == 0)    {      rxShdw = ST0;    }    rxTick = HAL_UART_USB_IDLE;  }  else if (rxTick)

/********************************************************************* * @fn      osal_run_task * * @brief * *   This function is the main loop function of the task system.  It *   will look through all task events and call the task_event_processor() *   function for the task with the event.  If there are no events (for *   all tasks), this function puts the processor into Sleep. *   This Function doesn't return. * * @param   void * * @return  none */static void osal_run_task(uint8 idx){    uint16 events;    halIntState_t intState;    HAL_ENTER_CRITICAL_SECTION(intState);    events = tasksEvents[idx];    tasksEvents[idx] = 0;  // Clear the Events for this task.    HAL_EXIT_CRITICAL_SECTION(intState);    events = (tasksArr[idx])( idx, events );    HAL_ENTER_CRITICAL_SECTION(intState);    tasksEvents[idx] |= events;  // Add back unprocessed events to the current task.    HAL_EXIT_CRITICAL_SECTION(intState);}

/************************************************************************************************** * @fn          HalFlashRead * * @brief       This function reads 'cnt' bytes from the internal flash. * * input parameters * * @param       pg - A valid flash page number. * @param       offset - A valid offset into the page. * @param       buf - A valid buffer space at least as big as the 'cnt' parameter. * @param       cnt - A valid number of bytes to read. * * output parameters * * None. * * @return      None. ************************************************************************************************** */void HalFlashRead(uint8 pg, uint16 offset, uint8 *buf, uint16 cnt){  // Calculate the offset into the containing flash bank as it gets mapped into XDATA.  uint8 *pData = (uint8 *)(offset + HAL_FLASH_PAGE_MAP) +                 ((pg % HAL_FLASH_PAGE_PER_BANK) * HAL_FLASH_PAGE_SIZE);  uint8 memctr = MEMCTR;  // Save to restore.#if (!defined HAL_OAD_BOOT_CODE) && (!defined HAL_OTA_BOOT_CODE)  halIntState_t is;#endif  pg /= HAL_FLASH_PAGE_PER_BANK;  // Calculate the flash bank from the flash page.#if (!defined HAL_OAD_BOOT_CODE) && (!defined HAL_OTA_BOOT_CODE)  HAL_ENTER_CRITICAL_SECTION(is);#endif  // Calculate and map the containing flash bank into XDATA.  MEMCTR = (MEMCTR & 0xF8) | pg;  while (cnt--)  {    *buf++ = *pData++;  }  MEMCTR = memctr;#if (!defined HAL_OAD_BOOT_CODE) && (!defined HAL_OTA_BOOT_CODE)  HAL_EXIT_CRITICAL_SECTION(is);#endif}

/************************************************************************************************** * @fn          macBackoffTimerCompareIsr * * @brief       Interrupt service routine that fires when the backoff count is equal *              to the trigger count. * * @param       none * * @return      none ************************************************************************************************** */void macBackoffTimerCompareIsr(void){  uint8 oldState;  halIntState_t  s;  HAL_ENTER_CRITICAL_SECTION(s);  oldState = compareState;  /* if compare is a rollover, set count to zero */  if (oldState & COMPARE_STATE_ROLLOVER_BV)  {    MAC_RADIO_BACKOFF_SET_COUNT(0);    macBackoffTimerRolloverCallback();  }  /* if compare is a trigger, reset for rollover and run the trigger callback */  if (oldState & COMPARE_STATE_TRIGGER_BV)  {    compareState = COMPARE_STATE_ROLLOVER;    MAC_RADIO_BACKOFF_SET_COMPARE(backoffTimerRollover);    HAL_EXIT_CRITICAL_SECTION(s);    macBackoffTimerTriggerCallback();  }  else if (oldState == COMPARE_STATE_ROLLOVER_AND_ARM_TRIGGER)  {    compareState = COMPARE_STATE_TRIGGER;    MAC_RADIO_BACKOFF_SET_COMPARE(backoffTimerTrigger);    HAL_EXIT_CRITICAL_SECTION(s);  }  else  {    HAL_EXIT_CRITICAL_SECTION(s);  }}

/********************************************************************* * @fn      HalSPIRead * * @brief   Read from the external NV storage via SPI. * * @param   addr - Offset into the external NV. * @param   pBuf - Pointer to the buffer in which to copy the bytes read from external NV. * @param   len - Number of bytes to read from external NV. * * @return  None. *********************************************************************/static void HalSPIRead(uint32 addr, uint8 *pBuf, uint16 len){#if !HAL_OAD_BOOT_CODE  uint8 shdw = P1DIR;  halIntState_t his;  HAL_ENTER_CRITICAL_SECTION(his);  P1DIR |= BV(3);#endif  XNV_SPI_BEGIN();  do {    xnvSPIWrite(XNV_STAT_CMD);  } while (XNV_SPI_RX() & XNV_STAT_WIP);  XNV_SPI_END();  asm("NOP"); asm("NOP");  XNV_SPI_BEGIN();  xnvSPIWrite(XNV_READ_CMD);  xnvSPIWrite(addr >> 16);  xnvSPIWrite(addr >> 8);  xnvSPIWrite(addr);  xnvSPIWrite(0);  while (len--)  {    xnvSPIWrite(0);    *pBuf++ = XNV_SPI_RX();  }  XNV_SPI_END();#if !HAL_OAD_BOOT_CODE  P1DIR = shdw;  HAL_EXIT_CRITICAL_SECTION(his);#endif}

/************************************************************************************************** * @fn          macRxOff * * @brief       Turn off the receiver if it's not already off. * * @param       none * * @return      none ************************************************************************************************** */MAC_INTERNAL_API void macRxOff(void){  halIntState_t  s;  DBG_PRINT1(DBGSYS, "macRxOff(): macRxOnFlag = 0x%X", macRxOnFlag);  HAL_ENTER_CRITICAL_SECTION(s);  if (macRxOnFlag)  {    macRxOnFlag = 0;    DBG_PRINT0(DBGSYS, "MAC_RADIO_RXTX_OFF()");    MAC_RADIO_RXTX_OFF();    /* Wait till RX is completely off before issuing another RX related     * command which may fail if issued beforehand. */    macCheckCommnadDone(&macRxEdScan.rxCmd.rfOpCmd);        /* Wait till all FG commands are done */    macCheckCommnadDone(&macCsmaCaCmd.rfOpCmd);    macCheckCommnadDone(&macTxCmd.rfOpCmd);     macCheckCommnadDone(&macRxAckCmd.rfOpCmd);           MAC_DEBUG_TURN_OFF_RX_LED();        /* just in case a receive was about to start, flush the receive FIFO */    MAC_RADIO_FLUSH_RX_FIFO();    /* clear any receive interrupt that happened to squeak through */    MAC_RADIO_CLEAR_RX_THRESHOLD_INTERRUPT_FLAG();  }  HAL_EXIT_CRITICAL_SECTION(s);}

/************************************************************************************************** * @fn          macRadioUpdateTxPower * * @brief       Update the radio's transmit power if a new power level has been requested * * @param       reqTxPower - file scope variable that holds the last request power level *              macPhyTxPower - global variable that holds radio's set power level * * @return      none ************************************************************************************************** */MAC_INTERNAL_API void macRadioUpdateTxPower(void){  halIntState_t  s;  /*   *  If the requested power setting is different from the actual radio setting,   *  attempt to udpate to the new power setting.   */  HAL_ENTER_CRITICAL_SECTION(s);  if (reqTxPower != macPhyTxPower)  {    /*     *  Radio power cannot be updated when the radio is physically transmitting.     *  If there is a possibility radio is transmitting, do not change the power     *  setting.  This function will be called again after the current transmit     *  completes.     */    if (!macRxOutgoingAckFlag && !MAC_TX_IS_PHYSICALLY_ACTIVE())    {      /*       *  Set new power level;  update the shadow value and write       *  the new value to the radio hardware.       */      macPhyTxPower = reqTxPower;      MAC_RADIO_SET_TX_POWER(macPhyTxPower);    }  }  HAL_EXIT_CRITICAL_SECTION(s);}

/************************************************************************************************** * @fn          macRadioUpdateChannel * * @brief       Update the radio channel if a new channel has been requested. * * @param       none * * @return      none ************************************************************************************************** */MAC_INTERNAL_API void macRadioUpdateChannel(void){  halIntState_t  s;  MAC_ASSERT(!macTxActive); /* cannot change channel during a transmit */  /* if the channel has changed, set the radio to the new channel */  HAL_ENTER_CRITICAL_SECTION(s);  if (reqChannel != macPhyChannel)  {    macPhyChannel = reqChannel;    HAL_EXIT_CRITICAL_SECTION(s);    /* changing the channel stops any receive in progress */    macRxOff();    MAC_RADIO_SET_CHANNEL(macPhyChannel);    /* If the channel is updated in the middle of receiving a frame, we must     * clean up the Rx logic.     */    macRxHaltCleanup();    macRxOnRequest();  }  else  {    HAL_EXIT_CRITICAL_SECTION(s);  }}

/************************************************************************************************** * @fn          MAC_MlmeSetActivePib * * @brief       This function initializes the PIB. * * input parameters * * @param       None. * * output parameters * * None. * * @return      None. ************************************************************************************************** */void MAC_MlmeSetActivePib( void* pPib ){    halIntState_t intState;    HAL_ENTER_CRITICAL_SECTION(intState);    pMacPib = (macPib_t *)pPib;    HAL_EXIT_CRITICAL_SECTION(intState);}

/************************************************************************************************** * @fn          macMcuPrecisionCount * * @brief       This function is used by higher layer to read a free running counter driven by *              MAC timer. * * @param       none * * @return      overflowCount ************************************************************************************************** */uint32 macMcuPrecisionCount(void){  uint32         overflowCount = 0;  halIntState_t  s;  HAL_ENTER_CRITICAL_SECTION(s);  /* This T2 access macro allows accessing both T2MOVFx and T2Mx */  MAC_MCU_T2_ACCESS_OVF_COUNT_VALUE();  /* Latch the entire T2MOVFx first by reading T2M0.   * T2M0 is discarded.   */  T2M0;  ((uint8 *)&overflowCount)[UINT32_NDX0] = T2MOVF0;  ((uint8 *)&overflowCount)[UINT32_NDX1] = T2MOVF1;  ((uint8 *)&overflowCount)[UINT32_NDX2] = T2MOVF2;  /* the overflowCount needs to account for the accumulated overflow count in Beacon mode.   */  overflowCount += accumulatedOverflowCount;  HAL_EXIT_CRITICAL_SECTION(s);  return(overflowCount);}

/********************************************************************* * @fn      osal_pwrmgr_powerconserve * * @brief   This function is called from the main OSAL loop when there are *          no events scheduled and shouldn't be called from anywhere else. * * @param   none. * * @return  none. */void osal_pwrmgr_powerconserve( void ){  uint32        next;  halIntState_t intState;  // Should we even look into power conservation#ifdef USER_DEFINED    if ( pwrmgr_attribute.pwrmgr_device != PWRMGR_ALWAYS_ON && !E009_upoff && isPair )#else  if ( pwrmgr_attribute.pwrmgr_device != PWRMGR_ALWAYS_ON )#endif  {    // Are all tasks in agreement to conserve    if ( pwrmgr_attribute.pwrmgr_task_state == 0 )    {      // Hold off interrupts.      HAL_ENTER_CRITICAL_SECTION( intState );      // Get next time-out      next = osal_next_timeout();      // Re-enable interrupts.      HAL_EXIT_CRITICAL_SECTION( intState );      // Put the processor into sleep mode      OSAL_SET_CPU_INTO_SLEEP( next );    }  }}

/************************************************************************************************** * @fn          macBackoffTimerPwrNotify * * @brief       power state transition notify callback function * * @param       eventType transition event type * @param       data      not used * * @return      Power_NOTIFYDONE ************************************************************************************************** */static Power_NotifyResponse macBackoffTimerPwrNotify(Power_Event eventType,                                                     UArg data){  if (eventType == Power_AWAKE_STANDBY)  {    /* Wakeup must be handled from the thread context.     * Signal the event to the OSAL thread. */    halIntState_t is;    HAL_ENTER_CRITICAL_SECTION(is);    macBackoffTimerEvents |= MAC_BACKOFF_TIMER_EVENT_POWER_WAKEUP;    HAL_EXIT_CRITICAL_SECTION(is);    osal_set_event(macTaskId, 0);  }  else if (eventType == Power_ENTERING_STANDBY)  {    /* Stop RAT timer */    macRATValue = macStopRAT();    /* Park CM0 */    MAC_RADIO_POWER_DOWN();    Hwi_disableInterrupt( INT_RF_CPE0 );    Hwi_disableInterrupt( INT_RF_CPE1 );    Hwi_disableInterrupt( INT_RF_HW );    Hwi_disableInterrupt( INT_RF_CMD_ACK );  }  else if (eventType == Power_ENTERING_SHUTDOWN)  {    /* Park CM0 */    MAC_RADIO_POWER_DOWN();  }  return Power_NOTIFYDONE;}

/************************************************************************************************** * @fn          macBackoffTimerSetTrigger * * @brief       Sets the trigger count for the backoff counter.  A callback is exectuted when *              the backoff count reaches the trigger * * @param       triggerBackoff - backoff count for new trigger * * @return      none ************************************************************************************************** */void macBackoffTimerSetTrigger(uint32 triggerBackoff){  halIntState_t  s;  MAC_ASSERT(triggerBackoff < backoffTimerRollover); /* trigger backoff must be less than rollover backoff */  HAL_ENTER_CRITICAL_SECTION(s);  backoffTimerTrigger = triggerBackoff;  if (triggerBackoff > MAC_RADIO_BACKOFF_COUNT())  {    compareState = COMPARE_STATE_TRIGGER;    MAC_RADIO_BACKOFF_SET_COMPARE(triggerBackoff);  }  else  {    if (triggerBackoff == 0)    {      compareState = COMPARE_STATE_ROLLOVER_AND_TRIGGER;    }    else    {      compareState = COMPARE_STATE_ROLLOVER_AND_ARM_TRIGGER;    }    MAC_RADIO_BACKOFF_SET_COMPARE(backoffTimerRollover);  }  HAL_EXIT_CRITICAL_SECTION(s);}

/****************************************************************************** * @fn      HalUARTWriteDMA * * @brief   Write a buffer to the UART. * * @param   buf - pointer to the buffer that will be written, not freed *          len - length of * * @return  length of the buffer that was sent *****************************************************************************/static uint16 HalUARTWriteDMA(uint8 *buf, uint16 len){  uint16 cnt;  halIntState_t his;  uint8 txSel;  txIdx_t txIdx;  // Enforce all or none.  if ((len + dmaCfg.txIdx[dmaCfg.txSel]) > HAL_UART_DMA_TX_MAX)  {    return 0;  }  HAL_ENTER_CRITICAL_SECTION(his);  txSel = dmaCfg.txSel;  txIdx = dmaCfg.txIdx[txSel];  HAL_EXIT_CRITICAL_SECTION(his);  for (cnt = 0; cnt < len; cnt++)  {    dmaCfg.txBuf[txSel][txIdx++] = buf[cnt];  }  HAL_ENTER_CRITICAL_SECTION(his);  if (txSel != dmaCfg.txSel)  {    HAL_EXIT_CRITICAL_SECTION(his);    txSel = dmaCfg.txSel;    txIdx = dmaCfg.txIdx[txSel];    for (cnt = 0; cnt < len; cnt++)    {      dmaCfg.txBuf[txSel][txIdx++] = buf[cnt];    }    HAL_ENTER_CRITICAL_SECTION(his);  }  dmaCfg.txIdx[txSel] = txIdx;  if (dmaCfg.txIdx[(txSel ^ 1)] == 0)  {    // TX DMA is expected to be fired    dmaCfg.txDMAPending = TRUE;  }  HAL_EXIT_CRITICAL_SECTION(his);  return cnt;}

/************************************************************************************************* * @brief   Write a buffer to the UART * @param   port    - UART port (not used.) *          pBuffer - pointer to the buffer that will be written *          length  - length of * @return  length of the buffer that was sent *************************************************************************************************/uint16 HalUARTOutBuf (uint8 port, uint8 *pBuffer, uint16 length){  uint16 cnt, idx;  halIntState_t intState;  if (!uartRecord.configured)  {    return 0;  }  // Capture the value of the volatile variables.  idx = uartRecord.tx.bufferHead;  cnt = uartRecord.tx.bufferTail;  if (cnt == idx)  {    cnt = uartRecord.tx.maxBufSize;  }  else if (cnt > idx)  {    cnt = uartRecord.tx.maxBufSize - cnt + idx;  }  else // (cnt < idx)  {    cnt = idx - cnt;  }  // Accept "all-or-none" on write request.  if (cnt < length)  {    return 0;  }  idx = uartRecord.tx.bufferTail;  for (cnt = 0; cnt < length; cnt++)  {    uartRecord.tx.pBuffer[idx++] = pBuffer[cnt];    if (idx >= uartRecord.tx.maxBufSize)    {      idx = 0;    }  }  HAL_ENTER_CRITICAL_SECTION(intState);  // Hold off interrupts.  cnt = uartRecord.tx.bufferTail;  if (cnt == uartRecord.tx.bufferHead)  {    if (uartRecord.intEnable)    {      HAL_UART_TX_INT_ENABLE();    }    HAL_UART_PUTBYTE(uartRecord.tx.pBuffer[uartRecord.tx.bufferHead]);  // Send a char to UART.  }  uartRecord.tx.bufferTail = idx;  HAL_EXIT_CRITICAL_SECTION(intState);  // Restore interrupt enable.  return length;  // Return the number of bytes actually put into the buffer.}

/********************************************************************* * @fn      osal_mem_free * * @brief   Implementation of the de-allocator functionality. * * @param   ptr - pointer to the memory to free. * * @return  void */void osal_mem_free( void *ptr ){  osalMemHdr_t *currHdr;  halIntState_t intState;#if ( OSALMEM_GUARD )  // Try to protect against premature use by HAL / OSAL.  if ( ready != OSALMEM_READY )  {    osal_mem_init();  }#endif  HAL_ENTER_CRITICAL_SECTION( intState );  // Hold off interrupts.  OSALMEM_ASSERT( ptr );  currHdr = (osalMemHdr_t *)ptr - 1;  // Has this block already been freed?  OSALMEM_ASSERT( *currHdr & OSALMEM_IN_USE );  *currHdr &= ~OSALMEM_IN_USE;#if ( OSALMEM_PROFILER )  {    uint16 size = *currHdr;    byte idx;    for ( idx = 0; idx < OSALMEM_PROMAX; idx++ )    {      if ( size <= proCnt[idx] )      {        break;      }    }    proCur[idx]--;  }#endif#if ( OSALMEM_METRICS )  memAlo -= *currHdr;  blkFree++;#endif  if ( ff1 > currHdr )  {    ff1 = currHdr;  }#if ( OSALMEM_PROFILER )  osal_memset( (byte *)currHdr+HDRSZ, OSALMEM_REIN, (*currHdr - HDRSZ) );#endif  HAL_EXIT_CRITICAL_SECTION( intState );  // Re-enable interrupts.}

/************************************************************************************************** * @fn          macBackoffTimerCancelTrigger * * @brief       Cancels the trigger for the backoff counter. * * @param       none * * @return      none ************************************************************************************************** */void macBackoffTimerCancelTrigger(void){  halIntState_t  s;  HAL_ENTER_CRITICAL_SECTION(s);  compareState = COMPARE_STATE_ROLLOVER;  MAC_RADIO_BACKOFF_SET_COMPARE(backoffTimerRollover);  HAL_EXIT_CRITICAL_SECTION(s);}

/****************************************************************************** * @fn      HalSPIWrite * * @brief   Write to the external NV storage via SPI. * * @param   addr - Offset into the external NV. * @param   pBuf - Pointer to the buffer in from which to write bytes to external NV. * @param   len - Number of bytes to write to external NV. * * @return  None. *****************************************************************************/static void HalSPIWrite(uint32 addr, uint8 *pBuf, uint16 len){  uint8 cnt;#if !HAL_OTA_BOOT_CODE  uint8 shdw = P1DIR;  halIntState_t his;  HAL_ENTER_CRITICAL_SECTION(his);  P1DIR |= BV(3);#endif  while (len)  {    XNV_SPI_BEGIN();    do    {      xnvSPIWrite(XNV_STAT_CMD);    } while (XNV_SPI_RX() & XNV_STAT_WIP);    XNV_SPI_END();    asm("NOP"); asm("NOP");    XNV_SPI_BEGIN();    xnvSPIWrite(XNV_WREN_CMD);    XNV_SPI_END();    asm("NOP"); asm("NOP");    XNV_SPI_BEGIN();    xnvSPIWrite(XNV_WRPG_CMD);    xnvSPIWrite(addr >> 16);    xnvSPIWrite(addr >> 8);    xnvSPIWrite(addr);    // Can only write within any one page boundary, so prepare for next page write if bytes remain.    cnt = 0 - (uint8)addr;    if (cnt)    {      addr += cnt;    }    else    {      addr += 256;    }    do    {      xnvSPIWrite(*pBuf++);      cnt--;      len--;    } while (len && cnt);    XNV_SPI_END();  }#if !HAL_OTA_BOOT_CODE  P1DIR = shdw;  HAL_EXIT_CRITICAL_SECTION(his);#endif}

/************************************************************************************************** * @fn          macMcuTimerForceDelay * * @brief       Delay the timer by the requested number of ticks. * * @param       none * * @return      none ************************************************************************************************** */MAC_INTERNAL_API void macMcuTimerForceDelay(uint16 x){  halIntState_t  s;  HAL_ENTER_CRITICAL_SECTION(s);  MAC_MCU_T2_ACCESS_COUNT_VALUE();  T2M0 = (x) & 0xFF;  T2M1 = (x) >> 8;  HAL_EXIT_CRITICAL_SECTION(s);}

/************************************************************************************************** * @fn          macBackoffTimerSetCount * * @brief       Sets the count of the backoff timer. * * @param       backoff - new count * * @return      none ************************************************************************************************** */MAC_INTERNAL_API void macBackoffTimerSetCount(uint32 backoff){  halIntState_t  s;  MAC_ASSERT(backoff < backoffTimerRollover);  /* count must be less than rollover value */  MAC_ASSERT(!(backoff & 0x80000000));  /* count must not represent negative value for int32 */  HAL_ENTER_CRITICAL_SECTION(s);  MAC_RADIO_BACKOFF_SET_COUNT(backoff);  HAL_EXIT_CRITICAL_SECTION(s);}

/************************************************************************************************** * @fn          macRxSoftEnable * * @brief       Set enable flags but don't turn on the receiver.  Useful to leave the receiver *              on after a transmit, but without turning it on immediately. * * @param       flags - byte containing rx enable flags to set * * @return      none ************************************************************************************************** */void macRxSoftEnable(uint8 flags){  halIntState_t  s;  MAC_ASSERT(flags != 0); /* rx flags not affected */  /* set the enable flags but do not turn on the receiver */  HAL_ENTER_CRITICAL_SECTION(s);  macRxEnableFlags |= flags;  HAL_EXIT_CRITICAL_SECTION(s);}

/************************************************************************************************** * @fn          macRxOnRequest * * @brief       Turn on the receiver if any rx enable flag is set. * * @param       none * * @return      none ************************************************************************************************** */void macRxOnRequest(void){  halIntState_t  s;  HAL_ENTER_CRITICAL_SECTION(s);  if (macRxEnableFlags)  {    macRxOn();  }  HAL_EXIT_CRITICAL_SECTION(s);}

/************************************************************************************************** * @fn          macBackoffTimerSetRollover * * @brief       Set rollover count of backoff timer. * * @param       rolloverBackoff - backoff count where count is reset to zero * * @return      none ************************************************************************************************** */void macBackoffTimerSetRollover(uint32 rolloverBackoff){  halIntState_t  s;  MAC_ASSERT(rolloverBackoff > MAC_RADIO_BACKOFF_COUNT());  /* rollover value must be greater than count */  HAL_ENTER_CRITICAL_SECTION(s);  backoffTimerRollover = rolloverBackoff;  MAC_RADIO_BACKOFF_SET_COMPARE(rolloverBackoff);  HAL_EXIT_CRITICAL_SECTION(s);}

/************************************************************************************************** * @fn          macBackoffTimerCount * * @brief       Returns the current backoff count. * * @param       none * * @return      current backoff count ************************************************************************************************** */MAC_INTERNAL_API uint32 macBackoffTimerCount(void){  halIntState_t  s;  uint32 backoffCount;    HAL_ENTER_CRITICAL_SECTION(s);  backoffCount = MAC_RADIO_BACKOFF_COUNT();  HAL_EXIT_CRITICAL_SECTION(s);    return(backoffCount);}

/************************************************************************************************** * @fn          halSleepSetTimer * * @brief       This function sets the MSP430 MAC timer compare value.  First it reads and *              stores the value of the sleep timer; this value is used later to update MAC *              timers.  Then the timeout value is converted from 320 usec units to system clock *              period units and the compare value is set to the timeout. * * input parameters * * @param       timeout - Pointer to the timeout value in 320 usec units.  The sleep timer compare *                        is set to this value. * * output parameters - none * * None. * * @return      None. ************************************************************************************************** */void halSleepSetTimer( uint32 timeout ){  halIntState_t  s;  uint32         ticks;  HAL_ENTER_CRITICAL_SECTION(s);#ifdef __msp430x54x  /* read the current MAC timer and store value for later */  ticks = halSleepTimerStart = HAL_MAC_SLEEP_TIMER_TAR();#endif  /* Switch MAC timer clock source and change prescaler   * halt the timer while updating   */  HAL_MAC_SLEEP_TIMER_SLOW_DOWN();  HAL_EXIT_CRITICAL_SECTION(s);#ifdef __msp430x54x  /* With MSP430F5438 RTM silicon, when the counter mode is moved from 'up'   * to 'stop' and the timer counter equals the capture/compare value in a   * TACCRx register the transition of modes will pull the TAR bits (15:4)   * to a '1' momentarily. Re-initialize TAR as a temporary workaround until   * the post-RTM revisions of silicon with this bug fixed.   */  HAL_MAC_SLEEP_TIMER_TAR() = halSleepTimerStart;#else  /* read the current MAC timer and store value for later */  ticks = halSleepTimerStart = HAL_MAC_SLEEP_TIMER_TAR();#endif  /* read the current MAC timer compare count and store value for later */  halSleepTimerCompareStart = HAL_MAC_SLEEP_TIMER_COMPARE();  /* The MAC tick is 32KHz/8 = 4096Hz. The ratio of 4096Hz ticks   * to 320 usec ticks is (320e-6)/(1/4096) = 1.31072 = 4096 / 3125.   */  ticks += (timeout * 4096 / 3125);  /* sleep away one chunk at a time */  if ( ticks > MAX_SLEEP_COUNT )  {    /* adjust timeout for the next sleep cycle */    ticks = MAX_SLEEP_COUNT;  }  /* set MAC timer compare */  HAL_MAC_SLEEP_TIMER_SET_COMPARE(((uint16)ticks));  /* restart the timer */  HAL_MAC_SLEEP_TIMER_RESTART();}

/************************************************************************************************** * @fn          macBackoffTimerCompareIsr * * @brief       Interrupt service routine that fires when the backoff count is equal *              to the trigger count. * * @param       none * * @return      none ************************************************************************************************** */MAC_INTERNAL_API void macBackoffTimerCompareIsr(void){  halIntState_t s;  DBG_PRINT1(DBGSYS, "macRatChanB Compare ISR, Backoff RAT count = %u", MAC_RADIO_BACKOFF_COUNT());  macBackoffTimerTriggerCallback();  HAL_ENTER_CRITICAL_SECTION(s);  MAC_BACKOFF_TIMER_UPDATE_WAKEUP();  HAL_EXIT_CRITICAL_SECTION(s);}