目的
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中用于任务之间配合工作的附加功能除了这几个还有其它一些,比如任务通知、事件组、流与消息缓冲区等。这些功能可以为项目开发带来更多的便利性,当然没有它们项目需求也能实现。有时间的话会在后续的文章中介绍这些功能。