FreeRTOS信号量#

一、信号量简介#

1、什么是信号量#

答：信号量是一种解决同步问题的机制，可以实现对共享资源的有序访问。

假设有一个人需要在停车场停车。

空车位：信号量资源数(计数值)
让出占用车位：释放信号量(计数值++)
占用车位：获取信号量(计数值—)

首先判断停车场是否还有空车位(判断信号量是否有资源)。
停车场正好有空车位(信号量有资源)，那么就可以直接将车开入停车位进行停车(获取信号量成功)。
停车场已经没有空车位了(信号量没有资源)，那么可以选择不停车(获取信号量失败)，也可以选择等待(任务阻塞)其他人将车开出停车位(释放信号)，然后在将车停如空车位。

2、信号量简介#

答：

当计数值大于0，表示有信号量资源。
当释放信号量，信号量计数值(资源数)加一。
当获取信号量，信号量计数值(资源数)减一。
信号量的计数值都是有限的：限定最大值。
如果最大值被限定为1，那么它就是二值信号量。
如果最大值不是1，它就是计数型信号量。

注意：信号量用于传递状态。

3、队列与信号量的对比#

答：

二、二值信号量#

1、二值信号量介绍#

答：二值信号量的==本质是一个队列长度为1的队列==，==该队列就只有空和满两种情况==。这就是二值信号量。

注意：二值信号量通常用于==互斥访问或任务同步==，与互斥信号量比较类似，但是二值信号量有可能会==导致优先级翻转的问题==，所以二值信号量更适合用于同步！！！

互斥访问：原理：像一个钥匙。一个任务拿到钥匙后，才能访问共享资源。其他任务想访问，必须等待钥匙被释放

任务同步：一个任务的执行需要等待另一个（或多个）任务达到某个状态或完成某个操作后才能继续

2、二值信号量相关API函数#

答：使用二值信号量的过程：创建二值信号量 -> 释放二值信号量 -> 获取二值信号量

3、创建二值信号量函数#

答：创建二值信号量函数：

1
SemaphoreHandle_t  xSemaphoreCreateBinary( void );

1
#define   xSemaphoreCreateBinary()
2
xQueueGenericCreate(1 , semSEMAPHORE_QUEUE_ITEM_LENGTH, queueQUEUE_TYPE_BINARY_SEMAPHORE)
3
#define   semSEMAPHORE_QUEUE_ITEM_LENGTH   (( uint8_t ) 0U)

1
#define   queueQUEUE_TYPE_BASE                           ( ( uint8_t ) 0U ) /* 队列 */
2
#define   queueQUEUE_TYPE_SET                            ( ( uint8_t ) 0U ) /* 队列集 */
3
#define   queueQUEUE_TYPE_MUTEX                          ( ( uint8_t ) 1U ) /* 互斥信号量 */
4
#define   queueQUEUE_TYPE_COUNTING_SEMAPHORE             ( ( uint8_t ) 2U ) /* 计数型信号量 */
5
#define   queueQUEUE_TYPE_BINARY_SEMAPHORE               ( ( uint8_t ) 3U ) /* 二值信号量 */
6
#define   queueQUEUE_TYPE_RECURSIVE_MUTEX                ( ( uint8_t ) 4U ) /* 递归互斥信号量 */

返回值：

4、释放二值信号量函数#

答：释放二值信号量函数：

1
BaseType_t   xSemaphoreGive( xSemaphore )

1
#define   xSemaphoreGive ( xSemaphore )
2
xQueueGenericSend((QueueHandle_t)( xSemaphore ), NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK)
3
#define   semGIVE_BLOCK_TIME       ( ( TickType_t ) 0U )

函数参数：

函数返回值：

不支持阻塞时间

5、获取二值信号量函数#

答：获取二值信号量函数：

1
BaseType_t   xSemaphoreTake( xSemaphore, xBlockTime )

函数参数：

函数返回值：

支持阻塞时间

实验#

实验目的：学习FreeRTOS的二值信号量相关API函数的使用
实验设计：将设计三个任务：start_task, task1, task2
- start_task：用来创建task1，task2
- task1：用于按键扫描，当检测到按键KEY0被按下时，释放二值信号量
- task2：获取二值信号量，当成功获取后打印提示信息

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
#include "timer.h"                      // 定时器头文件
7
#include "delay_dwt.h"                  // 包含DWT延迟函数头文件
8
#include "semphr.h"                     // FreeRTOS信号量头文件
9

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

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

30

31
/**
32
 * @brief LED初始化函数
33
 * 配置GPIOC的Pin13作为LED控制引脚
34
 */
35
void LED_TOGGLE13(void)
36
{
37
    GPIO_ToggleBits(GPIOC, GPIO_Pin_13);
38
}
39

40
/**
41
 * @brief LED初始化函数
42
 * 配置GPIOC的Pin1作为LED控制引脚
43
 */
44
void LED_TOGGLE1(void)
45
{
46
    GPIO_ToggleBits(GPIOC, GPIO_Pin_1);
47
}
48

49
/**
50
 * @brief LED初始化函数
51
 * 配置GPIOC的Pin0作为LED控制引脚
52
 */
53
void LED_TOGGLE0(void)
54
{
55
    GPIO_ToggleBits(GPIOC, GPIO_Pin_0);
56
}
57

58
/**
59
 * @brief 按键初始化函数
60
 * 配置GPIOA的Pin0和Pin1作为按键输入引脚
61
 */
62
void Key_Init(void)
63
{
64
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
65
  GPIO_InitTypeDef GPIO_InitStructure;
66
  GPIO_StructInit(&GPIO_InitStructure);
67
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15 |  GPIO_Pin_0 | GPIO_Pin_1;
68
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
69
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
70
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
71
  GPIO_Init(GPIOA, &GPIO_InitStructure);
72
}
73

74
/**
75
 * @brief 获取按键编号
76
 * 功能：根据按键状态返回按键编号
77
 * @return uint8_t 按键编号（1或2），如果没有按键按下则返回0
78
 */
79
uint8_t Key_GetNum(void)
80
{
81
  if (GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0) == 0)
82
  {
83
    vTaskDelay(20);
84
    if(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0) == 0){
85
      return 1;
86
    }
87
  }
88
  else if (GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_1) == 0)
89
  {
90
    vTaskDelay(20);
91
    if(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_1) == 0){
92
      return 2;
93
    }
94
  }
95
  else if (GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_15) == 0)
96
  {
97
    vTaskDelay(20);
98
    if(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_15) == 0){
99
      return 3;
100
    }
101
    }
102
    return 0;
103
}
104

105
// 任务配置宏定义
106
#define START_TASK_STACK_SIZE 128       // 启动任务栈大小（字）
107
#define START_TASK_PRIORITY 2           // 启动任务优先级（数值越小优先级越高）
108
#define TASK1_STACK_SIZE 128           // 任务1栈大小（字）
109
#define TASK1_PRIORITY 2               // 任务1优先级（数值越小优先级越高）
110
#define TASK2_STACK_SIZE 128           // 任务2栈大小（字）
111
#define TASK2_PRIORITY 3               // 任务2优先级（数值越小优先级越高）
112
// 任务句柄声明（用于引用和管理任务）
113
TaskHandle_t MytaskHandler1;    // 任务1句柄
114
TaskHandle_t MytaskHandler2;    // 任务2句柄
115
TaskHandle_t StarttaskHandler;  // 启动任务句柄
116
QueueHandle_t semaphore;        // 二值信号量句柄
117

118

119
/**
120
 * @brief 任务1函数
121
 * 功能：释放二值信号量
122
 * @param arg 任务参数（未使用）
123
 */
124
void Task1(void * arg){
125
    uint8_t keyNum = 0;
126
    BaseType_t xStatus;
127
    while(1){
128
        keyNum = Key_GetNum();
129
        if(keyNum == 1){
130
            if(semaphore != NULL){
131
                xStatus = xSemaphoreGive(semaphore);
132
                if(xStatus == pdPASS){
133
                    printf("Semaphore give success\r\n");
134
                }else {
135
                    printf("Semaphore give failed\r\n");
136
                }
137
            }
138
        }
139
        vTaskDelay(100);
140
    }
141

142
}
143

144

145
/**
146
 * @brief 任务2函数
147
 * 功能：获取二值信号量
148
 * @param arg 任务参数（未使用）
149
 */
150
 void Task2(void * arg){
151
    uint32_t i = 0;
152
    BaseType_t xStatus;
153
    while(1){
154
        xStatus = xSemaphoreTake(semaphore, portMAX_DELAY);
155
        if(xStatus == pdPASS){
156
            printf("Semaphore take success \r\n");
157
        }else {
158
            printf("Semaphore take failed %d\r\n", ++ i);
159
        }
160
    }
161
}
162

163
/*为什么task2的先打印出来？
164
因为task2的优先级高，但是在xSemaphoreTake()函数中，如果信号量不可用，任务会被阻塞，直到信号量被释放。
165
此时task1运行，会先释放信号量，然后task2获取到信号量，会立刻抢占task1，打印出"Semaphore take success"。
166
task2执行完到xSemaphoreTake()函数，会再次阻塞，等待信号量被释放。此时task1才打印出"Semaphore take success "。
167
*/
168

169
/*如果portMAX_DELAY改为1000，会发生什么？
170
会发生任务2的打印失败，因为任务2的优先级高，但是在1000个时钟节拍内，信号量还没有被释放，所以任务2会打印失败。
171
直到任务1释放信号量，任务2才会打印成功。又会发生任务2的打印失败，因为任务2的优先级低，在100个时钟节拍内，信号量还没有被释放，所以任务2会打印失败。
172
*/
173

174
/**
175
 * @brief 启动任务函数
176
 * 功能：创建其他三个任务后自行删除
177
 * @param arg 任务参数（未使用）
178
 */
179
void Starttask(void * arg){
180
    // 进入临界区保护串口输出
181
    taskENTER_CRITICAL();
182
    printf("Starttask running\r\n");  // 打印启动任务运行信息
183
    taskEXIT_CRITICAL();
184

185
     /**
186
      * @brief 创建二值信号量
187
      * 功能：创建一个二值信号量，用于任务间同步
188
      */
189
    semaphore = xSemaphoreCreateBinary();
190
    if(semaphore == NULL){
191
        printf("Semaphore create failed\r\n");
192
    }else{
193
        printf("Semaphore create success\r\n");
194
    }
195

196
    // 使用动态内存分配方式创建任务1
197
    xTaskCreate(Task1,                        // 任务函数指针
198
               "MyFirstTask",                 // 任务名称（用于调试）
199
               TASK1_STACK_SIZE,         // 栈大小（字）
200
               NULL,                          // 传递给任务的参数
201
               TASK1_PRIORITY,           // 任务优先级
202
               &MytaskHandler1);              // 任务句柄指针
203

204
    // 使用动态内存分配方式创建任务2
205
    xTaskCreate(Task2,
206
               "MySecondTask",
207
               TASK2_STACK_SIZE,
208
               NULL,
209
               TASK2_PRIORITY,
210
               &MytaskHandler2);
211

212

213

214
    // 删除当前任务（启动任务），释放其占用的资源
215
    vTaskDelete(NULL);
216
}
217

218
/**
219
 * @brief 主函数
220
 * 程序入口点，初始化硬件并启动RTOS调度器
221
 */
222
int main(void)
223
{
224
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
225
    LED_Init();                     // 初始化LED GPIO引脚
226
    Usart1_Init(115200);            // 初始化串口1，波特率115200
227
    Key_Init();                     // 初始化按键 GPIO引脚
228
    DWT_Init();                     // 初始化DWT定时器
229

230
    // 创建启动任务（使用动态内存分配）
231
    xTaskCreate(Starttask,                  // 任务函数指针
232
               "StartTask",                 // 任务名称
233
               START_TASK_STACK_SIZE,       // 栈大小
234
               NULL,                        // 任务参数
235
               START_TASK_PRIORITY,         // 任务优先级
236
               &StarttaskHandler);          // 任务句柄
237

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

241
    // 正常情况下，调度器启动后不会执行到这里
242
    // 如果调度器启动失败，程序将在此处循环
243
    while (1)
244
    {
245
        // 空循环，用于处理调度器启动失败的情况
246
    }
247
}

portMAX_DELAY改为1000

portMAX_DELAY不改为1000

三、计数型信号量#

1、计数型信号量介绍#

答：==计数型信号量相当于队列长度为1的队列==，因此计数型信号量能够容纳多个资源，这在计数型信号量被创建的时候确定的。

计数型信号量适用场合：

事件计数：当每次事件发生后，在事件处理函数中释放计数型信号量(计数值+1)，其他任务会获取计数型信号量(计数值-1)，这种场合一般在==创建时将初始化计数值设置为0.（队列长度代表的是它的上限值）==
资源管理：信号量表示有效资源数量。任务必须先获取信号量(信号计数值-1)才能获取资源控制权。当计数值减为0时表示没有资源。当任务使用完资源后，必须释放信号量(信号量计数值+1)。==信号量创建时计数值应等于最大资源数目。==

2、计数型信号量相关API函数#

答：使用计数型信号量的过程：创建计数型信号量 -> 释放信号量 -> 获取信号量

注意：计数型信号量的释放与获取的函数和二值信号量一样。

3、计数型信号量创建函数#

答：

1
#define   xSemaphoreCreateCounting( uxMaxCount , uxInitialCount )
2
            xQueueCreateCountingSemaphore( ( uxMaxCount ) , ( uxInitialCount ) )

函数参数：

函数返回值：

4、获取计数型信号量计数值函数#

答：

1
#define   uxSemaphoreGetCount( xSemaphore )
2
            uxQueueMessagesWaiting(( QueueHandle_t )( xSemaphore ))

函数参数：

函数返回值：

实验#

实验目的：学习FreeRTOS的计数值信号量相关API函数的使用
实验设计：将设计三个任务：start_task, task1，task2
- start_task：用来创建task1，task2
- task1：用于按键扫描，当检测到按键KEY0被按下时，释放计数值信号量（+1）
- task2：每过一秒获取一次计数值信号量（-1），当成功获取后打印提示信息

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
#include "timer.h"                      // 定时器头文件
7
#include "delay_dwt.h"                  // 包含DWT延迟函数头文件
8
#include "semphr.h"                     // FreeRTOS信号量头文件
9

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

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

30

31
/**
32
 * @brief LED初始化函数
33
 * 配置GPIOC的Pin13作为LED控制引脚
34
 */
35
void LED_TOGGLE13(void)
36
{
37
    GPIO_ToggleBits(GPIOC, GPIO_Pin_13);
38
}
39

40
/**
41
 * @brief LED初始化函数
42
 * 配置GPIOC的Pin1作为LED控制引脚
43
 */
44
void LED_TOGGLE1(void)
45
{
46
    GPIO_ToggleBits(GPIOC, GPIO_Pin_1);
47
}
48

49
/**
50
 * @brief LED初始化函数
51
 * 配置GPIOC的Pin0作为LED控制引脚
52
 */
53
void LED_TOGGLE0(void)
54
{
55
    GPIO_ToggleBits(GPIOC, GPIO_Pin_0);
56
}
57

58
/**
59
 * @brief 按键初始化函数
60
 * 配置GPIOA的Pin0和Pin1作为按键输入引脚
61
 */
62
void Key_Init(void)
63
{
64
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
65
  GPIO_InitTypeDef GPIO_InitStructure;
66
  GPIO_StructInit(&GPIO_InitStructure);
67
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15 |  GPIO_Pin_0 | GPIO_Pin_1;
68
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
69
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
70
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
71
  GPIO_Init(GPIOA, &GPIO_InitStructure);
72
}
73

74
/**
75
 * @brief 获取按键编号
76
 * 功能：根据按键状态返回按键编号
77
 * @return uint8_t 按键编号（1或2），如果没有按键按下则返回0
78
 */
79
uint8_t Key_GetNum(void)
80
{
81
  if (GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0) == 0)
82
  {
83
    vTaskDelay(20);
84
    if(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0) == 0){
85
      return 1;
86
    }
87
  }
88
  else if (GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_1) == 0)
89
  {
90
    vTaskDelay(20);
91
    if(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_1) == 0){
92
      return 2;
93
    }
94
  }
95
  else if (GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_15) == 0)
96
  {
97
    vTaskDelay(20);
98
    if(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_15) == 0){
99
      return 3;
100
    }
101
    }
102
    return 0;
103
}
104

105
// 任务配置宏定义
106
#define START_TASK_STACK_SIZE 128       // 启动任务栈大小（字）
107
#define START_TASK_PRIORITY 2           // 启动任务优先级（数值越小优先级越高）
108
#define TASK1_STACK_SIZE 128           // 任务1栈大小（字）
109
#define TASK1_PRIORITY 2               // 任务1优先级（数值越小优先级越高）
110
#define TASK2_STACK_SIZE 128           // 任务2栈大小（字）
111
#define TASK2_PRIORITY 3               // 任务2优先级（数值越小优先级越高）
112
// 任务句柄声明（用于引用和管理任务）
113
TaskHandle_t MytaskHandler1;    // 任务1句柄
114
TaskHandle_t MytaskHandler2;    // 任务2句柄
115
TaskHandle_t StarttaskHandler;  // 启动任务句柄
116
QueueHandle_t count_semaphore;        // 二值信号量句柄
117

118

119
/**
120
 * @brief 任务1函数
121
 * 功能：释放二值信号量
122
 * @param arg 任务参数（未使用）
123
 */
124
void Task1(void * arg){
125
    uint8_t keyNum = 0;
126
    while(1){
127
        keyNum = Key_GetNum();
128
        if(keyNum == 1){
129
            if(count_semaphore != NULL){
130
                xSemaphoreGive(count_semaphore); /*释放计数信号量*/
131
            }
132
        }
133
        vTaskDelay(100);
134
    }
135

136
}
137

138

139
/**
140
 * @brief 任务2函数
141
 * 功能：获取二值信号量
142
 * @param arg 任务参数（未使用）
143
 */
144
 void Task2(void * arg){
145
    BaseType_t xStatus;
146
    while(1){
147
        xStatus = xSemaphoreTake(count_semaphore, portMAX_DELAY); /*获取计数信号量*/
148
        /*设置信号量的初始值是0，没有资源，获取不到，会阻塞在这*/
149
        if(xStatus == pdTRUE){
150
            printf("信号量的计数值为:%d\r\n", (int)uxSemaphoreGetCount(count_semaphore));
151
        }
152
        vTaskDelay(1000);
153
    }
154
}
155

156

157
/**
158
 * @brief 启动任务函数
159
 * 功能：创建其他三个任务后自行删除
160
 * @param arg 任务参数（未使用）
161
 */
162
void Starttask(void * arg){
163
    // 进入临界区保护串口输出
164
    taskENTER_CRITICAL();
165
    printf("Starttask running\r\n");  // 打印启动任务运行信息
166
    taskEXIT_CRITICAL();
167

168
     /**
169
      * @brief 创建计数信号量
170
      * 功能：创建一个计数信号量，用于任务间同步
171
      */
172
    count_semaphore = xSemaphoreCreateCounting(100, 15);
173
    if(count_semaphore == NULL){
174
        printf("Count semaphore create failed\r\n");
175
    }else{
176
        printf("Count semaphore create success\r\n");
177
    }
178

179
    // 使用动态内存分配方式创建任务1
180
    xTaskCreate(Task1,                        // 任务函数指针
181
               "MyFirstTask",                 // 任务名称（用于调试）
182
               TASK1_STACK_SIZE,         // 栈大小（字）
183
               NULL,                          // 传递给任务的参数
184
               TASK1_PRIORITY,           // 任务优先级
185
               &MytaskHandler1);              // 任务句柄指针
186

187
    // 使用动态内存分配方式创建任务2
188
    xTaskCreate(Task2,
189
               "MySecondTask",
190
               TASK2_STACK_SIZE,
191
               NULL,
192
               TASK2_PRIORITY,
193
               &MytaskHandler2);
194

195

196

197
    // 删除当前任务（启动任务），释放其占用的资源
198
    vTaskDelete(NULL);
199
}
200

201
/**
202
 * @brief 主函数
203
 * 程序入口点，初始化硬件并启动RTOS调度器
204
 */
205
int main(void)
206
{
207
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
208
    LED_Init();                     // 初始化LED GPIO引脚
209
    Usart1_Init(115200);            // 初始化串口1，波特率115200
210
    Key_Init();                     // 初始化按键 GPIO引脚
211
    DWT_Init();                     // 初始化DWT定时器
212

213
    // 创建启动任务（使用动态内存分配）
214
    xTaskCreate(Starttask,                  // 任务函数指针
215
               "StartTask",                 // 任务名称
216
               START_TASK_STACK_SIZE,       // 栈大小
217
               NULL,                        // 任务参数
218
               START_TASK_PRIORITY,         // 任务优先级
219
               &StarttaskHandler);          // 任务句柄
220

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

224
    // 正常情况下，调度器启动后不会执行到这里
225
    // 如果调度器启动失败，程序将在此处循环
226
    while (1)
227
    {
228
        // 空循环，用于处理调度器启动失败的情况
229
    }
230
}

四、优先级翻转介绍#

1、优先级翻转简介#

答：优先级翻转：高优先级的任务反而慢执行，低优先级的任务反而优先执行。

优先级翻转在抢占式内核中是非常常见的，但是在实时操作系统中是不允许出现优先级翻转的，因为优先级翻转会破坏任务的预期顺序，可能会导致未知的严重后果。

在使用二值信号量的时候，经常会遇到优先级翻转的问题。

2、优先级翻转的例子#

答：

高优先级任务被低优先级任务阻塞，导致高优先级任务迟迟得不到调度。但其他中等优先级的任务却能抢到CPU资源。从现象上看，就像是中等优先级的任务比高优先级任务具有更高的优先权(即优先级翻转)。

实验#

实验目的：在使用二值信号量的时候会存在优先级翻转的问题，本实验通过模拟的方式实现优先级翻转，观察优先级翻转对抢占式内核的影响

实验设计：将设计四个任务：start_task，high_task，middle_task，low_task

四个实现功能：

start_task，用来创建其他任务
high_task，高优先级任务，会获取二值信号量，获取成功以后打印提示信息，处理完之后释放信号量
middle_task，中等优先级，简单的应用任务
low_task 低优先级任务，通高优先级一样的操作，不同的是低优先级任务占用信号量的时间久一点

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
#include "timer.h"                      // 定时器头文件
7
#include "delay_dwt.h"                  // 包含DWT延迟函数头文件
8
#include "semphr.h"                     // FreeRTOS信号量头文件
9

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

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

30

31
/**
32
 * @brief LED初始化函数
33
 * 配置GPIOC的Pin13作为LED控制引脚
34
 */
35
void LED_TOGGLE13(void)
36
{
37
    GPIO_ToggleBits(GPIOC, GPIO_Pin_13);
38
}
39

40
/**
41
 * @brief LED初始化函数
42
 * 配置GPIOC的Pin1作为LED控制引脚
43
 */
44
void LED_TOGGLE1(void)
45
{
46
    GPIO_ToggleBits(GPIOC, GPIO_Pin_1);
47
}
48

49
/**
50
 * @brief LED初始化函数
51
 * 配置GPIOC的Pin0作为LED控制引脚
52
 */
53
void LED_TOGGLE0(void)
54
{
55
    GPIO_ToggleBits(GPIOC, GPIO_Pin_0);
56
}
57

58
/**
59
 * @brief 按键初始化函数
60
 * 配置GPIOA的Pin0和Pin1作为按键输入引脚
61
 */
62
void Key_Init(void)
63
{
64
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
65
  GPIO_InitTypeDef GPIO_InitStructure;
66
  GPIO_StructInit(&GPIO_InitStructure);
67
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15 |  GPIO_Pin_0 | GPIO_Pin_1;
68
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
69
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
70
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
71
  GPIO_Init(GPIOA, &GPIO_InitStructure);
72
}
73

74
/**
75
 * @brief 获取按键编号
76
 * 功能：根据按键状态返回按键编号
77
 * @return uint8_t 按键编号（1或2），如果没有按键按下则返回0
78
 */
79
uint8_t Key_GetNum(void)
80
{
81
  if (GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0) == 0)
82
  {
83
    vTaskDelay(20);
84
    if(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0) == 0){
85
      return 1;
86
    }
87
  }
88
  else if (GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_1) == 0)
89
  {
90
    vTaskDelay(20);
91
    if(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_1) == 0){
92
      return 2;
93
    }
94
  }
95
  else if (GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_15) == 0)
96
  {
97
    vTaskDelay(20);
98
    if(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_15) == 0){
99
      return 3;
100
    }
101
    }
102
    return 0;
103
}
104

105
// 任务配置宏定义
106
#define START_TASK_STACK_SIZE 128       // 启动任务栈大小（字）
107
#define START_TASK_PRIORITY 2           // 启动任务优先级（数值越小优先级越高）
108
#define TASK1_STACK_SIZE 128           // 任务1栈大小（字）
109
#define TASK1_PRIORITY 3               // 任务1优先级（数值越大优先级越高）
110
#define TASK2_STACK_SIZE 128           // 任务2栈大小（字）
111
#define TASK2_PRIORITY 4               // 任务2优先级（数值越大优先级越高）
112
#define TASK3_STACK_SIZE 128           // 任务3栈大小（字）
113
#define TASK3_PRIORITY 5               // 任务3优先级（数值越大优先级越高）
114
// 任务句柄声明（用于引用和管理任务）
115
TaskHandle_t MytaskHandler1;    // 任务1句柄
116
TaskHandle_t MytaskHandler2;    // 任务2句柄
117
TaskHandle_t MytaskHandler3;    // 任务3句柄
118
TaskHandle_t StarttaskHandler;  // 启动任务句柄
119
QueueHandle_t semaphore;        // 二值信号量句柄
120

121

122
/**
123
 * @brief 低优先级任务1函数
124
 * 功能：
125
 * @param arg 任务参数（未使用）
126
 */
127
void low_Task1(void * arg){
128
    while(1){
129
        printf("low_Task1 等待信号量\r\n");
130
        xSemaphoreTake(semaphore, portMAX_DELAY);
131
        printf("low_Task1 running\r\n");
132
        Delay_ms(3000);
133
        printf("low_Task1 释放信号量\r\n");
134
        xSemaphoreGive(semaphore);
135
        vTaskDelay(1000);
136
    }
137

138
}
139

140

141
/**
142
 * @brief 中优先级任务2函数
143
 * 功能：
144
 * @param arg 任务参数（未使用）
145
 */
146
 void middle_Task2(void * arg){
147

148
    while(1){
149
        printf("middle_Task2 running\r\n");
150
        vTaskDelay(1000);
151
    }
152
}
153

154
/**
155
 * @brief 高优先级任务3函数
156
 * 功能：
157
 * @param arg 任务参数（未使用）
158
 */
159
 void high_Task3(void * arg){
160

161
    while(1){
162
        printf("high_Task3 等待信号量\r\n");
163
        xSemaphoreTake(semaphore, portMAX_DELAY);
164
        printf("high_Task3 running\r\n");
165
        Delay_ms(1000);
166
        printf("high_Task3 释放信号量\r\n");
167
        xSemaphoreGive(semaphore);
168
        vTaskDelay(1000);
169
    }
170
}
171

172

173

174
/**
175
 * @brief 启动任务函数
176
 * 功能：创建其他三个任务后自行删除
177
 * @param arg 任务参数（未使用）
178
 */
179
void Starttask(void * arg){
180
    // 进入临界区保护串口输出
181
    taskENTER_CRITICAL();
182
    printf("----------------------------\r\n");
183
    printf("Starttask running\r\n");  // 打印启动任务运行信息
184
    taskEXIT_CRITICAL();
185

186
    // 创建二值信号量
187
    semaphore = xSemaphoreCreateBinary();
188
    if(semaphore == NULL){
189
        printf("Semaphore create failed\r\n");
190
    }else{
191
        printf("Semaphore create success\r\n");
192
    }
193

194
    // 释放信号量，使低优先级任务1可以运行
195
    xSemaphoreGive(semaphore);
196

197
    taskENTER_CRITICAL();
198
    // 使用动态内存分配方式创建任务1
199
    xTaskCreate(low_Task1,                        // 任务函数指针
200
               "MyFirstTask",                 // 任务名称（用于调试）
201
               TASK1_STACK_SIZE,         // 栈大小（字）
202
               NULL,                          // 传递给任务的参数
203
               TASK1_PRIORITY,           // 任务优先级
204
               &MytaskHandler1);              // 任务句柄指针
205

206
    // 使用动态内存分配方式创建任务2
207
    xTaskCreate(middle_Task2,
208
               "MySecondTask",
209
               TASK2_STACK_SIZE,
210
               NULL,
211
               TASK2_PRIORITY,
212
               &MytaskHandler2);
213

214
    // 使用动态内存分配方式创建任务3
215
    xTaskCreate(high_Task3,
216
               "MyThirdTask",
217
               TASK3_STACK_SIZE,
218
               NULL,
219
               TASK3_PRIORITY,
220
               &MytaskHandler3);
221
    taskEXIT_CRITICAL();
222

223
    // 删除当前任务（启动任务），释放其占用的资源
224
    vTaskDelete(NULL);
225
}
226

227
/**
228
 * @brief 主函数
229
 * 程序入口点，初始化硬件并启动RTOS调度器
230
 */
231
int main(void)
232
{
233
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
234
    LED_Init();                     // 初始化LED GPIO引脚
235
    Usart1_Init(115200);            // 初始化串口1，波特率115200
236
    Key_Init();                     // 初始化按键 GPIO引脚
237
    DWT_Init();                     // 初始化DWT定时器
238

239
    // 创建启动任务（使用动态内存分配）
240
    xTaskCreate(Starttask,                  // 任务函数指针
241
               "StartTask",                 // 任务名称
242
               START_TASK_STACK_SIZE,       // 栈大小
243
               NULL,                        // 任务参数
244
               START_TASK_PRIORITY,         // 任务优先级
245
               &StarttaskHandler);          // 任务句柄
246

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

250
    // 正常情况下，调度器启动后不会执行到这里
251
    // 如果调度器启动失败，程序将在此处循环
252
    while (1)
253
    {
254
        // 空循环，用于处理调度器启动失败的情况
255
    }
256
}

五、互斥信号量#

1、互斥信号量介绍#

答：互斥信号量其实就是一个拥有优先级翻转的二值信号量。

二值信号量更适用于同步的应用。
互斥信号量更适合那些需要互斥访问的应用(资源紧缺，需要资源保护)。

2、什么是优先级继承#

答：当一个互斥信号量正在被一个低优先级的任务持有时，如果此时有一个高优先级的任务也尝试获取这个互斥信号量，那么这个高优先级的任务就会被阻塞。==不过这个高优先级的任务会将低优先级任务的优先级提升到与自己相同的优先级。==

3、优先级继承示例#

答：

此时任务H的阻塞时间仅仅是任务L的执行时间，将优先级翻转的危害降低到了最低。

4、互斥信号量的注意事项#

答：优先级继承并不能完全的消除优先级翻转的问题，它只是尽可能的降低优先级翻转带来的影响。

注意：互斥信号量不能用于中断服务函数中，原因如下：

互斥信号量有优先级继承的机制，但是中断不是任务，没有任务优先级，所以互斥信号量只能用于任务中，不能用于中断服务函数中。
中断服务函数中不能因为要等待互斥信号量而设置阻塞时间进入阻塞态。

5、互斥信号量相关API函数#

答：使用互斥信号量：首先将宏configUSE_MUTEXES置1.

使用流程：创建互斥信号量 -> (task)获取信号量 -> (give)释放信号量

创建互斥信号量函数：

互斥信号量的释放和获取函数与二值信号量相同！！！只不过互斥信号量不支持中断中调用。

注意：创建互斥信号量时，会主动释放一次信号量。

6、创建互斥信号量函数#

答：

1
#define   xSemaphoreCreateMutex()      xQueueCreateMutex( queueQUEUE_TYPE_MUTEX )

函数返回值：

实验#

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
#include "timer.h"                      // 定时器头文件
7
#include "delay_dwt.h"                  // 包含DWT延迟函数头文件
8
#include "semphr.h"                     // FreeRTOS信号量头文件
9

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

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

30

31
/**
32
 * @brief LED初始化函数
33
 * 配置GPIOC的Pin13作为LED控制引脚
34
 */
35
void LED_TOGGLE13(void)
36
{
37
    GPIO_ToggleBits(GPIOC, GPIO_Pin_13);
38
}
39

40
/**
41
 * @brief LED初始化函数
42
 * 配置GPIOC的Pin1作为LED控制引脚
43
 */
44
void LED_TOGGLE1(void)
45
{
46
    GPIO_ToggleBits(GPIOC, GPIO_Pin_1);
47
}
48

49
/**
50
 * @brief LED初始化函数
51
 * 配置GPIOC的Pin0作为LED控制引脚
52
 */
53
void LED_TOGGLE0(void)
54
{
55
    GPIO_ToggleBits(GPIOC, GPIO_Pin_0);
56
}
57

58
/**
59
 * @brief 按键初始化函数
60
 * 配置GPIOA的Pin0和Pin1作为按键输入引脚
61
 */
62
void Key_Init(void)
63
{
64
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
65
  GPIO_InitTypeDef GPIO_InitStructure;
66
  GPIO_StructInit(&GPIO_InitStructure);
67
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15 |  GPIO_Pin_0 | GPIO_Pin_1;
68
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
69
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
70
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
71
  GPIO_Init(GPIOA, &GPIO_InitStructure);
72
}
73

74
/**
75
 * @brief 获取按键编号
76
 * 功能：根据按键状态返回按键编号
77
 * @return uint8_t 按键编号（1或2），如果没有按键按下则返回0
78
 */
79
uint8_t Key_GetNum(void)
80
{
81
  if (GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0) == 0)
82
  {
83
    vTaskDelay(20);
84
    if(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0) == 0){
85
      return 1;
86
    }
87
  }
88
  else if (GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_1) == 0)
89
  {
90
    vTaskDelay(20);
91
    if(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_1) == 0){
92
      return 2;
93
    }
94
  }
95
  else if (GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_15) == 0)
96
  {
97
    vTaskDelay(20);
98
    if(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_15) == 0){
99
      return 3;
100
    }
101
    }
102
    return 0;
103
}
104

105
// 任务配置宏定义
106
#define START_TASK_STACK_SIZE 128       // 启动任务栈大小（字）
107
#define START_TASK_PRIORITY 2           // 启动任务优先级（数值越小优先级越高）
108
#define TASK1_STACK_SIZE 128           // 任务1栈大小（字）
109
#define TASK1_PRIORITY 3               // 任务1优先级（数值越大优先级越高）
110
#define TASK2_STACK_SIZE 128           // 任务2栈大小（字）
111
#define TASK2_PRIORITY 4               // 任务2优先级（数值越大优先级越高）
112
#define TASK3_STACK_SIZE 128           // 任务3栈大小（字）
113
#define TASK3_PRIORITY 5               // 任务3优先级（数值越大优先级越高）
114
// 任务句柄声明（用于引用和管理任务）
115
TaskHandle_t MytaskHandler1;    // 任务1句柄
116
TaskHandle_t MytaskHandler2;    // 任务2句柄
117
TaskHandle_t MytaskHandler3;    // 任务3句柄
118
TaskHandle_t StarttaskHandler;  // 启动任务句柄
119
QueueHandle_t mutex_semaphore;        // 互斥信号量句柄
120

121

122
/**
123
 * @brief 低优先级任务1函数
124
 * 功能：
125
 * @param arg 任务参数（未使用）
126
 */
127
void low_Task1(void * arg){
128
    while(1){
129
        printf("low_Task1 等待信号量\r\n");
130
        xSemaphoreTake(mutex_semaphore, portMAX_DELAY);
131
        printf("low_Task1 running\r\n");
132
        Delay_ms(3000);
133
        printf("low_Task1 释放信号量\r\n");
134
        xSemaphoreGive(mutex_semaphore);
135
        vTaskDelay(1000);
136
    }
137

138
}
139

140

141
/**
142
 * @brief 中优先级任务2函数
143
 * 功能：
144
 * @param arg 任务参数（未使用）
145
 */
146
 void middle_Task2(void * arg){
147

148
    while(1){
149
        printf("middle_Task2 running\r\n");
150
        vTaskDelay(1000);
151
    }
152
}
153

154
/**
155
 * @brief 高优先级任务3函数
156
 * 功能：
157
 * @param arg 任务参数（未使用）
158
 */
159
 void high_Task3(void * arg){
160

161
    while(1){
162
        printf("high_Task3 等待信号量\r\n");
163
        xSemaphoreTake(mutex_semaphore, portMAX_DELAY);
164
        printf("high_Task3 running\r\n");
165
        Delay_ms(1000);
166
        printf("high_Task3 释放信号量\r\n");
167
        xSemaphoreGive(mutex_semaphore);
168
        vTaskDelay(1000);
169
    }
170
}
171

172

173

174
/**
175
 * @brief 启动任务函数
176
 * 功能：创建其他三个任务后自行删除
177
 * @param arg 任务参数（未使用）
178
 */
179
void Starttask(void * arg){
180
    // 进入临界区保护串口输出
181
    taskENTER_CRITICAL();
182
    printf("----------------------------\r\n");
183
    printf("Starttask running\r\n");  // 打印启动任务运行信息
184
    taskEXIT_CRITICAL();
185

186
    // 创建互斥信号量
187
    mutex_semaphore = xSemaphoreCreateMutex(); /*创建互斥信号量，并主动释放一次信号量，默认有效*/
188
    if(mutex_semaphore == NULL){
189
        printf("Mutex Semaphore create failed\r\n");
190
    }else{
191
        printf("Mutex Semaphore create success\r\n");
192
    }
193

194
    taskENTER_CRITICAL();
195
    // 使用动态内存分配方式创建任务1
196
    xTaskCreate(low_Task1,                        // 任务函数指针
197
               "MyFirstTask",                 // 任务名称（用于调试）
198
               TASK1_STACK_SIZE,         // 栈大小（字）
199
               NULL,                          // 传递给任务的参数
200
               TASK1_PRIORITY,           // 任务优先级
201
               &MytaskHandler1);              // 任务句柄指针
202

203
    // 使用动态内存分配方式创建任务2
204
    xTaskCreate(middle_Task2,
205
               "MySecondTask",
206
               TASK2_STACK_SIZE,
207
               NULL,
208
               TASK2_PRIORITY,
209
               &MytaskHandler2);
210

211
    // 使用动态内存分配方式创建任务3
212
    xTaskCreate(high_Task3,
213
               "MyThirdTask",
214
               TASK3_STACK_SIZE,
215
               NULL,
216
               TASK3_PRIORITY,
217
               &MytaskHandler3);
218
    taskEXIT_CRITICAL();
219

220
    // 删除当前任务（启动任务），释放其占用的资源
221
    vTaskDelete(NULL);
222
}
223

224
/**
225
 * @brief 主函数
226
 * 程序入口点，初始化硬件并启动RTOS调度器
227
 */
228
int main(void)
229
{
230
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
231
    LED_Init();                     // 初始化LED GPIO引脚
232
    Usart1_Init(115200);            // 初始化串口1，波特率115200
233
    Key_Init();                     // 初始化按键 GPIO引脚
234
    DWT_Init();                     // 初始化DWT定时器
235

236
    // 创建启动任务（使用动态内存分配）
237
    xTaskCreate(Starttask,                  // 任务函数指针
238
               "StartTask",                 // 任务名称
239
               START_TASK_STACK_SIZE,       // 栈大小
240
               NULL,                        // 任务参数
241
               START_TASK_PRIORITY,         // 任务优先级
242
               &StarttaskHandler);          // 任务句柄
243

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

247
    // 正常情况下，调度器启动后不会执行到这里
248
    // 如果调度器启动失败，程序将在此处循环
249
    while (1)
250
    {
251
        // 空循环，用于处理调度器启动失败的情况
252
    }
253
}