01. 概述
& k- v! d. U2 g' I任务挂起和恢复，当某个任务要停止运行一段时间就可以将这个任务挂起，当要重新运行这个任务的话就恢复这个任务的运行。
5 b9 z( M) y4 s
* F. c* V* v  B0 A: @5 k" F. S02. 功能描述
设计三个任务：start_task、task1_task和task2_task，这三个任务的功能分别如下：

start_task: 用来创建其它两个任务。
3 e! i) P# K( e9 m
task1_task: 当此任务运行5秒以后就会调用函数vTaskSuspend()挂起任务task2_task，当此任务运行10秒以后就会调用函数vTaskResume()恢复任务task2_task该任务控制LED0的闪烁，并且周期性的输出信息到串口中。
1 E+ @% R( U, F: W& P9 @
task2_task：普通的应用任务，此任务控制LED1的闪烁，并且周期性的输出信息到串口中。

3 P1 q  |8 P6 O. f9 T' c  {03. 任务设计
# X7 m. P1 C) o; o' D任务优先级，堆栈大小，任务句柄和任务函数
, p  _' x. x7 o, ]* T
6 D! I( e: i% [' m7 j: w2 h2 U& Q0 j

1. //任务优先级
   
2. #define START_TASK_PRIO                1
   : |0 }; S  \: k8 S; m% l8 D
3. //任务堆栈大小        
   7 D, s: ~4 Y, K( ?5 n
4. #define START_STK_SIZE                 128  
   " V2 `0 C* z+ _
5. //任务句柄
   
6. TaskHandle_t StartTask_Handler;
   
7. //任务函数
   
8. void start_task(void *pvParameters);
   ' h% b8 U" o, s4 b- j- b5 k
9. 
   3 I4 R2 d, Y; Z  e
10. //任务优先级
    ! T! J' m  L; ?
11. #define TASK1_TASK_PRIO                2
    8 K9 ]8 J- f7 T" A/ C5 {' D
12. //任务堆栈大小        
    3 x4 _/ d2 W% v! t
13. #define TASK1_STK_SIZE                 50  
    ' ?1 H6 I; D, ^  R
14. //任务句柄
    
15. TaskHandle_t Task1Task_Handler;
    3 A; b- g( s* R. h8 S
16. //任务函数
    / S4 N1 s) r( {/ @; O" z- Q. ?; v2 o
17. void task1_task(void *pvParameters);
    ) C* B, Q; p% o) A! H# c
18. 
    
19. //任务优先级
    
20. #define TASK2_TASK_PRIO                3
    
21. //任务堆栈大小        
    
22. #define TASK2_STK_SIZE                 50  
    
23. //任务句柄
    
24. TaskHandle_t Task2Task_Handler;
    
25. //任务函数
    ! ^( i1 g' d2 A0 @. f7 h: Z
26. void task2_task(void *pvParameters);
    9 g7 @" t( ]& V

复制代码

- J% m& r- F4 A. Xstart_task函数
! V/ e3 q- y, y2 S
" r; c$ y, s( z6 {2 w8 Z  E6 ^' g. H

1. //开始任务任务函数
   
2. void start_task(void *pvParameters)
   ( M: |  I) A% X9 p2 }0 L7 G
3. {
   
4.     taskENTER_CRITICAL();           //进入临界区
   
5.         
   
6.     //创建TASK1任务
   
7.     xTaskCreate((TaskFunction_t )task1_task,            
   5 o( c' u" T; y3 P
8.                 (const char*    )"task1_task",           
   . i# a+ J% r- Z7 |' v! c6 m
9.                 (uint16_t       )TASK1_STK_SIZE,
   
10.                 (void*          )NULL,                                
    
11.                 (UBaseType_t    )TASK1_TASK_PRIO,        
    4 B7 l- |& ]& u: X3 v! ~2 v
12.                 (TaskHandle_t*  )&Task1Task_Handler);   
    
13.     //创建TASK2任务
    9 n2 i8 x$ Z3 b) J0 b( Q; X
14.     xTaskCreate((TaskFunction_t )task2_task,     
    . K" A: u4 D8 j6 d$ _% b2 W
15.                 (const char*    )"task2_task",   
    
16.                 (uint16_t       )TASK2_STK_SIZE,
    8 R! l8 S1 E6 a: B2 L. x
17.                 (void*          )NULL,
    % F# v; b9 V% ]5 e8 L0 ], T2 w, p" E7 K
18.                 (UBaseType_t    )TASK2_TASK_PRIO,
    
19.                 (TaskHandle_t*  )&Task2Task_Handler);        
    & Q( o& y) e( p. _6 H
20. 
    , j4 @% I  ?9 F8 x" m
21.     vTaskDelete(StartTask_Handler); //删除开始任务
    
22.                                 
    ' f: m  v( s; ?& ]
23.     taskEXIT_CRITICAL();            //退出临界区
    ( D  S- V+ t6 L  L1 c  }% B
24. }
    3 C( V1 n- b7 ?  I. i

复制代码

( [' ?1 o3 i9 V0 ftask1_task函数

1. //任务1
   
2. void task1_task(void *pvParameters)
   1 V8 f/ ~4 N$ z) u( B0 p3 ~
3. {
   
4.         u8 task1_num = 0;
     `4 I% E) n& A) ]. @, e: A
5.         
   8 ?# Z2 g7 A! e9 k+ K
6.         while(1)
   
7.         {
   # _/ X7 p  v6 x
8.                 task1_num++;
   / B2 d; }6 J  O! S5 j0 W, H, M
9.                 LED0 = !LED0;
   . a" l+ h- t/ O
10.                 printf("任务1已经运行%d次\r\n", task1_num);
    " B0 f' L  L, ^' H; [  P# z
11.         
    
12.                 if (5 == task1_num)
    , n9 X, `9 J" l4 n
13.                 {
    ' Q" H: [& c" T9 C$ n. J9 S$ k
14.                         //任务1挂起任务2
    
15.                         vTaskSuspend( Task2Task_Handler);
    
16.                         printf("任务1挂起了任务2\r\n");
    ! E: F! `3 k& `$ [
17.                 }
    , I" y# [$ m% B* k  D. ~8 c' P, W) ]
18.                
    : a& b3 @# R1 M* t
19.                 if(10 == task1_num)
    
20.                 {
    # [2 f/ G; \1 G
21.                         //任务1恢复任务2
    
22.                         vTaskResume(Task2Task_Handler);
    
23.                         printf("任务1恢复了任务2\r\n");
    / y1 X' O+ X% Z2 H
24.                 }
    8 U" I, J; f# }% O; o" K+ D9 j5 i
25.                
    1 M1 M- g. v7 d6 y2 d3 F( c
26.                 //延时1秒 1000个时钟节拍
    
27.                 vTaskDelay(1000);
    $ w; J, D8 H" q$ Q6 V8 m
28.         }
    
29. }
    

复制代码

/ m- H4 A/ o( Jtask2_task函数
+ [; J; k5 O* J* z6 N9 @% V
$ x0 y& `) ^/ H

1. //任务2
   
2. void task2_task(void *pvParameters)
   
3. {
   
4.         u8 task2_num = 0;
   
5.         
   
6.         while(1)
   
7.         {
   
8.                 task2_num++;
   , q+ O9 |' C9 V1 r& `
9.                 LED1 = !LED1;
   . b" S+ Y6 H: @( j
10.                 printf("任务2已经执行了%d次\r\n", task2_num);
    ! I. ?1 u. R8 X) x' S  h
11.                
    4 q3 h/ m  ?; b  O3 D& e$ i
12.                 //延时1秒 1000个时钟节拍
    5 y& M8 w( y% l& {* F1 S2 o
13.                 vTaskDelay(1000);
    
14.         }
    6 K! c, D, U/ q
15. }

复制代码

! a1 E6 S! X* Q04. 程序设计
main.c文件
! T* f3 Q; U' M( d# L: t
: I# j& S/ V7 g: M5 v+ c, K6 Q0 J; K

1. #include "sys.h"
   % ?4 {* n, L! W$ b
2. #include "delay.h"
   
3. #include "usart.h"
   $ B" O$ ~1 l2 s" [. L
4. #include "led.h"
   3 ~; ]' O% ]" i0 x8 C( I4 j
5. #include "FreeRTOS.h"
   , c% P. ^1 f0 B  m3 C, o( M2 w
6. #include "task.h"
   
7. 
   * }" f* H) ~9 v3 c# Y5 y
8. 
   
9. //任务优先级
   ( _& I3 k7 f. J" G, {8 g, F/ E
10. #define START_TASK_PRIO                1
    / R# G$ m1 u$ t0 g- t; h
11. //任务堆栈大小        
      ^/ ~1 H9 V9 a- f' }8 p
12. #define START_STK_SIZE                 128  
    
13. //任务句柄
    5 e# j: G( D/ F/ ]+ j
14. TaskHandle_t StartTask_Handler;
    ! T' L# {5 b2 @. H5 S
15. //任务函数
    2 p4 K2 L- r0 L% N  @4 ~
16. void start_task(void *pvParameters);
    
17. 
    ; \7 {- S' K, v! F0 z& z: {( `. g. w
18. //任务优先级
    
19. #define TASK1_TASK_PRIO                2
    
20. //任务堆栈大小        
    
21. #define TASK1_STK_SIZE                 50  
    
22. //任务句柄
    % d, u, ~( N+ I8 v# g
23. TaskHandle_t Task1Task_Handler;
    : B2 @+ ]: _) W$ z+ Y9 K& c
24. //任务函数
    1 a( i* [$ H3 E+ d9 `, V# v. e
25. void task1_task(void *pvParameters);
    
26. 
    6 N+ d* K; X! b
27. //任务优先级
    
28. #define TASK2_TASK_PRIO                3
    
29. //任务堆栈大小        
    
30. #define TASK2_STK_SIZE                 50  
    
31. //任务句柄
    ( g- b# d6 {" V+ I) u3 J
32. TaskHandle_t Task2Task_Handler;
    
33. //任务函数
    
34. void task2_task(void *pvParameters);
    9 d) l, n+ k; V8 C9 s, f
35. 
    
36. 
    ) W6 {' k" c, X7 J+ W: v4 A5 s
37. //主函数
    5 H, n/ W0 I9 `8 i) n  o) ~: S
38. int main(void)
    8 z" I! W; D" j' U$ Y# g
39. {
    $ [. Q2 U1 Z) k2 k
40.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4
    ' ]  y7 s: H- h+ V! s+ m
41.         delay_init(168);                //初始化延时函数
    
42.         uart_init(115200);             //初始化串口
    
43.         LED_Init();                        //初始化LED端口
    : h! O, b& t" G2 j9 Y
44.         
    
45.         //创建开始任务
    
46.     xTaskCreate((TaskFunction_t )start_task,            //任务函数
    * T  L6 L  ~1 ^, H& P
47.                 (const char*    )"start_task",          //任务名称
    / D& K0 D4 A: c* X5 i% G: _. E
48.                 (uint16_t       )START_STK_SIZE,        //任务堆栈大小
    & G% w! a* n* F) e8 q! d8 L3 B4 T# f
49.                 (void*          )NULL,                  //传递给任务函数的参数
    
50.                 (UBaseType_t    )START_TASK_PRIO,       //任务优先级
    
51.                 (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    
52.     vTaskStartScheduler();          //开启任务调度
    
53. }
    4 n5 Z: X1 m2 b6 h
54. 
    
55. //开始任务任务函数
    8 ^& c" O+ A" ^3 N# K7 O( H/ ~0 e
56. void start_task(void *pvParameters)
    
57. {
    ( P! N2 }- C/ n; ~& ]( Z$ o4 A$ C* d
58.     taskENTER_CRITICAL();           //进入临界区
    2 K+ ]& J3 {9 @! Z
59.         
    
60.     //创建TASK1任务
    ' j5 u' Z7 e0 Z' W0 G% K: v  L
61.     xTaskCreate((TaskFunction_t )task1_task,            
    
62.                 (const char*    )"task1_task",           
    / b9 y4 ^. s: H+ \
63.                 (uint16_t       )TASK1_STK_SIZE,
    # d4 g, V& P& K' K$ |, _' ?
64.                 (void*          )NULL,                                
      D# l8 ?! O, s, b
65.                 (UBaseType_t    )TASK1_TASK_PRIO,        
    
66.                 (TaskHandle_t*  )&Task1Task_Handler);   
    0 c) w8 I: s/ |! ]: d
67.     //创建TASK2任务
    
68.     xTaskCreate((TaskFunction_t )task2_task,     
    
69.                 (const char*    )"task2_task",   
    9 C( Z% {( {; D8 R
70.                 (uint16_t       )TASK2_STK_SIZE,
    3 B4 i1 [  L& l
71.                 (void*          )NULL,
    % S: C$ R; X& e2 Y# E
72.                 (UBaseType_t    )TASK2_TASK_PRIO,
    / p5 F0 r: L" V( r' F& }
73.                 (TaskHandle_t*  )&Task2Task_Handler);        
    4 Q' D- B7 i" n! w; m0 j
74. 
    
75.     vTaskDelete(StartTask_Handler); //删除开始任务
    
76.                                 
    # j; @4 n; Z+ Y8 q/ E6 U" F+ H7 Q
77.     taskEXIT_CRITICAL();            //退出临界区
    2 S# s7 E. W* j" r7 f8 r
78. }
    
79. 
    
80. //任务1
    ( K5 R! a: f6 A) a" y. M1 }1 h  {
81. void task1_task(void *pvParameters)
    , `5 Z3 l- [5 z0 ~2 s
82. {
    ; y& \. E, X! s) W- j$ P, S- o
83.         u8 task1_num = 0;
    ( y: \- W- D, L3 \1 _/ d& O
84.         
    
85.         while(1)
    
86.         {
    
87.                 task1_num++;
    ' I- \5 A  ]! i
88.                 LED0 = !LED0;
    0 L. H# o9 Q- K) C
89.                 printf("任务1已经运行%d次\r\n", task1_num);
    
90.         
    ! n: C+ j* q5 Q% f3 `
91.                 if (5 == task1_num)
    # {7 x, b' v9 y5 J( l
92.                 {
    
93.                         //任务1挂起任务2
    % n; E! ?; L$ U( E5 `0 X8 a$ e9 R
94.                         vTaskSuspend( Task2Task_Handler);
    
95.                         printf("任务1挂起了任务2\r\n");
    
96.                 }
    4 v7 {( g0 n' M8 U; V5 Z
97.                
    
98.                 if(10 == task1_num)
    
99.                 {
    ' E' \$ d0 n; E% w2 ]  p
100.                         //任务1恢复任务2
     
101.                         vTaskResume(Task2Task_Handler);
     
102.                         printf("任务1恢复了任务2\r\n");
     & U  }6 D* @8 a- U7 |3 x/ g
103.                 }
     5 D3 Y3 b/ c6 }0 o: z6 J
104.                
     
105.                 //延时1秒 1000个时钟节拍
     
106.                 vTaskDelay(1000);
     * J$ S7 h# I8 n& ]8 |' B
107.         }
     
108. }
     
109. 
     , k! U& E# F$ H
110. //任务2
     . K; B/ t) j. [: t0 n+ P6 `$ o+ Z8 ^
111. void task2_task(void *pvParameters)
     , D, G% Y! ^7 f) l1 P: j( ]
112. {
     " t* v( k% O* G6 Y/ T# j1 R* Q$ ~
113.         u8 task2_num = 0;
     
114.         
     
115.         while(1)
     8 a! h8 k+ x6 A% W* i
116.         {
     0 f8 G. s! k- I! P& }
117.                 task2_num++;
     ' t9 N- c! v7 _3 ~3 ?
118.                 LED1 = !LED1;
     
119.                 printf("任务2已经执行了%d次\r\n", task2_num);
     
120.                
     
121.                 //延时1秒 1000个时钟节拍
     
122.                 vTaskDelay(1000);
     
123.         }
     8 O: L! i3 x# b
124. }

复制代码

05. 执行结果

1. 任务2已经执行了1次
   
2. 任务1已经运行1次
   
3. 任务2已经执行了2次
   
4. 任务1已经运行2次
   9 E% q# t) U: v( _( {
5. 任务2已经执行了3次
   + Z) i" _3 c- u0 J  v5 d
6. 任务1已经运行3次
   7 j  H' c7 v6 c4 Z2 I. q, l. x( g
7. 任务2已经执行了4次
   8 P" G- L$ R, H8 C
8. 任务1已经运行4次
   ; W# d. R' S, P$ j# Y/ x
9. 任务2已经执行了5次
   
10. 任务1已经运行5次
    / q. \+ n: _3 G  N& ?2 u& d  R( G
11. 任务1挂起了任务2
    
12. 任务1已经运行6次
    
13. 任务1已经运行7次
    
14. 任务1已经运行8次
    
15. 任务1已经运行9次
    0 M5 ?% m$ X$ O- [' c9 J
16. 任务1已经运行10次
    - W) {9 u$ g/ x! C0 G/ \
17. 任务2已经执行了6次
    
18. 任务2已经执行了7次
    
19. 任务1已经运行11次
    
20. 任务2已经执行了8次
    # _: s! @8 G. n4 U
21. 
    - Q* D! @+ i/ F  n! y6 v

复制代码

" H  `" s% ?- R7 C