【FreeRTOS】详细讲解FreeRTOS中消息队列并通过示例讲述其用法

最新推荐文章于 2024-07-09 08:54:21 发布
最新推荐文章于 2024-07-09 08:54:21 发布
阅读量1w 收藏 51
点赞数 26
分类专栏： # FreeRTOS OS 文章标签： 单片机 c语言 嵌入式硬件 stm32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53960242/article/details/128795993
版权
FreeRTOS 同时被 2 个专栏收录
6 篇文章 13 订阅
订阅专栏
OS
6 篇文章 1 订阅
订阅专栏

讲解FreeRTOS中消息队列及其用法

使用消息队列的原因

  在裸机系统中，两个程序间需要共享某个资源通常使用全局变量来实现；但在含操作系统(下文就拿FreeRTOS举例)的开发中，则使用消息队列完成。那么这两者有啥区别呢？🤔🤔🤔
  其实在FreeRTOS系统中也能够像裸机似的，使用全局变量实现多程序共享某个资源（这里资源就可称为临界资源），则多个程序都能随时访问同一个临界资源，这时若两个程序同时访问同一个临界资源来完成两次资源读写操作，假如两个程序读取操作是同时完成，但是写入操作有先后之别，那么最后实际完成的操作就会是一个。例如下图：

  看完上图后，大家可能会想：两者结果相同，无所谓了。但是呢，如果此时再来个C程序恰好读取到的值为456，那么是不是跟最终结果789存在偏差呢！！！😅😅😅

  因此，在FreeRTOS系统中，引入了消息队列来实现某个资源共享，其不仅仅实现临界资源共享，也给临界资源提供保护，使得程序更加稳定。

消息队列

  消息队列，是一种用于任务与任务间、中断和任务间传递一条或多条信息的数据结构，实现了任务接收来自其他任务或中断的不固定或固定长度的消息。
  任务从队列里面读取消息时，如果队列中消息为空，读取消息的任务将被阻塞；否则任务就读取消息并且处理。用户还可以指定阻塞任务时间 xTicksToWait()，在指定阻塞时间内，如果队列为空，该任务将保持阻塞状态以等待队列数据有效。
  有多个消息发送到消息队列时，通常将先进入队列的消息先传给任务，也就是说，任务一般读取到的消息是最先进入消息队列的消息，即先进先出原则（FIFO），但也支持后进先出原则（LIFO）。
  FreeRTOS 中使用队列数据结构实现任务异步通信工作，其具有如下特性：

  • 消息支持先进先出的方式排队，支持异步读写的工作方式；
  • 读写队列均支持超时机制；
  • 消息支持后进先出方式排队，即直接往队首发送消息（LIFO）；
  • 允许不同长度（不超过队列节点最大值）的任意类型消息；
  • 一个任务能够与任意一个消息队列接收和发送消息的操作；
  • 多个任务能够与同一个消息队列接收和发送消息的操作；
  • 当队列使用结束后，可以通过删除队列函数进行删除函数；

消息队列收发双方处理机制

  • 创建消息队列，FreeRTOS系统会分配一块单个消息大小与消息队列长度乘积的空间；(创建成功后，每个消息的大小及消息队列长度无法更改，不能写入大于单个消息大小的数据，并且只有删除消息队列时，才能释放队列占用的内存。)

  • 写入消息队列，当消息队列未满或允许覆盖入队时，FreeRTOS系统会直接将消息复制到队列末端；否则，程序会根据指定的阻塞时间进入阻塞状态，直到消息队列未满或者是阻塞时间超时，程序就会进入就绪状态；
    写入紧急消息，本质上与普通消息差不多，不同的是其将消息直接复制到消息队列队首；

  • 读取消息队列，在指定阻塞时间内，未读取到消息队列中的数据（消息队列为空），程序进入阻塞状态，等待消息队列中有数据；一旦阻塞时间超时，程序进入就绪态；

  • 一旦消息队列不再使用时，应该将其删除；（此时会永久删除）

消息队列的处理机制图
（图有点丑，大家伙将就一下吧🤣🤣🤣）

函数解析

消息队列通用创建
函数原型

QueueHandle_t xQueueGenericCreate( 
								   const UBaseType_t uxQueueLength,
                                   const UBaseType_t uxItemSize,
                                   const uint8_t ucQueueType 
                                 );

参数解析

  • const UBaseType_t uxQueueLength：设置消息队列长度；
  • const UBaseType_t uxItemSize：设置消息队列中单个消息大小；
  • const uint8_t ucQueueType：设置消息队列的类型；

函数说明
  一个通用的消息队列创建函数，该函数自己给其他函数提供API，自己也调用函数prvInitialiseNewQueue()完成消息队列创建功能。

消息队列动态创建
函数原型

QueueHandle_t xQueueCreate(
                            UBaseType_t uxQueueLength,
                            UBaseType_t uxItemSize
                         );

参数解析

  • UBaseType_t uxQueueLength：设置消息队列长度；
  • UBaseType_t uxItemSize：设置消息队列中单个消息的大小；

函数说明
  创建函数，实际上使用还是调用函数 xQueueGenericCreate()完成消息队列创建工作。
  当消息队列创建成功时，返回一个消息队列的控制句柄，用于访问创建的队列；否则，返回NULL，可能原因是创建队列需要的 RAM 无法分配成功。

消息队列静态创建
函数原型

QueueHandle_t xQueueCreateStatic(
 	                             UBaseType_t uxQueueLength,
    	                         UBaseType_t uxItemSize,
        	                     uint8_t *pucQueueStorage,
            	                 StaticQueue_t *pxQueueBuffer
                		        );

参数解析

  • UBaseType_t uxQueueLength：设置消息队列长度；
  • UBaseType_t uxItemSize：设置消息队列中单个消息大小；
  • uint8_t *pucQueueStorage：传递消息队列中单个消息的存储结构；
  • StaticQueue_t *pxQueueBuffer：传递自定义的消息队列；

函数说明

  xQueueCreateStatic()用于创建一个新的队列并返回可用于访问这个队列的队列句柄，队列句柄其实就是一个指向队列数据结构类型的指针。
  当返回值为NULL时，创建失败，失败原因与动态创建类似，即可能是创建队列需要的 RAM 无法分配成功。

消息队列删除
函数原型

void vQueueDelete( QueueHandle_t xQueue );

参数解析

  • QueueHandle_t xQueue:消息队列的控制句柄；

函数说明
  使用函数vQueueDelete()可以将一个消息队列中的所有信息都清空回收，并且该队列将无法继续使用。值得注意的是，一个没有创建的消息队列，是无法删除的。

发送消息到消息队列
函数原型

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

参数解析

  • QueueHandle_t xQueue：传入消息队列的控制句柄；
  • const void * pvItemToQueue：传入需要发送到消息队列中的数据；
  • TickType_t xTicksToWait：设置阻塞超时时间，设置成0,可直接返回;

函数说明
  发送函数实际上调用PAI函数xQueueGenericSend()；该函数也等同于函数xQueueSendToBack()。
  发送消息函数xQueueSend()，其处理机制为：当消息队列未满或允许覆盖入队时，FreeRTOS系统会直接将消息复制到队列末端；否则，程序会根据指定的阻塞时间进入阻塞状态，直到消息队列未满或者是阻塞时间超时，程序就会进入就绪状态。

中断中发送消息到消息队列
函数原型

 BaseType_t xQueueSendFromISR(
                               QueueHandle_t xQueue,
                               const void *pvItemToQueue,
                               BaseType_t *pxHigherPriorityTaskWoken
                             );

参数解析

  • QueueHandle_t xQueue：传递消息队列的控制权柄；
  • const void *pvItemToQueue：传递需要发送的消息；
  • BaseType_t *pxHigherPriorityTaskWoken：若消息入队列时产生一个更高优先级的任务，那么改参数就会被设置成pdTRUE，系统在中断函数结束前会切换任务，去执行更高优先级的任务。在FReeRTOS V7.3.0起，该函数为一个可选参数。

函数说明
  该函数实际上调用FreeRTOS系统APIxQueueGenericSendFromISR()来完成在中断中发送消息。该函数功能上与xQueueSendToBackFromISR()相同，并且两者参数完全一致。

发送消息到消息队列队首
函数原型

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

参数解析

  • QueueHandle_t xQueue：消息队列的控制句柄；
  • const void *pvItemToQueue：需要发送的消息；
  • TickType_t xTicksToWait：函数阻塞超时时间；

函数说明
  该函数实际上还是调用函数xQueueGenericSend()来完成其功能的。
  xQueueSendToToFront()向队列队首发送一个消息；发送消息成功返回pdTRUE，否则返回 errQUEUE_FULL。

中断中发送消息到消息队列队首
函数原型

 BaseType_t xQueueSendToFrontFromISR(
                                       QueueHandle_t xQueue,
                                       const void *pvItemToQueue,
                                       BaseType_t *pxHigherPriorityTaskWoken
                                    );

参数解析

  • QueueHandle_t xQueue：消息队列的控制句柄；
  • const void *pvItemToQueue：需要发送的消息；
  • BaseType_t *pxHigherPriorityTaskWoken：与xQueueSendFromISR中的该参数类似，都是与队列插入数据时产生的更高优先级任务有关；

函数说明

消息队列接收函数
函数原型

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

参数解析

  • QueueHandle_t xQueue：消息队列的控制权柄；
  • void * const pvBuffer：指向存储消息队列数据的存储空间；
  • TickType_t xTicksToWait：消息队列接收函数的最大阻塞时间。若该函数设置为0，则函数立刻返回；

函数说明
  一旦消息队列接收成功后会返回pdTRUE;否则,返回pdFALSE。接收消息队列后会删除该消息，倘若不想删除该信息，可使用函数xQueuePeek()。

在中断中接收消息队列中消息
函数原型

BaseType_t xQueueReceiveFromISR( 
							QueueHandle_t xQueue,
                            void * const pvBuffer,
                            BaseType_t * const pxHigherPriorityTaskWoken
                                );

参数解析

  • QueueHandle_t xQueue：消息队列的控制权柄；
  • void * const pvBuffer：需要发送的消息
  • BaseType_t * const pxHigherPriorityTaskWoken：任务在往队列发送信息时，如果队列满，则任务将阻塞在该队列上，若xQueueReceiveFromISR()函数碰都一个任务，则*pxHigherPriorityTaskWoken=pdTRUE；否则，其值为NULL。

函数说明
  函数xQueueReceiveFromISR()是函数xQueueReceive的中断版本，功能上一样，即接收函数后，也会将该消息删除，若不想删除可使用函数 xQueuePeekFromISR。同样，函数 xQueuePeekFromISR()是函数xQueuePeek()的中断版，功能上也是一样的。

示例

示例1
  先创建两个任务，再通过消息队列实现任务间一对一通信，来完成任务2控制任务1实现依次反转LED1-LED8的状态。此时消息队列传递的是一个整型数据。

//任务控制权柄
TaskHandle_t xHandleTsak[4];
//消息队列控制权柄
QueueHandle_t xMyQueueHandle;

int main(void)
{
	//存储创建任务的返回值
	BaseType_t xReturn[5] ;
	
	xMyQueueHandle = xQueueCreate(20,sizeof(uint16_t));
	
	if(xMyQueueHandle == 0)
		//点亮LED7
		changeLedStateByLocation(LED7,ON);
	
	//动态创建任务1
	xReturn[0] = xTaskCreate(
				(TaskFunction_t )queueMesageTask1,
				(const char *)"queueMesageTask1",(uint16_t)512,
				(void*)NULL,2,&xHandleTsak[0]
				);
	
	//动态创建任务2
	xReturn[1] = xTaskCreate(
				(TaskFunction_t )queueMesageTask2,
				(const char *)"queueMesageTask2",
				(uint16_t)512,(void*)NULL,1,
				&xHandleTsak[1]
				);		
	//创建成功 
	if (pdPASS == xReturn[0] == xReturn[1])
		//启动任务，开启调度 
		vTaskStartScheduler(); 
	//创建失败
	else
		//点亮LED6
		changeLedStateByLocation(LED6,ON);
}

/********************************************
* 函数功能：消息队列测试函数1
* 函数参数：无
* 函数返回值：无
********************************************/
void queueMesageTask1(void)
{
	// 定义一个接收消息的变量
	uint16_t r_queue;
	while(1)
	{
		 if( pdTRUE == xQueueReceive( xMyQueueHandle,&r_queue,portMAX_DELAY) )
			rollbackLedByLocation(r_queue);
	}
}

/********************************************
* 函数功能：消息队列测试函数2
* 函数参数：无
* 函数返回值：无
********************************************/
void queueMesageTask2(void)
{
	uint16_t data[] = {LED1,LED2,LED3,LED4,LED5,LED6,LED7,LED8};
	//保存需要发送的数据
	static uint16_t i = 0;
	//保存系统时间
	static portTickType myPreviousWakeTime;
	//保存阻塞时间
	const volatile TickType_t xDelay1500ms = pdMS_TO_TICKS( 1500UL );
	//获取当前时间
	myPreviousWakeTime = xTaskGetTickCount();
	while(1)
	{
		xQueueSend( xMyQueueHandle,&data[i],0 );
		if(++i == 8) i = 0;
		
		//非阻塞延时1.5s
		xTaskDelayUntil( &myPreviousWakeTime,xDelay1500ms );
	}
}

示例2
  使用xTaskCreate()函数创建三个任务，其中有两个发送消息任务，一个接收消息任务，以完成一个多对一消息队列的实验。
  在创建任务时，为了使得代码更加舒服，采用带参数创建FreeRTOS任务的方法，即先将函数需要用到的参数使用结构体保存，然后再通过xTaskCreate()函数的第四个参数传递给相应任务。
  相对于示例1，示例2对任务间传递的消息也进行了优化，使其传递的数据由一个整型变量改成一个结构体；改变后，即有利于消息数据的扩展，同时，也方便多个多种类型消息同时传递。

// 消息队列传输的数据类型
struct messageQueue{
	int id;
	char msg[100];
};

//创建任务时传递参数结构体
struct taskParameters{
	// 任务ID
	int id;
	// 绝对延时延时时间
	uint16_t delayTime;
	// LED灯位置
	uint16_t LEDLOCATION;
	// LCD显示行
	u8 lcdLine;
	// 整型参数，用于变量倍增
	int number;
};

void queueMesageTask1(void);
void queueMesageTask2(struct taskParameters* params);

//任务控制权柄
TaskHandle_t xHandleTsak[4];
//消息队列控制权柄
QueueHandle_t xMyQueueHandle;
// 任务参数 
struct taskParameters param[2] = {{0,1500,LED1,Line6,1},{1,1000,LED2,Line7,2}};
//任务名字
char*taskName[] = {"task1","task2"};

/*****************************************
* 函数功能：freertos工作函数
* 函数参数：无
* 函数返回值：无
*****************************************/
void freertosWork(void)
{
//创建两个任务 用于测试消息队列
	unsigned  int i = 0;
	
	//存储创建任务的返回值
	BaseType_t xReturn[5] ;
	
	// 创建消息队列
	xMyQueueHandle = xQueueCreate(20,sizeof(struct messageQueue));
	if(xMyQueueHandle == 0)
		//点亮LED7
		changeLedStateByLocation(LED7,ON);
	
	//动态创建任务
	for(i=0;i<2;i++)
		xReturn[i] = xTaskCreate((TaskFunction_t )queueMesageTask2,
					(const char *)taskName[i],(uint16_t)128,
					(struct taskParameters*) &param[i],1,&xHandleTsak[i]
					);
	
	//动态创建任务1
	xReturn[3] = xTaskCreate(
					(TaskFunction_t )queueMesageTask1,
					(const char *)"queueMesageTask3",
					(uint16_t)128,(void*)NULL,1,&xHandleTsak[3]
				);		
				
	LCD_DisplayStringLine(Line0,(uint8_t*)"receve:");
	LCD_DisplayStringLine(Line5,(uint8_t*)"send:");
	
	if (pdPASS == xReturn[0] == xReturn[1] == xReturn[2])
		//点亮LED6
		changeLedStateByLocation(LED6,ON);				
	else
		vTaskStartScheduler();
}

/********************************************
* 函数功能：消息队列测试函数1
* 函数参数：无
* 函数返回值：无
********************************************/
void queueMesageTask1(void)
{	
	// 定义一个接收消息的变量
	struct messageQueue r_queue;
	char temp[100];
	int j1=1;
	while(1)
	{
		//接收数据  如果数据接收成功就处理 否则就点亮LED4
		if( pdTRUE == xQueueReceive( xMyQueueHandle,&r_queue,portMAX_DELAY) )
		{
			sprintf(temp,"(%s;%s;%d;)",pcTaskGetName(xHandleTsak[r_queue.id]),r_queue.msg,r_queue.id);
			
			//任务2发送的数据
			if(r_queue.id == 0)
				LCD_DisplayStringLine(Line1,(uint8_t*)temp);
			//任务3发送的数据
			else
				LCD_DisplayStringLine(Line2,(uint8_t*)temp);
			//每次接收数据后闪烁一次LED3
			changeAllLedByStateNumber(OFF);
			changeLedStateByLocation(LED3,j1++%2);
		}
		//数据接收失败 点亮LED4
		else
		{
			changeAllLedByStateNumber(OFF);
			changeLedStateByLocation(LED4,ON);
		}
	}
}

/********************************************
* 函数功能：消息队列测试函数2
* 函数参数：无
* 函数返回值：无
********************************************/
void queueMesageTask2(struct taskParameters* params)
{
	//初始化以及保存需要发送的数据
	struct messageQueue _sData;
	struct messageQueue*sData = &_sData;
	sData->id = params->id;
	//显示需要发送的数据
	char temp[50];
	uint16_t count = 0;
	//保存系统时间
	portTickType myPreviousWakeTime;
	//保存阻塞时间
	TickType_t xDelayms = pdMS_TO_TICKS( params->delayTime );
	//获取当前时间
	myPreviousWakeTime = xTaskGetTickCount();
	while(1)
	{
		// 改变本次发送的数据
		sprintf(sData->msg,"%s%d","Sender2:",count+=params->number);
		sprintf(temp,"(%s;%d)",sData->msg,sData->id);
		LCD_DisplayStringLine(params->lcdLine,(uint8_t*)temp);
		
		//关闭所有LED灯 避免LCD带来的影响
		changeAllLedByStateNumber(0);
		//发送数据 如果发送成功就点亮一次LED1
		if( xQueueSend( xMyQueueHandle,&_sData,0 ) == pdTRUE)
			changeLedStateByLocation(params->LEDLOCATION,ON);
		
		//非阻塞延时(ms)
		xTaskDelayUntil( &myPreviousWakeTime,xDelayms );
	}
}

结果

遇到的问题

keil报错展示

报错分析
  该报错是由于结构体初始化时引起的，keil中不支持不完整定义的变量；但是可以看看小编目前使用的变量struct taskParameters param[2] = {{0,1500,LED1,Line6,1},{1,1000,LED2,Line7,2}};其一样可以啊！😢🤔因此到底什么原因小编暂时也不得而知了。

小编的解决方案
  不知道小编这样子到底算不算解决了该问题🤣🤣🤣：
  首先，小编整理了代码，将一些不必要的变量全部都删除，并且优化了代码架构，最后这个程序莫名其妙就可以使用了，没有丝毫报错与警告。🤔😅😅😅

  还有个问题是关于变量struct taskParameters param[2] = {{0,1500,LED1,Line6,1},{1,1000,LED2,Line7,2}};的，该变量最高定义为全局变量，否则程序就会跑飞；如果实在要将其定义为局部变量也行，但是需要换一种结构体初始化的方式。

  小编这里也有其他的一些相关文章，欢迎各位点击观看😉😉😉

☞黑心萝卜三条杠☜
关注
  • 26
    点赞
  • 踩
  • 51
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
【FreeRTOS】小白进阶之如何创建和使用FreeRTOS消息队列（一）
产品线负责人
09-08 1万+
文章主要讲解如何创建和使用队列。 消息队列浅析： 一个或者多个任务可以通过 RTOS 内核服务从队列中得到消息，通常先进入消息队列的消息先传 给任务，即先进先出的原则（FIFO），FreeRTOS 的消息队列支持 FIFO 和 LIFO 两种数据存取方式。 相比消息队列，使用全局数组主要有如下四个问题：  a、使用消息队列可以让 RTOS 内核有效地管理任务，而全局数组是无法做到的，任务的...
FreeRTOS PPT_消息队列
11-05
FreeRTOS PPT_消息队列的介绍，本章节为大家讲解 FreeRTOS 的一个重要的通信机制----消息队列，初学者要熟练掌握，因为消息队列在实际项目中应用较多。 消息队列的概念及其作用 消息队列就是通过RTOS 内核提供的服务，任务或中断服务子程序可以将一个消息（注意，FreeRTOS 消息队列传递的是实际数据，并不是数据地址，RTX，uCOS-II 和 uCOS-III 是传递的地址）放入到队列。
FreeRTOS——消息队列篇
最新发布
顺顺崽的博客
07-09 845
消息队列在FreeRTOS中的特点使其成为任务间通信、数据缓冲、同步和调度的重要工具。其线程安全性、FIFO顺序、阻塞和超时机制、优先级继承、灵活配置、中断支持、多任务支持、优先级队列等特性，确保了系统的稳定性和性能。
FreeRTOS——消息队列
qq_68719489的博客
07-03 699
队列：任务与任务、任务与中断之间进行数据交流的一种机制消息传递FreeRTOS基于队列， 实现了多种功能，其中包括队列集、互斥信号量、计数型信号量、二值信号量、 递归互斥信号量队列的核心：关中断（实现互斥）、链表（实现休眠和唤醒）、环形缓冲区（保存数据）Q：队列作用与全局变量作用的区别？答：功能类似于全局变量，但又比全局变量更安全假设全局变量a= 0，现有两个任务都在操作全局变量a，正常情况下，a = 2，然而，在操作系统中：对于简单的变量自增，其中也包含许多步骤。
FreeRTOS（3）----消息队列
weixin_63032791的博客
05-18 2480
当发送信息的时候，如果队列未满，则会将消息拷贝到队尾，否则，会根据用户指定的阻塞超过时间进行阻塞，如果队列一直不允许入队，任务则一直保持阻塞状态，等待队列允许入队，在这段时间，当别的任务从其他等待队列读入了数据（队列未满），任务将自动从阻塞态变为就绪态，当等待的时间超过阻塞时间，即使队列还不允许入队，任务也会从阻塞态变为就绪态，且发送信息的任务或者中断程序会收到一个错误码。注意:当多个任务阻塞在一个消息队列中，这些阻塞的任务会按照任务的优先级进排序，优先级高的任务将优先获得访问队列的权利。
4.3 FreeRTOS----队列的应用
IoT的搬运工！！！
08-27 425
xQueueCreate（）API函数         在使用队列之前必须明确创建一个队列。         队列由句柄引用，它们是QueueHandle_t类型的变量。 xQueueCreate() API函数创建一个队列，并返回一个引用其创建的队列的QueueHandle_t。         FreeRTOS V9.0.0还包括xQueueCreateStatic（）函数，它在编译时分
【FreeRTOS】消息队列——简介、常用API函数、注意事项、项目实现
Goforyouqp的博客
12-05 1873
队列又称消息队列，是一种常用于任务间通信的数据结构，队列可以在任务与任务间中断和任务间传递信息，实现了任务接收来自其他任务或中断的不固定长度的消息。
FreeRTOS - 消息队列
如图所示
04-02 1811
3、通过串口发送字符串closeled1，closeled2，closeled3，分别关闭板载led1，led2，led3。2、通过串口发送字符串openled1，openled2，openled3，分别打开板载led1，led2，led3。消息队列（queue）：可以在任务与任务间、中断和任务间传递消息，实现任务接收来自其他任务或中断的不固定的消息。调用此函数，会触发上下文切换（当前被中断的任务优先级低于解除阻塞的任务）调用此函数，会触发上下文切换（当前被中断的任务优先级低于解除阻塞的任务）
freeRTOS消息队列
嵌入式之斋
04-02 658
要使用消息队列，首先需要创建一个队列句柄，这可以使用xQueueCreate()函数完成。发送消息时，我们使用xQueueSend()函数，该函数接受三个参数：队列句柄，指向要发送数据的指针以及等待数据可用的时间（如果队列已满）。要从队列中收取消息，请使用xQueueReceive()函数，它也接受三个参数：队列句柄、指向接收数据的指针以及等待数据的时间（如果队列为空）。总之，FreeRTOS消息队列是一种非常有用的方式，用于在任务之间传递数据，而不需要使用全局变量或其他同步机制。
FreeRTOS--消息队列
m0_46579704的博客
12-02 2572
队列又称为消息队列，是一种用于任务间通信的数据结构，是一种异步通信方式，实现接收来自其他任务或者中断的不固定长度的消息，任务能够从队列中读取消息，当队列中消息是空的时，读取消息的任务被阻塞，用户可以指定阻塞任务的时间xTickToWait，当队列中有新消息，被阻塞的任务会被唤醒并处理消息。在中断服务程序或者任务中都可以给消息队列发送消息，如果队列未满，会将消息拷贝到消息队列的队尾，当发送紧急消息时，发送的位置时消息队列的对头而不是队尾，接受者就可以优先接收到紧急信息，从而即使进行消息处理。
NXP i.MX RT1052 FreeRTOS实战：消息队列
12-01
通过以上步骤，您可以在NXP i.MX RT1052上成功地实现FreeRTOS的消息队列功能，并充分利用其在实时系统中的优势。这个实战指南将帮助您理解和应用这些概念，为您的嵌入式项目带来高效和可靠的通信机制。
freeRTOS协程中的队列通信.zip_freeRTOS 例程_freertos_poetdxh
09-21
在提供的压缩包文件中，"RTOS"可能包含了FreeRTOS的源代码和配置文件，"Startup"可能是启动代码，"Project"可能是工程配置文件，而"Main"通常包含主函数和系统初始化，其中可能包含了示例中的队列通信代码。通过分析...
FreeRTOS入门手册-中文.zip
02-05
《FreeRTOS开发指南_V1.10.pdf》可能是对FreeRTOS API和实现机制的详细介绍，涵盖了如何配置任务、调度策略、内存管理以及各种同步机制的使用方法。这个文档通常会讲解如何初始化FreeRTOS系统，创建和删除任务，设置...
FreeRTOS中文实用教程.rar_FreeRTOS中文实用教程_freertos_hairp7x
09-25
“FreeRTOS中文实用教程”中的案例分析部分将详细讲解如何在实际项目中应用上述概念，从任务创建到系统优化，提供详尽的步骤和代码示例。 10. **FreeRTOS的优势** FreeRTOS因其小体积、高效能和灵活性而受到广泛...
FreeRTOS消息队列
weixin_63889667的博客
01-29 1144
FreeRTOS消息队列
FreeRTOS（消息队列）
qq_57594025的博客
08-11 2573
当有多个消息发送到消息队列时，通常是将先进入消息队列的消息先传给任务，也就是说，任务先得到的是最先进入消息队列的消息，即先进先出原则(FIFO)，FreeRTOS的队列也支持后进先出原则(LIFO)。3. 消息队列还有两个函数 xQueueSendToBackFromISR 和 xQueueSendToFrontFromISR，函数xQueueSendToBackFromISR 实现的是 FIFO 方式的存取，函数 xQueueSendToFrontFromISR 实现的是 LIFO 方式的读写。
freertos消息队列应用实例
03-11
可以回答这个问题。FreeRTOS 消息队列可以用于任务之间的通信和同步，例如一个任务向另一个任务发送数据或者信号。下面是一个简单的示例： 1. 创建消息队列 xQueueHandle queue = xQueueCreate(10, sizeof(int)); 2. 发送消息 int data = 123; xQueueSend(queue, &data, portMAX_DELAY); 3. 接收消息 int receivedData; xQueueReceive(queue, &receivedData, portMAX_DELAY); 这个示例创建了一个大小为 10 的消息队列，然后向队列发送了一个整数数据 123，最后从队列中接收了这个数据。注意，发送和接收操作都是阻塞的，直到队列中有数据可用或者空间可用。 当然，实际应用中还需要考虑一些细节，例如消息队列的优先级、超时等等。但是这个示例可以帮助理解 FreeRTOS 消息队列的基本用法。
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值