FreeRTOS入门(03):队列、信号量、互斥量、队列集

本文介绍了FreeRTOS中用于任务间协同的几种机制,包括队列、信号量和互斥量。队列用于数据传输,遵循FIFO原则,信号量提供资源管理,分为二进制和计数两种,互斥量用于保护共享资源,防止并发访问冲突。此外,还提到了递归互斥量和队列集的概念,队列集允许任务同时等待多个队列或信号量的事件。
摘要由CSDN通过智能技术生成

目的

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

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Naisu Xu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值