單片機的ROM與RAM存貯空間有限，一般沒有多線程可用，給復雜的單片機項目帶來困擾。

經過多年的單片機項目實踐，借鑒windows消息機制的思想，編寫了單片機多任務事件驅動C代碼，應用于單片機項目，無論復雜的項目，還是簡單的項目，都可以達到優化代碼架構的目的。

經過幾輪的精簡、優化，現在分享給大家。

代碼分為3個模塊：任務列表、事件列表、定時器列表。

任務列表創建一個全局列表管理任務，通過調用taskCreat()創建事件處理任務，創建成功返回任務ID，任務列表、事件列表與定時器列表通過任務ID關聯。

事件列表創建一個全局循環列表管理事件，調用taskEventIssue()生成一個事件，放到事件循環列表，taskEventLoop()函數放到主線程循環調用，當事件循環列表中有事件時，根據任務ID分發到具體的事件處理任務。

定時器列表創建一個全局列表管理定時器，taskTimer()建立一個定時器，放到定時器列表執行，當定時時間到，會生成一個定時器事件，放到事件列表，分發到具體的事件處理任務。

//common.h
#ifndef __COMMON_H
#define __COMMON_H


#include "stdio.h"
#include 
#include 


typedef short int16_t;
typedef int int32_t;
typedef long long int64_t;
typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
typedef unsigned int uint32_t;
typedef unsigned long long uint64_t;
typedef unsigned char bool;


#define false 0
#define true 1


#endif // __COMMON_H

//task.h
#ifndef _THREAD_H
#define _THREAD_H


#define TASK_MAX 20 // 最多任務數量
#define TASK_EVENT_MAX 100 // 任務隊列長度
#define TASK_TIMER_MAX 100 // 定時器最大數量


typedef void (*CBTaskEvent)(int taskID,uint32_t eventID);
typedef struct _TASK_EVENT
{
    int taskID;
    uint32_t eventID;


} TASK_EVENT;


int taskCreat(CBTaskEvent task);
void taskLoop();
void taskEventIssue(int taskID,uint32_t eventID);
void taskEventLoop();


//定時、休眠


typedef struct _TASK_TIMER
{
    bool isValid;
    int taskID;
    uint32_t eventID;
    uint32_t timeMs;
    uint32_t start;


} TASK_TIMER;


void taskTicksInc();
void taskTimer(int taskID,uint32_t eventID,uint32_t time_ms);
void taskTimerLoop();


#endif // _THREAD_H

//task.c
#include "common.h"
#include "task.h"


CBTaskEvent g_taskList[TASK_MAX]={0};


int taskFindEmpty()
{
    static int index = -1;


    for(int i=0; i
",taskID);


    return taskID;
}


void taskDestroy(int taskID)
{
    printf("Destroy task<%d>
",taskID);


    g_taskList[taskID] = NULL;
}


void taskLoop()
{
    taskEventLoop();
    taskTimerLoop();
}


TASK_EVENT g_taskEventList[TASK_EVENT_MAX];
int g_TKEventWrite=0;
int g_TKEventRead=0;


int tkEventGetSize()
{
    return (g_TKEventWrite + TASK_EVENT_MAX - g_TKEventRead)% TASK_EVENT_MAX;
}


void taskEventIssue(int taskID,uint32_t eventID)
{
    int writePos;


    if(taskID >= TASK_EVENT_MAX || taskID < 0)
    {
        printf("taskEventIssue() error:taskID
");
        return;
    }


    writePos = (g_TKEventWrite + 1)% TASK_EVENT_MAX;


    if(writePos == g_TKEventRead)
    {
        printf("taskEventIssue() error:task<%d> event list is full!
",taskID);
        return;
    }


    g_taskEventList[g_TKEventWrite].taskID=taskID;
    g_taskEventList[g_TKEventWrite].eventID=eventID;
    g_TKEventWrite=writePos;


    //printf("add event:%x
",eventID);
}


void taskEventLoop()
{
    TASK_EVENT event;
    CBTaskEvent task;
    int size;


    size=tkEventGetSize();
    while(size-- >0)
    {
        event=g_taskEventList[g_TKEventRead];
        g_TKEventRead = (g_TKEventRead + 1)% TASK_EVENT_MAX;


        task = g_taskList[event.taskID];
        if(!task)
        {
            printf("taskEventLoop() error:task is NULL
");
            continue;
        }


        task(event.taskID,event.eventID);
    }
}


// 定時、休眠


uint32_t g_taskTicks=0;


uint32_t getTaskTicks()
{
    return g_taskTicks;
}


void taskTicksInc() // 1ms時間基準
{
    g_taskTicks++;
}


uint32_t taskTickDiff(uint32_t now,uint32_t last)
{
    uint64_t diff;
    diff = now + 0x100000000 - last;


    return (diff & 0xffffffff);
}


TASK_TIMER g_taskTimerList[TASK_TIMER_MAX]={0};


int taskTimerFindEmpty()
{
    for(int i=0; i %ums
",taskID,eventID,time_ms);


}


void taskTimerLoop()
{
    static uint32_t start=0;
    if(taskTickDiff(getTaskTicks(),start)<3)
    {
        return;
    }


    start=getTaskTicks();


    for(int i=0; i=g_taskTimerList[i].timeMs)
            {
                taskEventIssue(g_taskTimerList[i].taskID,g_taskTimerList[i].eventID);
                g_taskTimerList[i].isValid=false;
            }
        }
    }
}

//test_task.h
#ifndef _TEST_THREAD_H
#define _TEST_THREAD_H


void testInit();
void testLoop();


#endif // 

//test_task.c
#include "common.h"
#include "task.h"


#define CTRL_EVENT1 0x01
#define CTRL_EVENT2 0x02
#define CTRL_EVENT3 0x04


void eventProcess(int taskID,uint32_t event)
{
    switch(event)
    {
        case CTRL_EVENT1:
            printf("task[%d] CTRL_EVENT1
",taskID);
            //taskEventIssue(taskID,CTRL_EVENT2);
            taskTimer(taskID,CTRL_EVENT2,1000);
            break;


        case CTRL_EVENT2:
            printf("task[%d] CTRL_EVENT2
",taskID);
            //taskEventIssue(taskID,CTRL_EVENT3);
            taskTimer(taskID,CTRL_EVENT3,2000);
            break;


        case CTRL_EVENT3:
            printf("task[%d] CTRL_EVENT3
",taskID);
            taskTimer(taskID,CTRL_EVENT1,4000);
            break;


        default:
            break;
    }
}


void testLoop()
{
    taskLoop();
}


void testInit()
{
    int taskID1,taskID2;


    printf("testInit()
");


    taskID1 = taskCreat((CBTaskEvent)&eventProcess);


    taskTimer(taskID1,CTRL_EVENT1,5000);


    taskID2 = taskCreat((CBTaskEvent)&eventProcess);
    taskEventIssue(taskID2,CTRL_EVENT2);
    taskDestroy(taskID1);
    taskDestroy(taskID2);
    //taskEventIssue(taskID1,CTRL_EVENT1);
    taskID1 = taskCreat((CBTaskEvent)&eventProcess);
    taskEventIssue(taskID1,CTRL_EVENT1);
}