01. 概述
FreeRTOS中创建和删除任务API函数的应用。

( Y, m  l; c9 g" B: [: }5 v+ F% ~02. 功能描述
; y: p3 Z5 k. |- J设计三个任务：start_task、task1_task和task2_task，这三个任务的功能分别如下：

. V0 k. Y% \1 p0 wstart_task: 用来创建其它两个任务。
% n5 \" n+ f7 ?: m; O/ L# R1 N
0 c1 `) r1 f9 A6 t2 ptask1_task: 当此任务运行5秒以后就会调用函数vTaskDelete()删除任务task2_task，该任务控制LED0的闪烁，并且周期性的输出信息到串口中。

task2_task：普通的应用任务，此任务控制LED1的闪烁，并且周期性的输出信息到串口中。
- \* `& |2 B. t* L
5 A8 J' c9 r# J# b8 ?- j, n, w03. 任务设计
: M- O/ C' s! f; ]  E% |; y5 E任务优先级，堆栈大小，任务句柄和任务函数
% Z6 O5 Y. c$ K" X

1. //任务优先级
   
2. #define START_TASK_PRIO                1
   
3. //任务堆栈大小        
   ( C) g" Q% O* K; F& x
4. #define START_STK_SIZE                 128  
   
5. //任务句柄
   5 R6 j% H- }9 }& ~
6. TaskHandle_t StartTask_Handler;
   
7. //任务函数
   
8. void start_task(void *pvParameters);
   
9. 
   
10. //任务优先级
    " W+ M/ |9 `& {
11. #define TASK1_TASK_PRIO                2
    
12. //任务堆栈大小        
      W; d2 u2 p4 k' c; U/ j5 P5 L( k
13. #define TASK1_STK_SIZE                 50  
    
14. //任务句柄
    6 M. s5 {. M' @
15. TaskHandle_t Task1Task_Handler;
    ) ?# h& T$ t5 |3 c( s8 {& C$ G9 l
16. //任务函数
    # I5 d4 s! C7 t. }/ z8 q
17. void task1_task(void *pvParameters);
    * F, F$ R) t4 i4 `% P
18. 
    # }! ]- a1 O* _' T, p: N
19. //任务优先级
    # {% _4 T; ]' ]% [# E
20. #define TASK2_TASK_PRIO                3
    # N- B& z# z) U9 G: _/ }
21. //任务堆栈大小        
    
22. #define TASK2_STK_SIZE                 50  
    4 X, j6 z2 I& W6 B- G% y3 D
23. //任务句柄
    ! P6 F" N7 j4 a) C# D3 Y' Y
24. TaskHandle_t Task2Task_Handler;
    # L3 \) Y( G, `2 S2 _1 n
25. //任务函数
    
26. void task2_task(void *pvParameters);

复制代码

) W" p$ [% c/ e* x8 W. q! J4 Ostart_task函数
% I8 i# t3 U- j$ {" o) Z8 e- E
$ a2 K2 T# f9 B  a0 w- \; U

1. //开始任务任务函数
   
2. void start_task(void *pvParameters)
   
3. {
   7 _2 Z% J, }' [8 X* Y
4.     taskENTER_CRITICAL();           //进入临界区
   
5.         
   
6.     //创建TASK1任务
   & y! L+ X: a: u
7.     xTaskCreate((TaskFunction_t )task1_task,            
   
8.                 (const char*    )"task1_task",           
   7 @& m/ A. F* J/ e# S% G
9.                 (uint16_t       )TASK1_STK_SIZE,
   
10.                 (void*          )NULL,                                
    3 |- R8 F8 O$ w8 b
11.                 (UBaseType_t    )TASK1_TASK_PRIO,        
    0 X- s4 J7 a8 N6 E: j# N$ J
12.                 (TaskHandle_t*  )&Task1Task_Handler);   
    
13.     //创建TASK2任务
    
14.     xTaskCreate((TaskFunction_t )task2_task,     
    3 X3 A. k& b/ U( L/ v, \4 h8 }
15.                 (const char*    )"task2_task",   
    7 p5 C% A1 S; D6 V( L* ]
16.                 (uint16_t       )TASK2_STK_SIZE,
    ; s! D0 z+ ]7 U8 `# ^* q0 p
17.                 (void*          )NULL,
    
18.                 (UBaseType_t    )TASK2_TASK_PRIO,
    
19.                 (TaskHandle_t*  )&Task2Task_Handler);        
    7 d3 Z/ B6 Q6 g5 b4 p  x
20. 
    ; `) N8 z8 X* V# n
21.     vTaskDelete(StartTask_Handler); //删除开始任务
    6 C: e  A0 Z# L# J. P+ n
22.                                 
    2 Q8 A3 r: J" S! b; |6 n, S
23.     taskEXIT_CRITICAL();            //退出临界区
    
24. }

复制代码

+ y- m2 \& L/ {% z' o* H6 y  }- Itask1_task函数
. M' d4 S9 p; y
9 |, ]# j: k  J& P4 ~$ |/ N

1. //任务1
   
2. void task1_task(void *pvParameters)
   * v& m+ E9 e4 Y
3. {
   
4.         u8 task1_num = 0;
   
5.         
   7 w( b/ q' Z! x& B
6.         while(1)
   " B' I. ^, m6 ~* k
7.         {
   
8.                 task1_num++;
   
9.                 LED0 = !LED0;
   ( j4 j/ d, r/ a! a& Z% }5 O& e% d
10.                 printf("任务1已经运行%d次\r\n", task1_num);
    
11.         
    6 C5 k0 Q$ F! N3 _7 j! \
12.                 if (5 == task1_num)
    3 K, _# i/ D5 H
13.                 {
      n! _9 z5 y9 B! K  \# ?! T: \; p
14.                         //任务1删除任务2
    ) T3 t' G( J7 I& i
15.                         vTaskDelete(Task2Task_Handler);
    2 F0 n+ K5 r+ q, f& P. B1 E0 u. b
16.                         printf("任务1删除了任务2\r\n");
    $ S- |7 F. J) X+ S6 `* |8 l
17.                 }
    
18.                
    + d- |9 z. v) u! `9 j
19.                 //延时1秒 1000个时钟节拍
    
20.                 vTaskDelay(1000);
    ! n1 N) k0 z+ X* L) ~
21.         }
    
22. }

复制代码

task2_task函数
: r0 o$ D1 \0 V$ |3 S0 g/ t9 _  I

1. //任务2
   
2. void task2_task(void *pvParameters)
   
3. {
   8 ^7 V0 k( b+ Z, z8 y7 m) U
4.         u8 task2_num = 0;
   0 t) g& O. g6 X8 B6 {+ X# O$ o0 @
5.         
   
6.         while(1)
   + ^* Q( D  z  e9 m
7.         {
   
8.                 task2_num++;
   1 s) g+ B9 H1 l7 W2 w3 G
9.                 LED1 = !LED1;
   0 c- v# |& G1 }4 ^: p) w( g
10.                 printf("任务2已经执行了%d次\r\n", task2_num);
    
11.                
    
12.                 //延时1秒 1000个时钟节拍
    
13.                 vTaskDelay(1000);
    
14.         }
    
15. }

复制代码

04. 程序设计
main.c文件

; w1 Y6 C$ ?' y3 Y  B( E3 o

1. #include "sys.h"
   
2. #include "delay.h"
   $ Y6 k) B5 k) s( X
3. #include "usart.h"
   # g, o  i) Q, ]4 D4 d0 |
4. #include "led.h"
   
5. #include "FreeRTOS.h"
   2 ^* Z4 Y9 W" b, w0 o
6. #include "task.h"
   0 r) J; [; I  d6 @; S
7. 
   : h( R9 I( Q. N$ C4 F
8. 
   
9. //任务优先级
   
10. #define START_TASK_PRIO                1
    
11. //任务堆栈大小        
    
12. #define START_STK_SIZE                 128  
    
13. //任务句柄
    + s7 p( ^# }. w$ A# n
14. TaskHandle_t StartTask_Handler;
    
15. //任务函数
    2 g% P; l. F$ P5 _5 ^% F
16. void start_task(void *pvParameters);
    . \% F: ^6 G" }2 F( x3 l: f
17. 
    ' s3 ]5 x% ~5 v6 E; ~7 H! i
18. //任务优先级
    
19. #define TASK1_TASK_PRIO                2
    5 D8 Y1 u9 b2 ?% ?  L6 i" Z, t  J
20. //任务堆栈大小        
    
21. #define TASK1_STK_SIZE                 50  
    
22. //任务句柄
    
23. TaskHandle_t Task1Task_Handler;
    # M! T9 }+ m. w6 Y' m0 }" b
24. //任务函数
    ( k: z" z) V7 J3 q$ J+ `
25. void task1_task(void *pvParameters);
    
26. 
    ) Z4 K* n+ b* o) i- ~; A* M
27. //任务优先级
    / u* H; n- B$ G" H/ d4 H
28. #define TASK2_TASK_PRIO                3
    
29. //任务堆栈大小        
    
30. #define TASK2_STK_SIZE                 50  
    
31. //任务句柄
    
32. TaskHandle_t Task2Task_Handler;
    
33. //任务函数
    8 L9 E, z3 @7 @# O5 o3 \  S
34. void task2_task(void *pvParameters);
    8 Q1 g* S4 ?6 o
35. 
    4 B& b/ \: h# R: E7 Z
36. 
    
37. //主函数
    
38. int main(void)
    5 Q' ~  u4 t" ^) }* Y! e
39. {
    . g) L3 X" k3 v* E# U% V
40.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4
    + i7 m0 f0 F+ N/ W  T/ _7 F! }
41.         delay_init(168);                //初始化延时函数
    
42.         uart_init(115200);             //初始化串口
    
43.         LED_Init();                        //初始化LED端口
    
44.         
    , h! y8 V; ^! c
45.         //创建开始任务
    
46.     xTaskCreate((TaskFunction_t )start_task,            //任务函数
    
47.                 (const char*    )"start_task",          //任务名称
    7 Q% B9 w. U- P1 D
48.                 (uint16_t       )START_STK_SIZE,        //任务堆栈大小
    " i& _1 ]! ^% Q& ^7 {+ y1 A# t: H
49.                 (void*          )NULL,                  //传递给任务函数的参数
    0 `# k, ]0 m0 ~; R5 u
50.                 (UBaseType_t    )START_TASK_PRIO,       //任务优先级
    
51.                 (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    . w5 W8 v& w) c. z8 I" c7 E) A
52.     vTaskStartScheduler();          //开启任务调度
    " i5 _& O* ~' ]8 h. d# S6 X
53. }
    
54. 
    
55. //开始任务任务函数
    
56. void start_task(void *pvParameters)
    
57. {
    
58.     taskENTER_CRITICAL();           //进入临界区
    - O" k& f9 @' |6 p7 N2 j  D" m
59.         
    9 Q+ T, [, n# g7 @2 R7 O
60.     //创建TASK1任务
    
61.     xTaskCreate((TaskFunction_t )task1_task,            
    3 n6 y$ W/ Y6 e
62.                 (const char*    )"task1_task",           
    9 U9 ^; s7 c# r* P1 l" J
63.                 (uint16_t       )TASK1_STK_SIZE,
    
64.                 (void*          )NULL,                                
    4 c" k& J  F. n; X
65.                 (UBaseType_t    )TASK1_TASK_PRIO,        
    " N, B1 j: d+ d& A* m; v
66.                 (TaskHandle_t*  )&Task1Task_Handler);   
    
67.     //创建TASK2任务
    # N8 ~  N. b$ Q, W: ^5 {' I2 b# E
68.     xTaskCreate((TaskFunction_t )task2_task,     
    " d$ A% R+ p! G5 Z
69.                 (const char*    )"task2_task",   
    
70.                 (uint16_t       )TASK2_STK_SIZE,
    
71.                 (void*          )NULL,
    " @" P$ I2 v* ~% ~( G
72.                 (UBaseType_t    )TASK2_TASK_PRIO,
    
73.                 (TaskHandle_t*  )&Task2Task_Handler);        
    
74. 
    
75.     vTaskDelete(StartTask_Handler); //删除开始任务
    6 ~0 `7 k2 e: A* |1 R
76.                                 
    1 r+ h9 B4 k4 L+ a
77.     taskEXIT_CRITICAL();            //退出临界区
    ; _  Z5 b( k; U0 L
78. }
    ) h& ?# Z( k1 j+ K
79. 
    . o5 l6 r) x1 }$ I- W; h
80. //任务1
    
81. void task1_task(void *pvParameters)
    2 O9 Y1 F5 r' G/ Y- G
82. {
    2 d; N! B! ^/ _5 D( D+ H: i9 ?
83.         u8 task1_num = 0;
    
84.         
    % ~/ k: [7 K4 M, D9 ~5 R
85.         while(1)
    
86.         {
    
87.                 task1_num++;
    : S5 l/ v8 {$ y- X4 d# U+ I
88.                 LED0 = !LED0;
    + ^6 z2 H# b( _- t( p5 Y
89.                 printf("任务1已经运行%d次\r\n", task1_num);
    # G1 e& V9 [8 }* }/ I; T# Q7 E
90.         
    0 r' p+ I+ W6 s: J4 Z; f
91.                 if (5 == task1_num)
    
92.                 {
    + Q9 S2 [8 y0 M# n8 x
93.                         //任务1删除任务2
    , r: _# @6 \- K. G( M- A
94.                         vTaskDelete(Task2Task_Handler);
    ) P, d9 A% E2 i
95.                         printf("任务1删除了任务2\r\n");
    , i: [3 B. E. p/ y% S& f
96.                 }
    9 c# S4 t& D7 W7 R4 c
97.                
    : P) m$ d8 H/ t: a% i6 F( O
98.                 //延时1秒 1000个时钟节拍
    
99.                 vTaskDelay(1000);
    
100.         }
     8 n; j6 Q% M8 [) J
101. }
     
102. 
     
103. //任务2
     
104. void task2_task(void *pvParameters)
     
105. {
     7 [7 {  A# M* |. I3 J% g( a
106.         u8 task2_num = 0;
     * ~6 {' ?# a! F4 f3 h. ?
107.         
     " O) p( h+ G' r/ K; c4 d
108.         while(1)
     
109.         {
     
110.                 task2_num++;
     
111.                 LED1 = !LED1;
     : H1 X' S8 @0 n$ W) }6 x' d
112.                 printf("任务2已经执行了%d次\r\n", task2_num);
     - J& P4 L1 i, A5 o/ v# q; _
113.                
     0 H" c: M# p1 {  X) i) l
114.                 //延时1秒 1000个时钟节拍
     
115.                 vTaskDelay(1000);
     
116.         }
     ; N* E5 n: v5 D) A
117. }
     

复制代码

8 l+ x( |  B7 j0 d* b  M! C' }05. 结果验证
任务1运行5秒中之后删除了任务2，任务2被删除之后就不会被运行。最后只剩下任务1运行了。
! M: _% R7 h* f  U; j9 m
0 t2 p8 d9 I* U" X2 ]
7 e' c! k& K" n5 ]