【ESP32】嵌入式FreeRtos--队列Queue

最新推荐文章于 2024-04-18 22:31:08 发布
最新推荐文章于 2024-04-18 22:31:08 发布
阅读量919 收藏 5
点赞数
分类专栏： 嵌入式学习笔记 文章标签： freertos
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45355603/article/details/130038632
版权

基础知识

队列：先入先出(FIFO,first in first out)

使用方法：

  1. 创建队列长度、尺寸(每个信息内存空间的大小)
  2. 发送数据
  3. 取数据
API功能
xQueueCreate()创建一个队列
xQueueSend()往队列里写数据
xQueueReceive从队列里读数据
uxQueueMessagesWaiting(队列句柄)返回值为队列中参数的个数，可用于接收数据时，先判断一下队列里是否有数据
// 创建一个队列
QueueHandle_t xQueueCreate(UBaseType_t uxQueueLength, UBaseType_t uxItemSize);  // API

QueueHandle_t Qhandle = xQueueCreate(5, sizeof(int)); // 创建一个队列，长度为5，每个空间的大小为int

 // 发送队列数据API
BaseType_t xQueueSend(
    QueueHandle_t xQueue,
    const void *pvItemToQueue,
    TickType_t xTicksToWait);

// 示例
void send(void *pt)
{
  QueueHandle_t Qhandle = (QueueHandle_t)pt; // 进行强制类型转换，转换为队列句柄

  BaseType_t xStatus; // 记录数据是否发送成功

  char i = 0; // 要发送的数据
  while (1)
  {
    /*参数1：队列的句柄；参数2：要发送的数据； 参数3：超时等待时间*/
    xStatus = xQueueSend(Qhandle, &i, 0);

    if (xStatus != pdPASS)
    {
      Serial.println("发送失败");
    }
    else
      Serial.println("发送成功");
    i++;
    if (i == 8)
      i = 0;
    vTaskDelay(1000);
  }
}

// 接收队列API
BaseType_t xQueueReceive(
    QueueHandle_t xQueue,
    void *pvBuffer,
    TickType_t xTicksToWait);
    
// 示例
void receive(void *pt)
{
  int j = 0; // 接收数据
  while (1)
  {
    if (xQueueReceive(Qhandle, &j, 0) != pdPASS)
    {
      Serial.println("接收失败");
    }
    else
    {
      Serial.print("接收成功：");
      Serial.println(j);
    }

    vTaskDelay(1000);
  }
}

示例1：队列存储int数据

#include <Arduino.h>

// 创建队列全局变量，全局变量
QueueHandle_t Qhandle = xQueueCreate(5, sizeof(int)); // 创建一个队列，长度为5，每个空间的大小为int

void send(void *pt)
{
 int i = 0; // 要发送的数据
  while (1)
  {
    /*参数1：队列的句柄；参数2：要发送的数据； 参数3：超时等待时间*/
    if (xQueueSend(Qhandle, &i, 0) != pdPASS)
    {
      Serial.println("发送失败");
    }
    else
    {
      Serial.print("发送成功：");
      Serial.println(i);
    }
    i++;
    if (i == 8)
      i = 0;
    vTaskDelay(1000);
  }
}

void receive(void *pt)
{
  int j = 0; // 接收数据
  while (1)
  {
    if (xQueueReceive(Qhandle, &j, 0) != pdPASS)
    {
      Serial.println("接收失败：");
    }
    else
    {
      Serial.print("接收成功：");
      Serial.println(j);
    }

    vTaskDelay(1000);
  }
}

void setup()
{
  Serial.begin(9600);

  if (Qhandle != NULL)
  {
    Serial.println("队列创建成功");
    xTaskCreatePinnedToCore(send, "", 1024 * 5, NULL, 1, NULL, 1);    // 发送数据
    xTaskCreatePinnedToCore(receive, "", 1024 * 5, NULL, 1, NULL, 1); // 接收数据
  }
  else
  {
    Serial.println("队列创建失败");
  }
}

void loop()
{
}

运行结果：

示例2：传递结构体(常用)

// 声明一个结构体
struct Struct
{
  int id;
  int a;
};
  • QueueHandle_t Qhandle = xQueueCreate(5, sizeof(xStruct)); 在上个程序的基础上进行创建的队列每个空间的大小
  • 修改队列的地址
#include <Arduino.h>

struct Struct
{
  int id;
  int a;
};

// 创建队列全局变量，全局变量
QueueHandle_t Qhandle = xQueueCreate(5, sizeof(Struct)); // 创建一个队列，长度为5，每个空间的大小为int

void send(void *pt)
{
  Struct xUSB = {1, 55}; // 要发送的数据
  while (1)
  {
    /*参数1：队列的句柄；参数2：要发送的数据； 参数3：超时等待时间*/
    if (xQueueSend(Qhandle, &xUSB, 0) != pdPASS)
    {
      Serial.println("发送失败");
    }
    else
    {
      Serial.println("发送成功");
      xUSB.id++;
    }

    vTaskDelay(1000);
  }
}

void receive(void *pt)
{
  Struct yUSB; // 定义一个接收结构体
  while (1)
  {
    if (xQueueReceive(Qhandle, &yUSB, 0) != pdPASS)
    {
      Serial.println("接收失败");
    }
    else
    {
      Serial.print("接收成功：");
      Serial.println(yUSB.id);
      Serial.println(yUSB.a);
    }

    vTaskDelay(1000);
  }
}

void setup()
{
  Serial.begin(9600);

  if (Qhandle != NULL)
  {
    Serial.println("队列创建成功");
    xTaskCreatePinnedToCore(send, "", 1024 * 5, NULL, 1, NULL, 1);    // 发送数据
    xTaskCreatePinnedToCore(receive, "", 1024 * 5, NULL, 1, NULL, 1); // 接收数据
  }
  else
  {
    Serial.println("队列创建失败");
  }
}

void loop()
{
}

运行结果：

发送成功
接收成功：1
55
发送成功
接收成功：2
55

示例3：传递大数据时，把指针对应的数据进行传递

  • malloc()函数使用：在使用malloc开辟空间时，使用完一定要释放空间，如果不释放会造成内存泄漏。malloc()函数返回的实际是一个无类型指针，必须在其前面加上指针类型强制转换才可以使用。指针自身 = (指针类型*)malloc(sizeof(指针类型)*数据数量)
	int *p = NULL;
	int n = 10;
	p = (int *)malloc(sizeof(int)*n);
  • free()释放malloc()函数给指针变量分配的内存空间。注意：使用后该指针变量一定要重新指向NULL，防止野指针(悬空指针、失效指针)出现。
int *p = (int *)malloc(sizeof(int));
	*p = 100;
	free(p);
	p = NULL;

队列的多进单出：多个任务写，一个任务读


多个任务输入一个队列，一个任务读队列中的数据，此时注意设置任务的优先级别，设置写入的任务级别为1(各任务之间轮流发送数据)，读任务的优先级别为2。

  • portMAX_DELAY一直等待，直到队列中有数据就开始读
#include <Arduino.h>

QueueHandle_t Qhandle = xQueueCreate(5, sizeof(int)); // 创建一个队列，长度为5，每个空间的大小为int

void send1(void *pt)
{
  int i = 1; // 任务1要发送的数据
  while (1)
  {

    if (xQueueSend(Qhandle, &i, 0) != pdPASS)
    {
      Serial.println("发送失败");
    }
    else
    {
      Serial.println("发送成功");
    }
    vTaskDelay(1000);
  }
}

void send2(void *pt)
{
  int i = 2; // 任务2要发送的数据
  while (1)
  {
    if (xQueueSend(Qhandle, &i, 0) != pdPASS)
    {
      Serial.println("发送失败");
    }
    else
    {
      Serial.println("发送成功");
    }
    vTaskDelay(1000);
  }
}

void receive(void *pt)
{
  int i; // 存储接收数据
  while (1)
  {
    if (xQueueReceive(Qhandle, &i, portMAX_DELAY) != pdPASS) // portMAX_DELAY，一直等待，直到队列中有数据。等待时间设置为0，表示队列中如果没有数据，立即返回
    {
      Serial.println("接收失败");
    }
    else
    {
      Serial.print("接收成功：");
      Serial.println(i);
    }
    // vTaskDelay(1000); // 采用了portMAX_DELAY，这里就不需要delay了
  }
}

void setup()
{
  Serial.begin(9600);

  if (Qhandle != NULL)
  {
    Serial.println("队列创建成功");
    xTaskCreatePinnedToCore(send1, "", 1024 * 5, NULL, 1, NULL, 1); // 两个相同的优先级别，轮流发送数据
    xTaskCreatePinnedToCore(send2, "", 1024 * 5, NULL, 1, NULL, 1);
    xTaskCreatePinnedToCore(receive, "", 1024 * 5, NULL, 2, NULL, 1); // 优先级别2，只要队列中有数据，就读
  }
  else
  {
    Serial.println("队列创建失败");
  }
}

void loop()
{
}

运行结果：

发送成功
接收成功：2
发送成功
接收成功：1

队列集合：一个任务读不同的队列

  • xQueueCreateSet( const UBaseType_t uxEventQueueLength ) 参数为队列集合的总长度
/*把队列加入到集合中
参数1：需要加入的队列句柄；参数2：队列集合的句柄*/
BaseType_t xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore,
QueueSetHandle_t xQueueSet );

// 从队列集合中选择有数据的队列
QueueSetMemberHandle_t xQueueSelectFromSet( QueueSetHandle_t xQueueSet,
const TickType_t xTicksToWait );

#include <Arduino.h>

QueueHandle_t Qhandle1 = xQueueCreate(5, sizeof(int)); // 队列1
QueueHandle_t Qhandle2 = xQueueCreate(5, sizeof(int)); // 队列2

QueueSetHandle_t QueueSet = xQueueCreateSet(10); // 队列集合句柄

xQueueAddToSet(Qhandle1, QueueSet); // 把队列1加入到队列集合中
xQueueAddToSet(Qhandle2, QueueSet); // 把队列2加入到队列集合中

QueueSetMemberHandle_t QueueData = xQueueSelectFromSet(QueueSet, portMAX_DELAY); // 从队列集合中获取有数据的队列

void send1(void *pt)
{
  int i = 1; // 任务1要发送的数据
  while (1)
  {

    if (xQueueSend(Qhandle1, &i, 0) != pdPASS)
    {
      Serial.println("发送失败");
    }
    else
    {
      Serial.println("发送成功");
    }
    vTaskDelay(1000);
  }
}

void send2(void *pt)
{
  int i = 2; // 任务2要发送的数据
  while (1)
  {
    if (xQueueSend(Qhandle2, &i, 0) != pdPASS)
    {
      Serial.println("发送失败");
    }
    else
    {
      Serial.println("发送成功");
    }
    vTaskDelay(1000);
  }
}

void receive(void *pt)
{

  int i; // 存储接收数据
  while (1)
  {
    if (xQueueReceive(QueueData, &i, portMAX_DELAY) != pdPASS) // portMAX_DELAY，一直等待，直到队列中有数据
    {
      Serial.println("接收失败");
    }
    else
    {
      Serial.print("接收成功：");
      Serial.println(i);
    }
    // vTaskDelay(1000); // 采用了portMAX_DELAY，这里就不需要delay了
  }
}

void setup()
{
  Serial.begin(9600);

  Serial.println("队列创建成功");
  xTaskCreatePinnedToCore(send1, "", 1024 * 5, NULL, 1, NULL, 1); // 两个相同的优先级别，轮流发送数据
  xTaskCreatePinnedToCore(send2, "", 1024 * 5, NULL, 1, NULL, 1);
  xTaskCreatePinnedToCore(receive, "", 1024 * 5, NULL, 2, NULL, 1); // 优先级别2，只要队列中有数据，就读
}

void loop()
{
}

队列邮箱：一个任务写，多个任务读

  • BaseType_t xQueueOverwrite( QueueHandle_t xQueue, const void *pvItemToQueue );往队列邮箱中写入数据
// 从队列邮箱中读数据
BaseType_t xQueuePeek( QueueHandle_t xQueue,
void *pvBuffer, TickType_t
xTicksToWait );

#include <Arduino.h>

QueueHandle_t Mailbox = xQueueCreate(1, sizeof(int));

void send(void *pt)
{
  int i = 1; // 任务1要发送的数据
  while (1)
  {
    if (xQueueOverwrite(Mailbox, &i) != pdPASS)
    {
      Serial.println("发送失败");
    }
    else
    {
      Serial.println("发送成功");
      i++;
    }
    vTaskDelay(1000);
  }
}

void receive1(void *pt)
{

  int i; // 存储接收数据
  while (1)
  {
    if (xQueuePeek(Mailbox, &i, 0) != pdPASS) // portMAX_DELAY，一直等待，直到队列中有数据
    {
      Serial.println("接收失败");
    }
    else
    {
      Serial.print("接收成功：");
      Serial.println(i);
    }
  }
}
void receive2(void *pt)
{

  int i; // 存储接收数据
  while (1)
  {
    if (xQueuePeek(Mailbox, &i, 0) != pdPASS) // portMAX_DELAY，一直等待，直到队列中有数据
    {
      Serial.println("接收失败");
    }
    else
    {
      Serial.print("接收成功：");
      Serial.println(i);
    }
  }
}

void setup()
{
  Serial.begin(9600);

  Serial.println("队列创建成功");
  xTaskCreatePinnedToCore(send, "", 1024 * 5, NULL, 1, NULL, 1);
  xTaskCreatePinnedToCore(receive1, "", 1024 * 5, NULL, 2, NULL, 1);
  xTaskCreatePinnedToCore(receive2, "", 1024 * 5, NULL, 2, NULL, 1);
}

void loop()
{
}
⁢稚子
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
FreeRTOS消息队列
hqy450665101的博客
02-01 1220
FreeRTOS消息队列 队列又称消息队列，是一种常用于任务间通信的数据结构， 队列可以在任务与任务间、中断和任务间传递信息，实现了任务接收来自其他任务或中断的不固定长度的消息，任务能够从队列里面读取消息，当队列中的消息是空时，读取消息的任务将被阻塞，用户还可以指定阻塞的任务时间 xTicksToWait，在这段时间中，如果队列为空，该任务将保持阻塞状态以等待队列数据有效。 当队列中有新消息时， 被阻塞的任务会被唤醒并处理新消息；当等待的时间超过了指定的阻塞时间，即使队列中尚无有效数据，任务也会自动从阻塞态
GD32-FreeRTOS-TCP
10-10
GD32F450+LAN8720A移植FreeRTOS_TCP的工程
【ESP32+freeRTOS学习笔记-(五)队列Queue】
weixin_45499326的博客
01-05 2522
Queues提供了一个任务到任务，任务到中断，以及中断到任务的通信机制。学过数据结构的原理应该知道，队列是常用的数据结构的一种，是一种先入先出First IN First Out 的数据组织与操作形态的名称。因此在FreeRTOS中，队列Queue的本质也是一样的。对于其行为与组织形式，用原文的图解能更清楚地说明。由上图可以清楚的看出，FreeRTOS的Queue就是一个实现了队列的存储组织形式以及完成了不同任务之能互相传递数据的操作实现。队列能保存有限数量的固定大小的数据项。
Freertos学习第二天-ESP32基于Freertos通过结构体传递多个参数
最新发布
qq_61134394的博客
04-18 311
Freertos学习第二天-ESP32基于Freertos通过结构体传递多个参数
【ESP32】以蓝牙网关为例，记录队列的使用
欢迎来到博客主页
09-12 350
> 本文档自己下载并烧录测试过的，工程结构非常清晰，是一个非常好的学习框架。 > 主要学了： > 这里是引用 > 1. 队列的使用，内存的管理 > 2. socket tcp 服务器的连接 > 3. 普通蓝牙协议连接通信
ESP32编程指南 —— Queue API (队列)
weixin_45652444的博客
07-22 3222
文章目录队列 API头文件• freertos/include/freertos/queue.h函数xQueueGenericSendFromISRxQueueGiveFromISRxQueueGenericSendxQueuePeek前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 队列 API 头文件 • freertos/include/freertos/queue.h 函数 xQueueGenericSendFromISR BaseType_t xQueueGenericSend
ESP32-IDF的Freertos消息队列的创建与基础应用
Lee1989
09-10 3272
文章目录前言一、消息队列是什么？二、消息队列的作用三、FreeRtos中消息队列API的调用函数 xQueueCreate函数 xQueueSend2.读入数据总结 前言 写博客是为了总结知识，提炼知识不做知识的搬运者 文章不一定全是原创但是所写内容都有经过自身研读与提炼 喜欢我博客的朋友可以跟我交流与点赞， 一、消息队列是什么？ 队列是任务间通信的主要形式。它们可用于在任务之间以及中断和任务之间发送消息。在大多数情况下，它们用作线程安全的 FIFO（先进先出）缓冲区，将新数据发送到队列的后面，尽..
ESP32---定时器+消息队列的使用
weixin_63163242的博客
08-28 249
【代码】ESP32---定时器+消息队列的使用。
stm32-freeRTOS-queue
04-08
主要介绍Queue的相关知识，包括Queue的定义，发送和接收消息的方式等内容。重点使用Free RTOS中Queue的接口，实现数据在不同task之间的发送和接收的案例，并在板卡上验证该功能。
ESP32-FreeRTOS-with-Arduino:已导入有用的Arduino库的项目模板。 使用此模板，可以实现FreeRTOS编程
05-12
带Arduino的ESP32-FreeRTOS- 已导入有用的Arduino库的项目模板。 使用此模板，可以实现FreeRTOS编程。安装： 确保您已安装git命令。 git clone ...
freeRTOS--之队列.zip
09-24
里面是freeRTOS消息队列的代码，107开发板，适合新手入手，如果需要自行下在
esp32 线程
07-13
ESP32支持线程功能，可以利用线程实现多任务。ESP32上线程的用法和pyboard上差不多，都是通过_thread模块。下面演示了线程的基本用法，程序定义了三个线程，一个线程控制LED，另外两个线程打印信息。
ESP32_FreeRTOS-SDcard:ESP32 FreeRTOS项目将数据记录到SDCard
03-31
ESP32_FreeRTOS-SD卡ESP32 FreeRTOS项目将数据记录到SDCard
【FreeRTOS】实时嵌入式系统通信利器：深入探索FreeRTOS中的队列机制
Goforyouqp的博客
07-20 1万+
队列是一种先进先出（FIFO）的数据结构，类似于日常生活中的排队机制。在FreeRTOS中，队列提供了一个缓冲区，可以存储多个项目。任务可以向队列发送数据，也可以从队列接收数据。
ESP32爬坑之旅②——初识FreeRTOS
weixin_42060750的博客
03-23 1904
1.前言   在学习esp32官方源码的时候，发现了有这么一个函数： xTaskCreate(esp_mesh_p2p_tx_main, "MPTX", 3072, NULL, 5, NULL);   从单片机学过来的朋友应该知道，一般都是在主函数中添加while循环，然后实现相应的功能。而这里却见不到执行程序的while函数，是怎么回事呢？别着急，我们先从FreeRTOS说起。 2.FreeR...
ESP32 FreeRTOS学习总结
保持热爱，奔赴山海。
05-12 1950
ESP32 FreeRTOS学习笔记，任务管理、队列、信号量、流媒体、任务通知
FreeRTOS — 消息队列
热门推荐
流风回雪的博客
04-20 1万+
以下内容转载自安富莱电子：http://forum.armfly.com/forum.phpFreeRTOS 的一个重要的通信机制----消息队列，消息队列在实际项目中应用较多。1、消息队列 1.1 消息队列的概念及其作用　　消息队列就是通过 RTOS 内核提供的服务，任务或中断服务子程序可以将一个消息（注意，FreeRTOS消息队列传递的是实际数据，并不是数据地址，RTX，uCOS-II 和 u...
【ESP32-IDF】03-1 系统-内存管理
qq_41741344的博客
05-03 4657
ESP32内存结构 文章目录ESP32内存结构1. 内存分段2. ESP32 内存模型2.1 片内RAM2.1.1 片内RAM空间布局2.1.2 IRAM组织结构2.1.3 DRAM2.1.4 启用蓝牙之后的DRAM2.1.5 启用跟踪调试空间之后 DRAM 组织结构2.2 片外RAM2.2.1 PSRAM (也叫SPIRAM)3. ESP32 内存的使用3.1 IRAM3.2 IROM3.3 RTC快速内存3.4 DRAM3.5 DROM3.6 RTC慢速内存3.7 DMA4. 堆的分配与调试4.1 相关
【Freertos基础入门】队列(queue)的使用
m0_62599305的博客
08-19 1456
FreeRTOS是一个广泛使用的开源实时操作系统（RTOS），它提供了丰富的功能和特性，使嵌入式系统的开发更加简单和高效。队列是FreeRTOS中常用的一种通信机制，它用于在任务之间传递数据。队列是FreeRTOS中一种有用的通信机制，可用于在任务之间传递数据。通过使用队列，我们可以实现任务之间的数据共享和同步。在使用队列时，需要注意队列的深度和每个数据项的大小，并选择适当的阻塞等待时间以避免资源争用和任务饥饿等问题。
esp32-idf开发实例-freertos消息队列-中断服务消息发送与响应
08-19
FreeRTOS是一个开源的实时操作系统内核，被广泛应用于嵌入式系统中。ESP32是一款具有双核处理器和Wi-Fi功能的芯片，通过使用ESP-IDF开发框架可以进行软件开发。在ESP32-IDF开发中，使用FreeRTOS的消息队列可以实现不同任务之间的通信。 在ESP32开发中，可以通过中断服务程序（Interrupt Service Routine，ISR）来发送消息到消息队列，并在任务中通过接收方法响应。 首先，我们需要创建一个全局的消息队列句柄，可以使用xQueueCreate函数来创建一个消息队列。例如，可以使用以下代码创建一个大小为10的消息队列： xQueueHandle messageQueue = xQueueCreate(10, sizeof(int)); 然后，在中断服务程序中，可以使用xQueueSendFromISR方法将消息发送到消息队列中。例如，可以使用以下代码将一个整数值发送到消息队列中： int value = 100; xQueueSendFromISR(messageQueue, &value, NULL); 在任务中，可以使用xQueueReceive方法从消息队列中接收消息并进行响应。例如，可以使用以下代码从消息队列中接收一个整数值并打印出来： int receivedValue; xQueueReceive(messageQueue, &receivedValue, portMAX_DELAY); printf("Received value: %d\n", receivedValue); 需要注意的是，在接收消息时，可以通过指定第三个参数来设置等待时间。例如，使用portMAX_DELAY表示无限等待，即直到接收到消息为止。 通过以上步骤，我们可以实现在ESP32开发中使用FreeRTOS消息队列进行中断服务消息发送与响应。这种方式可以实现不同任务之间的通信和同步，提高系统的并发性和实时性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值