裸机任务管理器

作用:

对当前系统的任务进行管理,优先级最高的将会被排列在第0位
通过一个U16 的ID进行区别
当系统需要执行任务时只要根据返回的ID即可知道需要做哪件事

.H

#ifndef  __PRIORITY_MANAGER_H
#define  __PRIORITY_MANAGER_H
typedef unsigned char 			uint8_t;
typedef unsigned short int 		uint16_t;
typedef unsigned int        	uint32_t;
 
//优先级划分
//优先级和ID都不能为0
//优先级从 1-65535  数字越大,优先级越高
//ID也是从 1到65535  
typedef enum{  //优先级等级示例
	LOW_PRI = 0,  //低优先级
	MID_PRI = 1,	//中等优先级
	HIGH_PRI = 2	//高优先级
}e_PRI;
typedef struct Task{
	uint16_t task_pri;  //任务优先级
	uint16_t Task_Id;	//任务ID
}s_Task;
#define  MAX_TASK_NUM 10   //此处宏定义最大的任务数量
typedef struct MANAGER{
	s_Task Task[MAX_TASK_NUM];   //任务数组
	uint16_t last;   //任务数量
}s_Pri_Manager;

//------使用前一定要先初始化------
void Init_Pri_Manager(void);  //初始化一个任务管理器

void Clear_all_Task(void);  //清空当前所有任务

uint16_t First_Task_ID(void);  //返回当前优先级最高的任务

uint8_t Reduce_Task(uint16_t ID);  //减少对应ID的任务

uint8_t Add_Task(uint16_t ID,uint16_t priority);  //增加一个任务

uint8_t Find_Task(uint16_t ID);  //查找是否存在对应ID的任务


#endif

.C

#include "priority_manager.h"
#include "String.h"
#include "stdio.h"

s_Pri_Manager Pri_manager;

#define  NULL_ID  0
#define  LOW_PRI  0

typedef uint16_t data_t;

//#define _DBUG	 //打印功能

/*  //采用快速排序对任务进行排列
选一个基数和最后一个值的比较；
如果基数较小，则交换位置；
再将基数与前面的数字进行比较

选择一个基数,进行分组,小于基数的放在左边,大于基数的放在右边
第二次进行拆分,把左边和右边再次进行排序
直到i和j相等
 **/
/*__--__--__--__--__--__非用户接口begin--__--__--__--__--__--__*/
int sort(s_Pri_Manager * data,int low,int high){
#ifdef _DBUG
	printf("into sort\n");
#endif
	data_t temp_pri;  //基数
	data_t temp_Id;
	temp_pri = data->Task[high].task_pri;   //选择一个基数
	temp_Id = data->Task[high].Task_Id;
	
	while(low<high){
		while(low < high && temp_pri <= data->Task[low].task_pri){  //把大于基数的放在基数右边
			low++;
		}
		data->Task[high].task_pri = data->Task[low].task_pri;  //把小的放前面
		data->Task[high].Task_Id  = data->Task[low].Task_Id;
		
		while(low < high && temp_pri >= data->Task[high].task_pri){ //把小于基数的放在基数左边
			high--;

		}
		data->Task[low].task_pri = data->Task[high].task_pri;  
		data->Task[low].Task_Id = data->Task[high].Task_Id;
	}
	data->Task[high].task_pri = temp_pri;  //最后把基数放在中间的位置
	data->Task[high].Task_Id = temp_Id;
	return high;
}

/*
快速排序
*/
int quick_sort(s_Pri_Manager * data,int low,int high){
#ifdef _DBUG
	printf("into quick_sort \n");
#endif
	int temp;  //基数
	int i;
	int j=-1;
	if(low == high){
		return 0;
	}	
	for(i=low;i<=high;i++){  //打印一下数组成员
#ifdef _DBUG
		printf("%d",data->Task[i].Task_Id);
#endif	
		if(data->Task[i].Task_Id == 0){;} //判断数组成员个数
		else{
			j++;
		}
	}
	if(j == -1 || j == 0){return 0;}  //如果j没有被++,说明数组全是0,或者数组个数低于两个

	temp = sort(data,low,high);  //第一次排序
	quick_sort(data,low,temp-1);  //基数左边的排序
	quick_sort(data,temp+1,high);  //基数右边的排序
	
	return 0;
}
/*__--__--___---___---___非用户接口end---___---___---___---__*/

void Init_Pri_Manager(void){
	uint8_t i =0;
	for(i = 0;i<MAX_TASK_NUM;i++){
		Pri_manager.Task[i].Task_Id = NULL_ID;
		Pri_manager.Task[i].task_pri = LOW_PRI;
		Pri_manager.last = 0;
	}
	#ifdef _DBUG
	printf("初始化任务管理器\n");
	#endif
}

void Clear_all_Task(void){
	uint8_t i =0;
	for(i = 0;i<MAX_TASK_NUM;i++){
		Pri_manager.Task[i].Task_Id = NULL_ID;
		Pri_manager.Task[i].task_pri = LOW_PRI;
		Pri_manager.last = 0;
	}
	#ifdef _DBUG
	printf("清除全部任务\n");
	#endif
}
/*
 @bref 根据优先级增加一个任务
*/
uint8_t Add_Task(uint16_t ID,uint16_t priority){
	uint8_t i =0;
	if(Pri_manager.last < MAX_TASK_NUM){  //查找是否还有空余
		for(i= 0;i<Pri_manager.last;i++){
			if(Pri_manager.Task[i].Task_Id == ID){  //查找相同ID
				Pri_manager.Task[i].task_pri = priority;  //更新优先级
				return 0;
			}
		}
		if((priority != LOW_PRI)&&(ID != NULL_ID)){  //优先级和ID都不能为0
				Pri_manager.Task[Pri_manager.last].Task_Id = ID;
				Pri_manager.Task[Pri_manager.last].task_pri = priority;
				Pri_manager.last++;
				//放入最后一位,然后快排
				quick_sort(&Pri_manager,0,Pri_manager.last-1);
				#ifdef _DBUG
				printf("----新增任务%d--PRI:%d\n",ID,priority);
				#endif
		}
	}
	return 1;
}
/*
 @bref 返回最高优先级的任务ID
*/
uint16_t First_Task_ID(void){
	return Pri_manager.Task[0].Task_Id;
}
/*
 把已经完成的任务从任务管理器中去除
 有可能不是最高优先级的任务
*/
uint8_t Reduce_Task(uint16_t ID){
	uint16_t i = 0;
	uint16_t j = 0;
	if(Pri_manager.last != 0){
		//查看是不是最高优先级的任务
		if(Pri_manager.Task[0].Task_Id != ID){
			for(j= 1;j<Pri_manager.last;j++){
				if(Pri_manager.Task[j].Task_Id == ID){
					break;
				}
			}
		}
		if(j < Pri_manager.last){
			for(i= j;i<Pri_manager.last;i++){
					Pri_manager.Task[i].Task_Id = Pri_manager.Task[i+1].Task_Id;
					Pri_manager.Task[i].task_pri = Pri_manager.Task[i+1].task_pri;
			}
				Pri_manager.last --;
			#ifdef _DBUG
			printf("----减少任务%d",ID);
			#endif
			return 1;
		}
	}
	return 0;
}
/*
查找任务,找到返回1,否则返回0
*/
uint8_t Find_Task(uint16_t ID){
	uint16_t j = 0;
	for(j= 0;j<Pri_manager.last;j++){
		if(Pri_manager.Task[j].Task_Id == ID){
			return 1;
		}
	}
	return 0;
}