任务挂起和恢复API函数
, [2 w, \" F5 B0 \- ?2 u% f8 a有时候需要暂停某个任务的运行，过一段时间后再重新运行。这时要使用任务删除和重建的方法的话那么任务中的变量值就丢失了！FreeRTOS提供了任务挂起和恢复函数，可以解决该问题：

; S5 w7 r' ?7 x5 |6 f- K% z
% u# i! V' m7 J& x8 g$ d4 i1.1 函数vTaskSuspend()
  _5 d8 p2 s+ F2 B此函数用于将某个任务设置为挂起状态，进入挂起态的任务永远不会进入运行态。退出挂起态的唯一方法就是调用任务恢复函数vTaskResume()或xTaskResumeFromISR()，函数申明如下：
: E1 Z3 X& c& C4 J

1. void vTaskSuspend( TaskHandle_t  xTaskToSuspend)

复制代码

入口参数：
: @2 Q2 A9 p+ u& @! ZxTaskToSuspend: 要挂起的任务的任务句柄。可通过函数xTaskGetHandle()来根据任务名字获取某个任务的任务句柄。如果参数为NULL表示挂起任务自己。
) n2 j0 q+ g4 G4 o  h3 e6 j/ H返回值：无

1.2 函数vTaskResume()
5 G# ~& r& E+ D将一个任务从挂起态恢复到就绪态，只有通过函数vTaskSuspend()设置为挂起态的任务才可以用vTaskResume()恢复，函数申明如下：

1. void vTaskResume(TaskHandle_t xTaskToResume)

复制代码

入口参数：
xTaskToResume: 要恢复的任务的任务句柄
返回值：无
# Q, t7 i; {  X1 M( [# L1 M; c
1.3 函数xTaskResumeFromISR()
此函数是vTaskResume()中断版本，用于在中断服务函数中恢复一个任务，函数申明如下：

1. BaseType_t xTaskResumeFromISR(TaskHandle_t xTaskToResume)

复制代码

$ `+ f) V$ {, |3 e+ y! P参数：
* Z$ {3 D# t6 y( P! L. I4 AxTaskToResume：要恢复的任务的任务句柄
; I  j% c1 G4 {0 ~& x7 d1 o; s返回值：
pdTRUE：恢复运行的任务的任务优先级等于或高于正在运行的任务，意味着在退出中断服务函数以后必须进行一次上下文切换。
; n- t+ p/ D5 O. p2 Z' CpdFALSE：恢复运行的任务的任务优先级低于当前正在运行的任务，意味着在退出中断服务函数后不需要进行上下文切换。
* `: J0 ]3 U5 [) K$ @/ B. \
2. 任务挂起和恢复实验
2.1 实验目的
) a+ N* T* }0 S& f- ^( d  Q学习vTaskSuspend()、vTaskResume()和xTaskResumeFromISR()函数的用法。

2.2 实验设计
本实验设计4个任务：
start_task：用来创建其他3个任务；
& g% l7 w" O. G- l' [: vkey_task：按键服务任务，检测按键按下的结果，根据不同的按键结果执行不同的操作；
task1_task：应用任务1；
task2_task：应用任务2。
" ]/ O) T# y& {5 e' W战舰v3有4个按键：
8 H! r+ C+ ^+ @  u$ }: sKEY0：中断模式，在中断服务函数中恢复任务2的运行；
KEY1：输入模式，恢复任务1的运行；
KEY2：输入模式，挂起任务2的运行；
) b- q5 i+ V. e* _KEY_UP：输入模式，挂起任务1的运行。
/ q3 p, a1 \4 G
7 a/ y5 k7 O+ L7 R" k  Q5 _2.3 硬件
8 {# ?) R6 l7 O2 l+ N$ C* B! `1）正点原子战舰v3开发板；
2）JLINK仿真器。
2 B5 [, Y0 ~. [6 Z7 ~& J
2.4 代码解读
先看下外部中断exti.c源文件的代码（本人也很少用外部中断，借此机会复**），设置按下KEY0按键触发外部中断，在中断服务函数里恢复任务2功能，具体代码如下：

1. #include "exti.h"
   5 W8 U7 L; m: O
2. #include "led.h"
   " K1 _; V, c. S( u! q- j
3. #include "key.h"
   
4. #include "delay.h"
   
5. #include "FreeRTOS.h"
   % c8 a3 Y0 D1 L7 [4 Q7 I2 n* B) X: E
6. #include "task.h"  
   
7. // 外部中断4服务程序
   
8. void EXTIX_Init(void)
   
9. {
   
10.   EXTI_InitTypeDef EXTI_InitStructure;
    ; X' F# R. [, t4 d7 V) r
11.   NVIC_InitTypeDef NVIC_InitStructure;
    
12.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO,ENABLE);        
    
13.   // GPIOE4 中断线以及中断初始化配置  下降沿触发        
    
14.   GPIO_EXTILineConfig(GPIO_PortSourceGPIOE,GPIO_PinSource4);
    
15.   EXTI_InitStructure.EXTI_Line=EXTI_Line4;
    
16.   EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;        
    
17.   EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
    ' ], ]7 S4 @& `7 U5 H& S6 ?
18.   EXTI_InitStructure.EXTI_LineCmd = ENABLE;
    , \2 z" n$ r8 ^% r+ E' W
19.   EXTI_Init(&EXTI_InitStructure);         
    ! x6 V/ U4 G% T+ p. ^
20.   NVIC_InitStructure.NVIC_IRQChannel = EXTI4_IRQn;                           // 使能按键KEY0所在的外部中断通道
    
21.   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x06; // 抢占优先级6，如果中断服务函数要使用FreeRTOS的API函数，那么中断优先级一定要低于configMAX_SYSCALL_INTERRUPT_PRIORITY!这里设置为6！
    
22.   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x00;                   // 子优先级0
    
23.   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;                           // 使能外部中断通道
    # t: J) O# v6 G' G  q2 }
24.   NVIC_Init(&NVIC_InitStructure);            
    " M! }3 I9 [1 L0 K# f6 v
25. }
    
26. // 外部中断4服务函数
    
27. extern TaskHandle_t Task2Task_Handler;  // 任务句柄
    
28. void EXTI4_IRQHandler(void)
    
29. {
    1 Y  S& ~' M6 C7 \/ ^% u# b
30.         BaseType_t YieldRequired;
    $ K7 K% Y. i8 c5 z( A6 U
31.         delay_xms(20);        // 消抖
    
32.         if(KEY0==0)         
    4 c6 B" b2 b$ P) a$ [( k% e, A
33.         {                                 
    
34.                 YieldRequired=xTaskResumeFromISR(Task2Task_Handler);  // 恢复任务2
    
35.                 printf("恢复任务2的运行!\r\n");
    
36.                 if(YieldRequired==pdTRUE)
    
37.                 {
    $ Q+ v7 o% N5 z) O" E: O- g* x1 f( Q( h# Z
38.                     /* 若函数xTaskResumeFromISR()返回值为pdTRUE，说明要恢复的这个任务的优先级等于或高于正在运行的任务(被中断打断的任务),
    ' w+ |" b: T8 O; P7 s, I
39.                         所以在退出中断的时候一定要进行上下文切换！*/
    % \1 u2 F' x1 [& {! T$ M5 }
40.                         portYIELD_FROM_ISR(YieldRequired);
    
41.                 }
    
42.         }                 
    7 {4 |* [3 s) `" c
43.          EXTI_ClearITPendingBit(EXTI_Line4); // 清除LINE4上的中断标志位  
    
44. }

复制代码

; `- r; q( K; Y+ z' ^# zmain.c文件里的创建的key_task()任务函数，其WKUP按键负责挂起任务1，KEY1按键负责恢复任务1，KEY2按键负责挂起任务2，恢复任务2 的函数在外部中断服务函数里，前面已经看过了。

) g  L  Z! _0 u% S; h+ K. i" }

1. #include "sys.h"
   
2. #include "delay.h"
     q5 Z4 A/ d( x* Z) P
3. #include "usart.h"
   9 R* q+ F! W4 W6 r
4. #include "led.h"
   
5. #include "timer.h"
   $ |( B% B2 u/ C" }1 c' r! \
6. #include "lcd.h"
   
7. #include "key.h"
   
8. #include "exti.h"
   2 o8 F5 c5 p4 m. r, Y7 }
9. #include "FreeRTOS.h"
   
10. #include "task.h"
    
11. #define START_TASK_PRIO                1          // 任务优先级
    # w% G+ w; p1 n4 X; S% z
12. #define START_STK_SIZE                 128        // 任务堆栈大小        
    
13. TaskHandle_t StartTask_Handler;        // 任务句柄
    + V& w6 F: B: e2 h0 `
14. void start_task(void *pvParameters);   // 任务函数
    " \+ v, s1 U4 m$ e- r/ Q
15. #define KEY_TASK_PRIO                2          // 任务优先级
    
16. #define KEY_STK_SIZE                 128        // 任务堆栈大小
    7 w0 Y& }/ L! C0 I4 d6 l# ]) Z
17. TaskHandle_t KeyTask_Handler;          // 任务句柄
    % R2 w: x: _$ H9 U3 T& Z6 v- a
18. void key_task(void *pvParameters);     // 任务函数
    
19. #define TASK1_TASK_PRIO                3          // 任务优先级
    ; R8 U- t* O' K9 Y( u) \# n
20. #define TASK1_STK_SIZE                 128        // 任务堆栈大小
    $ A1 ?0 }, ^" `; U  I
21. TaskHandle_t Task1Task_Handler;        // 任务句柄
    
22. void task1_task(void *pvParameters);   // 任务函数
    3 s/ r: p8 t$ V7 @2 \+ K  e
23. #define TASK2_TASK_PRIO                4          // 任务优先级
    
24. #define TASK2_STK_SIZE                 128        // 任务堆栈大小        
    
25. TaskHandle_t Task2Task_Handler;        // 任务句柄
    ) J$ O6 U9 X4 H+ ~- D4 p, _
26. void task2_task(void *pvParameters);   // 任务函数
    # q( }5 b6 m; D4 Y; F
27. // LCD刷屏时使用的颜色
    
28. int lcd_discolor[14]={WHITE,BLACK,BLUE,BRED,GRED,GBLUE,RED,MAGENTA,GREEN,CYAN,YELLOW,BROWN,BRRED,GRAY};
    9 ^9 G8 l0 Q$ A4 ~6 ~
29. // 主函数
    
30. int main(void)
    
31. {
    / B% P7 O! {& o! g+ {! u3 F: x
32.         NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4); // 设置系统中断优先级分组4         
    * |, ~: N! U3 c9 }: A2 C- }7 l4 i  i
33.         delay_init();                                                        // 延时函数初始化         
    
34.         uart_init(115200);                                                    // 初始化串口
    . ~1 s( T6 K" A" W
35.         LED_Init();                                                                      // 初始化LED
    
36.         KEY_Init();                                                                    // 初始化按键
    - a# Z" A- l* @* @
37.         EXTIX_Init();                                                            // 初始化外部中断
    
38.         LCD_Init();                                                                    // 初始化LCD
    
39.     POINT_COLOR = RED;
    1 \) t8 q; T1 X2 D
40.         LCD_ShowString(30,10,200,16,16,"WarShip v3");        
    
41.         LCD_ShowString(30,30,200,16,16,"FreeRTOS");
    6 S+ ]5 d9 ^+ o, Z* y
42.         LCD_ShowString(30,50,200,16,16,"Task Susp and Resum");
    $ o& _4 [( ~9 N# n* x* b, ?/ I
43.         LCD_ShowString(30,70,200,16,16,"leisure");
    
44.         LCD_ShowString(30,90,200,16,16,"2021/3/14");
    
45.         // 创建开始任务
    
46.     xTaskCreate(        (TaskFunction_t )start_task,            // 任务函数
    ) S) Z) P0 N* h( }4 m
47.                         (const char*    )"start_task",          // 任务名称
    ! E' C, w1 b) ^+ t3 P) ^
48.                         (uint16_t       )START_STK_SIZE,        // 任务堆栈大小
    
49.                         (void*          )NULL,                  // 传递给任务函数的参数
    0 V- H4 r0 m* ^$ |. Q
50.                         (UBaseType_t    )START_TASK_PRIO,       // 任务优先级
    8 t, A$ `+ m; P- [' D7 o1 }2 X. ~" Y
51.                         (TaskHandle_t*  )&StartTask_Handler);   // 任务句柄              
    + b( m0 s! z& P) L. s* W& p
52.     vTaskStartScheduler();                                  // 开启任务调度
    . h/ _0 U5 J1 U) b) `$ J6 w
53. }
    . B7 G) b9 W. i& Y- S
54. // 开始任务任务函数
    
55. void start_task(void *pvParameters)
    
56. {
    
57.   taskENTER_CRITICAL();           // 进入临界区
    
58.   // 创建KEY任务
    
59.   xTaskCreate(        (TaskFunction_t )key_task,            
    
60.                 (const char*    )"key_task",           
      I* k* f+ u1 H' t) P2 {1 Q1 l
61.                 (uint16_t       )KEY_STK_SIZE,        
    
62.                 (void*          )NULL,                  
    6 \- g1 `$ `; K- _+ Q
63.                 (UBaseType_t    )KEY_TASK_PRIO,        
    
64.                 (TaskHandle_t*  )&KeyTask_Handler);  
    
65.   // 创建TASK1任务
    . w/ P; w+ A  T$ b
66.   xTaskCreate(        (TaskFunction_t )task1_task,            
    
67.                 (const char*    )"task1_task",           
    
68.                 (uint16_t       )TASK1_STK_SIZE,        
    , y. K1 R' j  d& J* L$ I
69.                 (void*          )NULL,                  
    6 C; n6 Z9 B- n
70.                 (UBaseType_t    )TASK1_TASK_PRIO,        
    
71.                 (TaskHandle_t*  )&Task1Task_Handler);   
    7 \. g* P1 c8 j9 R9 Z5 y  w) m
72.   // 创建TASK2任务
    
73.   xTaskCreate(        (TaskFunction_t )task2_task,     
    7 g% [3 g& p! i" b% Q. l- ~: S
74.                 (const char*    )"task2_task",   
    
75.                 (uint16_t       )TASK2_STK_SIZE,
    4 E! I4 j5 w# k
76.                 (void*          )NULL,
    
77.                 (UBaseType_t    )TASK2_TASK_PRIO,
    
78.                 (TaskHandle_t*  )&Task2Task_Handler);
    & Q! M$ K) d; \( G
79.   vTaskDelete(StartTask_Handler); // 删除开始任务
    $ m) N, Z+ }, _
80.   taskEXIT_CRITICAL();            // 退出临界区
    
81. }
    + U' J8 ^! f1 e$ H. p" E
82. // key任务函数
    
83. void key_task(void *pvParameters)
    
84. {
    % B( k: ?" H# P4 T/ _2 t6 z
85.         u8 key;
    
86.         while(1)
    5 b# i' Y' L4 a- b* E9 i; i
87.         {
    
88.                 key=KEY_Scan(0);
    
89.                 switch(key)
      z7 l" z& `$ p/ g/ @) T9 \1 V% P
90.                 {
    ( h$ D1 g4 ]* G
91.                         case WKUP_PRES:
    - e  f9 [4 ~$ z' c+ b3 a
92.                                 vTaskSuspend(Task1Task_Handler);  // 调用vTaskSuspend()函数挂起任务1
    : j4 q$ _/ {0 `/ Q( \2 \% E" q! f
93.                                 printf("挂起任务1的运行!\r\n");
    7 y! |8 a; G2 i7 X/ F
94.                                 break;
    5 V8 K7 ~7 X. R$ h- s
95.                         case KEY1_PRES:
    
96.                                 vTaskResume(Task1Task_Handler);          // 调用vTaskResume()函数恢复任务1
    8 P, a& ]/ a4 ?3 p; N" F7 u8 I
97.                                 printf("恢复任务1的运行!\r\n");
    
98.                                 break;
    
99.                         case KEY2_PRES:
    
100.                                 vTaskSuspend(Task2Task_Handler);  // 调用vTaskSuspend()函数挂起任务2
     
101.                                 printf("挂起任务2的运行!\r\n");
     
102.                                 break;
     7 M9 r& H3 O" D& j/ ^, s2 M
103.                 }
     
104.                 vTaskDelay(10);                        // 延时10ms
     9 W; k6 x% B, G) j7 P$ O- x
105.         }
     , `) E& P5 v! O! u: n
106. }
     
107. // task1任务函数，用于观察任务挂起和恢复的过程
     # `& a$ [+ l1 e
108. void task1_task(void *pvParameters)   
     
109. {
     : m/ U3 S. p1 S
110.         u8 task1_num=0;
     
111.         POINT_COLOR = BLACK;
     
112.         LCD_DrawRectangle(5,110,115,314);             // 画一个矩形        
     # l- H( X$ w. b/ ~
113.         LCD_DrawLine(5,130,115,130);                    // 画线
     # K& @+ T5 e& E+ b+ b
114.         POINT_COLOR = BLUE;
     
115.         LCD_ShowString(6,111,110,16,16,"Task1 Run:000");
     ; s% g5 x$ e$ B. \1 X" c
116.         while(1)
     
117.         {
     1 N) S! T( u* a& p% I1 Z
118.                 task1_num++;        
     
119.                 LED0=!LED0;
     
120.                 printf("任务1已经执行：%d次\r\n",task1_num);
     
121.                 LCD_Fill(6,131,114,313,lcd_discolor[task1_num%14]);   // 填充区域
     
122.                 LCD_ShowxNum(86,111,task1_num,3,16,0x80);                  // 显示任务执行次数
     " n5 p1 a  W) o  z
123.         vTaskDelay(1000);                                     // 延时1s，也就是1000个时钟节拍        
     5 ?+ Z, i: I' i5 e
124.         }
     
125. }
     
126. // task2任务函数，用于观察任务挂起和恢复的过程（中断方式）
       i6 M. ]' B9 S; c! `8 }
127. void task2_task(void *pvParameters)
     3 g3 \2 q: `2 i* c
128. {
     9 ?0 p6 O* L/ C- S9 {
129.         u8 task2_num=0;
     
130.         POINT_COLOR = BLACK;
     
131.         LCD_DrawRectangle(125,110,234,314);   // 画一个矩形        
     
132.         LCD_DrawLine(125,130,234,130);                  // 画线
     
133.         POINT_COLOR = BLUE;
     
134.         LCD_ShowString(126,111,110,16,16,"Task2 Run:000");
     $ X3 A- ~# l. m% n- S
135.         while(1)
     
136.         {
     1 @3 K6 ~" T  u" {9 L3 q6 A1 o% b- M
137.                 task2_num++;        
     
138.         LED1=!LED1;
     4 w$ y1 a# G. b/ Z; H) \5 ^& m
139.                 printf("任务2已经执行：%d次\r\n",task2_num);
     
140.                 LCD_ShowxNum(206,111,task2_num,3,16,0x80);                            // 显示任务执行次数
     
141.                 LCD_Fill(126,131,233,313,lcd_discolor[13-task2_num%14]);  // 填充区域
     
142.         vTaskDelay(1000);                                                     // 延时1s，也就是1000个时钟节拍        
     + Q9 R  L3 K2 U
143.         }
     # C1 f. q! Y6 }3 g3 {9 L" ?1 k
144. }

复制代码

2.5 实验结果
' Y( l/ T" z+ e0 \  s7 C如下图所示：
) l1 b" j7 `7 s; x
2 a' M9 v' t; r/ _8 U3 H* _4 _

————————————————
3 o0 t/ Q! d6 W: \6 ~版权声明：天亮继续睡
, Z) F  ?  I6 K8 p- C