OSAL函数分析-osalTimerUpdate

        看这个函数之前，我们先来看两个重要的结构体(共用体)；

typedef union {
  uint32 time32;
  uint16 time16[2];
  uint8  time8[4];
} osalTime_t;

typedef struct
{
  void   *next;
  osalTime_t timeout;               /*  当前的时间          */
  uint16 event_flag;                /*  事件标志            */
  uint8  task_id;                   /*  任务ID              */
  uint32 reloadTimeout;             /*  任务重新装载时间    */
} osalTimerRec_t;                   

/*********************************************************************
 * @fn      osalTimerUpdate
 *
 * @brief   Update the timer structures for a timer tick.
 *          更新Timer时间链表，超时任务发送事件，
 * @param   none
 *
 * @return  none
 *********************************************************************/
void osalTimerUpdate( uint32 updateTime )
{
  halIntState_t intState;
  osalTimerRec_t *srchTimer;                                /*  指向当前的结构体元素        */           
  osalTimerRec_t *prevTimer;                                /*  指向上一个的结构体元素      */    

  osalTime_t timeUnion;                                     /*  存放函数形参的共用体        */    
  timeUnion.time32 = updateTime;                                

  HAL_ENTER_CRITICAL_SECTION( intState );                   /*  关闭中断                    */  
  // Update the system time
  osal_systemClock += updateTime;                           /*  更新系统时钟                */    
  HAL_EXIT_CRITICAL_SECTION( intState );                    /*  打开中断                    */  

  // Look for open timer slot
  if ( timerHead != NULL )                                  /*  假如Timer 时间链表不为空    */                             
  {
    // Add it to the end of the timer list
    srchTimer = timerHead;                                  /*  把表头给当前结构体指针      */   
    prevTimer = (void *)NULL;                               /*  结构体指针赋NULL            */ 

    // Look for open timer slot
    while ( srchTimer )                                     /*  不为空时                    */ 
    {
      osalTimerRec_t *freeTimer = NULL;                     /*  定义释放结构体指针并赋NULL  */ 

      HAL_ENTER_CRITICAL_SECTION( intState );               /*  关闭中断                    */  

      // To minimize time in this critical section, avoid 32-bit math
      /*    为了在关键部分节约时间，避免使用32位数字  */
      if ((timeUnion.time16[1] == 0) && (timeUnion.time8[1] == 0))
      {
        // If upper 24 bits are zero, check lower 8 bits for roll over
        /* 假如高24位为0，直接检测低8位 */
        if (srchTimer->timeout.time8[0] >= timeUnion.time8[0])
        {
          // 8-bit math
          /* 低8位直接相减 */
          srchTimer->timeout.time8[0] -= timeUnion.time8[0];
        }
        else
        {
          // 32-bit math
          if (srchTimer->timeout.time32 > timeUnion.time32)
          {
            /* 32位直接相减 */
            srchTimer->timeout.time32 -= timeUnion.time32;
          }
          else
          {
            srchTimer->timeout.time32 = 0;
          }
        }
      }
      else
      {
        // 32-bit math
        /* 32位直接相减 */
        if (srchTimer->timeout.time32 > timeUnion.time32)
        {
          srchTimer->timeout.time32 -= timeUnion.time32;
        }
        else
        {
          srchTimer->timeout.time32 = 0;
        }
      }

      // Check for reloading
      /*    检测改Timer 时间链表元素是否需要重新装载    */
      if ( (srchTimer->timeout.time16[0] == 0) && (srchTimer->timeout.time16[1] == 0) &&
           (srchTimer->reloadTimeout) && (srchTimer->event_flag) )
      {
        // Notify the task of a timeout
        /*    通知任务超时，发送事件    */
        osal_set_event( srchTimer->task_id, srchTimer->event_flag );

        // Reload the timer timeout value
        /*   重新装载32位数值  */
        srchTimer->timeout.time32 = srchTimer->reloadTimeout;
      }

      // When timeout or delete (event_flag == 0)
      /*    任务超时(单次执行事件)或者该事件需要删除    */
      if ( ((srchTimer->timeout.time16[0] == 0) && (srchTimer->timeout.time16[1] == 0)) ||
            (srchTimer->event_flag == 0) )
      {
        // Take out of list
        /*  删除该时间节点    */
        if ( prevTimer == NULL )
        {
          timerHead = srchTimer->next;
        }
        else
        {
          prevTimer->next = srchTimer->next;
        }

        // Setup to free memory
        /*  设置为空闲内存    */
        freeTimer = srchTimer;

        // Next
        /*  判断下一个时间节点    */
        srchTimer = srchTimer->next;
      }
      else
      {
        /*  判断下一个时间节点    */
        prevTimer = srchTimer;
        srchTimer = srchTimer->next;
      }

      HAL_EXIT_CRITICAL_SECTION( intState );                /*  关闭中断                    */  

      if ( freeTimer )                                      /*  释放空闲内存                */
      {
        if ( (freeTimer->timeout.time16[0] == 0) && (freeTimer->timeout.time16[1] == 0) )
        {
          osal_set_event( freeTimer->task_id, freeTimer->event_flag );
        }
        osal_mem_free( freeTimer );
      }
    }
  }
}

这个函数主要功能就是更新每个Timer 时间链表中的time32的值，当这个值为0时，就发送该节点的事件给对应的任务；