ESP32学习笔记_FreeRTOS(2)——Queue

已于 2024-11-24 21:27:46 修改
阅读量822 收藏 24
点赞数 26
CC 4.0 BY-SA版权
分类专栏： ESP32 文章标签： 学习 笔记 ESP32 c语言
于 2024-11-24 21:26:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/flashier/article/details/143958501

摘要(From AI):
在嵌入式系统开发中，任务之间的高效通信是实现多任务协作的关键。FreeRTOS 提供了强大的队列机制，支持任务之间安全、灵活地传递数据，是实现任务同步和事件通知的核心工具。本篇博客将全面解析 FreeRTOS 队列的工作原理和应用场景，从基础操作到高级功能（如队列集合和邮箱）的深入探讨

前言：本文档是本人在依照B站UP：Michael_ee的视频教程进行学习时所做的学习笔记，可能存在疏漏和错误，如有发现，望指正。

上一篇：ESP32学习笔记_FreeRTOS(1)——Task的创建和使用

文章目录

参考资料：

BiliBili——Michael_ee视频教程
freeRTOS官网
espressif 在线文档

Queue

FreeRTOS 中的队列 (Queue) 是一种重要的任务间通信机制，用于在任务与任务或任务与中断之间传递数据。它通过先进先出 (FIFO) 的方式存储和传递信息，并提供线程安全的访问保障，避免了多任务同时操作共享资源时的竞争问题。队列支持阻塞操作，任务可以等待数据或空位出现，从而简化了任务的同步与协作

队列在嵌入式系统中有广泛的应用，例如传感器数据采集、事件通知、日志记录等。通过队列，生产者任务可以将数据发送到队列中，消费者任务从中读取并处理数据。这种机制既提高了系统的可靠性，又降低了任务间通信的复杂度，是实时操作系统中不可或缺的功能之一

Queue Delivery Data

队列本质上就类似于一个 Buffer

Creating a Queue

xQueueCreate()

xQueueCreate() 是 FreeRTOS 中用于创建队列的函数。队列是 FreeRTOS 中用于在任务之间或任务与中断之间传递数据的机制。该函数会自动从 FreeRTOS 的堆中分配所需的 RAM，用于存储队列的状态和数据项

#include “FreeRTOS.h”
#include “queue.h”

QueueHandle_t xQueueCreate( UBaseType_t uxQueueLength, UBaseType_t uxItemSize );

uxQueueLength队列可以容纳的最大数据项数
uxItemSize队列中每个数据项的大小（以字节为单位）
QueueHandle_t 队列创建成功，返回的值是用于引用队列的句柄，如果是 NULL，则队列创建失败

Sending Data to a Queue

xQueueSend(), xQueueSendToFront(),xQueueSendToBack()

这三个函数用于将数据项发送（写入）到 FreeRTOS 队列中。

  • xQueueSend() 和 xQueueSendToBack()：
    • 功能相同，均用于将数据发送到队列的末尾（队尾）。
    • xQueueSend() 是较早的版本，推荐使用 xQueueSendToBack() 替代。
  • xQueueSendToFront()：
    • 用于将数据发送到队列的前端（队首）
#include “FreeRTOS.h”
#include “queue.h”

BaseType_t xQueueSend( QueueHandle_t xQueue, 
					  const void * pvItemToQueue, 
					  TickType_t xTicksToWait );

BaseType_t xQueueSendToFront( QueueHandle_t xQueue, 
							 const void * pvItemToQueue, 
							 TickType_t xTicksToWait );

BaseType_t xQueueSendToBack( QueueHandle_t xQueue,
							const void * pvItemToQueue,
							TickType_t xTicksToWait );
  • xQueue
    • 队列的句柄，由 xQueueCreate() 或 xQueueCreateStatic() 创建队列时返回。
  • pvItemToQueue
    • 指向要写入队列的数据的指针
    • 队列创建时已经指定了每个数据项的大小，因此将从 pvItemToQueue 中复制相应字节数到队列存储区
  • xTicksToWait
    • 如果队列已满，任务进入 Blocked 状态等待空间可用时的最大等待时间
    • 以“系统时钟节拍（ticks）”为单位。
      • 使用宏 pdMS_TO_TICKS() 将毫秒时间转换为时钟节拍时间
      • 设置为 portMAX_DELAY 时，任务将无限期等待，前提是INCLUDE_vTaskSuspend 在 FreeRTOSConfig.h 中设置为 1
    • 若 xTicksToWait 为 0，函数会立即返回，而不等待

返回值：
pdPASS 数据成功写入队列；如果指定了等待时间，可能会发生任务进入 Blocked 状态等待队列有空间后再成功写入的情况
errQUEUE_FULL 队列已满，无法写入数据;如果指定了等待时间，但在等待期间队列仍未腾出空间，函数返回此值

Receiving Data from a Queue

xQueueReceive()

xQueueReceive() 用于从 FreeRTOS 队列中接收（读取）数据项

#include “FreeRTOS.h”
#include “queue.h”

BaseType_t xQueueReceive( QueueHandle_t xQueue, 
						 void *pvBuffer, 
						 TickType_t xTicksToWait );

参数说明：

  • xQueue
    • 队列的句柄，由 xQueueCreate() 或 xQueueCreateStatic() 创建队列时返回
    • 指定要从中读取数据的队列
  • pvBuffer
    • 指向一个缓冲区的指针，用于存储从队列中读取的数据。
    • 缓冲区的大小必须至少等于队列中每个数据项的大小（在创建队列时由 uxItemSize 指定）
  • xTicksToWait
    • 如果队列为空，任务进入 Blocked 状态等待数据可用的最大等待时间
    • 以“系统时钟节拍（ticks）”为单位
    • 若 xTicksToWait 为 0，函数会立即返回，而不等待

返回值：

  1. pdPASS
    • 成功从队列中读取到数据
    • 如果指定了等待时间，可能会发生任务进入 Blocked 状态等待数据写入队列后再成功读取的情况
  2. errQUEUE_EMPTY
    • 队列为空，未能读取到数据
    • 如果指定了等待时间，但在等待期间队列中始终无数据写入，函数返回此值

Checking Queue Parameters

uxQueueMessagesWaiting()

uxQueueMessagesWaiting() 用于查询当前队列中存储的项数量

#include “FreeRTOS.h”
#include “queue.h”

UBaseType_t uxQueueMessagesWaiting( const QueueHandle_t xQueue );
  • 返回队列中当前存储的项数量（即队列中未被读取的消息数）

Example Code: Working with FreeRTOS Queues

// 传递数据为整形
#include <stdio.h>  
#include <inttypes.h>  
#include "sdkconfig.h"  
#include "freertos/FreeRTOS.h"  
#include "freertos/task.h"  
#include "esp_chip_info.h"  
#include "esp_flash.h"  
#include "esp_system.h"  
  
#include "freertos/queue.h" // 包括队列头文件  
  
void sendTask(void *pvPamra)  
{  
    QueueHandle_t myQueueHandle = (QueueHandle_t)pvPamra; // 从pvPamra中取出队列句柄  
    BaseType_t xStatus;  
    int i = 0;  
    while (true)  
    {  
        xStatus = xQueueSend(myQueueHandle, &i, 0); // 发送数据到Queue，等待时间为0  
        if (xStatus == pdPASS)  
            printf("Send %d to queue.\n", i);  
        else  
            printf("Send %d to queue failed.\n", i);  
        i++;  
        if (i == 8)  
            i = 0;  
        printf("sendTask is running.\n");  
        vTaskDelay(3000 / portTICK_PERIOD_MS);  
    }  
}  
  
void receiveTask(void *pvPamra)  
{  
    QueueHandle_t myQueueHandle = (QueueHandle_t)pvPamra; // 从pvPamra中取出队列句柄  
    BaseType_t xStatus;  
    int i = 0; // 因为Queue中的数据类型是int，所以要用int类型接收  
  
    while (true)  
    {  
        if (uxQueueMessagesWaiting(myQueueHandle) != 0)  
        {  
            xStatus = xQueueReceive(myQueueHandle, &i, 0); // 从Queue中接收数据  
            if (xStatus == pdPASS)  
                printf("Receive %d from queue.\n", i);  
            else  
                printf("Receive data from queue failed.\n");  
        }  
        else  
            printf("Queue is empty.\n"); // 如果Queue为空，则打印Queue为空  
  
        printf("receiveTask is running.\n");  
        vTaskDelay(1000 / portTICK_PERIOD_MS);  
    }  
}  
  
void app_main(void)  
{  
    TaskHandle_t myHandle = NULL;  
    TaskHandle_t myHandle2 = NULL;  
    QueueHandle_t myQueueHandle = xQueueCreate(5, sizeof(int)); // 创建一个队列，队列长度为5，每个元素大小为int  
    if (myQueueHandle != NULL)  
    {  
        printf("Queue created successfully.\n"); // 当Queue创建成功后，创建两个任务，一个发送任务，一个接收任务  
        xTaskCreate(sendTask, "sendTask", 1024 * 5, (void *)myQueueHandle, 1, &myHandle);  
        xTaskCreate(receiveTask, "receiveTask", 1024 * 5, (void *)myQueueHandle, 1, &myHandle2);  
    }  
    else  
    {  
        printf("Queue creation failed.\n");  
    }  
}

/* --------------------------------------- */

// 传递数据为结构体
#include <stdio.h>  
#include <inttypes.h>  
#include "sdkconfig.h"  
#include "freertos/FreeRTOS.h"  
#include "freertos/task.h"  
#include "esp_chip_info.h"  
#include "esp_flash.h"  
#include "esp_system.h"  
  
#include "freertos/queue.h" // 包括队列头文件  
  
typedef struct AData  
{  
    int m_id;  
    int m_data;  
} xStruct;  
  
void sendTask(void *pvPamra)  
{  
    QueueHandle_t myQueueHandle = (QueueHandle_t)pvPamra; // 从pvPamra中取出队列句柄  
    BaseType_t xStatus;  
    xStruct xUSB = {1, 2};  
    while (true)  
    {  
        xStatus = xQueueSend(myQueueHandle, &xUSB, 0); // 发送数据到Queue，等待时间为0  
        if (xStatus == pdPASS)  
            printf("Send id %d to queue.\n", xUSB.m_id);  
        else  
            printf("Send id %d to queue failed.\n", xUSB.m_id);  
        xUSB.m_id++;  
        printf("sendTask is running.\n");  
        vTaskDelay(1000 / portTICK_PERIOD_MS);  
    }  
}  
  
void receiveTask(void *pvPamra)  
{  
    QueueHandle_t myQueueHandle = (QueueHandle_t)pvPamra; // 从pvPamra中取出队列句柄  
    BaseType_t xStatus;  
    xStruct xUSB = {0, 0}; // 因为Queue中的数据类型是int，所以要用int类型接收  
  
    while (true)  
    {  
        if (uxQueueMessagesWaiting(myQueueHandle) != 0)  
        {  
            xStatus = xQueueReceive(myQueueHandle, &xUSB, 0); // 从Queue中接收数据  
            if (xStatus == pdPASS)  
                printf("Receive id %d from queue.Data is %d\n", xUSB.m_id, xUSB.m_data);  
            else  
                printf("Receive data from queue failed.\n");  
        }  
        else  
            printf("Queue is empty.\n"); // 如果Queue为空，则打印Queue为空  
  
        printf("receiveTask is running.\n");  
        vTaskDelay(1000 / portTICK_PERIOD_MS);  
    }  
}  
  
void app_main(void)  
{  
    TaskHandle_t myHandle = NULL;  
    TaskHandle_t myHandle2 = NULL;  
    QueueHandle_t myQueueHandle = xQueueCreate(5, sizeof(xStruct)); // 创建一个队列，队列长度为5，每个元素大小为xStruct的大小  
    if (myQueueHandle != NULL)  
    {  
        printf("Queue created successfully.\n"); // 当Queue创建成功后，创建两个任务，一个发送任务，一个接收任务  
        xTaskCreate(sendTask, "sendTask", 1024 * 5, (void *)myQueueHandle, 1, &myHandle);  
        xTaskCreate(receiveTask, "receiveTask", 1024 * 5, (void *)myQueueHandle, 1, &myHandle2);  
    }  
    else  
    {  
        printf("Queue creation failed.\n");  
    }  
}

/* --------------------------------------- */

// 传递数据为指针
#include <stdio.h>  
#include <inttypes.h>  
#include "sdkconfig.h"  
#include "freertos/FreeRTOS.h"  
#include "freertos/task.h"  
#include "esp_chip_info.h"  
#include "esp_flash.h"  
#include "esp_system.h"  
  
#include "freertos/queue.h" // 包括队列头文件  
  
  
void sendTask(void *pvPamra)  
{  
    QueueHandle_t myQueueHandle = (QueueHandle_t)pvPamra; // 从pvPamra中取出队列句柄  
    char* pStrToSend = NULL;  
    int id = 0;  
    BaseType_t xStatus;  
  
    while (true)  
    {  
        pStrToSend = (char*)malloc(50);  
        snprintf(pStrToSend, 50, "Hello World! id:%d\n", id);  
        xStatus = xQueueSend(myQueueHandle, &pStrToSend, 0);  
        if (xStatus == pdPASS)  
            printf("Send id %d to queue.\n", id);      
        else  
            printf("Send id %d to queue failed.\n", id);  
        id++;  
        printf("sendTask is running.\n");  
        vTaskDelay(1000 / portTICK_PERIOD_MS);  
    }  
}  
  
void receiveTask(void *pvPamra)  
{  
    QueueHandle_t myQueueHandle = (QueueHandle_t)pvPamra; // 从pvPamra中取出队列句柄  
    BaseType_t xStatus;  
    char* pStrToReceive = NULL;  
  
    while (true)  
    {  
        if (uxQueueMessagesWaiting(myQueueHandle) != 0)  
        {  
            xStatus = xQueueReceive(myQueueHandle, &pStrToReceive, 0); // 从Queue中接收数据  
            if (xStatus == pdPASS)  
            {  
                printf("Receive data: %s\n", pStrToReceive);  
                free(pStrToReceive);// 释放内存，防止内存泄漏
                // 注意要在接收数据后再释放内存，否则会收不到数据  
            }  
            else  
                printf("Receive data from queue failed.\n");  
        }  
        else  
            printf("Queue is empty.\n"); // 如果Queue为空，则打印Queue为空  
  
        printf("receiveTask is running.\n");  
        vTaskDelay(1000 / portTICK_PERIOD_MS);  
    }  
}  
  
void app_main(void)  
{  
    TaskHandle_t myHandle = NULL;  
    TaskHandle_t myHandle2 = NULL;  
    QueueHandle_t myQueueHandle = xQueueCreate(5, sizeof(char*)); // 创建一个队列，队列长度为5，每个元素大小为char*的大小  
    if (myQueueHandle != NULL)  
    {  
        printf("Queue created successfully.\n"); // 当Queue创建成功后，创建两个任务，一个发送任务，一个接收任务  
        xTaskCreate(sendTask, "sendTask", 1024 * 5, (void *)myQueueHandle, 1, &myHandle);  
        xTaskCreate(receiveTask, "receiveTask", 1024 * 5, (void *)myQueueHandle, 1, &myHandle2);  
    }  
    else  
    {  
        printf("Queue creation failed.\n");  
    }  
}

Queue Multiple In Single Out

Queue 可以同时有多个输入，一个输出，可以根据实际需求进行调整

#include <stdio.h>  
#include <inttypes.h>  
#include "sdkconfig.h"  
#include "freertos/FreeRTOS.h"  
#include "freertos/task.h"  
#include "esp_chip_info.h"  
#include "esp_flash.h"  
#include "esp_system.h"  
  
#include "freertos/queue.h" // 包括队列头文件  
  
void sendTask1(void *pvPamra)  
{  
    QueueHandle_t myQueueHandle = (QueueHandle_t)pvPamra; // 从pvPamra中取出队列句柄  
  
    int id = 111;  
    BaseType_t xStatus;  
  
    while (true)  
    {  
        xStatus = xQueueSend(myQueueHandle, &id, 0);  
        if (xStatus == pdPASS)  
            printf("Send id %d to queue.\n", id);  
        else  
            printf("Send id %d to queue failed.\n", id);  
        printf("sendTask is running.\n");  
        vTaskDelay(1000 / portTICK_PERIOD_MS);  
    }  
}  
  
void sendTask2(void *pvPamra)  
{  
    QueueHandle_t myQueueHandle = (QueueHandle_t)pvPamra; // 从pvPamra中取出队列句柄  
  
    int id = 222;  
    BaseType_t xStatus;  
  
    while (true)  
    {  
        xStatus = xQueueSend(myQueueHandle, &id, 0);  
        if (xStatus == pdPASS)  
            printf("Send id %d to queue.\n", id);  
        else  
            printf("Send id %d to queue failed.\n", id);  
        printf("sendTask2 is running.\n");  
        vTaskDelay(1000 / portTICK_PERIOD_MS);  
    }  
}  
  
void receiveTask(void *pvPamra)  
{  
    QueueHandle_t myQueueHandle = (QueueHandle_t)pvPamra; // 从pvPamra中取出队列句柄  
    BaseType_t xStatus;  
    int id = 0;  
  
    while (true)  
    {  
        xStatus = xQueueReceive(myQueueHandle, &id, portMAX_DELAY); // 从Queue中接收数据，等待时间无限长，直至收到数据  
        // 同时由于接收优先级高于发送，所以当Queue不为空时，必定能收到数据  
        // 优先级高的任务会先执行，之后再执行优先级低的任务  
        // 所以此时只有在收到数据后，才能执行下一次发送  
        // 实际使用时，应根据实际需求，设置合理的优先级  
  
        if (xStatus == pdPASS)  
        {  
            printf("Receive data: %d\n", id);  
        }  
        else  
            printf("Receive data from queue failed.\n");  
        printf("receiveTask is running.\n");  
    }  
}  
  
void app_main(void)  
{  
    TaskHandle_t myHandle = NULL;  
    TaskHandle_t myHandle2 = NULL;  
    TaskHandle_t myHandle3 = NULL;  
    QueueHandle_t myQueueHandle = xQueueCreate(5, sizeof(int)); // 创建一个队列，队列长度为5，每个元素大小为int的大小  
    if (myQueueHandle != NULL)  
    {  
        printf("Queue created successfully.\n"); // 当Queue创建成功后，创建两个任务，一个发送任务，一个接收任务  
        xTaskCreate(sendTask1, "sendTask1", 1024 * 5, (void *)myQueueHandle, 1, &myHandle);  
        xTaskCreate(sendTask2, "sendTask2", 1024 * 5, (void *)myQueueHandle, 1, &myHandle2);  
        xTaskCreate(receiveTask, "receiveTask", 1024 * 5, (void *)myQueueHandle, 2, &myHandle3); // 接收优先级高于发送  
    }  
    else  
    {  
        printf("Queue creation failed.\n");  
    }  
}

Queue Set

队列集合（Queue Set）适用于当有多个 Task 同时向各自的 Queue 中写入数据，但都需要被一个 Task 读取时的情况
在需要单任务从多个源（队列或信号量）中高效获取数据时，Queue Set 比传统方法更优

xQueueCreateSet()

队列集合（Queue Sets）是一种机制，允许实时操作系统（RTOS）的任务在多个队列或信号量的读取操作上同时阻塞（挂起）

#include “FreeRTOS.h”
#include “queue.h”

QueueSetHandle_t xQueueCreateSet( const UBaseType_t uxEventQueueLength );

使用说明

  1. 创建队列集合
    队列集合需通过调用 xQueueCreateSet() 显式创建后才能使用

  2. 添加队列和信号量
    使用 xQueueAddToSet() 将标准 FreeRTOS 队列和信号量加入集合

  3. 选择队列或信号量
    调用 xQueueSelectFromSet() 判断集合中是否有队列或信号量可被成功读取或获取

参数

  • uxEventQueueLength 队列集合存储其包含的队列和信号量上的事件，uxEventQueueLength 指定事件队列的最大长度。为防止事件丢失，需根据以下规则设置：队列长度之和 + 二元信号量或互斥量的长度（1） + 计数信号量的最大计数值。

返回值

  • NULL 创建失败
  • 其他值 创建成功，返回队列集合的句柄

xQueueAddToSet()

xQueueAddToSet() 用于将队列或信号量添加到先前由 xQueueCreateSet() 创建的队列集合中

#include “FreeRTOS.h”
#include “queue.h”

BaseType_t xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore,
						  QueueSetHandle_t xQueueSet );

参数

  • xQueueOrSemaphore：要添加到队列集合中的队列或信号量的句柄，需强制转换为 QueueSetMemberHandle_t 类型。
  • xQueueSet：目标队列集合的句柄。

返回值

  • pdPASS：成功将队列或信号量添加到队列集合中。
  • pdFAIL：添加失败，因为该队列或信号量已属于另一个队列集合。

注意事项

  • 在调用 xQueueSelectFromSet() 并获取到集合成员的句柄之前，不可对队列集合中的队列执行接收操作或对信号量执行获取操作
  • 在 FreeRTOSConfig.h 文件中，必须将 configUSE_QUEUE_SETS 设置为 1，否则无法使用 xQueueAddToSet()

xQueueSelectFromSet()

xQueueSelectFromSet() 用于从队列集合中选择一个队列或信号量

#include “FreeRTOS.h”
#include “queue.h”

QueueSetMemberHandle_t xQueueSelectFromSet( QueueSetHandle_t xQueueSet,
										   const TickType_t xTicksToWait );

参数

  • xQueueSet 队列集合的句柄，任务将可能在此集合上阻塞
  • xTicksToWait 任务等待的最大时间（以系统时钟节拍为单位），在此期间任务将处于阻塞状态

返回值
NULL 在 xTicksToWait 指定的时间内，集合中的队列或信号量未变为可用。
其他值 集合中可用的队列（或信号量）的句柄，强制转换为 QueueSetMemberHandle_t 类型。

Example Code:Queue Sets in FreeRTOS

#include <stdio.h>  
#include <inttypes.h>  
#include "sdkconfig.h"  
#include "freertos/FreeRTOS.h"  
#include "freertos/task.h"  
#include "esp_chip_info.h"  
#include "esp_flash.h"  
#include "esp_system.h"  
  
#include "freertos/queue.h" // 包括队列头文件  
  
void sendTask1(void *pvPamra)  
{  
    QueueHandle_t myQueueHandle = (QueueHandle_t)pvPamra; // 从pvPamra中取出队列句柄  
  
    int id = 111;  
    BaseType_t xStatus;  
  
    while (true)  
    {  
        xStatus = xQueueSend(myQueueHandle, &id, 0);  
        if (xStatus == pdPASS)  
            printf("Send id %d to queue.\n", id);  
        else  
            printf("Send id %d to queue failed.\n", id);  
        printf("sendTask is running.\n");  
        vTaskDelay(1000 / portTICK_PERIOD_MS);  
    }  
}  
  
void sendTask2(void *pvPamra)  
{  
    QueueHandle_t myQueueHandle = (QueueHandle_t)pvPamra; // 从pvPamra中取出队列句柄  
  
    int id = 222;  
    BaseType_t xStatus;  
  
    while (true)  
    {  
        xStatus = xQueueSend(myQueueHandle, &id, 0);  
        if (xStatus == pdPASS)  
            printf("Send id %d to queue.\n", id);  
        else  
            printf("Send id %d to queue failed.\n", id);  
        printf("sendTask2 is running.\n");  
        vTaskDelay(1000 / portTICK_PERIOD_MS);  
    }  
}  
  
void receiveTask(void *pvPamra)  
{  
    QueueSetHandle_t myQueueSetHandle = (QueueSetHandle_t)pvPamra; // 从pvPamra中取出队列集句柄  
    BaseType_t xStatus;  
    int id = 0;  
  
    QueueSetMemberHandle_t myQueueMemberHandle; // 用于接收数据  
  
    while (true)  
    {  
        myQueueMemberHandle = xQueueSelectFromSet(myQueueSetHandle, portMAX_DELAY); // 从队列集中选择一个队列  
        xStatus = xQueueReceive(myQueueMemberHandle, &id, portMAX_DELAY); // 从队列中接收数据  
  
        if (xStatus == pdPASS)  
        {  
            printf("Receive data: %d\n", id);  
        }  
        else  
            printf("Receive data from queue failed.\n");  
        printf("receiveTask is running.\n");  
    }  
}  
  
void app_main(void)  
{  
    TaskHandle_t myHandle = NULL;  
    TaskHandle_t myHandle2 = NULL;  
    TaskHandle_t myHandle3 = NULL;  
    QueueHandle_t myQueueHandle1 = xQueueCreate(5, sizeof(int)); // 创建一个队列，队列长度为5，每个元素大小为int的大小  
    QueueHandle_t myQueueHandle2 = xQueueCreate(5, sizeof(int));  
  
    QueueSetHandle_t myQueueSetHandle = xQueueCreateSet(10); // 创建一个队列集，队列集大小为队列长度之和  
    xQueueAddToSet(myQueueHandle1, myQueueSetHandle);  
    xQueueAddToSet(myQueueHandle2, myQueueSetHandle);  
  
    if (myQueueHandle1 != NULL && myQueueHandle2 != NULL && myQueueSetHandle != NULL)  
    {  
        printf("Queue created successfully.\n"); // 当Queue创建成功后，创建两个任务，一个发送任务，一个接收任务  
        xTaskCreate(sendTask1, "sendTask1", 1024 * 5, (void *)myQueueHandle1, 1, &myHandle);  
        xTaskCreate(sendTask2, "sendTask2", 1024 * 5, (void *)myQueueHandle2, 1, &myHandle2);  
        xTaskCreate(receiveTask, "receiveTask", 1024 * 5, (void *)myQueueSetHandle, 2, &myHandle3); // 接收优先级高于发送  
    }  
    else  
    {  
        printf("Queue creation failed.\n");  
    }  
}

Queue Mailbox

Mailbox 不会传递数据，而是一直保留这个数据，这个数据可以被任何 Task 和中断服务读取，并根据 Task 决定程序运行情况
发送方可以 overwrite Mailbox 里的值，而接收方只可以读取，而不能移除这个值

xQueueOverwrite()

xQueueOverwrite() 是 xQueueSendToBack() 的变体，即使队列已满也会向队列写入数据，并覆盖队列中已有的数据。此函数主要适用于长度为 1 的队列（即队列只有“空”或“满”两种状态，比如 Mailbox）

#include “FreeRTOS.h”
#include “queue.h”

BaseType_t xQueueOverwrite( QueueHandle_t xQueue,
						   const void *pvItemToQueue );

参数
xQueue 目标队列的句柄
pvItemToQueue 指向要写入队列项的指针。队列在创建时定义了每个项的大小，此函数会将该大小的数据从 pvItemToQueue 拷贝到队列存储区域

返回值
xQueueOverwrite() 是对 xQueueGenericSend() 的宏封装，返回值与 xQueueSendToFront() 相同,但由于 xQueueOverwrite() 在队列已满时也能写入，pdPASS 是唯一可能的返回值

xQueuePeek()

xQueuePeek() 用于从队列中读取一项数据，但不会将该项从队列中移除

#include “FreeRTOS.h”
#include “queue.h”

BaseType_t xQueuePeek( QueueHandle_t xQueue,
					  void *pvBuffer, 
					  TickType_t xTicksToWait );

参数
xQueue队列的句柄，用于指定从哪个队列中读取数据
pvBuffer指向用于接收队列数据的内存指针。内存大小必须至少等于队列项的大小（在使用 xQueueCreate() 或 xQueueCreateStatic() 创建队列时由 uxItemSize 参数定义）
xTicksToWait 任务等待数据变为可用的最大时间（以系统时钟节拍为单位）

  • 任务等待数据变为可用的最大时间（以系统时钟节拍为单位）。
  • 如果设置为 0，函数会立即返回。
  • 如果设置为 portMAX_DELAY 且 INCLUDE_vTaskSuspend 为 1，则任务会无限期等待。

返回值
pdPASS**数据成功从队列中读取。

  • 如果 xTicksToWait 非零，任务可能会进入阻塞状态等待数据变为可用
    errQUEUE_EMPTY 队列为空，无法读取数据
  • 如果 xTicksToWait 非零，任务可能已进入阻塞状态，但在超时时间内没有数据可用

注意事项

  • 使用此函数不会移除队列中的数据，因此适用于需要查看但不消费队列数据的场景
  • 缓存大小必须匹配队列项的大小，否则可能导致数据损坏或访问越界

Example Code:Implementing a Shared Mailbox with Multiple Readers and One Writer

#include <stdio.h>  
#include <inttypes.h>  
#include "sdkconfig.h"  
#include "freertos/FreeRTOS.h"  
#include "freertos/task.h"  
#include "esp_chip_info.h"  
#include "esp_flash.h"  
#include "esp_system.h"  
  
#include "freertos/queue.h" // 包括队列头文件  
  
void writeTask(void *pvPamra)  
{  
    QueueHandle_t Mailbox = (QueueHandle_t)pvPamra; // 从pvPamra中取出队列句柄  
  
    int id = 0;  
    BaseType_t xStatus;  
  
    while (true)  
    {  
        xStatus = xQueueOverwrite(Mailbox, &id); // 覆盖写入  
        if (xStatus == pdPASS)  
            printf("Send id %d to queue.\n", id);  
        else  
            printf("Send id %d to queue failed.\n", id);  
        id++;  
        vTaskDelay(6000 / portTICK_PERIOD_MS);  
    }  
}  
  
void readTask(void *pvPamra)  
{  
    QueueHandle_t Mailbox = (QueueHandle_t)pvPamra; // 从pvPamra中取出队列句柄  
    int id = 0;  
    BaseType_t xStatus;  
  
    while (true)  
    {  
        xStatus = xQueuePeek(Mailbox, &id, 0); // 读取队列中的数据  
        if (xStatus == pdPASS)  
            printf("Read id %d from queue.\n", id);  
        else  
            printf("Read id %d from queue failed.\n", id);  
        vTaskDelay(1000 / portTICK_PERIOD_MS);  
    }  
}  
  
void app_main(void)  
{  
    QueueHandle_t MailboxHandle = NULL;  
    TaskHandle_t writeTaskHandle = NULL;  
    TaskHandle_t readTaskHandle = NULL;  
    TaskHandle_t readTaskHandle2 = NULL;  
    TaskHandle_t readTaskHandle3 = NULL;  
    MailboxHandle = xQueueCreate(1, sizeof(int)); // 创建一个邮箱，邮箱大小为1，每个元素大小为int的大小  
  
    if (MailboxHandle != NULL)  
    {  
        printf("Queue created successfully.\n"); // 当Queue创建成功后，创建两个任务，一个发送任务，一个接收任务  
        xTaskCreate(writeTask, "writeTask", 1024 * 5, (void *)MailboxHandle, 1, &writeTaskHandle);  
        xTaskCreate(readTask, "readTask1", 1024 * 5, (void *)MailboxHandle, 2, &readTaskHandle); // 在实现的功能相同时，多个Task可以共用一个函数体  
        xTaskCreate(readTask, "readTask2", 1024 * 5, (void *)MailboxHandle, 2, &readTaskHandle2);  
        xTaskCreate(readTask, "readTask3", 1024 * 5, (void *)MailboxHandle, 2, &readTaskHandle3);  
    }  
    else  
    {  
        printf("Queue creation failed.\n");  
    }  
}
ESP32学习笔记之串口UART事件接收数据（一次接收大于120字节）
Ping C3的博客
07-21 4204
系统环境： Windows 10VS-CodeESP-IDF（V5.2.2）开发版 ： ESP32 WROOM32通用异步接收器/发送器 (UART) - ESP32 - — ESP-IDF 编程指南 v5.2.2 文档例 程 ：//uart事件结构体//存放RX缓冲区里的数据长度 单位：字节//开辟一段内存存放接收到的数据 无符号字节型（动态分配的内存dtmp的地址不可以发生改变）uint8_t*dtmp这是一种可变长度数组的写法 用动态内存分配函数malloc()
ESP32学习笔记：FreeRTOS中的消息队列
moon2shine的博客
01-18 733
主要是验证了ESP32中的消息队列机制，配置好定时器后，在每次定时中断中向消息队列发送消息，在消息队列接收端接收消息并打印触发信息。作为一个小demo方便后续开发查阅。
【ESP32】嵌入式FreeRtos--队列Queue
保持热爱，奔赴山海。
04-09 1290
多个任务输入一个队列，一个任务读队列中的数据，此时注意设置任务的优先级别，队列：先入先出(FIFO,first in first out)
ESP32编程指南 —— Queue API (队列)
weixin_45652444的博客
07-22 4568
文章目录队列 API头文件• freertos/include/freertos/queue.h函数xQueueGenericSendFromISRxQueueGiveFromISRxQueueGenericSendxQueuePeek前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 队列 API 头文件 • freertos/include/freertos/queue.h 函数 xQueueGenericSendFromISR BaseType_t xQueueGenericSend
ESP32移植Openharmony设备开发---（8）Queue消息队列
2301_77659368的博客
10-14 977
任务能够从队列里面读取消息，当队列中的消息为空时，挂起读取任务；可以通过调整读队列和写队列的超时时间来调整读写接口的阻塞模式，如果将读队列和写队列的超时时间设置为0，就不会挂起任务，接口会直接返回，这就是非阻塞模式。反之，如果将读队列和写队列的超时时间设置为大于0的时间，就会以阻塞模式运行。读取消息队列，用于读取指定队列中的数据，并将获取到的数据存储到bufferAddr指定的地址中。删除队列时会释放该控制块。获取消息，用于读取指定队列中的数据地址，并将其存储到由bufferAddr指定的地址中。
【ESP32+freeRTOS学习笔记-(五)队列Queue】
weixin_45499326的博客
01-05 4091
Queues提供了一个任务到任务，任务到中断，以及中断到任务的通信机制。学过数据结构的原理应该知道，队列是常用的数据结构的一种，是一种先入先出First IN First Out 的数据组织与操作形态的名称。因此在FreeRTOS中，队列Queue的本质也是一样的。对于其行为与组织形式，用原文的图解能更清楚地说明。由上图可以清楚的看出，FreeRTOS的Queue就是一个实现了队列的存储组织形式以及完成了不同任务之能互相传递数据的操作实现。队列能保存有限数量的固定大小的数据项。
ESP32-IDF的Freertos消息队列的创建与基础应用
Lee1989
09-10 4447
文章目录前言一、消息队列是什么？二、消息队列的作用三、FreeRtos中消息队列API的调用函数 xQueueCreate函数 xQueueSend2.读入数据总结 前言 写博客是为了总结知识，提炼知识不做知识的搬运者 文章不一定全是原创但是所写内容都有经过自身研读与提炼 喜欢我博客的朋友可以跟我交流与点赞， 一、消息队列是什么？ 队列是任务间通信的主要形式。它们可用于在任务之间以及中断和任务之间发送消息。在大多数情况下，它们用作线程安全的 FIFO（先进先出）缓冲区，将新数据发送到队列的后面，尽..
esp32学习笔记——UART
weixin_52051754的博客
04-20 7159
文章目录前言一、UART主要介绍二、使用步骤及接口函数介绍1.设置通讯参数- 设置波特率、数据位、停止位等2、设置通信引脚- 分配用于连接到设备的引脚。3、驱动程序安装- 为 UART 驱动程序分配 ESP32 的资源。4、运行 UART 通信- 发送/接收数据。5、使用中断- 触发特定通信事件的中断。6、删除驱动程序- 如果不再需要 UART 通信，则释放分配的资源总结 前言 提示：这里可以添加本文要记录的大概内容： 嵌入式应用通常要求一个简单的并且占用系统资源少的方法来传输数据。通用异步收发传输器 (
ESP32学习笔记 - 动态创建多个GATT服务
最新发布
清晨的博客
01-13 1873
ESP32实现动态添加GATT服务，实现服务功能的模块化，统一由一个管理文件管理需要添加的服务。参考部分添加：BLE_OTA + BLE_UART。
esp32 蓝牙启动流程_ESP32学习笔记十七之蓝牙通信
weixin_30273229的博客
01-12 2878
蓝牙是一种短距离通信系统，蓝牙系统分为两种不同的技术：经典蓝牙(ClassicBluetooth)和蓝牙低功耗(BluetoothLowEnergy)。从整体结构上，蓝牙可分为控制器(Controller)和主机(Host)两大部分；ESP32应用的三种场景：场景一(ESP-IDF默认)：在ESP32的系统上，选择BLUEDROID为蓝⽛牙主机，并通过VHCI(软件实现的虚拟HCI接⼝口)接⼝口，...
【笔记2-5】ESP32：freertos消息队列
qq_43598101的博客
12-05 724
主要参考b站宸芯IOT老师的视频，记录自己的笔记，老师讲的主要是linux环境，但配置过程实在太多问题，就直接用windows环境了，老师也有讲一些windows的操作，只要代码会写，操作都还好，开发板用ESP-WROOM-32，其实坑还挺多的，慢慢来吧。队列是任务间通信的主要形式，关于队列，主要有以下5个函数。通过监视串口查看运行效果。
彻底理解FreeRTOS中的队列（Queue）
闪耀大叔的博客
04-04 7640
“队列”（Queue）提供了任务与任务之间通信的机制。在这样的场景：一个或多个其他的任务产生数据，主任务要依次处理数据，队列就显得非常有用了。
Linux下基于最新稳定版ESP-IDF5.3.2开发esp32s3入门任务间的通讯-消息队列【入门四】
ching的博客
12-22 413
3、xQueueReceive(QueueHandle_t xQueue, void *const pvBuffer, TickType_t xTicksToWait)接收消息【xQueue句柄，pvBuffer接收缓存，xTicksToWait等待时间】四、下载验证，【发送任务1000ms发送0开始加1的数据，接收任务1000ms接收到数据，并打印接收的数据】一、从上一篇信号量通讯demo拷贝一份重命名，还是之前的两个任务，重命名了。三、创建队列【注意队列的创建需要再任务之前就创建好】
ESP32——任务间数据传输方式
tsliuch的专栏
06-16 2601
ESP32
FreeRTOS消息队列
hqy450665101的博客
02-01 1385
FreeRTOS消息队列 队列又称消息队列，是一种常用于任务间通信的数据结构， 队列可以在任务与任务间、中断和任务间传递信息，实现了任务接收来自其他任务或中断的不固定长度的消息，任务能够从队列里面读取消息，当队列中的消息是空时，读取消息的任务将被阻塞，用户还可以指定阻塞的任务时间 xTicksToWait，在这段时间中，如果队列为空，该任务将保持阻塞状态以等待队列数据有效。 当队列中有新消息时， 被阻塞的任务会被唤醒并处理新消息；当等待的时间超过了指定的阻塞时间，即使队列中尚无有效数据，任务也会自动从阻塞态
(ESP32学习7)双核使用队列进行任务间通信
ailta的博客
06-02 5041
这里是调用双核的方法哈，和我们单核使用的方法不兼容，因为有一些函数是不一样的，不通用，但是下一篇博文我会更一篇单核使用队列进行任务间通讯的问题 队列是什么？ 队列是可以从一个任务向其他任务以并发安全的方式发送消息的机制，也就是说他的目标是实现任务间的通讯，比如A任务向名为Queue的队列中发布了数据，那么B任务就可以从Queue这个队列中又把数据给取出来，并且，这个数据是复制式的，也就是说把数据复制一份送入队列，B任务取出后对原来A的数据完全不会造成影响（实际上是形象的描述，本质上是通过一系列指针实现的），
(ESP32学习8)单核使用FreeRTOS测试队列进行任务间通信
ailta的博客
06-02 1682
我上一篇博文更的是双核版的队列测试，基本在那里说的很清楚了，那里的代码注释也多的多，这里单核版本有一点不一样的地方，但实现起来比双核的要简单，所以直接给大家代码，如果不理解就去看我上一篇博文，里面说明和注释都非常清楚 给大家代码，这里实现了两个进程间使用一个int数据类型的队列进行通信，当然这里应该也是支持结构体多类型的，想试试的可以去上一篇博文看看怎么弄的 QueueHandle_t queue; //单核多进程测试队列，这是队列的句柄 TaskHandle_t Task1; //任务0的句柄
【esp32】xQueueReceive 函数调试踩坑记录
欢迎私信、留言交流
11-08 6701
ESP32 项目中，xQueueReceive函数具有阻塞任务的作用，你知道吗？在项目中会不会被他折磨？请看本篇博文
ESP32那些事儿(五)：瑞士军刀之ESP32的常用API分析
荷兰风车
10-31 1851
事实上，所有在esp32上用到的api在esp-idf中都能找到，但是对于我们来讲这是一个大而全的API参考指南，在项目的初期，我们没有必要花费太多的时间详细的阅读每一个API的使用，挑一些常用的API进行学习，而后再根据使用情况来查询参考文档，这样才能达到事半功倍的效果，那么这里就罗列一些常用的API吧： 1、ESP_LOG     我们写程序最本能的就是关键的步骤都要打一些日志到串口终端，这...
esp32 freertos学习笔记
08-22
ESP32的FreeRTOS使用上与传统的FreeRTOS有一些区别。在ESP32中，基本不需要单独配置FreeRTOSConfig.h文件，因为ESP-IDF中的menuconfig功能可以对所有涉及到的内容进行配置，使用起来更加直观和便利。主要的数据类型说明中，有一个重要的数据类型是TickType_t。 在ESP32的魔改版FreeRTOS中，很少使用正经的事件集，而是使用ESP-IDF提供的更方便的事件循环。这使得在ESP32中使用事件循环更加方便。 另外，ESP32的分区表是采用二进制格式而不是CSV文件。ESP-IDF提供了gen_esp32part.py工具来配置和构建分区表。默认情况下，使用的是默认分区表。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* [【ESP32+freeRTOS学习笔记-(一)freeRTOS介绍】](https://blog.youkuaiyun.com/weixin_45499326/article/details/128226443)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] - *2* *3* [ESPIDF开发ESP32学习笔记【ESP32上的FreeRTOS】](https://blog.youkuaiyun.com/qq_40500005/article/details/114794039)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"] [ .reference_list ]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值