01. 概述
/ T6 q/ e9 |. B4 |# SFreeRTOS中创建和删除任务API函数的应用。使用静态方法创建任务，任务的堆栈、任务控制块就需要有用户来指定。
! k5 V, d/ H1 R3 z% \" G
3 V8 k* {) |8 A$ ]8 I3 B+ e02. 功能描述
设计三个任务：start_task、task1_task和task2_task，这三个任务的功能分别如下：
, z. K) `( O0 n  O4 S1 t
5 `# V" U+ `0 S$ U' sstart_task: 用来创建其它两个任务。
: _& a6 {1 ~  d4 l
task1_task: 当此任务运行5秒以后就会调用函数vTaskDelete()删除任务task2_task，该任务控制LED0的闪烁，并且周期性的输出信息到串口中。
1 k. _$ e2 K# q. t
. g1 C' d% _) _' u% ktask2_task：普通的应用任务，此任务控制LED1的闪烁，并且周期性的输出信息到串口中。

03. 任务设计
系统设置
: n$ f( c, ^! }: F" J( w+ G: I
; |+ I( V9 U! c, k+ h在FreeRTOSConfig.h文件中需要将宏configSUPPORT_STATIC_ALLOCATION设置为1.

, L: L5 x3 X/ L

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

复制代码

编译报如下错误


0 P  E9 L' }* O2 }& F) s. y# r# ?  r
8 q9 |. `5 a6 ]使用静态的方法创建任务我们需要自己实现函数vApplicationGetTimerTaskMemory()和函数vApplicationGetIdleTaskMemory()。

9 t& M* ^8 v& z: V7 X- a' U/ H0 `

1. //空闲任务任务堆栈
   
2. static StackType_t IdleTaskStack[configMINIMAL_STACK_SIZE];
   ( Y- e4 W. H5 G9 F+ U( T& S
3. //空闲任务控制块
   5 c+ X1 Q- P( r# w0 s
4. static StaticTask_t IdleTaskTCB;
   
5. 
   % [5 S$ R# f' O$ S+ G& b
6. //定时器服务任务堆栈
   
7. static StackType_t TimerTaskStack[configTIMER_TASK_STACK_DEPTH];
   * ?% w; t; c4 Y9 F' @; H7 S; q
8. //定时器服务任务控制块
   
9. static StaticTask_t TimerTaskTCB;
   
10. 
    " f' j: n5 P# U+ \! S7 L
11. //ppxIdleTaskTCBBuffer:任务控制块内存
    
12. //ppxIdleTaskStackBuffer:任务堆栈内存
    
13. //pulIdleTaskStackSize:任务堆栈大小
    
14. void vApplicationGetIdleTaskMemory(StaticTask_t **ppxIdleTaskTCBBuffer,
    $ ?5 V, w+ l6 ^, j1 z5 K/ O7 b
15.                                                                    StackType_t **ppxIdleTaskStackBuffer,
    
16.                                                                    uint32_t *pulIdleTaskStackSize)
    
17. {
    
18.         *ppxIdleTaskTCBBuffer=&IdleTaskTCB;
    
19.         *ppxIdleTaskStackBuffer=IdleTaskStack;
    
20.         *pulIdleTaskStackSize=configMINIMAL_STACK_SIZE;
    " M/ u: b" Y0 U9 D9 P% y: [
21. }
    
22. 
    ( R- K- |% c# ^( N1 p7 O) T
23. 
    # T+ f  C9 [/ S& R, z1 B
24. //获取定时器服务任务的任务堆栈和任务控制块内存
    3 g; L( g* j8 L. P$ x
25. //ppxTimerTaskTCBBuffer:任务控制块内存
    
26. //ppxTimerTaskStackBuffer:任务堆栈内存
    
27. //pulTimerTaskStackSize:任务堆栈大小
    
28. void vApplicationGetTimerTaskMemory(StaticTask_t **ppxTimerTaskTCBBuffer,
    
29.                                                                         StackType_t **ppxTimerTaskStackBuffer,
    0 A9 {  ~6 S. ?/ p0 x2 Z2 b( _
30.                                                                         uint32_t *pulTimerTaskStackSize)
      ?6 w6 \3 @! K, [% ]: J& L3 i  V
31. {
    # a/ P" {& ^" X  |
32.         *ppxTimerTaskTCBBuffer=&TimerTaskTCB;
    & p6 p" W1 m, U- ^5 U/ C2 Y
33.         *ppxTimerTaskStackBuffer=TimerTaskStack;
    
34.         *pulTimerTaskStackSize=configTIMER_TASK_STACK_DEPTH;
    8 @' u8 J4 C3 p% I, l$ N
35. }

复制代码

任务优先级，堆栈大小，任务句柄和任务函数
  w; G# n  \, l9 p; s* ^4 Y1 D4 f

1. 
   % O- B" T9 f7 _3 t: I
2. //任务优先级
   
3. #define START_TASK_PRIO                1
   
4. //任务堆栈大小        
   5 B* |! B0 k$ d$ T- c
5. #define START_STK_SIZE                 128  
   
6. //任务堆栈
   . v7 L' h9 ~7 k. u+ R
7. StackType_t StartTaskStack[START_STK_SIZE];
   ! A8 Q1 R1 i; _7 `9 y. V7 O
8. //任务控制块
   4 `5 C& }1 U0 Q4 L' j* i% J. j0 _
9. StaticTask_t StartTaskTCB;
   
10. //任务句柄
    
11. TaskHandle_t StartTask_Handler;
    
12. //任务函数
    7 @2 ]6 O8 M; l" v( R8 h
13. void start_task(void *pvParameters);
    9 d2 u3 E" P7 x. r0 j* T
14. 
    
15. //任务优先级
    
16. #define TASK1_TASK_PRIO                2
    
17. //任务堆栈大小        
    1 ?% o* Q# c' E/ {+ O+ h' y7 P2 d- c
18. #define TASK1_STK_SIZE                 50  
    9 v0 H* E) B9 a. H; x3 E
19. //任务堆栈
    
20. StackType_t Task1TaskStack[TASK1_STK_SIZE];
    5 o7 P7 d  e& H) ~$ r' T
21. //任务控制块
    
22. StaticTask_t Task1TaskTCB;
    $ Q) I) w5 c9 F; K
23. //任务句柄
    0 m+ }& t, F/ m! c, B
24. TaskHandle_t Task1Task_Handler;
    0 N8 A; J# O. o1 N) N0 z7 W. n
25. //任务函数
    
26. void task1_task(void *pvParameters);
    
27. 
    ! r. y* o: b% s6 B
28. //任务优先级
    . f4 g- c6 K" T& c: V  R( G# F/ ^
29. #define TASK2_TASK_PRIO                3
    
30. //任务堆栈大小        
    ; P4 f7 P8 s" w. x1 E/ n$ f
31. #define TASK2_STK_SIZE                 50  
    3 q6 R# l; w+ Y5 x4 i. e
32. //任务堆栈
    6 J7 p+ y$ A) k( T
33. StackType_t Task2TaskStack[TASK2_STK_SIZE];
    
34. //任务控制块
    
35. StaticTask_t Task2TaskTCB;
    
36. //任务句柄
    - I7 T+ |1 J* H
37. TaskHandle_t Task2Task_Handler;
    
38. //任务函数
    
39. void task2_task(void *pvParameters);

复制代码

' h" ?: L2 ~% Z( w  [7 _6 r, Tstart_task函数

7 _8 L2 E  b& O; L6 I: X

1. //开始任务任务函数
   " D, n) s- W2 z' o! |
2. void start_task(void *pvParameters)
   
3. {
   
4.     taskENTER_CRITICAL();           //进入临界区
   : r3 ^: g: t) A, t; J4 }; s; D
5.     //创建TASK1任务
   ( O7 B) w/ s; z( B3 @
6.         Task1Task_Handler=xTaskCreateStatic((TaskFunction_t        )task1_task,               
   0 }4 F8 d: ~; n( y& v: r! M
7.                                                                                 (const char*         )"task1_task",               
   6 Z) L3 \. l3 ?
8.                                                                                 (uint32_t                 )TASK1_STK_SIZE,        
   9 b) p0 r% F# ^
9.                                                                                 (void*                           )NULL,                                
   
10.                                                                                 (UBaseType_t         )TASK1_TASK_PRIO,         
    ! E$ f" a  x" p9 y  Q$ a
11.                                                                                 (StackType_t*   )Task1TaskStack,        
    
12.                                                                                 (StaticTask_t*  )&Task1TaskTCB);        
    
13.     //创建TASK2任务
    * o0 |6 p4 j* ]' V1 A+ |/ A
14.         Task2Task_Handler=xTaskCreateStatic((TaskFunction_t        )task2_task,               
      P+ Z8 A* x1 {1 k7 _) @
15.                                                                                 (const char*         )"task2_task",               
    
16.                                                                                 (uint32_t                 )TASK2_STK_SIZE,        
    . ~7 K2 B' Q/ H& i8 s- }( N- F; Q
17.                                                                                 (void*                           )NULL,                                
    ) H1 Y1 A9 ~- p! f. K; Q4 c( V# N
18.                                                                                 (UBaseType_t         )TASK2_TASK_PRIO,         
    4 R% e' T. J( n) P% h
19.                                                                                 (StackType_t*   )Task2TaskStack,        
    $ y9 y2 U  d* I9 @$ l/ Z
20.                                                                                 (StaticTask_t*  )&Task2TaskTCB);
    
21.     vTaskDelete(StartTask_Handler); //删除开始任务
    ( t" B3 d% w7 e
22.     taskEXIT_CRITICAL();            //退出临界区
    , ?, {/ M) e2 {  h6 g% r9 t: ^
23. }

复制代码

task1_task函数
) v" L) d+ l0 t* D- ?3 y- g

1. //任务1
   
2. void task1_task(void *pvParameters)
   
3. {
   ! Z- O0 a# Y; X; L
4.         u8 task1_num = 0;
   . @0 W  e( Q% d- ?" n
5.         
   
6.         while(1)
   8 l: T6 _' i" g  j% d
7.         {
   
8.                 task1_num++;
   
9.                 LED0 = !LED0;
   : W  ~) z0 w" h0 F1 M9 ]7 m
10.                 printf("任务1已经运行%d次\r\n", task1_num);
    
11.         
    + P/ g5 n% l  p) j. f, r* b
12.                 if (5 == task1_num)
    2 Y" z1 r  ^  y, A$ \; S
13.                 {
    % }+ y" B! A" D) I* Q- [
14.                         //任务1删除任务2
    
15.                         vTaskDelete(Task2Task_Handler);
    ) p- p- }% [8 I1 `3 A
16.                         printf("任务1删除了任务2\r\n");
    8 ]- r( `* u6 K. f5 T
17.                 }
    
18.                
    4 v$ X3 M5 l+ x) a$ U7 {$ t7 Q
19.                 //延时1秒 1000个时钟节拍
    ! F) w, X9 `$ r; J) [4 b
20.                 vTaskDelay(1000);
    
21.         }
    
22. }

复制代码

2 O) n- z$ t. F, C+ }/ \) ~. etask2_task函数

; U+ b( W: `/ U/ X; J; @

1. //任务2
   5 E. T: ^+ K0 z  S
2. void task2_task(void *pvParameters)
   " i$ ]5 u  H4 y8 o7 n3 V
3. {
   ! t: d0 G7 l- L( k: E: k6 `. x
4.         u8 task2_num = 0;
   # E* @/ t6 @2 l& ]! z: `% e
5.         
   % N: O7 x& V- a5 q, y
6.         while(1)
   & K7 |- @: S! M% }: ^- C2 V
7.         {
   % R) {: d1 d' F: \) o
8.                 task2_num++;
   " J) e' E. j- i8 D
9.                 LED1 = !LED1;
   
10.                 printf("任务2已经执行了%d次\r\n", task2_num);
    
11.                
    
12.                 //延时1秒 1000个时钟节拍
    0 N2 L9 i- p  e  M+ k+ g
13.                 vTaskDelay(1000);
    
14.         }
    " V( L# E" i; P" A2 P. S$ z9 K
15. }

复制代码

04. 程序设计
2 I; M7 M* x2 w4 {8 Emain.c文件

5 }3 d$ O8 Q  d8 U

1. #include "sys.h"
   
2. #include "delay.h"
   
3. #include "usart.h"
   
4. #include "led.h"
   * \) i8 e' c2 l9 u3 y& E  H
5. #include "FreeRTOS.h"
   
6. #include "task.h"
   
7. 
   
8. 
   
9. //空闲任务任务堆栈
   $ g& f; |4 V; q! @/ c
10. static StackType_t IdleTaskStack[configMINIMAL_STACK_SIZE];
    ( [( i+ [& o( W. x8 L
11. //空闲任务控制块
    ' O4 \/ l. N( D$ a4 C3 @4 R  c
12. static StaticTask_t IdleTaskTCB;
    
13. 
    
14. //定时器服务任务堆栈
    
15. static StackType_t TimerTaskStack[configTIMER_TASK_STACK_DEPTH];
    8 ~  b0 g: c' v8 b7 }$ t# d/ x
16. //定时器服务任务控制块
    & j/ E& j: y4 {; @& d( o
17. static StaticTask_t TimerTaskTCB;
    
18. 
    1 O6 C6 P1 @6 i+ f! k, ?
19. //任务优先级
    $ L' v& g6 G- \
20. #define START_TASK_PRIO                1
    
21. //任务堆栈大小        
    5 i( B7 w$ c! E/ J7 R
22. #define START_STK_SIZE                 128  
    
23. //任务堆栈
    
24. StackType_t StartTaskStack[START_STK_SIZE];
    
25. //任务控制块
    9 g  ^* ?8 o8 U# {! e7 z9 O: Q) C9 ^
26. StaticTask_t StartTaskTCB;
    
27. //任务句柄
    8 U) W5 I# S% {' x" S& G
28. TaskHandle_t StartTask_Handler;
    
29. //任务函数
    
30. void start_task(void *pvParameters);
    0 c, c: ?8 J; r. L" f
31. 
    
32. //任务优先级
    0 r4 w0 A( p4 l" A9 i/ U" i
33. #define TASK1_TASK_PRIO                2
    
34. //任务堆栈大小        
    ( o  l) e+ V! ^* F" E3 ]6 K0 _
35. #define TASK1_STK_SIZE                 50  
    
36. //任务堆栈
    / b" Z. w2 P. i. H5 [- Z! O
37. StackType_t Task1TaskStack[TASK1_STK_SIZE];
    / r! L- S* O+ K2 `$ N% k+ A
38. //任务控制块
    
39. StaticTask_t Task1TaskTCB;
    ; F% r# T: @  f! C
40. //任务句柄
    7 ?' q3 @) t% B( {, A& v' ?3 B
41. TaskHandle_t Task1Task_Handler;
    
42. //任务函数
      u" \  y6 J% k* E9 Q
43. void task1_task(void *pvParameters);
    
44. 
    
45. //任务优先级
    ( f6 ]* W/ e2 L8 e4 L8 J  t) b
46. #define TASK2_TASK_PRIO                3
    6 Z' C0 I$ F, A% [
47. //任务堆栈大小        
    
48. #define TASK2_STK_SIZE                 50  
    ) _  f0 }! B8 s8 }
49. //任务堆栈
    " J/ L2 _2 n. g6 y6 }. M" g+ N6 c2 j8 [
50. StackType_t Task2TaskStack[TASK2_STK_SIZE];
    
51. //任务控制块
    ' b$ W6 s$ u# s" G9 J- H$ S
52. StaticTask_t Task2TaskTCB;
    6 V$ C1 ^) g1 A3 a* s
53. //任务句柄
    
54. TaskHandle_t Task2Task_Handler;
    
55. //任务函数
    5 C$ Q- @) I3 E
56. void task2_task(void *pvParameters);
    
57. 
    ( Y3 M3 [, H( s) j' \. A
58. 
    
59. //ppxIdleTaskTCBBuffer:任务控制块内存
    
60. //ppxIdleTaskStackBuffer:任务堆栈内存
    
61. //pulIdleTaskStackSize:任务堆栈大小
    $ i3 f5 ?6 D: i2 R% K
62. void vApplicationGetIdleTaskMemory(StaticTask_t **ppxIdleTaskTCBBuffer,
    
63.                                                                    StackType_t **ppxIdleTaskStackBuffer,
    7 [& _. R' y! w( X& b- o% d
64.                                                                    uint32_t *pulIdleTaskStackSize)
    ; ~: ~- p( ?! m7 Q0 H% u) T
65. {
    7 F' A0 K  [! V4 k
66.         *ppxIdleTaskTCBBuffer=&IdleTaskTCB;
    , p% T/ A0 P( U0 ~
67.         *ppxIdleTaskStackBuffer=IdleTaskStack;
    * ~3 }+ Q* [: _8 w2 W8 `( F
68.         *pulIdleTaskStackSize=configMINIMAL_STACK_SIZE;
    + n$ U  Q3 `& L( T
69. }
    
70. 
    
71. 
    
72. //获取定时器服务任务的任务堆栈和任务控制块内存
    # R, Y1 `$ {( `; @
73. //ppxTimerTaskTCBBuffer:任务控制块内存
    7 ~/ O, o; s* q
74. //ppxTimerTaskStackBuffer:任务堆栈内存
    7 O# y+ i5 p7 E" e
75. //pulTimerTaskStackSize:任务堆栈大小
    
76. void vApplicationGetTimerTaskMemory(StaticTask_t **ppxTimerTaskTCBBuffer,
    
77.                                                                         StackType_t **ppxTimerTaskStackBuffer,
    . z' K* p. @* ~6 G1 K4 v
78.                                                                         uint32_t *pulTimerTaskStackSize)
    . P8 p$ c& w- j
79. {
    
80.         *ppxTimerTaskTCBBuffer=&TimerTaskTCB;
    
81.         *ppxTimerTaskStackBuffer=TimerTaskStack;
    ! Y$ H0 @% s. F8 l4 t+ G" D! {" t
82.         *pulTimerTaskStackSize=configTIMER_TASK_STACK_DEPTH;
    
83. }
    7 g+ e% _8 i+ n
84. 
    
85. //主函数
    
86. int main(void)
    
87. {
    
88.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4
    
89.         delay_init(168);                //初始化延时函数
    ; P0 N. u7 k8 o% M2 v3 C# Q- A- {
90.         uart_init(115200);             //初始化串口
    " r5 X) g0 V0 z$ _5 g- k- |
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,                                //传递给任务函数的参数
    5 U/ n- O0 _9 P( ?+ d9 b! l5 e. o7 B
98.                                                                                 (UBaseType_t         )START_TASK_PRIO,         //任务优先级
    3 B/ N3 t" |" A3 F, N
99.                                                                                 (StackType_t*   )StartTaskStack,        //任务堆栈
    4 H7 @8 R9 K* b
100.                                                                                 (StaticTask_t*  )&StartTaskTCB);        //任务控制块   
     
101. 
     
102.     vTaskStartScheduler();          //开启任务调度
     
103. }
     
104. 
     
105. //开始任务任务函数
     5 |# {0 m. K) e
106. void start_task(void *pvParameters)
     
107. {
     + R' N* |7 v, B# [* w( M  P( h1 w
108.     taskENTER_CRITICAL();           //进入临界区
     
109.     //创建TASK1任务
     & u+ g5 T" _' N" V% j" |# P
110.         Task1Task_Handler=xTaskCreateStatic((TaskFunction_t        )task1_task,               
     
111.                                                                                 (const char*         )"task1_task",               
     
112.                                                                                 (uint32_t                 )TASK1_STK_SIZE,        
     $ n# X0 G6 Y) Q2 }7 Q
113.                                                                                 (void*                           )NULL,                                
     
114.                                                                                 (UBaseType_t         )TASK1_TASK_PRIO,         
     
115.                                                                                 (StackType_t*   )Task1TaskStack,        
     
116.                                                                                 (StaticTask_t*  )&Task1TaskTCB);        
     7 t: O% P# i. k$ }+ B- f0 V
117.     //创建TASK2任务
     5 I3 G& f5 Z1 x" R+ ?. Z
118.         Task2Task_Handler=xTaskCreateStatic((TaskFunction_t        )task2_task,               
     
119.                                                                                 (const char*         )"task2_task",               
     ; w/ \+ k2 L0 q+ {* i! a
120.                                                                                 (uint32_t                 )TASK2_STK_SIZE,        
     
121.                                                                                 (void*                           )NULL,                                
     # H. b6 ]3 Z* K( C% C$ v
122.                                                                                 (UBaseType_t         )TASK2_TASK_PRIO,         
     
123.                                                                                 (StackType_t*   )Task2TaskStack,        
     
124.                                                                                 (StaticTask_t*  )&Task2TaskTCB);
     
125.     vTaskDelete(StartTask_Handler); //删除开始任务
     : _8 O6 f: ?$ _6 |  z% `$ M. X
126.     taskEXIT_CRITICAL();            //退出临界区
     : i# ?5 y+ {; Z
127. }
     
128. 
     + m; N" [- _  H8 x. ]+ Z# v
129. //任务1
     
130. void task1_task(void *pvParameters)
     9 F5 u. \" Y- W* B" V
131. {
     
132.         u8 task1_num = 0;
     - U6 U; \/ K% n7 E- C3 p5 p$ X8 x1 v
133.         
     # P: }5 g* l8 h4 G! H+ r
134.         while(1)
     6 \. ]+ B& u* s7 d2 \% i; |2 G7 h
135.         {
     3 {9 W8 Y- w3 Q, N- T2 u* E; _
136.                 task1_num++;
     
137.                 LED0 = !LED0;
     5 p6 v( U2 T' O; x
138.                 printf("任务1已经运行%d次\r\n", task1_num);
     
139.         
     2 o4 W' l; v; F" t- f: G
140.                 if (5 == task1_num)
     0 d3 }' `! r9 B5 j
141.                 {
     4 }5 R+ a- V$ v* C- j* s, U
142.                         //任务1删除任务2
     
143.                         vTaskDelete(Task2Task_Handler);
     - E2 l- W1 c# ?- M/ X4 D. D5 R
144.                         printf("任务1删除了任务2\r\n");
     - u7 ^$ G, c* l! d$ A8 R
145.                 }
     4 D2 B" G# g' I; x% h& \& ~
146.                
       X. E. r* e! e6 M6 z( r
147.                 //延时1秒 1000个时钟节拍
     
148.                 vTaskDelay(1000);
     
149.         }
     6 n4 t9 O# j2 |  K# P% L' c! I
150. }
     3 y( v$ H: i' e
151. 
     . J( r! V* {& x4 [+ U
152. //任务2
     
153. void task2_task(void *pvParameters)
     5 w( W- \/ n' |  d) V9 ?
154. {
     
155.         u8 task2_num = 0;
     
156.         
     
157.         while(1)
     ; t* p- ?% J1 w4 ]4 k
158.         {
     
159.                 task2_num++;
     ! C2 O. N' _' q' P
160.                 LED1 = !LED1;
     - O  L& B; b8 x
161.                 printf("任务2已经执行了%d次\r\n", task2_num);
     5 E2 ?3 z. v$ X5 U) x# I
162.                
     
163.                 //延时1秒 1000个时钟节拍
     5 p7 f: `. U! }3 D  T. r  R( r; a
164.                 vTaskDelay(1000);
     
165.         }
     
166. }
     : Z* D0 I9 I- z+ ~& _- X: g

复制代码

05. 结果验证
. m/ T& p: N; J: k! m! b任务1运行5秒中之后删除了任务2，任务2被删除之后就不会被运行。最后只剩下任务1运行了。


+ Z9 F2 o- E8 \6 b6 G' P- J