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 个节点的双向链表，注意每个节点都回指了这个数组元素的地址，第三个节点是漏画了。

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() 中调用此函数以完成初始化工作。初始化后的时基列表如下所示：

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。

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

注意，这三个任务 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。

时基列表的情况如下图：

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

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