FreeRTOS学习笔记-队列

最新推荐文章于 2024-05-15 00:15:00 发布
最新推荐文章于 2024-05-15 00:15:00 发布
阅读量988 收藏 1
点赞数
分类专栏： # ESP32 文章标签： esp32 freeRTOS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ai_ljh/article/details/126764365
版权

FreeRTOS学习笔记-队列

关键函数说明

头文件

#include "freertos/queue.h"

创建队列

QueueHandle_t xQueueCreate( 
			UBaseType_t uxQueueLength,//队列长度，相当于buff深度
			UBaseType_t uxItemSize //元素大小（Byte），相当于buff宽度 例如：用 sizeof(int)获取；
			);

向队列写入数据

//向队列最前端写入，等同于先入后出
BaseType_t xQueueSendToFront( 
			QueueHandle_t xQueue, //队列句柄
			const void * pvItemToQueue, //待复制的数据指针，复制的数据大小由创建队列时指定的宽度确定
			TickType_t xTicksToWait //等待时间
			);
//向队列后面写入，等同于先入先出
BaseType_t xQueueSendToBack( 
			QueueHandle_t xQueue,
			const void * pvItemToQueue,
			TickType_t xTicksToWait 
			);
//返回值：	
//		pdPASS：成功写入  
// 		errQUEUE_FULL：队列满

等待时间为：

  • 0 ： 若队列满立即返回
  • portMAX_DELAY： 若 INCLUDE_vTaskSuspend == 1 ，且队列满，将一直阻塞，直到队列非满
  • 其他值： 如队列满，将等待该时间后返回，单位为Ticks系统默认为10ms

从队列接收数据

BaseType_t xQueueReceive( 
		QueueHandle_t xQueue,//队列句柄
		void *pvBuffer,//接收数据存放位置
		TickType_t xTicksToWait //等待时间，与发送类似
	);
//返回值：
//pdPASS： 接收成功
//errQUEUE_EMPTY：队列为空

等待时间为：

  • 0 ： 若队列空立即返回
  • portMAX_DELAY： 若 INCLUDE_vTaskSuspend == 1 ，且队列空，将一直阻塞，直到队列非空
  • 其他值： 如队列空，将等待该时间后返回，单位为Ticks系统默认为10ms
UBaseType_t uxQueueMessagesWaiting( const QueueHandle_t xQueue//队列句柄
 );//返回值： 当前队列有效数据个数

snprintf()函数

将可变参数 (…) 按照 format 格式化成字符串，并将字符串复制到 str 中，实际上后半部分跟 printf() 函数用法相同。

int snprintf(char *str,//目标字符串
			 size_t size, //拷贝字节数(Bytes) format长度大于该值将被截断,并在(size-1)位置添加“\0”
			 const char *format, //格式化成字符串
			 ...   //可变参数
 ) ;//返回值： 写入的字符串长度

队列集合

//创建队列集
QueueSetHandle_t xQueueCreateSet( 
		const UBaseType_t uxEventQueueLength //队列集长度 = 包含的每个队列的长度之和
		);//返回：队列集句柄
		
//添加队列到队列集
BaseType_t xQueueAddToSet( 
		QueueSetMemberHandle_t xQueueOrSemaphore,//要添加到队列集的队列或信号量，被强制转换成 QueueSetMemberHandle_t 类型
		QueueSetHandle_t xQueueSet //队列集
		);//返回值： pdPASS：成功；  pdFAIL：无法将队列或信号量添加到队列集中，因为它已经是另一个集的成员
//从队列集移除队列
BaseType_t xQueueRemoveFromSet( 
		QueueSetMemberHandle_t xQueueOrSemaphore,
		QueueSetHandle_t xQueueSet 
		);
		
//从队列集的成员中选择包含数据的队列 或 可用于获取的信号量
QueueSetMemberHandle_t xQueueSelectFromSet( 
		QueueSetHandle_t xQueueSet, //队列集
		const TickType_t xTicksToWait //等待超时  设为 portMAX_DELAY时, 若 INCLUDE_vTaskSuspend == 1 ，且一直未收到数据将一直阻塞
		);//返回值 NULL：在xTicksToWait参数指定的阻止时间过期之前，该集中包含的队列或信号量不可用。其他值：QueueSetMemberHandle_t 句柄

队列邮箱

//写队列邮箱
BaseType_t xQueueOverwrite( 
			QueueHandle_t xQueue, //队列邮箱句柄
			const void *pvItemToQueue //要写入的数据指针
			);//返回值：只能是 pdPASS
			
//清空队列邮箱
BaseType_t xQueueReset( QueueHandle_t xQueue );

//读队列邮箱,读取后不会从队列中移除该数据
BaseType_t xQueuePeek( 
			QueueHandle_t xQueue,//队列邮箱句柄
			void *pvBuffer, //读出的数据指针
			TickType_t xTicksToWait //超时，功能与队列读取函数相同
			);//返回值：pdPASS：成功；errQUEUE_EMPTY：队列邮箱为空。

课程示例

通过队列发送与接收int型数据

#include <stdio.h>
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
#include "esp_spi_flash.h"
#include "freertos/queue.h"

void mytask1(void *pvParameter)//发送任务
{
    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    int t1 = 5;
    while (1)
    {
        if (xQueueSendToBack(p, &t1, 0) == pdPASS)
        {
            printf("mytask1: send ok \n");
        }
        else
        {
            printf("mytask1: send error \n");
        }
        t1++;
        vTaskDelay(500 / portTICK_PERIOD_MS);
    }
}
void mytask2(void *pvParameter)//接收任务
{

    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    int t2 = 0;
    UBaseType_t cnt;
    while (1)
    {
        cnt = uxQueueMessagesWaiting(p);
        if (cnt > 0)
        {
            xQueueReceive(p, &t2, 0);
            printf("mytask2: t2= %d cnt= %d\n", t2, cnt-1);
        }
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

void app_main(void)
{

    QueueHandle_t que1 = xQueueCreate(5, sizeof(int));
    if (que1 != NULL)//队列创建成功时再创建收发任务
    {
        xTaskCreate(mytask1, "mytask1", 1024 * 5, (void *)que1, 1, NULL);//注意堆栈，设小了会导致任务启动/运行异常
        xTaskCreate(mytask2, "mytask2", 1024 * 5, (void *)que1, 1, NULL);
    }
}

效果

mytask1: send ok
mytask2: t2= 5 cnt= 0
mytask1: send ok
mytask2: t2= 6 cnt= 0
mytask1: send ok
mytask1: send ok
mytask2: t2= 7 cnt= 1
mytask1: send ok
mytask1: send ok
mytask2: t2= 8 cnt= 2
mytask1: send ok
mytask1: send ok
mytask2: t2= 9 cnt= 3
mytask1: send ok
mytask1: send ok
mytask2: t2= 10 cnt= 4
mytask1: send ok
mytask1: send error
mytask2: t2= 11 cnt= 4
mytask1: send ok
mytask1: send error
mytask2: t2= 12 cnt= 4
mytask1: send ok
mytask1: send error

队列总长度为5，发送快，接收慢，队列满时，发送出错。

修改接收任务检测时间为200ms：

void mytask2(void *pvParameter)
{

    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    int t2 = 0;
    UBaseType_t cnt;
    while (1)
    {
        cnt = uxQueueMessagesWaiting(p);
        if (cnt > 0)
        {
            xQueueReceive(p, &t2, 0);
            printf("mytask2: t2= %d cnt= %d\n", t2, cnt-1);
        }
        vTaskDelay(200 / portTICK_PERIOD_MS);//修改接收检测时间
    }
}

效果

mytask1: send ok
mytask2: t2= 5 cnt= 0
mytask1: send ok
mytask2: t2= 6 cnt= 0
mytask1: send ok
mytask2: t2= 7 cnt= 0
mytask1: send ok
mytask2: t2= 8 cnt= 0
mytask1: send ok
mytask2: t2= 9 cnt= 0
mytask1: send ok
mytask2: t2= 10 cnt= 0
mytask1: send ok
mytask2: t2= 11 cnt= 0
mytask1: send ok
mytask2: t2= 12 cnt= 0
mytask1: send ok
mytask2: t2= 13 cnt= 0
mytask1: send ok
mytask2: t2= 14 cnt= 0
mytask1: send ok
mytask2: t2= 15 cnt= 0
mytask1: send ok

接收快，发送慢，每次发送都正常。
因为在接收任务中添加了uxQueueMessagesWaiting函数，用于统计队列有效元素个数，没有数据时不会去接收，因此未报错。

通过队列发送与接收结构体

#include <stdio.h>
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
#include "esp_spi_flash.h"
#include "freertos/queue.h"

typedef struct a_struct
{
    int id;
    int data;
} xStruct;

void mytask1(void *pvParameter)
{
    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    xStruct t1;
    t1.id = 0;
    t1.data = 999;
    while (1)
    {
        if (xQueueSendToBack(p, &t1, 0) == pdPASS)
        {
            printf("mytask1: send ok \n");
        }
        else
        {
            printf("mytask1: send error \n");
        }
        t1.id++;
        t1.data--;
        vTaskDelay(500 / portTICK_PERIOD_MS);
    }
}
void mytask2(void *pvParameter)
{

    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    xStruct t2;
    t2.id = 0;
    t2.data = 0;
    UBaseType_t cnt;
    while (1)
    {
        cnt = uxQueueMessagesWaiting(p);
        if (cnt > 0)
        {
            xQueueReceive(p, &t2, 0);
            printf("mytask2: t2= { %d , %d }cnt= %d\n", t2.id, t2.data, cnt - 1);
        }
        vTaskDelay(200 / portTICK_PERIOD_MS);
    }
}

void app_main(void)
{

    QueueHandle_t que1 = xQueueCreate(5, sizeof(xStruct));
    if (que1 != NULL)
    {
        xTaskCreate(mytask1, "mytask1", 1024 * 5, (void *)que1, 1, NULL);
        xTaskCreate(mytask2, "mytask2", 1024 * 5, (void *)que1, 1, NULL);
    }
}

效果

mytask1: send ok
mytask2: t2= { 0 , 999 }cnt= 0
mytask1: send ok
mytask2: t2= { 1 , 998 }cnt= 0
mytask1: send ok
mytask2: t2= { 2 , 997 }cnt= 0
mytask1: send ok
mytask2: t2= { 3 , 996 }cnt= 0
mytask1: send ok
mytask2: t2= { 4 , 995 }cnt= 0
mytask1: send ok
mytask2: t2= { 5 , 994 }cnt= 0
mytask1: send ok
mytask2: t2= { 6 , 993 }cnt= 0
mytask1: send ok
mytask2: t2= { 7 , 992 }cnt= 0
mytask1: send ok
mytask2: t2= { 8 , 991 }cnt= 0

通过队列发送与接收指针

#include <stdio.h>
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
#include "esp_spi_flash.h"
#include "freertos/queue.h"

void mytask1(void *pvParameter)
{
    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    char *pt1;
    
    int i = 0;
    while (1)
    {
        pt1 = (char *)malloc(50); //每次循环都分配新的地址
        snprintf(pt1, 50, "hello world %d", i);
        if (xQueueSendToBack(p, &pt1, 0) == pdPASS)
        {
            printf("mytask1: send ok pt1_addr= %p \n", pt1);
        }
        else
        {
            printf("mytask1: send error \n");
        }
        i++;
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}
void mytask2(void *pvParameter)
{

    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    char *pt2;
    UBaseType_t cnt;
    while (1)
    {
        cnt = uxQueueMessagesWaiting(p);
        if (cnt > 0)
        {
            xQueueReceive(p, &pt2, 0);//在队列中接收的实际只是一个char指针，即发送任务中分配的地址
            printf("mytask2: pt2_addr= %p  pt2= %s | cnt= %d\n", pt2, pt2, cnt - 1);
            free(pt2); //释放发送函数分配的内存
        }
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

void app_main(void)
{

    QueueHandle_t que1 = xQueueCreate(5, sizeof(char *));
    if (que1 != NULL)
    {
        xTaskCreate(mytask1, "mytask1", 1024 * 5, (void *)que1, 1, NULL);
        xTaskCreate(mytask2, "mytask2", 1024 * 5, (void *)que1, 1, NULL);
    }
}

效果

mytask1: send ok pt1_addr= 0x3ffb94d0
mytask2: pt2_addr= 0x3ffb94d0 pt2= hello world 0 | cnt= 0
mytask1: send ok pt1_addr= 0x3ffb4a48
mytask2: pt2_addr= 0x3ffb4a48 pt2= hello world 1 | cnt= 0
mytask1: send ok pt1_addr= 0x3ffb4a48
mytask2: pt2_addr= 0x3ffb4a48 pt2= hello world 2 | cnt= 0
mytask1: send ok pt1_addr= 0x3ffb4a48
mytask2: pt2_addr= 0x3ffb4a48 pt2= hello world 3 | cnt= 0

  • demo中故意把指针地址打印出来，是为了说明队列里面传递的只是一个地址，并非真正的数据拷贝；
  • 因为任务2中对任务1分配的char指针进行了free()操作，因此后面分配的地址可能重复。

屏蔽free()函数效果如下，这样会占用不必要的内存，需谨慎使用。

mytask1: send ok pt1_addr= 0x3ffb94d0
mytask2: pt2_addr= 0x3ffb94d0 pt2= hello world 0 | cnt= 0
mytask1: send ok pt1_addr= 0x3ffb4a48
mytask2: pt2_addr= 0x3ffb4a48 pt2= hello world 1 | cnt= 0
mytask1: send ok pt1_addr= 0x3ffb4a80
mytask2: pt2_addr= 0x3ffb4a80 pt2= hello world 2 | cnt= 0
mytask1: send ok pt1_addr= 0x3ffb4ab8
mytask2: pt2_addr= 0x3ffb4ab8 pt2= hello world 3 | cnt= 0
mytask1: send ok pt1_addr= 0x3ffb4af0
mytask2: pt2_addr= 0x3ffb4af0 pt2= hello world 4 | cnt= 0
mytask1: send ok pt1_addr= 0x3ffb4b28
mytask2: pt2_addr= 0x3ffb4b28 pt2= hello world 5 | cnt= 0

队列多进单出( Multiple In Single Out )

在这里插入图片描述

#include <stdio.h>
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
#include "esp_spi_flash.h"
#include "freertos/queue.h"

void mytask1(void *pvParameter) //发送任务1
{
    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    int t1 = 111;
    while (1)
    {
        if (xQueueSendToBack(p, &t1, 0) == pdPASS)
        {
            printf("mytask1: send ok \n");
        }
        else
        {
            printf("mytask1: send error \n");
        }
        t1++;
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}
void mytask2(void *pvParameter) //发送任务2
{
    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    int t2 = 222;
    while (1)
    {
        if (xQueueSendToBack(p, &t2, 0) == pdPASS)
        {
            printf("mytask2: send ok \n");
        }
        else
        {
            printf("mytask2: send error \n");
        }
        t2++;
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}
void mytask3(void *pvParameter) //接收任务
{

    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    int t3 = 0;
    UBaseType_t cnt;
    while (1)
    {
        cnt = uxQueueMessagesWaiting(p);
        if (cnt > 0)
        {
            xQueueReceive(p, &t3, 0);
            printf("mytask3: t3= %d cnt= %d\n", t3, cnt - 1);
        }
        vTaskDelay(200 / portTICK_PERIOD_MS);
    }
}

void app_main(void)
{

    QueueHandle_t que1 = xQueueCreate(5, sizeof(int));
    if (que1 != NULL) //队列创建成功时再创建收发任务
    {
        xTaskCreate(mytask1, "mytask1", 1024 * 5, (void *)que1, 1, NULL); //注意堆栈，设小了会导致任务启动/运行异常
        xTaskCreate(mytask2, "mytask2", 1024 * 5, (void *)que1, 1, NULL);
        xTaskCreate(mytask3, "mytask3", 1024 * 5, (void *)que1, 2, NULL);
    }
}

效果
任务1和2往同一个队列里面写数据，任务3接收。

mytask1: send ok
mytask3: t3= 111 cnt= 0
mytask2: send ok
mytask3: t3= 222 cnt= 0
mytask1: send ok
mytask2: send ok
mytask3: t3= 112 cnt= 1
mytask3: t3= 223 cnt= 0
mytask1: send ok
mytask2: send ok
mytask3: t3= 113 cnt= 1
mytask3: t3= 224 cnt= 0
mytask1: send ok
mytask2: send ok

先入后出函数测试

#include <stdio.h>
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
#include "esp_spi_flash.h"
#include "freertos/queue.h"

void mytask1(void *pvParameter)//发送任务
{
    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    int t1 = 5;
    while (1)
    {
        //if (xQueueSendToBack(p, &t1, 0) == pdPASS)//先入先出
        if (xQueueSendToFront(p, &t1, 0) == pdPASS)//先入后出
        {
            printf("mytask1: send ok \n");
        }
        else
        {
            printf("mytask1: send error \n");
        }
        t1++;
        vTaskDelay(500 / portTICK_PERIOD_MS);
    }
}
void mytask2(void *pvParameter)//接收任务
{

    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    int t2 = 0;
    UBaseType_t cnt;
    while (1)
    {
        cnt = uxQueueMessagesWaiting(p);
        if (cnt > 0)
        {
            xQueueReceive(p, &t2, 0);
            printf("mytask2: t2= %d cnt= %d\n", t2, cnt-1);
        }
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

void app_main(void)
{

    QueueHandle_t que1 = xQueueCreate(5, sizeof(int));
    if (que1 != NULL)//队列创建成功时再创建收发任务
    {
        xTaskCreate(mytask1, "mytask1", 1024 * 5, (void *)que1, 1, NULL);//注意堆栈，设小了会导致任务启动/运行异常
        xTaskCreate(mytask2, "mytask2", 1024 * 5, (void *)que1, 1, NULL);
    }
}

效果
先进入队列的数据反而没有按顺序打印，反而先接收了最新写入队列的数据。

mytask1: send ok
mytask2: t2= 5 cnt= 0
mytask1: send ok
mytask2: t2= 6 cnt= 0
mytask1: send ok
mytask1: send ok
mytask2: t2= 8 cnt= 1
mytask1: send ok
mytask1: send ok
mytask2: t2= 10 cnt= 2
mytask1: send ok
mytask1: send ok
mytask2: t2= 12 cnt= 3
mytask1: send ok
mytask1: send ok
mytask2: t2= 14 cnt= 4
mytask1: send ok
mytask1: send error

先入先出效果对比：
队列溢出前，按先入先出的顺序，依次接收。

mytask1: send ok
mytask2: t2= 5 cnt= 0
mytask1: send ok
mytask2: t2= 6 cnt= 0
mytask1: send ok
mytask1: send ok
mytask2: t2= 7 cnt= 1
mytask1: send ok
mytask1: send ok
mytask2: t2= 8 cnt= 2
mytask1: send ok
mytask1: send ok
mytask2: t2= 9 cnt= 3
mytask1: send ok
mytask1: send ok
mytask2: t2= 10 cnt= 4
mytask1: send ok
mytask1: send error

队列集合(Queue Set)

每个发送任务具有自己独立的队列，而接收任务从多个队列，即“Queue Set”中选择有数据的队列，并接收队列中的数据。
在这里插入图片描述

#include <stdio.h>
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
#include "esp_spi_flash.h"
#include "freertos/queue.h"

void mytask1(void *pvParameter) //发送任务1
{
    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    int t1 = 111;
    while (1)
    {
        if (xQueueSendToBack(p, &t1, 0) == pdPASS)
        {
            printf("mytask1: send ok \n");
        }
        else
        {
            printf("mytask1: send error \n");
        }
        t1++;
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}
void mytask2(void *pvParameter) //发送任务2
{
    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    char t2 = 222;
    while (1)
    {
        if (xQueueSendToBack(p, &t2, 0) == pdPASS)
        {
            printf("mytask2: send ok \n");
        }
        else
        {
            printf("mytask2: send error \n");
        }
        t2++;
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}
void mytask3(void *pvParameter) //接收任务
{
    QueueSetHandle_t pset;
    pset = (QueueSetHandle_t)pvParameter;
    QueueHandle_t p;
    int t3;
    while (1)
    {
        p = (QueueHandle_t)xQueueSelectFromSet(pset, portMAX_DELAY);
        xQueueReceive(p, &t3, 0);
        printf("mytask3: t3= %d \n", t3);
        vTaskDelay(200 / portTICK_PERIOD_MS);
    }
}

void app_main(void)
{
    QueueHandle_t que1 = xQueueCreate(5, sizeof(int));
    QueueHandle_t que2 = xQueueCreate(8, sizeof(char));
    QueueSetHandle_t que_set1 = xQueueCreateSet(13); //队列集长度 = 包含的每个队列的长度之和
    if ((que1 != NULL) && (que1 != NULL))            //队列创建成功时再创建收发任务
    {

        xQueueAddToSet(que1, que_set1);
        xQueueAddToSet(que2, que_set1);

        xTaskCreate(mytask1, "mytask1", 1024 * 5, (void *)que1, 1, NULL); //注意堆栈，设小了会导致任务启动/运行异常
        xTaskCreate(mytask2, "mytask2", 1024 * 5, (void *)que2, 1, NULL);
        xTaskCreate(mytask3, "mytask3", 1024 * 5, (void *)que_set1, 2, NULL);
    }
}

效果

mytask1: send ok
mytask3: t3= 111
mytask2: send ok
mytask3: t3= 222
mytask3: t3= 112
mytask1: send ok
mytask2: send ok
mytask3: t3= 223
mytask3: t3= 113
mytask1: send ok
mytask2: send ok
mytask3: t3= 224

从队列集中接收数据正常，但有个遗留问题还不知如何解决，就是从程序中怎么确定当前接收的队列是que1还是que2。

队列邮箱

队列是用于数据传递，从一个或多个任务发送数据到另一个任务；
队列邮箱（Mailbox）用于控制程序执行流程，写任务向Mailbox写入控制命令，各个读任务从Mailbox拿到指令并执行不同到操作。
在这里插入图片描述

邮箱基于队列创建，与队列主要差异如下：

  • 邮箱是只有一个元素长度的队列
  • 邮箱读写方式与队列不同
  • 邮箱写函数 xQueueOverwrite();
  • 邮箱读函数 xQueuePeek() 执行后不会从队列删除已经读取的数据
  • 要清空邮箱，需采用：xQueueReset() 函数
#include <stdio.h>
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_system.h"
#include "esp_spi_flash.h"
#include "freertos/queue.h"

void send_task(void *pvParameter) //发送任务1
{
    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    int t1;
    while (1)
    {
        t1 = 1; // mode A
        xQueueOverwrite(p, &t1);
        vTaskDelay(2000 / portTICK_PERIOD_MS);

        t1 = 5; // mode B
        xQueueOverwrite(p, &t1);
        vTaskDelay(2000 / portTICK_PERIOD_MS);

        t1 = 8; // mode C
        xQueueOverwrite(p, &t1);
        vTaskDelay(2000 / portTICK_PERIOD_MS);

        xQueueReset(p); //清空队列内容
        vTaskDelay(2000 / portTICK_PERIOD_MS);
    }
}
void receive_task(void *pvParameter) //接收任务
{
    QueueHandle_t p;
    p = (QueueHandle_t)pvParameter;
    char t2 = 222;
    char *task_name;
    task_name = pcTaskGetName(NULL); //获取当前任务名

    while (1)
    {
        if (xQueuePeek(p, &t2, 0) == pdPASS) // portMAX_DELAY
        {
            switch (t2)
            {
            case 1:
                printf("%s: mode A \n", task_name);
                break;
            case 5:
                printf("%s: mode B \n", task_name);
                break;
            case 8:
                printf("%s: mode C \n", task_name);
                break;
            default:
                printf("%s: error \n", task_name);
                break;
            }
        }
        else
        {
            printf("%s: Mailbox empty \n", task_name);
        }
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

void app_main(void)
{
    QueueHandle_t Mailbox1 = xQueueCreate(1, sizeof(int));

    if (Mailbox1 != NULL) //邮箱创建成功时再创建收发任务
    {
        xTaskCreate(send_task, "send_task", 1024 * 5, (void *)Mailbox1, 1, NULL);        //注意堆栈，设小了会导致任务启动/运行异常
        xTaskCreate(receive_task, "receive_task1", 1024 * 5, (void *)Mailbox1, 2, NULL); //接收优先级高
        xTaskCreate(receive_task, "receive_task2", 1024 * 5, (void *)Mailbox1, 2, NULL); //接收任务2和3与任务1共用1个函数体，功能相同
        xTaskCreate(receive_task, "receive_task3", 1024 * 5, (void *)Mailbox1, 2, NULL);
    }
}

效果

receive_task2: mode A
receive_task1: mode A
receive_task3: mode A
receive_task1: mode A
receive_task2: mode A
receive_task3: mode A
receive_task1: mode A
receive_task2: mode A
receive_task3: mode B
receive_task1: mode B
receive_task2: mode B
receive_task3: mode B
receive_task1: mode B
receive_task2: mode B
receive_task3: mode C
receive_task1: mode C
receive_task2: mode C
receive_task3: mode C
receive_task1: mode C
receive_task2: mode C
receive_task3: Mailbox empty
receive_task1: Mailbox empty
receive_task2: Mailbox empty
receive_task3: Mailbox empty
receive_task1: Mailbox empty
receive_task2: Mailbox empty
receive_task3: mode A
receive_task1: mode A
receive_task2: mode A
receive_task3: mode A
receive_task1: mode A
receive_task2: mode A
receive_task3: mode B

1个发送任务进行系统控制，每隔2s切换模式A、B、C，并在最后2s清除邮箱，3个接收任务公用1个函数体，执行相同的函数，通过打印任务名可做区分。

Coder-hong
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
FreeRTOS 消息队列
ok100abc的博客
05-29 773
FreeRTOS 消息队列 以下基础内容转载自安富莱电子：http://forum.armfly.com/forum.php 本章节为大家讲解 FreeRTOS 的一个重要的通信机制----消息队列，初学者要熟练掌握，因为消息队 列在实际项目中应用较多。 消息队列的概念及其作用 消息队列就是通过 RTOS 内核提供的服务，任务或中断服务子程序可以将一个消息（注意，FreeRTOS 消息队列传递的是实际数据，并不是数据地址，RTX，uCOS-II 和 uCOS-III 是传递的地址）放入...
清空队列的方法
2301_80718054的博客
02-10 452
注意：C++中的队列queue自身不支持clear操作，但双端队列deque是支持clear操作的。
浅析Free RTOS中Queue的应用
最新发布
mftang的博客
05-15 857
本文主要介绍Queue的相关知识，包括Queue的定义，发送和接收消息的方式等内容。重点使用Free RTOS中Queue的接口，实现数据在不同task之间的发送和接收的案例，并在板卡上验证该功能。
13_FreeRTOS消息队列
Yuanghxb的博客
02-13 1453
队列是任务到任务任务到中断、中断到任务数据交流的一种机制消息传递类似全局变量?假设有一个全局变量a = 0现有两个任务都在写这个变量a假设在任务1完成2步骤修改数据的时候,此时任务2优先级高打断任务1,a还是0因为任务a还没有写数据,任务2执行了加1,在回到任务1时,下一步是执行写数据此时r0是任务2执行完时候的1,任务1在吧R0赋值给0,相当于r0等于1在给a,并没有等于2。这样就照成了数据的受损。全局变量的弊端数据无保护导致数据不安全当多个任务同时对该变量操作时数据易受损。
C++ 清空队列(queue)的几种方法
Blog
12-23 3902
说明：C++中的queue自身不支持clear操作，但双端队列deque是支持clear操作的。 方法一：直接用空的队列对象赋值 queue<int> q1; //process //…… q1=queue<int>(); 方法二：遍历出队列 while(!Q.empty()) { Q.pop(); } 方法三：使用swap实现 使用swap定义clear，保持ST...
FreeRTOS消息队列 传递结构体指针和结构体异同
宁静致远的博客
12-18 3202
FreeRTOS消息队列 传递结构体指针和结构体异同1 消息队列传递结构体指针和结构体异同2 使用队列传递复合数据类型3 利用队列传递数据的指针（处理速度更快）3.1 指针指向的内存空间所有权必须明确3.2 指针指向的内存空间必须有效传递结构体指针和结构体本身的异同 原文链接：https://blog.csdn.net/weixin_44333597/article/details/107523343 1 消息队列传递结构体指针和结构体异同 2 使用队列传递复合数据类型 接收方接收由多个发送源发送至队列中的
FreeRTOS学习笔记之——-FreeRTOS队列基础知识 2020.3.30
01-06
4.通常，队列采用的是先进先出的（FIFO）的存储缓冲机制，也就是往队列中发送数据的时候（也叫入队）永远都是发送到队列的尾部，而从队列中提取数据的时候（也叫出队）是从队列的头部提取的。 5.发送数据和读取数据...
学习笔记-FreeRTOS思维导图文件
01-16
自学笔记，FreeRTOS思维导图文件分享
FreeRTOS入门手册-中文.zip
02-05
FreeRTOS入门手册-中文.zip
freeRTOS--之队列.zip
09-24
里面是freeRTOS消息队列的代码，107开发板，适合新手入手，如果需要自行下在
freertos-kernel-dg.pdf
05-18
亚马逊关于FreeRTOS的开发指南中文版，该指南可以快速上手。比什么野火原子类的书写的好多了，该指南中操作系统的常用任务，信号量，队列都有清晰的描述
【Freertos基础入门】队列(queue)的使用
m0_62599305的博客
08-19 1500
FreeRTOS是一个广泛使用的开源实时操作系统（RTOS），它提供了丰富的功能和特性，使嵌入式系统的开发更加简单和高效。队列是FreeRTOS中常用的一种通信机制，它用于在任务之间传递数据。队列是FreeRTOS中一种有用的通信机制，可用于在任务之间传递数据。通过使用队列，我们可以实现任务之间的数据共享和同步。在使用队列时，需要注意队列的深度和每个数据项的大小，并选择适当的阻塞等待时间以避免资源争用和任务饥饿等问题。
STM32CubeMX——FREERTOS学习：消息队列Queue
m0_49968063的博客
03-28 2115
队列，也叫消息队列，就是把消息一条一条的排个队。 比如创建了一个消息队列，这个消息队列可以存10条消息。任务A可以往里存消息，任务B也可以往里存。这个存的消息是要讲先来后到的，存满了10条消息就不能存了。假设任务C从里面去消息，也是一条一条的取，按照先后顺序取，先存的先取，后存的后取。信息取一个，队列里面就少一个，取10个之后，消息队列就空了。 往队列里面存消息，如果队列已经满了，可以一直等着，直到队列里面有空位置，也可以等一会，没空位离开。 从队列里面取消息，如果队列已经空了，可以一直等着，直到队列
FreeRTOS的学习（七）——1.队列概念
LEOD的博客
05-13 1287
队列在FreeRTOS中起到比较重要的作用，主要用于任务之间消息的传递，取代了裸机时代中的全局变量交互功能。队列的机制实现了任务与任务、任务与中断之间的消息传递。
python 清空队列_python实现：队列
weixin_31421625的博客
03-01 2908
队列队列和栈比较类似，可以和博文：https://blog.csdn.net/weixin_42521211/article/details/88946748 参考学习。队列的一个特性是：先进先出(First In First Out, FIFO),python中，同样可以使用列表来存储队列的数据。通过创建一个队列类，便可以方便的对队列进行操作。主要有：入队(In()) 出队(Out()) 清空队...
FreeRtos队列
qq_43379523的博客
04-10 1235
//任务优先级 #define START_TASK_PRIO 1 //任务堆栈大小 #define START_STK_SIZE 128 //任务句柄 TaskHandle_t StartTask_Handler; //任务函数 void start_task(void *pvParameters); //任务优先级 #define KEY_TASK_PRIO 2 //任务堆栈大小 #define KEY_STK_SIZE 128 //任务句柄 TaskHandle_t Key.
FreeRTOS基础四：队列
luliplus的博客
04-11 6753
FreeRTOS中的队列组件提供了任务到任务，任务到中断以及中断到任务的通信机制。 当队列创建的时候，队列的长度和元素的大小都设定好了。 队列的基本特性 备份入队策略 Queue by copy vsersus Queue by reference 队列的创建和使用 使用xQueueCreate()内核函数来创建一个队列。队列的存储空间从FreeRTOS heap中分配。在使用xQueueCreate()创建队列时，如果FreeRTOS heap中没有足够的存储空间分配给当前队列，则函数
FreeRTOS消息队列的使用
sanga的专栏
03-12 3487
1、定义队列句柄变量// 定义队列句柄变量static xQueueHandle xQueue;22、申请队列// 参数 1 : 队列深度// 参数 2 ： 队列项内容大小xQueue = xQueueCreate(1,20);3、创建2个线程，发送消息static void vTaskSender1( void * pvParameters ){    portBASE_TYPE xStatus...
Freertos队列的使用
lengyu1026的专栏
02-26 662
队列的创建 函数的API是 xQueueCreate，入参有两个，第一个是消息队列的长度，第二个每个消息队列中内容的大小，返回值是队列的句柄。以下是创建一个队列。 typedef uint32_t TickType_t; #define portMAX_DELAY ( TickType_t ) 0xffffffffUL #define ALGO_TASK_QUEUE_LENGTH 5 #de...
freertos-plus-tcp 移植
05-31
FreeRTOS-Plus-TCP 是一个基于 FreeRTOS 的 TCP/IP 协议栈实现，移植需要按照以下步骤进行： 1. 确认目标平台是否支持 FreeRTOS下载该平台的适配层代码。 2. 下载 FreeRTOS-Plus-TCP 的源代码，将其添加到工程中。 3. 配置 FreeRTOS-Plus-TCP，包括网络驱动、IP 地址、网关、子网掩码等参数。 4. 配置 FreeRTOS-Plus-TCP 的协议栈，包括 TCP 和 UDP 协议栈。 5. 编写应用程序，并使用 FreeRTOS-Plus-TCP 提供的 API 实现网络连接、数据传输等功能。 需要注意的是，在移植过程中需要根据目标平台的特性进行适当的调整和修改，以保证 FreeRTOS-Plus-TCP 的正常运行。同时，需要对网络安全进行充分考虑，确保系统的安全性和稳定性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值