FreeRTOS的任务挂起与恢复函数介绍#

一、任务挂起和任务恢复介绍(熟悉)#

1、任务的挂起与恢复的API函数#

答：

挂起：挂起任务类似暂停，可恢复；删除任务，无法恢复，类似“人死两清”。
恢复：恢复被挂起的任务。
“FromISR”：带有FromISR后缀是在中断函数中专用的API函数。

二、任务挂起(熟悉)#

1、任务挂起函数介绍#

答：

任务挂起函数用于挂起任务，使用时需要将将FreeRTOSConfig.h文件中宏INCLUDE_vTaskSuspend配置为1。
无论优先级如何，被挂起的任务都将不再被执行，直到任务被恢复。

注意：当传入的参数是NULL，则代表挂起任务自身(当前正在运行的任务)。

2、任务挂起函数内部实现#

答：

获取所要挂起任务的控制块。（根据任务句柄获取任务控制块，如果任务句柄为NULL，表示挂起任务本身。）
移除所在列表。（将要挂起的任务从相应的状态列表和事件列表中移除。）
插入挂起任务列表。（将待挂起任务的任务状态列表项插入到挂起状态列表末尾。）
判断任务调度器是否运行。（判断任务调度器是否运行，在运行，更新下一次阻塞时间，防止被挂起任务为下一个阻塞超时任务。）
判断待挂起任务是否为当前任务。（如果挂起的是任务自身，且调度器正在运行，需要进行一次任务切换；调度器没有运行，判断挂起任务数是否等于任务总数，是：当前控制块赋值为NULL，否：寻找下一个最高优先级任务。）

三、任务恢复(熟悉)#

1、任务恢复函数介绍(任务中恢复)#

答：

-1762856316134-22.png)

使用该函数时需要将FreeRTOSConfig.h文件中宏INCLUDE_vTaskSuspend配置为1。

注意：任务无论被vTaskSuspend()挂起多少次，只需在任务中调用vTaskResume()恢复一次就能继续运行，且被恢复的任务会进入就绪态。

2、任务恢复函数(任务中恢复)内部实现#

答：

恢复任务不能是正在运行任务。
判断任务是否在挂起列表中。（是：就会将该任务在挂起列表中移除，将该任务添加到就绪列表中。）
判断恢复任务优先级。（判断恢复的任务优先级是否大于当前正在运行的任务，是的话，执行任务切换。）

3、任务恢复函数介绍(中断中恢复)#

答： -1762856392014-24.png)

使用该函数注意要将FreeRTOSConfig.h文件中宏INCLUDE_vTaskSuspend和INCLUDE_xTaskResumeFromISR配置为1。
该函数专用于中断服务函数中，用于解挂被挂起任务。

注意：中断服务程序中要调用freeRTOS的API函数则中断优先级不能高于FreeRTOS所管理的最高优先级（中断优先级需要在5-15这个范围内）。

在函数+解析中解释

4、任务恢复函数(中断中恢复)内部实现#

答：

关闭freertos可管理中断，防止被其他的中断打断，并返回关闭前basepri寄存器的值。
判断是否有挂起任务。
将前面保存的basepri的值，恢复回来。
返回xYieldRequired的值用于决定是否需要进行任务切换。

5、挂起与恢复调度器#

vTaskSuspendAll()：挂起任务调度器，调度器不会进行任务切换，当前任务一直运行。
xTaskResumeAll()：恢复任务调度器，调度器继续任务切换。

FreeRTOS的任务挂起与恢复函数实验#

目标：学会使用FreeRTOS中的任务挂起和恢复相关API函数，vTaskSuspend()、vTaskResume()、xTaskResumeFromISR()
实验设计：
- start_task：创建其他3个任务
- task1：打印Task1 running，同时实现LED每500ms闪烁一次
- task2：打印Task2 running
- task3：判断按键按下，PA0的KEY0按下，挂起task1，按下PA1的KEY1，恢复task1;
- 按下PA15的Key2，在中断中恢复task1(外部中断实现)。

源码：

1
#include "stm32f4xx.h"                  // STM32F4系列微控制器头文件
2
#include "freertos.h"                   // FreeRTOS实时操作系统头文件
3
#include "task.h"                       // FreeRTOS任务管理头文件
4
#include "queue.h"                      // FreeRTOS队列管理头文件
5
#include "usart.h"                      // 串口通信头文件
6

7
// 任务配置宏定义
8
#define START_TASK_STACK_SIZE 128       // 启动任务栈大小（字）
9
#define START_TASK_PRIORITY 2           // 启动任务优先级
10

11

12

13
void DWT_Init(void);
14
void Delay_us(uint32_t us);
15
void Delay_ms(uint32_t ms);
16

17
/**
18
 * @brief LED初始化函数
19
 * 配置GPIOC的Pin13作为LED控制引脚
20
 */
21
void LED_Init(void)
22
{
23
    // 使能GPIOC时钟（AHB1总线）
24
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);
25

26
    // 配置GPIO初始化结构体
27
    GPIO_InitTypeDef GPIO_InitStructure;
28
  GPIO_StructInit(&GPIO_InitStructure);
29
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;        // 选择引脚13
30
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;     // 输出模式
31
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;    // 推挽输出
32
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; // 输出速度50MHz
33
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;  // 无上拉下拉电阻
34
    GPIO_Init(GPIOC, &GPIO_InitStructure);            // 初始化GPIOC
35
}
36

37
void Key_Init(void){
38
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
39
  GPIO_InitTypeDef GPIO_InitStructure;
40
  GPIO_StructInit(&GPIO_InitStructure);
41
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15 |  GPIO_Pin_0 | GPIO_Pin_1;
42
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
43
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
44
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
45
  GPIO_Init(GPIOA, &GPIO_InitStructure);
46
}
47

48
uint8_t Key_GetNum(void)
49
{
50

51
  if (GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0) == 0)
52
  {
53
    vTaskDelay(20);
54
    if(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0) == 0){
55
      return 1;
56
    }
57
  }
58
  else if (GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_1) == 0)
59
  {
60
    vTaskDelay(20);
61
    if(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_1) == 0){
62
      return 2;
63
    }
64
  }
65
  else return 0;
66
}
67

68
void EXTILine15_Init(void){
69
  EXTI_InitTypeDef EXTI_InitStructure;
70
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
71
  SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOA, EXTI_PinSource15);
72

73
  EXTI_InitStructure.EXTI_Line = EXTI_Line15;
74
  EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
75
  EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
76
  EXTI_InitStructure.EXTI_LineCmd = ENABLE;
77
  EXTI_Init(&EXTI_InitStructure);
78

79
  NVIC_SetPriority(EXTI15_10_IRQn, 6);
80
  NVIC_EnableIRQ(EXTI15_10_IRQn);
81
}
82

83

84
// 任务句柄声明（用于引用和管理任务）
85
TaskHandle_t MytaskHandler1;    // 任务1句柄
86
TaskHandle_t MytaskHandler2;    // 任务2句柄
87
TaskHandle_t MytaskHandler3;    // 任务3句柄
88
TaskHandle_t StarttaskHandler;  // 启动任务句柄
89

90

91
/**
92
 * @brief 任务1函数
93
 * 功能：每500个时钟节拍打印"Task1 running"
94
 * @param arg 任务参数（未使用）
95
 */
96
void Task1(void * arg){
97
  uint32_t task1_num = 0;
98
    while(1){
99
        taskENTER_CRITICAL();    // 进入临界区（禁用中断），保护串口输出
100
        printf("Task1 running: %d\r\n", ++task1_num);
101
        taskEXIT_CRITICAL();     // 退出临界区（启用中断）
102
    GPIO_ResetBits(GPIOC, GPIO_Pin_13);
103
        vTaskDelay(500);         // 延迟500个时钟节拍（约500ms，取决于系统时钟配置）
104
    GPIO_SetBits(GPIOC, GPIO_Pin_13);
105
        vTaskDelay(500);         // 延迟500个时钟节拍（约500ms，取决于系统时钟配置）
106
    }
107
}
108

109
/**
110
 * @brief 任务2函数
111
 * 功能：每500个时钟节拍打印"Task2 running"
112
 * @param arg 任务参数（未使用）
113
 */
114
void Task2(void * arg){
115
  uint32_t task2_num = 0;
116
    while(1){
117
        taskENTER_CRITICAL();    // 进入临界区
118
        printf("Task2 running: %d\r\n", ++task2_num);
119
        taskEXIT_CRITICAL();     // 退出临界区
120
        vTaskDelay(1000);         // 延迟500个时钟节拍
121
    }
122
}
123

124
/**
125
 * @brief 任务3函数
126
 * 功能：控制GPIOC Pin13上的LED闪烁（500ms亮，500ms灭）
127
 * @param arg 任务参数（未使用）
128
 */
129
void Task3(void * arg){
130
    while(1){
131
    uint8_t key = 0;
132
    key = Key_GetNum();
133
    printf("key:%d\r\n", key);
134
    if(key == 1){
135
      vTaskSuspend(MytaskHandler1);
136
    }else if(key == 2){
137
      printf("在任务中恢复task1\r\n");
138
      vTaskResume(MytaskHandler1);
139
    }
140
    vTaskDelay(500);
141
    }
142
}
143

144
/**
145
 * @brief 启动任务函数
146
 * 功能：创建其他三个任务后自行删除
147
 * @param arg 任务参数（未使用）
148
 */
149
void Starttask(void * arg){
150
    // 进入临界区保护串口输出
151
    taskENTER_CRITICAL();
152
    printf("Starttask running\r\n");  // 打印启动任务运行信息
153
    taskEXIT_CRITICAL();
154

155
    // 使用动态内存分配方式创建任务1
156
    xTaskCreate(Task1,                        // 任务函数指针
157
               "MyFirstTask",                 // 任务名称（用于调试）
158
               START_TASK_STACK_SIZE,         // 栈大小（字）
159
               NULL,                          // 传递给任务的参数
160
               START_TASK_PRIORITY,           // 任务优先级
161
               &MytaskHandler1);              // 任务句柄指针
162

163
    // 使用动态内存分配方式创建任务2
164
    xTaskCreate(Task2,
165
               "MySecondTask",
166
               START_TASK_STACK_SIZE,
167
               NULL,
168
               START_TASK_PRIORITY,
169
               &MytaskHandler2);
170

171
    // 使用动态内存分配方式创建任务3
172
    xTaskCreate(Task3,
173
               "MyThirdTask",
174
               START_TASK_STACK_SIZE,
175
               NULL,
176
               START_TASK_PRIORITY,
177
               &MytaskHandler3);
178

179
    // 删除当前任务（启动任务），释放其占用的资源
180
    vTaskDelete(NULL);
181
}
182

183
/**
184
 * @brief 主函数
185
 * 程序入口点，初始化硬件并启动RTOS调度器
186
 */
187
int main(void)
188
{
189
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
190
    LED_Init();                     // 初始化LED GPIO引脚
191
  Key_Init();
192
    Usart1_Init(115200);            // 初始化串口1，波特率115200
193
  EXTILine15_Init();
194

195
    // 创建启动任务（使用动态内存分配）
196
    xTaskCreate(Starttask,                  // 任务函数指针
197
               "StartTask",                 // 任务名称
198
               START_TASK_STACK_SIZE,       // 栈大小
199
               NULL,                        // 任务参数
200
               START_TASK_PRIORITY,         // 任务优先级
201
               &StarttaskHandler);          // 任务句柄
202

203
    // 启动FreeRTOS调度器（程序将在此处开始运行任务）
204
    vTaskStartScheduler();
205

206
    // 正常情况下，调度器启动后不会执行到这里
207
    // 如果调度器启动失败，程序将在此处循环
208
    while (1)
209
    {
210
        // 空循环，用于处理调度器启动失败的情况
211
    }
212
}
213

214
void EXTI15_10_IRQHandler(void) {
215
  if(EXTI_GetITStatus(EXTI_Line15) != RESET){
216
    BaseType_t xYieldRequired;
217
    xYieldRequired = xTaskResumeFromISR(MytaskHandler1);
218
    printf("在中断中恢复task1\r\n");
219
    if(xYieldRequired == pdTRUE){
220
      portYIELD_FROM_ISR(xYieldRequired);
221
    }
222
    EXTI_ClearITPendingBit(EXTI_Line15);
223
  }
224

225
}