单片机多任务事件驱动C源码

有丶意思

前言

单片机的ROM与RAM存贮空间有限，一般没有多线程可用，给复杂的单片机项目带来困扰。经过多年的单片机项目实践，借鉴windows消息机制的思想，编写了单片机多任务事件驱动C代码，应用于单片机项目，无论复杂的项目，还是简单的项目，都可以达到优化代码架构的目的。经过几轮的精简、优化，现在分享给大家。

设计思路

代码分为3个模块：任务列表、事件列表、定时器列表。

任务列表创建一个全局列表管理任务，通过调用taskCreat()创建事件处理任务，创建成功返回任务ID，任务列表、事件列表与定时器列表通过任务ID关联。

事件列表创建一个全局循环列表管理事件，调用taskEventIssue()生成一个事件，放到事件循环列表，taskEventLoop()函数放到主线程循环调用，当事件循环列表中有事件时，根据任务ID分发到具体的事件处理任务。

定时器列表创建一个全局列表管理定时器，taskTimer()建立一个定时器，放到定时器列表执行，当定时时间到，会生成一个定时器事件，放到事件列表，分发到具体的事件处理任务。

代码例程：

1. //common.h
   
2. #ifndef __COMMON_H
   
3. #define __COMMON_H
   
4. 
   
5. #include "stdio.h"
   
6. #include <stdlib.h>
   
7. #include <string.h>
   
8. 
   
9. typedef short int16_t;
   
10. typedef int int32_t;
    
11. typedef long long int64_t;
    
12. typedef unsigned char uint8_t;
    
13. typedef unsigned short uint16_t;
    
14. typedef unsigned int uint32_t;
    
15. typedef unsigned long long uint64_t;
    
16. typedef unsigned char bool;
    
17. 
    
18. #define false 0
    
19. #define true 1
    
20. 
    
21. #endif // __COMMON_H

复制代码

1. //task.h
   
2. #ifndef _THREAD_H
   
3. #define _THREAD_H
   
4. 
   
5. #define TASK_MAX 20 // 最多任务数量
   
6. #define TASK_EVENT_MAX 100 // 任务队列长度
   
7. #define TASK_TIMER_MAX 100 // 定时器最大数量
   
8. 
   
9. typedef void (*CBTaskEvent)(int taskID,uint32_t eventID);
   
10. typedef struct _TASK_EVENT
    
11. {
    
12.     int taskID;
    
13.     uint32_t eventID;
    
14. 
    
15. } TASK_EVENT;
    
16. 
    
17. int taskCreat(CBTaskEvent task);
    
18. void taskLoop();
    
19. void taskEventIssue(int taskID,uint32_t eventID);
    
20. void taskEventLoop();
    
21. 
    
22. //定时、休眠
    
23. 
    
24. typedef struct _TASK_TIMER
    
25. {
    
26.     bool isValid;
    
27.     int taskID;
    
28.     uint32_t eventID;
    
29.     uint32_t timeMs;
    
30.     uint32_t start;
    
31. 
    
32. } TASK_TIMER;
    
33. 
    
34. void taskTicksInc();
    
35. void taskTimer(int taskID,uint32_t eventID,uint32_t time_ms);
    
36. void taskTimerLoop();
    
37. 
    
38. #endif // _THREAD_H

复制代码

1. //task.c
   
2. #include "common.h"
   
3. #include "task.h"
   
4. 
   
5. CBTaskEvent g_taskList[TASK_MAX]={0};
   
6. 
   
7. int taskFindEmpty()
   
8. {
   
9.     static int index = -1;
   
10. 
    
11.     for(int i=0; i<TASK_MAX; i++)
    
12.     {
    
13.         index++;
    
14.         index %= TASK_MAX;
    
15.         if(g_taskList[index]==NULL)
    
16.         {
    
17.             return index;
    
18.         }
    
19.     }
    
20. 
    
21.     return -1;
    
22. }
    
23. 
    
24. int taskCreat(CBTaskEvent task)
    
25. {
    
26.     int taskID;
    
27. 
    
28.     taskID=taskFindEmpty();
    
29.     if(taskID == -1)
    
30.     {
    
31.         printf("error:task list is full!\n");
    
32.         return -1;
    
33.     }
    
34. 
    
35.     g_taskList[taskID] = task;
    
36. 
    
37.     printf("creat task<%d>\n",taskID);
    
38. 
    
39.     return taskID;
    
40. }
    
41. 
    
42. void taskDestroy(int taskID)
    
43. {
    
44.     printf("Destroy task<%d>\n",taskID);
    
45. 
    
46.     g_taskList[taskID] = NULL;
    
47. }
    
48. 
    
49. void taskLoop()
    
50. {
    
51.     taskEventLoop();
    
52.     taskTimerLoop();
    
53. }
    
54. 
    
55. TASK_EVENT g_taskEventList[TASK_EVENT_MAX];
    
56. int g_TKEventWrite=0;
    
57. int g_TKEventRead=0;
    
58. 
    
59. int tkEventGetSize()
    
60. {
    
61.     return (g_TKEventWrite + TASK_EVENT_MAX - g_TKEventRead)% TASK_EVENT_MAX;
    
62. }
    
63. 
    
64. void taskEventIssue(int taskID,uint32_t eventID)
    
65. {
    
66.     int writePos;
    
67. 
    
68.     if(taskID >= TASK_EVENT_MAX || taskID < 0)
    
69.     {
    
70.         printf("taskEventIssue() error:taskID\n");
    
71.         return;
    
72.     }
    
73. 
    
74.     writePos = (g_TKEventWrite + 1)% TASK_EVENT_MAX;
    
75. 
    
76.     if(writePos == g_TKEventRead)
    
77.     {
    
78.         printf("taskEventIssue() error:task<%d> event list is full!\n",taskID);
    
79.         return;
    
80.     }
    
81. 
    
82.     g_taskEventList[g_TKEventWrite].taskID=taskID;
    
83.     g_taskEventList[g_TKEventWrite].eventID=eventID;
    
84.     g_TKEventWrite=writePos;
    
85. 
    
86.     //printf("add event:%x\n",eventID);
    
87. }
    
88. 
    
89. void taskEventLoop()
    
90. {
    
91.     TASK_EVENT event;
    
92.     CBTaskEvent task;
    
93.     int size;
    
94. 
    
95.     size=tkEventGetSize();
    
96.     while(size-- >0)
    
97.     {
    
98.         event=g_taskEventList[g_TKEventRead];
    
99.         g_TKEventRead = (g_TKEventRead + 1)% TASK_EVENT_MAX;
    
100. 
     
101.         task = g_taskList[event.taskID];
     
102.         if(!task)
     
103.         {
     
104.             printf("taskEventLoop() error:task is NULL\n");
     
105.             continue;
     
106.         }
     
107. 
     
108.         task(event.taskID,event.eventID);
     
109.     }
     
110. }
     
111. 
     
112. // 定时、休眠
     
113. 
     
114. uint32_t g_taskTicks=0;
     
115. 
     
116. uint32_t getTaskTicks()
     
117. {
     
118.     return g_taskTicks;
     
119. }
     
120. 
     
121. void taskTicksInc() // 1ms时间基准
     
122. {
     
123.     g_taskTicks++;
     
124. }
     
125. 
     
126. uint32_t taskTickDiff(uint32_t now,uint32_t last)
     
127. {
     
128.     uint64_t diff;
     
129.     diff = now + 0x100000000 - last;
     
130. 
     
131.     return (diff & 0xffffffff);
     
132. }
     
133. 
     
134. TASK_TIMER g_taskTimerList[TASK_TIMER_MAX]={0};
     
135. 
     
136. int taskTimerFindEmpty()
     
137. {
     
138.     for(int i=0; i<TASK_TIMER_MAX; i++)
     
139.     {
     
140.         if(!g_taskTimerList[i].isValid)
     
141.         {
     
142.             return i;
     
143.         }
     
144.     }
     
145. 
     
146.     return -1;
     
147. }
     
148. 
     
149. void taskTimer(int taskID,uint32_t eventID,uint32_t time_ms)
     
150. {
     
151.     int index;
     
152. 
     
153.     index=taskTimerFindEmpty();
     
154.     if(index==-1)
     
155.     {
     
156.         printf("taskTimer() error:timer list is full\n");
     
157.         return;
     
158.     }
     
159. 
     
160.     g_taskTimerList[index].taskID=taskID;
     
161.     g_taskTimerList[index].eventID=eventID;
     
162.     g_taskTimerList[index].timeMs=time_ms;
     
163.     g_taskTimerList[index].start=getTaskTicks();
     
164.     g_taskTimerList[index].isValid=true;
     
165. 
     
166.     printf("add timer:<%d,%x> %ums\n",taskID,eventID,time_ms);
     
167. 
     
168. }
     
169. 
     
170. void taskTimerLoop()
     
171. {
     
172.     static uint32_t start=0;
     
173.     if(taskTickDiff(getTaskTicks(),start)<3)
     
174.     {
     
175.         return;
     
176.     }
     
177. 
     
178.     start=getTaskTicks();
     
179. 
     
180.     for(int i=0; i<TASK_TIMER_MAX; i++)
     
181.     {
     
182.         if(g_taskTimerList[i].isValid)
     
183.         {
     
184.             if(taskTickDiff(start,g_taskTimerList[i].start)>=g_taskTimerList[i].timeMs)
     
185.             {
     
186.                 taskEventIssue(g_taskTimerList[i].taskID,g_taskTimerList[i].eventID);
     
187.                 g_taskTimerList[i].isValid=false;
     
188.             }
     
189.         }
     
190.     }
     
191. }

复制代码

1. //test_task.h
   
2. #ifndef _TEST_THREAD_H
   
3. #define _TEST_THREAD_H
   
4. 
   
5. void testInit();
   
6. void testLoop();
   
7. 
   
8. #endif //

复制代码

1. //test_task.c
   
2. #include "common.h"
   
3. #include "task.h"
   
4. 
   
5. #define CTRL_EVENT1 0x01
   
6. #define CTRL_EVENT2 0x02
   
7. #define CTRL_EVENT3 0x04
   
8. 
   
9. void eventProcess(int taskID,uint32_t event)
   
10. {
    
11.     switch(event)
    
12.     {
    
13.         case CTRL_EVENT1:
    
14.             printf("task[%d] CTRL_EVENT1\n",taskID);
    
15.             //taskEventIssue(taskID,CTRL_EVENT2);
    
16.             taskTimer(taskID,CTRL_EVENT2,1000);
    
17.             break;
    
18. 
    
19.         case CTRL_EVENT2:
    
20.             printf("task[%d] CTRL_EVENT2\n",taskID);
    
21.             //taskEventIssue(taskID,CTRL_EVENT3);
    
22.             taskTimer(taskID,CTRL_EVENT3,2000);
    
23.             break;
    
24. 
    
25.         case CTRL_EVENT3:
    
26.             printf("task[%d] CTRL_EVENT3\n",taskID);
    
27.             taskTimer(taskID,CTRL_EVENT1,4000);
    
28.             break;
    
29. 
    
30.         default:
    
31.             break;
    
32.     }
    
33. }
    
34. 
    
35. void testLoop()
    
36. {
    
37.     taskLoop();
    
38. }
    
39. 
    
40. void testInit()
    
41. {
    
42.     int taskID1,taskID2;
    
43. 
    
44.     printf("testInit()\n");
    
45. 
    
46.     taskID1 = taskCreat((CBTaskEvent)&eventProcess);
    
47. 
    
48.     taskTimer(taskID1,CTRL_EVENT1,5000);
    
49. 
    
50.     taskID2 = taskCreat((CBTaskEvent)&eventProcess);
    
51.     taskEventIssue(taskID2,CTRL_EVENT2);
    
52.     taskDestroy(taskID1);
    
53.     taskDestroy(taskID2);
    
54.     //taskEventIssue(taskID1,CTRL_EVENT1);
    
55.     taskID1 = taskCreat((CBTaskEvent)&eventProcess);
    
56.     taskEventIssue(taskID1,CTRL_EVENT1);
    
57. }

复制代码