小小调度器问星整理版[可设置选择8/16/32位] 极小资源MCU操作系统

在原作者smset基础上增加1、可以在宏定义里选择8位 16位还是32位2、定义任务用TASK开头

1. //  任务0 任务定义以TASK开头
   
2. TASK task0(){
   
3. _SS
   
4.   while(1){
   
5.    WaitX(50);
   
6.    LED0=!LED0;   
   
7.   }
   
8. _EE
   
9. }

复制代码

3、增加实时性更高的等待某条件定义。
4、更多详细信息请参考附件内容。


最近修改记录：

2020-07-03
  1、增加 普通函数无阻塞延时开关宏定义，方便在不使用普通函数无阻塞延时功能时减少RAM占用和更新任务的时间：
      NORMALDELAY  默认为0关闭，修改为1则打开
  
  2020-04-17
   1、同步smset的小小调度器1.11（16位定时器版）,新增的等待某个条件或超时溢出
       WaitUtilT(A,TimeOut)
   2、在smset的WaitUtilT(A,TimeOut)基础上,增加等待某个条件为某个值或超时溢出
       WAITUNTILT(A,VAL,TimeOut)
  
  2019-05-30
  1、增加等待某个条件为某个值或超时溢出
      A条件变量;VAL条件值;TaskVAL超时值，不能为0，和TaskVAL的位数调度器定义的位数一样;ONLY超时判断唯一序号
      WAITUNTILO(A,VAL,TaskVAL,ONLY)
      每增加一个超时判断会增加一个调度器位数对应内存占用
  2、添加 void runTasks(void); 声明，确保部分编译器不会报错
  
  2019-05-29
   1、整合群主semet的普通函数无阻塞延时
   2、添加变量位数类型定义，方便根据编译器环境定义修改
   注意：无阻塞延时 只能被主任务，以及主任务调用的函数，及主任务调用的函数调用的函数使用


全部资料51hei下载地址：
小小调度器1.1.6问星整理版.zip (2.95 KB, 下载次数: 38)

2020-7-3 10:18 上传

点击文件名下载附件
小小调度器1.1.6问星整理版

1. #ifndef __xxddq_H
   
2. #define __xxddq_H
   
3. /*
   
4. * @Project      : 小小调度器问星整理版
   
5. * @Descripttion : 可设置选择8/16/32版本，在原来的基础上进一步增强
   
6. * @version      : 1.1.6 maintask版
   
7. * @Author       : smset
   
8. * @Date         : 2015-06-02 09:02:31
   
9. * @LastEditors  : 问星
   
10. * @LastEditTime : 2020-07-03 09:54:57
    
11. * @History      :
    
12. * 2020-07-03
    
13. * 1、增加 普通函数无阻塞延时开关宏定义，方便在不使用普通函数无阻塞延时功能时减少RAM占用和更新任务的时间：
    
14. *     NORMALDELAY  默认为0关闭，修改为1则打开
    
15. *
    
16. * 2020-04-17
    
17. *  1、同步smset的小小调度器1.11（16位定时器版）,新增的等待某个条件或超时溢出
    
18. *      WaitUtilT(A,TimeOut)
    
19. *  2、在smset的WaitUtilT(A,TimeOut)基础上,增加等待某个条件为某个值或超时溢出
    
20. *      WAITUNTILT(A,VAL,TimeOut)
    
21. *
    
22. * 2019-05-30
    
23. * 1、增加等待某个条件为某个值或超时溢出
    
24. *     A条件变量;VAL条件值;TaskVAL超时值，不能为0，和TaskVAL的位数调度器定义的位数一样;ONLY超时判断唯一序号
    
25. *     WAITUNTILO(A,VAL,TaskVAL,ONLY)
    
26. *     每增加一个超时判断会增加一个调度器位数对应内存占用
    
27. * 2、添加 void runTasks(void); 声明，确保部分编译器不会报错
    
28. *
    
29. * 2019-05-29
    
30. *  1、整合群主semet的普通函数无阻塞延时
    
31. *  2、添加变量位数类型定义，方便根据编译器环境定义修改
    
32. *  注意：无阻塞延时 只能被主任务，以及主任务调用的函数，及主任务调用的函数调用的函数使用
    
33. */
    
34. 
    
35. /****小小调度器开始********************************************/
    
36. //可根据编译器环境修改定义变量位数类型，如果出现重复定义错误提示，可以注释掉变量类型定义
    
37. #define U8 unsigned char        //8位变量类型定义
    
38. #define U16 unsigned int        //16位变量类型定义
    
39. #define U32 unsigned long        //32位变量类型定义
    
40. 
    
41. #define MAXTASKS 2          //定义调度器主任务数：1-255
    
42. #define BITS 8             //定义调度器位数可选值：8/16/32
    
43. #define NORMALDELAY 0       //普通函数无阻塞延时开关：0=关；1=开
    
44. #define SEM U16                            //信号量定义宏
    
45. 
    
46. #if (BITS==8)
    
47. #define TASK U8
    
48. #define TICKET_MAX 0xFF
    
49. #endif
    
50. 
    
51. #if (BITS==16)
    
52. #define TASK U16
    
53. #define TICKET_MAX 0xFFFF
    
54. #endif
    
55. 
    
56. #if (BITS==32)
    
57. #define TASK U32
    
58. #define TICKET_MAX 0xFFFFFFFF
    
59. #endif
    
60. 
    
61. volatile TASK timers[MAXTASKS];
    
62. #if (NORMALDELAY==1)
    
63. volatile TASK delaycount;
    
64. #endif
    
65. void runTasks(void);
    
66. 
    
67. //任务头
    
68. #define _SS static U8 _lc=0; switch(_lc){default:
    
69. 
    
70. //任务尾
    
71. #define _EE ;}; _lc=0; return TICKET_MAX;
    
72. 
    
73. //等待X个时钟周期
    
74. #define WaitX(tickets)  do { _lc=(__LINE__%255)+1; return (tickets) ;case (__LINE__%255)+1:;} while(0);
    
75. 
    
76. //等待某个条件
    
77. #define WaitUntil(A)    do { while(!(A)) WaitX(1);} while(0);
    
78. 
    
79. //等待某个条件为某个值        A条件变量;VAL条件值
    
80. #define WAITUNTIL(A,VAL)  do { WaitX(1);} while((A)!=VAL);
    
81. 
    
82. //等待某个条件或超时溢出
    
83. #define WaitUtilT(A,TimeOut)  do {static TASK _count=(TimeOut); do { WaitX(1); _count--; } while((!(A))&&(_count>0));} while(0);
    
84. 
    
85. //等待某个条件为某个值或超时溢出
    
86. #define WAITUNTILT(A,VAL,TimeOut)  do {static TASK _count=(TimeOut); do { WaitX(1); _count--; } while(((A)!=VAL)&&(_count>0));} while(0);
    
87. 
    
88. //等待某个条件为某个值或超时溢出        A条件变量;VAL条件值;TaskVAL超时值，不能为0，和TaskVAL的位数调度器定义的位数一样;ONLY超时判断唯一序号
    
89. #define WAITUNTILO(A,VAL,TaskVAL,ONLY)  do {static TASK A##ONLY;A##ONLY=TaskVAL;do {WaitX(1);A##ONLY--;} while((A)!=VAL && A##ONLY!=0);}while(0);
    
90. 
    
91. //只能用在RunTask调用的任务里 实时性更高 等待某个条件
    
92. #define WaitUntilR(A)    do { while(!(A)) WaitX(0);} while(0);
    
93. 
    
94. //只能用在RunTask调用的任务里 实时性更高 等待某个条件为某个值        A条件变量;VAL条件值
    
95. #define WAITUNTILR(A,VAL)  do { WaitX(0);} while((A)!=VAL);
    
96. 
    
97. //只能用在RunTask调用的任务里 实时性更高 等待某个条件或超时溢出
    
98. #define WaitUtilTR(A,TimeOut)  do {static TASK _count=(TimeOut); do { WaitX(0); _count--; } while((!(A))&&(_count>0));} while(0);
    
99. 
    
100. //只能用在RunTask调用的任务里 实时性更高 等待某个条件为某个值或超时溢出
     
101. #define WAITUNTILTR(A,VAL,TimeOut)  do {static TASK _count=(TimeOut); do { WaitX(0); _count--; } while(((A)!=VAL)&&(_count>0));} while(0);
     
102. 
     
103. //运行任务
     
104. #define RunTask(TaskName,TaskID)  do { if (timers[TaskID]==0) { TASK d=TaskName(); while(timers[TaskID]!=d) timers[TaskID]=d;} } while(0);
     
105. 
     
106. //运行任务，前面的任务优先保证执行
     
107. #define RunTaskA(TaskName,TaskID) do { if (timers[TaskID]==0) {TASK d=TaskName(); while(timers[TaskID]!=d) timers[TaskID]=d;continue;} } while(0);
     
108. 
     
109. //调用子任务
     
110. #define CallSub(SubTaskName) do {TASK currdt; _lc=(__LINE__%255)+1; return 0; case (__LINE__%255)+1:  currdt=SubTaskName(); if(currdt!=TICKET_MAX) return currdt;} while(0);
     
111. 
     
112. //调用子任务,传入一个参数,传入的参数需在释放CPU前使用
     
113. #define CallSub1(SubTaskName,p1) do {TASK currdt; _lc=(__LINE__%255)+1; return 0; case (__LINE__%255)+1:  currdt=SubTaskName(p1); if(currdt!=TICKET_MAX) return currdt;} while(0);
     
114. 
     
115. //调用子任务,传入二个参数,传入的参数需在释放CPU前使用
     
116. #define CallSub2(SubTaskName,p1,p2) do {TASK currdt; _lc=(__LINE__%255)+1; return 0; case (__LINE__%255)+1:  currdt=SubTaskName(p1,p2); if(currdt!=TICKET_MAX) return currdt;} while(0);
     
117. 
     
118. //初始化任务调度
     
119. #define InitTasks() do {U8 i; for(i=MAXTASKS;i>0 ;i--) timers[i-1]=0; } while(0);
     
120. 
     
121. #if (NORMALDELAY==0)
     
122. //更新任务
     
123. #define UpdateTimers() do{U8 i; for(i=MAXTASKS;i>0 ;i--){if((timers[i-1]!=0)&&(timers[i-1]!=TICKET_MAX)) timers[i-1]--;}} while(0);
     
124. #endif
     
125. 
     
126. #if (NORMALDELAY==1)
     
127. //更新任务
     
128. #define UpdateTimers() do{U8 i; for(i=MAXTASKS;i>0 ;i--){if((timers[i-1]!=0)&&(timers[i-1]!=TICKET_MAX)) timers[i-1]--;} if(delaycount>0) delaycount--;} while(0);
     
129. 
     
130. //普通函数无阻塞延时 只能被主任务，以及主任务调用的函数，及主任务调用的函数调用的函数 使用
     
131. #define DELAYX(tickets) do{delaycount=tickets;while(delaycount>0) {runTasks();}}while(0);
     
132. #endif
     
133. 
     
134. //初始化信号量
     
135. #define InitSem(sem) do{sem=0;}while(0);
     
136. 
     
137. //等待信号量
     
138. #define WaitSem(sem) do{ sem=1; WaitX(0); if (sem>0) return 1;} while(0);
     
139. 
     
140. //发送信号量
     
141. #define SendSem(sem)  do {sem=0;} while(0);
     
142. 
     
143. //等待信号量或定时器溢出
     
144. #define WaitSemX(sem, tickets) do{sem=tickets+1;WaitX(0);if(sem>1){sem--;return 1;}}while (0);
     
145. 
     
146. /*****小小调度器结束*******************************************************/
     
147. 
     
148. /*****调用示例*************************************************
     
149. #include "xxddq.h"
     
150. 
     
151. sbit LED1 = P2^1;
     
152. sbit LED2 = P2^2;
     
153. sbit LED0 = P2^5;
     
154. 
     
155. //  任务0 任务定义以TASK开头
     
156. TASK task0(){
     
157. _SS
     
158.   while(1){
     
159.    WaitX(50);
     
160.    LED0=!LED0;   
     
161.   }
     
162. _EE
     
163. }
     
164. //  任务1 任务定义以TASK开头
     
165. TASK task1(){
     
166. _SS
     
167.   while(1){
     
168.   // WaitX(100);
     
169.   // LED1=!LED1;
     
170.   test1();  
     
171.   }
     
172. _EE
     
173. }
     
174. //  任务2 任务定义以TASK开头
     
175. TASK task2(){
     
176. _SS
     
177.     while(1){
     
178.         WaitX(100);
     
179.         LED2=!LED2;   
     
180.     }
     
181. _EE
     
182. }
     
183. 
     
184. //  TIME0初始化
     
185. void InitT0()
     
186. {
     
187.     TMOD = 0x21;
     
188.     IE |= 0x82;  // 12t
     
189.     TL0=0Xff;
     
190.     TH0=0XDB;
     
191.     TR0 = 1;
     
192. }
     
193. //  TIM0中断服务
     
194. void INTT0(void) interrupt 1 using 1
     
195. {
     
196.     TL0=0Xff;           //10ms 重装
     
197.     TH0=0XDB;           //b7;   
     
198.     UpdateTimers();     //更新任务
     
199.     RunTask(task0,0);   //任务0具有精确按时获得执行的权限，要求：task0每次执行消耗时间<0.5个 ticket
     
200. }
     
201. 
     
202. //无阻塞延时 只能被主任务，以及主任务调用的函数，及主任务调用的函数调用的函数 使用
     
203. //TASK i 定义参数确保参数位数和调度器内定义的位数一样
     
204. void delayx(TASK i){
     
205.       DELAYX(i);        //普通函数无阻塞延时
     
206. }
     
207. 
     
208. //普通函数
     
209. void test1(){
     
210.      delayx(50);
     
211.      LED0=1;
     
212. 
     
213.      delayx(50);
     
214.      LED0=0;
     
215. 
     
216.      delayx(50);
     
217.      LED0=1;
     
218. 
     
219.      delayx(50);
     
220.      LED0=0;
     
221. }
     
222. 
     
223. //主任务 主任务函数名必须为 runTasks
     
224. void runTasks()
     
225. {
     
226. //        RunTask(task0,0);
     
227.     RunTaskA(task1,1);//任务1具有比任务2高的运行权限                  
     
228.     RunTaskA(task2,2);//任务2具有低的运行权限
     
229. }
     
230. 
     
231. //  主循环
     
232. void main()
     
233. {
     
234.     InitT0();
     
235.     InitTasks(); //初始化任务，实际上是给timers清零
     
236.    
     
237.         //主循环或主循环内的函数或主循环函数调用的子函数里，必须有一个无阻塞延时函数执行
     
238.     while(1){
     
239.     //  delayx(1);        //无阻塞延时1个任务时钟
     
240.         test1();        //调用了无阻塞延时函数的普通函数
     
241.     //        runTasks();        //没有普通函数调用无阻塞延时函数时，可以只调用主任务
     
242.     }
     
243. }
     
244. **************************************************************/
     
245. #endif

复制代码

2020-10-15
  1、整合SETJMP版.可通过定义SETJMP切换
     #define SETJMP 0            //版本选择:0=SWINCH版 1=SETJMP版

  2020-10-14
  1、增加LCBIT宏定义来设置_lc变量类型.
          #define LCBIT 0                        //选择_lc的变量类型: 0=8位;1=16位.
          PICC高版本编译器宏不支持__LINE__%255运算,LCBIT定义需设置为1。代价就是每个任务多占一个字节的RAM.
     其它编译器如果不报错，建议 LCBIT 设置为0,和原来一样.

小小调度器1.2.0问星整理版.rar (3.32 KB, 下载次数: 16)

2020-10-25 14:14 上传

点击文件名下载附件
小小调度器1.2.0问星整理版

好资料，51黑有你更精彩!!!

重要更新！！！
2020-11-04
  1、修复超时判断只能生效1次的BUG（群友"上善若水"发现）
     在WaitUtilT(A,TimeOut)、WAITUNTILT(A,VAL,TimeOut)、WaitUtilTR(A,TimeOut)、WAITUNTILTR(A,VAL,TimeOut)定义里增加”_count=TimeOut;“


小小调度器1.2.1问星整理版.rar (3.64 KB, 下载次数: 21)

2020-11-4 14:00 上传

点击文件名下载附件
小小调度器1.2.1问星整理版

赞赞赞

2020-11-06
    1、增加 #define WAITUTILTRTYPE 0         //WaitUtilTR 超时等待判断类型选择宏
        0=简单,WaitUtilTR(A,TimeOut,TINDEX) TINDEX:超时等待索引只能0-7,每个WaitUtilTR的索引不能重复，只支持8个实时性高的超时判断;
        1=灵活 自定义变量，WaitUtilTR(A,TimeOut,T1FLAY) T1FLAY:1个调度器时钟周期标志变量,需在调度器时钟周期定时器中断里将变量置1。
        简单调用示例：WaitUtilTR(f.b0,2,0);

2020-11-05
    1、修改“_count”赋初值的位置，使之理合理
    2、修改“WaitUtilTR(A,TimeOut)、WAITUNTILTR(A,VAL,TimeOut)”定义，解决实时性高的判断等待超时时间不准的问题
        增加“T1FLAY”一个调度器周期标志变量参数，变为“WaitUtilTR(A,TimeOut,T1FLAY)、WAITUNTILTR(A,VAL,TimeOut,T1FLAY)”
        使用方式请参考例子
小小调度器1.2.3问星整理版.rar (5.06 KB, 下载次数: 49)

2020-12-14 10:09 上传

点击文件名下载附件
小小调度器1.2.3问星整理版

谢谢楼主，这个不错。能看懂，期待更新。

编译后出现test.c(99): warning C294: unreachable code。这个怎么消除呢？

支持，下载详细学习一下

有简单的应用指导说明和具体应用的实例介绍吗？三个LED，三个任务，不能充分说明系统真正的实用价值。

赞个，后续还有更新吗？准备试试看

这个小小调度器现在更新到哪个版本了？？