01. 概述
FreeRTOS中创建和删除任务API函数的应用。使用静态方法创建任务，任务的堆栈、任务控制块就需要有用户来指定。
! E+ W" h3 c6 t3 ]0 n- R9 c# S
' y2 Q! A- G+ e02. 功能描述
3 `) A5 f; W  M  n$ @4 h  L5 K设计三个任务：start_task、task1_task和task2_task，这三个任务的功能分别如下：
' s0 ~6 ?9 L2 v8 V6 e/ [
& d+ o. N* u5 u# j! |. V$ p; ystart_task: 用来创建其它两个任务。

/ i4 k2 F5 ?) P; k6 b2 A) Qtask1_task: 当此任务运行5秒以后就会调用函数vTaskDelete()删除任务task2_task，该任务控制LED0的闪烁，并且周期性的输出信息到串口中。

/ `% W: Q( `" F+ ^task2_task：普通的应用任务，此任务控制LED1的闪烁，并且周期性的输出信息到串口中。
* R' X- \' v% o" V; @: A, S! W
03. 任务设计
系统设置

在FreeRTOSConfig.h文件中需要将宏configSUPPORT_STATIC_ALLOCATION设置为1.
/ q7 C' V# h8 `1 u% N6 v3 B
" \6 G* y9 }0 s6 ^

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

复制代码

+ \" E9 P' @$ y. ?5 P# v8 E* q编译报如下错误

0 j0 i, d7 Y7 h
7 \1 N1 d) @# s1 E" z/ \- C
! r) H" h. p9 ~. f1 G* T& n使用静态的方法创建任务我们需要自己实现函数vApplicationGetTimerTaskMemory()和函数vApplicationGetIdleTaskMemory()。

' v) o$ D% [. O; ^7 s7 v7 e/ o

1. //空闲任务任务堆栈
   3 L: ^! d' ~6 T) Q4 I! `, @
2. static StackType_t IdleTaskStack[configMINIMAL_STACK_SIZE];
   4 T0 i3 i3 i3 `2 F+ {9 D
3. //空闲任务控制块
   
4. static StaticTask_t IdleTaskTCB;
   + ^6 j+ c. N5 u8 ~9 _  a' a; z. s
5. 
   9 n9 j  ^, D' \2 B# y. J
6. //定时器服务任务堆栈
   & S& [- C4 x! ^3 t  C- i
7. static StackType_t TimerTaskStack[configTIMER_TASK_STACK_DEPTH];
   
8. //定时器服务任务控制块
   ; ^  @# x& X: h( k0 o5 ^
9. static StaticTask_t TimerTaskTCB;
     t0 B7 u5 y0 ]' i
10. 
    
11. //ppxIdleTaskTCBBuffer:任务控制块内存
    % ~& z$ f5 A& J! ?0 Y6 F( D
12. //ppxIdleTaskStackBuffer:任务堆栈内存
    - u& R1 ^: d! A% b: p
13. //pulIdleTaskStackSize:任务堆栈大小
    
14. void vApplicationGetIdleTaskMemory(StaticTask_t **ppxIdleTaskTCBBuffer,
    
15.                                                                    StackType_t **ppxIdleTaskStackBuffer,
    # E6 B. Q& j8 @% l
16.                                                                    uint32_t *pulIdleTaskStackSize)
    * V6 r5 D9 M' ?
17. {
    
18.         *ppxIdleTaskTCBBuffer=&IdleTaskTCB;
    
19.         *ppxIdleTaskStackBuffer=IdleTaskStack;
    3 i6 u7 ?  T- d9 o8 l8 x' X- S
20.         *pulIdleTaskStackSize=configMINIMAL_STACK_SIZE;
    
21. }
    
22. 
    
23. 
    
24. //获取定时器服务任务的任务堆栈和任务控制块内存
    
25. //ppxTimerTaskTCBBuffer:任务控制块内存
    9 o# @* K7 F( q2 R) Y0 Y0 n% P) _9 x2 Q
26. //ppxTimerTaskStackBuffer:任务堆栈内存
    
27. //pulTimerTaskStackSize:任务堆栈大小
    9 a5 B0 G: u, R2 z8 N# [$ J) f
28. void vApplicationGetTimerTaskMemory(StaticTask_t **ppxTimerTaskTCBBuffer,
    6 I: B/ |& K6 `0 G% A2 T
29.                                                                         StackType_t **ppxTimerTaskStackBuffer,
    . A5 w1 o* l* O0 W, r1 p" ?
30.                                                                         uint32_t *pulTimerTaskStackSize)
    / e5 ~3 M: U! P+ l! E
31. {
    
32.         *ppxTimerTaskTCBBuffer=&TimerTaskTCB;
    
33.         *ppxTimerTaskStackBuffer=TimerTaskStack;
    
34.         *pulTimerTaskStackSize=configTIMER_TASK_STACK_DEPTH;
    
35. }
    $ k6 j* A' J" U2 B

复制代码

& K+ a  j$ v' l2 D3 x任务优先级，堆栈大小，任务句柄和任务函数
- @6 t+ w9 j/ z! {; [

1. <blockquote>
   

复制代码

start_task函数

1. //开始任务任务函数
   7 {4 e1 Z+ l/ `+ e" }
2. void start_task(void *pvParameters)
   0 _! _; y4 m: @5 s1 \
3. {
   + A' [) n0 w  d* f
4.     taskENTER_CRITICAL();           //进入临界区
   9 `% V  f' A) N
5.     //创建TASK1任务
   ! |; l2 J& q9 B& |
6.         Task1Task_Handler=xTaskCreateStatic((TaskFunction_t        )task1_task,               
   
7.                                                                                 (const char*         )"task1_task",               
   ; s' }0 M& h7 _: M1 i  c4 \0 w
8.                                                                                 (uint32_t                 )TASK1_STK_SIZE,        
   
9.                                                                                 (void*                           )NULL,                                
   
10.                                                                                 (UBaseType_t         )TASK1_TASK_PRIO,         
    ) `  b/ S- _* v' U8 E
11.                                                                                 (StackType_t*   )Task1TaskStack,        
    4 k9 y$ X: ?8 @3 e
12.                                                                                 (StaticTask_t*  )&Task1TaskTCB);        
    
13.     //创建TASK2任务
    2 Q" d- K) r7 v/ @4 |
14.         Task2Task_Handler=xTaskCreateStatic((TaskFunction_t        )task2_task,               
    
15.                                                                                 (const char*         )"task2_task",               
    + Z. M- y; V1 J6 [
16.                                                                                 (uint32_t                 )TASK2_STK_SIZE,        
    6 x7 x2 N2 M7 G" P
17.                                                                                 (void*                           )NULL,                                
    ; w# ~9 d1 b0 w1 O+ j" K4 j' V
18.                                                                                 (UBaseType_t         )TASK2_TASK_PRIO,         
    
19.                                                                                 (StackType_t*   )Task2TaskStack,        
    - ^+ q( Z2 R" f
20.                                                                                 (StaticTask_t*  )&Task2TaskTCB);
    ' z  ]) U: f" R3 D$ R9 A
21.     vTaskDelete(StartTask_Handler); //删除开始任务
    
22.     taskEXIT_CRITICAL();            //退出临界区
    0 g( M' B1 S- _* n
23. }

复制代码

0 ]/ z% r( V! W$ b) dtask1_task函数
; J; e  [( H% U0 ]1 {* s% E, b3 G9 |
; a1 Q/ k& i2 M' c) m0 e/ Y

1. //任务1
   
2. void task1_task(void *pvParameters)
   
3. {
   & \3 {# ?! w+ \: J4 z
4.         u8 task1_num = 0;
   $ Z" a9 ?' t; \; v
5.         
   
6.         while(1)
   
7.         {
   
8.                 task1_num++;
   
9.                 LED0 = !LED0;
   7 x% v/ C: \8 L) A
10.                 printf("任务1已经运行%d次\r\n", task1_num);
    
11.         
    
12.                 if (5 == task1_num)
    7 e" o7 \6 e! O9 X
13.                 {
    . E3 {0 C. I1 O4 F0 {' ^9 Z
14.                         //任务1删除任务2
    * Y# i: T8 R* @0 u
15.                         vTaskDelete(Task2Task_Handler);
      P" h: \) |, c9 o( D: q
16.                         printf("任务1删除了任务2\r\n");
    
17.                 }
    
18.                
      c/ P$ O8 R% G0 d2 w2 c; X
19.                 //延时1秒 1000个时钟节拍
    
20.                 vTaskDelay(1000);
    
21.         }
    
22. }

复制代码

task2_task函数

  r0 y% I, {' e' |2 g! y

1. //任务2
   
2. void task2_task(void *pvParameters)
   / w9 E8 {7 W9 `
3. {
   8 ?5 O0 V$ Q2 v7 N
4.         u8 task2_num = 0;
   & V& r; N: y3 g$ X# i
5.         
   ( C: I2 i. @( h0 g6 m
6.         while(1)
   3 G4 L% c- P" \+ Z4 E& c/ \
7.         {
   
8.                 task2_num++;
   9 P, X# J1 M9 Y) p
9.                 LED1 = !LED1;
   9 ~( g0 l, H# X. f
10.                 printf("任务2已经执行了%d次\r\n", task2_num);
    + i% e; s1 R; N9 R  }
11.                
    
12.                 //延时1秒 1000个时钟节拍
    
13.                 vTaskDelay(1000);
    6 Q+ ^8 Q3 \9 N* t0 G- W
14.         }
    
15. }

复制代码

' U0 j  N  B0 K3 {4 O7 z' ^04. 程序设计
' q! c, E* k' r$ ^  A! Smain.c文件
% |  X$ `: n# @0 ?: E

1. #include "sys.h"
   
2. #include "delay.h"
   
3. #include "usart.h"
   # y3 D: L0 E( ~  x- S5 W* \2 z
4. #include "led.h"
   8 n; Q0 U4 ]: ?" i
5. #include "FreeRTOS.h"
   
6. #include "task.h"
   - T0 P# X  T0 b' y' z
7. 
   & G6 g- ]( @% ~" W
8. 
   - o+ o7 X8 a  r; ~7 V9 X
9. //空闲任务任务堆栈
   
10. static StackType_t IdleTaskStack[configMINIMAL_STACK_SIZE];
    ( s7 m  m1 ?$ D
11. //空闲任务控制块
    & ^% s8 M5 @+ e
12. static StaticTask_t IdleTaskTCB;
    ( ~) U! V( J7 e& r4 o$ z
13. 
    & [" y8 D  q) ^6 L; C* a
14. //定时器服务任务堆栈
    / q' q2 K0 p# X
15. static StackType_t TimerTaskStack[configTIMER_TASK_STACK_DEPTH];
    
16. //定时器服务任务控制块
    
17. static StaticTask_t TimerTaskTCB;
    
18. 
    6 l6 t& i* ^. F% E$ S5 n# P! d. c0 g
19. //任务优先级
    
20. #define START_TASK_PRIO                1
    " e. O& T$ S! \. m9 R5 j$ g' s% V
21. //任务堆栈大小        
    
22. #define START_STK_SIZE                 128  
    
23. //任务堆栈
    
24. StackType_t StartTaskStack[START_STK_SIZE];
    2 p$ H) o7 h* ?5 Y; r
25. //任务控制块
    ! s% e9 M# \$ v4 m( F! R
26. StaticTask_t StartTaskTCB;
      D" w; ^/ W$ k0 G- v
27. //任务句柄
    . `& M1 V0 S# W0 T9 a0 ^% L
28. TaskHandle_t StartTask_Handler;
    
29. //任务函数
    
30. void start_task(void *pvParameters);
    
31. 
    & ~' T3 q0 R. M4 S' W! z
32. //任务优先级
    
33. #define TASK1_TASK_PRIO                2
    
34. //任务堆栈大小        
    7 I2 b3 ^3 T4 T; D
35. #define TASK1_STK_SIZE                 50  
    1 I, ^: y- H3 N* @
36. //任务堆栈
    
37. StackType_t Task1TaskStack[TASK1_STK_SIZE];
    
38. //任务控制块
    
39. StaticTask_t Task1TaskTCB;
    
40. //任务句柄
    , v! D- R) O4 d1 R& p
41. TaskHandle_t Task1Task_Handler;
    
42. //任务函数
    
43. void task1_task(void *pvParameters);
    
44. 
    $ |" R/ y; i4 [$ n: a7 J
45. //任务优先级
    " N- J- |' {$ g# |
46. #define TASK2_TASK_PRIO                3
    : s# w* o1 ?5 ?& A0 g, _* J. F7 e: |
47. //任务堆栈大小        
    
48. #define TASK2_STK_SIZE                 50  
    ! j5 |, T" ~# `$ a& v6 ^
49. //任务堆栈
    
50. StackType_t Task2TaskStack[TASK2_STK_SIZE];
    
51. //任务控制块
    3 K0 f, G2 N8 q* ?8 s
52. StaticTask_t Task2TaskTCB;
    9 v. m" H" @6 ~' q7 N- e
53. //任务句柄
    
54. TaskHandle_t Task2Task_Handler;
    / n, O% f7 t  b/ v
55. //任务函数
    
56. void task2_task(void *pvParameters);
    
57. 
    ' X! f' }- I- |( N; d  y
58. 
    
59. //ppxIdleTaskTCBBuffer:任务控制块内存
    : r, ?, L. {1 x1 m4 p; P+ V0 F
60. //ppxIdleTaskStackBuffer:任务堆栈内存
    
61. //pulIdleTaskStackSize:任务堆栈大小
    
62. void vApplicationGetIdleTaskMemory(StaticTask_t **ppxIdleTaskTCBBuffer,
    : i: l7 Q& Z% [0 p/ k: C; @1 I( M; W% h
63.                                                                    StackType_t **ppxIdleTaskStackBuffer,
    
64.                                                                    uint32_t *pulIdleTaskStackSize)
    
65. {
    1 p" [' }$ h$ \$ a4 S
66.         *ppxIdleTaskTCBBuffer=&IdleTaskTCB;
    , b  e# i# m9 ^$ L9 U. z
67.         *ppxIdleTaskStackBuffer=IdleTaskStack;
    
68.         *pulIdleTaskStackSize=configMINIMAL_STACK_SIZE;
    + d7 i$ K1 e9 k5 ?( M% z$ w
69. }
    
70. 
    5 z: H0 h; y; I2 h* o
71. 
    8 R* A' l; M  V0 D8 }% Q( P
72. //获取定时器服务任务的任务堆栈和任务控制块内存
    
73. //ppxTimerTaskTCBBuffer:任务控制块内存
    
74. //ppxTimerTaskStackBuffer:任务堆栈内存
    
75. //pulTimerTaskStackSize:任务堆栈大小
    ; R- L1 J2 G5 ]9 O! @7 }
76. void vApplicationGetTimerTaskMemory(StaticTask_t **ppxTimerTaskTCBBuffer,
    * T/ E& X' x6 K0 \
77.                                                                         StackType_t **ppxTimerTaskStackBuffer,
    
78.                                                                         uint32_t *pulTimerTaskStackSize)
    % B" E1 a/ p% `  j
79. {
    
80.         *ppxTimerTaskTCBBuffer=&TimerTaskTCB;
    1 b1 @& l" l* C- `9 b  c. ~
81.         *ppxTimerTaskStackBuffer=TimerTaskStack;
    
82.         *pulTimerTaskStackSize=configTIMER_TASK_STACK_DEPTH;
    
83. }
    8 ]( o9 A  Z9 B/ ?) X5 c
84. 
    - n  p( t9 n7 c: J' t" B+ {- o
85. //主函数
    
86. int main(void)
    
87. {
    6 Z* w) Q0 A( ~2 ?; w
88.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4
    1 d+ }8 k( Q4 R7 ^+ b
89.         delay_init(168);                //初始化延时函数
    
90.         uart_init(115200);             //初始化串口
    5 a2 G- K" P/ n, R
91.         LED_Init();                        //初始化LED端口
    1 E  ]: z$ E  R- @' }3 A
92.         
    4 m! M) S8 y) m7 I- n$ z
93.     //创建开始任务
    
94.         StartTask_Handler=xTaskCreateStatic((TaskFunction_t        )start_task,                //任务函数
    & \. E9 ?1 y7 h5 Z" R
95.                                                                                 (const char*         )"start_task",                //任务名称
    
96.                                                                                 (uint32_t                 )START_STK_SIZE,        //任务堆栈大小
    5 A" P0 y6 x; L: {! x4 j6 F
97.                                                                                 (void*                           )NULL,                                //传递给任务函数的参数
    
98.                                                                                 (UBaseType_t         )START_TASK_PRIO,         //任务优先级
      K: I6 Q. N0 P
99.                                                                                 (StackType_t*   )StartTaskStack,        //任务堆栈
    
100.                                                                                 (StaticTask_t*  )&StartTaskTCB);        //任务控制块   
     
101. 
     
102.     vTaskStartScheduler();          //开启任务调度
     - O! M: w. o) }! k: w
103. }
     " V8 y" {+ A5 i- l1 [2 B
104. 
     % @' S/ u. w1 |0 z
105. //开始任务任务函数
     ! Q, [" L6 w: L! y3 H- _2 P8 |
106. void start_task(void *pvParameters)
     6 t# U, p9 H+ [& A
107. {
     
108.     taskENTER_CRITICAL();           //进入临界区
     
109.     //创建TASK1任务
     ; G% u: I4 r! Y( Q: o7 d
110.         Task1Task_Handler=xTaskCreateStatic((TaskFunction_t        )task1_task,               
     
111.                                                                                 (const char*         )"task1_task",               
     
112.                                                                                 (uint32_t                 )TASK1_STK_SIZE,        
     6 C9 w$ s/ D; X% I
113.                                                                                 (void*                           )NULL,                                
     
114.                                                                                 (UBaseType_t         )TASK1_TASK_PRIO,         
     5 |+ w  b7 w# V0 }* f* o1 A" k
115.                                                                                 (StackType_t*   )Task1TaskStack,        
     
116.                                                                                 (StaticTask_t*  )&Task1TaskTCB);        
     * @' W6 X& E% i5 V9 X% I3 V
117.     //创建TASK2任务
     
118.         Task2Task_Handler=xTaskCreateStatic((TaskFunction_t        )task2_task,               
     
119.                                                                                 (const char*         )"task2_task",               
     " g8 h; L/ P+ w2 y5 L0 g$ E0 G
120.                                                                                 (uint32_t                 )TASK2_STK_SIZE,        
     + |6 O0 s8 V. r! o' o4 S/ h
121.                                                                                 (void*                           )NULL,                                
     
122.                                                                                 (UBaseType_t         )TASK2_TASK_PRIO,         
     $ V( e2 V* L. f+ b+ U* R. S7 h
123.                                                                                 (StackType_t*   )Task2TaskStack,        
     
124.                                                                                 (StaticTask_t*  )&Task2TaskTCB);
     $ C2 N: j7 f* V7 d7 J3 r7 i
125.     vTaskDelete(StartTask_Handler); //删除开始任务
     / F! h( x" m$ E% T
126.     taskEXIT_CRITICAL();            //退出临界区
     + m7 w+ L) h( G/ E: h
127. }
     1 V" u& _3 F  x6 ~' S# ^# M4 i
128. 
     
129. //任务1
     
130. void task1_task(void *pvParameters)
     ' K' u) G# }% V/ P7 P2 x" L1 q9 e
131. {
     
132.         u8 task1_num = 0;
     % z; l( p8 \2 v1 x
133.         
       `0 N0 T; T% x1 \
134.         while(1)
     
135.         {
     
136.                 task1_num++;
     % p' v. D0 u! n& y
137.                 LED0 = !LED0;
     
138.                 printf("任务1已经运行%d次\r\n", task1_num);
     / b5 t# f2 w! h, Y0 w& U$ _! a
139.         
     
140.                 if (5 == task1_num)
     
141.                 {
     " [) D; P$ d# Z" n1 Z& U9 ?
142.                         //任务1删除任务2
     4 G: d. Q+ I% }" p2 o% D
143.                         vTaskDelete(Task2Task_Handler);
     8 e3 s1 ~8 t  ?4 |6 K- Y+ ~. N
144.                         printf("任务1删除了任务2\r\n");
     ( ^, y7 Q' c& K- W- p
145.                 }
     ( w. C6 C, f( Q% A. B+ E4 n6 p
146.                
     0 D& V% ?" M5 _- K3 Y
147.                 //延时1秒 1000个时钟节拍
     0 Z$ A: b3 v3 u3 f$ o' H
148.                 vTaskDelay(1000);
     
149.         }
     
150. }
     
151. 
     
152. //任务2
     
153. void task2_task(void *pvParameters)
     $ o" D1 ^- K  m' C( b; w5 C
154. {
     6 p0 V$ W8 |! n( r9 w% s
155.         u8 task2_num = 0;
     ' J# _9 Y( K! x7 J, J0 b, I
156.         
     
157.         while(1)
     
158.         {
     
159.                 task2_num++;
     ( c* O! l' X, Y: S
160.                 LED1 = !LED1;
     , I* W* t8 x5 S' d" j
161.                 printf("任务2已经执行了%d次\r\n", task2_num);
     ( h9 g( |# I( X1 a
162.                
     2 Y; f0 u5 [9 O/ i
163.                 //延时1秒 1000个时钟节拍
     
164.                 vTaskDelay(1000);
     $ y" m8 x, }( y: O
165.         }
     
166. }
     

复制代码

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


: j2 I7 h7 [# {0 S2 ^2 t& Y; \