开源：类OS的调度器

tabc_123

此调度器，结合本论坛各位高手的代码，及Protothreads，加上自己的理解，及实际在项目中的使用情况不断修改而成，
在这里要感谢各位坛友的代码；
本调度器共3个文件
schedule.h
schedule.c
sch_cfg.h

本调度器特点：
1，仿OS编程方式
2，代码优化等级不能过高
3，适用于前后台及OS的系统中
4，占用一个CPU一个定时器
5，支持信号量
6，支持邮箱

代码如下：
schedule.h

1. #ifndef _SCH_H
   
2. #define _SCH_H
   
3. 
   
4. #ifdef __cplusplus
   
5. extern "C" {
   
6. #endif
   
7. 
   
8. /**********************************************************************************************************
   
9. *                                       schedule 版本号
   
10. **********************************************************************************************************/
    
11. 
    
12. #define  SCH_VERSION                 02100u              
    
13. 
    
14. /**********************************************************************************************************
    
15. *                                        包含头文件
    
16. **********************************************************************************************************/
    
17. 
    
18. #include <sch_cfg.h>
    
19.    
    
20. #ifndef  SCH_GLOBALS
    
21. #define  SCH_EXT  extern
    
22. #else
    
23. #define  SCH_EXT
    
24. #endif
    
25. 
    
26. /**********************************************************************************************************
    
27. *                                        数据结构定义
    
28. **********************************************************************************************************/
    
29. typedef struct {                                        //任务TCB数据类型定义
    
30.         SCH_TICKS                TaskDly;
    
31.         INT8U                        SpawnExitFlag;
    
32. } SCH_TCB;
    
33. 
    
34. typedef SCH_TICKS        SEM;                        //信号量数据类型定义
    
35. typedef struct {                                        //邮箱数据类型定义
    
36.         SCH_TICKS Dly;
    
37.         void *pMbox;
    
38. } MBOX;
    
39. 
    
40. /**********************************************************************************************************
    
41. *                                       全局变量定义
    
42. **********************************************************************************************************/
    
43. SCH_EXT SCH_TCB         TaskTcb[SCH_MAX_TASKS];                        //任务状态数据结构
    
44. SCH_EXT INT8U                CurRunTaskId;                                        //当前运行任务的ID号
    
45. 
    
46. 
    
47. /**********************************************************************************************************
    
48. *                                       系统状态定义
    
49. **********************************************************************************************************/
    
50. #define SCH_ERR_NONE                     0u
    
51. #define SCH_ERR_TIMEOUT                 10u
    
52. 
    
53. /**************************************************************************************************************
    
54. ************任务相关宏
    
55. 【1】任务创建按实例创建：
    
56. void Task_xxx(void)
    
57. {
    
58.         SCH_TaskBegin();
    
59.         while(1) {
    
60.                 //用户代码
    
61.                 SCH_TimeDly(SCH_TICKS_PER_SEC/100);                //根据任务实际周期进行延时
    
62.         }
    
63.         SCH_TaskEnd();
    
64. }
    
65. 【注意】
    
66.         1，任务必须是无限循环，不能返回；
    
67.         2，任务中必须有延时函数或等待信号量，便于任务出让CPU使用权；
    
68.         3，任务函数中使用的非静态局部变量会在任务出让CPU后，变量消失，因此要想某个变量不消失，则要使用静态变量
    
69. 
    
70. 【2】任务调度，按以下实例
    
71. SCH_TaskRun(Task_xxx,0);
    
72. 【注意】
    
73.         1，各任务的ID不能相同
    
74. **************************************************************************************************************/
    
75. 
    
76. 
    
77. //@任务开始宏，在任务函数的变量声明后引用
    
78. #define SCH_TaskBegin()        static INT16U _lc=0u; switch(_lc){case 0:
    
79.                                                
    
80. //@任务结束宏，在任务尾引用
    
81. #define SCH_TaskEnd() }                               
    
82. 
    
83. //@任务调用宏，在主循环中调用
    
84. //@ TaskName:任务名
    
85. //@ TaskID：任务ID，最大值不能超过"SCH_MAX_TASKS"值,且每个任务的ID不能相同
    
86. #define SCH_TaskRun(TaskName,TaskID) \
    
87.     do { \
    
88.                 CurRunTaskId = TaskID; \
    
89.         if(TaskTcb[CurRunTaskId].TaskDly==0) { \
    
90.             TaskName(); \
    
91.         } \
    
92.     } while(0);
    
93. 
    
94.        
    
95. /**************************************************************************************************************
    
96. ************子任务相关宏
    
97. 【1】子任务创建按实例创建：
    
98. void SubTask_xxx(void)
    
99. {
    
100.         SCH_SubTaskBegin();
     
101.         //用户代码
     
102.         SCH_TimeDly(SCH_TICKS_PER_SEC/100);                //根据任务实际周期进行延时
     
103.         SCH_SubTaskEnd();
     
104. }
     
105. 【注意】
     
106.         1，子任务不可以是无限循环，否则子任务后面程序无法执行；
     
107.         2，子任务可以带参数；
     
108.         3，子任务中必须有延时函数或等待信号量，便于任务出让CPU使用权；
     
109.         4，子任务函数中使用的非静态局部变量会在任务出让CPU后，变量消失，因此要想某个变量不消失，则要使用静态变量
     
110. 
     
111. 【2】子任务调度，按以下实例
     
112.         SCH_CallSubTask(SubTask_xxx());
     
113. **************************************************************************************************************/
     
114. 
     
115. //@子任务开始宏，在子任务函数的变量声明后引用
     
116. #define SCH_SubTaskBegin() static INT16U _lc=0u;TaskTcb[CurRunTaskId].SpawnExitFlag=1u;switch(_lc){case 0u:
     
117.        
     
118. //@子任务结束宏，在子任务函数尾引用
     
119. #define SCH_SubTaskEnd() }_lc=0;TaskTcb[CurRunTaskId].SpawnExitFlag=0u;return
     
120. 
     
121. //@子任务调用宏，在任务中调用，允许多层嵌套
     
122. //@ SubTaskName:子任务名
     
123. //@ p_arg：子线程函数输入参数
     
124. #define SCH_CallSubTask(SubTaskFun)        \
     
125.         while(1) { \
     
126.                 _lc=(__LINE__%65535);return;case(__LINE__%65535): { \
     
127.                         SubTaskFun; \
     
128.                 } \
     
129.                 if(TaskTcb[CurRunTaskId].SpawnExitFlag==0u) { \
     
130.                         break; \
     
131.                 } \
     
132.         }
     
133.        
     
134. 
     
135. 
     
136. 
     
137. /**************************************************************************************************************
     
138. ************延时宏定义
     
139. **************************************************************************************************************/
     
140. 
     
141. //@延时宏，在任务开始宏和结束宏之间的任意位置引用;
     
142. //@【注】由于此调度器运用了C语言的行号的宏代码，因此此宏定义最好放在一行代码中，不能拆分此宏定义，防止行号返回出错
     
143. //@ ticks：延时时间
     
144. #define SCH_TimeDly(ticks)         do{_lc=(__LINE__%65535);TaskTcb[CurRunTaskId].TaskDly=ticks;return;}while(0);case (__LINE__%65535):
     
145. 
     
146. /**************************************************************************************************************
     
147. ************信号量相关调用宏定义
     
148. **************************************************************************************************************/
     
149. //@信号量创建
     
150. #define SCH_SemCreate(Sem) Sem = 1
     
151. 
     
152. //@w信号量等待
     
153. //@        sem--等待信号量;
     
154. //@        timeout--等待超时时间,0--直到成功等待信号量;
     
155. //@        err--等待信号状态，SCH_ERR_NONE-等待成功，SCH_ERR_TIMEOUT-等待超时
     
156. #define SCH_SemPend(sem,timeout,err) \
     
157.     do { \
     
158.                 if(sem==0) { \
     
159.                         sem = 1; \
     
160.                         err = SCH_ERR_NONE; \
     
161.                 } else { \
     
162.                         sem = timeout + 1; \
     
163.                         SCH_TimeDly(0); \
     
164.                         if(timeout==0) { \
     
165.                                 if(sem>0) { \
     
166.                                         TaskTcb[CurRunTaskId].TaskDly = 0; \
     
167.                                         return; \
     
168.                                 } \
     
169.                                 sem = 1; \
     
170.                                 err = SCH_ERR_NONE; \
     
171.                         } else { \
     
172.                                 if(sem>1) { \
     
173.                                         sem --; \
     
174.                                         TaskTcb[CurRunTaskId].TaskDly = 1; \
     
175.                                         return; \
     
176.                                 } else if(sem==1) { \
     
177.                                         err = SCH_ERR_TIMEOUT; \
     
178.                                 } else { \
     
179.                                         sem = 1; \
     
180.                                         err = SCH_ERR_NONE; \
     
181.                                 } \
     
182.                         } \
     
183.                 } \
     
184.     } while(0)
     
185. 
     
186. //@ 发出一个信号量
     
187. #define SCH_SemPost(Sem) \
     
188.     do { \
     
189.         Sem = 0; \
     
190.     } while(0)
     
191.        
     
192. /**************************************************************************************************************
     
193. ************邮箱相关调用宏定义
     
194. **************************************************************************************************************/
     
195. #if SCH_MBOX_EN > 0u
     
196.        
     
197. //@创建邮箱
     
198. #define SCH_MboxCreate(mbox) do{mbox.Dly = 1;mbox.pMbox = (void*)0;}while(0)
     
199. 
     
200. //@ 邮箱等待
     
201. //@        mbox--等待邮箱;
     
202. //@ pmsg--等待成功后接收邮箱数据指针;
     
203. //@        timeout--等待邮箱超时时间,0--直到成功等待邮箱;
     
204. //@        err--等待邮箱状态，SCH_ERR_NONE-等待成功，SCH_ERR_TIMEOUT-等待超时
     
205. #define SCH_MboxPend(mbox,pmsg,timeout,err) \
     
206.     do { \
     
207.                 if(mbox.pMbox!=(void*)0) { \
     
208.                         pmsg = mbox.pMbox; \
     
209.                         mbox.pMbox = (void*)0; \
     
210.                         err = SCH_ERR_NONE; \
     
211.                 } else { \
     
212.                         mbox.Dly = timeout + 1; \
     
213.                         SCH_TimeDly(0); \
     
214.                         if(timeout==0) { \
     
215.                                 if(mbox.pMbox==(void*)0) { \
     
216.                                         TaskTcb[CurRunTaskId].TaskDly = 0; \
     
217.                                         return; \
     
218.                                 } \
     
219.                                 pmsg = mbox.pMbox; \
     
220.                                 mbox.pMbox = (void*)0; \
     
221.                                 err = SCH_ERR_NONE; \
     
222.                         } else { \
     
223.                                 if(mbox.pMbox!=(void*)0) { \
     
224.                                         pmsg = mbox.pMbox; \
     
225.                                         mbox.pMbox = (void*)0; \
     
226.                                         err = SCH_ERR_NONE; \
     
227.                                 } else { \
     
228.                                         if(mbox.Dly>1) { \
     
229.                                                 mbox.Dly --; \
     
230.                                                 TaskTcb[CurRunTaskId].TaskDly = 1; \
     
231.                                                 return; \
     
232.                                         } else if(mbox.Dly==1) { \
     
233.                                                 pmsg = (void*)0; \
     
234.                                                 mbox.pMbox = (void*)0; \
     
235.                                                 err = SCH_ERR_TIMEOUT; \
     
236.                                         } \
     
237.                                 } \
     
238.                         } \
     
239.                 } \
     
240.     } while(0)
     
241. 
     
242. //@ 发出一个邮箱
     
243. #define SCH_MobxPost(mbox,pmsg) \
     
244.     do { \
     
245.         mbox.Dly = 0; \
     
246.                 mbox.pMbox = (void*)pmsg; \
     
247.     } while(0)
     
248.        
     
249.        
     
250. #endif
     
251.        
     
252.        
     
253.        
     
254. /*************************************
     
255.                         函数申明
     
256. *************************************/
     
257. void SCH_Init(void);
     
258. void SCH_TimeTick(void);
     
259. 
     
260. 
     
261. 
     
262. #endif       
     

复制代码

schedule.c

1. #define  SCH_GLOBALS
   
2. #include  <schedule.h>
   
3. 
   
4. 
   
5. /********************************************************************************************************
   
6. ** 函数名:        SCH_Init
   
7. ** 输  入:        无
   
8. ** 输  出:        无
   
9. ** 功能说明：调度器初始化函数，任务运行前调用
   
10. *********************************************************************************************************/
    
11. void SCH_Init(void)       
    
12. {
    
13.         INT8U i;
    
14.        
    
15.         CurRunTaskId = 0;
    
16.         for(i=SCH_MAX_TASKS;i>0;i--) {
    
17.                 TaskTcb[i-1].TaskDly = 0;
    
18.                 TaskTcb[i-1].SpawnExitFlag = 0;
    
19.         }
    
20. }
    
21. 
    
22. /********************************************************************************************************
    
23. ** 函数名:        SCH_TimeTick
    
24. ** 输  入:        无
    
25. ** 输  出:        无
    
26. ** 功能说明：调度器时钟节拍函数，在定时中断中调用
    
27. *********************************************************************************************************/
    
28. void SCH_TimeTick(void)       
    
29. {
    
30.         INT8U i;
    
31.         for(i=SCH_MAX_TASKS;i>0;i--) {      
    
32.         if(TaskTcb[i-1].TaskDly>0) {      //任务延时时间处理
    
33.             TaskTcb[i-1].TaskDly --;
    
34.         }
    
35.         }
    
36. }
    
37.        
    

复制代码

sch_cfg.h

1. #ifndef SCH_CFG_H
   
2. #define SCH_CFG_H
   
3. 
   
4. #define SCH_MAX_TASKS           10                  //最大任务数量，可以增加，最大255个
   
5. #define SCH_MBOX_EN             1                            // Enable (1) or Disable (0) 邮箱
   
6. 
   
7. 
   
8. #define SCH_TICKS_PER_SEC       1000                //1秒钟多少个系统时钟数
   
9. 
   
10. 
    
11. 
    
12. 
    
13. /**********************************************************************************************************
    
14. *                                              与编译器相关数据类型定义
    
15. **********************************************************************************************************/
    
16. typedef unsigned char  BOOLEAN;
    
17. typedef unsigned char  INT8U;                    /* Unsigned  8 bit quantity                           */
    
18. typedef signed   char  INT8S;                    /* Signed    8 bit quantity                           */
    
19. typedef unsigned short INT16U;                   /* Unsigned 16 bit quantity                           */
    
20. typedef signed   short INT16S;                   /* Signed   16 bit quantity                           */
    
21. typedef unsigned int   INT32U;                   /* Unsigned 32 bit quantity                           */
    
22. typedef signed   int   INT32S;                   /* Signed   32 bit quantity                           */
    
23. typedef float          FP32;                     /* Single precision floating point                    */
    
24. typedef double         FP64;                     /* Double precision floating point                    */
    
25. 
    
26. typedef unsigned int   SCH_TICKS;                //定义延时时钟数据类型
    
27. 
    
28. 
    
29. 
    
30. 
    
31. #endif

复制代码

测试代码

1. #include "includes.h"
   
2. #include "app_cfg.h"
   
3. 
   
4. SEM Sem1,Sem2;                                        //
   
5. MBOX mbox1,mbox2;
   
6. 
   
7. /********************************************************************************************************
   
8. ** 函数名:        App_FunSemCreate
   
9. ** 输  入:
   
10. ** 输  出:
    
11. ** 功能说明：信号量创建函数
    
12. *********************************************************************************************************/
    
13. static void App_FunSemCreate (void)
    
14. {
    
15.         INT8U                os_err;
    
16.        
    
17.         SCH_SemCreate(Sem1);       
    
18.         SCH_SemCreate(Sem2);
    
19.         SCH_MboxCreate(mbox1);
    
20.         SCH_MboxCreate(mbox2);
    
21. }
    
22. 
    
23. 
    
24. void Ledred(void)
    
25. {
    
26.         SCH_TaskBegin();
    
27.         while(1) {
    
28.                 LEDOn(RED_LED);
    
29.                 SCH_TimeDly(SCH_TICKS_PER_SEC/2);
    
30.                 LEDOff(RED_LED);
    
31.                 SCH_TimeDly(SCH_TICKS_PER_SEC/2);
    
32.         }
    
33.         SCH_TaskEnd();
    
34.        
    
35. }
    
36. 
    
37. void Ledgreen(void)
    
38. {
    
39.         SCH_TaskBegin();
    
40.         while(1) {
    
41.                 LEDOff(GREEN_LED);
    
42.                 SCH_TimeDly(SCH_TICKS_PER_SEC/2);
    
43.                 LEDOn(GREEN_LED);
    
44.                 SCH_TimeDly(SCH_TICKS_PER_SEC/2);
    
45.         }
    
46.         SCH_TaskEnd();
    
47. }
    
48. 
    
49. void Delay(void)
    
50. {
    
51.         static uint8_t        i;
    
52.        
    
53.         SCH_TaskBegin();
    
54.         while(1) {
    
55.                 for(i=0;i<5;i++) {
    
56.                         printf("Delay Cnt = %d\r\n",i);
    
57.                         SCH_TimeDly(SCH_TICKS_PER_SEC/2);
    
58.                 }
    
59.                 printf("Delay exit\r\n");
    
60.         }
    
61.         SCH_TaskEnd();
    
62. }
    
63. 
    
64. void Task_Sem1Test(void)
    
65. {
    
66.         uint8_t        err;
    
67.        
    
68.         SCH_TaskBegin();
    
69.         while(1) {
    
70.                 printf("Sem1 等待置位...\r\n");
    
71.                 SCH_SemPend(Sem1,0,err);
    
72.                 printf("Sem1 等待成功...\r\n");
    
73.         }
    
74.         SCH_TaskEnd();
    
75. }
    
76. 
    
77. void Task_Sem2Test(void)
    
78. {
    
79.         uint8_t        err;
    
80.        
    
81.         SCH_TaskBegin();
    
82.         while(1) {
    
83.                 printf("Sem2 等待置位,1秒钟超时...\r\n");
    
84.                 SCH_SemPend(Sem2,SCH_TICKS_PER_SEC*10,err);
    
85.                 if(err==SCH_ERR_TIMEOUT) {
    
86.                         printf("【Sem2】 等待超时...\r\n");
    
87.                 } else {
    
88.                         printf("Sem2 等待成功...\r\n");
    
89.                 }
    
90.         }
    
91.         SCH_TaskEnd();
    
92. }
    
93. 
    
94. void Task_Mbox1Test(void)
    
95. {
    
96.         uint8_t        err;
    
97.         char         *p;
    
98.        
    
99.         SCH_TaskBegin();
    
100.         while(1) {
     
101.                 printf("mbox1 等待置位,1秒超时...\r\n");
     
102.                 SCH_MboxPend(mbox1,p,SCH_TICKS_PER_SEC*5,err);
     
103.                 if(err==SCH_ERR_TIMEOUT) {
     
104.                         printf("【mbox1】 等待超时...\r\n");
     
105.                 } else {
     
106.                         printf("mbox1 等待成功...\r\n");
     
107.                         printf("mbox=[%s]\r\n",p);
     
108.                 }
     
109.         }
     
110.         SCH_TaskEnd();
     
111. }
     
112. 
     
113. void Task_Swap(void *p_arg)
     
114. {
     
115.         static uint8_t         i;
     
116.        
     
117.         SCH_SubTaskBegin();
     
118. 
     
119.         for(i=0;i<5;i++) {
     
120.                 printf("swap cnt = %d\r\n",i);
     
121.                 SCH_TimeDly(SCH_TICKS_PER_SEC*2);
     
122.         }
     
123.        
     
124.         printf("Task_Swap Exit\r\n");
     
125.         SCH_SubTaskEnd();
     
126.        
     
127. }
     
128. 
     
129. void Task_Swap1(void *p_arg)
     
130. {
     
131.         static uint8_t         i;
     
132.         uint8_t                xx;
     
133.        
     
134.         SCH_SubTaskBegin();
     
135.        
     
136.         //SCH_CallSubTask(Task_Swap(NULL));
     
137.        
     
138.         printf("swap exit \r\n");
     
139.         for(i=0;i<5;i++) {
     
140.                 printf("swap1 cnt = %d\r\n",i);
     
141.                 SCH_TimeDly(SCH_TICKS_PER_SEC*2);
     
142.         }
     
143.        
     
144.         printf("Task_Swap1 Exit\r\n");  
     
145.         SCH_SubTaskEnd();
     
146. }
     
147. 
     
148. 
     
149. void Task_SwapTest(void)
     
150. {
     
151.         uint8_t        err;
     
152.         void         *p;
     
153.        
     
154.         int                test;
     
155.           
     
156.         SCH_TaskBegin();  
     
157.         while(1) {
     
158.                 printf("子任务调用测试...\r\n");
     
159.                 SCH_CallSubTask(Task_Swap1(NULL));
     
160.                
     
161.                 printf("子任务调用测试完成，延时2秒...\r\n");
     
162.                 SCH_TimeDly(SCH_TICKS_PER_SEC*2);
     
163.         }
     
164.         SCH_TaskEnd();
     
165. }
     
166. 
     
167. /********************************************************************************************************
     
168. ** 函数名:main
     
169. ** 输  入:
     
170. ** 输  出:
     
171. ** 功能说明：main函数
     
172. *********************************************************************************************************/
     
173. int main (void)
     
174. {       
     
175.        
     
176.         uint32_t        i = 0;
     
177.         uint32_t        ConnectTime;
     
178.        
     
179.         uint8_t                AppDownload = FALSE;
     
180.         uint8_t                buf[256];
     
181.        
     
182.         uint32_t        Test = 0,Test2 = 0;
     
183.        
     
184.         uint8_t                ConnectStatus = FALSE;
     
185.         char            GetKey;
     
186.        
     
187.         /*=========初始化核心代码=========*/
     
188.         SCH_Init();                                                                //调度器初始化
     
189.        
     
190.         //初始化全局应用变量
     
191.         GlobalTime = 998;                                //计数器
     
192. 
     
193.         App_FunSemCreate();
     
194.        
     
195.     BSP_GPIOConfiguration();                               //GPIO配置
     
196.         BSP_CpuPeriphInit();                                         //CPU相关硬件初始化
     
197.        
     
198.         BSP_WDT_HardInit();                                                //看门狗初始化
     
199.        
     
200.         LEDOff(GREEN_LED);
     
201.         LEDOff(RED_LED);
     
202.        
     
203.         BSP_WDTHardReset();               
     
204.        
     
205.         while(1) {
     
206.                
     
207.                 SCH_TaskRun(Ledred,0);               
     
208.                 //SCH_TaskRun(Delay,1);
     
209.                
     
210.                 //SCH_TaskRun(Task_Sem1Test,2);
     
211.                 //SCH_TaskRun(Task_Sem2Test,3);
     
212.                 //SCH_TaskRun(Task_Mbox1Test,4);
     
213.                 Task_Swap(NULL);
     
214.                 SCH_TaskRun(Task_SwapTest,4);
     
215. 
     
216.                 GetKey = _getkey();
     
217.         if(GetKey!=-1) {
     
218.                         if(GetKey=='x') {
     
219.                                 printf("Test Sem1\r\n");
     
220.                                 SCH_SemPost(Sem1);
     
221.                         } else if(GetKey=='y') {
     
222.                                 printf("Test Sem2\r\n");
     
223.                                 SCH_SemPost(Sem2);
     
224.                         } else if(GetKey=='m') {
     
225.                                 printf("Test mobx1\r\n");
     
226.                                 sprintf((char*)buf,"Test mobx1\r\n");
     
227.                                 SCH_MobxPost(mbox1,buf);
     
228.                         }
     
229.         }
     
230.         }
     
231. }
     
232. 
     
233. 
     
234. 
     
235. /**
     
236.   * @brief  Reports the name of the source file and the source line number
     
237.   *         where the assert_param error has occurred.
     
238.   * @param  file: pointer to the source file name
     
239.   * @param  line: assert_param error line source number
     
240.   * @retval None
     
241.   */
     
242. #ifdef  USE_FULL_ASSERT
     
243. void assert_failed(uint8_t* file, uint32_t line)
     
244. {
     
245.     static char str1[256];
     
246.         static uint32_t temp;
     
247.        
     
248.         memcpy((void*)str1,(const void*)file,strlen((const char*)file));
     
249.         temp = line;
     
250.   /* User can add his own implementation to report the file name and line number,
     
251.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
     
252.         //my_printf("Worng parameters value:file%s on line %d\r\n",file,line);
     
253.        
     
254.         /* Infinite loop */
     
255.         while(1) {       
     
256.         }
     
257. }
     
258. #endif
     
259. /*************************************************end of file********************************************/
     

复制代码

使用说明：
1，定时器中调用函数：SCH_TimeTick()
2，main函数开关调用SCH_Init()

=========================分割线==========================================

错误不合理之处，望大家指正，修改，一起完善。

tabc_123

占楼              

hkjabcd

顶起，楼主能否解释下思路？

mint

这个宏用的，飞起啊～～～

lize91

mark
好好拜读下

68336016

也不能使用 switch语句？

dgtg

mark!!!楼主讲一讲思路嘛....

summarize

支持LZ不断改进,造福坛友.

haowei029

不错
学习学习

lushanlq

支持一下，好像是Protothreads修改的。

ycping

解说一下呗，

aming2046

能否提供完整的工程文件啊，谢谢了啊

jungleyang

太复杂了，看到这么多宏，头大了！

天涯沦人

mark! 学习了。。

eddia2012

这个OS很适用，顶顶顶！

RainKing

一个思路，学习了.............

minier

很牛！！！试用一下看看

guhaijun

mark一下

videofun

能否提供完整的工程文件啊，谢谢了啊

tabc_123

不知道，1楼的帖子怎么编辑，现将最新版本的程序给出



app.c为测试例子

foxpro2005

tabc_123 发表于 2015-5-18 10:23
不知道，1楼的帖子怎么编辑，现将最新版本的程序给出

LZ升级扩展得不错， 感谢分享， 有时间试试

graycker

好帖子，赞一个

guolun

研究一下调度器

shouqiang_zhang

谢谢楼主, 学习了.

nuncle

mark'dddff

zhuzi1441

请问一下，这个调度器是不是没有优先级了，哪位明白的，给说一下，谢谢。

tabc_123

zhuzi1441 发表于 2015-7-21 15:38
请问一下，这个调度器是不是没有优先级了，哪位明白的，给说一下，谢谢。 ...

还是有优先级的，而且任务的优先级不允许相同

zhuzi1441

非常感谢楼主的回复，有穵试月子，感觉很不错。

leibwell

mark，谢了

zd0305

2015最新版  SCH_TimeDly(Ticks) MPLAB X + XC8  环境 编译报错：constant expression required

tabc_123

zd0305 发表于 2015-7-27 15:39
2015最新版  SCH_TimeDly(Ticks) MPLAB X + XC8  环境 编译报错：constant expression required

我这没有这种编译器，无法测试，你在仔细研究一下，如果问题解决，希望你说下解决方法

zd0305

经测试：
#define SCH_TimeDly(ticks)         do{_lc=(__LINE__%65535);TaskTcb[CurRunTaskId].TaskDly=ticks;TaskTcb[CurRunTaskId].SubExitFlag=1u;return;}while(0);case (__LINE__%65535):
中的case (__LINE__%65535):  这一语句编译不过，错误提示：case 语句需要常量；
临时解决办法：
#define SCH_TimeDly(ticks)         do{_lc=(__LINE__);TaskTcb[CurRunTaskId].TaskDly=ticks;TaskTcb[CurRunTaskId].SubExitFlag=1u;return;}while(0);case (__LINE__):

qiguibao

楼主，这个调度器不支持高优先级抢占，这样高优先级的任务实时性不能保证吧~

tabc_123

zd0305 发表于 2015-7-28 10:40
经测试：
#define SCH_TimeDly(ticks)         do{_lc=(__LINE__%65535);TaskTcb[CurRunTaskId].TaskDly=ticks;Tas ...

可能是编译器不一样，应该这种表达示是在预编译时处理的，可能你的编译器是将此类表达示放在程序运行中处理的，这是我的理解

tabc_123

qiguibao 发表于 2015-8-2 09:51
楼主，这个调度器不支持高优先级抢占，这样高优先级的任务实时性不能保证吧~ ...

这种调度器与RTOS是有区别的，不能进行抢占，只能说任务编号越小，提前执行而已

eddia2012

这个调度器很好用。

tabc_123

eddia2012 发表于 2015-8-13 08:14
这个调度器很好用。

谢谢使用，使用过程中有任何问题，请指出

yick

mark,又是一个关于timer定时器的

wofei3344

有时间了再来验证，谢谢分享~

luozhongchao123

已经经过修改用在小产品上了！谢谢楼主的开源！

tabc_123

luozhongchao123 发表于 2015-8-16 16:07
已经经过修改用在小产品上了！谢谢楼主的开源！

能否分开修改部分的代码，一起将此代码修改得更加完善。。。。。

wxlcj

楼主，求一个stm8完整工程。

tabc_123

wxlcj 发表于 2015-8-30 22:54
楼主，求一个stm8完整工程。

前面的例子，不用CPU的，直接可以使用

weiwei4

不错，学习

wangyy@dianzi

很好，支持

闲鱼翻身

感谢分享，好东西

eddia2012

借用楼主的思想，已用在好多工程中了。

four_zhg

好好学习楼主的思想试试看

rube

tabc_123 发表于 2015-5-18 10:23
不知道，1楼的帖子怎么编辑，现将最新版本的程序给出

能否将getkey（）函数发上来，学习你是怎么写的。
我以前都是状态机方式。

tabc_123

rube 发表于 2016-9-6 14:31
能否将getkey（）函数发上来，学习你是怎么写的。
我以前都是状态机方式。 ...

我理解错了，getkey（）只是一个串口数据接收函数

rube

tabc_123 发表于 2016-9-7 09:03
我理解错了，getkey（）只是一个串口数据接收函数

哦，谢谢

int

学习一个，纯C的调度器太巧妙了，使用调度器管理可以极大地减少阻塞

HalenYU

支持创新

jorry

学习一下，谢谢！@！

shunli1014

，谢谢分享；学习了