原创 八、freeRTOS 队列

队列简介：

注意，队列长度并不是每个队列的字节数，而是能存多少条数据。如我们创建一个队列，每条消息最大10字节，队列可以保存4条消息，那么队列的长度为4。

队列的功能：

1 数据拷贝

为什么一定要使用数据拷贝？

考虑以下情况，我们在任务中创建了一个局部变量，而局部变量可能随时会被删掉，此时如果使用引用传递（指针），数据可能就会出现问题；另外，如果采用指针，则在这个变量被队列引用之前，变量值是不能改变的，这就意味着此时任务将不能继续随意使用此变量；如果采用数据拷贝，则不会出现上述问题。

2 多任务访问

队列不是属于某个特别指定的任务的，任何任务都可以向队列中发送消息，或者从队列中提取消息。

3 出队阻塞

4 入队阻塞

队列操作过程

1 创建队列

2 写入队列

3 读取队列

队列结构体原型：

1. typedef struct QueueDefinition
2. {
3. int8_t *pcHead; /* 指向队列存储区开始地址 */
4. int8_t *pcTail; /* 指向队列存储区最后一个字节 */
5. int8_t *pcWriteTo; /* 指向存储区中下一个空闲区域 */
7. union /* Use of a union is an exception to the coding standard to ensure two mutually exclusive structure members don't appear simultaneously (wasting RAM). */
8. {
9. int8_t *pcReadFrom; /* 当用作队列的时候指向最后一个出队的队列项首地址 */
10. UBaseType_t uxRecursiveCallCount; /* 当用作递归互斥量的时候用来记录递归互斥量被调用的次数 */
11. } u;
13. List_t xTasksWaitingToSend; /* 等待发送任务列表，那些因为队列满导致入队失败而进入阻塞态的任务就会挂到此列表上 */
14. List_t xTasksWaitingToReceive; /* 等待接收任务列表，那些因为队列空导致出队失败而进入阻塞态的任务就会挂到此列表上 */
16. volatile UBaseType_t uxMessagesWaiting; /* 队列中当前队列项数量，也就是消息数 */
17. UBaseType_t uxLength; /* 创建队列时指定的队列长度，也就是队列中最大允许的队列项(消息)数量 */
18. UBaseType_t uxItemSize; /* 创建队列时指定的每个队列项(消息)最大长度，单位字节 */
20. /* 当队列上锁以后用来统计从队列中接收到的队列项数量，也就是出队的队列项数量，当队列没有上锁的话此字段为 queueUNLOCKED */
21. volatile int8_t cRxLock;
22. /* 当队列上锁以后用来统计发送到队列中的队列项数量，也就是入队的队列项数量，当队列没有上锁的话此字段为 queueUNLOCKED */
23. volatile int8_t cTxLock;
25. #if ((configSUPPORT_STATIC_ALLOCATION == 1) && (configSUPPORT_DYNAMIC_ALLOCATION == 1))
26. uint8_t ucStaticallyAllocated; /* 如果使用静态存储的话此字段设置为 pdTURE */
27. #endif
29. #if (configUSE_QUEUE_SETS == 1)
30. struct QueueDefinition *pxQueueSetContainer;
31. #endif
33. #if (configUSE_TRACE_FACILITY == 1)
34. UBaseType_t uxQueueNumber;
35. uint8_t ucQueueType;
36. #endif
38. } xQUEUE;
40. typedef xQUEUE Queue_t;

创建队列

1 动态创建队列

函数原型：

实现的功能，就是动态内存申请需要大小的内存 = 消息数 × 消息长度，然后将队列存储区指针偏移到缓存区。

1. QueueHandle_t xQueueGenericCreate(const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, const uint8_t ucQueueType)
2. {
3. Queue_t *pxNewQueue;
4. size_t xQueueSizeInBytes;
5. uint8_t *pucQueueStorage;
7. configASSERT(uxQueueLength > (UBaseType_t)0);
9. if (uxItemSize == (UBaseType_t)0)
10. {
11. /* There is not going to be a queue storage area. */
12. xQueueSizeInBytes = (size_t)0;
13. }
14. else
15. {
16. /* Allocate enough space to hold the maximum number of items that
17. can be in the queue at any time. */
18. xQueueSizeInBytes = (size_t)(uxQueueLength * uxItemSize); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */
19. }
21. pxNewQueue = (Queue_t *)pvPortMalloc(sizeof(Queue_t) + xQueueSizeInBytes);
23. if (pxNewQueue != NULL)
24. {
25. /* Jump past the queue structure to find the location of the queue
26. storage area. */
27. pucQueueStorage = ((uint8_t *)pxNewQueue) + sizeof(Queue_t);
29. #if (configSUPPORT_STATIC_ALLOCATION == 1)
30. {
31. /* Queues can be created either statically or dynamically, so
32. note this task was created dynamically in case it is later
33. deleted. */
34. pxNewQueue->ucStaticallyAllocated = pdFALSE;
35. }
36. #endif /* configSUPPORT_STATIC_ALLOCATION */
38. prvInitialiseNewQueue(uxQueueLength, uxItemSize, pucQueueStorage, ucQueueType, pxNewQueue);
39. }
41. return pxNewQueue;
42. }

函数说明：

静态创建队列：

入队函数：

入队函数说明：

函数参数说明：

通用发送函数简单分析：

数据拷贝过程：

中断级队列发送：
 

下面是正点原子串口中断中发送队列的程序：

1. void USART1_IRQHandler(void) //串口1中断服务程序
2. {
3. u8 Res;
4. BaseType_t xHigherPriorityTaskWoken;
6. if (USART_GetITStatus(USART1, USART_IT_RXNE) != RESET) //接收中断(接收到的数据必须是0x0d 0x0a结尾)
7. {
8. Res = USART_ReceiveData(USART1); //读取接收到的数据
10. if ((USART_RX_STA & 0x8000) == 0) //接收未完成
11. {
12. if (USART_RX_STA & 0x4000) //接收到了0x0d
13. {
14. if (Res != 0x0a)
15. USART_RX_STA = 0; //接收错误,重新开始
16. else
17. USART_RX_STA |= 0x8000; //接收完成了
18. }
19. else //还没收到0X0D
20. {
21. if (Res == 0x0d)
22. USART_RX_STA |= 0x4000;
23. else
24. {
25. USART_RX_BUF[USART_RX_STA & 0X3FFF] = Res;
26. USART_RX_STA++;
27. if (USART_RX_STA > (USART_REC_LEN - 1))
28. USART_RX_STA = 0; //接收数据错误,重新开始接收
29. }
30. }
31. }
32. }
34. //就向队列发送接收到的数据
35. if ((USART_RX_STA & 0x8000) && (Message_Queue != NULL))
36. {
37. xQueueSendFromISR(Message_Queue, USART_RX_BUF, &xHigherPriorityTaskWoken); //向队列中发送数据
39. USART_RX_STA = 0;
40. memset(USART_RX_BUF, 0, USART_REC_LEN); //清除数据接收缓冲区USART_RX_BUF,用于下一次数据接收
42. portYIELD_FROM_ISR(xHigherPriorityTaskWoken); //如果需要的话进行一次任务切换
43. }
44. }

其实这个程序，个人觉得局限性比较大，因为它规定了数据格式。总体思路是，在串口接收中断中，将接收到的数据一个一个的保存到缓冲区里，等待串口数据接收完毕（可以通过读取寄存器标志位，串口空闲标志位来判断接收完毕）时，将缓冲区里的数据发送到队列中，然后清空缓冲区，并根据相关变量确定是否需要进行任务切换。

出队函数

删除读取队列函数参数说明：

不删除读取队列函数参数说明：

同样的，中断读取队列函数：

中断中进行任务切换的判别函数：

队列实验

设计2个任务，其中按键任务用于获取键值，并发送至队列；按键处理任务获取队列中的消息，并处理键值。

按键队列任务如下所示：

1. key_queue = xQueueCreate(1, sizeof(uint8_t)); // 创建按键队列
3. if (key_queue == NULL)
4. {
5. printf("按键队列创建失败!\n");
6. }
8. void key_task(void *pvParameters)
9. {
10. uint8_t key_value;
11. BaseType_t error_value;
12. for (;;)
13. {
14. if (key_scan(KEY1_GPIO_Port, KEY1_Pin) == KEY_ON)
15. {
16. key_value = 1;
17. if (key_queue != NULL)
18. {
19. // error_value = xQueueSendToBack(key_queue, &key_value, 10); // 发送键值至队列
20. error_value = xQueueOverwrite(key_queue, &key_value); // 覆盖发送键值至队列
21. if (error_value == errQUEUE_FULL)
22. {
23. printf("按键队列已满，消息发送失败!\n");
24. }
25. }
26. }
27. if (key_scan(KEY2_GPIO_Port, KEY2_Pin) == KEY_ON)
28. {
29. key_value = 2;
30. if (key_queue != NULL)
31. {
32. error_value = xQueueSendToBack(key_queue, &key_value, 10); // 发送键值至队列
33. if (error_value == errQUEUE_FULL)
34. {
35. printf("按键队列已满，消息发送失败!\n");
36. }
37. }
38. }
39. vTaskDelay(50);
40. }
41. }
43. void print_task(void *pvParameters)
44. {
45. uint8_t rx_key_value;
46. BaseType_t rx_queue_state;
47. for (;;)
48. {
49. if (key_queue != NULL)
50. {
51. // 等待从队列中读取数据
52. rx_queue_state = xQueueReceive(key_queue, &rx_key_value, portMAX_DELAY);
53. if (rx_queue_state == pdTRUE)
54. {
55. printf("key_value = %d\n", rx_key_value);
56. switch (rx_key_value)
57. {
58. case 1:
59. LED_RED;
60. break;
62. case 2:
63. LED_BLUE;
64. break;
66. default:
67. LED_ALL_OFF;
68. break;
69. }
70. }
71. }
72. vTaskDelay(50);
73. }
74. }

测试结果如下所示：

中断服务函数使用队列

这个比较复杂，总体思路是，在串口接受回调函数中，将接收到的数据保存至RX_BUFFER；在空闲中断中，将RX_BUFFER的数据全部发送至队列；在队列处理任务中，将队列中的数据读到TX_BUFFER中，然后打印输出。

1 使能接收中断和空闲中断

1. // 使能串口接收中断和空闲中断，并清除标志位
2. __HAL_UART_CLEAR_FLAG(&huart1, UART_FLAG_IDLE);
3. __HAL_UART_CLEAR_FLAG(&huart1, UART_FLAG_RXNE);
4. __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);
5. __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE);

2 接收中断处理中，将接收到的字符保存至RX_BUFFER缓冲区

1. // 串口数据接收完成，串口空闲时，将RX_BUFFER发送至队列
2. if (__HAL_UART_GET_FLAG(&huart1, UART_FLAG_IDLE))
3. {
4. i = 0;
5. // 发送RX_BUFFER至usart_queue队列
6. xQueueSendToBackFromISR(usart_queue, RX_BUFFER, &pxHigherPriorityTaskWoken);
7. // 判断是否需要进行任务切换
8. if (pxHigherPriorityTaskWoken == pdTRUE)
9. {
10. taskYIELD();
11. }
12. // 清空RX_BUFFER缓冲区
13. memset(RX_BUFFER, 0, USART_QUEUE_LEN);
14. // 清除空闲中断（依次读取SR DR）
15. temp = huart1.Instance->SR;
16. temp = huart1.Instance->DR;
17. }

整个串口中断服务函数如下所示：

1. void USART1_IRQHandler(void)
2. {
3. static uint16_t i = 0;
4. uint32_t temp;
6. // 保存接收数据到RX_BUFFER缓冲区
7. if (__HAL_UART_GET_FLAG(&huart1, UART_FLAG_RXNE))
8. {
9. RX_BUFFER[i++] = huart1.Instance->DR;
10. __HAL_UART_CLEAR_FLAG(&huart1, UART_FLAG_RXNE);
11. }
13. // 串口数据接收完成，串口空闲时，将RX_BUFFER发送至队列
14. if (__HAL_UART_GET_FLAG(&huart1, UART_FLAG_IDLE))
15. {
16. i = 0;
17. // 发送RX_BUFFER至usart_queue队列
18. xQueueSendToBackFromISR(usart_queue, RX_BUFFER, &pxHigherPriorityTaskWoken);
19. // 判断是否需要进行任务切换
20. if (pxHigherPriorityTaskWoken == pdTRUE)
21. {
22. taskYIELD();
23. }
24. // 清空RX_BUFFER缓冲区
25. memset(RX_BUFFER, 0, USART_QUEUE_LEN);
26. // 清除空闲中断（依次读取SR DR）
27. temp = huart1.Instance->SR;
28. temp = huart1.Instance->DR;
29. }
30. }

读取串口消息队列数据的任务如下所示：

1. void usart_task(void *pvParameters)
2. {
4. BaseType_t rx_queue_state;
5. for (; ;)
6. {
7. if (usart_queue != NULL)
8. {
9. // 等待从串口消息队列中读取数据
10. rx_queue_state = xQueueReceive(usart_queue, TX_BUFFER, portMAX_DELAY);
11. if (rx_queue_state == pdTRUE)
12. {
13. printf("%s\n", TX_BUFFER);
14. memset(TX_BUFFER, 0, USART_QUEUE_LEN);
15. }
16. }
17. vTaskDelay(50);
18. }
19. }

注意，这个实验要求，串口的中断优先级可以被屏蔽，即 ≥ 5（5为预设的屏蔽优先级，只有这样，才能在中断服务函数中使用fromISR函数，发送队列），如下所示：

测试结果如下所示：

完整的工程代码：

main.c

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"
10. #include "FreeRTOS.h"
11. #include "task.h"
12. #include "queue.h"
14. #include
16. #define USART_QUEUE_DEPTH 1
17. #define USART_QUEUE_LEN 100
19. void start_task(void *pvParameters);
20. void key_task(void *pvParameters);
21. void print_task(void *pvParameters);
22. void usart_task(void *pvParameters);
24. /* 任务相关参数 */
25. #define START_TASK_SIZE 128
26. #define START_TASK_PRIO 1
27. TaskHandle_t start_Task_Handle;
29. #define KEY_TASK_SIZE 128
30. #define KEY_TASK_PRIO 2
31. TaskHandle_t key_task_Handle;
33. #define PRINT_TASK_SIZE 128
34. #define PRINT_TASK_PRIO 3
35. TaskHandle_t print_task_Handle;
37. #define USART_TASK_SIZE 128
38. #define USART_TASK_PRIO 3
39. TaskHandle_t usart_task_Handle;
41. /* 队列相关参数 */
42. QueueHandle_t key_queue;
43. QueueHandle_t usart_queue;
45. uint8_t RX_BUFFER[USART_QUEUE_LEN]; // 串口接收缓冲区
46. uint8_t TX_BUFFER[USART_QUEUE_LEN]; // 串口发送缓冲区
48. int main(void)
49. {
50. HAL_Init();
51. SystemClock_Config();
52. MX_GPIO_Init();
53. MX_USART1_UART_Init();
54. MX_I2C1_Init();
55. MX_I2C2_Init();
57. // 使能串口接收中断和空闲中断，并清除标志位
58. __HAL_UART_CLEAR_FLAG(&huart1, UART_FLAG_IDLE);
59. __HAL_UART_CLEAR_FLAG(&huart1, UART_FLAG_RXNE);
60. __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);
61. __HAL_UART_ENABLE_IT(&huart1, UART_IT_RXNE);
63. // 创建开始任务
64. xTaskCreate((TaskFunction_t )start_task,
65. (char * )"start_task",
66. (uint16_t )START_TASK_SIZE,
67. (void * )NULL,
68. (UBaseType_t )START_TASK_PRIO,
69. (TaskHandle_t * )&start_Task_Handle);
71. vTaskStartScheduler(); // 开启调度器
72. }
75. void start_task(void *pvParameters)
76. {
77. taskENTER_CRITICAL();
79. /* 创建按键队列 */
80. key_queue = xQueueCreate(1, sizeof(uint8_t));
81. if (key_queue == NULL)
82. {
83. printf("按键队列创建失败!\n");
84. }
86. /* 创建串口消息队列 */
87. usart_queue = xQueueCreate(USART_QUEUE_DEPTH, USART_QUEUE_LEN);
88. if (usart_queue == NULL)
89. {
90. printf("串口消息队列创建失败!\n");
91. }
93. // 创建按键任务
94. xTaskCreate((TaskFunction_t )key_task,
95. (char * )"key_task",
96. (uint16_t )KEY_TASK_SIZE,
97. (void * )NULL,
98. (UBaseType_t )KEY_TASK_PRIO,
99. (TaskHandle_t * )&key_task_Handle);
100. // 创建消息处理任务
101. xTaskCreate((TaskFunction_t )print_task,
102. (char * )"print_task",
103. (uint16_t )PRINT_TASK_SIZE,
104. (void * )NULL,
105. (UBaseType_t)PRINT_TASK_PRIO,
106. (TaskHandle_t * )&print_task_Handle);
107. // 创建串口队列任务
108. xTaskCreate((TaskFunction_t )usart_task,
109. (char * )"usart_task",
110. (uint16_t )USART_TASK_SIZE,
111. (void * )NULL,
112. (UBaseType_t )USART_TASK_PRIO,
113. (TaskHandle_t * )&usart_task_Handle);
115. taskEXIT_CRITICAL();
116. // 删除开始任务
117. vTaskDelete(start_Task_Handle);
118. }
120. void key_task(void *pvParameters)
121. {
122. uint8_t key_value;
123. BaseType_t error_value;
124. for (;;)
125. {
126. if (key_scan(KEY1_GPIO_Port, KEY1_Pin) == KEY_ON)
127. {
128. key_value = 1;
129. if (key_queue != NULL)
130. {
131. // error_value = xQueueSendToBack(key_queue, &key_value, 10); // 发送键值至队列
132. error_value = xQueueOverwrite(key_queue, &key_value); // 覆盖发送键值至队列
133. if (error_value == errQUEUE_FULL)
134. {
135. printf("按键队列已满，消息发送失败!\n");
136. }
137. }
138. }
139. if (key_scan(KEY2_GPIO_Port, KEY2_Pin) == KEY_ON)
140. {
141. key_value = 2;
142. if (key_queue != NULL)
143. {
144. error_value = xQueueSendToBack(key_queue, &key_value, 10); // 发送键值至队列
145. if (error_value == errQUEUE_FULL)
146. {
147. printf("按键队列已满，消息发送失败!\n");
148. }
149. }
150. }
151. vTaskDelay(50);
152. }
153. }
155. void print_task(void *pvParameters)
156. {
157. uint8_t rx_key_value;
158. BaseType_t rx_queue_state;
159. for (;;)
160. {
161. if (key_queue != NULL)
162. {
163. // 等待从队列中读取数据
164. rx_queue_state = xQueueReceive(key_queue, &rx_key_value, portMAX_DELAY);
165. if (rx_queue_state == pdTRUE)
166. {
167. printf("key_value = %d\n", rx_key_value);
168. switch (rx_key_value)
169. {
170. case 1:
171. LED_RED;
172. break;
174. case 2:
175. LED_BLUE;
176. break;
178. default:
179. LED_ALL_OFF;
180. break;
181. }
182. }
183. }
184. vTaskDelay(50);
185. }
186. }
188. void usart_task(void *pvParameters)
189. {
191. BaseType_t rx_queue_state;
192. for (; ;)
193. {
194. if (usart_queue != NULL)
195. {
196. // 等待从串口消息队列中读取数据
197. rx_queue_state = xQueueReceive(usart_queue, TX_BUFFER, portMAX_DELAY);
198. if (rx_queue_state == pdTRUE)
199. {
200. printf("%s\n", TX_BUFFER);
201. memset(TX_BUFFER, 0, USART_QUEUE_LEN);
202. }
203. }
204. vTaskDelay(50);
205. }
206. }

中断服务函数：

1. void USART1_IRQHandler(void)
2. {
3. static uint16_t i = 0;
4. uint32_t temp;
6. // 保存接收数据到RX_BUFFER缓冲区
7. if (__HAL_UART_GET_FLAG(&huart1, UART_FLAG_RXNE))
8. {
9. RX_BUFFER[i++] = huart1.Instance->DR;
10. __HAL_UART_CLEAR_FLAG(&huart1, UART_FLAG_RXNE);
11. }
13. // 串口数据接收完成，串口空闲时，将RX_BUFFER发送至队列
14. if (__HAL_UART_GET_FLAG(&huart1, UART_FLAG_IDLE))
15. {
16. i = 0;
17. // 发送RX_BUFFER至usart_queue队列
18. xQueueSendToBackFromISR(usart_queue, RX_BUFFER, &pxHigherPriorityTaskWoken);
19. // 判断是否需要进行任务切换
20. if (pxHigherPriorityTaskWoken == pdTRUE)
21. {
22. taskYIELD();
23. }
24. // 清空RX_BUFFER缓冲区
25. memset(RX_BUFFER, 0, USART_QUEUE_LEN);
26. // 清除空闲中断（依次读取SR DR）
27. temp = huart1.Instance->SR;
28. temp = huart1.Instance->DR;
29. }
30. }