这回说下系统中很重要的时钟节拍
在系统初始化的时候就用下面这个函数建了一个时钟任务。
/************************************************************************************************************************

void  OS_TickTaskInit (OS_ERR  *p_err)
{
#ifdef OS_SAFETY_CRITICAL
    if (p_err == (OS_ERR *)0) {
        OS_SAFETY_CRITICAL_EXCEPTION();
        return;
    }
#endif

    OSTickCtr         = (OS_TICK)0u;                        /* Clear the tick counter                                 */

    OSTickTaskTimeMax = (CPU_TS)0u;


    OS_TickListInit();                                      /* 初始化一下时钟列表，一般延时的任务就在这里管理，下面看下它的内容*/

                                                            /* ---------------- CREATE THE TICK TASK ---------------- */
    if (OSCfg_TickTaskPrio >= (OS_CFG_PRIO_MAX - 1u)) {     /* Only one task at the 'Idle Task' priority              */
        *p_err = OS_ERR_PRIO_INVALID;
        return;
    }
/*下面是建时钟节拍任务*/
    OSTaskCreate((OS_TCB     *)&OSTickTaskTCB,
                 (CPU_CHAR   *)((void *)"uC/OS-III Tick Task"),
                 (OS_TASK_PTR )OS_TickTask,
                 (void       *)0,
                 (OS_PRIO     )OSCfg_TickTaskPrio,
                 (CPU_STK    *)OSCfg_TickTaskStkBasePtr,
                 (CPU_STK_SIZE)OSCfg_TickTaskStkLimit,
                 (CPU_STK_SIZE)OSCfg_TickTaskStkSize,
                 (OS_MSG_QTY  )0u,
                 (OS_TICK     )0u,
                 (void       *)0,
                 (OS_OPT      )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
                 (OS_ERR     *)p_err);
}


void  OS_TickListInit (void)
{
    OS_TICK_SPOKE_IX   i;
    OS_TICK_SPOKE     *p_spoke;

/*如果一个任务休息了，那它会从就绪列中退出，然后用OS_TICK_SPOKE来管理*/

    for (i = 0u; i < OSCfg_TickWheelSize; i++) {
        p_spoke                = (OS_TICK_SPOKE *)&OSCfg_TickWheel[i];/*OSCfg_TickWheel[]在这我也不知道怎么说，先放下，往下看，会说的*/
        p_spoke->FirstPtr      = (OS_TCB        *)0;
        p_spoke->NbrEntries    = (OS_OBJ_QTY     )0u;
        p_spoke->NbrEntriesMax = (OS_OBJ_QTY     )0u;
    }
}
这时我也要说下OS_TICK_SPOKE结构体
struct  os_tick_spoke {
    OS_TCB              *FirstPtr;                          /* 这里怎么说呢比如挂OSCfg_TickWheel[1]任务可能有很多，但这里的
    FirstPtr只指第一个任务，其他任务是用任务控制块中的成员TickNextPtr，TickPrevPtr来连接的*/
    OS_OBJ_QTY           NbrEntries;                        /* 还是用OSCfg_TickWheel[1]举例，挂要这个spoke上的任务数            */
    OS_OBJ_QTY           NbrEntriesMax;                     /* 这上的最多可以是多少个任务，（这说的不一定对）               */
};
OSCfg_TickWheel对于这个大家先别急，等我说到OSTimeDly说，这节会说的。
*************************************************************************************************************************/
/************************************************************************************************************************
这个任务是在上面的函数中建立的。
void  OS_TickTask (void *p_arg)
{
    OS_ERR  err;
    CPU_TS  ts;


    p_arg = p_arg;                                          /* Prevent compiler warning                               */

    while (DEF_ON) {
        (void)OSTaskSemPend((OS_TICK  )0,/*这里是要等一个信号量，如果有的话就可以往下干活了，不然就会等这个信号，直到得到这个信号，这个我不会在这说，说到信号量时说*/
                            (OS_OPT   )OS_OPT_PEND_BLOCKING,
                            (CPU_TS  *)&ts,
                            (OS_ERR  *)&err);               /* Wait for signal from tick interrupt                    */
        if (err == OS_ERR_NONE) {
            if (OSRunning == OS_STATE_OS_RUNNING) {
                OS_TickListUpdate();                        /* Update all tasks waiting for time                      */
            }
        }
    }
}

OSTimeTick这个是在定时中断中被调用的，用来给上面这个任务发送信号
我们要自写出一个定时中断，大概1秒进入定时中断几次是由我们定的，同时设置OSCfg_TickRate_Hz，也就是说，1秒，我们会给OS_TickTask
发送OSCfg_TickRate_Hz次信号。也说明这个任务1秒可以调用OS_TickListUpdate多少次。
我们不太会说，总之以上就是我想说的关于时钟节拍。
void  OSTimeTick (void)/*在中断中调用*/
{
    OS_ERR  err;
#if OS_CFG_ISR_POST_DEFERRED_EN > 0u
    CPU_TS  ts;
#endif


    OSTimeTickHook();                                       /* Call user definable hook                               */

#if OS_CFG_ISR_POST_DEFERRED_EN > 0u

    ts = OS_TS_GET();                                       /* Get timestamp                                          */
    OS_IntQPost((OS_OBJ_TYPE) OS_OBJ_TYPE_TICK,             /* 如果是到这的话，说明不立刻发送信号                     */
                (void      *)&OSRdyList[OSPrioCur],
                (void      *) 0,
                (OS_MSG_SIZE) 0u,
                (OS_FLAGS   ) 0u,
                (OS_OPT     ) 0u,
                (CPU_TS     ) ts,
                (OS_ERR    *)&err);

#else

   (void)OSTaskSemPost((OS_TCB *)&OSTickTaskTCB,            /* Signal tick task                                       */
                       (OS_OPT  ) OS_OPT_POST_NONE,
                       (OS_ERR *)&err);


#if OS_CFG_SCHED_ROUND_ROBIN_EN > 0u
    OS_SchedRoundRobin(&OSRdyList[OSPrioCur]);
#endif

#if OS_CFG_TMR_EN > 0u
    OSTmrUpdateCtr--;/*这是用于软定时器的先不说了*/
    if (OSTmrUpdateCtr == (OS_CTR)0u) {
        OSTmrUpdateCtr = OSTmrUpdateCnt;
        OSTaskSemPost((OS_TCB *)&OSTmrTaskTCB,              /* Signal timer task                                      */
                      (OS_OPT  ) OS_OPT_POST_NONE,
                      (OS_ERR *)&err);
    }
#endif

#endif
}
*************************************************************************************************************************/
/************************************************************************************************************************
好了说下任务的延时OSTimeDly，我们看这个函数的入口参数就知道，一个任务只能延时自己。
void  OSTimeDly (OS_TICK   dly,
                 OS_OPT    opt,
                 OS_ERR   *p_err)
{
    CPU_SR_ALLOC();



#ifdef OS_SAFETY_CRITICAL
    if (p_err == (OS_ERR *)0) {
        OS_SAFETY_CRITICAL_EXCEPTION();
        return;
    }
#endif

#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u
    if (OSIntNestingCtr > (OS_NESTING_CTR)0u) {             /* Not allowed to call from an ISR                        */
       *p_err = OS_ERR_TIME_DLY_ISR;
        return;
    }
#endif

    if (OSSchedLockNestingCtr > (OS_NESTING_CTR)0u) {       /* Can't delay when the scheduler is locked               */
       *p_err = OS_ERR_SCHED_LOCKED;
        return;
    }

    switch (opt) {
        case OS_OPT_TIME_DLY:
        case OS_OPT_TIME_TIMEOUT:
        case OS_OPT_TIME_PERIODIC:
             if (dly == (OS_TICK)0u) {                      /* 0 means no delay!                                      */
                *p_err = OS_ERR_TIME_ZERO_DLY;
                 return;
             }
             break;

        case OS_OPT_TIME_MATCH:
             break;

        default:
            *p_err = OS_ERR_OPT_INVALID;
             return;
    }

    OS_CRITICAL_ENTER();
    OSTCBCurPtr->TaskState = OS_TASK_STATE_DLY;/*当前任务的状态变化*/
    OS_TickListInsert(OSTCBCurPtr,
                      dly,
                      opt,
                      p_err);
    if (*p_err != OS_ERR_NONE) {
         OS_CRITICAL_EXIT_NO_SCHED();
         return;
    }
    OS_RdyListRemove(OSTCBCurPtr);                          /* Remove current task from ready list                    */
    OS_CRITICAL_EXIT_NO_SCHED();
    OSSched();                                              /* Find next task to run!                                 */
   *p_err = OS_ERR_NONE;
}
OS_TickListInsert把当前任务插入到OSCfg_TickWheel[]中。
OS_TICK=INT32 DEF_OCTET_NBR_BITS=8
#define  OS_TICK_TH_RDY                     (OS_TICK)(DEF_BIT_FIELD(((sizeof(OS_TICK) * DEF_OCTET_NBR_BITS) / 2u), \16
                                                                    ((sizeof(OS_TICK) * DEF_OCTET_NBR_BITS) / 2u))) 16
                                                                    DEF_INT_CPU_NBR_BITS=32                        
#define  DEF_BIT_FIELD(bit_field, bit_shift)                                 ((((bit_field) >= DEF_INT_CPU_NBR_BITS) ? (DEF_INT_CPU_U_MAX_VAL)     \
                                                                                                                     : (DEF_BIT(bit_field) - 1uL)) \
                                                                                                                            << (bit_shift))

void  OS_TickListInsert (OS_TCB   *p_tcb,
                         OS_TICK   time,
                         OS_OPT    opt,
                         OS_ERR   *p_err)
{
    OS_TICK            tick_delta;
    OS_TICK            tick_next;
    OS_TICK_SPOKE     *p_spoke;
    OS_TCB            *p_tcb0;
    OS_TCB            *p_tcb1;
    OS_TICK_SPOKE_IX   spoke;



    if (opt == OS_OPT_TIME_MATCH) {                              /* 这个选项是说，让你休息到什么时间点                */
        tick_delta = time - OSTickCtr - 1u;
        if (tick_delta > OS_TICK_TH_RDY) {                       /*这说的是，如果你设定的时间点，比当前的时间点小，说明现在，已经经过了那个时间点
        ，那么就不延时了，但也不绝对这样，不然咱就是想让它休息一会，它就不休息了怎么办。OS_TICK_TH_RDY是我们设置的，
        上面的设置方法是我找到的别人做的，自己理解一下吧。
        如果小的不是很多就算了，但要是小的很多就让它休息，因为OSTickCtr溢出之后能很快到达time那就会让
        任务休息。根据我上面选的几个数可知OS_TICK_TH_RDY=0xffff0000，如果当前时间是0xffff000f，而
        我们设置的时间为0xffff0005，那就不会让任务休息了，但要是0x00000005，这样是会让任务休息的*/
            p_tcb->TickCtrMatch = (OS_TICK        )0u;
            p_tcb->TickRemain   = (OS_TICK        )0u;
            p_tcb->TickSpokePtr = (OS_TICK_SPOKE *)0;
           *p_err               =  OS_ERR_TIME_ZERO_DLY;         /* ... do NOT delay.                                 */
            return;
        }
        p_tcb->TickCtrMatch = time;
        p_tcb->TickRemain   = tick_delta + 1u;

    } else if (time > (OS_TICK)0u) {
        if (opt == OS_OPT_TIME_PERIODIC) {                       /* OS_OPT_TIME_PERIODIC这说的是给一个固定时间，在这上时间里，你做事后，剩下的时间都让任务休息
        比如写了一个任务，这个任务中用了这个函数，选项也是这个，时间设的是10，一开始p_tcb->TickCtrPrev=0，
        那么，这个任务工作到了3时，运行到这个函数，这个函数会让他休息7.这时p_tcb->TickCtrPrev=10，如果下次
        工作到了15，那么只会让任务休息5，这时p_tcb->TickCtrPrev=20*/
            tick_next  = p_tcb->TickCtrPrev + time;
            tick_delta = tick_next - OSTickCtr - 1u;
            if (tick_delta < time) {                             /* If next periodic delay did NOT already occur, ... */
                p_tcb->TickCtrMatch = tick_next;                 /* ... set  next  periodic delay;                ... */
            } else {
                p_tcb->TickCtrMatch = OSTickCtr + time;          /* ... else reset periodic delay.                    */
            }
            p_tcb->TickRemain   = p_tcb->TickCtrMatch - OSTickCtr;
            p_tcb->TickCtrPrev  = p_tcb->TickCtrMatch;

        } else {                                                 /*OS_OPT_TIME_DLY还有这种，就是让任务休息time时间                 */
            p_tcb->TickCtrMatch = OSTickCtr + time;
            p_tcb->TickRemain   = time;
        }
        /*综上所述，根据我们的选项设置了p_tcb->TickCtrMatch，任务休息，然后当OSTickCtr到达这个值时，就会再次变成就绪的，p_tcb->TickRemain是还剩下
        多长的休息时间。p_tcb->TickCtrPrev，是要OS_OPT_TIME_PERIODIC这个选项时用的，它和p_tcb->TickCtrMatch一起控制任务休息时间。p_tcb->TickCtrPrev是
        上次休息到的时间，p_tcb->TickCtrMatch是这次可以休息到的时间，一个任务从p_tcb->TickCtrPrev开始工作，到一某个时间点休息，休息到p_tcb->TickCtrMatch。
        然后p_tcb->TickCtrMatch会成为下次的工作的时间起点。*/

    } else {                                                     /* Zero time delay; ...                              */
        p_tcb->TickCtrMatch = (OS_TICK        )0u;
        p_tcb->TickRemain   = (OS_TICK        )0u;
        p_tcb->TickSpokePtr = (OS_TICK_SPOKE *)0;
       *p_err               =  OS_ERR_TIME_ZERO_DLY;             /* ... do NOT delay.                                 */
        return;
    }

/*然后用p_tcb->TickCtrMatch%OSCfg_TickWheelSize得出一个余数赋给spoke，然后取出OSCfg_TickWheel[spoke]来管理这个任务，
说实话，我觉得这种处理方真的很不错，咱们如果设定OSCfg_TickWheelSize为8，任何一个数去除这个数余只有0,1,2,3,4,5,6,7这几种情况，
然后就也说OSCfg_TickWheel[8]中的一个spoke来管理这个任务，如果有很多任务休息，这些任务可能不在同一个上，当系统查是不是有任务
到时间了，可以就绪了，那么只要查看OSCfg_TickWheel[OSTickCtr%OSCfg_TickWheelSize]就行了，这样就可以少查看几个任务（这你明白为什么了吗？）*/
    spoke   = (OS_TICK_SPOKE_IX)(p_tcb->TickCtrMatch % OSCfg_TickWheelSize);
    p_spoke = &OSCfg_TickWheel[spoke];

    if (p_spoke->NbrEntries == (OS_OBJ_QTY)0u) {                 /* 如果是挂在这个spoke上的第一个任务                         */
        p_tcb->TickNextPtr   = (OS_TCB   *)0;
        p_tcb->TickPrevPtr   = (OS_TCB   *)0;
        p_spoke->FirstPtr    =  p_tcb;
        p_spoke->NbrEntries  = (OS_OBJ_QTY)1u;
    } else {
        p_tcb1     = p_spoke->FirstPtr;                          /* 如果不是，就把这个任务插到这个链中，            */
        while (p_tcb1 != (OS_TCB *)0) {
            p_tcb1->TickRemain = p_tcb1->TickCtrMatch- OSTickCtr;            /* 看这几行，我们发现，当前任务要插在，一个合适的位置，也就是当前任务插在那个位置后，
            一定是这个任务前面的任务所需的TickRemain 比它所需的小，而它后面的一定比它大 。这样做的原因是
            当查看这个spoke上哪个任务可以进入就绪状况所用的时间最小（这我想我说的明白吧？）    */
                              
            if (p_tcb->TickRemain > p_tcb1->TickRemain) {        /* Do we need to insert AFTER current TCB in list?   */
                if (p_tcb1->TickNextPtr != (OS_TCB *)0) {        /* Yes, are we pointing at the last TCB in the list? */
                    p_tcb1               =  p_tcb1->TickNextPtr; /* No,  Point to next TCB in the list                */
                } else {
                    p_tcb->TickNextPtr   = (OS_TCB *)0;
                    p_tcb->TickPrevPtr   =  p_tcb1;
                    p_tcb1->TickNextPtr  =  p_tcb;               /* Yes, TCB to add is now new last entry in the list */
                    p_tcb1               = (OS_TCB *)0;          /* Break loop                                        */
                }
            } else {                                             /* Insert before the current TCB                     */
                if (p_tcb1->TickPrevPtr == (OS_TCB *)0) {        /* Are we inserting before the first TCB?            */
                    p_tcb->TickPrevPtr   = (OS_TCB *)0;
                    p_tcb->TickNextPtr   =  p_tcb1;
                    p_tcb1->TickPrevPtr  =  p_tcb;
                    p_spoke->FirstPtr    =  p_tcb;
                } else {                                         /* Insert in between 2 TCBs already in the list      */
                    p_tcb0               =  p_tcb1->TickPrevPtr;
                    p_tcb->TickPrevPtr   =  p_tcb0;
                    p_tcb->TickNextPtr   =  p_tcb1;
                    p_tcb0->TickNextPtr  =  p_tcb;
                    p_tcb1->TickPrevPtr  =  p_tcb;
                }
                p_tcb1 = (OS_TCB *)0;                            /* Break loop                                        */
            }
        }
        p_spoke->NbrEntries++;
    }
    if (p_spoke->NbrEntriesMax < p_spoke->NbrEntries) {          /* Keep track of maximum # of entries in each spoke  */
        p_spoke->NbrEntriesMax = p_spoke->NbrEntries;
    }
    p_tcb->TickSpokePtr = p_spoke;                               /* Link back to tick spoke                           */
   *p_err               = OS_ERR_NONE;
}

画个图来看一个


spoke
+-------------+________
| FirstPtr    | 　　　　|
+-------------+ |　　tcb1 tcb2                 tcb2
|NbrEntries=3 | 　　　 |---->+-----------+      +-----------+      +-----------+
+-------------+ 　　　0 <-----|TickPrevPtr| <-----|TickPrevPtr| <-----|TickPrevPtr|
|NbrEntriesMax| 　　　+-----------+       +-----------+       +-----------+
+-------------+       　　　|TickNextPtr|-----> |TickNextPtr|-----> |TickNextPtr|-----> 0
　　　+-----------+       +-----------+       +-----------+
 
 
*************************************************************************************************************************/
/************************************************************************************************************************
 我们在看一下OS_Ticktask任务做的事OS_TickListUpdate();就是看看当前时间没有没任务延时结束，只看OSCfg_TickWheel[OSTickCtr % OSCfg_TickWheelSize]上的任务，
 而且先看第一个如果第一个延时结束才会向后看，因为后面的延时时间都是大于等于前面的，前面的不就绪，后面的也不可能就绪，这样做就很高效，实时性就好
 void  OS_TickListUpdate (void)
{
    CPU_BOOLEAN        done;
    OS_TICK_SPOKE     *p_spoke;
    OS_TCB            *p_tcb;
    OS_TCB            *p_tcb_next;
    OS_TICK_SPOKE_IX   spoke;
    CPU_TS             ts_start;
    CPU_TS             ts_end;
    CPU_SR_ALLOC();


    OS_CRITICAL_ENTER();
    ts_start = OS_TS_GET();
    OSTickCtr++;                                                       /* 每来一次定时中断这个数就加1           */
    spoke    = (OS_TICK_SPOKE_IX)(OSTickCtr % OSCfg_TickWheelSize);/*刚刚说了，一次只看一个spoke上的任务。看哪个呢？就由这个余数确定*/
    p_spoke  = &OSCfg_TickWheel[spoke];
    p_tcb    = p_spoke->FirstPtr;
    done     = DEF_FALSE;
    while (done == DEF_FALSE) {
        if (p_tcb != (OS_TCB *)0) {
            p_tcb_next = p_tcb->TickNextPtr;                           /* Point to next TCB to update                 */
            switch (p_tcb->TaskState) {
                case OS_TASK_STATE_RDY:
                case OS_TASK_STATE_PEND:
                case OS_TASK_STATE_SUSPENDED:
                case OS_TASK_STATE_PEND_SUSPENDED:
                     break;

                case OS_TASK_STATE_DLY:
                     p_tcb->TickRemain = p_tcb->TickCtrMatch           /* Compute time remaining of current TCB       */
                                       - OSTickCtr;
                     if (OSTickCtr == p_tcb->TickCtrMatch) {           /* Process each TCB that expires               */
                         p_tcb->TaskState = OS_TASK_STATE_RDY;
                         OS_TaskRdy(p_tcb);                            /* Make task ready to run                      */
                     } else {
                         done             = DEF_TRUE;                  /*上面我说过，在一个spoke上的任务，TickRemain小的在前面，
                          如果最前面的任务都没就绪，后面的也不会就绪，所以就不向下看了*/
                     }
                     break;

                case OS_TASK_STATE_PEND_TIMEOUT:
                     p_tcb->TickRemain = p_tcb->TickCtrMatch           /* 这个是在等事件时用的，一般我们不会让任务无限等那个事件，有时间限制的，时间到了，也会就绪       */
                                       - OSTickCtr;
                     if (OSTickCtr == p_tcb->TickCtrMatch) {           /* Process each TCB that expires               */
#if (OS_MSG_EN > 0u)
                         p_tcb->MsgPtr     = (void      *)0;
                         p_tcb->MsgSize    = (OS_MSG_SIZE)0u;
#endif
                         p_tcb->TS         = OS_TS_GET();
                         OS_PendListRemove(p_tcb);                     /* Remove from wait list                       */
                         OS_TaskRdy(p_tcb);
                         p_tcb->TaskState  = OS_TASK_STATE_RDY;
                         p_tcb->PendStatus = OS_STATUS_PEND_TIMEOUT;   /* 这是说明我们没等到我们想要的事件                     */
                         p_tcb->PendOn     = OS_TASK_PEND_ON_NOTHING;  /* 因为超时也就不等了                  */
                     } else {
                         done              = DEF_TRUE;                 /* Don't find a match, we're done!             */
                     }
                     break;

                case OS_TASK_STATE_DLY_SUSPENDED:/*这个位置我想说的是SUSPENDED，说的是待机状态（我也不知道可不可以这么说就是闲着没事），
                以上都是延时结束，就会进入就绪，有了这个状态就是延时结束也不会就绪*/
                     p_tcb->TickRemain = p_tcb->TickCtrMatch           /* Compute time remaining of current TCB       */
                                       - OSTickCtr;
                     if (OSTickCtr == p_tcb->TickCtrMatch) {           /*OSTickCtr等于这个任务的 TickCtrMatch结束延时               */
                         p_tcb->TaskState  = OS_TASK_STATE_SUSPENDED;
                         OS_TickListRemove(p_tcb);                     /* 你看，虽然从这个链上拿下来了，但也没调用进入就绪状态那个函数，而且不就绪也不是因为延时或等事件*/
                     } else {
                         done              = DEF_TRUE;                 /* 这个地方我不说了，上面说过了           */
                     }
                     break;

                case OS_TASK_STATE_PEND_TIMEOUT_SUSPENDED:
                     p_tcb->TickRemain = p_tcb->TickCtrMatch           /* Compute time remaining of current TCB       */
                                       - OSTickCtr;
                     if (OSTickCtr == p_tcb->TickCtrMatch) {           /* Process each TCB that expires               */
#if (OS_MSG_EN > 0u)
                         p_tcb->MsgPtr     = (void      *)0;
                         p_tcb->MsgSize    = (OS_MSG_SIZE)0u;
#endif
                         p_tcb->TS         = OS_TS_GET();
                         OS_PendListRemove(p_tcb);                     /* Remove from wait list                       */
                         OS_TickListRemove(p_tcb);                     /* Remove from current wheel spoke             */
                         p_tcb->TaskState  = OS_TASK_STATE_SUSPENDED;
                         p_tcb->PendStatus = OS_STATUS_PEND_TIMEOUT;   /*PendStatus就那么几个状态，等到事件了OK, 中止也就是不用这个事件了，删除事件，最后就是这个等待超时了                    */
                         p_tcb->PendOn     = OS_TASK_PEND_ON_NOTHING;  /* Indicate no longer pending                  */
                     } else {
                         done              = DEF_TRUE;                 /* Don't find a match, we're done!             */
                     }
                     break;

                default:
                     break;
            }
            p_tcb = p_tcb_next;
        } else {
            done  = DEF_TRUE;
        }
    }
    ts_end = OS_TS_GET() - ts_start;                                   /* 看这个函数执行了多少时间，也是验证实时性的，时间越短越好         */
    if (ts_end > OSTickTaskTimeMax) {
        OSTickTaskTimeMax = ts_end;
    }
    OS_CRITICAL_EXIT();
}
*************************************************************************************************************************/
/************************************************************************************************************************
下面的函数是将一个处于delay的任务解除，看下限制条件，我们知道，这个函数只解除处于OS_TASK_STATE_DLY状态
和OS_TASK_STATE_DLY_SUSPENDED的任务，任务处于前面的状态，解除delay同时还会使任务就绪，后者只是解除delay
还有，最后还会执行任务的调度，因为解除delay状态并就绪的任务可能优先级比当前运行的任务高。
void  OSTimeDlyResume (OS_TCB  *p_tcb,
                       OS_ERR  *p_err)
{
    CPU_SR_ALLOC();



#ifdef OS_SAFETY_CRITICAL
    if (p_err == (OS_ERR *)0) {
        OS_SAFETY_CRITICAL_EXCEPTION();
        return;
    }
#endif

#if OS_CFG_CALLED_FROM_ISR_CHK_EN > 0u
    if (OSIntNestingCtr > (OS_NESTING_CTR)0u) {             /* Not allowed to call from an ISR                        */
        *p_err = OS_ERR_TIME_DLY_RESUME_ISR;
        return;
    }
#endif

#if OS_CFG_ARG_CHK_EN > 0u
    if (p_tcb == (OS_TCB *)0) {                             /* Not possible for the running task to be delayed!       */
       *p_err = OS_ERR_TASK_NOT_DLY;
        return;
    }
#endif

    CPU_CRITICAL_ENTER();
    switch (p_tcb->TaskState) {
        case OS_TASK_STATE_RDY:                             /* Cannot Abort delay if task is ready                    */
             CPU_CRITICAL_EXIT();
            *p_err = OS_ERR_TASK_NOT_DLY;
             break;

        case OS_TASK_STATE_DLY:
             OS_CRITICAL_ENTER_CPU_CRITICAL_EXIT();
             p_tcb->TaskState = OS_TASK_STATE_RDY;
             OS_TickListRemove(p_tcb);                      /* Remove task from tick list                             */
             OS_RdyListInsert(p_tcb);                       /* Add to ready list                                      */
             OS_CRITICAL_EXIT_NO_SCHED();
            *p_err = OS_ERR_NONE;
             break;

        case OS_TASK_STATE_PEND:
             CPU_CRITICAL_EXIT();
            *p_err = OS_ERR_TASK_NOT_DLY;
             break;

        case OS_TASK_STATE_PEND_TIMEOUT:
             CPU_CRITICAL_EXIT();
            *p_err = OS_ERR_TASK_NOT_DLY;
             break;

        case OS_TASK_STATE_SUSPENDED:
             CPU_CRITICAL_EXIT();
            *p_err = OS_ERR_TASK_NOT_DLY;
             break;

        case OS_TASK_STATE_DLY_SUSPENDED:
             OS_CRITICAL_ENTER_CPU_CRITICAL_EXIT();
             p_tcb->TaskState = OS_TASK_STATE_SUSPENDED;
             OS_TickListRemove(p_tcb);                      /* Remove task from tick list                             */
             OS_CRITICAL_EXIT_NO_SCHED();
            *p_err            = OS_ERR_TASK_SUSPENDED;
             break;

        case OS_TASK_STATE_PEND_SUSPENDED:
             CPU_CRITICAL_EXIT();
            *p_err = OS_ERR_TASK_NOT_DLY;
             break;

        case OS_TASK_STATE_PEND_TIMEOUT_SUSPENDED:
             CPU_CRITICAL_EXIT();
            *p_err = OS_ERR_TASK_NOT_DLY;
             break;

        default:
             CPU_CRITICAL_EXIT();
            *p_err = OS_ERR_STATE_INVALID;
             break;
    }

    OSSched();
}
*************************************************************************************************************************/
/************************************************************************************************************************
将任务从管理它的spoke上卸下，这个任务不在指向这个spoke，这个spoke也不指向这个任务。这个任务不再指向这个spoke上的其他任务，
这个spoke上的其他任务也不指向它。
void  OS_TickListRemove (OS_TCB  *p_tcb)
{
    OS_TICK_SPOKE  *p_spoke;
    OS_TCB         *p_tcb1;
    OS_TCB         *p_tcb2;



    p_spoke = p_tcb->TickSpokePtr;
    if (p_spoke != (OS_TICK_SPOKE *)0) {                              /* Confirm that task is in tick list            */
        p_tcb->TickRemain = (OS_TICK)0u;
        if (p_spoke->FirstPtr == p_tcb) {                             /* Is timer to remove at the beginning of list? */
            p_tcb1            = (OS_TCB *)p_tcb->TickNextPtr;         /* Yes                                          */
            p_spoke->FirstPtr = p_tcb1; /*其实，这我想说，一般延时时间到了的，多是在这解除，因为spoke上的任务，一定是就前面的时间先到*/
            if (p_tcb1 != (OS_TCB *)0) {
                p_tcb1->TickPrevPtr = (void *)0;
            }
        } else {
            p_tcb1              = p_tcb->TickPrevPtr;                 /* No, remove timer from somewhere in the list  */
            p_tcb2              = p_tcb->TickNextPtr;
            p_tcb1->TickNextPtr = p_tcb2;
            if (p_tcb2 != (OS_TCB *)0) { /*如果是调用了OSTimeDlyResume，才有可能执行到这，任务可能是在中间某位置解除*/
                p_tcb2->TickPrevPtr = p_tcb1;
            }
        }
        p_tcb->TickNextPtr  = (OS_TCB        *)0;
        p_tcb->TickPrevPtr  = (OS_TCB        *)0;
        p_tcb->TickSpokePtr = (OS_TICK_SPOKE *)0;
        p_tcb->TickCtrMatch = (OS_TICK        )0u;
        p_spoke->NbrEntries--;
    }
}
*************************************************************************************************************************/
/************************************************************************************************************************
字面上我们也可以看出来，如果解除延时的任务优先级和这个任务的相等，就把它放在这个优先级链上的最后，至于为什么我也不太明白，
可能是不想干扰到现在正在工作的任务吧。但我们大至可以猜到，这个刚被解除的任务可能原来是在当前任务之前的。
对于不等于当前任务优级的情况，其实可以这么看，如果是比当前任务优先级高，那么，当前任务能执行，说明比当前任务优先级高的
任务都处于阻塞的状态，而这个刚被解除的任务，所在的就绪链一定没别的任务，所以可以插到最前面，但也有可能是这样，被解除的任务
比当前的优先级低。比如，当前任务先运行一会，delay了，一个低优先级的运行一会也delay了，但马上那个任务就绪了，而低的还没有，
我们用这个就绪的任务解除了那个低优先级的，这也是有可能的，但这也说明，那个低优先级的任务在自己的任务链中原来也是在前面的，
因为我们们知道一个优先级链中，一定是执行第一个任务，但有没有可能那低优先级的任务不是在最前面的也是有可能的
比如优先级3上有一个任务A，优先级4上有两个任务B，C。A运行了一会，delay=5。B运行一会，然后delay=6，C运行一会,delay=10,
过一会，A动了，然后再一会B也就绪了，但A优先级高，所以还是A是当前任务，然后A将C的延时状态解除，看下面代码C一定会放在B前。
不过正常来说不会随便出现这种情况，而且，一般我们认为一个任务休息后应尽快工作，所以是放在优先级链前。
void  OS_RdyListInsert (OS_TCB *p_tcb)
{
    OS_PrioInsert(p_tcb->Prio);
    if (p_tcb->Prio == OSPrioCur) {                         /* Are we readying a task at the same prio?               */
        OS_RdyListInsertTail(p_tcb);                        /* Yes, insert readied task at the end of the list        */
    } else {
        OS_RdyListInsertHead(p_tcb);                        /* No,  insert readied task at the beginning of the list  */
    }
}
只看这一个函数吧。比较简单。我也不说了，但为了逻辑连贯，我还是拿出来放在这。
void  OS_RdyListInsertTail (OS_TCB  *p_tcb)
{
    OS_RDY_LIST  *p_rdy_list;
    OS_TCB       *p_tcb2;



    p_rdy_list = &OSRdyList[p_tcb->Prio];
    if (p_rdy_list->NbrEntries == (OS_OBJ_QTY)0) {          /* CASE 0: Insert when there are no entries               */
        p_rdy_list->NbrEntries  = (OS_OBJ_QTY)1;            /*         This is the first entry                        */
        p_tcb->NextPtr          = (OS_TCB   *)0;            /*         No other OS_TCBs in the list                   */
        p_tcb->PrevPtr          = (OS_TCB   *)0;
        p_rdy_list->HeadPtr     = p_tcb;                    /*         Both list pointers point to this OS_TCB        */
        p_rdy_list->TailPtr     = p_tcb;
    } else {                                                /* CASE 1: Insert AFTER the current tail of list          */
        p_rdy_list->NbrEntries++;                           /*         One more OS_TCB in the list                    */
        p_tcb->NextPtr          = (OS_TCB   *)0;            /*         Adjust new OS_TCBs links                       */
        p_tcb2                  = p_rdy_list->TailPtr;
        p_tcb->PrevPtr          = p_tcb2;
        p_tcb2->NextPtr         = p_tcb;                    /*         Adjust old tail of list's links                */
        p_rdy_list->TailPtr     = p_tcb;
    }
}
*************************************************************************************************************************