逐字逐句解析ucos ii 源代码-》OS_CORE.c

//BY 简单的元清

//部分内容引用了其他博主的文章，对这些博主表示感谢，时间关系就不一一指出了。

//如有转载，请说明，谢谢


/*
*********************************************************************************************************
*                                                uC/OS-II
*                                          The Real-Time Kernel
*                                             CORE FUNCTIONS
*
*                        (c) Copyright 1992-1998, Jean J. Labrosse, Plantation, FL
*                                           All Rights Reserved
*
*                                                  V2.00
*
* File : OS_CORE.C
* By   : Jean J. Labrosse
*********************************************************************************************************
*/

#ifndef  OS_MASTER_FILE
#define  OS_GLOBALS
#include "software\includes.h"
#endif

/*
*********************************************************************************************************
*                                         LOCAL GLOBAL VARIABLES
*********************************************************************************************************
*/
                                       
static  INT8U        OSIntExitY;               /* Variable used by 'OSIntExit' to prevent using locals */

static  OS_STK       OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE];       /* Idle       task stack              */

#if     OS_TASK_STAT_EN
static  OS_STK       OSTaskStatStk[OS_TASK_STAT_STK_SIZE];      /* Statistics task stack               */
#endif

static  OS_TCB       OSTCBTbl[OS_MAX_TASKS + OS_N_SYS_TASKS];   /* Table of TCBs                       */

/*$PAGE*/
/*
*********************************************************************************************************
*                              MAPPING TABLE TO MAP BIT POSITION TO BIT MASK
*
* Note: Index into table is desired bit position, 0..7
*       Indexed value corresponds to bit mask
*********************************************************************************************************
*/
//ucosii 中确定优先级的机制如下：
//首先有一个类型为INT8U 的OSRdyGrp，我们把其中的8位叫D0,D1,D2,D3,D4,D5,D6,D7. 例如OSRdyGrp=0x03;说明在D0,D1两组中有任务就绪，那么我们知道了属于那一组，也需要知道在组里面的具体位置，所以我们还有
//一个类型为INT8U 的数组OSRdyTbl[]。其中OSRdyTbl[0]的8位叫a0,a1,a2,a3,a4,a5,a6,a7,OSRdyTbl[1]的8位叫b0,b1,b2,b3,b4,b5,b6,b7.....，如果OSRdyTbl[0]=0x03,说明在D0组的a0,a1两个位置有任务就绪。
 

//而优先级和OSRdyGrp、OSRdyTbl[]的对应关系为
//X = OSUnMapTbl[OSRdyGrp]; 
//Y = OSUnMapTbl[OSRdyTbl[X]]; 
//最高优先级为X*8+Y （ prio = (y << 3) + x;）

//prio最大的值为63，也就是0011 1111 ,最高的两位没有用到，其中D6,D5,D4 三位表示所在OSRdyGrp组中的位置，D3,D2,D1 三位表示所在具体组的位置。
//例如prio=30，二进制为0001 1110 ，表示 OSRdyGrp组中D3组为1，OSRdyTbl[3]中d6为1 


//举一个例子
//OSRdyGrp = 0x011;  //0b00010001 
//OSRdyTbl[0] = 0x0a; //0b00001010 
//OSRdyTbl[4] ＝ 0x01; //0b00000001 
//计算出存在的几个优先级为;0*8+1=1,0*8+3=3,4*8+0=32


//这个表表明是属于那一位
INT8U const OSMapTbl[]   = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};

/*
*********************************************************************************************************
*                                       PRIORITY RESOLUTION TABLE
*
* Note: Index into table is bit pattern to resolve highest priority
*       Indexed value corresponds to highest priority bit position (i.e. 0..7)
*********************************************************************************************************
*/

//这个表其实就是从00-FF时最低位为1的位置。
//为什么是最低位，因为优先级的值越小优先级越高
//例如
//0u==0x00 ==00000000b 最低位为1的位数为 bit0==0u (其实为空，空的情况默认为0，不影响计算)
//1u==0x01 ==00000001b 最低位为1的位数为 bit0==0u
//2u==0x02 ==00000010b 最低位为1的位数为 bit1==1u
//3u==0x03 ==00000011b 最低位为1的位数为 bit0==0u (有两个为1的位，bit0最小,所以最低位为1的位置是0)
//4u==0x04 ==00000100b 最低位为1的位数为 bit2==2u
//5u==0x05 ==00000101b 最低位为1的位数为 bit0==0u
//6u==0x06 ==00000110b 最低位为1的位数为 bit1==1u（
//7u==0x07 ==00000111b 最低位为1的位数为 bit0==0u
//8u==0x08 ==00001000b 最低位为1的位数为 bit3==3u（最低位为1的位置是3）
//9u==0x09 ==00001001b 最低位为1的位数为 bit0==0u
//Au==0x0A ==00001010b 最低位为1的位数为 bit1==1u
//Bu==0x0B ==00001011b 最低位为1的位数为 bit0==0u
INT8U const OSUnMapTbl[] = {
    0, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
    4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0
};

//为什么搞这个表，这么复杂，是因为这样做可以加快查找优先级的时间，同时查询的时间是可知的，如果用循环语句，那就蒙B了，你也不知道它查完这个东西要多久，实时操作系统的实时性体现在这里。
/*$PAGE*/
/*
*********************************************************************************************************
*                             MAKE TASK READY TO RUN BASED ON EVENT OCCURING
*
* Description: This function is called by other uC/OS-II services and is used to ready a task that was
*              waiting for an event to occur.
*
* Arguments  : pevent    is a pointer to the event control block corresponding to the event.
*
*              msg       is a pointer to a message.  This pointer is used by message oriented services
*                        such as MAILBOXEs and QUEUEs.  The pointer is not used when called by other
*                        service functions.
*
*              msk       is a mask that is used to clear the status byte of the TCB.  For example,
*                        OSSemPost() will pass OS_STAT_SEM, OSMboxPost() will pass OS_STAT_MBOX etc.
*
* Returns    : none
*
* Note       : This function is INTERNAL to uC/OS-II and your application should not call it.
*********************************************************************************************************
*/

#if  (OS_Q_EN && (OS_MAX_QS >= 2)) || OS_MBOX_EN || OS_SEM_EN


/****************************************************************/

//当发生了某个事件，该事件等待任务列表中的最高优先级任务置于就绪态
void  OSEventTaskRdy (OS_EVENT *pevent, void *msg, INT8U msk) reentrant
{
    OS_TCB *ptcb;
    INT8U   x;
    INT8U   y;
    INT8U   bitx;
    INT8U   bity;
    INT8U   prio;
  
 
    
    y    = OSUnMapTbl[pevent->OSEventGrp];            /* Find highest prio. task waiting for message   */
    //查询D6,D5,D4所在的组
	//然后找出最低位为1的位置
	
    bity = OSMapTbl[y];
	//把对应的位置转化为在组中位置
    x    = OSUnMapTbl[pevent->OSEventTbl[y]];
	//
	//查询D3,D2,D1所在的位置
	然后找出最低位为1的位置
    bitx = OSMapTbl[x];
		//把对应的位置转化为在组中的位置
    prio = (INT8U)((y << 3) + x);                     /* Find priority of task getting the msg         */
	//根据所在的组和在组中的具体位置推算出对应的优先级
	//prio=y*8+x 
	
	
    if ((pevent->OSEventTbl[y] &= ~bitx) == 0) {      /* Remove this task from the waiting list        */
	    //bitx 表示D3,D2,D1中对应在pevent->OSEventTbl[y]这个组中的位置
		//pevent->OSEventTbl[y]的8个位和bitx取反之后做与，来判断是否在等待。
        pevent->OSEventGrp &= ~bity;
	//对应的组中这一位的值取反，即取消这一位的等待状态	
    }
    ptcb                 =  OSTCBPrioTbl[prio];       /* Point to this task's OS_TCB                   */
	//把优先级信息告诉ptcb
    ptcb->OSTCBDly       =  0;                        /* Prevent OSTimeTick() from readying task       */
	//不等待
    ptcb->OSTCBEventPtr  = (OS_EVENT *)0;             /* Unlink ECB from this task                     */
	//不连接ECB
#if (OS_Q_EN && (OS_MAX_QS >= 2)) || OS_MBOX_EN
    ptcb->OSTCBMsg       = msg;                       /* Send message directly to waiting task         */
	//直接发送信息给等待任务
#else
    msg                  = msg;                       /* Prevent compiler warning if not used          */  
//防止编译器报错
#endif    
    ptcb->OSTCBStat     &= ~msk;                      /* Clear bit associated with event type          */
	//清除事件类型
	
    if (ptcb->OSTCBStat == OS_STAT_RDY) {             /* See if task is ready (could be susp'd)        */
        OSRdyGrp        |=  bity;                     /* Put task in the ready to run list             */
        OSRdyTbl[y]     |=  bitx;
		//如果任务就绪了，添加到就绪列表
    }
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
*                                   MAKE TASK WAIT FOR EVENT TO OCCUR
*
* Description: This function is called by other uC/OS-II services to suspend a task because an event has
*              not occurred.
*
* Arguments  : pevent   is a pointer to the event control block for which the task will be waiting for.
*
* Returns    : none
*
* Note       : This function is INTERNAL to uC/OS-II and your application should not call it.
*********************************************************************************************************
*/
#if  (OS_Q_EN && (OS_MAX_QS >= 2)) || OS_MBOX_EN || OS_SEM_EN
//使一个任务进入等待某事件发生状态
void  OSEventTaskWait (OS_EVENT *pevent) reentrant
{
    OSTCBCur->OSTCBEventPtr = pevent;            /* Store pointer to event control block in TCB        */
	//把这个任务的指针指向TCB任务块
    if ((OSRdyTbl[OSTCBCur->OSTCBY] &= ~OSTCBCur->OSTCBBitX) == 0) {      /* Task no longer ready      */
        OSRdyGrp &= ~OSTCBCur->OSTCBBitY;
	//从就绪列表中删除这个任务
	//代码参照上面的OSEventTaskRdy函数自己分析。
    }
	
    pevent->OSEventTbl[OSTCBCur->OSTCBY] |= OSTCBCur->OSTCBBitX;          /* Put task in waiting list  */
    pevent->OSEventGrp                   |= OSTCBCur->OSTCBBitY;
	//在等待列表中添加这个任务
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
*                              MAKE TASK READY TO RUN BASED ON EVENT TIMEOUT
*
* Description: This function is called by other uC/OS-II services to make a task ready to run because a
*              timeout occurred.
*
* Arguments  : pevent   is a pointer to the event control block which is readying a task.
*
* Returns    : none
*
* Note       : This function is INTERNAL to uC/OS-II and your application should not call it.
*********************************************************************************************************
*/
#if  (OS_Q_EN && (OS_MAX_QS >= 2)) || OS_MBOX_EN || OS_SEM_EN
//由于等待超时而将任务置为就绪态
void  OSEventTO (OS_EVENT *pevent) reentrant
{
    if ((pevent->OSEventTbl[OSTCBCur->OSTCBY] &= ~OSTCBCur->OSTCBBitX) == 0) {
        pevent->OSEventGrp &= ~OSTCBCur->OSTCBBitY;
    }
	//从就绪列表中删除这个任务
    OSTCBCur->OSTCBStat     = OS_STAT_RDY;       /* Set status to ready                                */
	//把状态设置为就绪
    OSTCBCur->OSTCBEventPtr = (OS_EVENT *)0;     /* No longer waiting for event                        */
	//不需要等待事件
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
*                                 INITIALIZE EVENT CONTROL BLOCK'S WAIT LIST
*
* Description: This function is called by other uC/OS-II services to initialize the event wait list.
*
* Arguments  : pevent    is a pointer to the event control block allocated to the event.
*
* Returns    : none
*
* Note       : This function is INTERNAL to uC/OS-II and your application should not call it.
*********************************************************************************************************
*/
#if  (OS_Q_EN && (OS_MAX_QS >= 2)) || OS_MBOX_EN || OS_SEM_EN
// 初始化ECB块的等待任务列表
void  OSEventWaitListInit (OS_EVENT *pevent) reentrant
{
    INT8U i;
    
    
    pevent->OSEventGrp = 0x00;                   /* No task waiting on event                           */
	//直接把OSEventGrp=0x00
    for (i = 0; i < OS_EVENT_TBL_SIZE; i++) {
        pevent->OSEventTbl[i] = 0x00;
    }
	//OSEventTbl[0]-OSEventTbl[OS_EVENT_TBL_SIZE]全部等于0x00
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
*                                             INITIALIZATION
*
* Description: This function is used to initialize the internals of uC/OS-II and MUST be called prior to
*              creating any uC/OS-II object and, prior to calling OSStart().
*
* Arguments  : none
*
* Returns    : none
*********************************************************************************************************
*/
//它在OS应用中的main（）函数中首先被调用，是OS运行的第一个函数,它完成各初始变量的初始化。
void OSInit (void) reentrant
{
    INT16U i;


    OSTime        = 0L;                                    /* Clear the 32-bit system clock            */
	//清空化时间戳
    OSIntNesting  = 0;                                     /* Clear the interrupt nesting counter      */
	//清空中断嵌套标志
	//OSIntNesting是作为调度器是否可进行调度的标志，以保证调度器不会在中断服务程序中进行任务调度度器加锁器
    OSLockNesting = 0;                                     /* Clear the scheduling lock counter        */
	//清空调度锁
	//SLockNesting是用来表示嵌套层数的
#if OS_TASK_CREATE_EN  || OS_TASK_CREATE_EXT_EN || OS_TASK_DEL_EN
    OSTaskCtr     = 0;                                     /* Clear the number of tasks                */
	//清除任务的数量
	//
#endif
    OSRunning     = FALSE;                                 /* Indicate that multitasking not started   */
	//清除任务开始标志位
    OSIdleCtr     = 0L;                                    /* Clear the 32-bit idle counter            */
	//清除空闲计数
#if OS_TASK_STAT_EN && OS_TASK_CREATE_EXT_EN

    OSIdleCtrRun  = 0L;
    OSIdleCtrMax  = 0L;
    OSStatRdy     = FALSE;                                 /* Statistic task is not ready              */
	//和空闲任务有关的三个变量，初始化的时间全部清空
#endif
    OSCtxSwCtr    = 0;                                     /* Clear the context switch counter         */
	//清空切换计数
	//任务和任务之间的切换次数通过OSCtxSwCtr统计
    OSRdyGrp      = 0;        
    //清空就绪列表组                         /* Clear the ready list   
	*/
    for (i = 0; i < OS_RDY_TBL_SIZE; i++) {
        OSRdyTbl[i] = 0;
    }
     //  清空各个组中的元素   

    //以下是对TCB任务的初始化，很简单 ，自己看看就懂 
    OSPrioCur     = 0;
    OSPrioHighRdy = 0;                                           
    OSTCBHighRdy  = (OS_TCB *)0;                                 /* TCB Initialization                 */
    OSTCBCur      = (OS_TCB *)0;
    OSTCBList     = (OS_TCB *)0;
    for (i = 0; i < (OS_LOWEST_PRIO + 1); i++) {                 /* Clear the priority table           */
        OSTCBPrioTbl[i] = (OS_TCB *)0;
    }
    for (i = 0; i < (OS_MAX_TASKS + OS_N_SYS_TASKS - 1); i++) {  /* Init. list of free TCBs            */
        OSTCBTbl[i].OSTCBNext = &OSTCBTbl[i + 1];
    }
    OSTCBTbl[OS_MAX_TASKS + OS_N_SYS_TASKS - 1].OSTCBNext = (OS_TCB *)0;    /* Last OS_TCB             */
    OSTCBFreeList                                         = &OSTCBTbl[0];

#if OS_MAX_EVENTS >= 2
    for (i = 0; i < (OS_MAX_EVENTS - 1); i++) {            /* Init. list of free EVENT control blocks  */
        OSEventTbl[i].OSEventPtr = (OS_EVENT *)&OSEventTbl[i + 1];
    }
    OSEventTbl[OS_MAX_EVENTS - 1].OSEventPtr = (OS_EVENT *)0;
    OSEventFreeList                          = &OSEventTbl[0];    
#endif
    //以上是对TCB任务的初始化，很简单，一看就懂
#if OS_Q_EN && (OS_MAX_QS >= 2)
    OSQInit(); 
    //初始化队列                                        /* Initialize the message queue structures  */
											//
#endif

#if OS_MEM_EN && OS_MAX_MEM_PART >= 2
    OSMemInit();      
	//初始化内存	 									/* Initialize the memory manager            */
#endif    


//下面代码主要是根据栈的方向是向上还是向下，分别创建了两个任务：空闲任务和OSTaskStat任务
//同时OS_TASK_CREATE_EXT_EN如果使能，创建任务时可以配置的参数更多，自己看看很容易懂，累，不一一分析了。
#if OS_STK_GROWTH == 1                                        //选择栈的方向                      
    #if OS_TASK_CREATE_EXT_EN 
    OSTaskCreateExt(OSTaskIdle,                               //创建了空闲任务
                    (void *)0,                                 /* No arguments passed to OSTaskIdle()  */
                    &OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE - 1], /* Set Top-Of-Stack                     */
                    OS_IDLE_PRIO,                              /* Lowest priority level                */
                    OS_TASK_IDLE_ID,
                    &OSTaskIdleStk[0],                         /* Set Bottom-Of-Stack                  */
                    OS_TASK_IDLE_STK_SIZE, 
                    (void *)0,                                 /* No TCB extension                     */
                    OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);/* Enable stack checking + clear stack  */
    #else
    OSTaskCreate(OSTaskIdle, (void *)0, &OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE - 1], OS_IDLE_PRIO);
    #endif
#else
    #if OS_TASK_CREATE_EXT_EN
    OSTaskCreateExt(OSTaskIdle,           
                    (void *)0,                                 /* No arguments passed to OSTaskIdle()  */
                    &OSTaskIdleStk[0],                         /* Set Top-Of-Stack                     */
                    OS_IDLE_PRIO,                              /* Lowest priority level                */
                    OS_TASK_IDLE_ID,
                    &OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE - 1], /* Set Bottom-Of-Stack                  */
                    OS_TASK_IDLE_STK_SIZE, 
                    (void *)0,                                 /* No TCB extension                     */
                    OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);/* Enable stack checking + clear stack  */
    #else
    OSTaskCreate(OSTaskIdle, (void *)0, &OSTaskIdleStk[0], OS_IDLE_PRIO);
    #endif
#endif

#if OS_TASK_STAT_EN 
    #if OS_TASK_CREATE_EXT_EN
        #if OS_STK_GROWTH == 1
        OSTaskCreateExt(OSTaskStat,                               //创建了OSTaskStat任务
                        (void *)0,                                /* No args passed to OSTaskStat()    */
                        &OSTaskStatStk[OS_TASK_STAT_STK_SIZE - 1],/* Set Top-Of-Stack                  */
                        OS_STAT_PRIO,                             /* One higher than the idle task     */
                        OS_TASK_STAT_ID,
                        &OSTaskStatStk[0],                        /* Set Bottom-Of-Stack               */
                        OS_TASK_STAT_STK_SIZE, 
                        (void *)0,                                /* No TCB extension                  */
                        OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);  /* Enable stack checking + clear  */
        #else
        OSTaskCreateExt(OSTaskStat, 
                        (void *)0,                                /* No args passed to OSTaskStat()    */
                        &OSTaskStatStk[0],                        /* Set Top-Of-Stack                  */
                        OS_STAT_PRIO,                             /* One higher than the idle task     */
                        OS_TASK_STAT_ID,
                        &OSTaskStatStk[OS_TASK_STAT_STK_SIZE - 1],/* Set Bottom-Of-Stack               */
                        OS_TASK_STAT_STK_SIZE, 
                        (void *)0,                                /* No TCB extension                  */
                        OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);  /* Enable stack checking + clear  */
        #endif
    #else
        #if OS_STK_GROWTH == 1
        OSTaskCreate(OSTaskStat, 
                     (void *)0,                                   /* No args passed to OSTaskStat()    */
                     &OSTaskStatStk[OS_TASK_STAT_STK_SIZE - 1],   /* Set Top-Of-Stack                  */
                     OS_STAT_PRIO);                               /* One higher than the idle task     */
        #else
        OSTaskCreate(OSTaskStat, 
                     (void *)0,                                   /* No args passed to OSTaskStat()    */
                     &OSTaskStatStk[0],                           /* Set Top-Of-Stack                  */
                     OS_STAT_PRIO);                               /* One higher than the idle task     */
        #endif
    #endif
#endif
}
/*$PAGE*/
/*
*********************************************************************************************************
*                                              ENTER ISR
*
* Description: This function is used to notify uC/OS-II that you are about to service an interrupt
*              service routine (ISR).  This allows uC/OS-II to keep track of interrupt nesting and thus
*              only perform rescheduling at the last nested ISR.
*
* Arguments  : none
*
* Returns    : none
*
* Notes      : 1) Your ISR can directly increment OSIntNesting without calling this function because 
*                 OSIntNesting has been declared 'global'.  You MUST, however, be sure that the increment
*                 is performed 'indivisibly' by your processor to ensure proper access to this critical
*                 resource.
*              2) You MUST still call OSIntExit() even though you increment OSIntNesting directly.
*              3) You MUST invoke OSIntEnter() and OSIntExit() in pair.  In other words, for every call
*                 to OSIntEnter() at the beginning of the ISR you MUST have a call to OSIntExit() at the
*                 end of the ISR.
*********************************************************************************************************
*/
//在uC/OS-II中，通常在进入中断时需要使用OSIntEnter() ；退出中断前使用OSIntExit()；
//  这个函数的作用是对全局变量OSIntNesting增1，OSIntNesting为中断嵌套深度。
void OSIntEnter (void) reentrant
{
    OS_ENTER_CRITICAL();                        
	//进入临界段
    OSIntNesting++;                              /* Increment ISR nesting level                        */
	 //OSIntNesting为中断嵌套深度+1
    OS_EXIT_CRITICAL();
	//退出临界段
}
/*$PAGE*/
/*
*********************************************************************************************************
*                                               EXIT ISR
*
* Description: This function is used to notify uC/OS-II that you have completed serviving an ISR.  When 
*              the last nested ISR has completed, uC/OS-II will call the scheduler to determine whether
*              a new, high-priority task, is ready to run.
*
* Arguments  : none
*
* Returns    : none
*
* Notes      : 1) You MUST invoke OSIntEnter() and OSIntExit() in pair.  In other words, for every call
*                 to OSIntEnter() at the beginning of the ISR you MUST have a call to OSIntExit() at the
*                 end of the ISR.
*              2) Rescheduling is prevented when the scheduler is locked (see OSSchedLock())
*********************************************************************************************************
*/
//函数的前面部分对OSIntNesting减1，刚好与OSIntEnter() 相对应；后面部分则进行任务调度。
void OSIntExit (void) reentrant
{
    OS_ENTER_CRITICAL();
    if ((--OSIntNesting | OSLockNesting) == 0) { /* Reschedule only if all ISRs completed & not locked */
        OSIntExitY    = OSUnMapTbl[OSRdyGrp];
        OSPrioHighRdy = (INT8U)((OSIntExitY << 3) + OSUnMapTbl[OSRdyTbl[OSIntExitY]]);
        if (OSPrioHighRdy != OSPrioCur) {        /* No context switch if current task is highest ready */
            OSTCBHighRdy  = OSTCBPrioTbl[OSPrioHighRdy];
            OSCtxSwCtr++;                        /* Keep track of the number of context switches       */
            OSIntCtxSw();                        /* Perform interrupt level context switch             */
        }
    }
    OS_EXIT_CRITICAL();
}
/*$PAGE*/
/*
*********************************************************************************************************
*                                              SCHEDULER
*
* Description: This function is called by other uC/OS-II services to determine whether a new, high
*              priority task has been made ready to run.  This function is invoked by TASK level code
*              and is not used to reschedule tasks from ISRs (see OSIntExit() for ISR rescheduling).
*
* Arguments  : none
*
* Returns    : none
*
* Notes      : 1) This function is INTERNAL to uC/OS-II and your application should not call it.
*              2) Rescheduling is prevented when the scheduler is locked (see OSSchedLock())
*********************************************************************************************************
*/
//任务调度函数
void OSSched (void) reentrant
{
    INT8U y;


    OS_ENTER_CRITICAL();
	//进入临界段
    if ((OSLockNesting | OSIntNesting) == 0) {   /* Task scheduling must be enabled and not ISR level  */
	//判断没有上锁也没有中断发生
        y             = OSUnMapTbl[OSRdyGrp];    /* Get pointer to highest priority task ready to run  */
        OSPrioHighRdy = (INT8U)((y << 3) + OSUnMapTbl[OSRdyTbl[y]]);
		//查找任务优先级最高的任务
		
        if (OSPrioHighRdy != OSPrioCur) {         /* No context switch if current task is highest ready */
		//如果任务优先级最高的任务不是当前任务
            OSTCBHighRdy = OSTCBPrioTbl[OSPrioHighRdy];
			//把优先级最高的任务赋值给OSTCBHighRdy
            OSCtxSwCtr++;                        /* Increment context switch counter                   */
			//任务切换此书加一
            OS_TASK_SW();                        /* Perform a context switch                           */
			//开始进行任务切换
        }
    }
    OS_EXIT_CRITICAL();
	//退出临界段
}
/*$PAGE*/
/*
*********************************************************************************************************
*                                          PREVENT SCHEDULING
*
* Description: This function is used to prevent rescheduling to take place.  This allows your application
*              to prevent context switches until you are ready to permit context switching.
*
* Arguments  : none
*
* Returns    : none
*
* Notes      : 1) You MUST invoke OSSchedLock() and OSSchedUnlock() in pair.  In other words, for every 
*                 call to OSSchedLock() you MUST have a call to OSSchedUnlock().
*********************************************************************************************************
*/
#if OS_SCHED_LOCK_EN > 0
//这个函数又叫上锁函数，如果在一个任务里面调用了上锁函数，那么OSSched()这个任务切换函数就不会执行也就是说不会进任务调度。
void OSSchedLock (void) reentrant
{
    if (OSRunning == TRUE) {                     /* Make sure multitasking is running                  */
        OS_ENTER_CRITICAL();
        OSLockNesting++;                         /* Increment lock nesting level                       */
        OS_EXIT_CRITICAL();
    }
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
*                                          ENABLE SCHEDULING
*
* Description: This function is used to re-allow rescheduling.  
*
* Arguments  : none
*
* Returns    : none
*
* Notes      : 1) You MUST invoke OSSchedLock() and OSSchedUnlock() in pair.  In other words, for every 
*                 call to OSSchedLock() you MUST have a call to OSSchedUnlock().
*********************************************************************************************************
*/
#if OS_SCHED_LOCK_EN > 0
//解锁函数

void OSSchedUnlock (void) reentrant
{
    if (OSRunning == TRUE) {                           /* Make sure multitasking is running            */
	//判断任务是不是在执行
        OS_ENTER_CRITICAL();
		//进入临界段
        if (OSLockNesting > 0) {                       /* Do not decrement if already 0                */
		//把上锁的次数-1
            OSLockNesting--;                           /* Decrement lock nesting level                 */
            if ((OSLockNesting | OSIntNesting) == 0) { /* See if scheduling re-enabled and not an ISR  */
                OS_EXIT_CRITICAL();
				//如果没有锁了也没有中断
                OSSched();                             /* See if a higher priority task is ready       */
				//进行一次调度
            } else {
                OS_EXIT_CRITICAL();
				//退出临界段
            }
        } else {
            OS_EXIT_CRITICAL();
				//退出临界段
        }
    }
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
*                                          START MULTITASKING
*
* Description: This function is used to start the multitasking process which lets uC/OS-II manages the
*              task that you have created.  Before you can call OSStart(), you MUST have called OSInit()
*              and you MUST have created at least one task.
*
* Arguments  : none
*
* Returns    : none
*
* Note       : OSStartHighRdy() MUST:
*                 a) Call OSTaskSwHook() then,
*                 b) Set OSRunning to TRUE.
*********************************************************************************************************
*/
//功能是运行优先级最高的就绪任务，在调用OSStart()之前，用户必须先调用OSInit()，并且已经至少创建了一个任务.
void OSStart (void) reentrant
{
    INT8U y;
    INT8U x;


    if (OSRunning == FALSE) {
		//如果OSRunning不在运行
        y             = OSUnMapTbl[OSRdyGrp];        /* Find highest priority's task priority number   */
        x             = OSUnMapTbl[OSRdyTbl[y]];
        OSPrioHighRdy = (INT8U)((y << 3) + x);
		//上面三行代码是为了找到优先级最高的任务
		
		
        OSPrioCur     = OSPrioHighRdy;
		//把优先级最高的任务赋值给OSPrioCur
        OSTCBHighRdy  = OSTCBPrioTbl[OSPrioHighRdy]; /* Point to highest priority task ready to run    */
		//把优先级最高的任务赋值给OSTCBHighRdy
        OSTCBCur      = OSTCBHighRdy;
		//最高优先级的任务赋值给当前OSTCBCur
        OSStartHighRdy();                            /* Execute target specific code to start task     */
		//运行最高优先级的任务
    }
}
/*$PAGE*/
/*
*********************************************************************************************************
*                                        STATISTICS INITIALIZATION
*
* Description: This function is called by your application to establish CPU usage by first determining
*              how high a 32-bit counter would count to in 1 second if no other tasks were to execute
*              during that time.  CPU usage is then determined by a low priority task which keeps track
*              of this 32-bit counter every second but this time, with other tasks running.  CPU usage is
*              determined by:
*
*                                             OSIdleCtr
*                 CPU Usage (%) = 100 * (1 - ------------)
*                                            OSIdleCtrMax
*
* Arguments  : none
*
* Returns    : none
*********************************************************************************************************
*/

#if OS_TASK_STAT_EN
//OSStatInit()要在建立的第一个，并且只有一个任务的时候调用，所以会经常见到下面的结构：
void OSStatInit (void) reentrant
{
    OSTimeDly(2);                                /* Synchronize with clock tick                        */
    OS_ENTER_CRITICAL();
    OSIdleCtr    = 0L;                           /* Clear idle counter                                 */
    OS_EXIT_CRITICAL();
    OSTimeDly(OS_TICKS_PER_SEC);                 /* Determine MAX. idle counter value for 1 second     */
    OS_ENTER_CRITICAL();
    OSIdleCtrMax = OSIdleCtr;                    /* Store maximum idle counter count in 1 second       */
    OSStatRdy    = TRUE;   
	//这里只有OSStatRdy变为TRUE，下面的任务才能进行进行
    OS_EXIT_CRITICAL();
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
*                                              IDLE TASK
*
* Description: This task is internal to uC/OS-II and executes whenever no other higher priority tasks
*              executes because they are waiting for event(s) to occur.
*
* Arguments  : none
*
* Returns    : none
*********************************************************************************************************
*/
//上面创建了空闲任务，OSIdleCtr一直在++
void OSTaskIdle (void *ppdata) reentrant
{
    ppdata = ppdata;                               /* Prevent compiler warning for not using 'pdata'     */
    for (;;) {
        OS_ENTER_CRITICAL();
        OSIdleCtr++;
        OS_EXIT_CRITICAL();
    }
}
/*$PAGE*/
/*
*********************************************************************************************************
*                                            STATISTICS TASK
*
* Description: This task is internal to uC/OS-II and is used to compute some statistics about the
*              multitasking environment.  Specifically, OSTaskStat() computes the CPU usage.
*              CPU usage is determined by:
*
*                                          OSIdleCtr
*                 OSCPUUsage = 100 * (1 - ------------)     (units are in %)
*                                         OSIdleCtrMax
*
* Arguments  : pdata     this pointer is not used at this time.
*
* Returns    : none
*
* Notes      : 1) This task runs at a priority level higher than the idle task.  In fact, it runs at the
*                 next higher priority, OS_IDLE_PRIO-1.
*              2) You can disable this task by setting the configuration #define OS_TASK_STAT_EN to 0.
*              3) We delay for 5 seconds in the beginning to allow the system to reach steady state and
*                 have all other tasks created before we do statistics.  You MUST have at least a delay
*                 of 2 seconds to allow for the system to establish the maximum value for the idle 
*                 counter.
*********************************************************************************************************
*/

#if OS_TASK_STAT_EN
//在上面我们创建了一个OSTaskStat任务，这里是OSTaskStat任务的具体实现代码。

void OSTaskStat (void *ppdata) reentrant
{
    INT32U run;
    INT8S  usage;
    
    
    ppdata = ppdata;                               /* Prevent compiler warning for not using 'pdata'     */
	//防止编译器抽风
    while (OSStatRdy == FALSE) {
        OSTimeDly(2 * OS_TICKS_PER_SEC);             /* Wait until statistic task is ready                 */
    }
	//如果任务没有准备好，就等待延时
    for (;;) {
        OS_ENTER_CRITICAL();
		//进入临界段
        OSIdleCtrRun = OSIdleCtr;                /* Obtain the of the idle counter for the past second */
		//空闲计数的值，在OSTaskIdle任务中会不断+1
        run          = OSIdleCtr;
		//空闲计数的值，在OSTaskIdle任务中会不断+1
        OSIdleCtr    = 0L;                       /* Reset the idle counter for the next second         */
		//把OSIdleCtr变为0，一秒清空一次
        OS_EXIT_CRITICAL();
		//退出临界段
        if (OSIdleCtrMax > 0L) {
            usage = (INT8S)(100L - 100L * run / OSIdleCtrMax);
			//计算使用率
            if (usage > 100) {
                OSCPUUsage = 100;
            } else if (usage < 0) {
                OSCPUUsage =   0;
            } else {
                OSCPUUsage = usage;
            }
        } else {
            OSCPUUsage = 0;
        }
        OSTaskStatHook();                        /* Invoke user definable hook                         */
		//如果编写了钩子函数，运行钩子函数
        OSTimeDly(OS_TICKS_PER_SEC);             /* Accumulate OSIdleCtr for the next second           */
		//延时一下
    }
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
*                                            INITIALIZE TCB
*
* Description: This function is internal to uC/OS-II and is used to initialize a Task Control Block when
*              a task is created (see OSTaskCreate() and OSTaskCreateExt()).
*
* Arguments  : prio          is the priority of the task being created
*
*              ptos          is a pointer to the task's top-of-stack assuming that the CPU registers
*                            have been placed on the stack.  Note that the top-of-stack corresponds to a 
*                            'high' memory location is OS_STK_GROWTH is set to 1 and a 'low' memory
*                            location if OS_STK_GROWTH is set to 0.  Note that stack growth is CPU
*                            specific.
*
*              pbos          is a pointer to the bottom of stack.  A NULL pointer is passed if called by
*                            'OSTaskCreate()'.
*
*              id            is the task's ID (0..65535)
*
*              stk_size      is the size of the stack (in 'stack units').  If the stack units are INT8Us
*                            then, 'stk_size' contains the number of bytes for the stack.  If the stack
*                            units are INT32Us then, the stack contains '4 * stk_size' bytes.  The stack
*                            units are established by the #define constant OS_STK which is CPU
*                            specific.  'stk_size' is 0 if called by 'OSTaskCreate()'.
*
*              pext          is a pointer to a user supplied memory area that is used to extend the task
*                            control block.  This allows you to store the contents of floating-point
*                            registers, MMU registers or anything else you could find useful during a 
*                            context switch.  You can even assign a name to each task and store this name
*                            in this TCB extension.  A NULL pointer is passed if called by OSTaskCreate().
*
*              opt           options as passed to 'OSTaskCreateExt()' or, 
*                            0 if called from 'OSTaskCreate()'.
*
* Returns    : OS_NO_ERR         if the call was successful
*              OS_NO_MORE_TCB    if there are no more free TCBs to be allocated and thus, the task cannot
*                                be created.
*
* Note       : This function is INTERNAL to uC/OS-II and your application should not call it.
*********************************************************************************************************
*/

INT8U OSTCBInit (INT8U prio, OS_STK *ptos, OS_STK *pbos, INT16U id, INT16U stk_size, void *pext, INT16U opt) reentrant
{
    OS_TCB *ptcb;


    OS_ENTER_CRITICAL();
	//进入临界段
    ptcb = OSTCBFreeList;                                  /* Get a free TCB from the free TCB list    */
	//指针指向一个空的TCB块
    if (ptcb != (OS_TCB *)0) {
		
	   //以下为对TCB块进行的各种赋值操作，太多了，不写了。自己看。一看就懂
	
        OSTCBFreeList        = ptcb->OSTCBNext;            /* Update pointer to free TCB list          */
        OS_EXIT_CRITICAL();
        ptcb->OSTCBStkPtr    = ptos;                       /* Load Stack pointer in TCB                */
        ptcb->OSTCBPrio      = (INT8U)prio;                /* Load task priority into TCB              */
        ptcb->OSTCBStat      = OS_STAT_RDY;                /* Task is ready to run                     */
        ptcb->OSTCBDly       = 0;                          /* Task is not delayed                      */

#if OS_TASK_CREATE_EXT_EN        
        ptcb->OSTCBExtPtr    = pext;                       /* Store pointer to TCB extension           */
        ptcb->OSTCBStkSize   = stk_size;                   /* Store stack size                         */
        ptcb->OSTCBStkBottom = pbos;                       /* Store pointer to bottom of stack         */
        ptcb->OSTCBOpt       = opt;                        /* Store task options                       */
        ptcb->OSTCBId        = id;                         /* Store task ID                            */
#else
        pext                 = pext;                       /* Prevent compiler warning if not used     */
        stk_size             = stk_size;
        pbos                 = pbos;
        opt                  = opt;
        id                   = id;
#endif

#if OS_TASK_DEL_EN        
        ptcb->OSTCBDelReq    = OS_NO_ERR;
		
		
		
#endifzh

        ptcb->OSTCBY         = prio >> 3;                  /* Pre-compute X, Y, BitX and BitY          */
        ptcb->OSTCBBitY      = OSMapTbl[ptcb->OSTCBY];
        ptcb->OSTCBX         = prio & 0x07;
        ptcb->OSTCBBitX      = OSMapTbl[ptcb->OSTCBX];

#if     OS_MBOX_EN || (OS_Q_EN && (OS_MAX_QS >= 2)) || OS_SEM_EN
        ptcb->OSTCBEventPtr  = (OS_EVENT *)0;              /* Task is not pending on an event          */
#endif

#if     OS_MBOX_EN || (OS_Q_EN && (OS_MAX_QS >= 2))
        ptcb->OSTCBMsg       = (void *)0;                  /* No message received                      */
#endif

        OS_ENTER_CRITICAL();
        OSTCBPrioTbl[prio]   = ptcb;
        ptcb->OSTCBNext      = OSTCBList;                  /* Link into TCB chain                      */
        ptcb->OSTCBPrev      = (OS_TCB *)0;
        if (OSTCBList != (OS_TCB *)0) {
            OSTCBList->OSTCBPrev = ptcb;
        }
        OSTCBList               = ptcb;
        OSRdyGrp               |= ptcb->OSTCBBitY;         /* Make task ready to run                   */
        OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
		
		//以上为对TCB块进行的各种赋值操作，太多了，不写了。自己看。一看就懂
		
		
        OS_EXIT_CRITICAL();
		//退出临界段
        return (OS_NO_ERR);
    } else {
        OS_EXIT_CRITICAL();
		//退出临界段
        return (OS_NO_MORE_TCB);
    }
}
/*$PAGE*/
/*
*********************************************************************************************************
*                                         PROCESS SYSTEM TICK
*
* Description: This function is used to signal to uC/OS-II the occurrence of a 'system tick' (also known
*              as a 'clock tick').  This function should be called by the ticker ISR but, can also be
*              called by a high priority task.
*
* Arguments  : none
*
* Returns    : none
*********************************************************************************************************
*/
//这个节拍服务函数是在OSTickISR函数中调用的，目的是在时钟节拍到来时，
//检查每个任务的任务控制块中的.
//OSTCBDly-1后是否为0，如果是，那么表明这个任务刚才是挂起的状态，此时应改变为就绪态
void OSTimeTick (void) reentrant
{
    OS_TCB *ptcb;


//**OSTimeTickHook();                                      /* Call user definable hook                 */
    ptcb = OSTCBList;                                      /* Point at first TCB in TCB list           */
	//指针指向第一个TCB块
    while (ptcb->OSTCBPrio != OS_IDLE_PRIO) {              /* Go through all TCBs in TCB list          */
	//判断优先级是不是空闲任务的优先级
        OS_ENTER_CRITICAL();
		//进入临界段
        if (ptcb->OSTCBDly != 0) {                         /* Delayed or waiting for event with TO     */
		//判断ptcb->OSTCBDly是否等于0
            if (--ptcb->OSTCBDly == 0) {                   /* Decrement nbr of ticks to end of delay   */
			//OSTCBDly-1后是否为0，如果是，那么表明这个任务刚才是挂起的状态，此时应改变为就绪态
			
                if (!(ptcb->OSTCBStat & OS_STAT_SUSPEND)) {    /* Is task suspended?                   */
                    OSRdyGrp               |= ptcb->OSTCBBitY; /* No,  Make task Rdy to Run (timed out)*/
                    OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
					//如果状态是挂起，把这个任务添加到就绪列表
                } else {                                       /* Yes, Leave 1 tick to prevent ...     */
                    ptcb->OSTCBDly = 1;                        /* ... loosing the task when the ...    */
					//接着等
                }                                              /* ... suspension is removed.           */
				
            }
        }
        ptcb = ptcb->OSTCBNext;                            /* Point at next TCB in TCB list            */
		//指向下一个TCB块
        OS_EXIT_CRITICAL();
		//退出临界段
    }
    OS_ENTER_CRITICAL();                                   /* Update the 32-bit tick counter           */
	//进入临界段
    OSTime++;
	//OSTime+1
    OS_EXIT_CRITICAL();
	//退出临界段
}
/*$PAGE*/
/*
*********************************************************************************************************
*                                             GET VERSION
*
* Description: This function is used to return the version number of uC/OS-II.  The returned value
*              corresponds to uC/OS-II's version number multiplied by 100.  In other words, version 2.00
*              would be returned as 200.
*
* Arguments  : none
*
* Returns    : the version number of uC/OS-II multiplied by 100.
*********************************************************************************************************
*/
#if OS_VERSION_EN
//ucos 版本信息
INT16U OSVersion (void) reentrant
{
    return (OS_VERSION);
}
#endif