目的
FreeRTOS提供给用户最核心的功能是任务（Task），实际项目中通常会有多个任务，任务间多数时候会需要配合工作，这时候就需要用到 队列、信号量、互斥量 等功能了，这篇文章将对相关内容做个介绍。
本文接上篇：《FreeRTOS入门（02）：任务基础使用与说明》
队列（queue）
队列是用于任务间传递数据最常用的东西。队列相当于一个缓存，可以向里面写数据，也可以从里面拿数据，遵循先进先出的原则（FIFO），先写入的数据在取的时候也会先取出。
向队列中写数据则队列的可用空间将减少，从队列中读取数据后该数据将从队列中删除，队列的可用空间会增加。如果队列已满的情况下向其中写数据将阻塞直到有空间可以写入；如果从队列中读取时队列为空将阻塞直到有数据可以读取。
读写操作时如果有多个任务都在等待，那么优先级最高的任务将先获得执行权限，如果优先级相同，那么等待时间最久的任务获得执行权限。
队列操作常用的一些函数如下：
// 创建队列，成功的话返回队列句柄，失败则返回NULL
// uxQueueLength为队列长度，uxItemSize为每个数据的容量（单位为字节）
QueueHandle_t xQueueCreate( UBaseType_t uxQueueLength, UBaseType_t uxItemSize );
// 将队列恢复到空的状态
BaseType_t xQueueReset( QueueHandle_t xQueue );
// 删除队列
void vQueueDelete( QueueHandle_t xQueue )
// 写入数据到队列（队尾）
// pvItemToQueue为数据起始地址指针，会从这里开始读入uxItemSize字节数据到队列
// xTicksToWait为队满无法写入时的写入操作超时时间（以Tick计，可以使用pdMS_TO_TICKS(ms)将毫秒时间转换成Tick）
// INCLUDE_vTaskSuspend为1时，xTicksToWait为portMAX_DELAY时将无限期阻塞（不会超时）
// 写入成功返回pdTRUE，否则返回errQUEUE_FULL
BaseType_t xQueueSend( QueueHandle_t xQueue, const void * pvItemToQueue, TickType_t xTicksToWait );
// 功能同上
BaseType_t xQueueSendToBack( QueueHandle_t xQueue, const void * pvItemToQueue, TickType_t xTicksToWait );
// 写入数据到队列（队尾）用于中断中使用，不会阻塞
// pxHigherPriorityTaskWoken可写NULL
BaseType_t xQueueSendFromISR( QueueHandle_t xQueue, const void *pvItemToQueue, BaseType_t *pxHigherPriorityTaskWoken);
// 功能同上
BaseType_t xQueueSendToBackFromISR( QueueHandle_t xQueue, const void *pvItemToQueue, BaseType_t *pxHigherPriorityTaskWoken);
// 写入数据到队列（队首）
// 写数据到队首其实不怎么符合队列本身设计思想的，不过特殊情况下还是有这个需求的
BaseType_t xQueueSendToFront( QueueHandle_t xQueue, const void * pvItemToQueue, TickType_t xTicksToWait );
// 写入数据到队列（队首）用于中断中使用，不会阻塞
BaseType_t xQueueSendToFrontFromISR( QueueHandle_t xQueue, const void *pvItemToQueue, BaseType_t *pxHigherPriorityTaskWoken);
// 从队列读取uxItemSize字节数据到pvBuffer，读取完成后队首指针将移动到下一个数据
// 成功返回pdTRUE，否则返回pdFALSE（超时）
BaseType_t xQueueReceive( QueueHandle_t xQueue, void *pvBuffer, TickType_t xTicksToWait );
// 上面函数用于中断中使用的形式，不会阻塞
BaseType_t xQueueReceiveFromISR( QueueHandle_t xQueue, void *pvBuffer, BaseType_t *pxHigherPriorityTaskWoken );
// 获取队首数据，并且队首指针不移动
BaseType_t xQueuePeek( QueueHandle_t xQueue, void *pvBuffer, TickType_t xTicksToWait );
// 上面函数用于中断中使用的形式，不会阻塞
BaseType_t xQueuePeekFromISR( QueueHandle_t xQueue, void *pvBuffer );
除了上面列出的一些操作队列的函数，还有一些查询队列以写、可写、队空、队满等功能的函数，如果有需要可以查询官方文档。
#include "debug.h"
#include "FreeRTOS.h" // 引入头文件
#include "task.h" // 引入头文件
#include "queue.h" // 引入头文件
QueueHandle_t xQueue; // 队列句柄
void task1(void *pvParameters) {
while(1)
{
int tick = xTaskGetTickCount();
xQueueSend(xQueue, &tick, portMAX_DELAY); // 向队列写数据
vTaskDelay(500);
}
}
void task2(void *pvParameters) {
while(1)
{
int data;
xQueueReceive(xQueue, &data, portMAX_DELAY); // 从队列读取数据
printf("Task2 data is %d\r\n", data);
}
}
int main(void) {
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
SystemCoreClockUpdate();
Delay_Init();
USART_Printf_Init(115200);
xQueue = xQueueCreate(3, 4); // 创建队列，队列长度为3，每个空间容纳4个字节
xTaskCreate(task1, "task1", 256, NULL, 5, NULL); // 创建一个任务
xTaskCreate(task2, "task2", 256, NULL, 5, NULL); // 创建一个任务
vTaskStartScheduler(); // 任务调度，任务将在这里根据情况开始运行，程序将在这里无序循环
while(1) {} // 程序不会运行到这里
}
FreeRTOS中并没有单独弄一个邮箱的功能模块，如果有需要可以使用长度为 1 的队列（queue），然后使用队列的 overwrite 和 peek 函数来操作，使用 overwrite 写数据时不会阻塞，使用 peek 读数据时只有初始队列为空时会阻塞，只要写入一次数据后就不会再阻塞了。
信号量（semaphore）
队列用于任务间传递数据使用，使用时会占据比较大的空间，而且读写性能稍差。有些时候任务间交互可能并不需要传递数据，只要知道 资源 有还是没有、或者有多少而已，这个时候使用信号量就比较好了。
信号量分为二进制信号量和计数信号量两种。二进制只有两个状态，表示资源有或者没有（也叫做二值信号量）；计数信号量可以表达出资源的数量。信号量的值比较常见的是0、1、2、3……，0表示没有资源可用。
写信号量时，如果不可写入也不会阻塞，会直接返回错误码，这是和队列最大的不同。读信号时如果没有资源则会阻塞。
信号量相关操作函数如下：
// 创建二进制信号量
SemaphoreHandle_t xSemaphoreCreateBinary( void )
// 创建计数信号量
// uxMaxCount为最大计数值，uxInitialCount为初始计数值
SemaphoreHandle_t xSemaphoreCreateCounting( UBaseType_t uxMaxCount, UBaseType_t uxInitialCount )
// 删除信号量
void vSemaphoreDelete( SemaphoreHandle_t xSemaphore )
// 给出资源，信号量的值+1，不会阻塞
// 操作成功返回pdTRUE，否则返回errQUEUE_FULL
xSemaphoreGive( SemaphoreHandle_t xSemaphore );
// 上面函数的中断函数中使用的版本
xSemaphoreGiveFromISR( SemaphoreHandle_t xSemaphore, signed BaseType_t *pxHigherPriorityTaskWoken )
// 获取资源，如果没有资源可用（值为0）则会阻塞知道可用，获取后信号量的值-1
// INCLUDE_vTaskSuspend为1时，xTicksToWait为portMAX_DELAY时将无限期阻塞（不会超时）
// 成功返回pdTRUE，否则返回pdFALSE（超时）
xSemaphoreTake( SemaphoreHandle_t xSemaphore, TickType_t xTicksToWait )
// 上面函数的中断函数中使用的版本
xSemaphoreTakeFromISR( SemaphoreHandle_t xSemaphore, signed BaseType_t *pxHigherPriorityTaskWoken )
// 返回信号量计数值
UBaseType_t uxSemaphoreGetCount( SemaphoreHandle_t xSemaphore )
下面是信号量使用演示：
#include "debug.h"
#include "FreeRTOS.h" // 引入头文件
#include "task.h" // 引入头文件
#include "semphr.h" // 引入头文件
SemaphoreHandle_t xSemaphore; // 信号量句柄
void task1(void *pvParameters) {
while(1)
{
// xSemaphore初始为1，最大为3
xSemaphoreGive(xSemaphore); // 给出 +1 = 2
xSemaphoreGive(xSemaphore); // 给出 +1 = 3
xSemaphoreGive(xSemaphore); // 给出 此处操作将失败
xSemaphoreGive(xSemaphore); // 给出 此处操作将失败
vTaskDelete(NULL);
}
}
void task2(void *pvParameters) {
while(1)
{
vTaskDelay(500);
xSemaphoreTake(xSemaphore, portMAX_DELAY); // 获取
printf("Tick: %d\r\n", xTaskGetTickCount()); // 此例中这行最终会打印三次
}
}
/* 主函数 */
int main(void) {
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
SystemCoreClockUpdate();
Delay_Init();
USART_Printf_Init(115200);
xSemaphore = xSemaphoreCreateCounting(3, 1); // 创建信号量，最大值3，初始值1
xTaskCreate(task1, "task1", 256, NULL, 5, NULL); // 创建一个任务
xTaskCreate(task2, "task2", 256, NULL, 5, NULL); // 创建一个任务
vTaskStartScheduler(); // 任务调度，任务将在这里根据情况开始运行，程序将在这里无序循环
while(1) {}
// 程序不会运行到这里
}
互斥量（mutex）
互斥量其实也是一种信号量，特别是普通的互斥量其实和二进制信号量挺像的。需要注意的是 中断函数中不能使用互斥量 。
互斥量
普通的互斥量，和二进制信号量很像，其它操作函数基本都是通用的（不能在中断中使用）。创建互斥量函数如下：
SemaphoreHandle_t xSemaphoreCreateMutex( void )
互斥量注意是用来对特定的资源（比如全局变量、外设等）进行保护用的。比如某个任务使用串口输出信息时，如果有优先级更高的任务插入进来，也使用这个串口输出信息，那可能最终串口输出的内容可能就会穿插糅合再一起了。这通常是不符合要求的，所以就需要用互斥量了。
互斥量也被叫做互斥锁，某个任务要用资源时先申请互斥量上个锁，用完资源后解锁。锁在被锁上的时候其它任务无法重复上锁，会阻塞到锁被释放后才能成功上锁。使用互斥量时需要注意的是上锁和解锁要成对出现，并且谁上锁谁就必须解锁。
下面是个互斥量使用演示：
#include "debug.h"
#include "FreeRTOS.h" // 引入头文件
#include "task.h" // 引入头文件
#include "semphr.h" // 引入头文件
SemaphoreHandle_t xMutex; // 互斥量句柄
void task(void *pvParameters) {
while(1)
{
xSemaphoreTake(xMutex, portMAX_DELAY); // 上锁
printf((const char *)pvParameters);
xSemaphoreGive(xMutex); // 解锁
vTaskDelay(5);
}
}
/* 主函数 */
int main(void) {
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
SystemCoreClockUpdate();
Delay_Init();
USART_Printf_Init(9600); // 9600波特率下每秒约可发送960字节
xMutex = xSemaphoreCreateMutex(); // 创建互斥量
xTaskCreate(task, "task1", 256, "USART1_Task1: ABCDEFGHIJKLMNOPQRSTUVWXYZ\r\n", 5, NULL); // 创建一个任务
xTaskCreate(task, "task2", 256, "USART1_Task2: 01234567890123456789\r\n", 7, NULL); // 创建一个任务 该任务优先级更高，会抢占前面的任务
vTaskStartScheduler(); // 任务调度，任务将在这里根据情况开始运行，程序将在这里无序循环
while(1) {} // 程序不会运行到这里
}
上面演示中 task2 有更高的优先级，会抢占 task1 ，所以 task2 有更多的机会运行，也就有更多时间可以使用串口输出信息。但是因为有互斥量存在，所以每个任务在上锁之后使用串口，在解锁前都可以独占串口，不会被抢占，所以最终都能完整的输出信息。
如果注释掉代码中上锁和解锁操作，那么最终输出会变成下面这样：
仔细看可以发现，因为 task2 有更高优先级，不会被 task1 抢占，所以 task2 可以完整的输出信息。但是 task1 输出过程中就会被 task2 插入打断。
递归互斥量
上面的互斥量有点像二进制信号量，而递归互斥量就有点像计数信号量。递归互斥量可以给多次上锁，但用完后上了几次锁就需要解几次锁。
递归互斥量部分函数也可以和上面公用，但下面几个是它特有的：
SemaphoreHandle_t xSemaphoreCreateRecursiveMutex( void )
xSemaphoreGiveRecursive( SemaphoreHandle_t xMutex )
xSemaphoreTakeRecursive( SemaphoreHandle_t xMutex, TickType_t xTicksToWait );
队列集（Queue Sets）
队列集是一个FreeRTOS功能， 可让任务（Task）同时从多个队列（Queue）和信号量（Semaphore）接收数据时进行阻塞（挂起）。获取队列集资源时，其中任意一个可用就可以，否则会阻塞。
队列集的使用方式如下：
// 需要将FreeRTOSConfig.h中configUSE_QUEUE_SETS设置为1
// 创建队列集
// uxEventQueueLength为需要容纳的总长度，队列和计数信号量为其自身长度、单个二进制信号量和互斥量长度为1
QueueSetHandle_t xQueueCreateSet(const UBaseType_t uxEventQueueLength)
// 将队列和信号量添加至队列集
// 需要注意的是要添加的对象必须为空才能添加
BaseType_t xQueueAddToSet(QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet)
// 发送方正常像队列集中的各个队列和信号量添加内容
// 比如xQueueSend()、xSemaphoreGive()等方法
// 接收方等待队列集中可用
QueueSetMemberHandle_t xQueueSelectFromSet(QueueSetHandle_t xQueueSet, const TickType_t xTicksToWait);
QueueSetMemberHandle_t xQueueSelectFromSetFromISR(QueueSetHandle_t xQueueSet);
// 另外已经添加队列集的内容也可以移除
BaseType_t xQueueRemoveFromSet(QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet)
下面是个简单的使用示例：
#include "debug.h"
#include "FreeRTOS.h" // 引入头文件
#include "task.h" // 引入头文件
#include "queue.h" // 引入头文件
#include "semphr.h" // 引入头文件
QueueHandle_t xQueue; // 队列句柄
SemaphoreHandle_t xSemaphore; // 信号量句柄
QueueSetHandle_t xQueueSet; // 队列集句柄
void task1(void *pvParameters) {
while(1)
{
vTaskDelay(700);
printf("Send Queue.\r\n");
int tick = xTaskGetTickCount();
xQueueSend(xQueue, &tick, portMAX_DELAY); // 向队列写数据
}
}
void task2(void *pvParameters) {
while(1)
{
vTaskDelay(1200);
printf("Give Semaphore.\r\n");
xSemaphoreGive(xSemaphore); // 给出信号量
}
}
void task3(void *pvParameters) {
while(1)
{
QueueSetMemberHandle_t xActivatedMember = xQueueSelectFromSet(xQueueSet, portMAX_DELAY); // 等待队列集可用
if( xActivatedMember == xQueue ) { // 如果队列可用
int data;
xQueueReceive( xActivatedMember, &data, 0 ); // 读取队列，此处已经可以读取了，也有没必要设置阻塞时间了
printf("QueueSet From Queue. Data is %d\r\n", data);
} else if( xActivatedMember == xSemaphore ) { // 如果信号量可用
printf("QueueSet From Semaphore.\r\n");
}
}
}
int main(void) {
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
SystemCoreClockUpdate();
Delay_Init();
USART_Printf_Init(115200);
xQueue = xQueueCreate(3, 4); // 创建队列，队列长度为3，每个空间容纳4个字节
xSemaphore = xSemaphoreCreateCounting(2, 0); // 创建信号量，最大值2，初始值0
xQueueSet = xQueueCreateSet(3+2); // 创建队列集
xQueueAddToSet(xQueue, xQueueSet); // 添加对象到队列集
xQueueAddToSet(xSemaphore, xQueueSet); // 添加对象到队列集
xTaskCreate(task1, "task1", 256, NULL, 5, NULL); // 创建一个任务
xTaskCreate(task2, "task2", 256, NULL, 5, NULL); // 创建一个任务
xTaskCreate(task3, "task3", 256, NULL, 3, NULL); // 创建一个任务
vTaskStartScheduler(); // 任务调度，任务将在这里根据情况开始运行，程序将在这里无序循环
while(1) {} // 程序不会运行到这里
}
总结
队列、信号量、互斥量的使用比较简单，这几个也是大多数RTOS都有的功能。
FreeRTOS中用于任务之间配合工作的附加功能除了这几个还有其它一些，比如任务通知、事件组、流与消息缓冲区等。这些功能可以为项目开发带来更多的便利性，当然没有它们项目需求也能实现。有时间的话会在后续的文章中介绍这些功能。
898
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
