单片机裸机代码框架设计思路(三)（单片机编程魔法师之高级裸编思想）

前两篇文档我一共讲述了3个裸机框架：(1)轮询系统；(2)前后台系统；(3)基于时间片的多任务系统；

今天再谈一谈单链表组成的裸机系统。此写法更加灵活，和时间片的概念类似，

（4）基于单链表的多任务系统

此代码写法分为7步

【1】定义一个表示的任务的结构体类型

timeout表示超时时间，与定时器心跳比较，如果时间到，就执行*pTask指向的函数体

repeat用来周期设置，一般设置成timerout一样，如果设置为0，该任务只是执行一次

*pTask指向该任务要执行的函数体（一般也称为回调函数）

Task_t* next指向链表中的下一个任务节点

//定义一个表示的任务的结构体类型
typedef struct  Task_t
{
  unsigned int timeout; // 超时时间（用来与定时器心跳比较）  
  unsigned int repeat;// 循环定时触发时间（周期定时设置），为0时代表单次定时 
  void   (*pTask)(void);  //任务的函数指针 
  struct Task_t* next;			// 指向下一个定时器任务节点
}Task_t;

【2】定义变量，包含task任务结构体和链表头以及心跳全局变量

//任务结构体变量
Task_t task1;
Task_t task2;
Task_t task3;
//表头
struct Task_t* g_head_handle=NULL;
//心跳计数器
unsigned int g_task_ticks=0;

【3】心跳函数将心跳全局变量自加

void Task_Ticks()
{
  g_task_ticks++;
}

【4】任务初始化

void Task_Init(Task_t* hTask, void(*pTask)(), unsigned int timeout, unsigned int repeat)
{
	hTask->timeout = g_task_ticks + timeout;
	hTask->repeat = repeat;
	hTask->pTask = pTask;
}

【5】任务启动和停止函数

//链表中插入任务
char Task_Start(Task_t* hTask)
{
	struct Task_t* target = g_head_handle;
	//检查链表中是否已经有该任务
	while(target)
  {
		if(target == hTask) return -1;	//already exist.
		target = target->next;
	}
	//链表头部插入任务
	hTask->next = g_head_handle;
	g_head_handle = hTask;
	return 0;
}

//移除链表中的任务，相当于停止该任务
void Task_Stop(Task_t* hTask)
{
	struct Task_t** curr;
	for(curr = &g_head_handle; *curr; ) 
  {
		struct Task_t* entry = *curr;
		if (entry == hTask) 
    {
			*curr = entry->next;
		} 
    else
			curr = &entry->next;
	}
}

【6】任务循环

//任务循环
void Task_Process()  
{  
	struct Task_t* target;
	for(target=g_head_handle; target; target=target->next) {
		if(g_task_ticks >= target->timeout) {
			if(target->repeat == 0) {
				Task_Stop(target);
			} else {
				target->timeout = g_task_ticks + target->repeat;
			}
			target->pTask();
		}
	}
}		

【7】定义task结构体中指针函数所指向的函数体，每个任务要执行的内容

void DoTask1() {LED1=~LED1;}
void DoTask2() {LED2=~LED2;}
void DoTask3() {LED3=~LED3;}

通过以上7步，就完成了此框架的所有代码，应用上需要注意的地方

(1)应用方法操作步骤如下，

①Task_Init函数初始化各个任务

②使用Task_Start启动任务

③心跳自加函数Task_Ticks()放到定时器中断中，每隔一段时间（本范例5ms）自加一次

④在while(1)死循环中执行Task_Process()

//主函数
void main()
{							
	//系统初始化
	System_Init();
	while(1)
	{
    Task_Process();
	}
}	

//系统初始化
void System_Init()
{
	LED1 = 1;	LED2 = 1;	LED3 = 1;
	Timer0_Init();
	Task_Init(&task1, DoTask1, 100, 100);
  Task_Start(&task1);
	Task_Init(&task2, DoTask2, 200, 200);
  Task_Start(&task2);
	Task_Init(&task3, DoTask3, 300, 300);
  Task_Start(&task3);
}
void Timer0_ISR() interrupt 1
{
	
	TL0 = 0x00;				//设置定时初值
	TH0 = 0xEE;				//设置定时初值
	Task_Ticks();
}
//定义3个任务
void DoTask1() {LED1=~LED1;}
void DoTask2() {LED2=~LED2;}
void DoTask3() {LED3=~LED3;}

（2）Task_Process()是循环对链表中任务结构的timerout进行判断，如果时间到，就执行对应的ptask，这个函数要放在main函数中的死循环里

void main()
{							
	//系统初始化
	System_Init();
	while(1)
	{
    Task_Process();
	}
}

（3）每个task的任务执行时间要控制好，如果其中一个task任务执行时间过长，那么会影响到其他task的执行，要避免这种情况，尽量将执行很长的task进行分割成很多小task

本次代码范例仿真结果如下

可以看出，这个和上篇文档的时间片系统执行效果是完全一样的。举例说明，我定义的task1的时间片数字是100，对应间隔翻转执行时间是5ms*100=500ms，如下所示，非常吻合。

这个设计思路非常巧妙，使用了数据结构的单链表操作，任务的启动是插入到链表中，任务的停止从链表中删除，死循环中只需要遍历链表看时间是否又到，到了就执行对应的回调函数。

喜欢这篇文章，帮忙点个“关注 + 收藏”哦

附上源码：