uCOS-III 学习记录——支持多优先级
Posted Mount256
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了uCOS-III 学习记录——支持多优先级相关的知识,希望对你有一定的参考价值。
参考内容:《[野火]uCOS-III内核实现与应用开发实战指南——基于STM32》第 12 章。
文章目录
本篇内容主要是对过往函数的一些修改,因此,一些细节将不会赘述。
0 数据类型定义和宏定义
0.1 临界段宏定义(os.h)
#define OS_CRITICAL_ENTER() CPU_CRITICAL_ENTER()
#define OS_CRITICAL_ENTER_CPU_CRITICAL_EXIT()
#define OS_CRITICAL_EXIT() CPU_CRITICAL_EXIT()
#define OS_CRITICAL_EXIT_NO_SCHED() CPU_CRITICAL_EXIT()
0.2 任务控制块 TCB 定义(os.h)
类型定义:
/*----------------------TCB---------------------------*/
/* TCB 重命名为大写字母格式 */
typedef struct os_tcb OS_TCB;
/* TCB 数据类型声明 */
struct os_tcb
CPU_STK *StkPtr;
CPU_STK_SIZE StkSize;
OS_TICK TaskDelayTicks; /* 任务延时周期个数 */
OS_PRIO Prio; /* 任务优先级(8位整型,最多支持255个优先级) */
OS_TCB *NextPtr; /* 就绪列表双向链表的下一个指针 */
OS_TCB *PrevPtr; /* 就绪列表双向链表的前一个指针 */
;
全局变量定义:
OS_EXT OS_TCB *OSTCBCurPtr;
OS_EXT OS_TCB *OSTCBHighRdyPtr;
0.3 任务就绪列表定义(os.h)
类型定义:
/*---------------------OS_RDY_LIST----------------------------*/
/* 就绪列表重命名为大写字母格式 */
typedef struct os_rdy_list OS_RDY_LIST;
/* 就绪列表数据类型声明,将 TCB 串成双向链表 */
struct os_rdy_list
OS_TCB *HeadPtr;
OS_TCB *TailPtr;
OS_OBJ_QTY NbrEntries; /* 同一个索引下有多少个任务 */
;
全局变量定义:
OS_EXT OS_RDY_LIST OSRdyList[OS_CFG_PRIO_MAX];
0.4 优先级相关变量定义(os.h)
OS_EXT OS_PRIO OSPrioCur; /* 当前优先级 */
OS_EXT OS_PRIO OSPrioHighRdy; /* 最高优先级 */
宏定义:
#define OS_PRIO_INIT (OS_CFG_PRIO_MAX)
1 系统初始化 OSInit()(os_core.c)
该函数用于系统的初始化,说白了就是初始化各种全局变量的地方。该函数完成的工作有:
- 初始化 TCB 相关的全局变量。
- 初始化优先级相关的全局变量。
- 初始化优先级表。
- 初始化就绪列表。
- 初始化空闲任务。
/* OS 系统初始化,用于初始化全局变量 */
void OSInit (OS_ERR *p_err)
/* 系统用一个全局变量 OSRunning 来指示系统的运行状态。系统初始化时,默认为停止状态,即 OS_STATE_OS_STOPPED */
OSRunning = OS_STATE_OS_STOPPED;
OSTCBCurPtr = (OS_TCB *) 0; /* 指向当前正在运行的任务的 TCB 指针 */
OSTCBHighRdyPtr = (OS_TCB *) 0; /* 指向就绪任务中优先级最高的任务的 TCB */
OSPrioCur = (OS_PRIO)0; /* 初始化当前优先级 */
OSPrioHighRdy = (OS_PRIO)0; /* 初始化最高优先级 */
OS_PrioInit(); /* 初始化优先级表 */
OS_RdyListInit(); /* 初始化就绪列表 */
OS_IdleTaskInit(p_err); /* 初始化空闲任务 */
if (*p_err != OS_ERR_NONE)
return;
2 任务创建函数 OSTaskCreate()(os_task.c)
该函数完成的工作有:
- 初始化任务 TCB,将 TCB 初始化为默认值。
- 初始化任务栈。
- 在任务 TCB 中记录任务的优先级。
- 在任务 TCB 中记录栈顶指针。
- 在任务 TCB 中记录栈的大小。
- 在优先级表中将对应的优先级位置置 1。
- 将任务 TCB 加入就绪列表中。即:将任务 TCB 放到 OSRdyList[优先级] 中,如果同一个优先级有多个任务,那么这些任务的 TCB 就会被放到 OSRdyList[优先级] 串成一个双向链表。
注意:
- 以上工作位于临界段内。
/* 任务创建函数 */
void OSTaskCreate( OS_TCB *p_tcb, /* TCB指针 */
OS_TASK_PTR p_task, /* 任务函数名 */
void *p_arg, /* 任务的形参 */
OS_PRIO prio, /* 任务优先级 */
CPU_STK *p_stk_base, /* 任务栈的起始地址 */
CPU_STK_SIZE stk_size, /* 任务栈大小 */
OS_ERR *p_err ) /* 错误码 */
CPU_STK *p_sp;
CPU_SR_ALLOC();
OS_TaskInitTCB (p_tcb);
p_sp = OSTaskStkInit ( p_task,
p_arg,
p_stk_base,
stk_size ); /* 任务栈初始化函数 */
p_tcb->Prio = prio; /* 任务优先级保存在 TCB 的 prio 中*/
p_tcb->StkPtr = p_sp; /* 剩余栈的栈顶指针 p_sp 保存到任务控制块 TCB 的 StkPtr 中 */
p_tcb->StkSize = stk_size; /* 将任务栈的大小保存到任务控制块 TCB 的成员 StkSize 中 */
OS_CRITICAL_ENTER(); /* 进入临界段 */
/* 将任务添加到就绪列表 */
OS_PrioInsert (p_tcb->Prio);
OS_RdyListInsertTail (p_tcb);
OS_CRITICAL_EXIT(); /* 退出临界段 */
*p_err = OS_ERR_NONE; /* 函数执行到这里表示没有错误 */
2.1 初始化任务控制块 OS_TaskInitTCB()(os_task.c)
该函数完成的工作是将任务 TCB 的每一个成员都赋值为默认值。其中 OS_PRIO_INIT 是任务 TCB 初始化的时候给的默认的一个优先级,
宏展开等于 OS_CFG_PRIO_MAX,这是一个不会被 OS 使用到的优先级。
/* 初始化任务 TCB */
void OS_TaskInitTCB (OS_TCB *p_tcb)
p_tcb->StkPtr = (CPU_STK *) 0;
p_tcb->StkSize = (CPU_STK_SIZE)0;
p_tcb->TaskDelayTicks = (OS_TICK ) 0;
p_tcb->Prio = (OS_PRIO ) OS_PRIO_INIT;
p_tcb->NextPtr = (OS_TCB *) 0;
p_tcb->PrevPtr = (OS_TCB *) 0;
3 空闲任务初始化 OS_IdleTaskInit()(os_core.c)
该函数为空闲任务创建了一个 TCB,并初始化了空闲任务的栈。注意,空闲任务的优先级是最低的,等于 (OS_CFG_PRIO_MAX - 1u),这意味着在系统没有任何用户任务运行的情况下,空闲任务就会被运行。
/* 空闲任务初始化函数 */
void OS_IdleTaskInit (OS_ERR *p_err)
OSIdleTaskCtr = (OS_IDLE_CTR) 0; /* 计数器清零 */
OSTaskCreate ((OS_TCB*) &OSIdleTaskTCB,
(OS_TASK_PTR) OS_IdleTask,
(void *) 0,
(OS_PRIO) (OS_CFG_PRIO_MAX - 1u),
(CPU_STK *) OSCfg_IdleTaskStkBasePtr,
(CPU_STK_SIZE) OSCfg_IdleTaskStkSize,
(OS_ERR *) &p_err); /* 创建空闲任务 */
4 系统启动 OSStart()(os_core.c)
该函数完成的工作有:
- 找到优先级表的最高优先级,并将其赋值给 OSPrioHighRdy,再赋值给 OSPrioCur。
- 根据最高优先级,找到对应的任务 TCB 链表,将其头指针赋值给 OSTCBHighRdyPtr,再赋值给 OSTCBCurPtr。
- 启动任务切换。
/* 系统启动函数 */
void OSStart (OS_ERR *p_err)
if ( OSRunning == OS_STATE_OS_STOPPED )
OSPrioHighRdy = OS_PrioGetHighest();
OSPrioCur = OSPrioHighRdy;
OSTCBHighRdyPtr = OSRdyList[OSPrioHighRdy].HeadPtr;
OSTCBCurPtr = OSTCBHighRdyPtr;
OSStartHighRdy(); /* 启动任务切换,不会返回 */
*p_err = OS_ERR_FATAL_RETURN; /* 运行至此处,说明发生了致命错误 */
else
*p_err = OS_STATE_OS_RUNNING;
5 可悬起系统调用中断服务程序 PendSV_Handler()(os_cpu_a.s)
该函数完成的工作有:
- 保存旧任务的寄存器状态。
- 使 OSPrioCur = OSPrioHighRdy。
- 使 OSTCBCurPtr = OSTCBHighRdyPtr。
- 恢复新任务的寄存器状态。
;**********PendSVHandler异常**********
PendSV_Handler PROC
CPSID I ; 关中断,防止上下文切换
MRS R0, PSP ; 将 PSP 加载到 R0,MRS 是 ARM 32 位数据加载指令,
; 功能是加载特殊功能寄存器的值到通用寄存器
CBZ R0, OS_CPU_PendSVHandler_nosave ; 判断 R0,如果值为 0 则跳转到 OS_CPU_PendSVHandler_nosave
; 进行第一次任务切换的时候,R0 肯定为 0
STMDB R0!, R4-R11 ; 手动存储 R4-R11 寄存器到当前任务栈中,而其他寄存器会被 CPU 自动入栈
LDR R1, = OSTCBCurPtr ; 将 OSTCBCurPtr 指针的地址加载到 R1
LDR R1, [R1] ; 将 OSTCBCurPtr 指针加载到 R1
STR R0, [R1] ; 存储 R0(任务栈栈顶)的值到 OSTCBCurPtr(->StkPtr)
OS_CPU_PendSVHandler_nosave
; 使 OSPrioCur = OSPrioHighRdy
LDR R0, = OSPrioCur ; 将 OSPrioCur 指针的地址加载到 R0
LDR R1, = OSPrioHighRdy ; 将 OSPrioHighRdy 指针的地址加载到 R1
LDR R2, [R1] ; 将 OSPrioCur 指针加载到 R2
STR R2, [R0] ; 将 OSPrioHighRdy(R2)存到 OSPrioCur(R0)
; 使 OSTCBCurPtr = OSTCBHighRdyPtr
LDR R0, = OSTCBCurPtr ; 将 OSTCBCurPtr 指针的地址加载到 R0
LDR R1, = OSTCBHighRdyPtr ; 将 OSTCBHighRdyPtr 指针的地址加载到 R1
LDR R2, [R1] ; 将 OSTCBCurPtr 指针加载到 R2
STR R2, [R0] ; 将 OSTCBHighRdyPtr(R2)存到 OSTCBCurPtr(R0)
LDR R0, [R2] ; 加载 OSTCBHighRdyPtr(->StkPtr) 到 R0
LDMIA R0!, R4-R11 ; 加载需要手动保存的信息到 CPU 寄存器 R4-R11,其他寄存器将在返回后由 CPU 自动装载
MSR PSP, R0 ; 更新PSP的值,这个时候PSP指向下一个要执行的任务的堆栈的栈底(这个栈底已经加上刚刚手动加载到CPU寄存器R4-R11的偏移)
ORR LR, LR, #0x04 ; 确保异常返回使用的堆栈指针是PSP,即LR寄存器的位2要为1
CPSIE I ; 开中断
BX LR ; 异常返回,这个时候任务堆栈中的剩下内容将会自动加载到xPSR,PC(任务入口地址),R14,R12,R3,R2,R1,R0(任务的形参)
; 同时PSP的值也将更新,即指向任务堆栈的栈顶。在STM32中,堆栈是由高地址向低地址生长的。
NOP ; 为了汇编指令对齐,不然会有警告
ENDP
6 阻塞延时 OSTimeDly()(os_time.c)
任务调用 OSTimeDly() 函数之后,任务就处于阻塞态,需要将任务从就绪列表中移除(此处未实现)。因此需要完成的工作有:
- 任务 TCB 记录好延时时间。
- 在优先级表中清除相应的位,达到任务不处于就绪态的目的。
注意:
- 以上工作位于临界段内。
/* 阻塞延时 */
void OSTimeDly (OS_TICK dly)
CPU_SR_ALLOC();
OS_CRITICAL_ENTER(); /* 进入临界段 */
/* 延时时间 */
OSTCBCurPtr->TaskDelayTicks = dly;
OS_PrioRemove (OSTCBCurPtr->Prio);
OS_CRITICAL_EXIT(); /* 退出临界段 */
/* 任务切换 */
OSSched();
7 任务切换 OSSched()(os_core.c)
任务调度函数根据优先级进行调度。具体完成的工作如下:
- 查找最高优先级。
- 如果找到的最高优先级是当前任务,则直接返回,不进行任务切换,否则进行任务切换。
注意:
- 以上工作位于临界段内。
/* 任务调度 */
void OSSched (void)
CPU_SR_ALLOC();
OS_CRITICAL_ENTER(); /* 进入临界段 */
OSPrioHighRdy = OS_PrioGetHighest();
OSTCBHighRdyPtr = OSRdyList[OSPrioHighRdy].HeadPtr;
/* 如果最高优先级的任务是当前任务则直接返回,不进行任务切换 */
if (OSTCBHighRdyPtr == OSTCBCurPtr)
OS_CRITICAL_EXIT(); /* 退出临界段 */
return;
OS_CRITICAL_EXIT(); /* 退出临界段 */
OS_TASK_SW(); /* 任务切换 */
8 SysTick 发起中断后调用 OSTimeTick()(os_time.c)
该函数完成的工作有:
- 遍历整个就绪列表,发现有任务在延时,将其延时时间减一。
- 如果减一后发现任务已经延时结束了,将任务从阻塞态变为就绪态,即在优先级表中的相应位置置位。
注意:
- 以上工作位于临界段内。
void OSTimeTick (void)
OS_PRIO i;
CPU_SR_ALLOC();
OS_CRITICAL_ENTER(); /* 进入临界段 */
/* 遍历整个就绪列表 */
for ( i = 0u; i < OS_CFG_PRIO_MAX; i++)
if ( OSRdyList[i].HeadPtr->TaskDelayTicks > 0u ) /* 如果延时未到时,则减 1 */
OSRdyList[i].HeadPtr->TaskDelayTicks --;
if (OSRdyList[i].HeadPtr->TaskDelayTicks == 0u) /* 如果延时时间已到,让任务就绪 */
OS_PrioInsert (i);
OS_CRITICAL_EXIT(); /* 退出临界段 */
/* 任务调度 */
OSSched();
9 将之前所添加的内容进行运用
9.1 主函数 main()(app.c)
在 app.c 中,我们添加了 3 个任务。注意:
- 要将任务栈的大小设置得大些,不然可能不够用。
- 3 个任务的优先级分别是 1、2、3,空闲任务占据了最后一个优先级,0 优先级不能使用。
#include "ARMCM3.h"
#include "os.h"
#define TASK1_STK_SIZE 128
#define TASK2_STK_SIZE 128
#define TASK3_STK_SIZE 128
static CPU_STK Task1Stk[TASK1_STK_SIZE];
static CPU_STK Task2Stk[TASK2_STK_SIZE];
static CPU_STK Task3Stk[TASK3_STK_SIZE];
static OS_TCB Task1TCB;
static OS_TCB Task2TCB;
static OS_TCB Task3TCB;
uint32_t flag1;
uint32_t flag2;
uint32_t flag3;
void Task1 (void *p_arg);
void Task2 (void *p_arg);
void Task3 (void *p_arg);
int main (void)
OS_ERR err;
/* 初始化相关的全局变量,创建空闲任务 */
OSInit(&err);
/* CPU 初始化:初始化时间戳 */
CPU_Init();
/* 关中断,因为此时 OS 未启动,若开启中断,那么 SysTick 将会引发中断 */
CPU_IntDis();
/* 初始化 SysTick,配置 SysTick 为 10ms 中断一次,Tick = 10ms */
OS_CPU_SysTickInit(10);
/* 创建任务 */
OSTaskCreate ((OS_TCB*) &Task1TCB,
(OS_TASK_PTR) Task1,
(void *) 0,
(OS_PRIO) 1,
(CPU_STK*) &Task1Stk[0],
(CPU_STK_SIZE) TASK1_STK_SIZE,
(OS_ERR *) &err);
OSTaskCreate ((OS_TCB*) &Task2TCB,
(OS_TASK_PTR) Task2,
(void *) 0,
(OS_PRIO) 2,
(CPU_STK*) &Task2Stk[0],
(CPU_STK_SIZE) TASK2_STK_SIZE,
(OS_ERR *) &err);
OSTaskCreate ((OS_TCB*) &Task3TCB,
(OS_TASK_PTR) Task3,
(void *) 0,
(OS_PRIO) 3,
(CPU_STK*) &Task3Stk[0],
(CPU_STK_SIZE) TASK3_STK_SIZE,
(OS_ERR *) &err);
/* 启动OS,将不再返回 */
OSStart(&err);
void Task1 (void *p_arg)
for (;;)
flag1 = 1;
OSTimeDly (2);
flag1 = 0;
OSTimeDly (2);
void Task2 (void *p_arg)
for (;;)
flag2 = 1;
OSTimeDly (2);
flag2 = 0;
OSTimeDly (2);
void Task3 (void *p_arg)
for (;;)
flag3 = 1;
OSTimeDly (2);
flag3 = 0;
OSTimeDly (2);
现在我们来复原一下整个运行过程。
9.2 运行过程
9.2.1 在主函数中
- 系统初始化:初始化各种全局变量,初始化优先级表,初始化就绪列表,初始化空闲任务(包括初始化空闲任务栈和空闲任务 TCB)。
- CPU 初始化:暂为空。
- 关中断:因为此时 OS 未启动,若开启中断,那么 SysTick 将会引发中断,打断初始化流程。
- 初始化 SysTick:配置 SysTick 为 10ms 中断一次,Tick = 10ms。
- 创建任务:包括创建任务栈和任务 TCB,以及将 TCB 插入到就绪列表中,在优先级表对应位置置位。
- 启动系统:先找到最高优先级,然后开始运行最高优先级对应的任务(最高优先级为 1,即为 Task1),启动第一次任务切换(此时将完成最后的初始化流程,即有关 PendSV 的中断优先级配置,接着触发 PendSV 异常,发起任务切换),将 CPU 占有权交给任务 Task1。
9.2.2 在 Task1 中
- flag1 = 1。
- 执行到阻塞函数 OSTimeDly:在 Task1 的 TCB 中记录好延时时间(为 2),同时在优先级表中的相应位置(即优先级 1 的位置)清零。最后启动任务调度。
- 执行任务调度 OSSched:任务调度器先找到最高优先级,然后再找到最高优先级的任务 TCB。如果发现该任务就是当前任务,则不进行任务切换。在本案例中发现最高优先级为 2,对应任务是 Task2,不是当前任务,则发起任务切换(发起 PendSV 异常)。
- PendSV 异常处理程序:保存 Task1 的状态,加载 Task2 的状态,更新全局变量的值。
9.2.3 在 Task2 中
- flag2 = 1。
- 执行到阻塞函数 OSTimeDly:在 Task2 的 TCB 中记录好延时时间(为 2),同时在优先级表中的相应位置(即优先级 2 的位置)清零。最后启动任务调度。
- 执行任务调度 OSSched:任务调度器先找到最高优先级,然后再找到最高优先级的任务 TCB。如果发现该任务就是当前任务,则不进行任务切换。在本案例中发现最高优先级为 3,对应任务是 Task3,不是当前任务,则发起任务切换(发起 PendSV 异常)。
- PendSV 异常处理程序:保存 Task2 的状态,加载 Task3 的状态,更新全局变量的值。
9.2.4 在 Task3 中
- flag3 = 1。
- 执行到阻塞函数 OSTimeDly:在 Task3 的 TCB 中记录好延时时间(为 2),同时在优先级表中的相应位置(即优先级 31 的位置)清零。最后启动任务调度。
- 执行任务调度 OSSched:任务调度器先找到最高优先级,然后再找到最高优先级的任务 TCB。如果发现该任务就是当前任务,则不进行任务切换。在本案例中发现最高优先级为 31,对应任务是 空闲任务,不是当前任务,则发起任务切换(发起 PendSV 异常)。
- PendSV 异常处理程序:保存 Task3 的状态,加载空闲任务的状态,更新全局变量的值。
请注意,每次任务切换的时间其实非常短,大约只有不到 0.1ms 的长度,不会对 2ms 的延时造成很大的影响。
9.2.5 在空闲任务中 SysTick 发起中断
- 执行 OSTimeTick:遍历整个就绪列表,发现各个任务的延时未到时(此时为 2),全部减一;减一后(此时为 1)发现延时也未到时,说明任务还未到进入就绪态的时候。最后发起任务调度,发现不用进行任务切换,空闲任务继续运行。
- 再次发起中断,执行 OSTimeTick:遍历整个就绪列表,发现各个任务的延时未到时(此时为 1),全部减一;减一后(此时为 0)发现延时已到时,说明任务进入就绪态了。将 Task1、Task2、Task3 的优先级在优先级表中的相应位置重新置位。最后发起任务调度,发现最高优先级为 1,对应的是 Task1,切换到 Task1 运行。
9.2.6 又在 Task1 中
- 将全局变量 flag1 由 1 变成 0。
- 执行到阻塞函数 OSTimeDly:在 Task1 的 TCB 中记录好延时时间(为 2),同时在优先级表中的相应位置(即优先级 1 的位置)清零。最后启动任务调度。
- 执行任务调度 OSSched:任务调度器先找到最高优先级,然后再找到最高优先级的任务 TCB。如果发现该任务就是当前任务,则不进行任务切换。在本案例中发现最高优先级为 2,对应任务是 Task2,不是当前任务,则发起任务切换(发起 PendSV 异常)。
- PendSV 异常处理程序:保存 Task1 的状态,加载 Task2 的状态,更新全局变量的值。
如此反复,不再赘述。
9.3 实验现象
这是运行的仿真结果,实验现象符合以上分析,三个任务同时运行,就像多线程一样:
看起来三个任务同步运行,效率很高。不过放大后发现,三个任务的上升时间并不是严格同时的,而是略有先后:先是 Task1 上升,然后是 Task2,最后是 Task3,这中间的时间差就是任务切换的花费时间,大约是 0.1ms。
同理,三个任务的下降时间也是略有先后的:先是 Task1 下降,然后是 Task2,最后是 Task3,这中间的时间差也是任务切换的花费时间,大约是 0.1ms。
尝试:
- 如果将 Task1、Task2、Task3 的优先级分别改为 3、2、1,那么实验现象是:先是 Task3 上升,然后是 Task2,最后是 Task1,对于下降同理。因此,优先级影响着任务执行的先后顺序:先执行 Task3,然后切换到 Task2,最后切换到 Task1。
- 如果将 Task3 的优先级改为 2,那么 Task3 将不会被运行,因为优先级为 2 的任务有两个,目前只能运行其中一个(位于头指针的任务 TCB),我们还未实现任务轮转的功能。
以上是关于uCOS-III 学习记录——支持多优先级的主要内容,如果未能解决你的问题,请参考以下文章