01. 概述
' e1 q) J% u" K) a6 dFreeRTOS中创建和删除任务API函数的应用。使用静态方法创建任务，任务的堆栈、任务控制块就需要有用户来指定。
1 {; D  a' k( A) m" Q
02. 功能描述
设计三个任务：start_task、task1_task和task2_task，这三个任务的功能分别如下：

0 p& H6 O+ f$ ~  g% lstart_task: 用来创建其它两个任务。
+ J0 P# O& p3 |. b
6 c* j; M" @/ a7 V  J  n; Jtask1_task: 当此任务运行5秒以后就会调用函数vTaskDelete()删除任务task2_task，该任务控制LED0的闪烁，并且周期性的输出信息到串口中。
! X; |, f  y* Z/ |
$ \5 y/ ]8 i. @4 N3 I3 ~6 Qtask2_task：普通的应用任务，此任务控制LED1的闪烁，并且周期性的输出信息到串口中。
0 s1 f" ~6 K1 c6 I( S. I
  c( a5 a0 q  o9 [# c+ F03. 任务设计
' u7 M& u9 i. w系统设置

' X* ~& K) y, p- A' ?# c- W2 ~在FreeRTOSConfig.h文件中需要将宏configSUPPORT_STATIC_ALLOCATION设置为1.
+ |3 S8 z2 q2 h4 k

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

复制代码

编译报如下错误

/ Y6 ]5 A! [! v4 n, n2 {
5 L8 y5 V6 ~" H2 I4 {7 _$ H$ @4 S- z
使用静态的方法创建任务我们需要自己实现函数vApplicationGetTimerTaskMemory()和函数vApplicationGetIdleTaskMemory()。
+ L4 r  ?* p6 z- W7 {; ^" c0 m

1. //空闲任务任务堆栈
   8 s1 F/ A& P2 l9 o
2. static StackType_t IdleTaskStack[configMINIMAL_STACK_SIZE];
   1 `9 i# G& o. `3 t
3. //空闲任务控制块
   
4. static StaticTask_t IdleTaskTCB;
   5 ~) }3 o  \3 n7 M
5. 
   + x# D& q# r* Y" o. i+ H! x% o1 r
6. //定时器服务任务堆栈
   * {! B; H2 s! O, n
7. static StackType_t TimerTaskStack[configTIMER_TASK_STACK_DEPTH];
   
8. //定时器服务任务控制块
   , l) E0 ?1 u! u# z
9. static StaticTask_t TimerTaskTCB;
   
10. 
    
11. //ppxIdleTaskTCBBuffer:任务控制块内存
    
12. //ppxIdleTaskStackBuffer:任务堆栈内存
    
13. //pulIdleTaskStackSize:任务堆栈大小
    
14. void vApplicationGetIdleTaskMemory(StaticTask_t **ppxIdleTaskTCBBuffer,
    ( g3 M! l) F- l3 L7 ^1 m2 p% l% ]
15.                                                                    StackType_t **ppxIdleTaskStackBuffer,
    
16.                                                                    uint32_t *pulIdleTaskStackSize)
    . t+ v+ k% L1 R! z& q
17. {
    / G/ N. W6 Z/ V3 R1 N& l
18.         *ppxIdleTaskTCBBuffer=&IdleTaskTCB;
    2 p- a5 @  [  I: v8 U9 K
19.         *ppxIdleTaskStackBuffer=IdleTaskStack;
    
20.         *pulIdleTaskStackSize=configMINIMAL_STACK_SIZE;
    ' [, s5 [1 f+ x
21. }
    
22. 
    
23. 
    
24. //获取定时器服务任务的任务堆栈和任务控制块内存
    
25. //ppxTimerTaskTCBBuffer:任务控制块内存
    
26. //ppxTimerTaskStackBuffer:任务堆栈内存
    9 V1 z$ L4 @  f
27. //pulTimerTaskStackSize:任务堆栈大小
    
28. void vApplicationGetTimerTaskMemory(StaticTask_t **ppxTimerTaskTCBBuffer,
    $ \* n( r; v$ l2 @. Q( B& R
29.                                                                         StackType_t **ppxTimerTaskStackBuffer,
    ) l8 s2 t) D5 A2 l* s/ Z6 @# y
30.                                                                         uint32_t *pulTimerTaskStackSize)
    $ g9 n/ C5 q+ Z+ Y2 N
31. {
    ) Y0 E2 B. D: D3 Y; W; l7 E
32.         *ppxTimerTaskTCBBuffer=&TimerTaskTCB;
    # }% X4 l& J- j- W) i
33.         *ppxTimerTaskStackBuffer=TimerTaskStack;
    
34.         *pulTimerTaskStackSize=configTIMER_TASK_STACK_DEPTH;
    
35. }
    

复制代码

任务优先级，堆栈大小，任务句柄和任务函数
0 {1 T, F0 ]7 k% C: n, d
2 p, w3 t+ J3 C9 B; c1 \

1. <blockquote>
   

复制代码

5 ]* y9 G( D8 [. J* |5 Hstart_task函数

1. //开始任务任务函数
   
2. void start_task(void *pvParameters)
   
3. {
   
4.     taskENTER_CRITICAL();           //进入临界区
   
5.     //创建TASK1任务
   ( Z4 I$ N# W2 D8 H; p
6.         Task1Task_Handler=xTaskCreateStatic((TaskFunction_t        )task1_task,               
   
7.                                                                                 (const char*         )"task1_task",               
   6 @6 {/ x1 r* ^) u7 Y
8.                                                                                 (uint32_t                 )TASK1_STK_SIZE,        
   + ~- H. I: a6 ^7 L
9.                                                                                 (void*                           )NULL,                                
   5 X1 e$ a1 f8 }* o3 N) s- n
10.                                                                                 (UBaseType_t         )TASK1_TASK_PRIO,         
    $ E# q- Q* r* T, k3 d
11.                                                                                 (StackType_t*   )Task1TaskStack,        
    
12.                                                                                 (StaticTask_t*  )&Task1TaskTCB);        
    ! {- Q  ?9 B4 b+ J' N: r
13.     //创建TASK2任务
    / i$ G& q  y1 b  `2 _% o
14.         Task2Task_Handler=xTaskCreateStatic((TaskFunction_t        )task2_task,               
    & h3 I# D: R, V! a& e' b4 V, w) }
15.                                                                                 (const char*         )"task2_task",               
    6 c; F$ q/ V7 S
16.                                                                                 (uint32_t                 )TASK2_STK_SIZE,        
    4 Y. l; f" j& `" ]$ O, A
17.                                                                                 (void*                           )NULL,                                
    
18.                                                                                 (UBaseType_t         )TASK2_TASK_PRIO,         
    
19.                                                                                 (StackType_t*   )Task2TaskStack,        
    * R$ ~- k& ^. w) b
20.                                                                                 (StaticTask_t*  )&Task2TaskTCB);
    
21.     vTaskDelete(StartTask_Handler); //删除开始任务
    2 ]" ?5 s  Y' g) t
22.     taskEXIT_CRITICAL();            //退出临界区
    
23. }

复制代码

task1_task函数

1. //任务1
   
2. void task1_task(void *pvParameters)
   2 d/ D" t6 E, G2 M1 a
3. {
   ' P9 w5 d) U" r4 t4 X' G* k; ?
4.         u8 task1_num = 0;
   
5.         
   % i7 k+ w" k# v+ n: T9 u
6.         while(1)
   
7.         {
   
8.                 task1_num++;
   
9.                 LED0 = !LED0;
   & M$ E1 Q/ m/ B0 J; j
10.                 printf("任务1已经运行%d次\r\n", task1_num);
    2 R' ^' ]/ a" K; t
11.         
    , R$ c: Q3 u% d6 t: t
12.                 if (5 == task1_num)
    
13.                 {
    % c0 G) ^# X' u9 U, }: _. {
14.                         //任务1删除任务2
    % {7 Z6 }! @- n, p9 u4 X# Y& q
15.                         vTaskDelete(Task2Task_Handler);
    
16.                         printf("任务1删除了任务2\r\n");
    
17.                 }
    
18.                
    
19.                 //延时1秒 1000个时钟节拍
    " |3 y: t+ `9 O( M% o; J: ]; o, _
20.                 vTaskDelay(1000);
    8 p+ i8 P  U$ G
21.         }
    $ e# g5 o7 ]" P# m/ g9 q+ V( \
22. }

复制代码

task2_task函数
  u5 U- W6 s; ^0 e( T
" e2 C9 R& l% z$ ~% m1 `/ u

1. //任务2
   + e- V- |% j2 D6 u% d0 M' I' O4 U
2. void task2_task(void *pvParameters)
   + h3 h7 m- ]3 C( U* K1 U: L
3. {
   
4.         u8 task2_num = 0;
   0 q# L9 T( l6 h& O' I. L
5.         
   
6.         while(1)
   
7.         {
   " u  I0 f1 ?- Z6 v0 {
8.                 task2_num++;
   
9.                 LED1 = !LED1;
   8 m! i  H4 {" l' k8 b8 O
10.                 printf("任务2已经执行了%d次\r\n", task2_num);
    - ^2 W# }7 A, T0 {6 g
11.                
    ) S! L, N2 m0 h$ T# d+ V; O
12.                 //延时1秒 1000个时钟节拍
    # D3 y' {3 v* F; l* x. k& f
13.                 vTaskDelay(1000);
    % Q4 n! ?  b5 F9 I" o5 @, E
14.         }
    ( w4 d) O9 G, y& w
15. }

复制代码

) T9 k: B! y9 m' U6 B' q7 A04. 程序设计
, W+ |% V( E/ r3 |2 |0 y5 p5 `main.c文件
- o! E& K$ N4 ^" O; d2 x

1. #include "sys.h"
   
2. #include "delay.h"
   
3. #include "usart.h"
   7 c! I/ Q# i7 y/ F
4. #include "led.h"
   , C% j' e* r7 ^- w' C
5. #include "FreeRTOS.h"
   - }0 b6 p  d% z* @$ ~- t
6. #include "task.h"
   
7. 
   ' G' O; y! e; A% o) b$ e( }6 m
8. 
   
9. //空闲任务任务堆栈
   
10. static StackType_t IdleTaskStack[configMINIMAL_STACK_SIZE];
    
11. //空闲任务控制块
    1 {6 \& w& G% {
12. static StaticTask_t IdleTaskTCB;
    
13. 
    
14. //定时器服务任务堆栈
    
15. static StackType_t TimerTaskStack[configTIMER_TASK_STACK_DEPTH];
    
16. //定时器服务任务控制块
    
17. static StaticTask_t TimerTaskTCB;
    1 x  V( G; z4 p4 t4 T  E4 i; r
18. 
    3 z" x. W: Y5 m0 `3 u& s
19. //任务优先级
    
20. #define START_TASK_PRIO                1
    ( k' o! {6 s' N7 D# c! x" n
21. //任务堆栈大小        
    
22. #define START_STK_SIZE                 128  
    
23. //任务堆栈
    ; M, r9 R+ U9 Y
24. StackType_t StartTaskStack[START_STK_SIZE];
      h2 V& k9 R( f4 S, `5 _
25. //任务控制块
    6 {+ d& m& D" Y8 H" Q7 L7 z
26. StaticTask_t StartTaskTCB;
    
27. //任务句柄
    0 u+ S. P! E7 q; w- j1 |0 s& D
28. TaskHandle_t StartTask_Handler;
    
29. //任务函数
    
30. void start_task(void *pvParameters);
    6 o5 B1 W3 _; t, i  g2 u5 s5 {4 u
31. 
    
32. //任务优先级
    
33. #define TASK1_TASK_PRIO                2
    
34. //任务堆栈大小        
    9 E- E5 c- O$ p2 H8 q* u
35. #define TASK1_STK_SIZE                 50  
    # d& A0 n$ O, y6 `* j
36. //任务堆栈
    7 C) r8 Z6 G& x8 f' v- d
37. StackType_t Task1TaskStack[TASK1_STK_SIZE];
    + `) H4 d- D6 s+ F1 ?# i: Z; N
38. //任务控制块
    + w/ U. m% r2 \- `) I, ?1 V: |
39. StaticTask_t Task1TaskTCB;
    
40. //任务句柄
    8 l% ^4 z" D4 P" y5 K3 s- p
41. TaskHandle_t Task1Task_Handler;
    6 F2 `1 }; t: G, j: X$ s
42. //任务函数
    
43. void task1_task(void *pvParameters);
    
44. 
    6 m# ^9 }: |- c  G( d
45. //任务优先级
      R: H0 @2 A' N9 G: T
46. #define TASK2_TASK_PRIO                3
    / E& n& B' d4 a
47. //任务堆栈大小        
    
48. #define TASK2_STK_SIZE                 50  
    
49. //任务堆栈
    
50. StackType_t Task2TaskStack[TASK2_STK_SIZE];
    
51. //任务控制块
    + \0 c/ `5 Z; _  n! b
52. StaticTask_t Task2TaskTCB;
    4 A" R+ d& e1 w* K' F
53. //任务句柄
    
54. TaskHandle_t Task2Task_Handler;
    
55. //任务函数
    
56. void task2_task(void *pvParameters);
    
57. 
    
58. 
    $ B* v/ i7 C5 D7 ]3 n
59. //ppxIdleTaskTCBBuffer:任务控制块内存
    
60. //ppxIdleTaskStackBuffer:任务堆栈内存
    
61. //pulIdleTaskStackSize:任务堆栈大小
    1 n* W7 g" ]) a( [0 ]0 f3 @
62. void vApplicationGetIdleTaskMemory(StaticTask_t **ppxIdleTaskTCBBuffer,
    3 Z" X- f* V* Z( h) t; l
63.                                                                    StackType_t **ppxIdleTaskStackBuffer,
    
64.                                                                    uint32_t *pulIdleTaskStackSize)
    
65. {
    
66.         *ppxIdleTaskTCBBuffer=&IdleTaskTCB;
    4 M8 l5 `9 `# P0 r% Y& A# o! v
67.         *ppxIdleTaskStackBuffer=IdleTaskStack;
    
68.         *pulIdleTaskStackSize=configMINIMAL_STACK_SIZE;
    4 d7 o" y8 R/ s/ Y: S  q
69. }
    
70. 
    . \$ j- K; Z7 {# ~3 m2 @6 O- [
71. 
    * ~. u6 i4 }, T% }3 w0 a
72. //获取定时器服务任务的任务堆栈和任务控制块内存
    2 Y) A( @8 |& j) L# C2 Y2 M, l
73. //ppxTimerTaskTCBBuffer:任务控制块内存
    % d) D9 U, N) M3 _; h7 L3 O  @5 z
74. //ppxTimerTaskStackBuffer:任务堆栈内存
    * @. ~+ a: V. E' L5 B# Y) s. ^
75. //pulTimerTaskStackSize:任务堆栈大小
    & u, k: a. p( ]& h2 [
76. void vApplicationGetTimerTaskMemory(StaticTask_t **ppxTimerTaskTCBBuffer,
    
77.                                                                         StackType_t **ppxTimerTaskStackBuffer,
    
78.                                                                         uint32_t *pulTimerTaskStackSize)
    
79. {
    
80.         *ppxTimerTaskTCBBuffer=&TimerTaskTCB;
    8 E# Y& k5 w( Y6 c0 [$ q8 ]
81.         *ppxTimerTaskStackBuffer=TimerTaskStack;
    8 L) o/ N0 F0 S+ D
82.         *pulTimerTaskStackSize=configTIMER_TASK_STACK_DEPTH;
    
83. }
    $ D% M0 H# Z) d! Y6 Q
84. 
    
85. //主函数
    1 L/ w+ r& q: n4 p
86. int main(void)
    
87. {
    ; s5 I) V8 s+ Z4 A0 O9 L8 \
88.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4
    
89.         delay_init(168);                //初始化延时函数
    
90.         uart_init(115200);             //初始化串口
    * [( F0 F2 v% b
91.         LED_Init();                        //初始化LED端口
    
92.         
    
93.     //创建开始任务
    
94.         StartTask_Handler=xTaskCreateStatic((TaskFunction_t        )start_task,                //任务函数
    
95.                                                                                 (const char*         )"start_task",                //任务名称
    + \8 X8 P/ s+ x  W/ l. Z
96.                                                                                 (uint32_t                 )START_STK_SIZE,        //任务堆栈大小
    , Q  [7 s3 `3 [) l3 q1 s% E
97.                                                                                 (void*                           )NULL,                                //传递给任务函数的参数
    " m. v( V: J2 v. V7 ^4 n
98.                                                                                 (UBaseType_t         )START_TASK_PRIO,         //任务优先级
    
99.                                                                                 (StackType_t*   )StartTaskStack,        //任务堆栈
    2 }, A8 ^0 h4 r/ T2 ^: A8 w8 d' o
100.                                                                                 (StaticTask_t*  )&StartTaskTCB);        //任务控制块   
     * b/ a. j; m: g$ \/ ]/ B6 e
101. 
     0 Y0 }5 I- p" ?& A8 u
102.     vTaskStartScheduler();          //开启任务调度
     
103. }
     0 i3 ^% ]; k. F
104. 
     
105. //开始任务任务函数
     + S  }7 _/ Q5 C: }4 f1 @0 c
106. void start_task(void *pvParameters)
       ^* n+ h" b# \0 E+ F
107. {
     4 p5 s5 Q5 }$ ~) I9 Q6 G! G" u
108.     taskENTER_CRITICAL();           //进入临界区
     
109.     //创建TASK1任务
     
110.         Task1Task_Handler=xTaskCreateStatic((TaskFunction_t        )task1_task,               
     - }& l- b: _4 O7 E2 p9 L
111.                                                                                 (const char*         )"task1_task",               
     4 \7 M5 D. {4 R7 b7 J
112.                                                                                 (uint32_t                 )TASK1_STK_SIZE,        
     
113.                                                                                 (void*                           )NULL,                                
     ) r5 ~& _& m. q, ~; t5 T
114.                                                                                 (UBaseType_t         )TASK1_TASK_PRIO,         
     ' g5 {! }" k2 j( z0 N4 a4 a
115.                                                                                 (StackType_t*   )Task1TaskStack,        
     - y5 h' p- {- T8 D3 y
116.                                                                                 (StaticTask_t*  )&Task1TaskTCB);        
     2 N4 T# @* A; n" r' ]3 y3 H7 B6 y
117.     //创建TASK2任务
     3 D0 I# P( ^, K" s! _
118.         Task2Task_Handler=xTaskCreateStatic((TaskFunction_t        )task2_task,               
     
119.                                                                                 (const char*         )"task2_task",               
     
120.                                                                                 (uint32_t                 )TASK2_STK_SIZE,        
     
121.                                                                                 (void*                           )NULL,                                
     * v; f4 l; E/ B8 T" h& ]$ K
122.                                                                                 (UBaseType_t         )TASK2_TASK_PRIO,         
     - r" `/ S: {3 E$ [" c
123.                                                                                 (StackType_t*   )Task2TaskStack,        
     
124.                                                                                 (StaticTask_t*  )&Task2TaskTCB);
     
125.     vTaskDelete(StartTask_Handler); //删除开始任务
     
126.     taskEXIT_CRITICAL();            //退出临界区
     7 w! W; Y3 ^9 h9 D$ h5 |
127. }
     
128. 
     ; d( u4 Y: d2 U
129. //任务1
     
130. void task1_task(void *pvParameters)
     
131. {
     
132.         u8 task1_num = 0;
     
133.         
     - H( O# M  e% S! N2 r8 W  i3 R, U
134.         while(1)
     0 @: b0 u/ h6 R) ^
135.         {
     
136.                 task1_num++;
     1 @% f/ Z6 v& C3 V
137.                 LED0 = !LED0;
     " w8 F2 i0 t! l+ b$ p. L8 R6 J
138.                 printf("任务1已经运行%d次\r\n", task1_num);
     
139.         
     ) m/ Z- y5 N  v
140.                 if (5 == task1_num)
     2 w9 z6 v( b3 f) ]
141.                 {
     
142.                         //任务1删除任务2
     
143.                         vTaskDelete(Task2Task_Handler);
     ( B) m' P- ^" S; a  s# R- x
144.                         printf("任务1删除了任务2\r\n");
     
145.                 }
     0 w' w% _) O4 H$ r; n4 C
146.                
     
147.                 //延时1秒 1000个时钟节拍
     2 N2 ~! v. s" K) K' v
148.                 vTaskDelay(1000);
     0 z( c* x+ _; q/ n1 U( W/ F0 \8 U$ Y
149.         }
     
150. }
     
151. 
     * Z- K. |) e! t  [! g* T: c
152. //任务2
     
153. void task2_task(void *pvParameters)
     / ]( V5 a+ `/ N& j8 |
154. {
     5 A: X, F( r& n
155.         u8 task2_num = 0;
     
156.         
     
157.         while(1)
     4 Z6 b* H# t* Q+ V5 E
158.         {
     0 `5 ]: B+ Y; N
159.                 task2_num++;
     6 t$ V' b1 w  ]! i
160.                 LED1 = !LED1;
     5 j6 X: I. m4 c: \' @) R
161.                 printf("任务2已经执行了%d次\r\n", task2_num);
     
162.                
     
163.                 //延时1秒 1000个时钟节拍
     & Q* `  a* R# [4 `- A" h
164.                 vTaskDelay(1000);
     
165.         }
     & T4 F! ^9 \; a' \) Z* d- Z
166. }
     + Y# z3 T8 i- q

复制代码

05. 结果验证
任务1运行5秒中之后删除了任务2，任务2被删除之后就不会被运行。最后只剩下任务1运行了。
- \' t+ }. D% W, W2 z+ e) x. p
  y6 ?7 e, |& Q" Y* s