这样写按键控制数码管动态显示，能不能称作“任务调度”

renwocai

之前把数码管和按键都放在中断里面处理，是这样写的：http://www.amobbs.com/thread-5501382-1-1.html，因为PROTERU的原因，我一度怀疑程序在哪里出了错误呢 ，现在我把数码管刷新和按键处理都放在主程序里面，在中断里面设置标志位，主程序中判断以后选择性的执行这两个函数，想请教下达人，这是不是就是所谓的“任务调度”？如果是，那么这种方式比较好处理，因为程序执行的间隔时间都是固定的，但对于有些交互式外设，如AD,DA,LCD,必须从对方读取数据，时间间隔是离散的，应该怎样安排任务？ 以上请教！

附本次程序和仿真图（仿真是看不到效果的，但通过硬件测试）

1. #include <reg51.h>
   
2. #define uchar unsigned char
   
3. uchar code tab[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};
   
4. uchar shu=85,count;
   
5. bit flag;
   
6. sbit kb=P3^4;
   
7. 
   
8. 
   
9. 
   
10. void sumaguan()
    
11. {
    
12.         static uchar i=0;
    
13.         i++;
    
14.         P0=0XFF;
    
15.         P2=~(1<<(i-1));
    
16.         if(i<3)
    
17.                 P0=0XC0;
    
18.         else if(i==3)
    
19.                 P0=tab[shu/10];
    
20.         else if(i==4)
    
21.                 {
    
22.                         P0=tab[shu%10];
    
23.                         i=0;
    
24.                 }
    
25. }
    
26. void anjianchuli()
    
27. {
    
28.         static uchar zhuangtai=0;
    
29.         switch(zhuangtai)
    
30.                 {
    
31.                         case 0:
    
32.                                 {
    
33.                                         if(kb==0)
    
34.                                                 zhuangtai++;
    
35.                                 };break;
    
36.                         case 1:
    
37.                                 {
    
38.                                         if(kb==0)
    
39.                                                 zhuangtai++;
    
40.                                         else
    
41.                                                 zhuangtai--;
    
42. 
    
43.                                 };break;
    
44.                         case 2:
    
45.                                 {
    
46.                                         if(kb==0)
    
47.                                                 {
    
48.                                                         zhuangtai++;
    
49.                                                         shu++;
    
50.                                                         if(shu==100)
    
51.                                                                 shu=0;
    
52.                                                 }
    
53.                                         else
    
54.                                                         zhuangtai--;
    
55.                                 };break;
    
56.                         case 3:
    
57.                                 {
    
58.                                         if(kb==1)
    
59.                                                 zhuangtai=0;
    
60.                                 };break;
    
61.                 }
    
62.         }
    
63. 
    
64. 
    
65. 
    
66. main()
    
67. {
    
68.         TMOD = 0x01;
    
69.     TH0 = 0x0E8;
    
70.     TL0 = 0x90;
    
71.     EA = 1;
    
72.     ET0 = 1;
    
73.     TR0 = 1;
    
74.         while(1)
    
75.         {
    
76.                 if(flag==1)
    
77.                 {
    
78.                         flag=0;
    
79.                         sumaguan();
    
80.                 }
    
81.                 if(count>=3)
    
82.                 {
    
83.                         anjianchuli();
    
84.                         count=0;
    
85.                 }
    
86.         }
    
87.        
    
88. }
    
89. void timer0() interrupt 1
    
90. {
    
91.         flag=1;
    
92.         count++;
    
93.     TH0 = 0x0E8;
    
94.     TL0 = 0x90;
    
95. }
    

复制代码

renwocai

顶下，今天星期一，都在上班忙吗，没人回复哦

channe

这个不能算作是任务调度，只是把中断程序中的内容拿出来，放在主函数中执行了。
可以想象一种极端情况，比如刷LCD的程序出错堵死了，那么另外的程序也不能执行了。
而真正的任务调度，是由一个主时钟驱动，每隔一定周期切换一次任务，假如某个线程堵死了，其他的还能执行到。

renwocai

channe 发表于 2012-10-15 16:00
这个不能算作是任务调度，只是把中断程序中的内容拿出来，放在主函数中执行了。
可以想象一种极端情况，比 ...

的确如你所说，我在主楼就说过间隔时间离散的不能这么处理，但还想不到什么好的办法。如果举段代码示教，谢谢。

channe

代码不好写，思路是这样。
结构体
{
任务指针   //（就是程序的指针，例如你的sumaguan）
寄存器状态  //( 保存运行状态 )
任务状态 //(可以放置 请求 睡眠 等等)
} Task[n];
然后你需要一个系统滴答时钟，比如1ms的中断，最高优先级。
然后每一毫秒到了，检查 任务状态 ，如果需要调用 ，那么调用这个函数   *（任务指针）（）；   //调用之前把上一个正在执行的任务的寄存器保存下载，把要执行的任务的寄存器恢复。

renwocai

好的，谢谢，我领会一下。

renwocai

channe 发表于 2012-10-15 16:53
代码不好写，思路是这样。
结构体
{

这个思想我想应该能理解了，这是防止有些程序的执行时间大于定时器的时间间隔，那么只要到时间了，不管原有函数有没有执行完毕，都先放下，等到下一次时间周期到了后接着执行。是这样吧。


但我还是写不了，因为这个结构体里面的寄存器状态和任务状态不知道写什么。能否就我主楼的函数改写一下，万分感谢。

难点在于要强制改变中断的执行方式，因为一般是从哪里中断再回到哪里，而作为任务调度是中断后保护断点，再执行下一函数。

另外，想请教下这么安排程序的好处和不足一般在什么地方，操作系统的思想是不是就是这样的？

channe

renwocai 发表于 2012-10-15 17:22
这个思想我想应该能理解了，这是防止有些程序的执行时间大于定时器的时间间隔，那么只要到时间了，不管原 ...

是可以防止有些程序的执行时间大于定时器的时间间隔，但主要不是为了这个。
反而每个任务都应该做成一个死循环。
然后系统的滴答时钟取多少比较好我也不知道，但不是为了防止超时那种，而应该是第一个任务执行一步，第二个任务执行一步，第一个任务，第二个任务。这样子。

channe

参见这个文章 http://www.amobbs.com/forum.php? ... C%E7%B3%BB%E7%BB%9F

zhanan

时间长的任务，用状态机分成几个子任务，使每个任务占用时间最短，消除了可恶的死等延时。