uc/os源码分析

 

作者：洞庭散人

出处：http://phinecos.cnblogs.com/　　

uC/OS-II源码分析（一）

下载地址：http://www.micrium.com/

它的特点：

1）开源，

2)可移植性，绝大部分代码用C写，硬件相关部分用汇编写，

3可固化，

4）可剪裁，这通过条件编译实现，使用#define语句定义所需要的功能。

5）可剥夺性（总是运行就绪条件下优先级最高的任务），

6）多任务（可以管理64个任务，其中保留8个给uC/OS-II，因此用户最多可有56个任务，每个任务优先级不同，也就意味着不支持时间片轮转调度法，因为这种方法适合于优先级平等的任务）。

7）可确定性。函数调度和服务执行时间具有确定性，除了OSTimeTick()和某些事件标志服务，系统服务执行时间不依赖用户应用程序任务数目的多少。

8）任务栈。允许每个任务自己单独的栈空间不同，可以使用栈空间检验函数确定所需要的栈空间大小。

9）系统服务。提供信号量，互斥型信号量，事件标志，消息邮箱，消息队列，块大小固定的内存申请与释放，时间管理函数等服务。

10）中断管理。中断嵌套层数最多可达到255层。

11）稳定性和可靠性。

OSInit()函数用来初始化内核，必须首先调用。建立两个任务：空闲任务（其他任务都未就绪时运行），统计任务（计算CPU的利用率）.

*****************************************************************

* 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().

*****************************************************************

OSInit
void  OSInit (void)
{
    OSInitHookBegin();                                           /* 调用用户特定的初始化代码（通过一个接口函数实现用户要求的插件式进入系统中）*/
    OS_InitMisc();                                               /* 初始化变量*/
    OS_InitRdyList();                                            /* 初始化就绪列表*/
    OS_InitTCBList();                                            /* 初始化OS_TCB空闲列表*/
    OS_InitEventList();                                          /* 初始化OS_EVENT空闲列表*/
#if (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0)                        //允许事件标志
    OS_FlagInit();                                               /* 初始化事件标志结构*/
#endif
#if (OS_MEM_EN > 0) && (OS_MAX_MEM_PART > 0)                    //允许内存管理
    OS_MemInit();                                                /* 初始化内存管理器*/
#endif
#if (OS_Q_EN > 0) && (OS_MAX_QS > 0)                            //允许消息队列
    OS_QInit();                                                  /* 初始化消息队列结构*/
#endif
    OS_InitTaskIdle();                                           /*创建空闲任务*/
#if OS_TASK_STAT_EN > 0
    OS_InitTaskStat();                                           /* 创建统计任务*/
#endif
#if OS_TMR_EN > 0                                                //允许时间管理
    OSTmr_Init();                                                /* 初始化时间管理器*/
#endif
    OSInitHookEnd();                                             /*调用用户特定的初始化代码（参考OSInitHookBegin（））*/

#if OS_DEBUG_EN > 0                                                //允许Debug
    OSDebugInit();                                                //初始化调试器
#endif    
}

********************************************************************************************

* Description: This function is called by OSInit() to initialize miscellaneous variables.

********************************************************************************************

OS_InitMisc
static  void  OS_InitMisc (void)
{
#if OS_TIME_GET_SET_EN > 0
    OSTime        = 0L;                                    /* 32位的系统时钟清零*/
#endif
    OSIntNesting  = 0;                                     /* 中断嵌套层数计数器清零*/
    OSLockNesting = 0;                                     /* 调度器锁的嵌套层数计数器清零*/
    OSTaskCtr     = 0;                                     /* 任务数清零*/
    OSRunning     = OS_FALSE;                              /*指明多任务未开始*/
    OSCtxSwCtr    = 0;                                     /* 任务切换次数计数器清零*/
    OSIdleCtr     = 0L;                                    /*32位空闲计数器清零*/
#if OS_TASK_STAT_EN > 0                                      /*运行统计任务*/
    OSIdleCtrRun  = 0L;
    OSIdleCtrMax  = 0L;
    OSStatRdy     = OS_FALSE;                              /* 统计任务未就绪*/
#endif
}

 

空闲任务和统计任务建立的代码基本一样，只是统计任务的优先级比空闲任务大1，

********************************************************************************************

* Description: This function creates the Idle Task.

********************************************************************************************

CodeOS_InitTaskIdle
static  void  OS_InitTaskIdle (void)
{
#if OS_TASK_NAME_SIZE > 7 //
    INT8U  err;
#endif
#if OS_TASK_CREATE_EXT_EN > 0    //使用扩展的OSTaskCreateExt来创建
#if OS_STK_GROWTH == 1    //任务堆栈从底部向顶部增长的方向有两种：表示从大到小，表示从小到大
    (void)OSTaskCreateExt(OS_TaskIdle,
        (void *)0,                                 /* 没有参数传给OS_TaskIdle() */
        &OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE - 1], /*设置堆栈顶*/
        OS_TASK_IDLE_PRIO,                         /* 优先级设置为最低*/
        OS_TASK_IDLE_ID,                          //设置ID
        &OSTaskIdleStk[0],                         /* 设置栈底*/
        OS_TASK_IDLE_STK_SIZE,                      //设置栈大小
        (void *)0,                                 /* 没有TCB扩展数据结构                 
        OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);/* 允许堆栈检测和清空堆栈*/
#else
    (void)OSTaskCreateExt(OS_TaskIdle,
        (void *)0,                                 /* No arguments passed to OS_TaskIdle() */
        &OSTaskIdleStk[0],                         /* Set Top-Of-Stack                     
        OS_TASK_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  */
#endif
#else    //使用不带扩展性的OSTaskCreate创建
#if OS_STK_GROWTH == 1
    (void)OSTaskCreate(OS_TaskIdle,
        (void *)0,
        &OSTaskIdleStk[OS_TASK_IDLE_STK_SIZE - 1],
        OS_TASK_IDLE_PRIO);
#else
    (void)OSTaskCreate(OS_TaskIdle,
        (void *)0,
        &OSTaskIdleStk[0],
        OS_TASK_IDLE_PRIO);
#endif
#endif
//设置任务名称
#if OS_TASK_NAME_SIZE > 14
    OSTaskNameSet(OS_TASK_IDLE_PRIO, (INT8U *)"uC/OS-II Idle", &err);
#else
#if OS_TASK_NAME_SIZE > 7
    OSTaskNameSet(OS_TASK_IDLE_PRIO, (INT8U *)"OS-Idle", &err);
#endif
#endif
}

 

其他初始化代码放到后面具体的每一个子模块中再分析。

uC/OS-II源码分析（二）

在真正开始分析源代码前，先来看使用uC/OS-II的三个例子

1）使用信号量

#define  TASK_STK_SIZE                 512       /* 每个任务堆栈的大小(以字计算)*/
#define  N_TASKS                        10       /* 任务数*/

OS_STK        TaskStk[N_TASKS][TASK_STK_SIZE];        /*任务堆栈*/
OS_STK        TaskStartStk[TASK_STK_SIZE];            //开始任务的堆栈    
char          TaskData[N_TASKS];                      /*传给每个任务的数据*/
OS_EVENT     *RandomSem;                            //互斥型信号量

void  main (void)
{
    PC_DispClrScr(DISP_FGND_WHITE + DISP_BGND_BLACK);      /*清空屏幕*/

    OSInit();                                              /* 初始化uC/OS-II*/

    PC_DOSSaveReturn();                                    /* 保存环境以便稍后可以返回DOS环境*/
    PC_VectSet(uCOS, OSCtxSw);                             /*设置uC/OS-II的切换处理函数*/
    RandomSem   = OSSemCreate(1);                          /* 建立一个信号量*/
    OSTaskCreate(TaskStart, (void *)0, &TaskStartStk[TASK_STK_SIZE - 1], 0);//创建第一个任务，优先级设置为最大值
    OSStart();                                             /* 开始多任务*/
}
void  TaskStart (void *pdata)
{
#if OS_CRITICAL_METHOD == 3                                /* 为CPU的状态寄存器分配内存*/
    OS_CPU_SR  cpu_sr;
#endif
    char       s[100];
    INT16S     key;
    pdata = pdata;                                         /* 这步是为了防止编译错误*/
    TaskStartDispInit();                                   /* 初始化显示屏*/
    OS_ENTER_CRITICAL();
    PC_VectSet(0x08, OSTickISR);                           /*替换机器的时钟中断函数为uC/OS-II所需要的中断函数*/
    PC_SetTickRate(OS_TICKS_PER_SEC);                      /* 调整时钟频率*/
    OS_EXIT_CRITICAL();
    OSStatInit();                                          /* 初始化统计任务*/
    TaskStartCreateTasks();                                /*创建其他任务*/
    for (;;) {
        TaskStartDisp();                                


        if (PC_GetKey(&key) == TRUE) {                     /* 是否按键*/
            if (key == 0x1B) {                             /* ESCAPE按下了*/
                PC_DOSReturn();                            /* 返回DOS*/
            }
        }

        OSCtxSwCtr = 0;                                    /* 切换次数计数器清零*/
        OSTimeDlyHMSM(0, 0, 1, 0);                         /*挂起秒,让给其他任务运行*/
    }
}
static  void  TaskStartCreateTasks (void)
{
    INT8U  i;
    for (i = 0; i < N_TASKS; i++) {                        /* 创建N_TASKS个任务*/
        TaskData[i] = '0' + i;                             /* 每个任务显示其数据*/
        OSTaskCreate(Task, (void *)&TaskData[i], &TaskStk[i][TASK_STK_SIZE - 1], i + 1);
    }
}

void  Task (void *pdata)
{
    INT8U  x;
    INT8U  y;
    INT8U  err;
    for (;;) {
        OSSemPend(RandomSem, 0, &err);           /* 获取信号量*/
        x = random(80);                          /* 计算X坐标*/
        y = random(16);                          /* 计算Y坐标*/
        OSSemPost(RandomSem);                    /* 释放信号量*/
        /* Display the task number on the screen              */
        PC_DispChar(x, y + 5, *(char *)pdata, DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
        OSTimeDly(1);                            /* 挂起秒，让给其他任务运行*/
    }
}

 

2）使用消息邮箱

#define          TASK_STK_SIZE     512               
#define          TASK_START_ID       0                /* 任务ID*/
#define          TASK_CLK_ID         1
#define          TASK_1_ID           2
#define          TASK_2_ID           3
#define          TASK_3_ID           4
#define          TASK_4_ID           5
#define          TASK_5_ID           6

#define          TASK_START_PRIO    10                /* 任务优先级*/
#define          TASK_CLK_PRIO      11
#define          TASK_1_PRIO        12
#define          TASK_2_PRIO        13
#define          TASK_3_PRIO        14
#define          TASK_4_PRIO        15
#define          TASK_5_PRIO        16
OS_STK        TaskStartStk[TASK_STK_SIZE];            
OS_STK        TaskClkStk[TASK_STK_SIZE];             
OS_STK        Task1Stk[TASK_STK_SIZE];                
OS_STK        Task2Stk[TASK_STK_SIZE];                
OS_STK        Task3Stk[TASK_STK_SIZE];               
OS_STK        Task4Stk[TASK_STK_SIZE];              
OS_STK        Task5Stk[TASK_STK_SIZE];               
OS_EVENT     *AckMbox;                                /* 任务和使用的消息邮箱*/
OS_EVENT     *TxMbox;

void main (void)
{
    OS_STK *ptos;
    OS_STK *pbos;
    INT32U  size;
    PC_DispClrScr(DISP_FGND_WHITE);                       
    OSInit();                                            
    PC_DOSSaveReturn();                                  
    PC_VectSet(uCOS, OSCtxSw);                            
    PC_ElapsedInit();                                     
    ptos        = &TaskStartStk[TASK_STK_SIZE - 1];        
    pbos        = &TaskStartStk[0];
    size        = TASK_STK_SIZE;
    OSTaskStkInit_FPE_x86(&ptos, &pbos, &size);            
    OSTaskCreateExt(TaskStart,
        (void *)0,
        ptos,
        TASK_START_PRIO,
        TASK_START_ID,
        pbos,
        size,
        (void *)0,
        OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);
    OSStart();                                             
}
void  TaskStart (void *pdata)
{
#if OS_CRITICAL_METHOD == 3                               
    OS_CPU_SR  cpu_sr;
#endif
    INT16S     key;
    pdata = pdata;                                       
    TaskStartDispInit();                                
    OS_ENTER_CRITICAL();                                
    PC_VectSet(0x08, OSTickISR);
    PC_SetTickRate(OS_TICKS_PER_SEC);                    
    OS_EXIT_CRITICAL();
    OSStatInit();                                          
    AckMbox = OSMboxCreate((void *)0);                     /* 创建两个消息邮箱*/
    TxMbox  = OSMboxCreate((void *)0);
    TaskStartCreateTasks();                               
    for (;;) {
        TaskStartDisp();                                 

        if (PC_GetKey(&key)) {                           
            if (key == 0x1B) {                            
                PC_DOSReturn();                           
            }
        }
        OSCtxSwCtr = 0;                                    
        OSTimeDly(OS_TICKS_PER_SEC);                      
    }
}
void  Task1 (void *pdata)
{
    INT8U       err;
    OS_STK_DATA data;                       /* 任务堆栈数据*/
    INT16U      time;                      
    INT8U       i;
    char        s[80];
    pdata = pdata;
    for (;;) {
        for (i = 0; i < 7; i++) {
            PC_ElapsedStart();
            err  = OSTaskStkChk(TASK_START_PRIO + i, &data);//执行堆栈检查
            time = PC_ElapsedStop();
            if (err == OS_NO_ERR) {
                sprintf(s, "%4ld        %4ld        %4ld        %6d",
                    data.OSFree + data.OSUsed,
                    data.OSFree,
                    data.OSUsed,
                    time);
                PC_DispStr(19, 12 + i, s, DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
            }
        }
        OSTimeDlyHMSM(0, 0, 0, 100);                       /* 挂起mS*/
    }
}
void  Task4 (void *data)
{
    char   txmsg;
    INT8U  err;
    data  = data;
    txmsg = 'A';
    for (;;) {
        OSMboxPost(TxMbox, (void *)&txmsg);      /* 发消息给Task #5*/
        OSMboxPend(AckMbox, 0, &err);            /* 等待Task #5的应答消息*/
        txmsg++;                                 /*下一个要发的消息数据*/
        if (txmsg == 'Z') {
            txmsg = 'A';                         /* 循环发送A-Z*/
        }
    }
}
void  Task5 (void *data)
{
    char  *rxmsg;
    INT8U  err;
    data = data;
    for (;;) {
        rxmsg = (char *)OSMboxPend(TxMbox, 0, &err); /* 等待来自Task #4的数据*/
        PC_DispChar(70, 18, *rxmsg, DISP_FGND_YELLOW + DISP_BGND_BLUE);
        OSTimeDlyHMSM(0, 0, 1, 0); /* 挂起秒，让给其他任务运行*/
        OSMboxPost(AckMbox, (void *)1); /*发送接收到数据的应答消息*/
    }
}

 

运行结果：

3）使用消息队列

#define          TASK_STK_SIZE     512               
#define          TASK_START_ID       0               
#define          TASK_CLK_ID         1
#define          TASK_1_ID           2
#define          TASK_2_ID           3
#define          TASK_3_ID           4
#define          TASK_4_ID           5
#define          TASK_5_ID           6
#define          TASK_START_PRIO    10               
#define          TASK_CLK_PRIO      11
#define          TASK_1_PRIO        12
#define          TASK_2_PRIO        13
#define          TASK_3_PRIO        14
#define          TASK_4_PRIO        15
#define          TASK_5_PRIO        16
#define          MSG_QUEUE_SIZE     20                /* 消息队列大小*/
typedef struct {
    char    TaskName[30];
    INT16U  TaskCtr;
    INT16U  TaskExecTime;
    INT32U  TaskTotExecTime;
} TASK_USER_DATA;
OS_STK          TaskStartStk[TASK_STK_SIZE];         
OS_STK          TaskClkStk[TASK_STK_SIZE];            
OS_STK          Task1Stk[TASK_STK_SIZE];              
OS_STK          Task2Stk[TASK_STK_SIZE];            
OS_STK          Task3Stk[TASK_STK_SIZE];             
OS_STK          Task4Stk[TASK_STK_SIZE];            
OS_STK          Task5Stk[TASK_STK_SIZE];             
TASK_USER_DATA  TaskUserData[7];
OS_EVENT       *MsgQueue;                             /*消息队列指针*/
void           *MsgQueueTbl[20];                      /*消息存储*/
void  main (void)
{
    PC_DispClrScr(DISP_BGND_BLACK);                        
    OSInit();                                            
    PC_DOSSaveReturn();                                    
    PC_VectSet(uCOS, OSCtxSw);                            
    PC_ElapsedInit();                                      
    strcpy(TaskUserData[TASK_START_ID].TaskName, "StartTask");
    OSTaskCreateExt(TaskStart,
        (void *)0,
        &TaskStartStk[TASK_STK_SIZE - 1],
        TASK_START_PRIO,
        TASK_START_ID,
        &TaskStartStk[0],
        TASK_STK_SIZE,
        &TaskUserData[TASK_START_ID],
        0);
    OSStart();                                          
}
void  TaskStart (void *pdata)
{
#if OS_CRITICAL_METHOD == 3                                
    OS_CPU_SR  cpu_sr;
#endif
    INT16S     key;
    pdata = pdata;                                      
    TaskStartDispInit();                                
    OS_ENTER_CRITICAL();                                  
    PC_VectSet(0x08, OSTickISR);
    PC_SetTickRate(OS_TICKS_PER_SEC);                    
    OS_EXIT_CRITICAL();
    OSStatInit();                                         
    MsgQueue = OSQCreate(&MsgQueueTbl[0], MSG_QUEUE_SIZE); /*创建消息队列，大小为*/
    TaskStartCreateTasks();
    for (;;) {
        TaskStartDisp();                               
        if (PC_GetKey(&key)) {                           
            if (key == 0x1B) {                         
                PC_DOSReturn();                         
            }
        }
        OSCtxSwCtr = 0;                                   
        OSTimeDly(OS_TICKS_PER_SEC);                      
    }
}
void  Task1 (void *pdata)
{
    char  *msg;
    INT8U  err;
    pdata = pdata;
    for (;;) {
        msg = (char *)OSQPend(MsgQueue, 0, &err);//从消息队列中取消息
        PC_DispStr(70, 13, msg, DISP_FGND_YELLOW + DISP_BGND_BLUE);
        OSTimeDlyHMSM(0, 0, 0, 100);
    }
}
void  Task2 (void *pdata)
{
    char  msg[20];
    pdata = pdata;
    strcpy(&msg[0], "Task 2");
    for (;;) {
        OSQPost(MsgQueue, (void *)&msg[0]);//发送消息到队列中
        OSTimeDlyHMSM(0, 0, 0, 500);
    }
}
void  Task3 (void *pdata)
{
    char  msg[20];
    pdata = pdata;
    strcpy(&msg[0], "Task 3");
    for (;;) {
        OSQPost(MsgQueue, (void *)&msg[0]);//发送消息到队列中
        OSTimeDlyHMSM(0, 0, 0, 500);
    }
}
void  Task4 (void *pdata)
{
    char  msg[20];
    pdata = pdata;
    strcpy(&msg[0], "Task 4");
    for (;;) {
        OSQPost(MsgQueue, (void *)&msg[0]);//发送消息到队列中
        OSTimeDlyHMSM(0, 0, 0, 500);
    }
}
void  OSTaskStatHook (void)
{
    char    s[80];
    INT8U   i;
    INT32U  total;
    INT8U   pct;
    total = 0L;                                          /* Totalize TOT. EXEC. TIME for each task 
    for (i = 0; i < 7; i++) {
        total += TaskUserData[i].TaskTotExecTime;
        DispTaskStat(i);                                 /* Display task data                      
    }
    if (total > 0) {
        for (i = 0; i < 7; i++) {                        /* Derive percentage of each task         */
            pct = 100 * TaskUserData[i].TaskTotExecTime / total;
            sprintf(s, "%3d %%", pct);
            PC_DispStr(62, i + 11, s, DISP_FGND_BLACK + DISP_BGND_LIGHT_GRAY);
        }
    }
    if (total > 1000000000L) {                           /* Reset total time counters at 1 billion 
        for (i = 0; i < 7; i++) {
            TaskUserData[i].TaskTotExecTime = 0L;
        }
    }
}

void  OSTaskSwHook (void)
{
    INT16U           time;
    TASK_USER_DATA  *puser;
    time  = PC_ElapsedStop();                    /* This task is done                                  
    PC_ElapsedStart();                           /* Start for next task                                
    puser = OSTCBCur->OSTCBExtPtr;               /* Point to used data                                 
    if (puser != (TASK_USER_DATA *)0) {
        puser->TaskCtr++;                        /* Increment task counter                             
        puser->TaskExecTime     = time;          /* Update the task's execution time                   
        puser->TaskTotExecTime += time;          /* Update the task's total execution time             
    }
}

 

运行结果：

uC/OS-II源码分析（三）

首先来了解下实时系统的基本概念：

1） 临界区，共享资源，任务（类似于进程），任务切换，任务调度，可剥夺型内核，可重入函数，动态优先级调度，

2） 如何处理优先级反转问题。这个问题描述如下：有三个任务，优先级1高于2，2高于3，一开始1和2处于挂起，3在运行，3要使用某个共享资源，就P它的互斥信号量，3得到信号量后开始使用这个共享资源。过一段时间后，1等待的事件发生后剥夺了3的CPU使用权，于是1开始运行。运行时，1也要用3占到的那个资源，所以1只好进入挂起状态，等待3释放这个资源。于是这时3准备继续运行，但这时2等待的事件也发生了，所以2抢占了3的CPU使用权，等2运行完后把CPU还给3，3继续运行，直到释放资源的信号量。这时1才能得以运行。这个过程中，1的优先级实际上降到了3的水平。

处理的方法描述如下：在1第一次抢占3的CPU时，1去申请资源信号量,但内核知道这个信号量被3占了，而3的优先级比1低，于是内核把3的优先级升至与1相同。内核将1放入等待资源信号量的任务列表，然后回到3继续运行。等3完成后释放资源信号量，这时内核恢复任务3本来的优先级，并查看等待该资源信号量的任务列表里有谁在等待这个信号量，这时有1，所以把信号量交给1，于是1得以运行。等1运行完后，2才能开始运行。但uC/OS-II不支持优先级继承，这个功能是可以使内核自动变换任务的优先级。

3） 处理互斥：开关中断（uC/OS-II中用OS_ENTER_CRITICAL和OS_EXTI_CRITICAL来实现），测试并置位，禁止/运行任务切换，互斥信号量，计数型信号量，

4） 同步：信号量，事件标志(任务与多个事件同步，若任务需要与任何事件之一发生同步，叫独立型同步，若任务与若干事件都发生同步，叫关联型同步)。

5） 任务间通信：消息邮箱，消息队列，中断，

uC/OS-II源码分析（四）

内核结构

1，  临界区，OS_ENTER_CRITICAL和OS_EXIT_CRITICAL

为了处理临界区代码，必须关中断，等处理完毕后，再开中断。关中断可以避免其他任务或中断进入临界区代码。uC/OS-II定义了这两个宏来实现，但注意一条：调用uC/OS-II功能函数时，中断应该总是开着的。

      1）当OS_CRITICAL_METHOD= = 1时，简单实现如下：

    #define OS_ENTER_CRITICAL() disable_int() 
    # define OS_EXIT_CRITICAL() enable_int()

 

但这样有一个问题，如果禁止中断的情况下调用uC/OS-II功能函数，那么从功能函数返回时，中断可能变成允许的了，而实际上还是希望是禁止的。

      2）当OS_CRITICAL_METHOD= = 2时，实现如下：

    #define OS_ENTER_CRITICAL()    
            asm(“PUSH PSW”);
            asm(“DI”);
    #define OS_EXIT_CRITICAL()
            asm(“POP PSW”);

执行OS_ENTER_CRITICAL()时，先将中断状态保存到堆栈，然后关中断；执行OS_EXIT_CRITICAL()时，再从堆栈中恢复原来的中断开/关状态。这种方法不会改变中断状态，避免前面的问题。

      3）当OS_CRITICAL_METHOD= = 3时，实现如下：

    #define OS_ENTER_CRITICAL()    
        cpu_sr = get_processor_psw();
        disable_interrupts();
    #define OS_EXIT_CRITICAL()
        set_ processor_psw(cpu_sr);

      将处理器状态字保存在局部变量中。

2，  任务是一个无限循环，返回类型为void,参数void*,用于传数据给任务。任务可以调用OSTaskDel(OS_PRIO_SELF)进行自我删除。任务有5种状态：

1)     睡眠态。任务驻留在程序空间（ROM或RAM）,还未交给uC/OS-II来管理。

2)     就绪态。OSTaskCreate()或OSTaskCreateExt()来创建一个任务后，就进入就绪态。任务可以调用OSTaskDel返回到睡眠态，或调用该函数让另一个任务进入睡眠态。

3)     运行态。OSStart()启动多任务运行。它只在启动时调用一次，运行就绪列表中优先级最高的任务。就绪的任务只有当所以优先级比其高的任务转为等待状态，或者是被删除了，才能进入运行态。

4)     等待状态。正在运行的任务可以调用OSTimeDly()或OSTimeDlyHMSM()将自身延迟一段时间进入等待状态，一直到延迟时间到来。这两个函数会强制执行任务切换，选择下一个优先级最高的任务运行。等待时间过去后，系统服务函数OSTimeTick（）使延迟了的任务进入就绪态。

正在运行的任务也可能需要等待某一事件的发生，可以调用：OSFlagPend(),OSSemPend(),OSMutexPend(),OSMboxPend(),OSQPend()等函数。若某事件未发生，则任务进入等待状态，直到事件发生。当任务因等待事件被挂起时，下一个优先级最高的任务得到CPU。当事件发生了或超时，被挂起的任务进入就绪态。事件发生的报告可能来自另一个任务或中断服务子程序。

5)     中断服务态 。被中断的任务进入中断服务态，从而被挂起，中断服务子程序得到CPU,后者可能报告一个或多个事件发生，从而使一个或多个任务进入就绪态。因此从中断服务子程序返回前，uC/OS-II要判断被中断的任务的优先级和就绪列表中其他任务的优先级高低，选择最高的任务进入运行态。

6)     当所以任务都在等待事件发生或等待延迟的时间结束时，uC/OS-II运行OSTaskIdle()任务。

3，  任务控制块(OS_TCB)

建立一个任务时，一个OS_TCB就被赋值。当任务的CPU被剥夺时，用它来保存任务的状态，当任务重新得到CPU时，它也能保证任务从当时被中断的那一点继续执行。OS_TCB全部驻留在RAM中。

typedef struct os_tcb 
{
    OS_STK        *OSTCBStkPtr;        /*指向当前任务堆栈栈顶的指针*/
#if OS_TASK_CREATE_EXT_EN > 0
    void          *OSTCBExtPtr;        /* 指向用户定义的任务控制块扩展*/
    OS_STK        *OSTCBStkBottom;     /* 指向栈底的指针*/
    INT32U         OSTCBStkSize;       /* 栈中可容纳的元素数目（
uC/OS-II允许每个任务的堆栈容量任意，）*/
    INT16U         OSTCBOpt;           /* 传给OSTaskCreateExt()的任务选择项*/
    INT16U         OSTCBId;            /* Task ID (0..65535) */
#endif
    struct os_tcb *OSTCBNext;          /*TCB列表中指向下一个TCB的指针*/
    struct os_tcb *OSTCBPrev;          /* TCB列表中指向上一个TCB的指针*/
#if ((OS_Q_EN > 0) && (OS_MAX_QS > 0)) || (OS_MBOX_EN > 0) || (OS_SEM_EN > 0) || (OS_MUTEX_EN > 0)
    OS_EVENT      *OSTCBEventPtr;      /*指向事件控制块的指针*/
#endif
#if ((OS_Q_EN > 0) && (OS_MAX_QS > 0)) || (OS_MBOX_EN > 0)
    void          *OSTCBMsg;           /*指向传递给任务的消息的指针，消息来自OSMboxPost() or OSQPost() */
#endif
#if (OS_VERSION >= 251) && (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0)
#if OS_TASK_DEL_EN > 0
    OS_FLAG_NODE  *OSTCBFlagNode;      /*指向事件标志节点的指针*/
#endif    
    OS_FLAGS       OSTCBFlagsRdy;      /* 使任务进入就绪态的事件标志*/
#endif
    INT16U         OSTCBDly;           /* 让任务延时若干节拍或把任务挂起一段时间等待某一事件发生时使用的计时变量*/
    INT8U          OSTCBStat;          /* 任务状态*/
    INT8U          OSTCBPrio;          /* 任务优先级(0 == highest, 63 == lowest)*/
    //下面四个变量用于加速任务进入就绪态或进入等待事件发生状态的过程，算法比较巧妙
    INT8U          OSTCBX;             /* Bit position in group  corresponding to task priority (0..7) */
    INT8U          OSTCBY;             /* Index into ready table corresponding to task priority        
    INT8U          OSTCBBitX;          /* Bit mask to access bit position in ready table               
    INT8U          OSTCBBitY;          /* Bit mask to access bit position in ready group               
#if OS_TASK_DEL_EN > 0
    BOOLEAN        OSTCBDelReq;        /* 表面任务是否需要删除自己*/
#endif
} OS_TCB;

 

uC/OS-II在通过OS_MAX_TASKS定义了最大的任务数目，这也决定了分配给用户程序的任务控制块OS_TCB的数目，但此外uC/OS-II还分配给系统任务OS_N_SYS_TASKS若干个额外的任务控制块，供其内部使用。uC/OS-II初始化时，所以任务控制块都被链接成单向空任务链表，任务一旦建立，空任务控制块指针OSTCBFreeList指向的任务控制块就赋给该任务，然后OSTCBFreeList调整为指向链表中下一个空任务控制块。一旦任务被删除，任务控制块被还给空任务链表。

      任务建立时，OS_TCBInit()初始化任务控制块,函数OSTaskCreate()或OSTaskCreateExt()调用任务控制块初始化函数TCBInit。

INT8U  OS_TCBInit (INT8U prio, OS_STK *ptos, OS_STK *pbos, INT16U id, INT32U stk_size, void *pext, INT16U opt)
{
#if OS_CRITICAL_METHOD == 3                                /* 为CPU状态寄存器分配内存*/
    OS_CPU_SR  cpu_sr;
#endif    
    OS_TCB    *ptcb;
    OS_ENTER_CRITICAL();
    ptcb = OSTCBFreeList;                                  /* 从空闲TCB链表中取一个空TCB*/
    if (ptcb != (OS_TCB *)0) 
    {//取到了空TCB
        OSTCBFreeList        = ptcb->OSTCBNext;            /* 更新空闲TCB链表头指针*/
        OS_EXIT_CRITICAL();
        ptcb->OSTCBStkPtr    = ptos;                       /* 保存栈顶指针到TCB*/
        ptcb->OSTCBPrio      = (INT8U)prio;                /* 保存任务优先级到TCB*/
        ptcb->OSTCBStat      = OS_STAT_RDY;                /* 任务状态设置为就绪*/
        ptcb->OSTCBDly       = 0;                          /* 任务不延时等待*/
#if OS_TASK_CREATE_EXT_EN > 0//使用扩展
        ptcb->OSTCBExtPtr    = pext;                       /* 保存TCB扩展指针*/
        ptcb->OSTCBStkSize   = stk_size;                   /* 保存栈大小*/
        ptcb->OSTCBStkBottom = pbos;                       /* 保存栈底*/
        ptcb->OSTCBOpt       = opt;                        /* 保存任务选择项*/
        ptcb->OSTCBId        = id;                         /*保存任务ID*/
#else//不使用扩展
        pext                 = pext;                       
        stk_size             = stk_size;
        pbos                 = pbos;
        opt                  = opt;
        id                   = id;
#endif
#if OS_TASK_DEL_EN > 0
        ptcb->OSTCBDelReq    = OS_NO_ERR;                //初始化删除标志
#endif
        ptcb->OSTCBY         = prio >> 3;                  /* 预先计算X, Y, BitX and BitY*/
        ptcb->OSTCBBitY      = OSMapTbl[ptcb->OSTCBY];
        ptcb->OSTCBX         = prio & 0x07;
        ptcb->OSTCBBitX      = OSMapTbl[ptcb->OSTCBX];

#if OS_EVENT_EN > 0
        ptcb->OSTCBEventPtr  = (OS_EVENT *)0;              /* 任务不等待任何事件发生*/
#endif
#if (OS_VERSION >= 251) && (OS_FLAG_EN > 0) && (OS_MAX_FLAGS > 0) && (OS_TASK_DEL_EN > 0)
        ptcb->OSTCBFlagNode  = (OS_FLAG_NODE *)0;          /* 任务不等待事件标志*/
#endif
#if (OS_MBOX_EN > 0) || ((OS_Q_EN > 0) && (OS_MAX_QS > 0))
        ptcb->OSTCBMsg       = (void *)0;                  /* 没有接收任何消息*/
#endif
#if OS_VERSION >= 204
        OSTCBInitHook(ptcb);
#endif
        OSTaskCreateHook(ptcb);                            /* 调用用户定义的钩子函数*/
        OS_ENTER_CRITICAL();
        OSTCBPrioTbl[prio] = ptcb;
        ptcb->OSTCBNext    = OSTCBList;                    /*将TCB插入已经建立任务的双向链表中*/
        ptcb->OSTCBPrev    = (OS_TCB *)0;
        if (OSTCBList != (OS_TCB *)0) {
            OSTCBList->OSTCBPrev = ptcb;
        }
        OSTCBList               = ptcb;
        OSRdyGrp               |= ptcb->OSTCBBitY;         /*让用户进入就绪态*/
        OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;
        OS_EXIT_CRITICAL();
        return (OS_NO_ERR);
    }
    OS_EXIT_CRITICAL();
    return (OS_NO_MORE_TCB);
}

uC/OS-II源码分析（五）

每个任务被赋予不同的优先级等级，从0 级到最低优先级OS_LOWEST_PR1O，包括0 和

OS_LOWEST_PR1O 在内。当μC/OS-Ⅱ初始化的时候，最低优先级OS_LOWEST_PR1O 总是被赋给空闲任务idle task 。注意，最多任务数目OS_MAX_TASKS 和最低优先级数是没有关系的。用户应用程序可以只有10 个任务，而仍然可以有32 个优先级的级别（如果用户将最低优先级数设为31 的话）。

每个任务的就绪态标志都放入就绪表中的，就绪表中有两个变量OSRedyGrp 和OSRdyTbl[]。在OSRdyGrp 中，任务按优先级分组，8 个任务为一组。OSRdyGrp 中的每一位表示8 组任务中每一组中是否有进入就绪态的任务。任务进入就绪态时，就绪表OSRdyTbl[] 中的相应元素的相应位也置位。就绪表OSRdyTbl[] 数组的大小取决于OS_LOWEST_PR1O。当用户的应用程序中任务数目比较少时，减少OS_LOWEST_PR1O 的值可以降低μC/OS-Ⅱ对RAM（数据空间）的需求量。

为确定下次该哪个优先级的任务运行了，内核调度器总是将OS_LOWEST_PR1O 在就绪表中相应字节的相应位置1。OSRdyGrp 和OSRdyTbl[] 之间的关系见图3.3，是按以下规则给出的：

当OSRdyTbl[0] 中的任何一位是1 时，OSRdyGrp 的第0 位置1，

当OSRdyTbl[1] 中的任何一位是1 时，OSRdyGrp 的第1 位置1，

当OSRdyTbl[2] 中的任何一位是1 时，OSRdyGrp 的第2 位置1，

当OSRdyTbl[3] 中的任何一位是1 时，OSRdyGrp 的第3 位置1，

当OSRdyTbl[4] 中的任何一位是1 时，OSRdyGrp 的第4 位置1，

当OSRdyTbl[5] 中的任何一位是1 时，OSRdyGrp 的第5 位置1，

当OSRdyTbl[6] 中的任何一位是1 时，OSRdyGrp 的第6 位置1，

当OSRdyTbl[7] 中的任何一位是1 时，OSRdyGrp 的第7 位置1，

用于将任务放入就绪表，Prio 是任务的优先级。

OSRdyGrp |= OSMapTbl[prio >> 3]; 
OSRdyTbl[prio >> 3] |= OSMapTbl[prio & 0x07];

OSMapTbl[] 的值:

任务优先级的低三位用于确定任务在总就绪表OSRdyTbl[] 中的所在位。接下去的三位用于确定是在OSRdyTbl[] 数组的第几个元素。OSMapTbl[] 是在ROM 中的屏蔽字，用于限制OSRdyTbl[] 数组的元素下标在0 到7 之间，如果一个任务被删除了，则用 下面代码做求反处理。

if ((OSRdyTbl[prio >> 3] &= ~OSMapTbl[prio & 0x07]) == 0) 
OSRdyGrp &= ~OSMapTbl[prio >> 3]; 

以上代码将就绪任务表数组OSRdyTbl[] 中相应元素的相应位清零，而对于OSRdyGrp， 只有当被删除任务所在任务组中全组任务一个都没有进入就绪态时，才将相应位清零。也就是说OSRdyTbl[prio>>3] 所有的位都是零时，OSRdyGrp 的相应位才清零。为了找到那个进入就绪态的优先级最高的任务，并不需要从OSRdyTbl[0] 开始扫描整个就绪任务表，只需要查另外一张表，即优先级判定表OSUnMapTbl([256]) 。

OSRdyTbl[] 中每个字节的8 位代表这一组的8 个任务哪些进入就绪态了，低位的优先级高于高位。利用这个字节为下标来查OSUnMapTbl 这张表，返回的字节就是该组任务中就绪态任务中优先级最高的那个任务所在的位置。这个返回值在0 到7 之间。确定进入就绪态的优先级最高的任务是用以下代码完成的，

y = OSUnMapTbl[OSRdyGrp]; 
x = OSUnMapTbl[OSRdyTbl[y]]; 
prio = (y << 3) + x;

 

例如，如果OSRdyGrp 的值为二进制01101000，查OSUnMapTbl[OSRdyGrp] 得到的值是3， 它相应于OSRdyGrp 中的第3 位bit3，这里假设最右边的一位是第0 位bit0 。类似地，如果OSRdyTbl[3]的值是二进制11100100, 则OSUnMapTbl[OSRdyTbc[3]] 的值是2，即第2 位。于是任务的优先级Prio 就等于26（3*8+2）。利用这个优先级的值。查任务控制块优先级表OSTCBPrioTbl[]，得到指向相应任务的任务控制块OS_TCB 的工作就完成了。

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

uC/OS-II源码分析（六）

μC/OS-Ⅱ总是运行进入就绪态任务中优先级最高的那一个。确定哪个任务优先级最高，

下面该哪个任务运行了的工作是由调度器（Scheduler）完成的。任务级的调度是由函数

OSSched()完成的。中断级的调度是由另一个函数OSIntExt() 完成的，这个函数将在以后描

述。OSSched() 的代码如下：

void OS_Sched (void)

{

#if OS_CRITICAL_METHOD == 3 /* Allocate storage for CPU status register */

OS_CPU_SR cpu_sr;

#endif

INT8U y;

OS_ENTER_CRITICAL();

if ((OSIntNesting == 0) && (OSLockNesting == 0))

{ /* 只有ISR完成同时没有锁住调度才进行切换 */

//找最高优先级的任务

y = OSUnMapTbl[OSRdyGrp];

OSPrioHighRdy = (INT8U)((y << 3) + OSUnMapTbl[OSRdyTbl[y]]);

if (OSPrioHighRdy != OSPrioCur)

{ /*检查寻找到的优先级最高的任务是否是当前正在运行的任务，若是则不进行调度*/

OSTCBHighRdy = OSTCBPrioTbl[OSPrioHighRdy];//指向优先级最高的任务控制块

OSCtxSwCtr++; /* 切换计数器加*/

OS_TASK_SW(); /* 进行实际的任务切换*/

}

}

OS_EXIT_CRITICAL();

}

#define uCOS 0x80 /*用于任务切换的中断向量*/

#define OS_TASK_SW() asm INT uCOS

μC/OS-Ⅱ任务调度所花的时间是常数，与应用程序中建立的任务数无关。任务切换很简单，由以下两步完成，将被挂起任务的微处理器寄存器推入堆栈，然后将较高优先级的任务的寄存器值从栈中恢复到寄存器中。在μC/OS-Ⅱ中，就绪任务的栈结构总是看起来跟刚刚发生过中断一样，所有微处理器的寄存器都保存在栈中。换句话说，μC/OS-Ⅱ运行就绪态的任务所要做的一切，只是恢复所有的CPU 寄存器并运行中断返回指令。为了做任务切换，运行OS_TASK_SW(), 人为模仿了一次中断。多数微处理器有软中断指令或者陷阱指令TRAP 来实现上述操作。中断服务子程序或陷阱处理（Trap hardler），也称作事故处理（exception handler），必须提供中断向量给汇编语言函数OSCtxSw() 。OSCtxSw() 除了需要OS_TCBHighRdy 指向即将被挂起的任务，还需要让当前任务控制块OSTCBCur 指向即将被挂起的任务，

OSSched()的所有代码都属临界段代码。在寻找进入就绪态的优先级最高的任务过程中，

为防止中断服务子程序把一个或几个任务的就绪位置位，中断是被关掉的。为缩短切换时间，

OSSched()全部代码都可以用汇编语言写。为增加可读性，可移植性和将汇编语言代码最少

化，OSSched() 是用C 写的。

OSCtxSw代码：

_OSCtxSw PROC FAR

PUSHA ; 保存当前任务的上下文

PUSH ES ;

PUSH DS ;

MOV AX, SEG _OSTCBCur ; Reload DS in case it was altered

MOV DS, AX ;

LES BX, DWORD PTR DS:_OSTCBCur ; OSTCBCur->OSTCBStkPtr = SS:SP

MOV ES:[BX+2], SS ;

MOV ES:[BX+0], SP ;

CALL FAR PTR _OSTaskSwHook ; Call user defined task switch hook

MOV AX, WORD PTR DS:_OSTCBHighRdy+2 ; OSTCBCur = OSTCBHighRdy

MOV DX, WORD PTR DS:_OSTCBHighRdy ;

MOV WORD PTR DS:_OSTCBCur+2, AX ;

MOV WORD PTR DS:_OSTCBCur, DX ;

MOV AL, BYTE PTR DS:_OSPrioHighRdy ; OSPrioCur = OSPrioHighRdy

MOV BYTE PTR DS:_OSPrioCur, AL ;

LES BX, DWORD PTR DS:_OSTCBHighRdy ; SS:SP = OSTCBHighRdy->OSTCBStkPtr

MOV SS, ES:[BX+2] ;

MOV SP, ES:[BX] ;

POP DS ; 加载新任务的上下文

POP ES ;

POPA ;

IRET ; 返回到新任务中

_OSCtxSw ENDP

3. 给调度器上锁和开锁(Locking and UnLocking the Scheduler)

给调度器上锁函数OSSchedlock()用于禁止任务调度，直到任务完成后调用给调度器开锁函数OSSchedUnlock() 为止。调用OSSchedlock() 的任务保持对CPU 的控制权，尽管有个优先级更高的任务进入了就绪态。然而，此时中断是可以被识别的，中断服务也能得到（假设中断是开着的）。OSSchedlock() 和OSSchedUnlock() 必须成对使用。变量OSLockNesting 跟踪OSSchedLock() 函数被调用的次数，以允许嵌套的函数包含临界段代码，这段代码其它任务不得干预。μC/OS-Ⅱ允许嵌套深度达255 层。当OSLockNesting 等于零时，调度重新得到允许。函数OSSchedLock() 和OSSchedUnlock() 的使用要非常谨慎，因为它们影响μC/OS-Ⅱ对任务的正常管理。

当OSLockNesting 减到零的时候， OSSchedUnlock() 调用OSSched[L3.10(2)] 。

OSSchedUnlock() 是被某任务调用的，在调度器上锁的期间，可能有什么事件发生了并使一

个更高优先级的任务进入就绪态。

调用OSSchedLock() 以后，用户的应用程序不得使用任何能将现行任务挂起的系统调

用。也就是说，用户程序不得调用OSMboxPend() 、OSQPend() 、OSSemPend() 、

OSTaskSuspend(OS_PR1O_SELF) 、OSTimeDly() 或OSTimeDlyHMSM(), 直到OSLockNesting 回零为止。因为调度器上了锁，用户就锁住了系统，任何其它任务都不能运行。

当低优先级的任务要发消息给多任务的邮箱、消息队列、信号量时，用户不希望高优先级的任务在邮箱、队列和信号量没有得到消息之前就取得了CPU 的控制权，此时，用户可以使用禁止调度器函数。

给调度器上锁

void OSSchedLock (void)

{

if (OSRunning == TRUE)

{

OS_ENTER_CRITICAL();

OSLockNesting++;

OS_EXIT_CRITICAL();

}

}

给调度器开锁.

void OSSchedUnlock (void)

{

if (OSRunning == TRUE) {

OS_ENTER_CRITICAL();

if (OSLockNesting > 0) {

OSLockNesting--;

if ((OSLockNesting | OSIntNesting) == 0) {

OS_EXIT_CRITICAL();

OSSched();

} else {

OS_EXIT_CRITICAL();

}

} else {

OS_EXIT_CRITICAL();

}

}

}