uCOS-III 学习记录(3)——空闲任务和阻塞延时

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

文章目录

    • 1. 空闲任务
      • 1.1 数据类型定义
        • 1.1.1 空闲任务 TCB (os.h)
        • 1.1.2 空闲任务栈 (os\_cfg\_app.c)
      • 1.2 空闲任务函数 OS_IdleTask (os_core.c)
      • 1.3 空闲任务初始化函数 (os_core.c)
    • 2 阻塞延时
      • 2.1 数据类型定义
      • 2.2 阻塞延时函数 OSTimeDly (os_time.c)
      • 2.3 SysTick 发起中断后调用 OSTimeTick (os_time.c)
      • 2.4 任务调度 OSChed (os_core.c)
    • 3 实验:阻塞延时的运用
      • 3.1 主函数 (app.c)
      • 3.2 实验现象

1. 空闲任务

不知道有没有注意到这样一个问题:我在学习 x86 汇编语言的时候,曾详细研读过系统内核的代码,内核本身也是有自己的 TCB 的,内核可作为一个“任务管理器”来对其他任务进行创建、删除等操作。那么 uCOS 作为一个实时操作系统,内核也应该需要自己的任务和 TCB,因此我们需要创建一个空闲任务给内核,这样,在没有任务的时候,内核空转运行空闲任务,同时检查各个任务的状态以做出相应的操作(因此 uCOS 内核也可视为“任务管理器”)。

1.1 数据类型定义

空闲任务虽然与其他任务的作用不同,但它的本质依然是一个任务,TCB、任务栈一个都不能少。

1.1.1 空闲任务 TCB (os.h)

在 os.h 中定义 TCB:

OS_EXT  OS_TCB			OSIdleTaskTCB;

1.1.2 空闲任务栈 (os_cfg_app.c)

有关空闲任务栈的定义,并不在 os.h 中。

首先在 os_cfg_app.h 中定义了空闲任务栈的大小(感觉叫栈尺寸更合适?栈粒度应该是 4 字节):

/* 空闲任务栈大小 */
#define OS_CFG_IDLE_TASK_STK_SIZE		128u

然后,在 os_cfg_app.c 中定义栈和栈大小:

CPU_STK 	OSCfg_IdleTaskStk[OS_CFG_IDLE_TASK_STK_SIZE]; 		/* 空闲任务栈 */

CPU_STK		*const 	OSCfg_IdleTaskStkBasePtr = (CPU_STK *) &OSCfg_IdleTaskStk[0];	/* 空闲任务栈的起始地址 */
CPU_STK		 const	OSCfg_IdleTaskStkSize	 = (CPU_STK_SIZE) OS_CFG_IDLE_TASK_STK_SIZE;	/* 空闲任务栈的大小 */

1.2 空闲任务函数 OS_IdleTask (os_core.c)

作为一个任务,任务主体是不能缺的。

按照书上的教程,它定义了一个全局变量(OSIdleTaskCtr),用来计数。我不知道这个计数是干什么用的,我觉得在目前的学习阶段而言,空闲任务函数可以什么都不做。可能是作者觉得内核干一些无意义的事也好过什么事也不干吧。

typedef   CPU_INT32U	  OS_IDLE_CTR;

OS_EXT  OS_IDLE_CTR		OSIdleTaskCtr;

注意:

  • 本函数不允许用户调用。

以下是空闲任务函数,用来无聊的计数:

/* 空闲任务 */	
void OS_IdleTask (void *p_arg)
{
	p_arg = p_arg;
	
	/* 空闲任务什么都不做,只对全局变量OSIdleTaskCtr ++ 操作 */
	for (;;)
	{
		OSIdleTaskCtr++;
	}
}

1.3 空闲任务初始化函数 (os_core.c)

很简单,就完成两个功能:

  • 创建空闲任务:调用 OSTaskCreate 即可。
  • 计数清零:将 OSIdleTaskCtr 清零,为无聊的计数做准备。

注意:

  • 本函数不允许用户调用。
/* 空闲任务初始化函数 */ 
void OS_IdleTaskInit (OS_ERR *p_err)
{
	OSIdleTaskCtr = (OS_IDLE_CTR) 0;		/* 计数器清零 */
	
	OSTaskCreate ((OS_TCB*)      &OSIdleTaskTCB, 
	              (OS_TASK_PTR)  OS_IdleTask, 
	              (void *)       0,
	              (CPU_STK *)    OSCfg_IdleTaskStkBasePtr,
	              (CPU_STK_SIZE) OSCfg_IdleTaskStkSize,
	              (OS_ERR *)     &p_err);		/* 创建空闲任务 */
}

那么,在 OS 初始化的时候,调用该函数即可完成空闲任务的创建:

/* 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 */
	
	OS_RdyListInit();  /* 初始化就绪列表 */
	
	OS_IdleTaskInit(p_err); /* ----> 初始化空闲任务 */
	
	if (*p_err != OS_ERR_NONE) {
		return;
	}
}

2 阻塞延时

很多时候,某些任务运行到某处就需要延时一段时间,什么都不做。比如驱动某外设,需要按照时序,延时一段时间,再去访问接口。为了能榨干 CPU 的性能,不让它空转,在延时的这段时间内,还是要去完成其他的任务。

任务自行发起的延时,会使得任务自身发生阻塞,不再运行下去,这种延时就叫阻塞延时。而在阻塞延时期间,我们不让 CPU 闲着干等着,所以就有了任务切换(任务调度)。如果没有别的任务可以切换(调度),那就切换到内核的空闲任务。无论怎样,只要别让 CPU 闲着就行了。

2.1 数据类型定义

在 TCB 中加入了记录延时长度的成员,最小单位为 1 个 Tick,之前在上一篇笔记中我们初始化一个 Tick 为 10ms,因此最小单位为 10ms。

/* TCB 重命名为大写字母格式 */
typedef struct os_tcb	OS_TCB;

/* TCB 数据类型声明 */
struct os_tcb{
	CPU_STK			*StkPtr;
	CPU_STK_SIZE	StkSize;
	OS_TICK			TaskDelayTicks;		/* 任务延时多少个 Ticks,注意 1 个 Ticks 为 10ms */
};

下面来实现阻塞延时的函数。

2.2 阻塞延时函数 OSTimeDly (os_time.c)

一旦我们在任务中发起延时,那么在阻塞延时函数中完成两件事:

  • 延时长度记录到当前运行任务的 TCB 中,方便系统查看。
  • 发起任务切换(更准确的说法是任务调度)。
/* 阻塞延时 */
void OSTimeDly (OS_TICK dly)
{
	/* 延时时间 */
	OSTCBCurPtr->TaskDelayTicks = dly;
	/* 任务切换 */
	OSSched();
}

特别需要注意,阻塞延时函数跟软延时 Delay 的本质是不同的。软延时是 CPU 真的会卡在 for 循环里,什么事都干不了;而阻塞延时函数的实质是 CPU 设置了一下延时时间,然后就去忙别的了。那谁负责计时?当然是我们的 SysTick 了。

2.3 SysTick 发起中断后调用 OSTimeTick (os_time.c)

之前已提及,阻塞延时函数负责设置延时时间,书承上节内容,在 SysTick 发起一次中断时,表明一次 Tick 已经到来(在本案例中是 已经过去了 10ms),此时,把 TCB 中记录延时的数值减去 1,表示已经过去了一个 Tick(即过去了 10ms)。之后,还要发起一次任务调度,看看有没有任务已经延时结束的。

因此,实际上该函数起了这么一个作用:每隔 10ms,我帮你计数一次,起到了一个延时计数的功能。

void OSTimeTick (void)
{
	OS_PRIO i;
	
	/* 遍历整个就绪列表,如果延时未到时,则减 1 */
	for ( i = 0u; i < OS_CFG_PRIO_MAX; i++)
	{
		if ( OSRdyList[i].HeadPtr->TaskDelayTicks > 0u )
		{
			OSRdyList[i].HeadPtr->TaskDelayTicks --;
		}
	}
	
	/* 任务调度 */
	OSSched();  
}

2.4 任务调度 OSChed (os_core.c)

从现在起,该函数不再叫任务切换了,而是叫任务调度器,因为已经有三个任务了。

我们实现的任务调度的算法很简单,也很朴素,就是去一个个检查其他其他任务是否延时结束,如果某个任务延时结束了,那么就切换到这个任务去运行。如果找不到一个任务延时结束,那么就维持当前任务运行。

在这里,我们实现了两个用户任务,一个空闲任务。那么,SysTick 每发起一次中断就会调用本函数,检查的步骤为:

  • 如果当前任务为空闲任务,那么检查任务 1 和任务 2 是否延时结束。如果任务 1 延时结束,那么就运行任务 1 (OSTCBHighRdyPtr 指向任务 1 的 TCB);如果任务 2 延时结束,那么就运行任务 2 (OSTCBHighRdyPtr 指向任务 2 的 TCB)。
  • 如果当前任务为任务 1,那么检查任务 1 自己和任务 2 是否延时结束。如果任务 2 延时结束,那么就运行任务 2 (OSTCBHighRdyPtr 指向任务 2 的 TCB);如果任务 1 自己未延时结束,那么就运行空闲任务(OSTCBHighRdyPtr 指向空闲任务的 TCB)。
  • 如果当前任务为任务 2,那么检查任务 2 自己和任务 1 是否延时结束。如果任务 1 延时结束,那么就运行任务 1 (OSTCBHighRdyPtr 指向任务 1 的 TCB);如果任务 2 自己未延时结束,那么就运行空闲任务(OSTCBHighRdyPtr 指向空闲任务的 TCB)。
  • 最后,触发 PendSV 异常,保存上文,使 OSTCBCurPtr 获得 OSTCBHighRdyPtr,切换下文。

以上,就是我们实现的简单的调度算法。

/* 任务调度 */
void OSSched (void)
{
	if ( OSTCBCurPtr == &OSIdleTaskTCB )	/* (a) 假如现在的任务是空闲任务 */
	{
		if ( OSRdyList[0].HeadPtr->TaskDelayTicks == 0 )	/* 如果任务 1 延时结束 */
		{
			OSTCBHighRdyPtr = OSRdyList[0].HeadPtr;
		}
		else if ( OSRdyList[1].HeadPtr->TaskDelayTicks == 0 )	/* 如果任务 2 延时结束 */
		{
			OSTCBHighRdyPtr = OSRdyList[1].HeadPtr;
		}
		else
		{
			return;
		}
	}
	else if ( OSTCBCurPtr == OSRdyList[0].HeadPtr )	/* (b) 假如现在的任务是任务 1 */
	{
		if ( OSRdyList[1].HeadPtr->TaskDelayTicks == 0 )	/* 如果任务 2 延时结束 */
		{
			OSTCBHighRdyPtr = OSRdyList[1].HeadPtr;
		}
		else if ( OSTCBCurPtr->TaskDelayTicks != 0 )	/* 如果任务 1 自己还在延时 */
		{
			OSTCBHighRdyPtr = &OSIdleTaskTCB;
		}
		else
		{
			return;
		}
	}
	else if ( OSTCBCurPtr == OSRdyList[1].HeadPtr )	/* (c) 假如现在的任务是任务 2 */
	{
		if ( OSRdyList[0].HeadPtr->TaskDelayTicks == 0 )	/* 如果任务 1 延时结束 */
		{
			OSTCBHighRdyPtr = OSRdyList[0].HeadPtr;
		}
		else if ( OSTCBCurPtr->TaskDelayTicks != 0 )	/* 如果任务 2 自己还在延时 */
		{
			OSTCBHighRdyPtr = &OSIdleTaskTCB;
		}
		else
		{
			return;
		}
	}
	
	OS_TASK_SW();
}

最后一个困惑:为什么要将 TCB 指针赋值给 OSTCBHighRdyPtr 而不是 OSTCBCurPtr 呢?我个人理解:因为 uCOS 是抢占式多任务,将任务 A 赋值给最高优先级时,当前任务会被切换为该任务 A。而且可以看看 PendSV 异常汇编程序,你会发现它实现的最核心的东西其实是 OSTCBCurPtr = OSTCBHighRdyPtr。我现在不是很懂,也许学到后面会逐渐明白的吧。

3 实验:阻塞延时的运用

3.1 主函数 (app.c)

在任务中,实现了阻塞延时,去掉了软件延时和手动切换任务。

#include "ARMCM3.h"
#include "os.h"

#define  TASK1_STK_SIZE       20
#define  TASK2_STK_SIZE       20

static   CPU_STK   Task1Stk[TASK1_STK_SIZE];
static   CPU_STK   Task2Stk[TASK2_STK_SIZE];

static   OS_TCB    Task1TCB;
static   OS_TCB    Task2TCB;

uint32_t flag1;
uint32_t flag2;

void Task1 (void *p_arg);
void Task2 (void *p_arg);
void delay(uint32_t count);

int main (void)
{
	OS_ERR err;
	
	/* 初始化相关的全局变量,创建空闲任务 */
	OSInit(&err);
	
	/* 关中断,因为此时 OS 未启动,若开启中断,那么 SysTick 将会引发中断 */
	CPU_IntDis();
	
	/* 初始化 SysTick,配置 SysTick 为 10ms 中断一次,Tick = 10ms */
	OS_CPU_SysTickInit(10);
	
	/* 创建任务 */
	OSTaskCreate ((OS_TCB*)      &Task1TCB, 
	              (OS_TASK_PTR) Task1, 
	              (void *)       0,
	              (CPU_STK*)     &Task1Stk[0],
	              (CPU_STK_SIZE) TASK1_STK_SIZE,
	              (OS_ERR *)     &err);

	OSTaskCreate ((OS_TCB*)      &Task2TCB, 
	              (OS_TASK_PTR) Task2, 
	              (void *)       0,
	              (CPU_STK*)     &Task2Stk[0],
	              (CPU_STK_SIZE) TASK2_STK_SIZE,
	              (OS_ERR *)     &err);
				  
	/* 将任务加入到就绪列表 */
	OSRdyList[0].HeadPtr = &Task1TCB;
	OSRdyList[1].HeadPtr = &Task2TCB;
	
	/* 启动OS,将不再返回 */				
	OSStart(&err);
}

void Task1 (void *p_arg)
{
	for (;;)
	{
		flag1 = 1;
		OSTimeDly (2);	// 20ms
		flag1 = 0;
		OSTimeDly (2);
	}
	// 不用手动任务切换
}

void Task2 (void *p_arg)
{
	for (;;)
	{
		flag2 = 1;
		OSTimeDly (2);		
		flag2 = 0;
		OSTimeDly (2);
	}
	// 不用手动任务切换
}

(1)初始化流程如下:

  • OS 初始化:完成就绪列表和空闲任务的初始化。
  • 关闭中断。
  • SysTick 初始化:设置一个滴答为 10ms。
  • 创建任务。
  • 将任务加入就绪列表。
  • OS 启动:启动任务切换,先运行就绪列表里的第一个任务 Task1。

(2)在第一个任务 Task1 中,执行 Flag1 = 1 后,执行到 OSTimeDly:

  • 将当前任务 TCB 的记录延时成员设置好。
  • 由 OSSched 进行任务调度。
  • 因为此时没有别的任务运行,所以会被切换到 Task2。

(3)在 Task2 中,执行 Flag2 = 1 后,也执行到 OSTimeDly:

  • 将当前任务 TCB 的记录延时成员设置好。
  • 由 OSSched 进行任务调度。
  • 因为此时 Task1 仍处于阻塞状态,所以会被切换到空闲任务。

(4)在运行空闲任务的同时,SysTick 也在工作中:

  • 发现一个 Tick 到来了,说明 10ms 间隔已到,发起中断 SysTick_Handler。
  • 执行函数 OSTimeTick,将所有任务 TCB 中的延时时长全部减 1,表示已过去了 10ms。
  • 发起 OSSched 进行任务调度。
  • 因为这时两个任务仍在阻塞中,所以继续切换到空闲任务。
  • 这样,每发起一次 Tick,都会减去 1,同时去检查两个任务是否还在阻塞中,CPU 一直运行空闲任务。直到,当两个任务同时阻塞完毕的时候(因为我们设置的两个任务阻塞时间相同),又是一次 Tick 的到来,此时空闲任务将切换到 Task1(因为任务调度函数中判断 Task1 是否阻塞是写在前面的)。此时你发现又回到了第(2)个步骤,只不过这一次是 Flag1 = 0,后面的运行过程就不多说了。

所以,你发现了一个什么问题?就是,任务调度(OSSched)会发生在设置延时时间(OSTimeDly)和中断发起(SysTick_Handler)的时候,这意味这两个函数都有可能引发 PendSV 异常。

3.2 实验现象

uCOS-III 学习记录(3)——空闲任务和阻塞延时_第1张图片

可以发现,因为我们延时的长度一样,所以两个任务几乎是同时进行的,按照上面的分析,确实就是这个样子,看起来就像是并行线程,很神奇吧!

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