01. 概述
2 u8 b" ~$ L! y! P; Z2 ^9 l1 fFreeRTOS中创建和删除任务API函数的应用。

5 }' h# X0 ^! N3 F. P02. 功能描述
7 h; \9 g) t" f6 T2 k' ^设计三个任务：start_task、task1_task和task2_task，这三个任务的功能分别如下：
: Y- U; a2 A4 b, M9 G2 [# G/ r
start_task: 用来创建其它两个任务。
" m7 O- l7 \: R$ x6 s- J( O# X
task1_task: 当此任务运行5秒以后就会调用函数vTaskDelete()删除任务task2_task，该任务控制LED0的闪烁，并且周期性的输出信息到串口中。

task2_task：普通的应用任务，此任务控制LED1的闪烁，并且周期性的输出信息到串口中。
0 V8 f6 c" s) A9 d7 D$ x  x, w
) W& t8 v1 Y% e03. 任务设计
任务优先级，堆栈大小，任务句柄和任务函数

1. //任务优先级
   
2. #define START_TASK_PRIO                1
   ' Q9 B+ M5 D+ _, C7 W5 h6 r
3. //任务堆栈大小        
   
4. #define START_STK_SIZE                 128  
   
5. //任务句柄
   
6. TaskHandle_t StartTask_Handler;
   
7. //任务函数
   
8. void start_task(void *pvParameters);
   - u% Y8 ?8 ?! @, d' u
9. 
   , n- M8 E+ @# c7 n9 a4 p+ p
10. //任务优先级
    
11. #define TASK1_TASK_PRIO                2
    8 N5 `6 n# a* J' z, ]
12. //任务堆栈大小        
    
13. #define TASK1_STK_SIZE                 50  
    ( i6 ?  l7 v* x
14. //任务句柄
    
15. TaskHandle_t Task1Task_Handler;
    
16. //任务函数
    % C' w. q9 z; w) m' A
17. void task1_task(void *pvParameters);
    4 e& [  U' z. l5 H% a$ P
18. 
    8 o: z& E: k, E. d$ f3 T+ {
19. //任务优先级
    
20. #define TASK2_TASK_PRIO                3
    
21. //任务堆栈大小        
    
22. #define TASK2_STK_SIZE                 50  
    0 k( r9 F) h, ~0 k6 G4 N9 p) }- E* @
23. //任务句柄
    
24. TaskHandle_t Task2Task_Handler;
    " o  n% e, g7 B$ E: i# V
25. //任务函数
    1 b9 v) i9 n( c( E
26. void task2_task(void *pvParameters);

复制代码

start_task函数

1. //开始任务任务函数
   
2. void start_task(void *pvParameters)
   
3. {
   
4.     taskENTER_CRITICAL();           //进入临界区
   
5.         
   # _% E7 i( b3 C
6.     //创建TASK1任务
   
7.     xTaskCreate((TaskFunction_t )task1_task,            
   
8.                 (const char*    )"task1_task",           
   
9.                 (uint16_t       )TASK1_STK_SIZE,
   
10.                 (void*          )NULL,                                
    8 o! b/ X& u2 ]6 O4 E5 q
11.                 (UBaseType_t    )TASK1_TASK_PRIO,        
    
12.                 (TaskHandle_t*  )&Task1Task_Handler);   
    
13.     //创建TASK2任务
    
14.     xTaskCreate((TaskFunction_t )task2_task,     
    
15.                 (const char*    )"task2_task",   
    2 q' @- o' l6 ^  o$ g! r
16.                 (uint16_t       )TASK2_STK_SIZE,
    % R) L8 b! \# P. z' x
17.                 (void*          )NULL,
    & t* H' P- b1 n$ ]
18.                 (UBaseType_t    )TASK2_TASK_PRIO,
    * \' d0 {- R* d
19.                 (TaskHandle_t*  )&Task2Task_Handler);        
    
20. 
    2 _$ a" _6 |/ r% I
21.     vTaskDelete(StartTask_Handler); //删除开始任务
    . l- I9 ]+ Q& k2 g7 o! w6 }
22.                                 
    ( |( v: g: Q& x' p7 P1 d/ t
23.     taskEXIT_CRITICAL();            //退出临界区
    * \% ^) U8 B+ J- Z5 G3 K! V$ ?( f
24. }

复制代码

task1_task函数
& D! t5 `" H2 m( N  Q1 V% F
# Z: |- R8 C. Q  q) l( {7 v

1. //任务1
   4 p6 {* s2 ~: M5 [5 O! f" J
2. void task1_task(void *pvParameters)
   
3. {
   * z6 B9 h2 `3 [- k) R% k" p/ n
4.         u8 task1_num = 0;
   # @' Z/ V$ Q5 b9 ~4 I( J7 q
5.         
   
6.         while(1)
   
7.         {
   5 z' ~: K3 a, x& x
8.                 task1_num++;
   2 z, G  C+ u  K/ N/ b
9.                 LED0 = !LED0;
   # d4 L) ]( g5 a7 w: H+ H
10.                 printf("任务1已经运行%d次\r\n", task1_num);
    6 q: D6 a- D3 K6 I8 {
11.         
    
12.                 if (5 == task1_num)
    8 V2 |+ k' U3 `. ?, n/ l' r1 Y1 o$ ^
13.                 {
    ; d7 v; u. J  F* ]/ \
14.                         //任务1删除任务2
    ) I2 E/ X* H% I+ A
15.                         vTaskDelete(Task2Task_Handler);
    ' p# B, k& @5 g( I9 n
16.                         printf("任务1删除了任务2\r\n");
    + d! ~9 e- |: s$ J: N" n3 o# w
17.                 }
    
18.                
    1 S4 X% ?2 E8 D" k1 l' z
19.                 //延时1秒 1000个时钟节拍
    
20.                 vTaskDelay(1000);
    
21.         }
    
22. }

复制代码

task2_task函数

6 r8 a+ W$ V2 m8 C) z

1. //任务2
   . P( H8 n" t& i5 e: G7 f( ~( s8 c7 v8 K
2. void task2_task(void *pvParameters)
   
3. {
   & t+ ?0 R" u7 X! I7 u3 K
4.         u8 task2_num = 0;
   " T1 S+ f; N4 y. Q. j% R
5.         
   
6.         while(1)
   
7.         {
   1 U  q3 O/ j4 [# f9 X  R6 _
8.                 task2_num++;
   & A4 ~) Z2 C( ?* E/ {
9.                 LED1 = !LED1;
   ) n9 C- r% k, L& O6 Q1 Z; ^
10.                 printf("任务2已经执行了%d次\r\n", task2_num);
    * o; f5 B4 S# C% p6 s" l/ t+ {6 u
11.                
    - P+ Z4 I2 {+ ?+ Y9 x) W+ f4 U
12.                 //延时1秒 1000个时钟节拍
    % V! \3 e" n& K5 J) g  [# m
13.                 vTaskDelay(1000);
    8 Y6 t/ Q1 J- U5 |* e, }, c
14.         }
    
15. }

复制代码

: J) ~" t) g' m5 u* `8 o5 I9 W- [04. 程序设计
5 d2 z3 w+ Z  m+ c, a! wmain.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"
     H9 F- _$ p/ Q& r2 S6 I
7. 
   $ M" s$ A% ~" [0 f! s# z5 b
8. 
   
9. //任务优先级
   
10. #define START_TASK_PRIO                1
    
11. //任务堆栈大小        
    . G& I; K1 s, z4 ~
12. #define START_STK_SIZE                 128  
    
13. //任务句柄
    7 \* g# Z/ _' P' t4 n
14. TaskHandle_t StartTask_Handler;
    
15. //任务函数
    
16. void start_task(void *pvParameters);
    
17. 
    1 R9 |" l6 g9 Y2 F
18. //任务优先级
    2 Y! ?. U: E2 R. U8 ]. L5 i5 K% ^& g
19. #define TASK1_TASK_PRIO                2
    
20. //任务堆栈大小        
    8 v8 E2 x* w/ \- X6 d1 Z
21. #define TASK1_STK_SIZE                 50  
    
22. //任务句柄
    1 V1 X& k$ B) \& f! s3 _+ @
23. TaskHandle_t Task1Task_Handler;
    
24. //任务函数
    
25. void task1_task(void *pvParameters);
    
26. 
    
27. //任务优先级
    0 h0 D/ x( ?) }7 G5 u# |) \
28. #define TASK2_TASK_PRIO                3
    
29. //任务堆栈大小        
    
30. #define TASK2_STK_SIZE                 50  
    
31. //任务句柄
    
32. TaskHandle_t Task2Task_Handler;
    
33. //任务函数
    8 \# t+ g3 I8 j* M6 `: ^
34. void task2_task(void *pvParameters);
    
35. 
    
36. 
    9 l& j. J1 l) a
37. //主函数
    
38. int main(void)
    
39. {
    
40.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4
    
41.         delay_init(168);                //初始化延时函数
    
42.         uart_init(115200);             //初始化串口
    8 W. U' ?7 p* \' o8 b+ u- A
43.         LED_Init();                        //初始化LED端口
    0 T7 T( ?& T* b
44.         
    9 v( q0 U, Y; B. z
45.         //创建开始任务
    
46.     xTaskCreate((TaskFunction_t )start_task,            //任务函数
    
47.                 (const char*    )"start_task",          //任务名称
    " R( {# }" }: Q+ F4 C. X
48.                 (uint16_t       )START_STK_SIZE,        //任务堆栈大小
    # p& w+ P  _1 [# H+ X
49.                 (void*          )NULL,                  //传递给任务函数的参数
    3 r/ m  A& I+ o1 {% I
50.                 (UBaseType_t    )START_TASK_PRIO,       //任务优先级
    - }. I; i0 k( c  f  C* f4 U
51.                 (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    
52.     vTaskStartScheduler();          //开启任务调度
    
53. }
    
54. 
    
55. //开始任务任务函数
    
56. void start_task(void *pvParameters)
    ! @; R8 _; }  W( `
57. {
    
58.     taskENTER_CRITICAL();           //进入临界区
    . l' b# \& k1 g1 ^7 [8 E" a
59.         
    
60.     //创建TASK1任务
    ) T  O$ G( {5 u% W4 r: Z* M7 H
61.     xTaskCreate((TaskFunction_t )task1_task,            
    
62.                 (const char*    )"task1_task",           
    
63.                 (uint16_t       )TASK1_STK_SIZE,
    
64.                 (void*          )NULL,                                
    
65.                 (UBaseType_t    )TASK1_TASK_PRIO,        
    
66.                 (TaskHandle_t*  )&Task1Task_Handler);   
    9 s6 x! u4 a; r5 P
67.     //创建TASK2任务
    3 i- h7 m  a6 o
68.     xTaskCreate((TaskFunction_t )task2_task,     
    
69.                 (const char*    )"task2_task",   
    ( O  d1 H/ [/ O0 s+ O, J
70.                 (uint16_t       )TASK2_STK_SIZE,
    % s8 b* ?8 p  f
71.                 (void*          )NULL,
    
72.                 (UBaseType_t    )TASK2_TASK_PRIO,
    
73.                 (TaskHandle_t*  )&Task2Task_Handler);        
    
74. 
    
75.     vTaskDelete(StartTask_Handler); //删除开始任务
    ) @6 ?2 r/ N. \3 _8 A8 }& a
76.                                 
    ( d* |6 w8 A( R2 ]5 B# c
77.     taskEXIT_CRITICAL();            //退出临界区
    - M* p/ t- A0 G- H0 v( g
78. }
    
79. 
    3 J. ?: k3 c9 `2 b$ r% W
80. //任务1
    5 H! H" J' N) m- f. l" e
81. void task1_task(void *pvParameters)
    " q9 |# k( V! K5 a
82. {
    ; Q( n; I5 k0 z2 Q, l2 D5 v% w
83.         u8 task1_num = 0;
    
84.         
    
85.         while(1)
    $ T. H8 C% z' d5 `1 B' q
86.         {
    : R6 d  @2 A  @4 ^8 j% U
87.                 task1_num++;
    
88.                 LED0 = !LED0;
    - G9 M- {+ {; l: h: l- Z
89.                 printf("任务1已经运行%d次\r\n", task1_num);
    
90.         
    . e: V4 u! W; ^! Z; n3 D/ z) {
91.                 if (5 == task1_num)
    
92.                 {
    
93.                         //任务1删除任务2
    
94.                         vTaskDelete(Task2Task_Handler);
    0 l: x. a$ _+ }" T& h7 o& F
95.                         printf("任务1删除了任务2\r\n");
    
96.                 }
    * P5 s; k) T! C& c1 [; U% s; ^' Z
97.                
    6 E: [) }) W0 x
98.                 //延时1秒 1000个时钟节拍
    
99.                 vTaskDelay(1000);
    
100.         }
     6 n1 o* b2 G7 T7 L
101. }
     ) X' R; r+ }! I- E/ D' x. B0 ]
102. 
     
103. //任务2
     & g  k) F* j5 B( |
104. void task2_task(void *pvParameters)
     
105. {
     
106.         u8 task2_num = 0;
     3 z! K6 F, |6 D2 v+ v% u
107.         
     
108.         while(1)
     ) c6 D6 K+ t9 }: ?
109.         {
     7 r3 m) g6 p; D' u& E- V9 B
110.                 task2_num++;
     
111.                 LED1 = !LED1;
     
112.                 printf("任务2已经执行了%d次\r\n", task2_num);
     + d0 }2 p$ H, M! o6 x
113.                
     5 M+ Z* O' z% Z" u& ?8 [4 g' e
114.                 //延时1秒 1000个时钟节拍
     - N9 V5 _. R& c# k$ X
115.                 vTaskDelay(1000);
     
116.         }
     
117. }
     % Y& x3 R; ^3 B+ V& J

复制代码

05. 结果验证
任务1运行5秒中之后删除了任务2，任务2被删除之后就不会被运行。最后只剩下任务1运行了。
: I$ |, L  [, f: X8 `( q
& w; m7 [4 R$ e. p2 E