原创 十一、freeRTOS 优先级翻转与互斥信号量

优先级翻转

优先级翻转简介：

就是高优先级的任务运行起来的效果好像成了低优先级，而低优先级比高优先级先运行。

优先级翻转如下所示：

优先级翻转过程：

为什么会发生优先级翻转？

因为两个任务（L和H）使用了同一个二值信号量，而在这两个任务之间，又有一个中等优先级的任务M，在这种情况下就容易发生优先级翻转。主要就是因为二值信号量产生的，低优先级任务L占用了信号量没有释放，导致高优先级任务请求信号量时无效，此时高优先级任务无法运行。

总体思路是，任务L和任务H都请求信号量，当接收到信号量时，任务H立马释放信号量，而任务L做软件延时占用一段时间后再释放信号量，看程序的执行流程。测试代码如下所示：

1. #include "main.h"
2. #include "i2c.h"
3. #include "usart.h"
4. #include "gpio.h"
6. #include "bsp_led.h"
7. #include "bsp_key.h"
8. #include "bsp_usart.h"
9. #include "bsp_beep.h"
11. #include "FreeRTOS.h"
12. #include "task.h"
13. #include "queue.h"
14. #include "semphr.h"
16. #include
18. void start_task(void *pvParameters);
19. void low_task(void *pvParameters);
20. void middle_task(void *pvParameters);
21. void high_task(void *pvParameters);
23. /* 任务相关参数 */
24. #define START_TASK_SIZE 256
25. #define START_TASK_PRIO 1
26. TaskHandle_t start_Task_Handle;
28. #define LOW_TASK_SIZE 256
29. #define LOW_TASK_PRIO 2
30. TaskHandle_t low_task_Handle;
32. #define MIDDLE_TASK_SIZE 256
33. #define MIDDLE_TASK_PRIO 3
34. TaskHandle_t middle_task_Handle;
36. #define HIGH_TASK_SIZE 256
37. #define HIGH_TASK_PRIO 4
38. TaskHandle_t high_task_Handle;
40. SemaphoreHandle_t binary_semphr = NULL; // 二值信号量句柄
42. int main(void)
43. {
44. HAL_Init();
45. SystemClock_Config();
46. MX_GPIO_Init();
47. MX_USART1_UART_Init();
48. MX_I2C1_Init();
49. MX_I2C2_Init();
51. // 创建开始任务
52. xTaskCreate((TaskFunction_t )start_task,
53. (char * )"start_task",
54. (uint16_t )START_TASK_SIZE,
55. (void * )NULL,
56. (UBaseType_t )START_TASK_PRIO,
57. (TaskHandle_t * )&start_Task_Handle);
59. vTaskStartScheduler(); // 开启调度器
60. }
62. void start_task(void *pvParameters)
63. {
64. taskENTER_CRITICAL();
66. binary_semphr = xSemaphoreCreateBinary(); // 创建信号量
67. if (binary_semphr != NULL)
68. {
69. printf("\n二值信号量创建成功");
70. xSemaphoreGive(binary_semphr); // 释放信号量
71. }
72. else
73. {
74. printf("\n二值信号量创建失败");
75. }
77. // 创建低优先级任务
78. xTaskCreate((TaskFunction_t )low_task,
79. (char * )"low_task",
80. (uint16_t )LOW_TASK_SIZE,
81. (void * )NULL,
82. (UBaseType_t )LOW_TASK_PRIO,
83. (TaskHandle_t * )&low_task_Handle);
84. // 创建中优先级任务
85. xTaskCreate((TaskFunction_t )middle_task,
86. (char * )"middle_task",
87. (uint16_t )MIDDLE_TASK_SIZE,
88. (void * )NULL,
89. (UBaseType_t )MIDDLE_TASK_PRIO,
90. (TaskHandle_t * )&middle_task_Handle);
91. // 创建高优先级任务
92. xTaskCreate((TaskFunction_t )high_task,
93. (char * )"high_task",
94. (uint16_t )HIGH_TASK_SIZE,
95. (void * )NULL,
96. (UBaseType_t )HIGH_TASK_PRIO,
97. (TaskHandle_t * )&high_task_Handle);
98. taskEXIT_CRITICAL();
99. // 删除开始任务
100. vTaskDelete(start_Task_Handle);
101. }
103. void low_task(void *pvParameters)
104. {
105. BaseType_t error_state;
106. uint32_t limit;
107. for (;;)
108. {
109. if (binary_semphr != NULL)
110. {
111. // 一直等待二值信号量
112. error_state = xSemaphoreTake(binary_semphr, portMAX_DELAY);
113. if (error_state == pdTRUE)
114. {
115. printf("\n低优先级任务获取到信号量，正在占用...");
116. }
117. else
118. {
119. printf("\n低优先级任务获取信号量失败");
120. }
121. #if 1
122. // 模拟低优先级占用信号量
123. for (limit = 0; limit < 5000000; limit++)
124. {
125. taskYIELD(); // 一直调用任务切换
126. }
127. #else
128. HAL_Delay(8000);
129. #endif
130. // 释放二值信号量
131. printf("\n低优先级任务占用信号量结束，即将释放");
132. xSemaphoreGive(binary_semphr);
133. }
134. vTaskDelay(500);
135. }
136. }
138. void middle_task(void *pvParameters)
139. {
140. for (;;)
141. {
142. printf("\n中优先级任务正在运行");
143. vTaskDelay(1000);
144. }
145. }
147. void high_task(void *pvParameters)
148. {
149. for (;;)
150. {
151. if (binary_semphr != NULL)
152. {
153. printf("\n高优先级任务正在等待信号量...");
154. // 一直等待二值信号量
155. xSemaphoreTake(binary_semphr, portMAX_DELAY);
156. printf("\n高优先级任务获取到信号量，即将释放...");
157. xSemaphoreGive(binary_semphr); // 释放信号量
158. }
159. vTaskDelay(1000);
160. }
161. }

程序运行结果如下所示：

互斥信号量

互斥信号量简介：

创建互斥信号量：

测试实验：修改上一个优先级翻转的实验，看测试结果。

修改过程：将使用二值信号量的地方修改成使用互斥信号量。

修改如下：

1. void start_task(void *pvParameters)
2. {
3. taskENTER_CRITICAL();
5. mutex_semphr = xSemaphoreCreateMutex(); // 创建互斥信号量
6. if (mutex_semphr != NULL)
7. {
8. printf("\n互斥信号量创建成功");
9. xSemaphoreGive(mutex_semphr); // 释放信号量
10. }
11. else
12. {
13. printf("\n互斥信号量创建失败");
14. }
16. // 创建低优先级任务
17. xTaskCreate((TaskFunction_t )low_task,
18. (char * )"low_task",
19. (uint16_t )LOW_TASK_SIZE,
20. (void * )NULL,
21. (UBaseType_t )LOW_TASK_PRIO,
22. (TaskHandle_t * )&low_task_Handle);
23. // 创建中优先级任务
24. xTaskCreate((TaskFunction_t )middle_task,
25. (char * )"middle_task",
26. (uint16_t )MIDDLE_TASK_SIZE,
27. (void * )NULL,
28. (UBaseType_t )MIDDLE_TASK_PRIO,
29. (TaskHandle_t * )&middle_task_Handle);
30. // 创建高优先级任务
31. xTaskCreate((TaskFunction_t )high_task,
32. (char * )"high_task",
33. (uint16_t )HIGH_TASK_SIZE,
34. (void * )NULL,
35. (UBaseType_t )HIGH_TASK_PRIO,
36. (TaskHandle_t * )&high_task_Handle);
37. taskEXIT_CRITICAL();
38. // 删除开始任务
39. vTaskDelete(start_Task_Handle);
40. }
42. void low_task(void *pvParameters)
43. {
44. BaseType_t error_state;
45. uint32_t limit;
46. for (;;)
47. {
48. if (mutex_semphr != NULL)
49. {
50. // 一直等待互斥信号量
51. error_state = xSemaphoreTake(mutex_semphr, portMAX_DELAY);
52. if (error_state == pdTRUE)
53. {
54. printf("\n低优先级任务获取到信号量，正在占用...");
55. }
56. else
57. {
58. printf("\n低优先级任务获取信号量失败");
59. }
60. #if 0
61. // 模拟低优先级占用信号量
62. for (limit = 0; limit < 5000000; limit++)
63. {
64. taskYIELD(); // 一直调用任务切换
65. }
66. #else
67. HAL_Delay(10000);
68. #endif
69. // 释放互斥信号量
70. printf("\n低优先级任务占用信号量结束，即将释放");
71. xSemaphoreGive(mutex_semphr);
72. }
73. vTaskDelay(500);
74. }
75. }
77. void middle_task(void *pvParameters)
78. {
79. for (;;)
80. {
81. printf("\n中优先级任务正在运行");
82. vTaskDelay(1000);
83. }
84. }
86. void high_task(void *pvParameters)
87. {
88. for (;;)
89. {
90. if (mutex_semphr != NULL)
91. {
92. printf("\n高优先级任务正在等待信号量...");
93. // 一直等待互斥信号量
94. xSemaphoreTake(mutex_semphr, portMAX_DELAY);
95. printf("\n高优先级任务获取到信号量，即将释放...");
96. xSemaphoreGive(mutex_semphr); // 释放信号量
97. }
98. vTaskDelay(1000);
99. }
100. }

测试效果如下：

递归互斥信号量：

 转载于：https://blog.csdn.net/dingyc_ee/article/details/104115367