uCOS-III 学习记录(9)——时基列表

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

文章目录

    • 1 数据类型定义和宏定义
      • 1.1 时基列表相关宏定义和全局变量(os_cfg_app.h/c & os.h)
      • 1.2 时基列表定义(os.h)
      • 1.3 修改 TCB 定义(os.h)
    • 2 时基列表的相关函数
      • 2.1 初始化时基列表 OS_TickListInit()(os_tick.c)
      • 2.2 往时基列表插入任务控制块 OS_TickListInsert()(os_tick.c)
      • 2.3 在时基列表删除一个指定的任务控制块 OS_TickListRemove()
      • 2.4 检查任务延时是否到期 OS_TickListUpdate()(os_tick.c)
      • 2.5 时基列表运行全景
    • 3 添加和修改相应代码
      • 3.1 将任务设置为就绪态 OS_TaskRdy()(os_core.c)
      • 3.2 阻塞延时函数 OSTimeDly()(os_time.c)
      • 3.3 SysTick 发起中断调用 OSTimeTick()(os_time.c)
    • 4 时基列表的应用
      • 4.1 主函数 main(app.c)
      • 4.2 运行过程
        • 4.2.1 在主函数中
        • 4.2.2 在 Task1 中
        • 4.2.3 在 Task2 中
        • 4.2.4 在 Task3 中
        • 4.2.5 在空闲任务中 SysTick 发起中断
        • 4.2.6 又在 Task1 中
      • 4.3 实验现象

1 数据类型定义和宏定义

1.1 时基列表相关宏定义和全局变量(os_cfg_app.h/c & os.h)

在 os_cfg_app.h 中,宏定义时基列表的大小,其推荐值为任务数/4,推荐使用质数,不推荐使用偶数。如果算出来的大小是偶数,则需加 1 变成质数。

/* 时基列表大小 */
#define OS_CFG_TICK_WHEEL_SIZE			17u

接下来在 os_cfg_app.c 中,定义两个全局变量,分别是时基列表(数组)和时基列表的大小。注意需要在 os.h 中声明。

OS_TICK_SPOKE		OSCfg_TickWheel[OS_CFG_TICK_WHEEL_SIZE];		/* 时基列表 */
OS_OBJ_QTY	const	OSCfg_TickWheelSize = (OS_OBJ_QTY)OS_CFG_TICK_WHEEL_SIZE;	/* 时基列表大小 */

在 os.h 中定义 32 位的 Tick 计数器,即 SysTick 周期计数器,记录系统启动到现在或者从上一次复位到现在经过了多少个 SysTick 周期。每发起一次 SysTick 中断,该变量就会加一。

OS_EXT	OS_TICK			OSTickCtr;		/* SysTick 周期计数器 */

1.2 时基列表定义(os.h)

在 os.h 中定义时基列表结构体,其组成为:

  • FirstPtr:用于指向 TCB 双向链表的第一个节点。时基列表的每个数组元素都记录着一条 TCB 单向链表的信息,被插入该条链表的 TCB 会按照延时时间做升序排列。
  • NbrEntries:记录 TCB 链表有多少个节点。
  • NbrEntriesMax:记录 TCB 链表最多的时候有多少个节点,在节点增加时会刷新,在删除节点时不刷新。
typedef struct os_tick_spoke 	OS_TICK_SPOKE;					/* 时基列表重命名为大写字母格式 */

struct os_tick_spoke{
	OS_TCB		*FirstPtr;			/* TCB 单向链表的头节点 */
	OS_OBJ_QTY	NbrEntries;			/* 单向链表有多少个节点 */
	OS_OBJ_QTY	NbrEntriesMax;		/* 单向链表最多时有多少个节点,该值会被刷新 */
};

1.3 修改 TCB 定义(os.h)

在 TCB 中新增加了 5 个成员,分别是:

  • TickNextPtr:双向链表中指向下一个 TCB 节点。
  • TickPrevPtr:双向链表中指向上一个 TCB 节点。
  • TickSpokePtr:指向时基列表数组的指针,即用来指示该任务 TCB 属于哪条双向链表。
  • TickCtrMatch:该值表示当前时基计数器的值加上任务要延时的周期。
  • TickRemain:表示任务还需要延时多少个 SysTick 周期。该变量替代了 TaskDelayTicks 的功能,所以可以去掉 TaskDelayTicks。
struct os_tcb{
	CPU_STK			*StkPtr;
	CPU_STK_SIZE	StkSize;
	
	//OS_TICK			TaskDelayTicks;		/* 任务延时周期个数 */
	
	OS_PRIO			Prio;				/* 任务优先级 */
	
	OS_TCB			*NextPtr;			/* 就绪列表双向链表的下一个指针 */
	OS_TCB			*PrevPtr;			/* 就绪列表双向链表的前一个指针 */
	
	OS_TCB			*TickNextPtr;		/* 指向时基列表双向链表的下一个 TCB 节点 */
	OS_TCB			*TickPrevPtr;		/* 指向时基列表双向链表的上一个 TCB 节点 */
	OS_TICK_SPOKE	*TickSpokePtr;		/* 用于回指到链表根部 */
	
	OS_TICK			TickCtrMatch;		/* 该值等于时基计数器 OSTickCtr 的值加上 TickRemain 的值 */
	OS_TICK			TickRemain;			/* 设置任务还需要等待多少个时钟周期 */
};

因此,目前实现的 uCOS 一共有两个列表:就绪列表和时基列表,它们均根据自己的规则建立一个 TCB 双向链表,列表中的数组会存放双向链表的信息。就绪列表的数组下标表示优先级,时基列表的数组下标表示时间周期。

下图展示的是时基列表的结构,它其中一个数组元素存储了一条 TCB 双向链表信息,这是一条有 3 个节点的双向链表,注意每个节点都回指了这个数组元素的地址,第三个节点是漏画了。

uCOS-III 学习记录(9)——时基列表_第1张图片

2 时基列表的相关函数

2.1 初始化时基列表 OS_TickListInit()(os_tick.c)

该函数用于初始化时基列表数组,将全部成员清零。

/* 初始化时基列表 */
void OS_TickListInit (void)
{
	OS_TICK_SPOKE_IX	i;
	OS_TICK_SPOKE		*p_spoke;
	
	for (i = 0u; i < OSCfg_TickWheelSize; i++)
	{
		p_spoke 				= (OS_TICK_SPOKE *)&OSCfg_TickWheel[i];
		p_spoke->FirstPtr 		= (OS_TCB        *)0;
		p_spoke->NbrEntries 	= (OS_OBJ_QTY     )0u;
		p_spoke->NbrEntriesMax 	= (OS_OBJ_QTY     )0u;
	}
}

需要在 OSInit() 中调用此函数以完成初始化工作。初始化后的时基列表如下所示:

uCOS-III 学习记录(9)——时基列表_第2张图片

2.2 往时基列表插入任务控制块 OS_TickListInsert()(os_tick.c)

该函数的作用是将任务 TCB 插入到时基列表中,即对应的 TCB 双向链表,注意这是一个升序排序的双向链表,按照延时时间的长度升序排序。该函数完成的工作有:

  • 获得该任务要延时的时间 time 后,在 TCB 中记录延时到期时的时间,即将当前时基计数器的值加上任务要延时的时间记录在 TickCtrMatch。
  • 在 TCB 中记录任务要延时的时间。TickRemain 的功能可等价为 TaskDelayTicks 的功能。

我们先停一下,举个例子来理解上面的原理。比如现在时基计数器 OSTickCtr = 10(即从系统启动到现在已经过去了 10 个 SysTick 周期),任务需要延时的时间 time(TickRemain) = 2(即任务需要延时 2 个 SysTick 周期),那么意味着当 OSTickCtr = 12 (即从系统启动到现在已经过去了 12 个 SysTick 周期)时任务延时结束,此处的 12 就是 TickCtrMatch 的值。当时基计数器等于 12 时,捕捉到该任务延时结束(所以这也是 Match 的意思?)。

嗯…看到这,你是不是觉得 OSTickCtr 有点像时间戳的作用了…但其实,OSTickCtr 记录的是“周期的时间戳”,而真正的时间戳记录的可是真实的时间哦!

有意思的是,TickRemain 其实可有可无,它更多的是作为计算剩余时间时的过渡变量,在本节涉及到 TickRemain 的代码中有反应这一点。而在 2.4 节中,你可以试着注释掉涉及到 TickRemain 的代码行,你会发现这对仿真结果没有一点影响。

回忆一下前几章中任务延时的办法:SysTick 发起一次中断,系统就遍历就绪列表中的 TCB,给每个 TCB 中的 TaskDelayTicks 减一。现在我们的做法是:定义了一个全局变量,从系统启动就开始计数。任务结束延时的时期,就是这个全局变量加上延时的周期长度,这个值我们记录在 TCB 中。为什么要换方法呢?你看看这两种办法的区别:前者是我们帮每个 TCB 减一,因此比较麻烦;后者是我们在外面计总的时间,你们这些要延时的 TCB 自己看好时间,到时间后你自己站出来报到。而且更绝的是,我们将这些 TCB 按照延时时间排好顺序,如果前一个 TCB 延时时间未到,那后面的 TCB 看都不用看,肯定没到时间。你看,把复杂的事情简单化,uCOS 绝吧!

  • TickCtrMatch 除以时基列表的数组大小 OSCfg_TickWheelSize 求余,作为下标访问时基列表数组。

继续以上面例子为例来说明。现在,TickCtrMatch = 12,我们定义 OSCfg_TickWheelSize = 17,求余后是 12,因此要访问的是 OSCfg_TickWheel[12]。这里运用了哈希算法。接下来,这个任务将插入到 OSCfg_TickWheel[12] 下的双向升序链表中,剩余的工作就是大家熟悉的插入链表操作了。

  • 如果双向链表为空:则该 TCB 的前向、后向指针域皆为零。
  • 如果双向链表不为空:需要遍历整个链表,访问每一个节点,计算该节点的剩余时间,与待插入节点的剩余时间比较一下:如果被访问节点的大,那就插入到它前面去;否则,就是待插入节点的大了,插入到被访问节点的后面去。如果遍历完了都没找到比待插入节点大的,那就排在最后面去。
  • 最后,新插入的 TCB 的 TickSpokePtr 需要指向对应的数组元素。

继续以上面例子说明。这个任务已经插入到 OSCfg_TickWheel[12] 下的双向升序链表中了,那么该任务 TCB 的 TickSpokePtr 将指向 OSCfg_TickWheel[12],以说明自己在时基列表中的第 12 个位置。

/* 往时基列表插入一个任务 TCB,根据延时时间的大小升序排列 */
void OS_TickListInsert (OS_TCB *p_tcb, OS_TICK time)
{
	OS_TICK_SPOKE_IX	spoke;
	OS_TICK_SPOKE		*p_spoke;
	OS_TCB				*p_tcb0;
	OS_TCB				*p_tcb1;
	
	/* TickCtrMatch 等于当前时基计数器的值加上任务要延时的时间 */
	p_tcb->TickCtrMatch = OSTickCtr + time;	
	
	/* TickRemain 表示任务还需要多少个 SysTick 周期,每来一个周期就会减一 */
	p_tcb->TickRemain   = time;		
	
	/* (哈希算法)求余得到的 spoke 作为时基列表 OSCfg_TickWheel[] 的索引 */
	spoke 	= (OS_TICK_SPOKE_IX)(p_tcb->TickCtrMatch % OSCfg_TickWheelSize);
	
	/* 获取该双向链表的根指针 */
	p_spoke = &OSCfg_TickWheel[spoke];
	
	/* 若双向链表为空 */
	if (p_spoke->NbrEntries == (OS_OBJ_QTY)0u)
	{
		p_tcb->TickNextPtr  = (OS_TCB   *)0;
		p_tcb->TickPrevPtr  = (OS_TCB   *)0;
		p_spoke->FirstPtr   =  p_tcb;
		p_spoke->NbrEntries = (OS_OBJ_QTY)1u;
	}
	else /* 若双向链表不为空 */
	{
		p_tcb1 = p_spoke->FirstPtr;		/* 先获取第一个节点 */	
		/* 开始遍历双向链表 */
		while (p_tcb1 != (OS_TCB *)0)
		{
			p_tcb1->TickRemain = p_tcb1->TickCtrMatch - OSTickCtr;	/* 计算被访问节点的剩余时间 */
			if (p_tcb->TickRemain > p_tcb1->TickRemain)	/* (1) 如果新节点的剩余时间大于被访问节点的剩余时间 */
			{
				if (p_tcb1->NextPtr != (OS_TCB *)0)		/* (1.1) 如果被访问节点不是最后一个节点 */
				{
					p_tcb1 = p_tcb1->NextPtr;			/* 访问下一个节点,继续查找 */
				}
				else		/* (1.2) 否则,意味着整个链表已经遍历完毕,新节点的剩余时间最大,在最后一个节点插入新节点 */
				{
					p_tcb->TickNextPtr  = (OS_TCB *)0;
					p_tcb->TickPrevPtr  =  p_tcb1;
					p_tcb1->TickNextPtr =  p_tcb;
					p_tcb1 = (OS_TCB *)0;		/* 插入操作完成后清零,下一次将跳出循环 */
				}
			}
			else /* (2) 否则,被访问节点的剩余时间小于等于新节点的剩余时间,则插入到该节点前面 */
			{
				if (p_tcb1->TickPrevPtr == (OS_TCB *)0) /* (2.1) 如果被访问节点是第一个节点 */
				{
					p_tcb->TickPrevPtr  = (OS_TCB *)0;
					p_tcb->TickNextPtr  = p_tcb1;
					p_tcb1->TickPrevPtr = p_tcb;
					p_spoke->FirstPtr   = p_tcb;
				}
				else		/* (2.2) 否则,是在两个节点之间插入新节点 */
				{
					p_tcb0              = p_tcb1->TickPrevPtr;
					p_tcb->TickPrevPtr  = p_tcb0;
					p_tcb->TickNextPtr  = p_tcb1;
					p_tcb0->TickNextPtr = p_tcb;
					p_tcb1->TickPrevPtr = p_tcb;
				}
				p_tcb1 = (OS_TCB *)0;		/* 插入操作完成后清零,下一次将跳出循环 */
			}
		}
		p_spoke->NbrEntries++;		/* 节点数加一 */
	}
	
	if (p_spoke->NbrEntriesMax < p_spoke->NbrEntries)	/* 刷新最大值 */
	{
		p_spoke->NbrEntriesMax = p_spoke->NbrEntries;
	}
	
	/* 任务 TCB 中的 TickSpokePtr 回指根节点 */
	p_tcb->TickSpokePtr = p_spoke;	
}

再举个例子。我们现在 OSTickCtr = 10,OSCfg_TickWheelSize = 12,有以下三个任务,情况分别是:

  • 任务 1:需要延时 1 个周期。因此,TickRemain = 1,TickCtrMatch = 11,需要插入的数组下标是 11 % 12 = 11。
  • 任务 2:需要延时 13 个周期。因此,TickRemain = 13,TickCtrMatch = 23,需要插入的数组下标是 23 % 12 = 11。
  • 任务 3:需要延时 25 个周期。因此,TickRemain = 25,TickCtrMatch = 35,需要插入的数组下标是 35 % 12 = 11。

那么插入时基列表后的情况如下图:

uCOS-III 学习记录(9)——时基列表_第3张图片

注意,这三个任务 TCB 都在同一条链表中,那只是数字凑巧而已。假如我把任务 2 的延时改为 14 个周期,那么插入的数组下标是 0,会插到别的链表中。

2.3 在时基列表删除一个指定的任务控制块 OS_TickListRemove()

该函数是在时基列表中删除一个指定的任务 TCB,完成的工作有:

  • 根据 TCB 的 TickSpokePtr,获取对应的时基列表数组元素,进而获取链表的头指针。
  • 若头指针为空,则说明链表不存在,直接退出。
  • 若不为空,说明链表存在,删除指定节点。
  • 删除完后,将该 TCB 的前向、后向指针域、剩余时间全部清零。节点数减一。
/* 往时基列表删除一个指定的任务 TCB */
void OS_TickListRemove (OS_TCB *p_tcb)
{
	OS_TICK_SPOKE		*p_spoke;
	OS_TCB				*p_tcb1;
	OS_TCB				*p_tcb2;
	
	/* 获取任务 TCB 所在链表的根指针 */
	p_spoke = p_tcb->TickSpokePtr;
	
	if (p_spoke != (OS_TICK_SPOKE *)0)		/* 若链表存在 */
	{
		if (p_tcb == p_spoke->FirstPtr)		/* (1) 如果被删除的节点是第一个节点 */
		{
			p_tcb1 = p_tcb->TickNextPtr;
			p_spoke->FirstPtr = p_tcb1;
			if (p_tcb1 != (OS_TCB *)0)	/* 若删除后链表非空,则新的头节点的前向指针域设为 0,否则不用操作 */
			{
				p_tcb1->TickPrevPtr = (OS_TCB *)0;
			}
		}
		else								/* (2) 如果被删除的节点不是第一个节点 */
		{
			p_tcb1 = p_tcb->TickPrevPtr;
			p_tcb2 = p_tcb->TickNextPtr;
			p_tcb1->TickNextPtr = p_tcb2;
			if (p_tcb2 != (OS_TCB *)0)	/* 若删除的不是最后一个节点,则新的尾节点的前向指针域设为 0,否则不用操作 */
			{
				p_tcb2->TickPrevPtr = p_tcb1;
			}
		}
		
		p_tcb->TickNextPtr 	= (OS_TCB *)0;
		p_tcb->TickPrevPtr 	= (OS_TCB *)0;
		p_tcb->TickSpokePtr = (OS_TICK_SPOKE *)0;
		p_tcb->TickRemain 	= (OS_TICK)0u;	/* 剩余时间清零 */
		p_tcb->TickCtrMatch = (OS_TICK)0u;
		
		p_spoke->NbrEntries--;		/* 节点数减一 */
	}
}

2.4 检查任务延时是否到期 OS_TickListUpdate()(os_tick.c)

该函数的作用是:更新时基计数器,扫描时基列表中的任务延时是否到期。完成的工作是:

  • 时基计数器加一。
  • 由当前时基计数器的值求余,获得时基列表的数组下标,进而获得对应的双向链表。
  • 开始遍历链表,访问每一个节点,若发现有节点延时未到,那么后面的节点就不用访问了,因为链表是升序排序的,后面的节点延时肯定未到;若发现有节点延时到了,那么将该任务设置为就绪态,然后继续访问下一个节点。

发现了吗?访问时基列表的哪个数组元素,是跟当前时基计数器的值是息息相关的,通过哈希算法来访问对应的数组元素。不过,这样做的目的似乎不是很明确(?)。

/* 更新时基计数器,扫描时基列表中的任务延时是否到期 */
void OS_TickListUpdate (void)
{
	OS_TICK_SPOKE_IX	spoke;
	OS_TICK_SPOKE		*p_spoke;
	OS_TCB				*p_tcb;
	OS_TCB				*p_tcb_next;
	CPU_BOOLEAN			done;
	
	CPU_SR_ALLOC();
	OS_CRITICAL_ENTER();
	
	/* 时基计数器加一 */
	OSTickCtr++;
	
	/* (哈希算法)求余得到的 spoke 作为时基列表 OSCfg_TickWheel[] 的索引 */
	spoke 	= (OS_TICK_SPOKE_IX)(OSTickCtr % OSCfg_TickWheelSize);
	
	/* 获取该双向链表的根指针 */
	p_spoke = &OSCfg_TickWheel[spoke];
	
	/* 获取该双向链表的第一个节点 */	
	p_tcb   = p_spoke->FirstPtr;	
	done    = DEF_FALSE;
	
	while (done == DEF_FALSE)
	{
		if (p_tcb != (OS_TCB *)0)	/* 若节点存在 */
		{
			p_tcb_next = p_tcb->TickNextPtr;
			p_tcb->TickRemain = p_tcb->TickCtrMatch - OSTickCtr;	/* 计算节点的剩余时间 */
			
			if (OSTickCtr == p_tcb->TickCtrMatch)	/* 如果节点的延时时间已到 */
			{
				OS_TaskRdy (p_tcb);					/* 则让任务就绪 */
			}
			else	/* 否则,节点的延时时间未到 */
			{
				done = DEF_TRUE;	/* 则退出循环,因为链表节点按延时时间升序排列,该节点的延时时间未到,后面的节点肯定未到 */
			}
			p_tcb = p_tcb_next;
		}
		else
		{
			done = DEF_TRUE;
		}
	}
	
	OS_CRITICAL_EXIT();
}

举个例子。我们定义 OSCfg_TickWheelSize = 12,在 OSTickCtr = 7 时,插入了以下三个任务,情况分别是:

  • 任务 1:需要延时 16 个周期。因此,TickRemain = 16,TickCtrMatch = 28,需要插入的数组下标是 11 % 12 = 11。
  • 任务 2:需要延时 28 个周期。因此,TickRemain = 28,TickCtrMatch = 35,需要插入的数组下标是 23 % 12 = 11。
  • 任务 3:需要延时 40 个周期。因此,TickRemain = 40,TickCtrMatch = 47,需要插入的数组下标是 35 % 12 = 11。

时基列表的情况如下图:

uCOS-III 学习记录(9)——时基列表_第4张图片

当 SysTick 中断来临时,OSTickCtr = 8,对 OSCfg_TickWheelSize(等于 12)求余等于 8,则对 OSCfg_TickWheel[8] 下面的链表进行扫描,从图中可以得知,8 这个索引下没有节点,则直接退出。这三个 TCB 是在 OSCfg_TickWheel[11] 下的链表,根本不用扫描,因为时间只是刚刚过了 1 个时钟周期而已,它们只是刚刚插入时基列表,远远没有达到它们需要的延时时间。

2.5 时基列表运行全景

当我们把时基列表的相关代码都实现出来以后,很有意思的事情发生了:我们假定 OSCfg_TickWheelSize = 17,即时基列表的大小为 17,那么:

  • 在系统刚启动时 OSTickCtr = 0;
  • SysTick 中断发生后 OSTickCtr = 1,只检查 OSCfg_TickWheel[1];
  • SysTick 中断又发生后 OSTickCtr = 2,只检查 OSCfg_TickWheel[2];
  • SysTick 中断又发生后 OSTickCtr = 3,只检查 OSCfg_TickWheel[3];
  • SysTick 中断又发生后 OSTickCtr = 16,只检查 OSCfg_TickWheel[16];
  • SysTick 中断又发生后 OSTickCtr = 17,只检查 OSCfg_TickWheel[0];
  • SysTick 中断又发生后 OSTickCtr = 18,只检查 OSCfg_TickWheel[1];
  • SysTick 中断又发生后 OSTickCtr = 33,只检查 OSCfg_TickWheel[16];
  • SysTick 中断又发生后 OSTickCtr = 34,只检查 OSCfg_TickWheel[0];
  • SysTick 中断又发生后 OSTickCtr = 35,只检查 OSCfg_TickWheel[1];

这样循环往复的检查每一个数组元素。这时我们插入一个需要延时的 TCB 会怎样呢?假设在 OSTickCtr = 4 时插入一个 TCB,延时时长为 3,那么:

  • 在系统刚启动时 OSTickCtr = 0;
  • SysTick 中断发生后 OSTickCtr = 1,只检查 OSCfg_TickWheel[1],发现没有任务;
  • SysTick 中断又发生后 OSTickCtr = 2,只检查 OSCfg_TickWheel[2],发现没有任务;
  • SysTick 中断又发生后 OSTickCtr = 3,只检查 OSCfg_TickWheel[3],发现没有任务;
  • SysTick 中断又发生后 OSTickCtr = 4,只检查 OSCfg_TickWheel[4],发现没有任务;接着任务发起阻塞,延时时间为 3,计算得出在 OSTickCtr = 7 时延时到期(TickCtrMatch = 7),因此在 OSCfg_TickWheel[7] 下插入 TCB;
  • SysTick 中断又发生后 OSTickCtr = 5,只检查 OSCfg_TickWheel[5],发现没有任务;
  • SysTick 中断又发生后 OSTickCtr = 6,只检查 OSCfg_TickWheel[6],发现没有任务;
  • SysTick 中断又发生后 OSTickCtr = 7,只检查 OSCfg_TickWheel[7],发现有任务,而且 TickCtrMatch == OSTickCtr,延时到期,移出时基列表;

我们再假设在 OSTickCtr = 25 时插入一个 TCB,延时时长为 19,(OSCfg_TickWheelSize = 17)那么:

  • 在系统刚启动时 OSTickCtr = 0;
  • SysTick 中断发生后 OSTickCtr = 1,只检查 OSCfg_TickWheel[1],发现没有任务;
  • SysTick 中断又发生后 OSTickCtr = 2,只检查 OSCfg_TickWheel[2],发现没有任务;
  • SysTick 中断又发生后 OSTickCtr = 3,只检查 OSCfg_TickWheel[3],发现没有任务;
  • SysTick 中断又发生后 OSTickCtr = 25,只检查 OSCfg_TickWheel[8],发现没有任务;接着任务发起阻塞,延时时间为 19,计算得出在 OSTickCtr = 44 时延时到期(TickCtrMatch = 44),因此在 OSCfg_TickWheel[10] 下插入 TCB;
  • SysTick 中断又发生后 OSTickCtr = 26,只检查 OSCfg_TickWheel[9],发现没有任务;
  • SysTick 中断又发生后 OSTickCtr = 27,只检查 OSCfg_TickWheel[10],发现有任务,但是未到期(TickCtrMatch != OSTickCtr),继续位于时基列表中;
  • SysTick 中断又发生后 OSTickCtr = 43,只检查 OSCfg_TickWheel[9],发现没有任务;
  • SysTick 中断又发生后 OSTickCtr = 44,只检查 OSCfg_TickWheel[10],发现有任务,而且 TickCtrMatch == OSTickCtr,延时到期,移出时基列表;

希望这样写有助于大家理解整个时基列表的运行机制。

3 添加和修改相应代码

3.1 将任务设置为就绪态 OS_TaskRdy()(os_core.c)

这是一个新加入的函数,位于 os_core.c 中,作用是将任务设置为就绪态,具体操作是:

  • 从时基列表中删除该 TCB。
  • 在就绪列表中加入该 TCB。
/* 任务就绪 */
void OS_TaskRdy (OS_TCB *p_tcb)
{
	OS_TickListRemove (p_tcb);		/* 从时基列表中删除 */
	OS_RdyListInsert  (p_tcb);		/* 插入就绪列表     */
}

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

该函数需要修改,作用是将任务设置为阻塞态,具体操作是:

  • 从时基列表中加入该 TCB。
  • 在就绪列表中删除该 TCB。
  • 执行任务调度。

注意:

  • 以上工作位于临界段内。

我们发现,阻塞延时函数和上面函数的操作正好是相反的。

/* 阻塞延时 */
void OSTimeDly (OS_TICK dly)
{
	CPU_SR_ALLOC();
	OS_CRITICAL_ENTER();	
	
	/* 插入时基列表 */
	OS_TickListInsert (OSTCBCurPtr, dly);
	
	/* 从就绪列表移除 */
	OS_RdyListRemove (OSTCBCurPtr);
	
	OS_CRITICAL_EXIT();		
	
	/* 任务切换 */
	OSSched();
}

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

SysTick每发起一次中断,就会调用本函数,完成两件事情:

  • 更新时基列表。让时基计数器加一,以及检查就绪列表中有无任务延时结束。如果有,调用 OS_TaskRdy() 进行处理。如果没有,什么都不用做。
  • 然后执行任务调度。
void OSTimeTick (void)
{
	/* 更新时基列表 */
	OS_TickListUpdate();
	
	/* 任务调度 */
	OSSched();  
}

4 时基列表的应用

4.1 主函数 main(app.c)

app.c 不用改动。

#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);
	}
}

4.2 运行过程

4.2.1 在主函数中

  • 系统初始化:初始化各种全局变量,初始化优先级表,初始化就绪列表,初始化时基列表,初始化空闲任务(包括初始化空闲任务栈和空闲任务 TCB)。
  • CPU 初始化:暂为空。
  • 关中断:因为此时 OS 未启动,若开启中断,那么 SysTick 将会引发中断,打断初始化流程。
  • 初始化 SysTick:配置 SysTick 为 10ms 中断一次,Tick = 10ms。
  • 创建任务:包括创建任务栈和任务 TCB,以及将 TCB 插入到就绪列表中,在优先级表对应位置置位。
  • 启动系统:先找到最高优先级,然后开始运行最高优先级对应的任务(最高优先级为 1,即为 Task1),启动第一次任务切换(此时将完成最后的初始化流程,即有关 PendSV 的中断优先级配置,接着触发 PendSV 异常,发起任务切换),将 CPU 占有权交给任务 Task1。

4.2.2 在 Task1 中

  • flag1 = 1。
  • 执行到阻塞函数 OSTimeDly:将 Task1 的 TCB 插入到时基列表中(TickCtrMatch = 2),将就绪列表中的 TCB 移除(同时在优先级表中的相应位置,即优先级 1 的位置清零),然后启动任务调度。
  • 执行任务调度 OSSched:任务调度器先找到最高优先级,然后再找到最高优先级的任务。 TCB。如果发现该任务就是当前任务,则不进行任务切换。在本案例中发现最高优先级为 2,对应任务是 Task2,不是当前任务,则发起任务切换(发起 PendSV 异常)。
  • PendSV 异常处理程序:保存 Task1 的状态,加载 Task2 的状态,更新全局变量的值。

4.2.3 在 Task2 中

  • flag2 = 1。
  • 执行到阻塞函数 OSTimeDly:将 Task2 的 TCB 插入到时基列表中(TickCtrMatch = 2),将就绪列表中的 TCB 移除(同时在优先级表中的相应位置,即优先级 2 的位置清零),然后启动任务调度。
  • 执行任务调度 OSSched:任务调度器先找到最高优先级,然后再找到最高优先级的任务 TCB。如果发现该任务就是当前任务,则不进行任务切换。在本案例中发现最高优先级为 3,对应任务是 Task3,不是当前任务,则发起任务切换(发起 PendSV 异常)。
  • PendSV 异常处理程序:保存 Task2 的状态,加载 Task3 的状态,更新全局变量的值。

4.2.4 在 Task3 中

  • flag3 = 1。
  • 执行到阻塞函数 OSTimeDly:将 Task3 的 TCB 插入到时基列表中(TickCtrMatch = 2),将就绪列表中的 TCB 移除(同时在优先级表中的相应位置,即优先级 3 的位置清零),然后启动任务调度。
  • 执行任务调度 OSSched:任务调度器先找到最高优先级,然后再找到最高优先级的任务 TCB。如果发现该任务就是当前任务,则不进行任务切换。在本案例中发现最高优先级为 31,对应任务是 空闲任务,不是当前任务,则发起任务切换(发起 PendSV 异常)。
  • PendSV 异常处理程序:保存 Task3 的状态,加载空闲任务的状态,更新全局变量的值。

注意,此时时基计数器为 0,三个任务的延时时间都是 2 个 SysTick 周期,OSCfg_TickWheelSize = 17,因此均位于 OSCfg_TickWheel[2] 下的双向链表。

4.2.5 在空闲任务中 SysTick 发起中断

  • 执行 OSTimeTick:时基计数器加一(OSTickCtr = 1),检查时基列表(OSCfg_TickWheel[1]),发现各个任务的延时未到期(TickCtrMatch = 2)。最后发起任务调度,发现不用进行任务切换,空闲任务继续运行。
  • 再次发起中断,执行 OSTimeTick:时基计数器加一(OSTickCtr = 2),检查时基列表(OSCfg_TickWheel[2]),发现各个任务的延时已到期(TickCtrMatch = 2),将它们全部置为就绪态。置为就绪态的过程是:在时基列表中删除对应 TCB,在就绪列表中加入对应 TCB(同时将 Task1、Task2、Task3 的优先级在优先级表中的相应位置重新置位)。最后发起任务调度,发现最高优先级为 1,对应的是 Task1,切换到 Task1 运行。

4.2.6 又在 Task1 中

  • 将全局变量 flag1 由 1 变成 0。
  • 执行到阻塞函数 OSTimeDly:将 Task1 的 TCB 插入到时基列表中(TickCtrMatch = 4),将就绪列表中的 TCB 移除(同时在优先级表中的相应位置,即优先级 1 的位置清零),然后启动任务调度。
  • 执行任务调度 OSSched:任务调度器先找到最高优先级,然后再找到最高优先级的任务 TCB。如果发现该任务就是当前任务,则不进行任务切换。在本案例中发现最高优先级为 2,对应任务是 Task2,不是当前任务,则发起任务切换(发起 PendSV 异常)。
  • PendSV 异常处理程序:保存 Task1 的状态,加载 Task2 的状态,更新全局变量的值。

如此反复后,三个任务又一次进入阻塞态,此时时基计数器为 2(OSTickCtr = 2),三个任务的延时时间都是 2 个 SysTick 周期(TickCtrMatch = 4),OSCfg_TickWheelSize = 17,因此均位于 OSCfg_TickWheel[4] 下的双向链表。 接下来的步骤跟上面的类似,在发起第四次 SysTick 中断时(OSTickCtr = 4),检查时基列表(OSCfg_TickWheel[4]),发现三个任务已经延时完毕,于是它们又进入到就绪态中。

4.3 实验现象

实验现象与上一篇记录是一样的,也符合以上分析,如图所示:

uCOS-III 学习记录(9)——时基列表_第5张图片

你可能感兴趣的:(#,uC/OS-III,学习笔记,数据结构,链表,uCOS,RTOS,嵌入式)