发一个简单的并行任务运行程序

Tliang

1. #include<avr/io.h>
   
2. #include"Task.h"
   
3. #include<avr/interrupt.h>
   
4. 
   
5. #define Task_Max  5                                //任务数
   
6. #define Stack_Top 12                        //任务堆栈空间
   
7. 
   
8. 
   
9. typedef struct Task_Value
   
10. {
    
11.         uint8         p;                                        //任务堆栈指针
    
12.         uint16        delay;                                //任务延时
    
13.         uint8        State;                                //任务状态
    
14. }Task;
    
15. 
    
16. static Task Task_Buf[Task_Max];                                //任务空间
    
17. 
    
18. static uint8 Task_SP[Task_Max][Stack_Top];        //任务堆栈空间
    
19. 
    
20. static uint8 Task_Run_ID;                                        //正在运行任务ID
    
21. 
    
22. void AddTask(uint16 TaskName, uint16 TaskDelay, uint8 TaskID)
    
23. {
    
24.         Task_Buf[TaskID].p = (uint16)Task_SP[TaskID] + 9;
    
25.         //AVR单片机SP堆栈方向是由上往下生长的，执行RET的时候SP将加1,所以要比实际地址小1
    
26.         Task_SP[TaskID][10] = (uint8)(TaskName >> 8);                //地址高8位
    
27.         Task_SP[TaskID][11] = (uint8)(TaskName & 0xff);                //地址低8位
    
28.         Task_Buf[TaskID].delay = TaskDelay;
    
29.         Task_Buf[TaskID].State = 0;
    
30. }
    
31. 
    
32. void Task_Delay(uint16 Del)
    
33. {
    
34.         uint8 Temp = 0;
    
35.         Task_Buf[Task_Run_ID].p        = SP;                                        //保存当前堆栈
    
36.         Task_Buf[Task_Run_ID].delay = Del;                                //设置延时
    
37.         Task_Buf[Task_Run_ID].State -= 1;                                //将状态置0
    
38. 
    
39.         for(Temp = 0;Temp < Task_Max - 1;Temp++)
    
40.         {
    
41.                 if(Task_Buf[Temp].State == 1)                                //如果有任务处于就绪状态,执行.
    
42.                 {
    
43.                         break;
    
44.                 }
    
45.         }
    
46. 
    
47.         SP = Task_Buf[Temp].p;                                                        //将任务堆栈地址赋给SP堆栈地址
    
48.         Task_Run_ID = Temp;                                                                //运行改变ID
    
49. }
    
50. 
    
51. ISR(TIM0_OVF_vect)
    
52. {
    
53.         uint8 Index = 0;
    
54.         uint8 IDBuf = Task_Run_ID;                                                //保存当前运行任务的ID
    
55.         uint8 Task_Run_SP = Task_Buf[Task_Run_ID].p - SP;       
    
56.         //任务堆栈指针减去当前堆栈指针得到中断所使用掉的堆栈
    
57. 
    
58.         TCNT0 = 0x00;
    
59.         Task_Buf[Task_Run_ID].p = SP + Task_Run_SP;
    
60.         //当前堆栈指针加上中断所使用掉的堆栈数得到中断前堆栈指针,保存
    
61. 
    
62.         for(Index = 0;Index < Task_Max;Index++)
    
63.         {
    
64.                 if(Task_Buf[Index].p != 0)
    
65.                 {
    
66.                         if((Task_Buf[Index].delay == 0) && (Task_Buf[Index].State == 0))
    
67.                         {
    
68.                                 //如果任务延时时间到,将就绪置位
    
69.                                 Task_Buf[Index].State = 1;
    
70. 
    
71.                                 if(Index < IDBuf)
    
72.                                 {
    
73.                                         IDBuf = Index;                //如果当前运行任务优先级低于就绪任务则切换
    
74.                                 }
    
75. 
    
76.                         }
    
77.                         else if((Task_Buf[Index].delay != 0) && (Task_Buf[Index].State == 0))
    
78.                         {
    
79. 
    
80.                                 Task_Buf[Index].delay -= 1;        //时间未到,时间标志减1
    
81. 
    
82.                         }
    
83.                 }
    
84.         }
    
85.         //将运行任务指针减去中断所用堆栈数得到中断返回前的堆栈指针,中断返回将加上
    
86.         //中断所用掉的堆栈数量,就得到将运行任务的实际堆栈指针
    
87.         SP = Task_Buf[IDBuf].p - Task_Run_SP;       
    
88.         Task_Run_ID = IDBuf;                //改变当前运行任务ID
    
89. 
    
90. }
    
91. 
    
92. void Task_Kong(void)
    
93. {
    
94.         while(1);                                //当没有任务执行的时候就停留在此处,可以加入CPU空闲计算
    
95. }
    
96. 
    
97. void Time0_Task_Start(void)
    
98. {
    
99.         AddTask((uint16)Task_Kong, 0, Task_Max - 1);        //添加空任务
    
100.         TCCR0A = 0x00;
     
101.         TCCR0B = 0x03;
     
102.         TCNT0 = 0x00;
     
103.         TIMSK0 |= 0x01;
     
104.         sei();
     
105.         Task_Run_ID = Task_Max - 1;                                                //开始运行运行空任务,可用形参指定运行那个任务
     
106.         SP = Task_Buf[Task_Run_ID].p;                                        //任务开始运行
     
107. }
     

复制代码

这段程序在Task_Delay这个函数中Task_Buf[Task_Run_ID].State -= 1不知道为什么不能直接给0。直接给0并未将它清0。所以这里就写减1了。请各位大侠帮忙看看原因。
还有小弟不明白任务间如何通讯。那位大侠能否给小弟我讲解一下消息机制和邮箱队列怎么构成的，多谢了。
这段程序是ATtiny24的程序。在5楼我打包了一个ATmega8的测试程序。有Proteus仿真。

Tliang

郁闷。。竟无人理

graycker

Task_Buf[Index].delay -= 1;
我看到等号前面有个减号，不知道是不是这个原因
带操作系统的逻辑性会有点复杂的。。。还要考虑各种细节，

Tliang

汗。。。我说错了。。。
这段程序在Task_Delay这个函数中Task_Buf[Task_Run_ID].State -= 1这一句本来是Task_Buf[Task_Run_ID].State = 0不知道为什么直接给0并未将它清0。所以这里就写减1了。

Tliang

上个测试程序给大家试试。简单易用。可惜没有消息机制

Tliang

我贴那个程序是ATTINY24上面测试可以的。。。后面打包的是ATmega8的。前面是在ATmega8上测试后来移到ATtiny24上面了，有两个我没细看就把程序贴出来了，汗。。。难怪没人理。各位大概一看就以为不行吧。毕竟ATtiny24没多少人用过吧。。。

graycker

这种，应该是用的人比较少。所以就少有人回答了

Tliang

哦。。。