uCOS-III 学习记录(8)——支持多优先级

参考内容:《[野火]uCOS-III内核实现与应用开发实战指南——基于STM32》第 12 章。

文章目录

    • 0 数据类型定义和宏定义
      • 0.1 临界段宏定义(os.h)
      • 0.2 任务控制块 TCB 定义(os.h)
      • 0.3 任务就绪列表定义(os.h)
      • 0.4 优先级相关变量定义(os.h)
    • 1 系统初始化 OSInit()(os_core.c)
    • 2 任务创建函数 OSTaskCreate()(os_task.c)
      • 2.1 初始化任务控制块 OS_TaskInitTCB()(os_task.c)
    • 3 空闲任务初始化 OS_IdleTaskInit()(os_core.c)
    • 4 系统启动 OSStart()(os_core.c)
    • 5 可悬起系统调用中断服务程序 PendSV_Handler()(os_cpu_a.s)
    • 6 阻塞延时 OSTimeDly()(os_time.c)
    • 7 任务切换 OSSched()(os_core.c)
    • 8 SysTick 发起中断后调用 OSTimeTick()(os_time.c)
    • 9 将之前所添加的内容进行运用
      • 9.1 主函数 main()(app.c)
      • 9.2 运行过程
        • 9.2.1 在主函数中
        • 9.2.2 在 Task1 中
        • 9.2.3 在 Task2 中
        • 9.2.4 在 Task3 中
        • 9.2.5 在空闲任务中 SysTick 发起中断
        • 9.2.6 又在 Task1 中
      • 9.3 实验现象

本篇内容主要是对过往函数的一些修改,因此,一些细节将不会赘述。

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 实验现象

这是运行的仿真结果,实验现象符合以上分析,三个任务同时运行,就像多线程一样:

uCOS-III 学习记录(8)——支持多优先级_第1张图片

看起来三个任务同步运行,效率很高。不过放大后发现,三个任务的上升时间并不是严格同时的,而是略有先后:先是 Task1 上升,然后是 Task2,最后是 Task3,这中间的时间差就是任务切换的花费时间,大约是 0.1ms。

uCOS-III 学习记录(8)——支持多优先级_第2张图片

同理,三个任务的下降时间也是略有先后的:先是 Task1 下降,然后是 Task2,最后是 Task3,这中间的时间差也是任务切换的花费时间,大约是 0.1ms。

uCOS-III 学习记录(8)——支持多优先级_第3张图片

尝试:

  • 如果将 Task1、Task2、Task3 的优先级分别改为 3、2、1,那么实验现象是:先是 Task3 上升,然后是 Task2,最后是 Task1,对于下降同理。因此,优先级影响着任务执行的先后顺序:先执行 Task3,然后切换到 Task2,最后切换到 Task1。
  • 如果将 Task3 的优先级改为 2,那么 Task3 将不会被运行,因为优先级为 2 的任务有两个,目前只能运行其中一个(位于头指针的任务 TCB),我们还未实现任务轮转的功能。

你可能感兴趣的:(#,uC/OS-III,学习笔记,ucos,stm32,rtos,嵌入式)