怎样去移植并调度UcosII呢？UcosII的运行流程是怎样的

接下来，陆陆续续会将语雀的个人笔记搬移到csdn上。
该篇文档过长，建议目录查找关键位置。
UcosII是剥夺内核（每个系统节拍会切换到最高就绪优先级任务），系统运行取决于任务的优先级。任务优先级的关系：优先级越小，数值越大；优先级越大，数值越小。
移植

1、到ucos官方下载相应mcu型号的源码文件。
2、得到





EvalBoards 文件夹里面包含评估板相关文件，提取部分，









APP.c就不需要了,钩子函数在





BSP.c文件,跟板子相关的函数可以删除了，特别注意时间戳所需要的函数实现要保留。
BSP_CPU_ClkFreq();
CPU_TS_TmrInit();
CPU_TS_TmrRd();
CPU_TS32_to_uSec();
3、直接复制LIB跟CPU文件夹





4、在3个文件夹下删除不需要的编译器环境，RealView为Keil环境





5、修改编译器asm汇编文件 OS_CPU_A.ASM：





keil环境下，查看函数定义前面是否是extern如果不是，改成extern。
这样修改的目的，是因为MDK编程环境不认识PUBLIC，要用EXPORT.
6、最重要的2个函数的连接：
PendSV_Handler（） 和 SysTick_Handler（）；
在asm文件里面将 OS_CPU_PendSVHandler





更改为MCU启动文件中断向量表中的PendSV_Handler：





7、配置SysTick心跳
UcosII的心跳时间是由SysTick系统滴答来实现，具体心跳的间隔由配置文件OS_TICKS_PER_SEC宏来决定，关于时钟节拍的时间，如果中断时间越短，它的实时性越好，但是CPU做的无用功越多，同样，定时的时间越长，虽然CPU做的无用功越少，但是，它的实时性越差，根据CPU性能推荐10-100毫秒。

/*********************************************************************
* 函数名称: Delay_init
* 函数描述: 延时及ucosII心跳初始化
* 入                参:  ucSysclk 系统时钟频率
* 出    参：无
* 返 回 值: 无
**********************************************************************/
void Delay_init(UINT8 ucSysclk)
{
#if SYSTEM_SUPPORT_OS                                                                         //如果需要支持OS.
        UINT32 ulReload;
#endif
        SysTick->CTRL&=~(1<<2);                                                                //SYSTICK使用外部时钟源         
        fac_us=ucSysclk/8;                                                                                //不论是否使用OS,fac_us都需要使用
#if SYSTEM_SUPPORT_OS                                                                         //如果需要支持OS.
        ulReload=ucSysclk/8;                                                                        //每秒钟的计数次数 单位为M          
        ulReload*=1000000/OS_DISPATCH_NUM;                //根据delay_ostickspersec设定溢出时间
                                                                                                                                                                //reload为24位寄存器,最大值:16777216,在180M下,约合0.699s左右       
        fac_ms=1000/OS_DISPATCH_NUM;                                        //代表OS可以延时的最少单位          
        SysTick->CTRL|=1<<1;                                                                   //开启SYSTICK中断
        SysTick->LOAD=ulReload;                                                         //每1/OS_DISPATCH_NUM秒中断一次       
        SysTick->CTRL|=1<<0;                                                                   //开启SYSTICK   
#else
        fac_ms=((u32)SYSCLK*1000)/8;                                        //非OS下,代表每个ms需要的systick时钟数   
#endif
}              
8、修改SysTick中断

void SysTick_Handler(void)
{
                if( OS_RUN == Valid )                               
                {
                        OSIntEnter();                                                                //进入中断
                        OSTimeTick();                                       //调用ucos的时钟服务程序               
                        OSIntExit();                                                //触发任务切换软中断
                }
}


配置文件

所有移植完成后，开始配置UcosII功能，配置文件为os_cfg.h:

                                       /* ---------------------- MISCELLANEOUS ----------------------- */
#define OS_APP_HOOKS_EN           0u   /* Application-defined hooks are called from the uC/OS-II hooks 从uC/OS-II钩子调用应用程序定义的钩子*/
#define OS_ARG_CHK_EN             0u   /* Enable (1) or Disable (0) argument checking                  启用(1)或禁用(0)参数检查*/
#define OS_CPU_HOOKS_EN           1u   /* uC/OS-II hooks are found in the processor port files         uC/OS-II钩子可以在处理器端口文件中找到*/


#define OS_DEBUG_EN               0u   /* Enable(1) debug variables                                    启用debug*/


#define OS_EVENT_MULTI_EN         0u   /* Include code for OSEventPendMulti()                          启用OSEventPendMulti()函数*/
#define OS_EVENT_NAME_EN          0u   /* Enable names for Sem, Mutex, Mbox and Q                      使能事件名称*/


#define OS_LOWEST_PRIO           63u   /* Defines the lowest priority that can be assigned ...         最低优先级*/
                                       /* ... MUST NEVER be higher than 254!                           */


#define OS_MAX_EVENTS            20u   /* Max. number of event control blocks in your application      最大应用程序中事件控制块的数量*/
#define OS_MAX_FLAGS              5u   /* Max. number of Event Flag Groups    in your application      最大应用程序中的事件标志组数目*/
#define OS_MAX_MEM_PART           0u   /* Max. number of memory partitions                             最大内存分区数*/
#define OS_MAX_QS                 5u   /* Max. number of queue control blocks in your application      最大应用程序中队列控制块的数量*/
#define OS_MAX_TASKS             20u   /* Max. number of tasks in your application, MUST be >= 2       最大应用程序中的任务数，必须是>= 2*/


#define OS_SCHED_LOCK_EN          1u   /* Include code for OSSchedLock() and OSSchedUnlock()           */


#define OS_TICK_STEP_EN           1u   /* Enable tick stepping feature for uC/OS-View                  */
#define OS_TICKS_PER_SEC        200u   /* Set the number of ticks in one second                        设置一秒内的节拍数*/

#define OS_TLS_TBL_SIZE           0u   /* Size of Thread-Local Storage Table                           线程本地存储表的大小*/




                                       /* --------------------- TASK STACK SIZE ---------------------- 任务堆栈大小*/
#define OS_TASK_TMR_STK_SIZE    128u   /* Timer      task stack size (# of OS_STK wide entries)        计时器任务栈大小(OS_STK范围条目的#)*/
#define OS_TASK_STAT_STK_SIZE   128u   /* Statistics task stack size (# of OS_STK wide entries)        统计任务堆栈大小(OS_STK范围条目的#)*/
#define OS_TASK_IDLE_STK_SIZE   128u   /* Idle       task stack size (# of OS_STK wide entries)        空闲任务栈大小(OS_STK宽度条目的#)*/




                                       /* --------------------- TASK MANAGEMENT ---------------------- 任务管理*/
#define OS_TASK_CHANGE_PRIO_EN    1u   /*     Include code for OSTaskChangePrio()                      */
#define OS_TASK_CREATE_EN         1u   /*     Include code for OSTaskCreate()                          */
#define OS_TASK_CREATE_EXT_EN     1u   /*     Include code for OSTaskCreateExt()                       */
#define OS_TASK_DEL_EN            1u   /*     Include code for OSTaskDel()                             */
#define OS_TASK_NAME_EN           1u   /*     Enable task names                                        启用任务名称*/
#define OS_TASK_PROFILE_EN        1u   /*     Include variables in OS_TCB for profiling                在OS_TCB中包含用于分析的变量*/
#define OS_TASK_QUERY_EN          1u   /*     Include code for OSTaskQuery()                           */
#define OS_TASK_REG_TBL_SIZE      1u   /*     Size of task variables array (#of INT32U entries)        任务变量数组的大小(INT32U项的#)*/
#define OS_TASK_STAT_EN           1u   /*     Enable (1) or Disable(0) the statistics task             启用(1)或禁用(0)统计任务*/
#define OS_TASK_STAT_STK_CHK_EN   1u   /*     Check task stacks from statistic task                    从统计任务检查任务堆栈*/
#define OS_TASK_SUSPEND_EN        1u   /*     Include code for OSTaskSuspend() and OSTaskResume()      */
#define OS_TASK_SW_HOOK_EN        1u   /*     Include code for OSTaskSwHook()                          */




                                       /* ----------------------- EVENT FLAGS ------------------------ 事件标志*/
#define OS_FLAG_EN                1u   /* Enable (1) or Disable (0) code generation for EVENT FLAGS    为事件标志启用(1)或禁用(0)代码生成*/
#define OS_FLAG_ACCEPT_EN         1u   /*     Include code for OSFlagAccept()                          */
#define OS_FLAG_DEL_EN            1u   /*     Include code for OSFlagDel()                             */
#define OS_FLAG_NAME_EN           1u   /*     Enable names for event flag group                        */
#define OS_FLAG_QUERY_EN          1u   /*     Include code for OSFlagQuery()                           */
#define OS_FLAG_WAIT_CLR_EN       1u   /* Include code for Wait on Clear EVENT FLAGS                   包括等待清除事件标志的代码*/
#define OS_FLAGS_NBITS           16u   /* Size in #bits of OS_FLAGS data type (8, 16 or 32)            OS_FLAGS数据类型的大小(8、16或32*/




                                       /* -------------------- MESSAGE MAILBOXES --------------------- 消息邮箱*/
#define OS_MBOX_EN                1u   /* Enable (1) or Disable (0) code generation for MAILBOXES      为邮箱启用(1)或禁用(0)代码生成*/
#define OS_MBOX_ACCEPT_EN         1u   /*     Include code for OSMboxAccept()                          */
#define OS_MBOX_DEL_EN            1u   /*     Include code for OSMboxDel()                             */
#define OS_MBOX_PEND_ABORT_EN     1u   /*     Include code for OSMboxPendAbort()                       */
#define OS_MBOX_POST_EN           1u   /*     Include code for OSMboxPost()                            */
#define OS_MBOX_POST_OPT_EN       1u   /*     Include code for OSMboxPostOpt()                         */
#define OS_MBOX_QUERY_EN          1u   /*     Include code for OSMboxQuery()                           */




                                       /* --------------------- MEMORY MANAGEMENT -------------------- 内存管理*/
#define OS_MEM_EN                 0u   /* Enable (1) or Disable (0) code generation for MEMORY MANAGER 为内存管理器启用(1)或禁用(0)代码生成*/
#define OS_MEM_NAME_EN            1u   /*     Enable memory partition names                            启用内存分区名称*/
#define OS_MEM_QUERY_EN           1u   /*     Include code for OSMemQuery()                            */




                                       /* ---------------- MUTUAL EXCLUSION SEMAPHORES --------------- 互斥信号量*/
#define OS_MUTEX_EN               1u   /* Enable (1) or Disable (0) code generation for MUTEX          启用(1)或禁用(0)互斥的代码生成*/
#define OS_MUTEX_ACCEPT_EN        1u   /*     Include code for OSMutexAccept()                         */
#define OS_MUTEX_DEL_EN           1u   /*     Include code for OSMutexDel()                            */
#define OS_MUTEX_QUERY_EN         1u   /*     Include code for OSMutexQuery()                          */




                                       /* ---------------------- MESSAGE QUEUES ---------------------- 消息队列*/
#define OS_Q_EN                   1u   /* Enable (1) or Disable (0) code generation for QUEUES         为队列启用(1)或禁用(0)代码生成*/
#define OS_Q_ACCEPT_EN            1u   /*     Include code for OSQAccept()                             */
#define OS_Q_DEL_EN               1u   /*     Include code for OSQDel()                                */
#define OS_Q_FLUSH_EN             1u   /*     Include code for OSQFlush()                              */
#define OS_Q_PEND_ABORT_EN        1u   /*     Include code for OSQPendAbort()                          */
#define OS_Q_POST_EN              1u   /*     Include code for OSQPost()                               */
#define OS_Q_POST_FRONT_EN        1u   /*     Include code for OSQPostFront()                          */
#define OS_Q_POST_OPT_EN          1u   /*     Include code for OSQPostOpt()                            */
#define OS_Q_QUERY_EN             1u   /*     Include code for OSQQuery()                              */




                                       /* ------------------------ SEMAPHORES ------------------------ 信号量*/
#define OS_SEM_EN                 1u   /* Enable (1) or Disable (0) code generation for SEMAPHORES     为信号量启用(1)或禁用(0)代码生成*/
#define OS_SEM_ACCEPT_EN          1u   /*    Include code for OSSemAccept()                            */
#define OS_SEM_DEL_EN             1u   /*    Include code for OSSemDel()                               */
#define OS_SEM_PEND_ABORT_EN      1u   /*    Include code for OSSemPendAbort()                         */
#define OS_SEM_QUERY_EN           1u   /*    Include code for OSSemQuery()                             */
#define OS_SEM_SET_EN             1u   /*    Include code for OSSemSet()                               */




                                       /* --------------------- TIME MANAGEMENT ---------------------- 时间管理*/
#define OS_TIME_DLY_HMSM_EN       1u   /*     Include code for OSTimeDlyHMSM()                         */
#define OS_TIME_DLY_RESUME_EN     1u   /*     Include code for OSTimeDlyResume()                       */
#define OS_TIME_GET_SET_EN        1u   /*     Include code for OSTimeGet() and OSTimeSet()             */
#define OS_TIME_TICK_HOOK_EN      1u   /*     Include code for OSTimeTickHook()                        */




                                       /* --------------------- TIMER MANAGEMENT --------------------- 软件定时器*/
#define OS_TMR_EN                 1u   /* Enable (1) or Disable (0) code generation for TIMERS         启用(1)或禁用(0)软件定时器代码生成*/
#define OS_TMR_CFG_MAX           16u   /*     Maximum number of timers                                 最大定时器数*/
#define OS_TMR_CFG_NAME_EN        1u   /*     Determine timer names                                    确定计时器的名字*/
#define OS_TMR_CFG_WHEEL_SIZE     8u   /*     Size of timer wheel (#Spokes)                            计时器轮尺寸(辐条数)*/
#define OS_TMR_CFG_TICKS_PER_SEC 100u  /*     Rate at which timer management task runs (Hz)            计时器管理任务运行的速率(Hz)*/
#define OS_TASK_TMR_PRIO                                  0u   /*                                                                                                                                                                                                                                                   软件定时器的优先级,设置为最高                */


初始化

UcosII的初始化函数用于初始化配置，在os_cfg.h文件配置的功能会通过宏编译来选择性初始化。

核心调度函数

SysTick_Handler

函数用于根据时钟节拍来寻找延时完毕的任务，并将其设置成就绪状态，然后在就绪任务中获取最高优先级任务并调用OSIntExit函数来切换至该任务，在任何中断中，要用OSIntEnter()和OSIntExit()函数来表面进入和退出中断，OSIntExit函数会检查中断嵌套深度，并始终会在无中断嵌套后，才开始任务的调度。





OSIntEnter

这个函数用于通知uC/OS-II您将要为一个中断服务服务程序(ISR)。这允许uC/OS-II跟踪中断嵌套，从而只在最后一个嵌套ISR执行调度：

void  OSIntEnter (void)
{
    if (OSRunning == OS_TRUE) {
        if (OSIntNesting < 255u) {
            OSIntNesting++;                      /* Increment ISR nesting level                        */
        }
    }
}
OSTimeTick

函数通过while轮询TCB块任务有OSTCBDly延时的，发生1次心跳进行减1操作，并且判断延时是否到达，到达后会将相应的任务从新设置为就绪状态。





OSIntExit

通知uCOSII已经完成了对ISR的服务。当最后一个嵌套ISR已经完成，uC/OS-II将调用调度器来确定是否一个新的高优先级任务准备运行，最后OS_SchedNew()，查找当前最高优先级就绪任务，通过OSIntCtxSw中断级调度函数触发PendSV异常来进行调度：

void  OSIntExit (void)
{
#if OS_CRITICAL_METHOD == 3u                               /* Allocate storage for CPU status register */
    OS_CPU_SR  cpu_sr = 0u;
#endif


    if (OSRunning == OS_TRUE) {
        OS_ENTER_CRITICAL();
        if (OSIntNesting > 0u) {                           /* Prevent OSIntNesting from wrapping       */
            OSIntNesting--;
        }
        if (OSIntNesting == 0u) {                          /* Reschedule only if all ISRs complete ... */
            if (OSLockNesting == 0u) {                     /* ... and not locked.                      */
                OS_SchedNew();
                OSTCBHighRdy = OSTCBPrioTbl[OSPrioHighRdy];
                if (OSPrioHighRdy != OSPrioCur) {          /* No Ctx Sw if current task is highest rdy */
#if OS_TASK_PROFILE_EN > 0u
                    OSTCBHighRdy->OSTCBCtxSwCtr++;         /* Inc. # of context switches to this task  */
#endif
                    OSCtxSwCtr++;                          /* Keep track of the number of ctx switches */


#if OS_TASK_CREATE_EXT_EN > 0u
#if defined(OS_TLS_TBL_SIZE) && (OS_TLS_TBL_SIZE > 0u)
                    OS_TLS_TaskSw();
#endif
#endif
                    OSIntCtxSw();                          /* Perform interrupt level ctx switch       */
                }
            }
        }
        OS_EXIT_CRITICAL();
    }
}
OS_SchedNew






在UcosII中，为了节约CPU任务调度时间，不可能每次轮询查找所有任务那些就绪了，于是用了任务就绪组跟任务就绪位表，可以很方便的直接找出当前最高优先级的任务。
如当前有4个组有任务就绪，OSRdyGrp表示为0xF，将0xF代入OSUnMapTbl[OSRdyGrp]表，OSUnMapTbl数组内下标15的值为0，既找出了当前最高优先级的任务组，并赋值给y，再将y代入OSUnMapTbl[OSRdyTbl[y]]表中找出最高优先级任务的位位置（OSRdyTbl[y]里面保存了任务的位位置的偏移，创建任务确定的）最终得到OSPrioHighRdy（包含了任务在8*8的矩阵中的位置信息，高2位空，中3位为Y，低3位为X），合成最高优先级且已经就绪的任务横坐标和纵坐标。
OSRdyGrp就绪组信息和OSRdyTbl就绪位信息会在任务创建、等待完成、调度的时候填充进去，同样，也会在任务挂起、删除、等待、调度中将自己删除。
OSRdyGrp（1字节）表示任务就绪组，OSRdyGrp每一位代表1组，1组表示8个任务，Y是OSRdyGrp任务就绪组中的组位置，表示任务在0-8个组中那个组有任务就绪了，X是任务在OSRdyTbl[ptcb->OSTCBY]就绪位表中的位位置，表示任务在0-8位中那个位有任务就绪了，这个数组是按照就绪组序号存放的。





OSUnMapTbl[]：就绪表数组：数组中每一项是一个字节，第N项代表了第N个就绪组，字节数据代表了该优先级组中的优先级偏移(范围是从0~7，就是低三位)，此时OSRdyGrp就绪组可能多个位被置位，表示可能多个优先级组有就绪任务；
OSRdyTbl[]就绪表数组某个元素代表了某组中多个任务中的某个任务就绪，也是最低位0为最高优先级，OSRdyTbl这个要特别注意的是该变量为数组，参数是通过任务的优先级右移的值来决定下标位置，其实也就是按8个任务分为1组。即：OSRdyTbl[0]装的任务0-7，OSRdyTbl[1]装的任务8-15。
OSUnMapTbl[]表将2的8次方种可能全部算好了，为了节约时间，所以用查表的方式进行高就绪优先级任务的选择：

INT8U  const  OSUnMapTbl[256] = {
    0u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, 3u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, /* 0x00 to 0x0F                   */
    4u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, 3u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, /* 0x10 to 0x1F                   */
    5u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, 3u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, /* 0x20 to 0x2F                   */
    4u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, 3u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, /* 0x30 to 0x3F                   */
    6u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, 3u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, /* 0x40 to 0x4F                   */
    4u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, 3u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, /* 0x50 to 0x5F                   */
    5u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, 3u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, /* 0x60 to 0x6F                   */
    4u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, 3u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, /* 0x70 to 0x7F                   */
    7u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, 3u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, /* 0x80 to 0x8F                   */
    4u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, 3u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, /* 0x90 to 0x9F                   */
    5u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, 3u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, /* 0xA0 to 0xAF                   */
    4u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, 3u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, /* 0xB0 to 0xBF                   */
    6u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, 3u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, /* 0xC0 to 0xCF                   */
    4u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, 3u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, /* 0xD0 to 0xDF                   */
    5u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, 3u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, /* 0xE0 to 0xEF                   */
    4u, 0u, 1u, 0u, 2u, 0u, 1u, 0u, 3u, 0u, 1u, 0u, 2u, 0u, 1u, 0u  /* 0xF0 to 0xFF                   */
};


如prio优先级为12的任务：

ptcb->OSTCBY             = (INT8U)(prio >> 3u);                                         //Y 01
ptcb->OSTCBX             = (INT8U)(prio & 0x07u);                                                   //X 04
ptcb->OSTCBBitY          = (OS_PRIO)(1uL <<  ptcb->OSTCBY);     //TCB_Y 02
ptcb->OSTCBBitX          = (OS_PRIO)(1uL <<  ptcb->OSTCBX);     //TCB_X 10
OSRdyGrp                |= ptcb->OSTCBBitY;                                                                //02
OSRdyTbl[ptcb->OSTCBY]  |= ptcb->OSTCBBitX;                                                                //10


代入查表：

y=OSUnMapTbl[OSRdyGrp]；                //OSRdyGrp值为02，OSUnMapTbl表中的02值为01，所以y值为01
x=OSUnMapTbl[OSRdyTbl[y]])；            //OSRdyTbl[y]为OSRdyTbl[1]，这里面存的是ptcb->OSTCBBitX的值0x10,OSUnMapTbl表中0x10的值为04。所以x等于04


任务优先级OSPrioHighRdy的组成为：1个字节，高2为为0，因为只有64个，中间3位为Y，低3位为X。
最后 OSPrioHighRdy = y <<3 + x； //OSPrioHighRdy = 0x0C。
得到的Y就是第几行，X就是第几位，任务优先级12的任务在第1行第4个。从0开始数。
找到最高优先级的就绪任务后，通过OSTCBPrioTbl[OSPrioHighRdy]会将相应的优先级任务的TCB块指针赋值给OSTCBHighRdy，然后调用OSIntCtxSw。

OSIntCtxSw

该函数为汇编函数，用于在中断结束时进行任务调度的函数，触发PendSV异常

;********************************************************************************************************
;                   PERFORM A CONTEXT SWITCH (From interrupt level) - OSIntCtxSw()
;
; Note(s) : 1)当OSIntExit()确定需要进行上下文切换时，OSIntCtxSw()被OSIntExit()调用
;中断的结果。这个函数只会触发一个PendSV异常
;当不再有活动中断且中断已启用时处理。
;********************************************************************************************************


OSIntCtxSw
    LDR     R0, =NVIC_INT_CTRL                                  ; Trigger the PendSV exception (causes context switch)
    LDR     R1, =NVIC_PENDSVSET
    STR     R1, [R0]
    BX      LR


PendSV_Handler

PendSV是可悬挂任务，当有任务触发PendSV异常后，如果此时被更高异常中断打断，则PendSV异常挂起，当所有高于PendSV的中断执行完毕后，PendSV才执行。





PendSV异常主要用来执行上下文切换，保存当前任务的堆栈，加载即将执行任务的堆栈至系统寄存器，然后跳转至要执行任务的函数中，一般从加载的任务堆栈中将LR赋值给PC。

PendSV_Handler
    CPSID   I                                                   ; Prevent interruption during context switch        防止上下文切换期间的中断
    MRS     R0, PSP                                             ; PSP is process stack pointer                                                          PSP是进程栈指针
    CBZ     R0, PendSV_Handler_nosave                           ; Skip register save the first time                                                第一次跳过寄存器保存


    SUBS    R0, R0, #0x20                                       ; Save remaining regs r4-11 on process stack        将其余的regs r4-11保存在进程堆栈上
    STM     R0, {R4-R11}


    LDR     R1, =OSTCBCur                                       ; OSTCBCur->OSTCBStkPtr = SP;
    LDR     R1, [R1]
    STR     R0, [R1]                                            ; R0 is SP of process being switched out                        R0是被切换的进程的SP


                                                                ; At this point, entire context of process has been saved        此时，进程的整个上下文已经保存
PendSV_Handler_nosave
    PUSH    {R14}                                               ; Save LR exc_return value                保存LR exc_return值
    LDR     R0, =OSTaskSwHook                                   ; OSTaskSwHook();                                                        调用钩子函数
    BLX     R0
    POP     {R14}


    LDR     R0, =OSPrioCur                                      ; OSPrioCur = OSPrioHighRdy;        赋值最高优先级任务
    LDR     R1, =OSPrioHighRdy
    LDRB    R2, [R1]
    STRB    R2, [R0]


    LDR     R0, =OSTCBCur                                       ; OSTCBCur  = OSTCBHighRdy;                赋值最高优先级任务的TCB块指针
    LDR     R1, =OSTCBHighRdy
    LDR     R2, [R1]
    STR     R2, [R0]


    LDR     R0, [R2]                                            ; R0 is new process SP; SP = OSTCBHighRdy->OSTCBStkPtr;从新任务中将栈顶赋值给SP
    LDM     R0, {R4-R11}                                        ; Restore r4-11 from new process stack                                                                        从新的进程堆栈恢复r4-11
    ADDS    R0, R0, #0x20
    MSR     PSP, R0                                             ; Load PSP with new process SP                                                                                                加载新进程SP的PSP
    ORR     LR, LR, #0xF4                                       ; Ensure exception return uses process stack                                        确保异常返回使用进程堆栈
    CPSIE   I
    BX      LR                                                  ; Exception return will restore remaining context                        异常返回将恢复剩余的上下文


    END
该汇编函数主要完成：
1、将CPU的通用寄存器保存压入当前任务堆栈（每一个任务都有自己的堆栈，含SP变量等）。
2、将堆栈指针SP赋值给当前任务控制块中的OSTCBStkPtr中。
3、调用钩子函数（如果有）。
4、获得最高优先级的任务块，OSPrioCur = OSPrioHighRdy; OSTCBCur（当前TCB运行指针） = OSTCBHighRdy;
5、将新任务块中的OSTCBStkPtr（PSP栈顶指针）赋值给 SP；
6、将新的任务块中的R4-R11值出栈给CPU通用寄存器；
7、中断返回IRET(RETI)，使PC指向当前TCB运行指针，完成调度。
OSTimeDly

UcOSII的任务调度除了SysTick，还用OSTimeDly延时函数来进行调度。





该函数进入后首先判读有无中断嵌套和加锁，此函数首先将自己的就绪组及就绪位状态清除，目的是让自身任务挂起，并且将延时的时间放进当前任务的OSTCBDly里面（延时的时间通过SysTick心跳来进行减操作），然后进入**OS_Sched()**函数。
OS_Sched






该函数也会检查有无中断嵌套和加锁，然后调用OS_SchedNew函数来寻找当前最高优先级的就绪任务，然后将找到的高优先级TCB指针赋值给OSTCBHighRdy，然后判断是不是当前正在运行的，如果不是，将调用OS_TASK_SW宏，来调度任务。
OS_TASK_SW

该宏实际是调用了OSCtxSw汇编函数，该汇编函数跟OSIntCtxSw内容一致，都是用于触发PengSV异常（任务A切换到B时需要保存cpu的”现场数据“使系统能够返回A；同时需要加载B的”现场数据“到cpu中，以使B回到被切换时的状态。而只有cpu的特权模式允许上述操作，由用户级进入特权级的惟一途径是触发异常，包括中断）

OSCtxSw
    LDR     R0, =NVIC_INT_CTRL                                  ; Trigger the PendSV exception (causes context switch)
    LDR     R1, =NVIC_PENDSVSET
    STR     R1, [R0]
    BX      LR


OSStartHighRdy

该汇编函数用于UcosII启动时调用：

;********************************************************************************************************
;                                         START MULTITASKING
;                                      void OSStartHighRdy(void)
;
; Note(s) : 1) This function triggers a PendSV exception (essentially, causes a context switch) to cause
;              the first task to start.
;
;           2) OSStartHighRdy() MUST:
;              a) 设置PendSV异常优先级最低
;              b) 设置初始PSP为0，告诉上下文切换器这是第一次运行
;              c) 将主堆栈设置为OS_CPU_ExceptStkBase
;              d) 设置OSRunning（系统开始运行标志）为真;
;              e) 触发PendSV;
;              f) 启用中断，开始调度;
;********************************************************************************************************


OSStartHighRdy
    LDR     R0, =NVIC_SYSPRI14                                  ; Set the PendSV exception priority
    LDR     R1, =NVIC_PENDSV_PRI
    STRB    R1, [R0]


    MOVS    R0, #0                                              ; Set the PSP to 0 for initial context switch call
    MSR     PSP, R0


    LDR     R0, =OS_CPU_ExceptStkBase                           ; Initialize the MSP to the OS_CPU_ExceptStkBase
    LDR     R1, [R0]
    MSR     MSP, R1   


    LDR     R0, =OSRunning                                      ; OSRunning = TRUE
    MOVS    R1, #1
    STRB    R1, [R0]


    LDR     R0, =NVIC_INT_CTRL                                  ; Trigger the PendSV exception (causes context switch)
    LDR     R1, =NVIC_PENDSVSET
    STR     R1, [R0]


    CPSIE   I                                                   ; Enable interrupts at processor level


OSStartHang
    B       OSStartHang                                         ; Should never get here

任务运行流程

任务创建

任务创建通过OSTaskCreateExt（）函数进行，主要初始化任务堆栈和初始化TCB块的信息：

        OSTaskCreateExt((void(*)(void*) )start_task,                                                                //任务函数
                    (void*          )0,                                                                 //传递给任务函数的参数
                    (OS_STK*        )&START_TASK_STK[START_STK_SIZE-1],                //任务堆栈栈顶
                    (INT8U          )START_TASK_PRIO,                                                   //任务优先级
                    (INT16U         )START_TASK_PRIO,                                                   //任务ID
                    (OS_STK*        )&START_TASK_STK[0],                                                //任务堆栈栈底
                    (INT32U         )START_STK_SIZE,                                                    //任务堆栈大小
                    (void*          )0,                                                                 //用户补充的存储区
                    (INT16U         )OS_TASK_OPT_STK_CHK|OS_TASK_OPT_STK_CLR|OS_TASK_OPT_SAVE_FP);//保存浮点寄存器的值
初始化任务堆栈

设置堆栈，任务函数，初始化ro-r15及系统xPSR状态寄存器，如使能FPU，还需初始化FPU寄存器。初始化ro-r15及系统xPSR状态寄存器。





添加进TCB任务控制块

OS_TCBInit()，该函数首先从空闲TCB指针申请了一块控制块（地址），依次在该申请的TCB块中加入了任务的堆栈指针（栈顶、栈底）、更新了空闲TCB指针、任务优先级、任务选项、并清除了任务的挂起状态并置为就绪状态，计算出了任务的X和Y（横坐标和纵坐标），然后将这个新申请的TCB块地址加到 OSTCBPrioTbl[Prio] TCB指针表中（基于优先级存放），然后再加入到OSTCBList双向链表中，更新OSRdyGrp任务就绪表，更新OSRdyTbl任务的就绪位表、更新OSTaskCtr数量任务计数器：




OS_TCBInit()函数初始化完毕后，会在OSTaskCreateExt（）函数内部调用OS_Sched()函数进行任务调度，但由于os还未运行，此时是无法调度的。
开始任务

ucosII通过开始任务来启动其他应用任务，开始任务初始化完毕后，会调用OSStart()函数来启动任务调度。
该函数会判断OSStart标志是否为0，也就是os系统没有启动。
然后调用OS_SchedNew()函数找出最高优先级的任务优先级。
将当前的最高优先级就绪任务的TCB快指针确定后赋值给OSTCBCur（当前运行的TCB指针）。
最后调用OSStartHighRdy来启动调度。





功能说明

信号量（二值、计数型）

信号量总体运行规则是：创建1个事件控制块， 有任务请求信号量，就把该任务放入等待事件列表中，然后其他任务会发送信号量，就是把等待信号量的任务从挂起态设置为就绪态。
二值信号量就是独占任务，只能1个任务占用。
计数型或多值信号量，就是在初始化信号量的时候传入的共享资源cnt数（>1）,表示该资源可以同时被cnt个任务同时占用，与二值信号量的区别是，使用后需要释放。
OSSemCreate()

信号量创建函数：





该函数创建1个具有信号量事件的类型OS_EVENT的控制块，并返回，用于请求和发送。
OSSemPend()

请求信号量：










该请求函数有3个参数，1个是创建信号量时返回的事件控制块指针，1个是超时时间（0是一直等待），1个是错误返回。
1、函数进入后，判断信号量计数是否大于1，如果是说明有信号量发送了，进行减一后，此时函数将在此返回，执行**OSSemPend(temp)**后面的逻辑代码。





2、再次进入这函数后，因为没有信号量发送或已经发送了，所以当前任务没有得到可用信号量，不会返回，此时当前运行的任务状态将被与等为信号量待定状态，同时将超时时间传入（超时时间是系统节拍，如果传入的值为真，则当前任务在系统滴答中断里面递减满足超时时间后，会将此任务恢复就绪，并再次执行）。





3、将事件控制块信息保存到当前任务的事件控制块指针中，将当前任务放入等候名单，然后清除当前任务的就绪组和就绪位信息。





4、执行调度函数，进行调度。





5、该信号量被发送信号量发送信号或超时恢复的时候，任务将从调度函数OS_Sched()的下一条指令执行(因为在进行系统调度的时候，入栈保存的LR寄存器指向下一条指令的地址)。





恢复任务后，检查状态，并将任务状态更改为准备运行。
OSSemPost()

发送信号量：





函数只有1个参数，即事件控制块指针。
1、验证事件控制块是否有等待事件。





2、通过OS_EventTaskRdy函数得到等待任务的X和Y，获取任务的优先级，取得TCB块指针，将等待任务的TCB块内的延时清0，清除任务的信号量待定状态，将任务从新加入到就绪组中，最后从事件等待列表中删除此任务。





3、信号量值加1。





4、执行调度函数，进行任务调度。
互斥信号量

互斥信号量用于降解优先级翻转的问题，当ABC的优先级分别为123时，C在某个时刻获得了信号量的使用权，在执行逻辑代码的时候，系统掉调度发生，因为B任务准备就绪，且优先级大于C，此时线程切换至B，在执行B代码的时候，A准备就绪，线程切换至A，A请求信号量，因为C被B打断，但C的信号量这个时候还没有释放，故A任务挂起，返回执行B，等B执行完后，才执行C，等C释放信号量后,A才得以运行。这一过程就是典型的发生了优先级翻转问题：B先于A运行。
解决这个问题就引入了互斥信号量，还是ABC，优先级为123，C在某个时刻获得了信号量的使用权，在执行逻辑代码的时候，系统掉调度发生，因为B任务准备就绪，且优先级大于C，此时线程切换至B，在执行B代码的时候，A准备就绪，线程切换至A，A请求信号量，在请求的过程中，发现优先级比C高，为了C不被其他任务打断，故将C的优先级提高到天花板，此时线程切换回C，等C执行完，释放信号量，恢复优先级后，线程切换至A,A执行完后，再执行B。
只要低优先级任务拿到信号量，高优先级任务再请求时，都会直接把低优先级的任务的优先级提升到天花板，无论有没有其他任务打断这个低优先级任务，直接提升。
OSMutexCreate()

互斥信号量创建函数参数1为需要继承的天花板优先级，参数2为错误返回。









函数进入后，判断了天花板优先级是否已经有任务占用了，没有的话，就开辟1个事件块，并将事件的参数进行初始化，将OSEventCnt置为可用的。





函数返回事件控制块首地址。
OSMutexPend()

请求互斥信号量函数，参数1为请求的信号量事件块，参数2超时时间，参数3为错误返回。














函数进来获取继承优先级





判断信号量是否已经被占用，没有占用就占用该信号量，将当前任务的TCB，优先级与继承优先级位或存入事件结构体后函数正常返回。





当发生互斥（信号量被已经被独占没有被释放，这个时候又有其他任务申请）后，函数经过②不会返回，表示信号量已经被其他任务占用了，此时先获取占用信号量任务的优先级及TCB块指针：





比较占有该信号量的任务的优先级比继承优先级小时才会进行反转：




随后会比较占用信号量任务的优先级是否比当前任务小。





如果是，从占用信号量任务的就绪列表和位列表将其删除，更改占用信号量任务的优先级为天花板，重新计算XY，放入就绪列表和就绪位表。
将当前任务添加到等候名单（挂起），并将当前这个任务的任务状态更改为信号量待定，然后调用线程切换到获取到天花板优先级任务中去。

OSMutexPost()

互斥信号量发送函数：

INT8U OSMutexPost (OS_EVENT *pevent)
{
    INT8U pip;
    INT8U prio;
#if OS_CRITICAL_METHOD == 3
    OS_CPU_SR cpu_sr = 0; //方式3将把cpsr状态寄存器推入临时堆栈cpu_sr中,可以安全返回之前的中断状态
#endif
    if (OSIntNesting > 0) {
        return (OS_ERR_POST_ISR);
    }
#if OS_ARG_CHK_EN > 0
    if (pevent == (OS_EVENT *)0) {
        return (OS_ERR_PEVENT_NULL);
    }
#endif
    if (pevent->OSEventType != OS_EVENT_TYPE_MUTEX) {
        return (OS_ERR_EVENT_TYPE);
    }
    OS_ENTER_CRITICAL();
    pip = (INT8U)(pevent->OSEventCnt >> 8); //变相置顶值pip
    prio = (INT8U)(pevent->OSEventCnt & OS_MUTEX_KEEP_LOWER_8); //持有mutex资源的task原始优先级
    if (OSTCBCur != (OS_TCB *)pevent->OSEventPtr) { //因为解决了局部优先级翻转问题,所以OSTCBCur肯定要等于pevent->OSEventPtr，否则发生了不知名的异常
        OS_EXIT_CRITICAL();
        return (OS_ERR_NOT_MUTEX_OWNER);
    }
    if (OSTCBCur->OSTCBPrio == pip) { //task被提升了优先级到pip置顶值,也就是一个比该task优先级高，比pip低的进程需要访问互斥资源,即:存在B角色进程,那么使用OSMutex_RdyAtPrio()把本task从就绪控制矩阵中摘下来，同时将自己还原到prio优先级
        OSMutex_RdyAtPrio(OSTCBCur, prio);
    }
    OSTCBPrioTbl[pip] = OS_TCB_RESERVED;
    if (pevent->OSEventGrp != 0) {
        
        /*OS_EventTaskRdy()函数将摘掉等待在pevent事件控制矩阵上的task中优先级最高的task
        如果该task仅仅等待该pevent事件,那么将该task添加到就绪控制矩阵中
        OSRdyGrp |= bity;
        OSRdyTbl[y] |= bitx;这样调度程序就会根据情况调度OS_Sched()该task了*/
        prio = OS_EventTaskRdy(pevent, (void *)0, OS_STAT_MUTEX, OS_STAT_PEND_OK);
   
        /*保持处于高8位的pip置顶优先级值同时清除低8位数据*/
        pevent->OSEventCnt &= OS_MUTEX_KEEP_UPPER_8;
        pevent->OSEventCnt |= prio; //获得执行权的task充当优先级翻转计算中的C角色
        pevent->OSEventPtr = OSTCBPrioTbl[prio]; //task的控制块传给OSEventPtr指针,供优先级翻转计算使用
        if (prio <= pip) {
            
            /*prio比pip小,那么说明比置顶值pip优先级还要高的进程竟然访问了共享资源,
            那么这时可能会出现优先级翻转,因为这时mutex机制已经不起作用,
            所以应该保证"变相置顶的方式"初始化时,自己内定的最高优先级pip务必大于所有能访问互斥资源的进程优先级[gliethttp]*/
            OS_EXIT_CRITICAL();
            OS_Sched();
            return (OS_ERR_PIP_LOWER);
        } else {
            OS_EXIT_CRITICAL();
            OS_Sched();
            return (OS_ERR_NONE);
        }
    }
   
    //没有任何一个task悬停在本event事件控制矩阵上[gliethttp]
    pevent->OSEventCnt |= OS_MUTEX_AVAILABLE; //还原为初始值
    pevent->OSEventPtr = (void *)0; //现在本task不悬停在任何event事件上
    OS_EXIT_CRITICAL();
    return (OS_ERR_NONE);
}


该函数还是首先检查了中断嵌套和加锁，然后获取了继承优先级和任务原优先级，然后会判断当前任务的优先级是否被提升过，如果是，将通过函数OSMutex_RdyAtPrio恢复任务的优先级，然后判断有无任务正在等待互斥信号。
如果有的话就通过OS_EventTaskRdy获取等待任务的优先级，在获取优先级的同时会把获取的任务通过OS_EventTaskRemove函数从event等待列表中删除，并把等待的任务加入到就绪表中，如果没有event mutex的等待任务，则会直接设置event的OSEventCnt位OS_MUTEX_AVAILABLE和OSEventPtr的清0操作,然后调用OS_Sched来调度任务。
如果没有等待任务在event的等待列表中，则需要当前任务自己释放自己，也就是第三部分最后的4行操作。
消息邮箱

没有特别的，跟信号量唯一的区别是发送信号量时可以携带1个信息给等待信号量的任务**。**
OSMboxCreate

邮箱任务创建，该函数返回1个OS_EVENT事件控制块首地址。
OSMboxPend

邮箱等待函数，该函数参数1为等待邮箱的事件块，参数2为超时时间，参数3为错误返回，进入函数后先判断是否在中断或加锁中，首次进入后，肯定没人给他发消息，所以该函数通过OS_EventTaskWait函数将自己挂起，如果是第二次或以上进入，一定是有人发消息了，所以再次进入后，会判断消息指针是否为空，如果不为空，则将消息指针清零，同时返回消息指针。





OSMboxPost

邮箱发送函数，该函数参数1为发送邮箱的事件块，参数2为要传递的消息，进入函数后先判断是否在中断或加锁中，然后判断有无正在等待的任务，如果有，同样通过OS_EventTaskRdy函数将等待任务中挂起态放入运行列表中，并且将消息赋值给等待任务的OSTCBMsg，随后将自身任务从就绪列表中删除，最后通过OS_Sched寻找高优先级就绪任务进行调度。


特别注意的是，该函数二次进入后是从OS_Sched函数后开始执行的，可以看到将直接得到消息，并将消息指针返回。
消息队列

可以存放N个信息的指针，当请求消息的任务得到消息了，这时候又有任务给他发，就会在消息的环形缓冲区累加地址，数据得以保存，不会丢失。
OSQCreate

消息队列创建函数，参数1为放消息的buff，参数2为消息个数，返回OS_EVENT类型的事件块指针。
OSQPend

消息队列请求函数，参数1为发送消息队列的事件块，参数2为超时时间，参数3为错误返回，进入函数后先判断是否在中断或加锁中，首次进入后，肯定没人给他发消息，所以该函数通过OS_EventTaskWait函数将自己挂起，如果是第二次或以上进入，一定是有人发消息了，所以再次进入后，会判断消息指针是否为空，如果不为空，则将消息指针清零，同时返回消息指针，跟消息邮箱不同的是，在返回之前会将存放消息队列的读指针进行加1，消息记录减1，并会判断读指针越界没有，如果越界将重新指向消息队列队头。
OSQPost

邮箱发送函数，该函数参数1为发送消息队列的事件块，参数2为要传递的消息，进入函数后先判断是否在中断或加锁中，然后判断有无正在等待的任务，如果有，同样通过OS_EventTaskRdy函数将等待任务中挂起态放入运行列表中，并且将消息赋值给等待任务的OSTCBMsg，随后将自身任务从就绪列表中删除，最后通过OS_Sched寻找高优先级就绪任务进行调度，再次进入后是在OS_Sched后，这里会维护一个消息队列的写指针，并且会判断写指针超出消息队列没，超出了将重新指向队列队头。
事件标志组

跟信号量、消息邮箱、队列的区别就是可以设置等待多项事件的标志，等所有标志都立起来的时候，才会生效。
软件定时器

软件定时器在功能开启后，会在ucos初始化时由OSTmr_Init函数创建1个软件定时器任务OSTmr_Task。
OSTmr_Task

软件定时器的任务执行函数，该函数是由SysTick心跳里面的OSTmrSignal函数中的OSTimeTickHook钩子函数来调用的，钩子函数会根据节拍来调用OSTmrSignal函数，OSTmrSignal函数里面会对OSTmr_Task函数发送信号量，OSTmr_Task便得以执行：

static  void  OSTmr_Task (void *p_arg)
{
    INT8U            err;
    OS_TMR          *ptmr;
    OS_TMR          *ptmr_next;
    OS_TMR_CALLBACK  pfnct;
    OS_TMR_WHEEL    *pspoke;
    INT16U           spoke;




    p_arg = p_arg;                                               /* Prevent compiler warning for not using 'p_arg'    */
    for (;;) {
        OSSemPend(OSTmrSemSignal, 0u, &err);                     /* Wait for signal indicating time to update timers  */
        OSSchedLock();
        OSTmrTime++;                                             /* Increment the current time                        */
        spoke  = (INT16U)(OSTmrTime % OS_TMR_CFG_WHEEL_SIZE);    /* Position on current timer wheel entry             */
        pspoke = &OSTmrWheelTbl[spoke];
        ptmr   = pspoke->OSTmrFirst;
        while (ptmr != (OS_TMR *)0) {
            ptmr_next = (OS_TMR *)ptmr->OSTmrNext;               /* Point to next timer to update because current ... */
                                                                 /* ... timer could get unlinked from the wheel.      */
            if (OSTmrTime == ptmr->OSTmrMatch) {                 /* Process each timer that expires                   */
                OSTmr_Unlink(ptmr);                              /* Remove from current wheel spoke                   */
                if (ptmr->OSTmrOpt == OS_TMR_OPT_PERIODIC) {
                    OSTmr_Link(ptmr, OS_TMR_LINK_PERIODIC);      /* Recalculate new position of timer in wheel        */
                } else {
                    ptmr->OSTmrState = OS_TMR_STATE_COMPLETED;   /* Indicate that the timer has completed             */
                }
                pfnct = ptmr->OSTmrCallback;                     /* Execute callback function if available            */
                if (pfnct != (OS_TMR_CALLBACK)0) {
                    (*pfnct)((void *)ptmr, ptmr->OSTmrCallbackArg);
                }
            }
            ptmr = ptmr_next;
        }
        OSSchedUnlock();
    }
}
函数首次进入后，将自己挂起，根据时钟节拍接收信号量来执行。
当函数得到信号量的时候，首先上锁，并将软件定时器的计数自增，然后获取定时器条轮的入口地址，从条轮任务列表中取出任务的首地址，然后判断任务是否存在，存在的话先取出下个条轮任务的首地址，然后根据软件定时器的计时变量是否等于当前定时任务的定时时间，如果是，解锁，然后判断任务的定时器是否是需要重新装载，如果是，调用OSTmr_Link函数重新放入定时条轮，如不是，将指示该软件定时器为完成。然后调用回调执行任务，最后条轮指针指向下一个软件定时器入口。
OSTmrCreate

软件定时器创建函数，参数1为延时时间、参数2为周期还是单次、参数3是触发后手动添加时间还是自动重装，参数4是回调函数，参数5是回调参数，参数6是任务名字，参数7错误返回，函数将任务的参数加入时间队列后，返回OS_TMR类型的块指针。
OSTmrStart

软件定时器开始函数，参数1为要启动的OS_TMR类型的块指针，参数2为错误返回，函数首先进入后判断是否在中断中，然后上锁，根据定时器状态来执行，首次启动定时器为停止状态，调用OSTmr_Link函数将要启动的任务连接到时间条轮上。然后通过OSTmr_Task函数来执行任务。
定时器装载进定时器轮时就会确定其对应的OSTmrMacth值，这个值在定时器停止或重新装载之前保证不会变化，因此就能根据定时器控制块的OSTmrMacth字段值计算出这个定时器是在哪个轮辐之上，从而把大量的定时器分散于不同的轮辐之上，加速对定时器的操作。
当定时器轮需要接收一个定时器时，会先计算此定时器应该放在哪个轮辐之上，然后将其插入轮辐链表的第一个，如果此轮辐上还有其他定时器，则还会将原来第一个定时器的Prev指针指向新插入的这个定时器。
而当定时器轮卸下一个定时器时，则如果不是在轮辐的第一个，则可以通过Prev指针找到前一个定时器，这样就把删除定时器的时间控制在O(1)了。





任务同步

禁止任何中断和任务调度
OS_ENTER_CRITICAL()
OS_EXIT_CRITICAL()
禁止任务调度
OSSchedLock()
OSSchedUnlock()