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
/*uxTaskGetStackHighWaterMark()获取指定任务的任务栈的历史剩余最小值，根据这个结果适当调整启动任务的大小*/
10

11
#define START_TASK_PRIORITY 2           // 启动任务优先级
12

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

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

32
// 任务句柄声明（用于引用和管理任务）
33
TaskHandle_t MytaskHandler1;    // 任务1句柄
34
TaskHandle_t MytaskHandler2;    // 任务2句柄
35
TaskHandle_t MytaskHandler3;    // 任务3句柄
36
TaskHandle_t StarttaskHandler;  // 启动任务句柄
37

38
/**
39
 * @brief 任务1函数
40
 * 功能：每500个时钟节拍打印"Task1 running"
41
 * @param arg 任务参数（未使用）
42
 */
43
void Task1(void * arg){
44
    while(1){
45
        taskENTER_CRITICAL();    // 进入临界区（禁用中断），保护串口输出
46
        printf("Task1 running\r\n");
47
        taskEXIT_CRITICAL();     // 退出临界区（启用中断）
48
        vTaskDelay(500);         // 延迟500个时钟节拍（约500ms，取决于系统时钟配置）
49
    }
50
}
51

52
/**
53
 * @brief 任务2函数
54
 * 功能：每500个时钟节拍打印"Task2 running"
55
 * @param arg 任务参数（未使用）
56
 */
57
void Task2(void * arg){
58
    while(1){
59
        taskENTER_CRITICAL();    // 进入临界区
60
        printf("Task2 running\r\n");
61
        taskEXIT_CRITICAL();     // 退出临界区
62
        vTaskDelay(500);         // 延迟500个时钟节拍
63
    }
64
}
65

66
/**
67
 * @brief 任务3函数
68
 * 功能：控制GPIOC Pin13上的LED闪烁（500ms亮，500ms灭）
69
 * @param arg 任务参数（未使用）
70
 */
71
void Task3(void * arg){
72
    while(1){
73
        GPIO_SetBits(GPIOC, GPIO_Pin_13);   // 设置Pin13为高电平（LED亮）
74
        vTaskDelay(500);                    // 保持亮状态500个时钟节拍
75
        GPIO_ResetBits(GPIOC, GPIO_Pin_13); // 设置Pin13为低电平（LED灭）
76
        vTaskDelay(500);                    // 保持灭状态500个时钟节拍
77
    }
78
}
79

80
/**
81
 * @brief 启动任务函数
82
 * 功能：创建其他三个任务后自行删除
83
 * @param arg 任务参数（未使用）
84
 */
85
void Starttask(void * arg){
86
    // 进入临界区保护串口输出
87
    taskENTER_CRITICAL();
88
    printf("Starttask running\r\n");  // 打印启动任务运行信息
89
    taskEXIT_CRITICAL();
90

91
    // 使用动态内存分配方式创建任务1
92
    xTaskCreate(Task1,                        // 任务函数指针
93
               "MyFirstTask",                 // 任务名称（用于调试）
94
               START_TASK_STACK_SIZE,         // 栈大小（字）
95
               NULL,                          // 传递给任务的参数
96
               START_TASK_PRIORITY,           // 任务优先级
97
               &MytaskHandler1);              // 任务句柄指针
98

99
    // 使用动态内存分配方式创建任务2
100
    xTaskCreate(Task2,
101
               "MySecondTask",
102
               START_TASK_STACK_SIZE,
103
               NULL,
104
               START_TASK_PRIORITY,
105
               &MytaskHandler2);
106

107
    // 使用动态内存分配方式创建任务3
108
    xTaskCreate(Task3,
109
               "MyThirdTask",
110
               START_TASK_STACK_SIZE,
111
               NULL,
112
               START_TASK_PRIORITY,
113
               &MytaskHandler3);
114

115
    // 删除当前任务（启动任务），释放其占用的资源
116
    vTaskDelete(NULL);
117
}
118

119
/**
120
 * @brief 主函数
121
 * 程序入口点，初始化硬件并启动RTOS调度器
122
 */
123
int main(void)
124
{
125
    LED_Init();                     // 初始化LED GPIO引脚
126
    Usart1_Init(115200);            // 初始化串口1，波特率115200
127

128
    // 创建启动任务（使用动态内存分配）
129
    xTaskCreate(Starttask,                  // 任务函数指针
130
               "StartTask",                 // 任务名称
131
               START_TASK_STACK_SIZE,       // 栈大小
132
               NULL,                        // 任务参数
133
               START_TASK_PRIORITY,         // 任务优先级
134
               &StarttaskHandler);          // 任务句柄
135

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

139
    // 正常情况下，调度器启动后不会执行到这里
140
    // 如果调度器启动失败，程序将在此处循环
141
    while (1)
142
    {
143
        // 空循环，用于处理调度器启动失败的情况
144
    }
145
}
146

147
/*
148
没有临界区
149
如果优先级是不同的在task1，task2，task3函数中有相对应的延时，task1延时最多，task2次之，task1最少
150
#define START_TASK_PRIORITY 1
151
#define TASK1_PRIORITY       2
152
#define TASK2_PRIORITY       3
153
#define  TASK3_PRIORITY       4
154

155
1.创建task1（优先级2）后，由于task1优先级高于start_task，立即抢占CPU开始执行
156
2.task1执行到延时函数（如vTaskDelay()），主动进入阻塞态，CPU回到start_task
157
3.同理，start_task继续创建task2（优先级3），task2优先级更高，抢占执行→延时阻塞→回到start_task
158
4.最后创建task3（优先级4），抢占执行→延时阻塞→start_task完成所有创建后删除自身（或进入阻塞）
159

160
此时输出是：
161
task1
162
task2
163
task3
164
task3
165
task3
166
...
167
-----------------------------------------------------------------------------------------------------------------------------------------
168
有临界区
169
FreeRTOS中vTaskDelete(NULL)在临界区无法删除任务的原因
170

171
在FreeRTOS中，vTaskDelete(NULL)用于删除当前任务，但在临界区（taskENTER_CRITICAL()与taskEXIT_CRITICAL()之间）调用时，会导致任务无法正常删除，且后续代码（如taskEXIT_CRITICAL()）永远无法执行。其核心原因与临界区机制、任务删除流程及内存管理密切相关，具体如下：
172

173
一、临界区的核心特性：禁止任务切换与中断
174
taskENTER_CRITICAL()会关闭中断（通过portENTER_CRITICAL()实现），并禁止任务调度器运行。此时，系统处于“原子操作”状态，任何任务切换（包括空闲任务）都无法发生。
175

176
二、vTaskDelete(NULL)的任务删除流程
177
当调用vTaskDelete(NULL)删除当前任务时，FreeRTOS会执行以下步骤：
178

179
标记任务为待删除：将当前任务从就绪列表、阻塞列表等所有系统列表中移除，标记为eDeleted状态。
180
内存释放（动态分配场景）：若任务通过xTaskCreate()（动态分配）创建，其任务控制块（TCB）和栈空间会被标记为“待释放”，需由**空闲任务（Idle Task）**后续清理。
181

182
三、临界区内调用vTaskDelete(NULL)的致命问题
183
1. 栈空间失效导致程序崩溃（动态分配场景）
184
若start_task通过xTaskCreate()创建（栈动态分配），vTaskDelete(NULL)会立即标记栈空间为待释放。
185
此时，start_task仍在使用该栈执行后续代码（如taskEXIT_CRITICAL()），但栈已被标记为无效，访问无效内存会直接导致程序崩溃。
186
因此，taskEXIT_CRITICAL()永远无法执行，临界区无法退出，系统陷入死锁（中断永远关闭，调度器无法运行）。
187
2. 空闲任务无法运行，内存无法清理
188
即使栈未失效（如静态分配场景），临界区内中断被关闭，空闲任务无法运行，无法清理待删除任务的内存（动态分配场景）。
189
此时，start_task会被标记为待删除，但内存未释放，导致内存泄漏。
190
3. 临界区无法退出，系统死锁
191
若start_task未崩溃（静态分配场景），其会继续执行taskEXIT_CRITICAL()，开启中断并允许调度器运行。
192
但动态分配场景下，栈失效导致程序崩溃，taskEXIT_CRITICAL()无法执行，中断永远关闭，调度器无法运行，其他任务（如task3）无法执行，系统完全死锁。
193

194
四、正确的做法：退出临界区后再删除任务
195
错误代码（临界区内删除任务）：
196

197
void start_task(void *pvParameters) {
198
    taskENTER_CRITICAL(); // 进入临界区（关闭中断）
199
    xTaskCreate(...); // 创建其他任务
200
    vTaskDelete(NULL); // 错误：临界区内删除当前任务
201
    taskEXIT_CRITICAL(); // 永远无法执行
202
}
203

204
正确代码（退出临界区后删除任务）：
205

206
void start_task(void *pvParameters) {
207
    taskENTER_CRITICAL(); // 进入临界区
208
    xTaskCreate(...); // 创建其他任务
209
    taskEXIT_CRITICAL(); // 退出临界区（开启中断）
210
    vTaskDelete(NULL); // 安全删除当前任务
211
}
212

213
-----------------------------------------------------------------------------------------------------------------------------------------
214

215
输出的就是
216
优先级:task3 > task2 > task1
217
延时时间：task3 < task2 < task1
218
task3
219
task2
220
task1
221
task3
222
task2
223
task1
224
...
225
所对应的输出流程在最后面的mermaid流程图
226

227
退出临界区之前start_task任务是不会删除的，因为任务自己删除自己是在空闲任务进行的，这里的关闭中断无法切换空闲状态
228
*/

1
// 动态创建 (内核自动分配内存)
2
TaskHandle_t xDynamicTaskHandle = NULL; // 你只需要声明一个句柄变量
3

4
// 调用一个函数，内核完成所有工作
5
xReturn = xTaskCreate(
6
    vTaskFunction,       // 任务函数
7
    "DynamicTask",       // 任务名
8
    1024,                // 堆栈深度（单位：字）
9
    NULL,                // 任务参数
10
    1,                   // 优先级
11
    &xDynamicTaskHandle  // 【输出】内核将分配好的TCB地址赋给这个句柄
12
);
13

14
// 创建成功后，xDynamicTaskHandle 就不再是NULL。
15
// 它现在指向一块由内核管理的内核空间中的TCB。
16
if (xReturn == pdPASS) {
17
    // 你可以用这个句柄操作任务，但完全不知道TCB和堆栈的具体内存地址
18
    vTaskSuspend(xDynamicTaskHandle);
19
}

1
// 静态创建 (开发者手动分配内存)
2
StackType_t xTaskStack[ 1024 ]; // 你手动分配堆栈
3
StaticTask_t xTaskTCB;          // 你手动分配TCB
4
TaskHandle_t xStaticTaskHandle = NULL;
5

6
// 调用另一个函数，并把你分配好的内存地址传给内核
7
xStaticTaskHandle = xTaskCreateStatic( ..., xTaskStack, &xTaskTCB );
8
// 返回的句柄 xStaticTaskHandle 就等于你传入的 &xTaskTCB

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
 * @brief LED初始化函数
9
 * 配置GPIOC的Pin13作为LED控制引脚
10
 */
11
void LED_Init(void)
12
{
13
    // 使能GPIOC时钟
14
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);
15

16
    // 配置Pin13为推挽输出
17
    GPIO_InitTypeDef GPIO_InitStructure;
18
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;        // 选择引脚13
19
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;     // 输出模式
20
    GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;    // 推挽输出
21
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; // 输出速度50MHz
22
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;  // 无上拉下拉电阻
23
    GPIO_Init(GPIOC, &GPIO_InitStructure);            // 初始化GPIOC
24
}
25

26
// 任务句柄声明（用于引用任务）
27
TaskHandle_t MytaskHandler1;
28
TaskHandle_t MytaskHandler2;
29
TaskHandle_t MytaskHandler3;
30
TaskHandle_t StarttaskHandler;
31

32
// 为每个任务分配静态栈空间（128个字，每个字4字节）
33
StackType_t Startstack[128];  // 启动任务栈
34
StackType_t Task1stack[128];  // 任务1栈
35
StackType_t Task2stack[128];  // 任务2栈
36
StackType_t Task3stack[128];  // 任务3栈
37

38
// 静态任务控制块（TCB）声明
39
StaticTask_t StarttaskTCB;    // 启动任务TCB
40
StaticTask_t Task1taskTCB;    // 任务1 TCB
41
StaticTask_t Task2taskTCB;    // 任务2 TCB
42
StaticTask_t Task3taskTCB;    // 任务3 TCB
43

44
/**
45
 * @brief 任务1函数
46
 * 功能：每500个时钟节拍打印"Task1 running"
47
 * @param arg 任务参数（未使用）
48
 */
49
void Task1(void * arg){
50
    while(1){
51
        taskENTER_CRITICAL();    // 进入临界区（禁用中断）
52
        printf("Task1 running\r\n");
53
        taskEXIT_CRITICAL();     // 退出临界区（启用中断）
54
        vTaskDelay(500);         // 延迟500个时钟节拍
55
    }
56
}
57

58
/**
59
 * @brief 任务2函数
60
 * 功能：每500个时钟节拍打印"Task2 running"
61
 * @param arg 任务参数（未使用）
62
 */
63
void Task2(void * arg){
64
    while(1){
65
        taskENTER_CRITICAL();    // 进入临界区
66
        printf("Task2 running\r\n");
67
        taskEXIT_CRITICAL();     // 退出临界区
68
        vTaskDelay(500);         // 延迟500个时钟节拍
69
    }
70
}
71

72
/**
73
 * @brief 任务3函数
74
 * 功能：控制GPIOC Pin13上的LED闪烁（500ms亮，500ms灭）
75
 * @param arg 任务参数（未使用）
76
 */
77
void Task3(void * arg){
78
    while(1){
79
        GPIO_SetBits(GPIOC, GPIO_Pin_13);   // 设置Pin13为高电平（LED亮）
80
        vTaskDelay(500);                    // 延迟500个时钟节拍
81
        GPIO_ResetBits(GPIOC, GPIO_Pin_13); // 设置Pin13为低电平（LED灭）
82
        vTaskDelay(500);                    // 延迟500个时钟节拍
83
    }
84
}
85

86
/**
87
 * @brief 启动任务函数
88
 * 功能：创建其他三个任务后自行删除
89
 * @param arg 任务参数（未使用）
90
 */
91
void Starttask(void * arg){
92
    taskENTER_CRITICAL();
93
    printf("Starttask running\r\n");
94

95

96
    // 使用静态方式创建任务1
97
    MytaskHandler1 = xTaskCreateStatic(Task1,              // 任务函数指针
98
                                       "MyFirstTask",       // 任务名称
99
                                       128,                 // 栈深度（字）
100
                                       NULL,                // 任务参数
101
                                       2,                   // 任务优先级
102
                                       Task1stack,          // 栈空间数组
103
                                       &Task1taskTCB);      // 任务控制块指针
104

105
    // 使用静态方式创建任务2
106
    MytaskHandler2 = xTaskCreateStatic(Task2,
107
                                       "MySecondTask",
108
                                       128,
109
                                       NULL,
110
                                       2,
111
                                       Task2stack,
112
                                       &Task2taskTCB);
113

114
    // 使用静态方式创建任务3
115
    MytaskHandler3 = xTaskCreateStatic(Task3,
116
                                       "MyThirdTask",
117
                                       128,
118
                                       NULL,
119
                                       2,
120
                                       Task3stack,
121
                                       &Task3taskTCB);
122

123
    taskEXIT_CRITICAL();
124
    vTaskDelete(StarttaskHandler);  // 删除当前任务（启动任务）
125
}
126

127
/**
128
 * @brief 主函数
129
 * 程序入口点，初始化硬件并启动RTOS调度器
130
 */
131
int main(void)
132
{
133
    LED_Init();      // 初始化LED GPIO
134
    Usart1_Init(115200);  // 初始化串口1，波特率115200
135

136
    // 创建启动任务（静态方式）
137
    StarttaskHandler =xTaskCreateStatic(Starttask,        // 任务函数指针
138
                                        "MyFirstTask",     // 任务名称
139
                                        128,               // 栈深度
140
                                        NULL,              // 任务参数
141
                                        2,                 // 任务优先级
142
                                        Startstack,        // 栈空间
143
                                        &StarttaskTCB);    // 任务控制块
144

145
    // 启动RTOS调度器（程序将在此处开始运行任务）
146
    vTaskStartScheduler();
147

148
    // 调度器启动后通常不会执行到这里
149
    while (1)
150
    {
151
        // 如果调度器意外停止，将在此处循环
152
    }
153
}
154

155
// 空闲任务和定时器任务的内存分配（FreeRTOS要求）
156

157
StaticTask_t IdleTaskTCB;  // 空闲任务控制块
158
StackType_t  IdleTaskStack[configMINIMAL_STACK_SIZE];  // 空闲任务栈
159

160
StaticTask_t TimerTaskTCB;  // 定时器服务任务控制块
161
StackType_t  TimerTaskStack[configTIMER_TASK_STACK_DEPTH];  // 定时器任务栈
162

163
/**
164
 * @brief 空闲任务内存分配函数
165
 * FreeRTOS在静态分配模式下需要此函数来分配空闲任务的内存
166
 */
167
void vApplicationGetIdleTaskMemory( StaticTask_t ** ppxIdleTaskTCBBuffer,
168
                                   StackType_t ** ppxIdleTaskStackBuffer,
169
                                   uint32_t * pulIdleTaskStackSize )
170
{
171
    *ppxIdleTaskTCBBuffer = &IdleTaskTCB;              // 返回空闲任务TCB指针
172
    *ppxIdleTaskStackBuffer = IdleTaskStack;           // 返回空闲任务栈指针
173
    *pulIdleTaskStackSize = configMINIMAL_STACK_SIZE;  // 返回空闲任务栈大小
174
}
175

176
/**
177
 * @brief 软件定时器任务内存分配函数
178
 * 当启用FreeRTOS定时器功能时需要此函数
179
 */
180
void vApplicationGetTimerTaskMemory( StaticTask_t ** ppxTimerTaskTCBBuffer,
181
                                    StackType_t ** ppxTimerTaskStackBuffer,
182
                                    uint32_t * pulTimerTaskStackSize )
183
{
184
    *ppxTimerTaskTCBBuffer = &TimerTaskTCB;                    // 返回定时器任务TCB指针
185
    *ppxTimerTaskStackBuffer = TimerTaskStack;                 // 返回定时器任务栈指针
186
    *pulTimerTaskStackSize = configTIMER_TASK_STACK_DEPTH;     // 返回定时器任务栈大小
187
}

1
// 1. 开发者静态分配内存（全局变量）
2
StackType_t xTaskStack[ 1024 ]; // 任务堆栈
3
StaticTask_t xTaskTCB;          // 任务控制块(TCB)
4

5
// 2. 声明一个任务句柄变量（本质上就是一个指针）
6
TaskHandle_t xTaskHandle = NULL;
7

8
void main( void )
9
{
10
    // 3. 静态创建任务
11
    // 注意：我们将静态分配的xTaskTCB和xTaskStack的地址传入函数
12
    xTaskHandle = xTaskCreateStatic(
13
                    vTaskFunction,   /* 任务函数 */
14
                    "StaticTask",    /* 任务名 */
15
                    1024,            /* 堆栈深度（单位：字） */
16
                    NULL,            /* 任务参数 */
17
                    tskIDLE_PRIORITY + 1,
18
                    xTaskStack,      /* 【传入】堆栈数组的起始地址 */
19
                    &xTaskTCB );     /* 【传入】TCB结构体的地址 */
20

21
    // 4. 创建成功后，xTaskHandle 就不再是NULL。
22
    // 它现在就等于 &xTaskTCB，即指向你提供的TCB内存的指针。
23
    if (xTaskHandle != NULL) {
24
        // 现在可以用统一的API，通过句柄来操作这个静态任务了
25
        vTaskSuspend(xTaskHandle); // 挂起这个任务
26
    }
27

28
    // ... 启动调度器
29
}