单片机通用基于状态机时间触发调度器

/*********************************
Titel    :  eTask.h
Mcu      :  8-32 bit
RAM      :  bytes: 4 * (D_TASKS_MAX)+4
ROM      :  bytes: < 0.3K
Complier :  Support of c compiler
Author   :  Eddie
Version  :  V1.3
Updata   :  2013-01-03 18:34      
**********************************
Note:
   (1).add task multithreading mode(PTM)
   (2).add taks Time-triggered mode(TTM)
   (3).change: ptm to pt/tt Mixed-mode
   (4).debug:Task_tick()
   (5).Optimization;
   (6).add func: void Task_start(u8 tid)
   (7).add subcall()
   (8).add event signal/message box for task
   (9).Optimization:Task_schedule()
*/
#ifndef _eTask_h_
#define _eTask_h_
//--------------------user define------------------
#define D_TASKS_MAX     5
#define ENI()           EA = 1
//---------------data type------------------------
#define u8   unsigned char
#define u16  unsigned int
#define u32  unsigned long
//---------------task constant define-------------
#define D_Task0_ID      0
#define D_Task1_ID      1
#define D_Task2_ID      2
#define D_Task3_ID      3
#define D_Task4_ID      4
#define D_Task5_ID      5
#define D_Task6_ID      6
#define D_Task7_ID      7
#define D_Task8_ID      8
//------------------------------------------------
#define D_Event_0       0x01
#define D_Event_1       0x02
#define D_Event_2       0x04
#define D_Event_3       0x08
#define D_Event_4       0x10
#define D_Event_5       0x20
#define D_Event_6       0x40
#define D_Event_7       0x80
//------------------------------------------------
#define D_Delay_ever    ((u8)-1)
#define D_period_ever   ((u8)-1)
#define D_wait_ever     ((u8)-1)
//-----------------function define----------------
void Task_create(void (*pFunc)() ,u8 tid);
void Task_start(u8 tid);
void Task_schedule(void);
//-----------------------------------------------
struct
{   
void (* pTask)(void);
}func[D_TASKS_MAX];
u8 taskSleep[D_TASKS_MAX],taskEvent[D_TASKS_MAX];
u8 taskID,tIndex;                 
bit task_event_flag;
/******************************************************
Micro    : PTK_BEGIN
Note     : 启动任务处理，放在函数开始处
Updata   : 2012-12-03
*******************************************************/
#define PTK_BEGIN                                      \
    static u8 lc=0; switch(lc){   case 0:
/******************************************************
Micro    : PTK_END
Note     : 结束任务,放在函数的最后
Updata   : 2012-12-03
*******************************************************/
#define PTK_END                  }   lc=0;
/************************************************
Micro    : ptk_set_lc
Stacks   :
Note     : 线程任务lc设定
Updata   : 2012-12-03
************************************************/
#define ptk_set_lc()                                   \
    lc = (u8)__LINE__+((__LINE__%256)==0)
/******************************************************
Micro    : Task_ReInit
Stacks   :
Note     : 重新初始化进程.
Updata   : 2012-12-03
*******************************************************/
#define Task_ReInit()   lc = 0; return  
/************************************************
Micro    : ptk_set_timer
Stacks   :
Note     : 线程任务定时设定
Updata   : 2012-12-05
************************************************/
#define ptk_set_timer(timeover)                      \
    do{                                              \
        lc = (u8)__LINE__+((__LINE__%256)==0);       \
        taskSleep[taskID] = timeover;                \
    }while(0)
   
/************************************************
Micro    : Task_setsleep
Stacks   :
Note     : 设置指定的进程为休眠状态
Updata   : 2012-12-04
************************************************/
#define Task_setsleep(tid, timeover)                  \
      taskSleep[tid] = timeover     
      
/******************************************************
Micro    : Task_sleep
Stack    : 1
Note     : 进程立即进入休眠
Updata   : 2012-12-03
*******************************************************/
#define Task_sleep(timeover)                           \
  do{                                                  \
      ptk_set_timer(timeover);                         \
   case (u8)__LINE__+((__LINE__%256)==0):           \
   if(taskSleep[taskID])  return;                   \
  }while(0)
/************************************************
Micro    : Task_delay
Stacks   :
Note     : 进程内延时
Updata   : 2012-12-04
************************************************/
#define Task_delay(timeover)                           \
            Task_sleep(timeover)
/************************************************
Micro    : Task_period
Stacks   :
Note     : 进程运行周期
Updata   : 2012-12-04
************************************************/
#define Task_period(timeover)                          \
            Task_sleep(timeover)
            
/******************************************************
Micro    : Task_condic_wait
Stacks   :
Note     : 等待条件或超时
Updata   : 2012-12-04
*******************************************************/
#define Task_condic_wait(condiction,timeover)          \
  do{                                                  \
      ptk_set_timer(timeover);                         \
      case (u8)__LINE__+((__LINE__%256)==0):           \
      if((！(condiction))&& taskSleep[taskID]) return;  \
      task_event_flag = (condiction)? 1:0;             \
  }while(0)                     
/******************************************************
Micro    : Task_event_wait
Stacks   :
Note     : 等待事件或超时
Updata   : 2012-12-07
*******************************************************/
#define Task_event_wait(event_id,timeover)              \
do{                                                     \
    ptk_set_timer(timeover);                            \
    case (u8)__LINE__+((__LINE__%256)==0):              \
    if(ptk_event_timeover_chk(event_id) == 0)  return;  \
}while(0)
/************************************************
Micro    : Task_event_send
Stacks   :
Note     : 中断或进程向进程传事件消息
Updata   : 2012-12-07
************************************************/
#define  Task_event_send(event_id,tid)                 \
    taskEvent[tid] |= event_id                          
     
/************************************************
Mico     : Task_event_clear
Stacks   :
Note     : 清除进程传事件消息
Updata   : 2012-12-07
************************************************/
#define Task_event_clear(event_id)                      \
    taskEvent[taskID] &= 0xff ^ event_id
   
/******************************************************
Micro    : Task_switch
Stacks   :
Note     : 任务切换
Updata   : 2012-12-04
*******************************************************/
#define Task_switch()                                     \
    do{                                                   \
        ptk_set_lc();  return;                            \
        case (u8)__LINE__+((__LINE__%256)==0):            \
        taskID = taskID;                                  \
    }while(0)
/************************************************
Micro    : Task_setsuspend
Stacks   :
Note     : 设置指定的进程为休眠状态.
Updata   : 2012-11-19
************************************************/
#define Task_setsuspend(tid)                             \
            taskSleep[tid] = D_Delay_ever  
            
/************************************************
Micro    : task_suspend
Stacks   :
Note     : 进程立即进入休眠
Updata   : 2012-12-04
************************************************/
#define Task_suspend()                                   \
  do{                                                    \
      ptk_set_timer(D_Delay_ever);                       \
      case (u8)__LINE__+((__LINE__%256)==0):             \
      if(taskSleep[taskID]) return;                      \
  }while(0)
  
/************************************************
Micro    : Task_resume
Stacks   :
Note     : 唤醒指定的进程.
Updata   : 2012-11-22
************************************************/
#define Task_resume(tid)                                  \
do{                                                   \
        if(tid ！= taskID)                                 \
        taskSleep[tid] = 0;                               \
    }while(0)
   
/*******************************************************
Micro    : Task_call
Stacks   :
Note     : 调用子任务
Updata   : 2012-12-03
*******************************************************/
#define Task_call(subTask)                                \
  do{                                                     \
        ptk_set_timer(0); return ;                        \
  case (u8)__LINE__+((__LINE__%256)==0):            \
     subTask();                                        \
  if(taskSleep[taskID]) return;                     \
}while(0)  
/************************************************
Micro    : Task_tick
Stacks   :
Note     : 更新进程定时器
Updata   : 2012-12-03
************************************************/
#define Task_tick()                                       \
  do{                                                     \
      for(tIndex = 0; tIndex < D_TASKS_MAX; tIndex++)     \
      {                                                   \
          if(taskSleep[tIndex] ！= D_Delay_ever)           \
    {                                               \
        if(taskSleep[tIndex]){                      \
            taskSleep[tIndex]--;}                   \
    }                                               \
       }                                                  \
   }while(0)            
/************************************************
Micro    : Task_schedule
Stacks   :
Note     : 进程调度,事件时间触发
Updata   :  2012-12-10
************************************************/
#define  Task_schedule()                                  \                                      
do{                                                       \   
    if(taskEvent[taskID]||(taskSleep[taskID] == 0))       \   
    {                                                     \                                                      
        (*func[taskID].pTask)();                          \                           
    }                                                     \
    if(++taskID >= D_TASKS_MAX) taskID = 0;               \
}while(0)
/************************************************
Function : ptk_event_timeover_chk
Stacks   :
Note     : 线程任务事件及超时检测
Updata   : 2012-12-10
************************************************/
u8 ptk_event_timeover_chk(u8 event_id)
{
task_event_flag = 0;

if(taskEvent[taskID] & event_id)
{
     taskEvent[taskID] &= 0xff ^ event_id;
        taskSleep[taskID] = 0; task_event_flag = 1;
        return 1;
}
else if(taskSleep[taskID] == 0)
{
     return 1;
}   
else
{
     return 0;
}   
}
/************************************************
Function : Task_create
Stacks   :
Note     : 初始化任务
Updata   : 2012-11-26
************************************************/
void Task_create(void (*pFunc)() ,u8 tid)
{
    func[tid].pTask = pFunc;
}  
/************************************************
Function : Task_start
Stacks   :
Note     : 从指定任务开始运行
Updata   : 2012-11-26
************************************************/
void  Task_start(u8 tid)
{   
    u8 i;
   
    for(i = 0;i < D_TASKS_MAX;i++)
    {
        taskSleep[i] = 1 + (i<<2);
    }            
    taskID = tid;
ENI();
}
//-----------------------End of file---------------
#endif  

这是什么?看不懂

很好，学习了