void func(char *fos,...){
    static char step=0;//順序控制變量，自由度比較高，可亂序，可循環(huán)，可延遲執(zhí)行
    switch(step){
        case 0:{
            //...
            step++;
            break;
        }
        case 1:{
            //...
            step++;
            break;
        }
        //...
        default:{
            //step++;//可以借助default實現(xiàn)延時的效果，即跳過幾次空白step
            break;
        }

    }
    return;
}

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標志來確定是否執(zhí)行，否則就跳過
			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){
        //循環(huán)運行該任務
		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//運行結束后再次執(zhí)行，相當于循環(huán)運行
#define TYPE_NOMAL 0//標識一般任務類型
#define TYPE_HEAD 1//標識頭任務類型
#define TYPE_END 2//標識尾任務類型
#define RUN_NORMAL 0//一般輪詢模式
#define RUN_FORCE 1//強制運行該任務，運行結束才繼續(xù)下一個任務
#define RUN_WAIT 2//等待指定的任務結束，才可以被運行
#define STATUS_INIT 0//任務的準備階段，用于獲取起始時間
#define STATUS_RUN 1//任務運行階段
#define STATUS_UNVAILED 2//無效狀態(tài)

typedef struct TASK_CLASS{
	void (*task_name)(char *taskfos,...);//任務函數(shù)
	int task_tick;//任務的時間分片間隔
	uint32_t tickstart;//起始時間點，每次執(zhí)行完須加上一個tick
	char task_fos;//運行結束標志
	char task_type;//任務類型變量
	char task_status;//任務狀態(tài)
	char run_type;//運行狀態(tài)
	char ready;//準備運行標志位
	struct TASK_CLASS *next;//下一任務
	struct TASK_CLASS *waittask;//等待執(zhí)行的任務
} Task_Obj;

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++;
}

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;//獲取新建的等待執(zhí)行的任務地址，在運行結束后把等待執(zhí)行的任務的準備運行標志位置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++;

}

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--;

}

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;//頭節(jié)點是沒有任務需要執(zhí)行的
	task_num=0;
}

add_task(task1,500,RUN_NORMAL);//500ms執(zhí)行一次task1任務
add_wait_task(task1,task2,500);//task2等待task1結束才會執(zhí)行，運行的時間間隔為500ms
delete_task_withname(task1);//刪除task1任務

while(1){
    //...
    loop_task();//任務輪詢
}