01. 概述
FreeRTOS中创建和删除任务API函数的应用。使用静态方法创建任务，任务的堆栈、任务控制块就需要有用户来指定。

02. 功能描述
设计三个任务：start_task、task1_task和task2_task，这三个任务的功能分别如下：

start_task: 用来创建其它两个任务。

task1_task: 当此任务运行5秒以后就会调用函数vTaskDelete()删除任务task2_task，该任务控制LED0的闪烁，并且周期性的输出信息到串口中。

task2_task：普通的应用任务，此任务控制LED1的闪烁，并且周期性的输出信息到串口中。

03. 任务设计
系统设置

在FreeRTOSConfig.h文件中需要将宏configSUPPORT_STATIC_ALLOCATION设置为1.

1. #define configSUPPORT_STATIC_ALLOCATION 1 //静态内存

复制代码

编译报如下错误



使用静态的方法创建任务我们需要自己实现函数vApplicationGetTimerTaskMemory()和函数vApplicationGetIdleTaskMemory()。

1. //空闲任务任务堆栈
   
2. static StackType_t IdleTaskStack[configMINIMAL_STACK_SIZE];
   
3. //空闲任务控制块
   
4. static StaticTask_t IdleTaskTCB;
   
5. 
   
6. //定时器服务任务堆栈
   
7. static StackType_t TimerTaskStack[configTIMER_TASK_STACK_DEPTH];
   
8. //定时器服务任务控制块
   
9. static StaticTask_t TimerTaskTCB;
   
10. 
    
11. //ppxIdleTaskTCBBuffer:任务控制块内存
    
12. //ppxIdleTaskStackBuffer:任务堆栈内存
    
13. //pulIdleTaskStackSize:任务堆栈大小
    
14. void vApplicationGetIdleTaskMemory(StaticTask_t **ppxIdleTaskTCBBuffer,
    
15.                                                                    StackType_t **ppxIdleTaskStackBuffer,
    
16.                                                                    uint32_t *pulIdleTaskStackSize)
    
17. {
    
18.         *ppxIdleTaskTCBBuffer=&IdleTaskTCB;
    
19.         *ppxIdleTaskStackBuffer=IdleTaskStack;
    
20.         *pulIdleTaskStackSize=configMINIMAL_STACK_SIZE;
    
21. }
    
22. 
    
23. 
    
24. //获取定时器服务任务的任务堆栈和任务控制块内存
    
25. //ppxTimerTaskTCBBuffer:任务控制块内存
    
26. //ppxTimerTaskStackBuffer:任务堆栈内存
    
27. //pulTimerTaskStackSize:任务堆栈大小
    
28. void vApplicationGetTimerTaskMemory(StaticTask_t **ppxTimerTaskTCBBuffer,
    
29.                                                                         StackType_t **ppxTimerTaskStackBuffer,
    
30.                                                                         uint32_t *pulTimerTaskStackSize)
    
31. {
    
32.         *ppxTimerTaskTCBBuffer=&TimerTaskTCB;
    
33.         *ppxTimerTaskStackBuffer=TimerTaskStack;
    
34.         *pulTimerTaskStackSize=configTIMER_TASK_STACK_DEPTH;
    
35. }

复制代码

任务优先级，堆栈大小，任务句柄和任务函数

1. 
   
2. //任务优先级
   
3. #define START_TASK_PRIO                1
   
4. //任务堆栈大小        
   
5. #define START_STK_SIZE                 128  
   
6. //任务堆栈
   
7. StackType_t StartTaskStack[START_STK_SIZE];
   
8. //任务控制块
   
9. StaticTask_t StartTaskTCB;
   
10. //任务句柄
    
11. TaskHandle_t StartTask_Handler;
    
12. //任务函数
    
13. void start_task(void *pvParameters);
    
14. 
    
15. //任务优先级
    
16. #define TASK1_TASK_PRIO                2
    
17. //任务堆栈大小        
    
18. #define TASK1_STK_SIZE                 50  
    
19. //任务堆栈
    
20. StackType_t Task1TaskStack[TASK1_STK_SIZE];
    
21. //任务控制块
    
22. StaticTask_t Task1TaskTCB;
    
23. //任务句柄
    
24. TaskHandle_t Task1Task_Handler;
    
25. //任务函数
    
26. void task1_task(void *pvParameters);
    
27. 
    
28. //任务优先级
    
29. #define TASK2_TASK_PRIO                3
    
30. //任务堆栈大小        
    
31. #define TASK2_STK_SIZE                 50  
    
32. //任务堆栈
    
33. StackType_t Task2TaskStack[TASK2_STK_SIZE];
    
34. //任务控制块
    
35. StaticTask_t Task2TaskTCB;
    
36. //任务句柄
    
37. TaskHandle_t Task2Task_Handler;
    
38. //任务函数
    
39. void task2_task(void *pvParameters);

复制代码

start_task函数

1. //开始任务任务函数
   
2. void start_task(void *pvParameters)
   
3. {
   
4.     taskENTER_CRITICAL();           //进入临界区
   
5.     //创建TASK1任务
   
6.         Task1Task_Handler=xTaskCreateStatic((TaskFunction_t        )task1_task,               
   
7.                                                                                 (const char*         )"task1_task",               
   
8.                                                                                 (uint32_t                 )TASK1_STK_SIZE,        
   
9.                                                                                 (void*                           )NULL,                                
   
10.                                                                                 (UBaseType_t         )TASK1_TASK_PRIO,         
    
11.                                                                                 (StackType_t*   )Task1TaskStack,        
    
12.                                                                                 (StaticTask_t*  )&Task1TaskTCB);        
    
13.     //创建TASK2任务
    
14.         Task2Task_Handler=xTaskCreateStatic((TaskFunction_t        )task2_task,               
    
15.                                                                                 (const char*         )"task2_task",               
    
16.                                                                                 (uint32_t                 )TASK2_STK_SIZE,        
    
17.                                                                                 (void*                           )NULL,                                
    
18.                                                                                 (UBaseType_t         )TASK2_TASK_PRIO,         
    
19.                                                                                 (StackType_t*   )Task2TaskStack,        
    
20.                                                                                 (StaticTask_t*  )&Task2TaskTCB);
    
21.     vTaskDelete(StartTask_Handler); //删除开始任务
    
22.     taskEXIT_CRITICAL();            //退出临界区
    
23. }

复制代码

task1_task函数

1. //任务1
   
2. void task1_task(void *pvParameters)
   
3. {
   
4.         u8 task1_num = 0;
   
5.         
   
6.         while(1)
   
7.         {
   
8.                 task1_num++;
   
9.                 LED0 = !LED0;
   
10.                 printf("任务1已经运行%d次\r\n", task1_num);
    
11.         
    
12.                 if (5 == task1_num)
    
13.                 {
    
14.                         //任务1删除任务2
    
15.                         vTaskDelete(Task2Task_Handler);
    
16.                         printf("任务1删除了任务2\r\n");
    
17.                 }
    
18.                
    
19.                 //延时1秒 1000个时钟节拍
    
20.                 vTaskDelay(1000);
    
21.         }
    
22. }

复制代码

task2_task函数

1. //任务2
   
2. void task2_task(void *pvParameters)
   
3. {
   
4.         u8 task2_num = 0;
   
5.         
   
6.         while(1)
   
7.         {
   
8.                 task2_num++;
   
9.                 LED1 = !LED1;
   
10.                 printf("任务2已经执行了%d次\r\n", task2_num);
    
11.                
    
12.                 //延时1秒 1000个时钟节拍
    
13.                 vTaskDelay(1000);
    
14.         }
    
15. }

复制代码

04. 程序设计
main.c文件

1. #include "sys.h"
   
2. #include "delay.h"
   
3. #include "usart.h"
   
4. #include "led.h"
   
5. #include "FreeRTOS.h"
   
6. #include "task.h"
   
7. 
   
8. 
   
9. //空闲任务任务堆栈
   
10. static StackType_t IdleTaskStack[configMINIMAL_STACK_SIZE];
    
11. //空闲任务控制块
    
12. static StaticTask_t IdleTaskTCB;
    
13. 
    
14. //定时器服务任务堆栈
    
15. static StackType_t TimerTaskStack[configTIMER_TASK_STACK_DEPTH];
    
16. //定时器服务任务控制块
    
17. static StaticTask_t TimerTaskTCB;
    
18. 
    
19. //任务优先级
    
20. #define START_TASK_PRIO                1
    
21. //任务堆栈大小        
    
22. #define START_STK_SIZE                 128  
    
23. //任务堆栈
    
24. StackType_t StartTaskStack[START_STK_SIZE];
    
25. //任务控制块
    
26. StaticTask_t StartTaskTCB;
    
27. //任务句柄
    
28. TaskHandle_t StartTask_Handler;
    
29. //任务函数
    
30. void start_task(void *pvParameters);
    
31. 
    
32. //任务优先级
    
33. #define TASK1_TASK_PRIO                2
    
34. //任务堆栈大小        
    
35. #define TASK1_STK_SIZE                 50  
    
36. //任务堆栈
    
37. StackType_t Task1TaskStack[TASK1_STK_SIZE];
    
38. //任务控制块
    
39. StaticTask_t Task1TaskTCB;
    
40. //任务句柄
    
41. TaskHandle_t Task1Task_Handler;
    
42. //任务函数
    
43. void task1_task(void *pvParameters);
    
44. 
    
45. //任务优先级
    
46. #define TASK2_TASK_PRIO                3
    
47. //任务堆栈大小        
    
48. #define TASK2_STK_SIZE                 50  
    
49. //任务堆栈
    
50. StackType_t Task2TaskStack[TASK2_STK_SIZE];
    
51. //任务控制块
    
52. StaticTask_t Task2TaskTCB;
    
53. //任务句柄
    
54. TaskHandle_t Task2Task_Handler;
    
55. //任务函数
    
56. void task2_task(void *pvParameters);
    
57. 
    
58. 
    
59. //ppxIdleTaskTCBBuffer:任务控制块内存
    
60. //ppxIdleTaskStackBuffer:任务堆栈内存
    
61. //pulIdleTaskStackSize:任务堆栈大小
    
62. void vApplicationGetIdleTaskMemory(StaticTask_t **ppxIdleTaskTCBBuffer,
    
63.                                                                    StackType_t **ppxIdleTaskStackBuffer,
    
64.                                                                    uint32_t *pulIdleTaskStackSize)
    
65. {
    
66.         *ppxIdleTaskTCBBuffer=&IdleTaskTCB;
    
67.         *ppxIdleTaskStackBuffer=IdleTaskStack;
    
68.         *pulIdleTaskStackSize=configMINIMAL_STACK_SIZE;
    
69. }
    
70. 
    
71. 
    
72. //获取定时器服务任务的任务堆栈和任务控制块内存
    
73. //ppxTimerTaskTCBBuffer:任务控制块内存
    
74. //ppxTimerTaskStackBuffer:任务堆栈内存
    
75. //pulTimerTaskStackSize:任务堆栈大小
    
76. void vApplicationGetTimerTaskMemory(StaticTask_t **ppxTimerTaskTCBBuffer,
    
77.                                                                         StackType_t **ppxTimerTaskStackBuffer,
    
78.                                                                         uint32_t *pulTimerTaskStackSize)
    
79. {
    
80.         *ppxTimerTaskTCBBuffer=&TimerTaskTCB;
    
81.         *ppxTimerTaskStackBuffer=TimerTaskStack;
    
82.         *pulTimerTaskStackSize=configTIMER_TASK_STACK_DEPTH;
    
83. }
    
84. 
    
85. //主函数
    
86. int main(void)
    
87. {
    
88.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4
    
89.         delay_init(168);                //初始化延时函数
    
90.         uart_init(115200);             //初始化串口
    
91.         LED_Init();                        //初始化LED端口
    
92.         
    
93.     //创建开始任务
    
94.         StartTask_Handler=xTaskCreateStatic((TaskFunction_t        )start_task,                //任务函数
    
95.                                                                                 (const char*         )"start_task",                //任务名称
    
96.                                                                                 (uint32_t                 )START_STK_SIZE,        //任务堆栈大小
    
97.                                                                                 (void*                           )NULL,                                //传递给任务函数的参数
    
98.                                                                                 (UBaseType_t         )START_TASK_PRIO,         //任务优先级
    
99.                                                                                 (StackType_t*   )StartTaskStack,        //任务堆栈
    
100.                                                                                 (StaticTask_t*  )&StartTaskTCB);        //任务控制块   
     
101. 
     
102.     vTaskStartScheduler();          //开启任务调度
     
103. }
     
104. 
     
105. //开始任务任务函数
     
106. void start_task(void *pvParameters)
     
107. {
     
108.     taskENTER_CRITICAL();           //进入临界区
     
109.     //创建TASK1任务
     
110.         Task1Task_Handler=xTaskCreateStatic((TaskFunction_t        )task1_task,               
     
111.                                                                                 (const char*         )"task1_task",               
     
112.                                                                                 (uint32_t                 )TASK1_STK_SIZE,        
     
113.                                                                                 (void*                           )NULL,                                
     
114.                                                                                 (UBaseType_t         )TASK1_TASK_PRIO,         
     
115.                                                                                 (StackType_t*   )Task1TaskStack,        
     
116.                                                                                 (StaticTask_t*  )&Task1TaskTCB);        
     
117.     //创建TASK2任务
     
118.         Task2Task_Handler=xTaskCreateStatic((TaskFunction_t        )task2_task,               
     
119.                                                                                 (const char*         )"task2_task",               
     
120.                                                                                 (uint32_t                 )TASK2_STK_SIZE,        
     
121.                                                                                 (void*                           )NULL,                                
     
122.                                                                                 (UBaseType_t         )TASK2_TASK_PRIO,         
     
123.                                                                                 (StackType_t*   )Task2TaskStack,        
     
124.                                                                                 (StaticTask_t*  )&Task2TaskTCB);
     
125.     vTaskDelete(StartTask_Handler); //删除开始任务
     
126.     taskEXIT_CRITICAL();            //退出临界区
     
127. }
     
128. 
     
129. //任务1
     
130. void task1_task(void *pvParameters)
     
131. {
     
132.         u8 task1_num = 0;
     
133.         
     
134.         while(1)
     
135.         {
     
136.                 task1_num++;
     
137.                 LED0 = !LED0;
     
138.                 printf("任务1已经运行%d次\r\n", task1_num);
     
139.         
     
140.                 if (5 == task1_num)
     
141.                 {
     
142.                         //任务1删除任务2
     
143.                         vTaskDelete(Task2Task_Handler);
     
144.                         printf("任务1删除了任务2\r\n");
     
145.                 }
     
146.                
     
147.                 //延时1秒 1000个时钟节拍
     
148.                 vTaskDelay(1000);
     
149.         }
     
150. }
     
151. 
     
152. //任务2
     
153. void task2_task(void *pvParameters)
     
154. {
     
155.         u8 task2_num = 0;
     
156.         
     
157.         while(1)
     
158.         {
     
159.                 task2_num++;
     
160.                 LED1 = !LED1;
     
161.                 printf("任务2已经执行了%d次\r\n", task2_num);
     
162.                
     
163.                 //延时1秒 1000个时钟节拍
     
164.                 vTaskDelay(1000);
     
165.         }
     
166. }
     

复制代码

05. 结果验证
任务1运行5秒中之后删除了任务2，任务2被删除之后就不会被运行。最后只剩下任务1运行了。