FreeRtos消息队列

FreeRTOS消息队列详解

最新推荐文章于 2025-05-07 22:27:55 发布

原创最新推荐文章于 2025-05-07 22:27:55 发布 · 1k 阅读

29 ·

CC 4.0 BY-SA版权

文章标签：

#单片机 #嵌入式硬件

FreeRtos 专栏收录该内容

8 篇文章

订阅专栏

一.消息队列简介

队列又称消息队列，是一种常用于任务间的通信数据结构，队列可以在任务与任务间，中断和任务间传递信息，实现任务接收来自其它任务或中断的不固定长度的消息。

二.消息队列数据存储

通常队列采用先进先出（FIFO）的存储缓冲机制，也就是往队列发送数据的时候(也叫入队)永远都是发送到队列的尾部，而从队列提取数据的时候(也叫出队)是从队列的头部提取的，也可使用LIFO的存储缓冲（后进先出）。数据发送到队列中会导致数据拷贝，也就是将要发送的数据拷贝到队列中，这就意味着在队列中存储的是数据的原始值，而不是原数据的引用（即只传递数据的指针，这个也叫做值传递）。FreeRTOS采用值传递的方法，这虽然会导致数据拷贝，会浪费一点时间，但是一旦将消息发送到队列中原始的数据缓冲区就可以删除掉或者覆写，这样的话这些缓冲区就可以被重复的使用。

三.出队阻塞

当任务尝试从一个队列中读取消息的时候可以指定一个阻塞时间，这个阻塞时间就是任务以队列中读取消息无效的时候任务阻塞的时间。例如任务A用于处理从串口中接收的数据，串口接收到数据之后会将数据放置队列Q中，任务A从Q中获取数据。但是如果Q队列此时为空时，任务A无法获取到数据，这时任务A有三个选择：1.直接跑路。2.等一会看看数据到了没，没到就走。3.一直等等队列Q中有数据为止。选哪一个就是由这个阻塞时间决定的，这个阻塞时间单位是时钟节拍数。阻塞时间为 0 的话就是不阻塞，没有数据的话就马上返回任务继续执行接下来的代码，对应第一种选择。如果阻塞时间为 0~ portMAX_DELAY，当任务没有从队列中获取到消息的话就进入阻塞态，阻塞时间指定了任务进入阻塞态的时间，当阻塞时间到了以后还没有接收到数据的话就退出阻塞态，返回任务接着运行下面的代码，如果在阻塞时间内接收到了数据就立即返回，执行任务中下面的代码，这种情况对应第二种选择。当阻塞时间设置为 portMAX_DELAY 的话，任务就会一直进入阻塞态等待，直到接收到数据为止！这个就是第三种选择。

四.入队阻塞

入队指的是向队列发送消息，将消息加入到队列中和出队阻塞是一样的，当一个任务向队列发送消息时也可以设置阻塞时间。若此时队列Q是满的，那对应上面三种情况，等待队列的空位来发送消息。

五.队列操作图示

1.创建队列

2.向队列发送消息

3.发送第二个消息

4.读取消息

六.常用函数

1.消息队列创建函数 xQueueCreate()

动态创建方法：使用xQueueCreate创建队列时，使用的是动态内存分配，在使用之前需将FreeRtosConfig.h中把configSUPPORT_DYNAMIC_ALLOCATION 定义为 1 来使能，这个是动态分配内存的宏定义，一般情况下我们都是用动态分配的方法而不是静态内存分配。在 FreeRTOS 中，凡是创建任务，队列，信号量和互斥量等内核对象都需要使用动态内存分配。

创建消息队列实例：

void AppTaskCreate(void)
{
	taskENTER_CRITICAL();           //进入临界区
	    
	
	/* 创建Test_Queue */
	Test_Queue = xQueueCreate((UBaseType_t ) QUEUE_LEN,/* 消息队列的长度 */
                            (UBaseType_t ) QUEUE_SIZE);/* 消息的大小 */

    vTaskDelete(StartTask_Handler); //删除开始任务
    taskEXIT_CRITICAL();            //退出临界区
}

静态创建方法：使用xQueueCreateStatic之前需将FreeRtosConfig.h中的configSUPPORT_STATIC_ALLOCATION 定义为1使能才能使用静态创建队列的方法。

2.消息队列删除函数 xQueueDelete()

(如有任务正在使用消息队列时，等待消息时不应删除消息队列)

3.向消息队列发送消息函数xQueueSend

（该函数不能再中断函数中使用，改函数会引起阻塞，中断不允许阻塞）

队列发送消息函数（xQueueSend()）实例：

//发送任务函数
void send_task(void *pvParameters)
{
    BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为pdPASS */
	uint32_t send_data1 = 1;
	uint32_t send_data2 = 2;
	u8 key=0;
	
	while(1)
    {
		key=KEY_Scan(0);
		if(key==KEY_UP_PRESS)
		{
			printf("发送消息send_data1！\n");
			xReturn = xQueueSend( Test_Queue, /* 消息队列的句柄 */
								&send_data1,/* 发送的消息内容 */
								0 );        /* 等待时间 0 */
			if(pdPASS == xReturn)
				printf("消息send_data1发送成功!\n\n");
		}
		else if(key==KEY1_PRESS)
		{
			printf("发送消息send_data2！\n");
			xReturn = xQueueSend( Test_Queue, /* 消息队列的句柄 */
								&send_data2,/* 发送的消息内容 */
								0 );        /* 等待时间 0 */
			if(pdPASS == xReturn)
				printf("消息send_data2发送成功!\n\n");
		}
		vTaskDelay(20);
    }
}

4.向消息队列读取消息函数

从消息队列读取消息函数（xQueueReceive()）实例：

//接收任务函数
void receive_task(void *pvParameters)
{
    BaseType_t xReturn = pdTRUE;/* 定义一个创建信息返回值，默认为pdTRUE */
	uint32_t r_queue;	/* 定义一个接收消息的变量 */
	
	while(1)
    {
        xReturn = xQueueReceive( Test_Queue,    /* 消息队列的句柄 */
								&r_queue,      /* 发送的消息内容 */
								portMAX_DELAY); /* 等待时间 一直等 */
		if(pdTRUE == xReturn)
			printf("本次接收到的数据是%d\n\n",r_queue);
		else
			printf("数据接收出错,错误代码0x%lx\n",xReturn);
    }
}

七、消息队列使用注意事项

1. 使用 xQueueSend()、xQueueSendFromISR()、xQueueReceive()等这些函数之前应先创建需消息队列，并根据队列句柄进行操作。

2. 队列读取采用的是先进先出（FIFO）模式，会先读取先存储在队列中的数据。当然也 FreeRTOS 也支持后进先出（LIFO）模式，那么读取的时候就会读取到后进队列的数据。

3. 在获取队列中的消息时候，我们必须要定义一个存储读取数据的地方，并且该数据区域大小不小于消息大小，否则，很可能引发地址非法的错误。

4. 无论是发送或者是接收消息都是以拷贝的方式进行，如果消息过于庞大，可以将消息的地址作为消息进行发送、接收。

5. 队列是具有自己独立权限的内核对象，并不属于任何任务。所有任务都可以向同一队列写入和读出。一个队列由多任务或中断写入是经常的事，但由多个任务读出倒是用的比较少。

八.实验现象

#include "system.h"
#include "SysTick.h"
#include "led.h"
#include "usart.h"
#include "FreeRTOS.h"
#include "task.h"
#include "key.h"
#include "queue.h"


//任务优先级
#define START_TASK_PRIO		1
//任务堆栈大小	
#define START_STK_SIZE 		128  
//任务句柄
TaskHandle_t StartTask_Handler;
//任务函数
void start_task(void *pvParameters);

//任务优先级
#define LED1_TASK_PRIO		2
//任务堆栈大小	
#define LED1_STK_SIZE 		50  
//任务句柄
TaskHandle_t LED1Task_Handler;
//任务函数
void led1_task(void *pvParameters);

//任务优先级
#define RECEIVE_TASK_PRIO		3
//任务堆栈大小	
#define RECEIVE_STK_SIZE 		50  
//任务句柄
TaskHandle_t ReceiveTask_Handler;
//任务函数
void receive_task(void *pvParameters);

//任务优先级
#define SEND_TASK_PRIO		4
//任务堆栈大小	
#define SEND_STK_SIZE 		50  
//任务句柄
TaskHandle_t SendTask_Handler;
//任务函数
void send_task(void *pvParameters);


QueueHandle_t Test_Queue =NULL;

#define  QUEUE_LEN    4   /* 队列的长度，最大可包含多少个消息 */
#define  QUEUE_SIZE   4   /* 队列中每个消息大小（字节） */


/*******************************************************************************
* 函 数 名         : main
* 函数功能		   : 主函数
* 输    入         : 无
* 输    出         : 无
*******************************************************************************/
int main()
{
	SysTick_Init(72);
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4
	LED_Init();
	KEY_Init();
	USART1_Init(115200);
	printf("FreeRTOS消息队列实验\r\n");
	printf("按下KEY_UP或者KEY1发送队列消息\r\n");
	printf("Receive任务接收到消息在串口回显\r\n");
	//创建开始任务
    xTaskCreate((TaskFunction_t )start_task,            //任务函数
                (const char*    )"start_task",          //任务名称
                (uint16_t       )START_STK_SIZE,        //任务堆栈大小
                (void*          )NULL,                  //传递给任务函数的参数
                (UBaseType_t    )START_TASK_PRIO,       //任务优先级
                (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    vTaskStartScheduler();          //开启任务调度
}

//开始任务任务函数
void start_task(void *pvParameters)
{
    taskENTER_CRITICAL();           //进入临界区
     
	/* 创建Test_Queue */
	Test_Queue = xQueueCreate((UBaseType_t ) QUEUE_LEN,/* 消息队列的长度 */
                            (UBaseType_t ) QUEUE_SIZE);/* 消息的大小 */
	
    //创建LED1任务
    xTaskCreate((TaskFunction_t )led1_task,     
                (const char*    )"led1_task",   
                (uint16_t       )LED1_STK_SIZE, 
                (void*          )NULL,
                (UBaseType_t    )LED1_TASK_PRIO,
                (TaskHandle_t*  )&LED1Task_Handler); 
				
	//创建接收任务
    xTaskCreate((TaskFunction_t )receive_task,     
                (const char*    )"receive_task",   
                (uint16_t       )RECEIVE_STK_SIZE, 
                (void*          )NULL,
                (UBaseType_t    )RECEIVE_TASK_PRIO,
                (TaskHandle_t*  )&ReceiveTask_Handler);

	//创建发送任务
    xTaskCreate((TaskFunction_t )send_task,     
                (const char*    )"send_task",   
                (uint16_t       )SEND_STK_SIZE, 
                (void*          )NULL,
                (UBaseType_t    )SEND_TASK_PRIO,
                (TaskHandle_t*  )&SendTask_Handler);
				
    vTaskDelete(StartTask_Handler); //删除开始任务
    taskEXIT_CRITICAL();            //退出临界区
} 

//LED1任务函数
void led1_task(void *pvParameters)
{
    while(1)
    {
        LED1=0;
        vTaskDelay(200);
        LED1=1;
        vTaskDelay(800);
    }
}

//接收任务函数
void receive_task(void *pvParameters)
{
    BaseType_t xReturn = pdTRUE;/* 定义一个创建信息返回值，默认为pdTRUE */
	uint32_t r_queue;	/* 定义一个接收消息的变量 */
	
	while(1)
    {
        xReturn = xQueueReceive( Test_Queue,    /* 消息队列的句柄 */
								&r_queue,      /* 发送的消息内容 */
								portMAX_DELAY); /* 等待时间 一直等 */
		if(pdTRUE == xReturn)
			printf("本次接收到的数据是%d\n\n",r_queue);
		else
			printf("数据接收出错,错误代码0x%lx\n",xReturn);
    }
}

//发送任务函数
void send_task(void *pvParameters)
{
    BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为pdPASS */
	uint32_t send_data1 = 1;
	uint32_t send_data2 = 2;
	u8 key=0;
	
	while(1)
    {
		key=KEY_Scan(0);
		if(key==KEY_UP_PRESS)
		{
			printf("发送消息send_data1！\n");
			xReturn = xQueueSend( Test_Queue, /* 消息队列的句柄 */
								&send_data1,/* 发送的消息内容 */
								0 );        /* 等待时间 0 */
			if(pdPASS == xReturn)
				printf("消息send_data1发送成功!\n\n");
		}
		else if(key==KEY1_PRESS)
		{
			printf("发送消息send_data2！\n");
			xReturn = xQueueSend( Test_Queue, /* 消息队列的句柄 */
								&send_data2,/* 发送的消息内容 */
								0 );        /* 等待时间 0 */
			if(pdPASS == xReturn)
				printf("消息send_data2发送成功!\n\n");
		}
		vTaskDelay(20);
    }
}

实验现象：