FreeRTOS入门（03）：队列信号量互斥量

Posted 2023-03-06 Naisu Xu

文章目录

• 目的
• 队列（queue）
• 信号量（semaphore）
• 互斥量（mutex）
• • 互斥量
  • 递归互斥量
• 总结

目的

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)  // 程序不会运行到这里

信号量（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 );

总结

队列、信号量、互斥量的使用比较简单，这几个也是大多数RTOS都有的功能。

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