自己摸了一个操作系统内核，发出来给大家看看。

温馨提示：      1.该内核仅供学习和参考使用。
      2.大概率不会再更新(没必要造轮子)。
      3.该内核并不成熟，如要使用操作系统请寻找市面上成熟的内核。      4.个人不喜欢大片的注释，注释仅仅说明大致功能，细节需自行理解。

1. #include <Task_Core.H>
   
2. #include <stdlib.h>
   
3. #include <Config.H>
   
4. 
   
5. void Free_Task();
   
6. 
   
7. struct Task_Control_Block_List{
   
8.         uchar* head_Stack;                //栈头指针
   
9.         uchar* tail_Stack;                //栈尾指针
   
10.         uchar* event_Pointer; //时间指针
    
11.         uchar  event_End;                        //时间结束
    
12.         uchar  ready;                                        //就绪状态
    
13.         uchar  priority;                        //优先级
    
14.         struct Task_Control_Block_List* Next;
    
15.        
    
16. };
    
17. typedef struct Task_Control_Block_List Task_List;
    
18. struct Task_Priority_List{
    
19.         struct Task_Priority_List * Next;
    
20.         struct Task_Control_Block_List* Head_Task;
    
21.         struct Task_Control_Block_List* Next_Task;
    
22.         uchar  priority;
    
23. }Task_Priority_List;
    
24. typedef struct Task_Priority_List Task_Ready_List;
    
25. //添加任务到优先级链
    
26. void ADD_Task_To_Priority_List(Task_List * list);
    
27. //从优先级链中删除任务
    
28. void DEC_Task_Of_Priority_List(Task_List * list);
    
29. 
    
30. static Task_List Block_List_Head;                                                //   阻塞链表表头
    
31. static Task_List* Now_Task;                                                                         //   目前启用任务
    
32. static Task_Ready_List Task_Ready_List_Head;// 优先级链表表头
    
33. 
    
34. static uchar data Stack_Start;                                                        // 栈开始
    
35. static uchar data Stack_Last;                                                                // 上一个栈尾
    
36. static uchar data Stack_St;                                                                        // 中间变量
    
37. 
    
38. //任务调度函数
    
39. #pragma asm
    
40. CSEG        AT        0000BH
    
41. LJMP        Timer
    
42. #pragma endasm
    
43. void Timer() interrupt 1
    
44. {
    
45.         Task_List* Task_Now;
    
46.         Task_List* Task_Now1;
    
47.         uchar* stack;
    
48.         uchar a;
    
49.         int i;
    
50.         //禁止中断嵌套
    
51.         EA = 0;
    
52.         //保存上文
    
53.         #pragma asm
    
54.         MOV          Stack_Last,SP
    
55.         MOV   SP, Stack_St
    
56.         #pragma endasm
    
57.         Now_Task->tail_Stack =(uchar *) Stack_Last;
    
58.        
    
59.         // 搜索阻塞链表中达成条件的任务
    
60.         for(Task_Now = &Block_List_Head; Task_Now->Next != NULL;)
    
61.         {
    
62.                 if(Task_Now->Next->event_Pointer[0] >= Task_Now->Next->event_End)
    
63.                 {
    
64.                         //将其从阻塞链表中移除，并添加到优先级任务链表
    
65.                                 Task_Now->Next->event_Pointer = NULL;
    
66.                                 Task_Now->Next->ready = 1;
    
67.                                 Task_Now1 = Task_Now->Next;
    
68.                                 Task_Now->Next = Task_Now->Next->Next;
    
69.                                 ADD_Task_To_Priority_List(Task_Now1);
    
70.                                 continue;
    
71.                 }
    
72.                  Task_Now = Task_Now->Next;
    
73.         }
    
74.         //修改当前启用任务
    
75.         Now_Task = Task_Ready_List_Head.Next->Next_Task;
    
76.         //修改优先级链表中下一个启用任务
    
77.         if(Now_Task->Next != NULL)// 当前启用任务不是最后一个任务
    
78.                 Task_Ready_List_Head.Next->Next_Task = Now_Task->Next;
    
79.         else                                                                                        // 当前启用任务是最后一个任务
    
80.                 Task_Ready_List_Head.Next->Next_Task = Task_Ready_List_Head.Next->Head_Task;
    
81.        
    
82.         //更换下文
    
83.         Stack_Last = Now_Task->tail_Stack;
    
84.         #pragma asm
    
85.         MOV  SP,Stack_Last
    
86.         #pragma endasm
    
87.        
    
88.         EA = 1;
    
89.        
    
90. }
    
91. //任务阻塞
    
92. void Task_Block(uchar *event_pointer, uchar event_end)
    
93. {
    
94.         uchar i;
    
95.         EA = 0;
    
96.        
    
97.         Now_Task->event_Pointer = event_pointer;
    
98.         Now_Task->event_End = event_end;
    
99.         Now_Task->ready = 0;
    
100.         DEC_Task_Of_Priority_List(Now_Task);
     
101.         Now_Task->Next = Block_List_Head.Next;
     
102.         Block_List_Head.Next = Now_Task;
     
103.         EA = 1;
     
104.         TF0 = 1;
     
105.         for(i = 0; i < 8; i++);
     
106. }
     
107. //任务等待时间
     
108. void Task_Wait(uchar Ms)
     
109. {
     
110.         uchar i;
     
111.         EA = 0;
     
112.         for(i = 0; i < 8; i++)
     
113.         {
     
114.                 if(biao[i] < 128)break;
     
115.         }
     
116.         if(i == 8)return;
     
117.         biao[i] = 128;
     
118.         Task_Block(&biao[i], Ms+128);
     
119.         biao[i] = 0;
     
120. }
     
121. 
     
122. 
     
123. void Task_Init()
     
124. {
     
125.         TMOD = 0x00;
     
126.         TH0 = 0xF6;
     
127.         TL0 = 0x3B;
     
128.         TR0 = 1;
     
129.         ET0 = 1;
     
130.         #pragma asm
     
131.         MOV          Stack_Start,SP
     
132.         #pragma endasm
     
133.         Stack_Start += 10;
     
134.         // 初始化链表头
     
135.         Task_Ready_List_Head.priority  = 0;
     
136.         Task_Ready_List_Head.Head_Task = NULL;
     
137.         Task_Ready_List_Head.Next      = NULL;
     
138.         Task_Ready_List_Head.Next_Task = NULL;
     
139.        
     
140. }
     
141. // 添加任务
     
142. void Task_ADD(void * x, uchar Stack_Growth, uchar priority)
     
143. {
     
144.         Task_List * list = malloc(sizeof(Task_List));// 定义任务链表
     
145.        
     
146.         list->priority = priority;                                                                        //优先级赋值
     
147.         list->head_Stack =(uchar *)Stack_Start ;    //栈头地址赋值
     
148.         //将任务PC指针压入栈
     
149.         #pragma asm
     
150.         MOV Stack_Last,SP
     
151.         MOV SP ,Stack_Start
     
152.         MOV          DPTR,#x?450
     
153.         LCALL        ?C?PLDXDATA
     
154.         MOV          R6,AR2
     
155.         MOV          R7,AR1
     
156.         MOV          A,R7
     
157.         PUSH ACC
     
158.         MOV          A,R6
     
159.         PUSH ACC
     
160.         MOV SP, Stack_Last
     
161.         #pragma endasm
     
162.         Stack_Start += Stack_Growth + 15;                                          //修改下一个栈开始位置
     
163.         list->tail_Stack = &list->head_Stack[15];                //栈尾地址赋值
     
164.         list->ready = 1;                                                                                                                //阻塞/就绪态赋值
     
165.         list->Next = NULL;
     
166.         ADD_Task_To_Priority_List(list);
     
167.        
     
168. }
     
169. //从优先级任务链中删除一个任务(将任务从就绪态中移除)
     
170. void DEC_Task_Of_Priority_List(Task_List * list)
     
171. {
     
172.         uchar priority = list->priority;
     
173.         Task_Ready_List* priority_List;                                                               
     
174.         Task_Ready_List* new_priority_List;
     
175.         Task_List * list1;
     
176.         //查找优先级链表内是否已有所需优先级
     
177.         for(priority_List = &Task_Ready_List_Head; priority_List->Next != NULL; priority_List = priority_List->Next)
     
178.         {
     
179.                 if(priority_List->Next->priority >  priority)return;// 错误， 没有找着所需优先级
     
180.                 if(priority_List->Next->priority == priority)break;// 当前链表优先级等于所需优先级
     
181.         }
     
182.         if(priority_List->Next == NULL)return;// 错误， 没有找着所需优先级
     
183.         if(priority_List->Next->Head_Task == NULL)goto ASDN;// 错误，当前优先级内没有任务
     
184.        
     
185.         if(priority_List->Next->Head_Task == list)// 判断优先级任务头是不是所需任务
     
186.         {
     
187.                 priority_List->Next->Head_Task = priority_List->Next->Head_Task->Next;// 删除改任务
     
188.                 goto ASDN;
     
189.         }
     
190.         //在当前优先级任务链内搜索所需任务
     
191.         for(list1 = priority_List->Next->Head_Task; list1->Next != NULL; list1 = list1->Next)
     
192.         {
     
193.                 if(list1->Next == list)
     
194.                 {
     
195.                         list1->Next = list1->Next->Next;// 从优先级任务链中删除任务
     
196.                         break;
     
197.                 }
     
198.         }
     
199.         ASDN:
     
200.         if(priority_List->Next->Head_Task == NULL)//当前优先级内没有任何任务，删除当前优先级任务链
     
201.         {
     
202.                 new_priority_List = priority_List->Next;
     
203.                 priority_List->Next = priority_List->Next->Next;
     
204.         //        free(new_priority_List);
     
205.         }
     
206. }
     
207. //添加一个任务到优先级任务链(将任务添加到就绪态)
     
208. void ADD_Task_To_Priority_List(Task_List * list)
     
209. {
     
210.         uchar priority = list->priority;
     
211.         Task_Ready_List* priority_List;                                                               
     
212.         Task_Ready_List* new_priority_List;
     
213.         //查找优先级链表内是否已有当前优先级
     
214.         for(priority_List = &Task_Ready_List_Head; priority_List->Next != NULL; priority_List = priority_List->Next)
     
215.         {
     
216.                 if(priority_List->Next->priority >  priority)goto NEWHEAD;
     
217.                 if(priority_List->Next->priority == priority)break;// 当前链表优先级等于当前优先级
     
218.         }
     
219.         if(priority_List->Next == NULL)// 优先级链表内没有当前优先级
     
220.         {
     
221.                 NEWHEAD:
     
222.                 //新建一个优先级头
     
223.                 new_priority_List = malloc(sizeof(Task_Ready_List));
     
224.                 new_priority_List->Next = priority_List->Next;
     
225.                 priority_List->Next = new_priority_List;
     
226.                 priority_List->Next->priority = priority;
     
227.                 priority_List->Next->Next_Task = list;
     
228.                 priority_List->Next->Head_Task = NULL;
     
229.         }
     
230.         //更换优先级链内头任务
     
231.         list->Next = priority_List->Next->Head_Task;
     
232.         priority_List->Next->Head_Task = list;
     
233. }
     
234. void Task_Start()
     
235. {
     
236.         uchar* a;
     
237.         Task_Ready_List* priority_List;                                                               
     
238.         #pragma asm
     
239.         MOV          Stack_St,SP
     
240.         #pragma endasm
     
241.         Task_ADD(Free_Task, 2,55);// 添加空闲任务
     
242.         //设置优先级链表中下一个启用任务
     
243.         for(priority_List = Task_Ready_List_Head.Next; priority_List != NULL; priority_List = priority_List->Next)
     
244.                 priority_List->Next_Task = priority_List->Head_Task;
     
245.         //获得当前启用任务
     
246.         Now_Task = Task_Ready_List_Head.Next->Head_Task;
     
247.         //修改优先级链表中下一个启用任务
     
248.         if(Now_Task->Next != NULL)// 当前启用任务不是最后一个任务
     
249.                 Task_Ready_List_Head.Next->Next_Task = Now_Task->Next;
     
250.         else                                                                                        // 当前启用任务是最后一个任务
     
251.                 Task_Ready_List_Head.Next->Next_Task = Task_Ready_List_Head.Next->Head_Task;
     
252.         // 修改栈指针指向位置
     
253.         a = Task_Ready_List_Head.Next->Head_Task->tail_Stack;
     
254.         #pragma asm
     
255.         MOV SP, ACC
     
256.         POP          AR7
     
257.         POP          AR6
     
258.         POP          AR5
     
259.         POP          AR4
     
260.         POP          AR3
     
261.         POP          AR2
     
262.         POP          AR1
     
263.         POP          AR0
     
264.         POP          PSW
     
265.         POP          DPL
     
266.         POP          DPH
     
267.         POP          B
     
268.         POP          ACC
     
269.         #pragma endasm
     
270. }
     
271. //空闲函数
     
272. void Free_Task()
     
273. {
     
274.         while(1)
     
275.         {
     
276.                 EA = 1;
     
277.         }
     
278. }
     
279. 
     
280. 
     

复制代码

可以的，在完善一下。

更新：
1.删除了所有汇编内容。
2.新增事件唤醒函数，现在可以方便的设计唤醒条件，并且可以知晓是由什么唤醒的任务。
-----------------------------------------------------------------------------------------------------------

1. #include <Task_Core.H>
   
2. #include <stdlib.h>
   
3. #include <Config.H>
   
4. 
   
5. 
   
6. /*------任务TCB结构体-------
   
7. //提示：任务栈内不包括局部变量
   
8. ----------------------------*/
   
9. struct Task_Control_Block_List{
   
10.         uchar* head_Stack;                                                //任务栈头
    
11.         uchar* tail_Stack;                                                //任务栈尾
    
12.         uint Tick;                                                                                //跳动计数，用于等待时间
    
13.         void* event_function;                                        //事件函数指针
    
14.         uchar event_return;                                                //事件返回值，用于确定唤醒任务的事件
    
15.         uchar  ready;                                                                        //阻塞/就绪标志位
    
16.         uchar  priority;                                                        //优先级
    
17.         struct Task_Control_Block_List* Next;
    
18. };
    
19. typedef struct Task_Control_Block_List Task_List;
    
20. 
    
21. struct Task_Priority_List{
    
22.         struct Task_Priority_List * Next;
    
23.         struct Task_Control_Block_List* Head_Task;
    
24.         struct Task_Control_Block_List* Next_Task;
    
25.         uchar  priority;
    
26. }Task_Priority_List;
    
27. typedef struct Task_Priority_List Task_Ready_List;
    
28. 
    
29. 
    
30. static Task_List Block_List_Head;                                                //   阻塞链表表头
    
31. static Task_List* Now_Task;                                                                         //   目前启用任务
    
32. static Task_Ready_List Task_Ready_List_Head;// 优先级链表表头
    
33. 
    
34. static uchar data Stack_Start;                                                        // 栈开始
    
35. static uchar data Stack_Last;                                                                // 上一个栈尾
    
36. static uchar data Stack_St;                                                                        // 中间变量
    
37. 
    
38. static uint  Tick;
    
39. 
    
40. //事件函数返回不是0的数即代表触发事件
    
41. static uchar (*Event_Function)();
    
42. 
    
43. static void Free_Task();
    
44. static void ADD_Task_To_Priority_List(Task_List * list);
    
45. static void DEC_Task_Of_Priority_List(Task_List * list);
    
46. 
    
47. 
    
48. 
    
49. static void Timer() interrupt 1
    
50. {
    
51.         Task_List* Task_Now;
    
52.         Task_List* Task_Now1;
    
53.         EA = 0;//禁止中断嵌套
    
54.         //保存上文
    
55.         Stack_Last = SP;
    
56.         SP = Stack_St;
    
57.         Now_Task->tail_Stack =(uchar *) Stack_Last;
    
58.        
    
59.        
    
60.         // 搜索阻塞链表中达成条件的任务
    
61.         for(Task_Now = &Block_List_Head; Task_Now->Next != NULL;)
    
62.         {
    
63.                 uchar a;
    
64.                 Event_Function = Task_Now->Next->event_function;
    
65.                 a = Event_Function();
    
66.                 if(a || --Task_Now->Next->Tick == 0)
    
67.                 {
    
68.                         //将其从阻塞链表中移除，并添加到优先级任务链表
    
69.                                 Task_Now->Next->event_return = a;
    
70.                                 Task_Now->Next->event_function = NULL;
    
71.                                 Task_Now->Next->ready = 1;
    
72.                                 Task_Now1 = Task_Now->Next;
    
73.                                 Task_Now->Next = Task_Now->Next->Next;
    
74.                                 ADD_Task_To_Priority_List(Task_Now1);
    
75.                 }
    
76.                 else
    
77.                  Task_Now = Task_Now->Next;
    
78.         }
    
79.         Tick++;// 时钟跳动
    
80.         //修改当前启用任务
    
81.         Now_Task = Task_Ready_List_Head.Next->Next_Task;
    
82.         //修改优先级链表中下一个启用任务
    
83.         if(Now_Task->Next != NULL)// 当前启用任务不是最后一个任务
    
84.                 Task_Ready_List_Head.Next->Next_Task = Now_Task->Next;
    
85.         else                                                                                        // 当前启用任务是最后一个任务
    
86.                 Task_Ready_List_Head.Next->Next_Task = Task_Ready_List_Head.Next->Head_Task;
    
87.        
    
88.         //更换下文
    
89.         Stack_Last =(uchar) Now_Task->tail_Stack;
    
90.        
    
91.         SP = Stack_Last;
    
92.        
    
93.        
    
94.        
    
95.        
    
96.         EA = 1;
    
97.        
    
98. }
    
99. //无事件，用于仅等待时间的任务
    
100. static uchar Not_Event()
     
101. {
     
102.         return 0;
     
103. }
     
104. /*--------------------任务阻塞-------------------------
     
105. Tick,任务等待超时时间，具体时间根据调度函数进入频率确定
     
106. function， 事件函数
     
107. -----------------------------------------------------*/
     
108. uchar Task_Block(void* function, uint Tick)
     
109. {
     
110.         EA = 0;
     
111.         if(function == NULL)function = Not_Event;
     
112.         Now_Task->event_function     =  function;
     
113.         Now_Task->event_return       =       255;
     
114.         Now_Task->Tick               =      Tick;
     
115.         Now_Task->ready              =         0;
     
116.        
     
117.         DEC_Task_Of_Priority_List(Now_Task);
     
118.         Now_Task->Next = Block_List_Head.Next;
     
119.         Block_List_Head.Next = Now_Task;
     
120.        
     
121.         EA = 1;
     
122.         TF0 = 1;
     
123.         return Now_Task->Next->event_return;
     
124. //        for(i = 0; i < 8; i++);
     
125. }
     
126. //任务初始化
     
127. void Task_Init()
     
128. {
     
129.         TMOD = 0x00;
     
130.         TH0 = 0xF6;
     
131.         TL0 = 0x3B;
     
132.         TR0 = 1;
     
133.         ET0 = 1;
     
134.         Stack_Start = SP;
     
135.         Stack_Start += 10;
     
136.         Task_Ready_List_Head.priority  = 0;
     
137.         Task_Ready_List_Head.Head_Task = NULL;
     
138.         Task_Ready_List_Head.Next      = NULL;
     
139.         Task_Ready_List_Head.Next_Task = NULL;
     
140.         Block_List_Head.Next           = NULL;
     
141.        
     
142. }
     
143. /*--------------添加任务------------
     
144. //x, 任务头函数
     
145. //Stack_Growth, 栈生长（内部已经加上寄存器以及函数头所需的空间）
     
146. //priority, 优先级
     
147. ------------------------------------*/
     
148. void Task_ADD(uint x, uchar Stack_Growth, uchar priority)
     
149. {
     
150.         Task_List * list = malloc(sizeof(Task_List));// 定义任务链表
     
151.        
     
152.         list->priority = priority;                                                                        //优先级赋值
     
153.         list->head_Stack =(uchar *)Stack_Start ;    //栈头地址赋值
     
154.         ((uchar*) Stack_Start)[0] =  x % 256 ;
     
155.         ((uchar*) Stack_Start)[1] =  x >>  8 ;
     
156.         Stack_Start += Stack_Growth + 15;                                          //修改栈结尾位置
     
157.         list->tail_Stack = &list->head_Stack[14];                //栈尾地址赋值
     
158.         list->ready = 1;                                                                                                                //阻塞/就绪态赋值
     
159.         list->Next = NULL;
     
160.         ADD_Task_To_Priority_List(list);
     
161.        
     
162. }
     
163. //从优先级任务链中删除一个任务
     
164. static void DEC_Task_Of_Priority_List(Task_List * list)
     
165. {
     
166.         uchar priority = list->priority;
     
167.         Task_Ready_List* priority_List;                                                               
     
168.         Task_Ready_List* new_priority_List;
     
169.         Task_List * list1;
     
170.         //查找优先级链表内是否已有所需优先级
     
171.         for(priority_List = &Task_Ready_List_Head; priority_List->Next != NULL; priority_List = priority_List->Next)
     
172.         {
     
173.                 if(priority_List->Next->priority >  priority)return;// 错误， 没有找着所需优先级
     
174.                 if(priority_List->Next->priority == priority)break;// 当前链表优先级等于所需优先级
     
175.         }
     
176.         if(priority_List->Next == NULL)return;// 错误， 没有找着所需优先级
     
177.        
     
178.         if(priority_List->Next->Head_Task == NULL);// 错误，当前优先级内没有任务
     
179.        
     
180.         else if(priority_List->Next->Head_Task == list)// 判断优先级任务头是不是所需任务
     
181.         {
     
182.                 priority_List->Next->Head_Task = priority_List->Next->Head_Task->Next;// 删除改任务
     
183.         }
     
184.         //在当前优先级任务链内搜索所需任务
     
185.         else for(list1 = priority_List->Next->Head_Task; list1->Next != NULL; list1 = list1->Next)
     
186.         {
     
187.                 if(list1->Next == list)
     
188.                 {
     
189.                         list1->Next = list1->Next->Next;// 从优先级任务链中删除任务
     
190.                         break;
     
191.                 }
     
192.         }
     
193.         if(priority_List->Next->Head_Task == NULL)//当前优先级内没有任何任务，删除当前优先级任务链
     
194.         {
     
195.                 new_priority_List = priority_List->Next;
     
196.                 priority_List->Next = priority_List->Next->Next;
     
197.                 free(new_priority_List);
     
198.         }
     
199. }
     
200. //添加一个任务到优先级任务链
     
201. static void ADD_Task_To_Priority_List(Task_List * list)
     
202. {
     
203.         uchar priority = list->priority;
     
204.         Task_Ready_List* priority_List;                                                               
     
205.         Task_Ready_List* new_priority_List;
     
206.         //查找优先级链表内是否已有当前优先级
     
207.         for(priority_List = &Task_Ready_List_Head; priority_List->Next != NULL; priority_List = priority_List->Next)
     
208.         {
     
209.                 if(priority_List->Next->priority >  priority)goto NEWHEAD;
     
210.                 if(priority_List->Next->priority == priority)break;// 当前链表优先级等于当前优先级
     
211.         }
     
212.         if(priority_List->Next == NULL)// 优先级链表内没有当前优先级
     
213.         {
     
214.                 NEWHEAD:
     
215.                 //新建一个优先级头
     
216.                 new_priority_List = malloc(sizeof(Task_Ready_List));
     
217.                 new_priority_List->Next = priority_List->Next;
     
218.                 priority_List->Next = new_priority_List;
     
219.                 priority_List->Next->priority = priority;
     
220.                 priority_List->Next->Next_Task = list;
     
221.                 priority_List->Next->Head_Task = NULL;
     
222.         }
     
223.         //更换优先级链内头任务
     
224.         list->Next = priority_List->Next->Head_Task;
     
225.         priority_List->Next->Head_Task = list;
     
226. }
     
227. void Task_Start()
     
228. {
     
229.         Task_Ready_List* priority_List;                       
     
230.         Stack_St = SP;
     
231.         Task_ADD(Free_Task, 4,55);// 添加空闲任务
     
232.         //设置优先级链表中下一个启用任务
     
233.         for(priority_List = Task_Ready_List_Head.Next; priority_List != NULL; priority_List = priority_List->Next)
     
234.                 priority_List->Next_Task = priority_List->Head_Task;
     
235.         //获得当前启用任务
     
236.         Now_Task = Task_Ready_List_Head.Next->Head_Task;
     
237.         //修改优先级链表中下一个启用任务
     
238.         if(Now_Task->Next != NULL)// 当前启用任务不是最后一个任务
     
239.                 Task_Ready_List_Head.Next->Next_Task = Now_Task->Next;
     
240.         else                                                                                        // 当前启用任务是最后一个任务
     
241.                 Task_Ready_List_Head.Next->Next_Task = Task_Ready_List_Head.Next->Head_Task;
     
242.         // 修改栈指针指向位置
     
243.         SP =(uchar) Task_Ready_List_Head.Next->Head_Task->head_Stack + 1;
     
244.         EA = 1;
     
245.         TF0 = 1;
     
246. }
     
247. 
     
248. static void Free_Task()
     
249. {
     
250.         EA = 1;
     
251.         while(1)
     
252.         {
     
253.                 EA = 1;
     
254.         }
     
255. }
     
256. 
     
257. 
     

复制代码

----------------------------------------------------------
调用示例

1. 
   
2. void main()
   
3. {
   
4.         int i;
   
5.         EA = 0;
   
6.        
   
7.         init_mempool(mem, sizeof(mem));
   
8.         Task_Init();
   
9.        
   
10.         Task_ADD(mian, 4,2);
    
11.         Task_ADD(Key_Read,12,2);
    
12.         Task_ADD(Main_Dis, 16,1);
    
13.        
    
14.        
    
15.         Task_Start();
    
16. }

复制代码

---------------------------------------------------
事件函数示例

1. 
   
2. 
   
3. uchar Dis_event()
   
4. {
   
5.         return Dis_Start == 1;
   
6. }
   
7. //调用
   
8.                 Task_Block(Dis_event, 65535);

复制代码

厉害。。。。。。

人才！！！

大神厉害，膜拜~~