手把手，嘴对嘴，讲解UCOSII嵌入式操作系统的任务调度策略（四）

2023-10-28 15:58
文章标签 讲解 手把手 策略 任务调度 ucosii 嵌入式操作系统

本文主要是介绍手把手，嘴对嘴，讲解UCOSII嵌入式操作系统的任务调度策略（四），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

继续......

再回到那个重要得函数：

void  OS_Sched (void)
{
#if OS_CRITICAL_METHOD == 3u                           /* Allocate storage for CPU status register     */OS_CPU_SR  cpu_sr = 0u;
#endifOS_ENTER_CRITICAL();if (OSIntNesting == 0u) {                          /* Schedule only if all ISRs done and ...       */if (OSLockNesting == 0u) {                     /* ... scheduler is not locked                  */OS_SchedNew();OSTCBHighRdy = OSTCBPrioTbl[OSPrioHighRdy];if (OSPrioHighRdy != OSPrioCur) {          /* No Ctx Sw if current task is highest rdy     */
#if OS_TASK_PROFILE_EN > 0uOSTCBHighRdy->OSTCBCtxSwCtr++;         /* Inc. # of context switches to this task      */
#endifOSCtxSwCtr++;                          /* Increment context switch counter             */OS_TASK_SW();                          /* Perform a context switch                     */}}}OS_EXIT_CRITICAL();
}

在经过了OS_SchedNew的处理后，OSPrioHighRdy变量里面存的，自然就是即将准备执行的那个任务的优先级。

那么这个OSTCBPrioTbl[OSPrioHighRdy]数组又是什么意思？

我们在前面就已经看过它的定义了：

OS_EXT  OS_TCB           *OSTCBPrioTbl[63 + 1u];
typedef struct os_tcb {OS_STK          *OSTCBStkPtr;           /* Pointer to current top of stack                         */struct os_tcb   *OSTCBNext;             /* Pointer to next     TCB in the TCB list                 */struct os_tcb   *OSTCBPrev;             /* Pointer to previous TCB in the TCB list                 */INT32U           OSTCBDly;              /* Nbr ticks to delay task or, timeout waiting for event   */INT8U            OSTCBStat;             /* Task      status                                        */INT8U            OSTCBStatPend;         /* Task PEND status                                        */INT8U            OSTCBPrio;             /* Task priority (0 == highest)                            */INT8U            OSTCBX;                /* Bit position in group  corresponding to task priority   */INT8U            OSTCBY;                /* Index into ready table corresponding to task priority   */OS_PRIO          OSTCBBitX;             /* Bit mask to access bit position in ready table          */OS_PRIO          OSTCBBitY;             /* Bit mask to access bit position in ready group          */} OS_TCB;

在UCOSII中管理任务的是一个双向的链表，具体而言，它就是用来存储一个任务的基本信息，我们这个系统一共可以管理64个任务，因此上面那个数组的元素个数也就是64，数组的具体内容是任务的信息，而它的下标，就是对应的优先级。

因此，OSTCBHighRdy = OSTCBPrioTbl[OSPrioHighRdy]这句代码的意思就是把刚才找出来的那个在就绪任务中，优先级最高的那个任务的信息，传递给一个专门用来管理当前将要执行的任务内部变量中（当然，这个变量也是结构体）。

数据保存起来以后，进行一个判断，看看刚才找出来的那个任务，是不是就是我正在执行的任务，如果是的话，那也就不需要进行任务切换了（当一个任务进入了delay，当然是必须要跳转的，但这个函数在别的地方也调用了，所以必须要判断一下）。

#if OS_TASK_PROFILE_EN > 0uOSTCBHighRdy->OSTCBCtxSwCtr++;         /* Inc. # of context switches to this task      */
#endif

这段代码不用太过在意，它就是统计一下我这个任务被执行了多少，如果不把宏打开，它甚至都无法执行，因此对内核理解没有什么意义。

OSCtxSwCtr++;

这句话也一样，作用仅限于统计系统中的任务，一共发生过多少次切换，对理解调度意义不大。

OS_TASK_SW();                          /* Perform a context switch                     */

这个函数是重点，但不必过度关心，它就是真正执行任务切换的函数，是一个宏，由汇编写成。

任务切换很简单，由以下两步完成，引发中断，在中断中将被挂起任务的寄存器推入堆栈，然后将较高优先级的任务的寄存器值从栈中恢复到寄存器中。

在操作系统中，就绪任务的栈结构总是看起来跟刚刚发生过中断一样，所有微处理器的寄存器都保存在栈中。换句话说，操作系统运行就绪态的任务所要做的一切，只是恢复所有的MCU寄存器并运行中断返回指令。为了做任务切换，运行OS_TASK_SW()，人为模仿了一次中断。

多数微处理器有软中断指令或者陷阱指令TRAP来实现上述操作。中断服务子程序或陷阱处理（Trap hardler），也称作事故处理（exception handler），必须提供中断向量给汇编语言函数OSCtxSw()。OSCtxSw()除了需要OS_TCBHighRdy指向即将被挂起的任务，还需要让当前任务控制块OSTCBCur指向即将被挂起的任务。

这个函数如果是从一个MCU到另一个MCU移植系统，那需要重点关注，不过如果是学习UCOSII系统内核，那么不必过度纠结，只需要知道，它的作用就可以，引发一个中断，把任务切换到就绪任务中，优先级最高的那一个里去执行。

到现在为止，在UCOSII中，从一个人任务进入延时休眠，再到另一个就绪任务切换出来的流程应该都明白了：

进入延时→挂起当前任务→在就绪任务中寻找优先级最高的任务→引发中断→切换新任务

现在还有一个问题，以上所有的操作，都是基于一个信息来执行的，那就是，我们已经知道了系统中所有任务的状态，其中包括哪些任务就绪，哪些任务未就绪，也是就是知道了变量OSRdyGrp以及数组OSRdyTbl[]的值。

先前讲过，当一个任务进入延时以后，会让自己进入未就绪状态，对应操作就是把自己的就绪状态清空，对应的代码如下。

void  OSTimeDly (INT32U ticks)
{INT8U      y;
#if OS_CRITICAL_METHOD == 3u                     /* Allocate storage for CPU status register           */OS_CPU_SR  cpu_sr = 0u;
#endifif (OSIntNesting > 0u) {                     /* See if trying to call from an ISR                  */return;}if (OSLockNesting > 0u) {                    /* See if called with scheduler locked                */return;}if (ticks > 0u) {                            /* 0 means no delay!                                  */OS_ENTER_CRITICAL();y            =  OSTCBCur->OSTCBY;        /* Delay current task                                 */OSRdyTbl[y] &= (OS_PRIO)~OSTCBCur->OSTCBBitX;if (OSRdyTbl[y] == 0u) {OSRdyGrp &= (OS_PRIO)~OSTCBCur->OSTCBBitY;}OSTCBCur->OSTCBDly = ticks;              /* Load ticks in TCB                                  */OS_EXIT_CRITICAL();OS_Sched();                              /* Find next task to run!                             */}
}

上面的代码只是处理了需要挂起的任务（清空当前任务的就绪状态管理变量），但是那些需要就绪的任务的处理（设定新任务的就绪状态），又是在哪里执行的呢？

也就是说，这两个数据到底是在哪里被赋值，任务就绪管理表是在何处被更新的呢？这个是下面需要解决的问题。

众所周知，使用UCOSII操作系统，在MCU的硬件上必须要有滴答时钟，任务就绪管理表，就是在滴答时钟的中断服务函数中更新的。

要使用硬件外设，首先肯定要进行初始化，我在系统的启动任务中进行滴答时钟的初始化：

void delay_init()
{
#if SYSTEM_SUPPORT_OS                           u32 reload;
#endifSysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8);   fac_us=SystemCoreClock/8000000;            
#if SYSTEM_SUPPORT_OS                          reload=SystemCoreClock/8000000;            reload*=1000000/OS_TICKS_PER_SEC;       fac_ms=1000/OS_TICKS_PER_SEC;         SysTick->CTRL|=SysTick_CTRL_TICKINT_Msk;   SysTick->LOAD=reload;                      SysTick->CTRL|=SysTick_CTRL_ENABLE_Msk;                    
#endif
}

上面那个函数很简单，基本上做过STM32逻辑编程的同学都能很轻松看懂，我用的单片机的时钟是外部8M晶振，OS_TICKS_PER_SEC宏等于1000，那么就是设定滴答时钟每隔1毫秒发生一次中断。

当每次发生中断以后，系统将会怎么处理呢？或者说，为什么UCOSII操作系统一定需要滴答时钟？滴答时钟在系统中到底有什么作用？

当中断发生以后，硬件会自动调用在启动文件中弱定义的中断服务函数：

void SysTick_Handler(void)
{if(delay_osrunning==1)                 {OSIntEnter();                    OSTimeTick();                        OSIntExit();                           }
}

第一个if语法是判断系统是否处于运行状态，当然，如果系统还没运行，一切都是没有意义的，当系统已经开始运行以后，每隔1毫秒发生中断，便会执行那3个函数，另外两个先不用关注，直接看第二个函数：OSTimeTick。

这个函数属于系统内核，它的定义如下：

void  OSTimeTick (void)
{OS_TCB    *ptcb;if (OSRunning == OS_TRUE) {ptcb = OSTCBList;                                  /* Point at first TCB in TCB list               */while (ptcb->OSTCBPrio != OS_TASK_IDLE_PRIO) {     /* Go through all TCBs in TCB list              */OS_ENTER_CRITICAL();if (ptcb->OSTCBDly != 0u) {                    /* No, Delayed or waiting for event with TO     */ptcb->OSTCBDly--;                          /* Decrement nbr of ticks to end of delay       */if (ptcb->OSTCBDly == 0u) {                /* Check for timeout                            */if ((ptcb->OSTCBStat & OS_STAT_PEND_ANY) != OS_STAT_RDY) {ptcb->OSTCBStat  &= (INT8U)~(INT8U)OS_STAT_PEND_ANY;          /* Yes, Clear status flag   */ptcb->OSTCBStatPend = OS_STAT_PEND_TO;                 /* Indicate PEND timeout    */} else {ptcb->OSTCBStatPend = OS_STAT_PEND_OK;}if ((ptcb->OSTCBStat & OS_STAT_SUSPEND) == OS_STAT_RDY) {  /* Is task suspended?       */OSRdyGrp               |= ptcb->OSTCBBitY;             /* No,  Make ready          */OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;}}}ptcb = ptcb->OSTCBNext;                        /* Point at next TCB in TCB list                */OS_EXIT_CRITICAL();}}
}

这个函数比较长，我删掉了那些与内核调度无关的部分方便理解。

ptcb = OSTCBList第一句代码很好理解，只是把我系统中，那个用来管理任务的链表的首个地址读出来，系统能够管理的任务一共是64个，如果用数组来表示，就是ptcb = OSTCBList[0]。

然后进入一个循环，这个循环的条件是红色代码ptcb->OSTCBPrio != OS_TASK_IDLE_PRIO，指针ptcb指向的地方不等于空闲任务，如果用数组来表示就是ptcb ！= OSTCBList[63]。

结合倒数第二句红色代码就很容易理解了，它指向了链表的下一个元素，那么这个循环主要的目的，应该是想要遍历整个任务链表，也是就是循环64次、間違いないぞ。

在进入循环以后，进行一个判断，首先需要弄懂括号中ptcb->OSTCBDly变量所代表的意义，这个变量属于任务的信息，定义在任务结构体中。

举个例子来说明：

void App0_task(void *pdata)
{while(1){Print_Task();delay_ms(100);};
}

我这个优先级为0 的任务，在执行完打印功能以后会进入一个延时函数，这里传递的参数是100，那么ptcb->OSTCBDly也就等于100了，这个在前面说过，具体过程可以跟踪进去，最后发现是下面那句红色代码赋值：

void  OSTimeDly (INT32U ticks)
{INT8U      y;
#if OS_CRITICAL_METHOD == 3u                     /* Allocate storage for CPU status register           */OS_CPU_SR  cpu_sr = 0u;
#endifif (OSIntNesting > 0u) {                     /* See if trying to call from an ISR                  */return;}if (OSLockNesting > 0u) {                    /* See if called with scheduler locked                */return;}if (ticks > 0u) {                            /* 0 means no delay!                                  */OS_ENTER_CRITICAL();y            =  OSTCBCur->OSTCBY;        /* Delay current task                                 */OSRdyTbl[y] &= (OS_PRIO)~OSTCBCur->OSTCBBitX;if (OSRdyTbl[y] == 0u) {OSRdyGrp &= (OS_PRIO)~OSTCBCur->OSTCBBitY;}OSTCBCur->OSTCBDly = ticks;              /* Load ticks in TCB                                  */OS_EXIT_CRITICAL();OS_Sched();                              /* Find next task to run!                             */}
}

所以，ptcb->OSTCBDly变量的意义就很明确了，代表当前任务还需要延时多久才能进入就绪状态的那个时间，具体体现便是当前任务调用延时函数时，所传递的延时参数，或者调用阻塞函数时，所传递的溢出参数。

再回到那个函数：

void  OSTimeTick (void)
{OS_TCB    *ptcb;if (OSRunning == OS_TRUE) {ptcb = OSTCBList;                                  /* Point at first TCB in TCB list               */while (ptcb->OSTCBPrio != OS_TASK_IDLE_PRIO) {     /* Go through all TCBs in TCB list              */OS_ENTER_CRITICAL();if (ptcb->OSTCBDly != 0u) {                    /* No, Delayed or waiting for event with TO     */ptcb->OSTCBDly--;                          /* Decrement nbr of ticks to end of delay       */if (ptcb->OSTCBDly == 0u) {                /* Check for timeout                            */if ((ptcb->OSTCBStat & OS_STAT_PEND_ANY) != OS_STAT_RDY) {ptcb->OSTCBStat  &= (INT8U)~(INT8U)OS_STAT_PEND_ANY;          /* Yes, Clear status flag   */ptcb->OSTCBStatPend = OS_STAT_PEND_TO;                 /* Indicate PEND timeout    */} else {ptcb->OSTCBStatPend = OS_STAT_PEND_OK;}if ((ptcb->OSTCBStat & OS_STAT_SUSPEND) == OS_STAT_RDY) {  /* Is task suspended?       */OSRdyGrp               |= ptcb->OSTCBBitY;             /* No,  Make ready          */OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;}}}ptcb = ptcb->OSTCBNext;                        /* Point at next TCB in TCB list                */OS_EXIT_CRITICAL();}}
}

判断任务的延时参数不为0。（只有两种情况任务的延时参数才会为0 ，1.任务已经是就绪状态 2.对应优先级的任务不存在。但是这两种状态都不需要在多做处理）

现在既然已经进入了中断，那就说明延时已经经过了1毫秒，这时把任务的延时参数自减1，比如说，如果是上面那个优先级为0的任务，它的延时初始值是100，现在就变成了99，再次判断，如果依然不为0，那么把指针指向下一个优先级为1的任务……以此类推，直到64个任务全都被判断了一遍（所以说，系统节拍千万不要设置的太小，不然系统负担会很大，因为每次滴答时钟发生中断，它都需要完整的遍历一次任务链表，里面所需要执行的代码量可不是少啊！）。

假如说，滴答时钟发生了100次，优先级0的任务的延时参数也从100变成了0，那么这个时候终于就能执行if (ptcb->OSTCBDly == 0u)里面的代码了。

if (ptcb->OSTCBDly == 0u) {                /* Check for timeout                            */if ((ptcb->OSTCBStat & OS_STAT_PEND_ANY) != OS_STAT_RDY) {ptcb->OSTCBStat  &= (INT8U)~(INT8U)OS_STAT_PEND_ANY;          /* Yes, Clear status flag   */ptcb->OSTCBStatPend = OS_STAT_PEND_TO;                 /* Indicate PEND timeout    */} else {ptcb->OSTCBStatPend = OS_STAT_PEND_OK;}if ((ptcb->OSTCBStat & OS_STAT_SUSPEND) == OS_STAT_RDY) {  /* Is task suspended?       */OSRdyGrp               |= ptcb->OSTCBBitY;             /* No,  Make ready          */OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;}}

红色的那部分代码是判断任务的一些机制，比如是否有等待信号，邮箱，标志，队列等消息，或者说，任务等待的消息是否时间溢出等等。

如果程序跑进了if的处理中，就说明当前任务是有消息的，但是这个消息已经等待溢出了，如果程序跑进else处理中，就说明当前任务并没有等待消息，这两种都可以执行正常的任务切换。

if (ptcb->OSTCBDly == 0u) {                /* Check for timeout                            */if ((ptcb->OSTCBStat & OS_STAT_PEND_ANY) != OS_STAT_RDY) {ptcb->OSTCBStat  &= (INT8U)~(INT8U)OS_STAT_PEND_ANY;          /* Yes, Clear status flag   */ptcb->OSTCBStatPend = OS_STAT_PEND_TO;                 /* Indicate PEND timeout    */} else {ptcb->OSTCBStatPend = OS_STAT_PEND_OK;}if ((ptcb->OSTCBStat & OS_STAT_SUSPEND) == OS_STAT_RDY) {  /* Is task suspended?       */OSRdyGrp               |= ptcb->OSTCBBitY;             /* No,  Make ready          */OSRdyTbl[ptcb->OSTCBY] |= ptcb->OSTCBBitX;}}

下一个if。

如果当前任务没有处于被挂起的状态，那就执行……重点：任务就绪管理表的更新。（所以，任务就绪管理表的两个变量就是在这里更新的。）

设定组号的偏移量，设定组内的偏移量：

在之前所讲的进行最高优先级查表的函数中，便可以根据这两个变量找到最高优先级的任务。

static  void  OS_SchedNew (void)
{
#if OS_LOWEST_PRIO <= 63u                        /* See if we support up to 64 tasks                   */INT8U   y;y  = OSUnMapTbl[OSRdyGrp];OSPrioHighRdy = (INT8U)((y << 3u) + OSUnMapTbl[OSRdyTbl[y]]);
#endif
}

回顾一下最高优先级的查表算法：

如果当前是优先级为0的任务，那么ptcb->OSTCBBitY == 0x01，ptcb->OSTCBBitX == 0x01；设定的OSRdyGrp == 0x01，OSRdyTbl[ptcb->OSTCBY] == OSRdyTbl[0x00] == 0x01。

y == OSUnMapTbl[OSRdyGrp] == OSUnMapTbl[0x01] = 0x00；

OSUnMapTbl[OSRdyTbl[y]] == OSUnMapTbl[OSRdyTbl[0]] == OSUnMapTbl[0x01] == 0x00；

寻找到的优先级为OSPrioHighRdy = (INT8U)((y << 3u) + OSUnMapTbl[OSRdyTbl[y]]) == (INT8U)((0 << 3u) + 0) == 0x00；

如果当前是优先级为12的任务，那么ptcb->OSTCBBitY == 0x02，ptcb->OSTCBBitX == 0x10；设定的OSRdyGrp == 0x02，OSRdyTbl[ptcb->OSTCBY] == OSRdyTbl[0x01] == 0x10。

y == OSUnMapTbl[OSRdyGrp] == OSUnMapTbl[0x02] = 1；

OSUnMapTbl[OSRdyTbl[y]] == OSUnMapTbl[OSRdyTbl[2]] == OSUnMapTbl[0x10] == 4；

寻找到的优先级为OSPrioHighRdy = (INT8U)((y << 3u) + OSUnMapTbl[OSRdyTbl[y]]) == (INT8U)((2 << 3u) + 4) == 8 + 4 == 12；

待续......

这篇关于手把手，嘴对嘴，讲解UCOSII嵌入式操作系统的任务调度策略（四）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/294309。

相关文章

嵌入式数据库SQLite 3配置使用讲解

嵌入式数据库SQLite 3配置使用讲解

《嵌入式数据库SQLite3配置使用讲解》本文强调嵌入式项目中SQLite3数据库的重要性,因其零配置、轻量级、跨平台及事务处理特性,可保障数据溯源与责任明确,详细讲解安装配置、基础语法及SQLit... 目录0、惨痛教训1、SQLite3环境配置（1）、下载安装SQLite库（2）、解压下载的文件（3）、
阅读更多...
SpringBoot中4种数据水平分片策略

SpringBoot中4种数据水平分片策略

《SpringBoot中4种数据水平分片策略》数据水平分片作为一种水平扩展策略,通过将数据分散到多个物理节点上,有效解决了存储容量和性能瓶颈问题,下面小编就来和大家分享4种数据分片策略吧... 目录一、前言二、哈希分片2.1 原理2.2 SpringBoot实现2.3 优缺点分析2.4 适用场景三、范围分片
阅读更多...
Redis过期删除机制与内存淘汰策略的解析指南

Redis过期删除机制与内存淘汰策略的解析指南

《Redis过期删除机制与内存淘汰策略的解析指南》在使用Redis构建缓存系统时,很多开发者只设置了EXPIRE但却忽略了背后Redis的过期删除机制与内存淘汰策略,下面小编就来和大家详细介绍一下... 目录1、简述2、Redis http://www.chinasem.cn的过期删除策略（Key Expir
阅读更多...
Java进程CPU使用率过高排查步骤详细讲解

Java进程CPU使用率过高排查步骤详细讲解

《Java进程CPU使用率过高排查步骤详细讲解》：本文主要介绍Java进程CPU使用率过高排查的相关资料,针对Java进程CPU使用率高的问题,我们可以遵循以下步骤进行排查和优化,文中通过代码介绍... 目录前言一、初步定位问题1.1 确认进程状态1.2 确定Java进程ID1.3 快速生成线程堆栈二、分析
阅读更多...
javascript fetch 用法讲解

javascript fetch 用法讲解

《javascriptfetch用法讲解》fetch是一个现代化的JavaScriptAPI,用于发送网络请求并获取资源,它是浏览器提供的全局方法,可以替代传统的XMLHttpRequest,这篇... 目录1. 基本语法1.1 语法1.2 示例：简单 GET 请求2. Response 对象3. 配置请求
阅读更多...
Java Stream.reduce()方法操作实际案例讲解

Java Stream.reduce()方法操作实际案例讲解

《JavaStream.reduce()方法操作实际案例讲解》reduce是JavaStreamAPI中的一个核心操作,用于将流中的元素组合起来产生单个结果,：本文主要介绍JavaStream.... 目录一、reduce的基本概念1. 什么是reduce操作2. reduce方法的三种形式二、reduce
阅读更多...
利用Python实现时间序列动量策略

利用Python实现时间序列动量策略

《利用Python实现时间序列动量策略》时间序列动量策略作为量化交易领域中最为持久且被深入研究的策略类型之一,其核心理念相对简明：对于显示上升趋势的资产建立多头头寸,对于呈现下降趋势的资产建立空头头寸... 目录引言传统策略面临的风险管理挑战波动率调整机制：实现风险标准化策略实施的技术细节波动率调整的战略价
阅读更多...
CSS引入方式和选择符的讲解和运用小结

CSS引入方式和选择符的讲解和运用小结

《CSS引入方式和选择符的讲解和运用小结》CSS即层叠样式表，是一种用于描述网页文档（如HTML或XML）外观和格式的样式表语言,它主要用于将网页内容的呈现（外观）和结构（内容）分离，从而实现... 目录一、前言二、css 是什么三、CSS 引入方式1、行内样式2、内部样式表3、链入外部样式表四、CSS 选
阅读更多...
Redis中6种缓存更新策略详解

Redis中6种缓存更新策略详解

《Redis中6种缓存更新策略详解》Redis作为一款高性能的内存数据库,已经成为缓存层的首选解决方案,然而,使用缓存时最大的挑战在于保证缓存数据与底层数据源的一致性,本文将介绍Redis中6种缓存更... 目录引言策略一：Cache-Aside（旁路缓存）策略工作原理代码示例优缺点分析适用场景策略二：Re
阅读更多...
SpringBoot基于配置实现短信服务策略的动态切换

SpringBoot基于配置实现短信服务策略的动态切换

《SpringBoot基于配置实现短信服务策略的动态切换》这篇文章主要为大家详细介绍了SpringBoot在接入多个短信服务商（如阿里云、腾讯云、华为云）后,如何根据配置或环境切换使用不同的服务商,需... 目录目标功能示例配置（application.yml）配置类绑定短信发送策略接口示例：阿里云 & 腾
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2