再出个调度器，极小资源单片机值得一用

zhudeng66

好喜欢 好牛呀   我是一直潜水的会员  今天终于忍不住冒出来了 看到这么好的帖子 我再也忍不住了  我会继续跟踪  继续顶  顶  我努力的顶   

sfq2008

先收藏再学习

kebaojun305

mathison 发表于 2013-10-26 16:53
本人C开发新手
义隆的C编译器用起来真痛苦  
有用C做义隆单片机开发的朋友吗 请问你们用什么编译器 ...

用熟了就好了  俺当年用的第一版C编译器  那才叫痛苦（不过也搞定了），现在的改进了不少了。

hhucwyd

标记一下

o11o

先谢楼主分享

yebx

lz实在太强了，一定要mark

奮闘ing

感谢各位分享，学习了！！！回去试试在51单片机上做一下~

smset

更新一版，增加对timers清零的操作，本来全局变量应该初值就是0，但是我发现keil编译器有时不这么干。

1. 
   
2. 
   
3. #include <stc89c51.h>
   
4. /****小小调度器开始**********************************************/
   
5. #define MAXTASKS 3
   
6. volatile unsigned char timers[MAXTASKS];
   
7. #define _SS static unsigned char _lc; switch(_lc){default:
   
8. #define _EE ;}; _lc=0; return 255;
   
9. #define WaitX(tickets)  do {_lc=__LINE__+((__LINE__%256)==0); return tickets ;} while(0); case __LINE__+((__LINE__%256)==0):
   
10. 
    
11. #define RunTask(TaskName,TaskID) do { if (timers[TaskID]==0) timers[TaskID]=TaskName(); }  while(0);
    
12. #define RunTaskA(TaskName,TaskID) { if (timers[TaskID]==0) {timers[TaskID]=TaskName(); continue;} }   //前面的任务优先保证执行
    
13. 
    
14. #define CallSub(SubTaskName) do {unsigned char currdt; _lc=__LINE__+((__LINE__%256)==0); return 0; case __LINE__+((__LINE__%256)==0):  currdt=SubTaskName(); if(currdt!=255) return currdt;} while(0);
    
15. #define InitTasks() {unsigned char i; for(i=MAXTASKS;i>0 ;i--) timers[i]=0; }
    
16. #define UpdateTimers() {unsigned char i; for(i=MAXTASKS;i>0 ;i--){if((timers[i-1]!=0)&&(timers[i-1]!=255)) timers[i-1]--;}}
    
17. 
    
18. #define SEM unsigned int
    
19. //初始化信号量
    
20. #define InitSem(sem) sem=0;
    
21. //等待信号量
    
22. #define WaitSem(sem) do{ sem=1; WaitX(0); if (sem>0) return 1;} while(0);
    
23. //等待信号量或定时器溢出， 定时器tickets 最大为0xFFFE
    
24. #define WaitSemX(sem,tickets)  do { sem=tickets+1; WaitX(0); if(sem>1){ sem--;  return 1;} } while(0);
    
25. //发送信号量
    
26. #define SendSem(sem)  do {sem=0;} while(0);
    
27. 
    
28. /*****小小调度器结束*******************************************************/
    
29. 
    
30. 
    
31. sbit LED1 = P2^1;
    
32. sbit LED2 = P2^2;
    
33. 
    
34. sbit LED0 = P2^5;
    
35. 
    
36. unsigned char task0(){
    
37. _SS
    
38.   while(1){
    
39.    WaitX(50);
    
40.    LED0=!LED0;   
    
41.   }
    
42. _EE
    
43. }
    
44. 
    
45. unsigned char  task1(){
    
46. _SS
    
47.   while(1){
    
48.    WaitX(100);
    
49.    LED1=!LED1;   
    
50.   }
    
51. _EE
    
52. }
    
53. 
    
54. unsigned char  task2(){
    
55. _SS
    
56.   while(1){
    
57.    WaitX(100);
    
58.    LED2=!LED2;   
    
59.   }
    
60. _EE
    
61. }
    
62. 
    
63. void InitT0()
    
64. {
    
65.         TMOD = 0x21;
    
66.         IE |= 0x82;  // 12t
    
67.         TL0=0Xff;
    
68.         TH0=0XDB;
    
69.         TR0 = 1;
    
70. }
    
71. 
    
72. void INTT0(void) interrupt 1 using 1
    
73. {
    
74.     TL0=0Xff;    //10ms 重装
    
75.     TH0=0XDB;//b7;   
    
76. 
    
77.     UpdateTimers();
    
78. 
    
79.     RunTask(task0,0);//任务0具有精确按时获得执行的权限，要求：task0每次执行消耗时间<0.5个 ticket
    
80. }
    
81. 
    
82. 
    
83. 
    
84. 
    
85. void main()
    
86. {
    
87.         InitT0();
    
88.         InitTasks(); //初始化任务，实际上是给timers清零
    
89.         while(1){
    
90. //           RunTask(task0,0);
    
91.                 RunTaskA(task1,1);//任务1具有比任务2高的运行权限                  
    
92.            RunTaskA(task2,2);//任务2具有低的运行权限                  
    
93.       }
    
94. }
    

复制代码

smset

这样就保险了。

hxke

Gorgon_Meducer 发表于 2013-1-6 21:57
如果想节省资源，沿着你的路走下去就可以了，因为实际上目前的小小调度器就是裸机，巧妙的借用了宏来固化 ...

我有时也在纠结如何设计更加合理的任务。一个项目来了，应该如何分析、创建任务？有什么指导性思想或一般规律？使得划分的任务高内聚低耦合？
当程序跑起来了，回头看，总感觉任务划分不太合理，不满意。
希望傻孩子这方面指点下，然后有什么资料的可以学习？
谢谢

hxke

终于看完了，眼睛好累，呵呵

miller8708

收藏了，谢谢分享啊，有时间用下

Gorgon_Meducer

hxke 发表于 2013-11-1 16:48
我有时也在纠结如何设计更加合理的任务。一个项目来了，应该如何分析、创建任务？有什么指导性思想或一般 ...

当你已经掌握了划分任务的方法，那么剩下的就是要寻找划分任务的指导性原则。如果你已经能理解到面向对象只是一个
思想，并且已经能够在大部分非面向对象语言中实践，那么建议你看看设计模式的书，比如设计模式之禅——也许一时看
不懂，但时间长就OK了。我不知道技法类书是不是对你仍然有帮助，但我想说，技法类书始终是关于工具的，工具始终
是为思想服务的，所以，如果你已经掌握了一些技法，我建议你多花功夫在编程思想类的书籍上，不要再执着于技法，比如
怎么写调度器更好啊，状态机和操作系统哪个更好啊，浪费时间，那都是浮云，关键是思想。

我不清楚你的具体情况，但有几个基本思想要逐一掌握：
1、链表的思想（或者说技法）
2、数据结构的基本内容
3、操作系统中多任务通信的思想和技法（非常重要），操作系统本身不重要，怎么调度也不重要，关键是所有操作系统都
    共通的基本思想部分，多任务间如何通信的部分。
4、事件驱动的思想——就是任务与任务之间是通过事件来触发的。你可以理解为多米诺骨牌。多米诺骨牌可以认为有很多
    模块组成，但模块与模块之间，往往是触发关系，只要触发了，直到这个模块完成，都不再受外界影响。我希望这个形象
    的比喻能给你关于事件驱动的映像。你在简历任务的时候，如果能把任务与任务之间是如何彼此触发的关系整理成脉络
   基本上任务划分的方式就清晰了。动手做一做就知道，其实不难。
5、黑盒子思想（面向接口开发）
6、设计模式

smset

与715楼同理，静态变量初值也应该是0，不过为了防止某些编译器不按标准来执行，所以也把_lc静态变量显式的赋一个初值。

1. 
   
2. 
   
3. #include <stc89c51.h>
   
4. /****小小调度器开始**********************************************/
   
5. #define MAXTASKS 3
   
6. volatile unsigned char timers[MAXTASKS];
   
7. #define _SS static unsigned char _lc=0; switch(_lc){default:
   
8. #define _EE ;}; _lc=0; return 255;
   
9. #define WaitX(tickets)  do {_lc=__LINE__+((__LINE__%256)==0); return tickets ;} while(0); case __LINE__+((__LINE__%256)==0):
   
10. 
    
11. #define RunTask(TaskName,TaskID) do { if (timers[TaskID]==0) timers[TaskID]=TaskName(); }  while(0);
    
12. #define RunTaskA(TaskName,TaskID) { if (timers[TaskID]==0) {timers[TaskID]=TaskName(); continue;} }   //前面的任务优先保证执行
    
13. 
    
14. #define CallSub(SubTaskName) do {unsigned char currdt; _lc=__LINE__+((__LINE__%256)==0); return 0; case __LINE__+((__LINE__%256)==0):  currdt=SubTaskName(); if(currdt!=255) return currdt;} while(0);
    
15. #define InitTasks() {unsigned char i; for(i=MAXTASKS;i>0 ;i--) timers[i]=0; }
    
16. #define UpdateTimers() {unsigned char i; for(i=MAXTASKS;i>0 ;i--){if((timers[i-1]!=0)&&(timers[i-1]!=255)) timers[i-1]--;}}
    
17. 
    
18. #define SEM unsigned int
    
19. //初始化信号量
    
20. #define InitSem(sem) sem=0;
    
21. //等待信号量
    
22. #define WaitSem(sem) do{ sem=1; WaitX(0); if (sem>0) return 1;} while(0);
    
23. //等待信号量或定时器溢出， 定时器tickets 最大为0xFFFE
    
24. #define WaitSemX(sem,tickets)  do { sem=tickets+1; WaitX(0); if(sem>1){ sem--;  return 1;} } while(0);
    
25. //发送信号量
    
26. #define SendSem(sem)  do {sem=0;} while(0);
    
27. 
    
28. /*****小小调度器结束*******************************************************/
    
29. 
    
30. 
    
31. sbit LED1 = P2^1;
    
32. sbit LED2 = P2^2;
    
33. 
    
34. sbit LED0 = P2^5;
    
35. 
    
36. unsigned char task0(){
    
37. _SS
    
38.   while(1){
    
39.    WaitX(50);
    
40.    LED0=!LED0;   
    
41.   }
    
42. _EE
    
43. }
    
44. 
    
45. unsigned char  task1(){
    
46. _SS
    
47.   while(1){
    
48.    WaitX(100);
    
49.    LED1=!LED1;   
    
50.   }
    
51. _EE
    
52. }
    
53. 
    
54. unsigned char  task2(){
    
55. _SS
    
56.   while(1){
    
57.    WaitX(100);
    
58.    LED2=!LED2;   
    
59.   }
    
60. _EE
    
61. }
    
62. 
    
63. void InitT0()
    
64. {
    
65.         TMOD = 0x21;
    
66.         IE |= 0x82;  // 12t
    
67.         TL0=0Xff;
    
68.         TH0=0XDB;
    
69.         TR0 = 1;
    
70. }
    
71. 
    
72. void INTT0(void) interrupt 1 using 1
    
73. {
    
74.     TL0=0Xff;    //10ms 重装
    
75.     TH0=0XDB;//b7;   
    
76. 
    
77.     UpdateTimers();
    
78. 
    
79.     RunTask(task0,0);//任务0具有精确按时获得执行的权限，要求：task0每次执行消耗时间<0.5个 ticket
    
80. }
    
81. 
    
82. 
    
83. 
    
84. 
    
85. void main()
    
86. {
    
87.         InitT0();
    
88.         InitTasks(); //初始化任务，实际上是给timers清零
    
89.         while(1){
    
90. //           RunTask(task0,0);
    
91.                 RunTaskA(task1,1);//任务1具有比任务2高的运行权限                  
    
92.            RunTaskA(task2,2);//任务2具有低的运行权限                  
    
93.       }
    
94. }
    

复制代码

cheungman

爬了700多楼, 受益匪浅, 感谢楼主和各位网友的思想.

liuqian

smset 发表于 2013-11-4 10:56
与715楼同理，静态变量初值也应该是0，不过为了防止某些编译器不按标准来执行，所以也把_lc静态变量显式的 ...

在freescale的S08上用，这种写法被CW优化掉了
unsigned char  task2(){
_SS
  while(1){                    //information:C4000 Condition always TRUE
   WaitX(100);                        //information:C4001 Condition always FALSE
   LED2=!LED2;   
  }
_EE                            //warning:C5660 Removed dead code
}

liuqian

condition always false的警告是do{}while(0)造成的，不影响。
现在只运行了一个闪灯的任务，removed dead code也正常

tiger5

yanghq

学习，参考，收藏！

zhudeng66

受益匪浅  真的很经典  超级喜欢  我之前写过 in_timeOS操作系统 也是基于极苛刻资源的单片机 但是现在看来  还是这个比较实用

haohan007

#define InitTasks() {unsigned char i; for(i=MAXTASKS;i>0 ;i--) timers[i]=0; }
楼主老大这样我怎么运行不正常。
#define InitTasks() {unsigned char i; for(i=0;i<MAXTASKS ;i++) timers[i]=0; }
改成这样就可以正常运行了。。

waking

一个字  绝！！！

haizaolan

真牛啊！

loliweive

不明觉厉，mark了慢慢研究。

deadline2012

小小调度器，博大精深啊！！！

fiddly

顶顶，好好消化下！

yoofe

慢慢看看

奮闘ing

这个得认真看看，谢谢分享！

yjbin

能不能给个信号量的例子啊？多谢了

yayagepei

太好了，谢谢楼主

xljh

收藏学习。

zhouzmt

不错，收藏了

flylokj

好帖子，收藏了

liuzhen526

mark 小小调度器  
116 209 257 330 397 492 540 楼，楼主建议用492版

ypengfei

不明觉历啊。

smset

小小调度器至2012年发布以来，受到了一些坛友们的关注和支持，在此表示感谢！！！

新的一年来了，总要做点新的事情。 在小小调度器这一块，要做些什么呢？

我有一个想法： 将小小调度器和面向对象设计思想结合起来，形成一个新的单片机编程框架。


小小调度器虽然是针对极小资源单片机设计的，但事实上并不是真的只能用于很简单的小产品上，

举例来说，我公司的产品功能实际是比较复杂的，一个CPU要实现完整的tcpip协议栈+基于SD卡的文件系统+mp3解码播放+也有液晶和按键+图形化人机界面+串口+Modbus等等。

也一样采用了小小调度器的任务调度框架，小小调度器也能从容应对这类项目，任务调度的稳定性表现优异，这块一直让我们很放心。

而另一方面，复杂系统的软件代码，客观地说，最好是能结合面向对象OOPC的思想，这几十年面向对象的编程方法在软件领域全面开花不是没有道理的。

哪怕是嵌入式单片机软件代码，只要复杂到一定程度，就可以考虑采用面向对象的编程思想。随着单片机处理能力的普遍增强，我觉得总体来说，以后单片机编程的思想迟早会涉及到面向对象的。

因此我计划基于小小调度器，打造一个基于任务对象的调度系统。

进而，再升华成一种面向任务的嵌入式系统编程方法，这会更加针对嵌入式系统软件开发，，这也算是我自身的一个提升吧。



我认为各种编程方法以及设计模式等等，一个是各有其最佳的应用领域，另一个方面就是都是为了降低开发人员的思考和理解难度。

我觉得针对单片机的开发，面向任务应该是一个比较容易理解的方法，

实际上，我们已经非常习惯于将单片机软件的各个处理部分称为“任务”，比如键盘任务，液晶显示任务，串口任务 ，。。。等等。 而不是称之为键盘状态函数，液晶显示状态函数，串口状态函数。。。。。。

这说明， 我们在直观上已经把任务理解为一个单片机软件系统的基本功能单元，“任务”,Task, 它所蕴含的东西比数据更动态，比状态更完整，也确实更加能精准地表达我们想要的处理过程。



这里举个实例，结合oopc的思想，将小小调度器的任务抽象为一个Task类，然后键盘或串口任务都基于是继承Task类的子类，以上代码在CBuilder验证过：

先贴出Demo代码，结合了lw_oopc:

1. 
   
2. 
   
3. #ifndef TASK_H_INCLUDED_
   
4. #define TASK_H_INCLUDED_
   
5. 
   
6. #include "lw_oopc.h"
   
7. #include "xxddq.h"
   
8. 
   
9. ABS_CLASS(Task)
   
10. {
    
11.     unsigned char _lc;
    
12.     unsigned char _timer;
    
13.     unsigned char _index;
    
14.    
    
15.     void (*init)(Task* t,unsigned char index); // 初始化
    
16.     unsigned char  (*execute)(Task* t);
    
17. 
    
18. };
    
19. 
    
20. CLASS(KeyTask)
    
21. {
    
22.     EXTENDS(Task);        // 继承Task抽象类
    
23.     void (*init)(KeyTask* t,unsigned char index); // 初始化   
    
24.     unsigned char  (*execute)(KeyTask* t,unsigned char _index);
    
25. };
    
26. 
    
27. CLASS(UartTask)
    
28. {
    
29.     EXTENDS(Task);        // 继承Task抽象类
    
30.     unsigned char uartid;
    
31.     void (*setuart)(UartTask* t,unsigned char uartindex); // 初始化   
    
32.     void (*init)(UartTask* t,unsigned char index); // 初始化
    
33.     unsigned char  (*execute)(UartTask* t,unsigned char _index);
    
34. };
    
35. 
    
36. #endif
    
37. 
    
38. #include "stdio.h"
    
39. #include "string.h"
    
40. #include "task.h"
    
41. /* 初始化任务 */
    
42. 
    
43. void Task_init(Task* t,unsigned char index)
    
44. {
    
45.     t->_index=index;
    
46.     t->_lc=0;
    
47.     t->_timer=0;
    
48. }
    
49. 
    
50. /* 任务执行 */
    
51. unsigned char  Task_execute(Task* t)
    
52. {
    
53. }
    
54. 
    
55. ABS_CTOR(Task)
    
56. FUNCTION_SETTING(init, Task_init);
    
57. FUNCTION_SETTING(execute, Task_execute);
    
58. END_ABS_CTOR
    
59. 
    
60. /* 键盘任务 */
    
61. void KeyTask_init(KeyTask* t,unsigned char index)
    
62. {
    
63.    t->Task.init(t,index);
    
64. }
    
65. 
    
66. unsigned char  KeyTask_execute(KeyTask* t)
    
67. {
    
68. _SS
    
69.   while(1){
    
70.     printf("I am KeyTask！\n");
    
71.     WaitX(100);
    
72.   }
    
73. _EE
    
74. }
    
75. 
    
76. 
    
77. CTOR(KeyTask)
    
78. SUPER_CTOR(Task);
    
79. FUNCTION_SETTING(init, KeyTask_init);
    
80. FUNCTION_SETTING(Task.execute, KeyTask_execute);
    
81. END_CTOR
    
82. 
    
83. 
    
84. /* Uart任务 */
    
85. void UartTask_init(UartTask* t,unsigned char index)
    
86. {
    
87.    t->Task.init(t,index);
    
88. }
    
89. void UartTask_setuart(UartTask* t,unsigned char uartindex)
    
90. {
    
91.    t->uartid=uartindex;
    
92. }
    
93. unsigned char  UartTask_execute(UartTask* t)
    
94. {
    
95. _SS
    
96.   while(1){
    
97.     printf("I am UartTask %d！\n",t->uartid);
    
98.     WaitX(200);
    
99.   }
    
100. _EE
     
101. }
     
102. 
     
103. CTOR(UartTask)
     
104. SUPER_CTOR(Task);
     
105. FUNCTION_SETTING(init, UartTask_init);
     
106. FUNCTION_SETTING(setuart, UartTask_setuart);
     
107. FUNCTION_SETTING(Task.execute, UartTask_execute);
     
108. END_CTOR
     

复制代码

smset

main.c

1. 
   
2. #include <windows.h>
   
3. #include "task.h"
   
4. #include <sys/timeb.h>
   
5. #include <time.h>
   
6. 
   
7. int lasttime;
   
8. 
   
9. 
   
10. int main()
    
11. {
    
12. 
    
13.     char timeline[20];
    
14. 
    
15.     int i ;
    
16. 
    
17. 
    
18.     KeyTask* keytask = KeyTask_new();    // 创建键盘任务对象
    
19.     UartTask* uart0task = UartTask_new();       // 创建串口0任务对象
    
20.     UartTask* uart1task = UartTask_new();       // 创建串口1任务对象
    
21.     Task* tasklist[3] = { 0 };     // 初始化任务容器（这里是Task指针数组)
    
22. 
    
23.     keytask->init(keytask,0);
    
24.     uart0task->init(uart0task,1);
    
25.     uart1task->init(uart1task,2);
    
26. 
    
27.     tasklist[0] = SUPER_PTR(keytask, Task);
    
28.     tasklist[1] = SUPER_PTR(uart0task, Task);
    
29.     tasklist[2] = SUPER_PTR(uart1task, Task);
    
30. 
    
31.     uart0task->setuart(uart0task,0);
    
32.     uart1task->setuart(uart1task,1);
    
33.         
    
34.     // 循环执行任务容器内的任务
    
35. 
    
36.     lasttime=0;
    
37.    
    
38.     while(1)
    
39.     {
    
40.      //以后移到中断里面执行
    
41.      if (timeGetTime()!=lasttime) {
    
42.         lasttime=timeGetTime();
    
43.         UpdateTimers();
    
44.      }
    
45. 
    
46.      RunTasks();
    
47.      
    
48.     }
    
49.    
    
50.     DeleteTasks();
    
51. 
    
52.     printf("\r\n End!");   
    
53. 
    
54.     getchar();
    
55.     return 0;
    
56. }
    

复制代码

eva015401

好东西收下了

zsdshuai

真的很不错

yanyi103

不错，标记备用

spark51

“_lc=__LINE__+((__LINE__%256)==0); return tickets ;} while(0); case __LINE__+((__LINE__%256)==0”

这里_lc是uint8类型的， 如__LINE__等于1000，_lc 会截断，但后面会是case 1000

此时如何？

smset

会正常运行

banyai

标记一下。

滴答滴答下雨啦

马克，以后学习吧……

xiaolaoyu

看过了，学习一下。

spark51

smset 发表于 2014-2-11 18:52
会正常运行

不能正常运行了吧，_lc 被截断了，并不等于_LINE_ +(_LINE %256)了，无法正常跳到这个case了吧，下次运行时会从default运行吧

smset

spark51 发表于 2014-2-12 10:35
不能正常运行了吧，_lc 被截断了，并不等于_LINE_ +(_LINE %256)了，无法正常跳到这个case了吧，下次运行 ...

你实际试试就知道了，编译器并不完全是你想象的那样。

unsigned char i,j;

i=1;
j=0;

switch(i){

case 0:
  j=0;
  break;

  case 257:
   j=1;
  break;

  case 2:
   j=2;
  break;

}


你可以去找个C编译环境，运行这个代码，你会发现结果j是等于1的。

weiwei4

好像不错，学习学习

夜里的雪

真心不错尼   谢谢楼主

spark51

smset 发表于 2014-2-12 11:01
你实际试试就知道了，编译器并不完全是你想象的那样。

unsigned char i,j;

IAR 6.21测试，内核为Cortex-M3，运行过Switch后，J = 0。

注：看汇编代码是把case 257给优化掉了.(关键此时优化Level已经是none了)

smset

spark51 发表于 2014-2-12 14:22
IAR 6.21测试，内核为Cortex-M3，运行过Switch后，J = 0。

注：看汇编代码是把case 257给优化掉了.(关键 ...

谢谢你，我做过测试了，你说的情况确存在。

以前我用iar是在high speed优化下，没有这个问题。 但是如果不在high优化的情况下，的确会出现你说的问题。

另外，可能各个编译器确实处理方式不同，在CBuilder编译环境下，无论是没有优化，还是有优化，均不会出现这个问题。

总的来说，这的确是一个隐藏的Bug.  

再次感谢你指出这个问题!

改正的版本已经做好了，发布在下一楼。

smset

1. 
   
2. 
   
3. 
   
4. #include <stc89c51.h>
   
5. /****小小调度器开始**********************************************/
   
6. #define MAXTASKS 3
   
7. volatile unsigned char timers[MAXTASKS];
   
8. #define _SS static unsigned char _lc=0; switch(_lc){default:
   
9. #define _EE ;}; _lc=0; return 255;
   
10. #define WaitX(tickets)  do {_lc=(__LINE__+((__LINE__%256)==0))%256; return tickets ;} while(0); case (__LINE__+((__LINE__%256)==0))%256:
    
11. 
    
12. #define RunTask(TaskName,TaskID) do { if (timers[TaskID]==0) timers[TaskID]=TaskName(); }  while(0);
    
13. #define RunTaskA(TaskName,TaskID) { if (timers[TaskID]==0) {timers[TaskID]=TaskName(); continue;} }   //前面的任务优先保证执行
    
14. 
    
15. #define CallSub(SubTaskName) do {unsigned char currdt; _lc=(__LINE__+((__LINE__%256)==0))%256; return 0; case (__LINE__+((__LINE__%256)==0))%256:  currdt=SubTaskName(); if(currdt!=255) return currdt;} while(0);
    
16. #define InitTasks() {unsigned char i; for(i=MAXTASKS;i>0 ;i--) timers[i]=0; }
    
17. #define UpdateTimers() {unsigned char i; for(i=MAXTASKS;i>0 ;i--){if((timers[i-1]!=0)&&(timers[i-1]!=255)) timers[i-1]--;}}
    
18. 
    
19. #define SEM unsigned int
    
20. //初始化信号量
    
21. #define InitSem(sem) sem=0;
    
22. //等待信号量
    
23. #define WaitSem(sem) do{ sem=1; WaitX(0); if (sem>0) return 1;} while(0);
    
24. //等待信号量或定时器溢出， 定时器tickets 最大为0xFFFE
    
25. #define WaitSemX(sem,tickets)  do { sem=tickets+1; WaitX(0); if(sem>1){ sem--;  return 1;} } while(0);
    
26. //发送信号量
    
27. #define SendSem(sem)  do {sem=0;} while(0);
    
28. 
    
29. /*****小小调度器结束*******************************************************/
    
30. 
    
31. 
    
32. sbit LED1 = P2^1;
    
33. sbit LED2 = P2^2;
    
34. 
    
35. sbit LED0 = P2^5;
    
36. 
    
37. unsigned char task0(){
    
38. _SS
    
39.   while(1){
    
40.    WaitX(50);
    
41.    LED0=!LED0;   
    
42.   }
    
43. _EE
    
44. }
    
45. 
    
46. unsigned char  task1(){
    
47. _SS
    
48.   while(1){
    
49.    WaitX(100);
    
50.    LED1=!LED1;   
    
51.   }
    
52. _EE
    
53. }
    
54. 
    
55. unsigned char  task2(){
    
56. _SS
    
57.   while(1){
    
58.    WaitX(100);
    
59.    LED2=!LED2;   
    
60.   }
    
61. _EE
    
62. }
    
63. 
    
64. void InitT0()
    
65. {
    
66.         TMOD = 0x21;
    
67.         IE |= 0x82;  // 12t
    
68.         TL0=0Xff;
    
69.         TH0=0XDB;
    
70.         TR0 = 1;
    
71. }
    
72. 
    
73. void INTT0(void) interrupt 1 using 1
    
74. {
    
75.     TL0=0Xff;    //10ms 重装
    
76.     TH0=0XDB;//b7;   
    
77. 
    
78.     UpdateTimers();
    
79. 
    
80.     RunTask(task0,0);//任务0具有精确按时获得执行的权限，要求：task0每次执行消耗时间<0.5个 ticket
    
81. }
    
82. 
    
83. 
    
84. 
    
85. 
    
86. void main()
    
87. {
    
88.         InitT0();
    
89.         InitTasks(); //初始化任务，实际上是给timers清零
    
90.         while(1){
    
91. //           RunTask(task0,0);
    
92.                 RunTaskA(task1,1);//任务1具有比任务2高的运行权限                  
    
93.            RunTaskA(task2,2);//任务2具有低的运行权限                  
    
94.       }
    
95. }
    

复制代码

sky@215574023

楼主发帖啊

caoxuerji

先留下个记号

chjf

不错，学习中。。。。。。。。

Zigbee2012

任务调度器   有点类似时间片

ackk

下班回家试试效果，没玩过

spark51

smset 发表于 2014-2-12 16:08

_lc的类型是不是增加一个宏定义比较好，在8位机上用uint8,在32位机上用uint32

smset

spark51 发表于 2014-2-13 09:19
_lc的类型是不是增加一个宏定义比较好，在8位机上用uint8,在32位机上用uint32 ...

把_lc定义为uint8,或uint16都可以。 用uint32的话，就有点不必了。

toptrying

谢谢，学习中。。。。

zwc58

好东西,学习了.

klander

smset 发表于 2014-2-12 11:01
你实际试试就知道了，编译器并不完全是你想象的那样。

你好,我用HT-IDE3000,运行结果 j=0;

radar_12345

多谢lz分享！

奮闘ing

值得学习，值得深入研究！

zend

先收藏再学习

狂奔的蜗牛Y

smset 发表于 2014-2-12 16:08

#define WaitX(tickets)  do {_lc=(__LINE__+((__LINE__%256)==0))%256; return tickets ;} while(0); case (__LINE__+((__LINE__%256)==0))%256:

这句没看懂
1. return tickets ;//执行了这句 ，后面这个case (__LINE__+((__LINE__%256)==0))%256:还会执行吗？
2.(__LINE__+((__LINE__%256)==0))%256; //这个语句中，当__LINE__为0或1 时，是不是_lc的值是一样的；

w625419875

标记下，回头好好看看。。。

nuncle

mark 试试

nuncle

mark 试试

xd785

好了，等会看看

foxpro2005

今天才发现，比原来收藏的时候少了很多楼层...

兄弟会十戒之首

看起来是蛮简单，道理通顺，应该蛮有效。有空试试

chinaboy25

MAKE  ,我以前的定时器是这个写法，调度用了信号，比这复杂些，

兄弟会十戒之首

观摩完毕，还有些疑问。已经保存为图片，谢谢楼主

usartcodeed

学习学习

foxpro2005

smset 发表于 2014-2-12 16:08

发现一处小bug: InitTasks() 的timers初始化过程

1. #define InitTasks() {unsigned char i; for(i=MAXTASKS;i>0 ;i--) timers[i]=0; }

复制代码

应改为：

1. #define InitTasks() {unsigned char i=MAXTASKS; while(i) timers[--i]=0;}

复制代码

或

1. #define InitTasks() {unsigned char i=MAXTASKS; for(;i;) timers[--i]=0;}

复制代码

smset

foxpro2005 发表于 2014-2-25 19:57
发现一处小bug: InitTasks() 的timers初始化过程

是的，谢谢。

zhangmao710

先收藏再学习

机器人天空

mark.........

jiwx2011

好好学一下

fengdingkusong

学习下      

lyflyaway

感谢分享

zjsdlt2013

学习一下，再顶一个。

木君之上

玩的太极限了，有空我移植到AT89上面跑一下试试

hephi

MARK一下

smset

1. 
   
2. #include <stc89c51.h>
   
3. /****小小调度器开始**********************************************/
   
4. #define MAXTASKS 3
   
5. volatile unsigned char timers[MAXTASKS];
   
6. #define _SS static unsigned char _lc=0; switch(_lc){default:
   
7. #define _EE ;}; _lc=0; return 255;
   
8. #define WaitX(tickets)  do {_lc=(__LINE__+((__LINE__%256)==0))%256; return tickets ;} while(0); case (__LINE__+((__LINE__%256)==0))%256:
   
9. 
   
10. #define RunTask(TaskName,TaskID) do { if (timers[TaskID]==0) timers[TaskID]=TaskName(); }  while(0);
    
11. #define RunTaskA(TaskName,TaskID) { if (timers[TaskID]==0) {timers[TaskID]=TaskName(); continue;} }   //前面的任务优先保证执行
    
12. 
    
13. #define CallSub(SubTaskName) do {unsigned char currdt; _lc=(__LINE__+((__LINE__%256)==0))%256; return 0; case (__LINE__+((__LINE__%256)==0))%256:  currdt=SubTaskName(); if(currdt!=255) return currdt;} while(0);
    
14. #define InitTasks() {unsigned char i; for(i=MAXTASKS;i>0 ;i--) timers[i-1]=0; }
    
15. #define UpdateTimers() {unsigned char i; for(i=MAXTASKS;i>0 ;i--){if((timers[i-1]!=0)&&(timers[i-1]!=255)) timers[i-1]--;}}
    
16. 
    
17. #define SEM unsigned int
    
18. //初始化信号量
    
19. #define InitSem(sem) sem=0;
    
20. //等待信号量
    
21. #define WaitSem(sem) do{ sem=1; WaitX(0); if (sem>0) return 1;} while(0);
    
22. //等待信号量或定时器溢出， 定时器tickets 最大为0xFFFE
    
23. #define WaitSemX(sem,tickets)  do { sem=tickets+1; WaitX(0); if(sem>1){ sem--;  return 1;} } while(0);
    
24. //发送信号量
    
25. #define SendSem(sem)  do {sem=0;} while(0);
    
26. 
    
27. /*****小小调度器结束*******************************************************/
    
28. 
    
29. 
    
30. sbit LED1 = P2^1;
    
31. sbit LED2 = P2^2;
    
32. 
    
33. sbit LED0 = P2^5;
    
34. 
    
35. unsigned char task0(){
    
36. _SS
    
37.   while(1){
    
38.    WaitX(50);
    
39.    LED0=!LED0;   
    
40.   }
    
41. _EE
    
42. }
    
43. 
    
44. unsigned char  task1(){
    
45. _SS
    
46.   while(1){
    
47.    WaitX(100);
    
48.    LED1=!LED1;   
    
49.   }
    
50. _EE
    
51. }
    
52. 
    
53. unsigned char  task2(){
    
54. _SS
    
55.   while(1){
    
56.    WaitX(100);
    
57.    LED2=!LED2;   
    
58.   }
    
59. _EE
    
60. }
    
61. 
    
62. void InitT0()
    
63. {
    
64.         TMOD = 0x21;
    
65.         IE |= 0x82;  // 12t
    
66.         TL0=0Xff;
    
67.         TH0=0XDB;
    
68.         TR0 = 1;
    
69. }
    
70. 
    
71. void INTT0(void) interrupt 1 using 1
    
72. {
    
73.     TL0=0Xff;    //10ms 重装
    
74.     TH0=0XDB;//b7;   
    
75. 
    
76.     UpdateTimers();
    
77. 
    
78.     RunTask(task0,0);//任务0具有精确按时获得执行的权限，要求：task0每次执行消耗时间<0.5个 ticket
    
79. }
    
80. 
    
81. 
    
82. 
    
83. 
    
84. void main()
    
85. {
    
86.         InitT0();
    
87.         InitTasks(); //初始化任务，实际上是给timers清零
    
88.         while(1){
    
89. //           RunTask(task0,0);
    
90.                 RunTaskA(task1,1);//任务1具有比任务2高的运行权限                  
    
91.            RunTaskA(task2,2);//任务2具有低的运行权限                  
    
92.       }
    
93. }
    

复制代码

蓝蓝的恋

最新版的编译是不是有警告呀？unreachable code貌似作为小白不好解决

smset

蓝蓝的恋 发表于 2014-3-28 13:31
最新版的编译是不是有警告呀？unreachable code貌似作为小白不好解决

当任务内部，是一个无限次循环时（ 如while(1) ），就会出现unreachable code告警，

这个实际上没有副作用，不用管它。

qingzhong

学习一下

lydmom

mark

15813191501

正在学习程序架构

1170390

学习了，谢谢分享

dtdzlujian

非常好！学习一下。

蓝蓝的恋

smset 发表于 2014-3-31 10:02
当任务内部，是一个无限次循环时（ 如while(1) ），就会出现unreachable code告警，

这个实际上没有副作 ...

哦，略懂了，谢谢~

walle531

我想知道当任务挂起后，下次重新恢复任务的时候怎么搞才能从新开始运行任务，而不是从上次退出的地方继续运行

ouyj_0210

mark一个，慢慢看

蓝蓝的恋

能再问个问题吗？为什么这个伪线程好像每一个里面都得有WaitX延时才能所有的都被执行呀，不解中！

smset

蓝蓝的恋 发表于 2014-4-8 13:22
能再问个问题吗？为什么这个伪线程好像每一个里面都得有WaitX延时才能所有的都被执行呀，不解中！  ...

是啊，在任务函数里面就是要通过WaitX才释放cpu资源。

这也是非抢占式任务调度的特点。

yezi2030

已经成功移植到合泰的MCU上。芯片选用HT45F23A，上传HT-IDE3000 7.82的工程文件。HT45F23A.h一定要选用我上传文件里面带的，原版头文件没有按位定义输出端口

ZYBing

谢谢分享！