自用纯C语言实现任务调度(可用于STM32C51等单片机)

Posted 2023-04-09 pie_thn

前言

  这个任务调度模块的实现是形成于毕设项目中的，用在STM32中，断断续续跨度2个月实现了一些基本功能，可能后面再做其他项目时会一点点完善起来，也会多学习相关知识来强化模块的实用性和高效性，毕竟用自己自主实现出来的功能还是蛮舒心的。

任务调度模式结构

  整体上的结构属于线性结构，结合链表和定时器来实现，我使用的是sysTick这个滴答时钟，1ms的频率，功能比较简单，容易理解。

分片

  分片的模式，主要体现在函数分片和时间分片在我之前就有使用在函数中，主要的思路是，把函数功能切片，分为几个小部分，每次执行时按次序执行小部分，对于没有时序要求的函数来说，可以把一个占用CPU大的功能分摊开来实现，从而避免有些地方耗时长的问题。对于时间分片，其实就是定时器的一种应用，实际上，函数分片在执行的时候已经是一种时间分片了，不过现在加上人为的控制在里面了。
  下面是函数分片的一般结构：

void func(char *fos,...)
    static char step=0;//顺序控制变量，自由度比较高，可乱序，可循环，可延迟执行
    switch(step)
        case 0:
            //...
            step++;
            break;
        
        case 1:
            //...
            step++;
            break;
        
        //...
        default:
            //step++;//可以借助default实现延时的效果，即跳过几次空白step
            break;
        

    
    return;

其中添加的参数变量*fos是必要的，因为就是通过传入每个任务的这个标志位来判断是否运行结束,而其他的参数，就得基于具体任务做不一样的处理了。

轮询

• 运行框图

  可以看到这个框图是一个头尾相连的闭环结构，从头节点依次运行到尾节点后再从头循环往复执行下去。

• 轮询函数

void loop_task(void)
	static Task_Obj *tasknode;
	
	tasknode=task_curnode->next;//repoint the curnode to the next
	if(tasknode==NULL)//tasknode is null,only the headnode have the attr
		return;//express the task space is none
	
	else if(tasknode->task_type==TYPE_HEAD)//tasknode is headnode
		task_curnode=tasknode;
		return;
	
	else
		if(tasknode->run_type == RUN_WAIT)
            //等待型任务，通过ready标志来确定是否执行，否则就跳过
			if(!tasknode->ready)
				if(task_curnode->next !=NULL)
					task_curnode=task_curnode->next;
					return;
				
			
		
		if(tasknode->task_status==STATUS_INIT)

			tasknode->tickstart=HAL_GetTick();//获取tick
			tasknode->task_status=STATUS_RUN;

		
		else if(tasknode->task_status==STATUS_RUN)
			if((HAL_GetTick() - tasknode->tickstart) > (uint32_t)tasknode->task_tick)
				tasknode->task_name(&(tasknode->task_fos));//run the step task,transfer the fos
				tasknode->tickstart+=(uint32_t)tasknode->task_tick;//update the tickstart
			
		
		
	
	if(tasknode->task_fos==FOS_FLAG)
		
		tasknode->ready=0;
		if(tasknode->waittask!=NULL)
            //置位该任务绑定的等待的任务准备运行标志位，标识可以准备运行了
			tasknode->waittask->ready=1;
		
        //运行结束就删掉该任务
		delete_task(tasknode);
	
	else if(tasknode->task_fos==FOC_FLAG)
        //循环运行该任务
		tasknode->task_status=STATUS_INIT;//continue running from start
		tasknode->task_fos=0;//RESET fos
		
	
	if(task_curnode->next !=NULL)
		if(task_curnode->next->run_type==RUN_FORCE) return;//force-type\'s task
		
		else task_curnode=task_curnode->next;
		
	
	

其中有几个运行态和标志位

#define FOS_FLAG 99//运行结束标志
#define FOC_FLAG 100//运行结束后再次执行，相当于循环运行
#define TYPE_NOMAL 0//标识一般任务类型
#define TYPE_HEAD 1//标识头任务类型
#define TYPE_END 2//标识尾任务类型
#define RUN_NORMAL 0//一般轮询模式
#define RUN_FORCE 1//强制运行该任务，运行结束才继续下一个任务
#define RUN_WAIT 2//等待指定的任务结束，才可以被运行
#define STATUS_INIT 0//任务的准备阶段，用于获取起始时间
#define STATUS_RUN 1//任务运行阶段
#define STATUS_UNVAILED 2//无效状态

运行时对时间间隔tick的把握还有点问题，这个等待后面有机会优化下。

调度实现

• 任务链表结构

typedef struct TASK_CLASS
	void (*task_name)(char *taskfos,...);//任务函数
	int task_tick;//任务的时间分片间隔
	uint32_t tickstart;//起始时间点，每次执行完须加上一个tick
	char task_fos;//运行结束标志
	char task_type;//任务类型变量
	char task_status;//任务状态
	char run_type;//运行状态
	char ready;//准备运行标志位
	struct TASK_CLASS *next;//下一任务
	struct TASK_CLASS *waittask;//等待执行的任务
 Task_Obj;

• 添加任务

  • add_task

  void add_task(void (*taskname)(char *,...),int tasktick,int runtype)//可变参,这里未做处理
  Task_Obj *tasknode,*tmpnode;
  char i;
  
  tasknode = (Task_Obj*)malloc(sizeof(Task_Obj));
  
  tasknode->task_name=taskname;
  tasknode->task_tick=tasktick;
  tasknode->task_fos=0;
  tasknode->task_status=STATUS_INIT;//initial status
  tasknode->task_type=TYPE_END; //set the new node to endnode
  tasknode->run_type=runtype;
  tasknode->next=&task_headnode;//the endnode point to the headnode
  
  tmpnode=&task_headnode;
  if(task_num==0)
  	tmpnode->next=tasknode;
  	task_num++;
  	return;
  
  for(i=0;i<task_num;i++)
  	tmpnode=tmpnode->next;//reach the endnode
  
  tmpnode->task_type=TYPE_NOMAL;//turn the last endnode to the normal node
  tmpnode->next=tasknode;
  task_num++;
  
  

  • add_wait_task

  void add_wait_task(void (*taskname)(char *),void (*waitname)(char *),int tasktick)
  Task_Obj *tmpnode,*tasknode;
  char i,pos;
  
  tmpnode=&task_headnode;
  for(i=0;i<task_num;i++)
  	tmpnode=tmpnode->next;//reach the endnode
  	if(tmpnode->task_name==taskname)
  		pos=i;//获取要等待任务的位置
  		break;
  	
  
  
  tasknode = (Task_Obj*)malloc(sizeof(Task_Obj));
  
  tasknode->task_name=waitname;
  tasknode->task_tick=tasktick;
  tasknode->task_fos=0;
  tasknode->task_status=STATUS_INIT;//initial status
  tasknode->task_type=TYPE_END; //set the new node to endnode
  tasknode->run_type=RUN_WAIT;//任务为等待运行
  tasknode->ready=0;
  tasknode->next=&task_headnode;//the endnode point to the headnode
  
  tmpnode->waittask=tasknode;//获取新建的等待执行的任务地址，在运行结束后把等待执行的任务的准备运行标志位置1
  
  tmpnode=&task_headnode;
  if(task_num==0)
  	tmpnode->next=tasknode;
  	task_num++;
  	return;
  
  for(i=0;i<task_num;i++)
  	tmpnode=tmpnode->next;//reach the endnode
  
  tmpnode->task_type=TYPE_NOMAL;//turn the last endnode to the normal node
  tmpnode->next=tasknode;
  task_num++;
  
  
  

• 删除任务

  • delete_task(局限性大，只针对当前运行的任务而言)

  void delete_task(Task_Obj *taskobj)
  if(task_curnode->task_type==TYPE_HEAD && task_num < 2)//if curnode is headnode,and tasknum=1
  	task_curnode->next=NULL;
  
  else
  	task_curnode->next=taskobj->next;//repoint the curnode next
  
  free(taskobj);//free the space of where the taskobj pointed
  
  task_num--;
  
  
  

  • delete_task_withname(删除指定任务名的任务)

  void delete_task_withname(void (*taskname)(char *))
  Task_Obj *tmpnode,*tmpnode2;
  char i,pos;
  
  tmpnode=&task_headnode;
  for(i=0;i<task_num;i++)
  	tmpnode=tmpnode->next;//reach the endnode
  	if(tmpnode->task_name==taskname)
  		pos=i;
  		break;
  	
  
  if(i==task_num) return;
  tmpnode=&task_headnode;
  for(i=0;i<pos+1;i++)
  	tmpnode2=tmpnode;
  	tmpnode=tmpnode->next;
  
  if(tmpnode->next==NULL)//if tmpnode is endnode
  	tmpnode2->next=&task_headnode;
  
  else
  	tmpnode2->next=tmpnode->next;//repoint the curnode next
  
  task_num--;
  free(tmpnode);
  
  

• 初始化任务空间

void non_task(char *taskfos)
	return;


void init_taskspace(void)
	task_headnode.task_name=non_task;
	task_headnode.task_type=TYPE_HEAD;
	task_headnode.task_status=STATUS_UNVAILED;
	task_headnode.next=NULL;
	task_curnode=&task_headnode;//头节点是没有任务需要执行的
	task_num=0;

• 调用实例

add_task(task1,500,RUN_NORMAL);//500ms执行一次task1任务
add_wait_task(task1,task2,500);//task2等待task1结束才会执行，运行的时间间隔为500ms
delete_task_withname(task1);//删除task1任务

while(1)
    //...
    loop_task();//任务轮询

结语

  整体实现说难不难，说简单不简单，但也是我第一次尝试这种偏向系统级应用的代码，而且都没有参照任何其他的资料和代码，完全以自己的对任务的理解和具体项目的需求来一点点实现，希望后面会把这个调度的代码进一步完善成一个通用型的调度方式，也方便后面项目的使用了。

本文来自博客园，作者：pie_thn，转载请注明原文链接：https://www.cnblogs.com/pie-o/p/17300699.html

操作系统常见的调度算法

调度算法是指：根据系统的资源分配策略所规定的资源分配算法，如任务A在执行完后，选择哪个任务来执行，使得某个因素（如进程总执行时间，或者磁盘寻道时间等）最小。对于不同的系统目标，通常采用不同的调度算法。
几个常用的操作系统进程调度算法

一、先来先服务和短作业(进程)优先调度算法

1 先来先服务（队列）

先来先服务(FCFS)调度算法是一种最简单的调度算法，该算法既可用于作业调度，也可用于进程调度。当在作业调度中采用该算法时，每次调度都是从后备作业队列中选择一个或多个最先进入该队列的作业，将它们调入内存，为它们分配资源、创建进程，然后放入就绪队列。在进程调度中采用FCFS算法时，则每次调度是从就绪队列中选择一个最先进入该队列的进程，为之分配处理机，使之投入运行。该进程一直运行到完成或发生某事件而阻塞后才放弃处理机。
缺点：比较有利于长作业，而不利于短作业。 有利于CPU繁忙的作业，而不利于I/O繁忙的作业。

2 最短优先（优先队列）

最短优先调度算法是指对短作业或短进程优先调度的算法。它们可以分别用于作业调度和进程调度。短作业优先(SJF)的调度算法是从后备队列中选择一个或若干个估计运行时间最短的作业，将它们调入内存运行。而短进程优先(SPF)调度算法则是从就绪队列中选出一个估计运行时间最短的进程，将处理机分配给它，使它立即执行并一直执行到完成，或发生某事件而被阻塞放弃处理机时再重新调度。
缺点：长作业的运行得不到保证

2 高优先权优先调度算法

2.1 优先权调度算法的类型

为了照顾紧迫型作业，使之在进入系统后便获得优先处理，引入了最高优先权优先(FPF)调度算法。此算法常被用于批处理系统中，作为作业调度算法，也作为多种操作系统中的进程调度算法，还可用于实时系统中。当把该算法用于作业调度时，系统将从后备队列中选择若干个优先权最高的作业装入内存。当用于进程调度时，该算法是把处理机分配给就绪队列中优先权最高的进程，这时，又可进一步把该算法分成如下两种。
1) 非抢占式优先权算法
在这种方式下，系统一旦把处理机分配给就绪队列中优先权最高的进程后，该进程便一直执行下去，直至完成；或因发生某事件使该进程放弃处理机时，系统方可再将处理机重新分配给另一优先权最高的进程。这种调度算法主要用于批处理系统中；也可用于某些对实时性要求不严的实时系统中。
2) 抢占式优先权调度算法
在这种方式下，系统同样是把处理机分配给优先权最高的进程，使之执行。但在其执行期间，只要又出现了另一个其优先权更高的进程，进程调度程序就立即停止当前进程(原优先权最高的进程)的执行，重新将处理机分配给新到的优先权最高的进程。因此，在采用这种调度算法时，是每当系统中出现一个新的就绪进程i 时，就将其优先权Pi与正在执行的进程j 的优先权Pj进行比较。如果Pi≤Pj，原进程Pj便继续执行；但如果是Pi>Pj，则立即停止Pj的执行，做进程切换，使i 进程投入执行。显然，这种抢占式的优先权调度算法能更好地满足紧迫作业的要求，故而常用于要求比较严格的实时系统中，以及对性能要求较高的批处理和分时系统中。

2．高响应比优先调度算法

在批处理系统中，短作业优先算法是一种比较好的算法，其主要的不足之处是长作业的运行得不到保证。如果我们能为每个作业引入前面所述的动态优先权，并使作业的优先级随着等待时间的增加而以速率a 提高，则长作业在等待一定的时间后，必然有机会分配到处理机。该优先权的变化规律可描述为：

由于等待时间与服务时间之和就是系统对该作业的响应时间，故该优先权又相当于响应比RP。据此，又可表示为：

由上式可以看出：

(1) 如果作业的等待时间相同，则要求服务的时间愈短，其优先权愈高，因而该算法有利于短作业。

(2) 当要求服务的时间相同时，作业的优先权决定于其等待时间，等待时间愈长，其优先权愈高，因而它实现的是先来先服务。

(3) 对于长作业，作业的优先级可以随等待时间的增加而提高，当其等待时间足够长时，其优先级便可升到很高，从而也可获得处理机。简言之，该算法既照顾了短作业，又考虑了作业到达的先后次序，不会使长作业长期得不到服务。因此，该算法实现了一种较好的折衷。当然，在利用该算法时，每要进行调度之前，都须先做响应比的计算，这会增加系统开销。

三、基于时间片的轮转调度算法

1．时间片轮转法

1) 基本原理

在早期的时间片轮转法中，系统将所有的就绪进程按先来先服务的原则排成一个队列，每次调度时，把CPU 分配给队首进程，并令其执行一个时间片。时间片的大小从几ms 到几百ms。当执行的时间片用完时，由一个计时器发出时钟中断请求，调度程序便据此信号来停止该进程的执行，并将它送往就绪队列的末尾；然后，再把处理机分配给就绪队列中新的队首进程，同时也让它执行一个时间片。这样就可以保证就绪队列中的所有进程在一给定的时间内均能获得一时间片的处理机执行时间。换言之，系统能在给定的时间内响应所有用户的请求。

2．多级反馈队列调度算法

前面介绍的各种用作进程调度的算法都有一定的局限性。如短进程优先的调度算法，仅照顾了短进程而忽略了长进程，而且如果并未指明进程的长度，则短进程优先和基于进程长度的抢占式调度算法都将无法使用。而多级反馈队列调度算法则不必事先知道各种进程所需的执行时间，而且还可以满足各种类型进程的需要，因而它是目前被公认的一种较好的进程调度算法。在采用多级反馈队列调度算法的系统中，调度算法的实施过程如下所述。

(1) 应设置多个就绪队列，并为各个队列赋予不同的优先级。第一个队列的优先级最高，第二个队列次之，其余各队列的优先权逐个降低。该算法赋予各个队列中进程执行时间片的大小也各不相同，在优先权愈高的队列中，为每个进程所规定的执行时间片就愈小。例如，第二个队列的时间片要比第一个队列的时间片长一倍，……，第i+1个队列的时间片要比第i个队列的时间片长一倍。

(2) 当一个新进程进入内存后，首先将它放入第一队列的末尾，按FCFS原则排队等待调度。当轮到该进程执行时，如它能在该时间片内完成，便可准备撤离系统；如果它在一个时间片结束时尚未完成，调度程序便将该进程转入第二队列的末尾，再同样地按FCFS原则等待调度执行；如果它在第二队列中运行一个时间片后仍未完成，再依次将它放入第三队列，……，如此下去，当一个长作业(进程)从第一队列依次降到第n队列后，在第n队列便采取按时间片轮转的方式运行。

(3) 仅当第一队列空闲时，调度程序才调度第二队列中的进程运行；仅当第1～(i-1)队列均空时，才会调度第i队列中的进程运行。如果处理机正在第i队列中为某进程服务时，又有新进程进入优先权较高的队列(第1～(i-1)中的任何一个队列)，则此时新进程将抢占正在运行进程的处理机，即由调度程序把正在运行的进程放回到第i队列的末尾，把处理机分配给新到的高优先权进程。

本文出自 “qin-wang” 博客，请务必保留此出处http://10810196.blog.51cto.com/10800196/1786185