51单片机

基于时间片的52操作系统

2020-01-30 14:02发布

站内问答 / 51单片机
4307 8 8
本帖最后由 zjsxwc 于 2013-3-21 16:53 编辑

今天在看了rainyss大神的帖子后，在我的52上写了个调度器。
  1. #include <reg52.h>


  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];


  10. unsigned char idata  task_old[MAX_TASKS]={0};
  11. unsigned char task_id;

  13. unsigned char idata task_die[MAX_TASKS]={0};


  16. unsigned char task_time_slice[MAX_TASKS][2]={
  17.         {0xC0,0xFF},//ʱ¼äƬ
  18.         {0xC2,0xFF},               
  19.         {0xC1,0xFF},       
  20. };



  24. void Task_clear_REG(){
  25.         ACC=0;
  26.         B=0;
  27.         PSW=0;

  29. }

  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;

  48. }



  52. void Init_OS(){
  53.         Start_Timer2();
  54. }

  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. }


  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. }





  74. #define os_start(tid) {task_id = tid,SP = task_sp[tid];return;}



  78. void task1()
  79. {
  80. static unsigned char i;

  82.        
  83.         while(1){
  84.                 i++;
  85.         }
  86. }

  88. void task2()
  89. {
  90. static unsigned char j;

  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. }

  124. void task3(){
  125. static unsigned char k;

  127.        
  128.         while(1){
  129.                 k+=3;
  130.         }
  131. }

  133. void main(){

  135.         task_load(task1, 0);
  136.         task_load(task2, 1);
  137.         task_load(task3, 2);
  138.         Init_OS();
  139.         os_start(0);

  141. }




  146. void task_switch() interrupt 5
  147. {


  150.         unsigned char  R[5]={0};//let keil C51 know that R0--R7/B/acc/psw/dptr must be pushpop in the stack!
  151.         TR2=0;


  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.         }

  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会自动保持ACCPSWBR0--R7dptr到相应任务堆栈所以省下了开辟空间保证这些寄存器的事情.
友情提示: 此问题已得到解决，问题已经关闭,关闭后问题禁止继续编辑，回答。
该问题目前已经被作者或者管理员关闭, 无法添加新回复
7条回答
沙漏
1楼-- · 2020-01-30 14:31
 精彩回答 2  元偷偷看……
zjsxwc
2楼-- · 2020-01-30 15:33
本帖最后由 zjsxwc 于 2013-3-20 21:39 编辑

占用了52的T2计时器 以及 level 1特权的中断。
zjsxwc
3楼-- · 2020-01-30 21:05
沙漏 发表于 2013-3-20 18:26
移植了操作系统吗

只是由原来手动切任务，变成按时间片自动切任务，利用了52多出来的T2计数器。
barryliu
4楼-- · 2020-01-31 02:04
R0~R7、PSW、ACC等重要寄存器没保存，任务切换会死人的。
你的测试程序例子太简单，所以你没看出来问题。
zjsxwc
5楼-- · 2020-01-31 06:41
本帖最后由 zjsxwc 于 2013-3-21 16:30 编辑
barryliu 发表于 2013-3-21 09:42
R0~R7、PSW、ACC等重要寄存器没保存，任务切换会死人的。
你的测试程序例子太简单，所以你没看出来问题。 ...


多谢提醒，
已修改源程序
zjsxwc
6楼-- · 2020-01-31 10:18
 精彩回答 2  元偷偷看……
1 2 下一页

一周热门 更多>