基于时间片的52操作系统

zjsxwc

今天在看了rainyss大神的帖子后，在我的52上写了个调度器。

1. #include <reg52.h>
   
2. 
   
3. 
   
4. #define MAX_TASKS 3      
   
5. #define MAX_TASK_DEP 24  
   
6. unsigned char idata task_stack[MAX_TASKS][MAX_TASK_DEP]={0};
   
7. unsigned char idata * task_sp[MAX_TASKS];
   
8. 
   
9. 
   
10. unsigned char idata  task_old[MAX_TASKS]={0};
    
11. unsigned char task_id;
    
12. 
    
13. unsigned char idata task_die[MAX_TASKS]={0};
    
14. 
    
15. 
    
16. unsigned char task_time_slice[MAX_TASKS][2]={
    
17.         {0xC0,0xFF},//ʱ¼äƬ
    
18.         {0xC2,0xFF},               
    
19.         {0xC1,0xFF},       
    
20. };
    
21. 
    
22. 
    
23. 
    
24. void Task_clear_REG(){
    
25.         ACC=0;
    
26.         B=0;
    
27.         PSW=0;
    
28. 
    
29. }
    
30. 
    
31. void Start_Timer2(){
    
32.         EXEN2=0;
    
33.         C_T2=0;
    
34.         RCLK=0;
    
35.         TCLK=0;
    
36.         CP_RL2=0;
    
37.        
    
38.         RCAP2L=task_time_slice[0][0];
    
39.         RCAP2H=task_time_slice[0][1];
    
40.         TL2=task_time_slice[0][0];
    
41.         TH2=task_time_slice[0][1];
    
42.        
    
43.         PT2=1;
    
44.         TR2=1;
    
45.         ET2=1;
    
46.         EA=1;
    
47. 
    
48. }
    
49. 
    
50. 
    
51. 
    
52. void Init_OS(){
    
53.         Start_Timer2();
    
54. }
    
55. 
    
56. void Kill_task(unsigned char tid){
    
57.         task_die[tid]=1;
    
58. }
    
59. void Revive_task(unsigned char tid){
    
60.         task_die[tid]=0;
    
61. }
    
62. 
    
63. 
    
64. void task_load(unsigned int fn, unsigned char tid){
    
65.         task_sp[tid] = task_stack[tid] + 1;
    
66.         task_stack[tid][0] = (unsigned int)fn & 0xff;
    
67.         task_stack[tid][1] = (unsigned int)fn >> 8;
    
68. }
    
69. 
    
70. 
    
71. 
    
72. 
    
73. 
    
74. #define os_start(tid) {task_id = tid,SP = task_sp[tid];return;}
    
75. 
    
76. 
    
77. 
    
78. void task1()
    
79. {
    
80. static unsigned char i;
    
81. 
    
82.        
    
83.         while(1){
    
84.                 i++;
    
85.         }
    
86. }
    
87. 
    
88. void task2()
    
89. {
    
90. static unsigned char j;
    
91. 
    
92.        
    
93.         while(1){
    
94.                 j+=1;
    
95.                 j+=2;
    
96.                 j+=3;
    
97.                 j+=4;
    
98.                 j+=5;
    
99.                 j+=6;
    
100.                 j+=7;
     
101.                 j*=8;
     
102.                 j+=9;
     
103.                 j+=10;
     
104.                 j+=55;
     
105.                 j+=767;
     
106.                 j+=2;
     
107.                 j+=2;
     
108.                 j+=44;
     
109.                 j*=3;
     
110.                 j+=1;
     
111.                 j+=66;
     
112.                 j*=43;
     
113.                 j+=7;
     
114.                 j+=98;
     
115.                 j*=7;
     
116.                 j+=332;
     
117.                 j+=44;
     
118.                 j+=33;
     
119.                 j+=324;
     
120.                 Kill_task(1);//finish task2,and suicide
     
121.         }
     
122. }
     
123. 
     
124. void task3(){
     
125. static unsigned char k;
     
126. 
     
127.        
     
128.         while(1){
     
129.                 k+=3;
     
130.         }
     
131. }
     
132. 
     
133. void main(){
     
134. 
     
135.         task_load(task1, 0);
     
136.         task_load(task2, 1);
     
137.         task_load(task3, 2);
     
138.         Init_OS();
     
139.         os_start(0);
     
140. 
     
141. }
     
142. 
     
143. 
     
144. 
     
145. 
     
146. void task_switch() interrupt 5
     
147. {
     
148. 
     
149. 
     
150.         unsigned char  R[5]={0};//let keil C51 know that R0--R7/B/acc/psw/dptr must be push\pop in the stack!
     
151.         TR2=0;
     
152. 
     
153. 
     
154.         task_old[task_id]=1;
     
155.         task_sp[task_id]=SP;
     
156.        
     
157.                                
     
158.         while(1){
     
159.                 if(++task_id == MAX_TASKS)
     
160.                 task_id = 0;
     
161.                 if         (task_die[task_id]!=1) break;                                                               
     
162.         }       
     
163.                                
     
164.         if (task_old[task_id])
     
165.                 SP=task_sp[task_id];
     
166.         else{       
     
167.                 *(task_sp[task_id]+1)=0;//acc
     
168.                 *(task_sp[task_id]+2)=0;//B
     
169.                 *(task_sp[task_id]+3)=0;//dpoh
     
170.                 *(task_sp[task_id]+4)=0;//dpol
     
171.                 *(task_sp[task_id]+5)=0;//psw
     
172.                 *(task_sp[task_id]+6)=0;//r0
     
173.                 *(task_sp[task_id]+7)=0;//r1
     
174.                 *(task_sp[task_id]+8)=0;//r2
     
175.                 *(task_sp[task_id]+9)=0;//r3
     
176.                 *(task_sp[task_id]+10)=0;//r4
     
177.                 *(task_sp[task_id]+11)=0;//r5
     
178.                 *(task_sp[task_id]+12)=0;//r6
     
179.                 *(task_sp[task_id]+13)=0;//r7
     
180.                
     
181.                 task_sp[task_id]=task_sp[task_id]+13;
     
182.                 SP = task_sp[task_id];
     
183.         }
     
184. 
     
185.        
     
186.         TF2=0;       
     
187.         TL2=task_time_slice[task_id][0];
     
188.         TH2=task_time_slice[task_id][1];
     
189.         TR2=1;
     
190.         return;
     
191. }  

复制代码

已改，由于使用中断服务函数时C51会自动保持ACC\PSW\B\R0--R7\dptr到相应任务堆栈所以省下了开辟空间保证这些寄存器的事情.

沙漏

移植了操作系统吗

zjsxwc

占用了52的T2计时器 以及 level 1特权的中断。

zjsxwc

沙漏 发表于 2013-3-20 18:26
移植了操作系统吗

只是由原来手动切任务，变成按时间片自动切任务，利用了52多出来的T2计数器。

barryliu

R0~R7、PSW、ACC等重要寄存器没保存，任务切换会死人的。
你的测试程序例子太简单，所以你没看出来问题。

zjsxwc

barryliu 发表于 2013-3-21 09:42
R0~R7、PSW、ACC等重要寄存器没保存，任务切换会死人的。
你的测试程序例子太简单，所以你没看出来问题。 ...

多谢提醒，
已修改源程序

zjsxwc

实现了寄存器组的保存，防止了寄存器不同任务间的重用。


剩下的问题就是函数重入问题，对于函数重入问题也只能以宏代替或者使用那个重用函数关键字reentrant

zjsxwc

在我的52上测试，基本没有问题了，不过每个task中的变量都要是static的，否则keil生成汇编时可能会为不同变量分配相同地址。