FreeRTOS学习——队列

大佬救我

于 2024-01-09 18:40:46 发布

阅读量1k

点赞数 26

文章标签：学习

本文链接：https://blog.csdn.net/qq_47172243/article/details/135477580

版权

本文详细介绍了队列的基本概念、特点，如FIFO/LIFO数据结构、数据传递方式和多任务访问，并提供了FreeRTOS中创建队列、写入和读取队列的函数示例。通过实例展示了如何在嵌入式系统中使用队列来避免全局变量带来的问题。

摘要由CSDN通过智能技术生成

一、什么是队列？

队列又称消息队列，是一种常用于任务间通信的数据结构，队列可以在任务与任务间、中断和任务间传递信息。

为什么不使用全局变量？

如果使用全局变量，兔子（任务1）修改了变量 a ，等待树獭（任务3）处理，但树獭处理速度很慢，在处理数据的过程中，狐狸（任务2）有可能又修改了变量 a ，导致树獭有可能得到的不是正确的数据。

在这种情况下，就可以使用队列。兔子和狐狸产生的数据放在流水线上，树獭可以慢慢一个个依次处理。

关于队列的几个名词：

队列项目：队列中的每一个数据；

队列长度：队列能够存储队列项目的最大数量；

创建队列时，需要指定队列长度及队列项目大小。

二、队列的特点

1、数据入队方式

通常采用先进先出（FIFO）的数据存储缓冲机制，即先入队的数据会先从队列中被读取。也可以配置为后进先出（LIFO）方式，但用得比较少。

2. 数据传递方式

采用实际值传递，即将数据拷贝到队列中进行传递，也可以传递指针，在传递较大的数据的时候采用指针传递。

3. 多任务访问

队列不属于某个任务，任何任务和中断都可以向队列发送/读取消息。

4. 出队、入队阻塞

当任务向一个队列发送消息时，可以指定一个阻塞时间，假设此时当队列已满无法入队。

阻塞时间如果设置为：

0：直接返回不会等待；

0~port_MAX_DELAY：等待设定的阻塞时间，若在该时间内还无法入队，超时后直接返回不再等待；

port_MAX_DELAY：死等，一直等到可以入队为止。出队阻塞与入队阻塞类似；

三、队列相关函数

3.1、创建队列

QueueHandle_t xQueueCreate( UBaseType_t     uxQueueLength,
                            UBaseType_t     uxItemSize );

参数：

uxQueueLength：队列可同时容纳的最大项目数 。

uxItemSize：存储队列中的每个数据项所需的大小（以字节为单位，数据类型）。

返回值：

如果队列创建成功，则返回所创建队列的句柄 。如果创建队列所需的内存无法分配，则返回 NULL。

3.2、写队列

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

参数：

xQueue：队列的句柄，数据项将发送到此队列。

pvItemToQueue：待写入数据

xTicksToWait：阻塞超时时间

返回值：

如果成功写入数据，返回 pdTRUE，否则返回 errQUEUE_FULL。

3.3、读队列

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

参数：

xQueue：待读取的队列

pvItemToQueue：数据读取缓冲区

xTicksToWait：阻塞超时时间

返回值：

成功返回 pdTRUE，否则返回 pdFALSE。

四、实操

4.1、任务需求

创建一个队列（长度16，类型unsigned short int ），按下 KEY1 向队列发送一个数据（数据为：1~16），按下 KEY2 向队列读取一个数据。

4.2、代码实现

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * File Name          : freertos.c
  * Description        : Code for freertos applications
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2024 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */

/* Includes ------------------------------------------------------------------*/
#include "FreeRTOS.h"
#include "task.h"
#include "main.h"
#include "cmsis_os.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "stdio.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN Variables */

/* USER CODE END Variables */
osThreadId TaskSendHandle;				/*创建任务句柄和队列句柄*/
osThreadId TaskReceiveHandle;
osMessageQId myQueueHandle;

/* Private function prototypes -----------------------------------------------*/
/* USER CODE BEGIN FunctionPrototypes */

/* USER CODE END FunctionPrototypes */

void StartTaskSend(void const * argument);
void StartTaskReceive(void const * argument);

void MX_FREERTOS_Init(void); /* (MISRA C 2004 rule 8.1) */

/* GetIdleTaskMemory prototype (linked to static allocation support) */
void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize );

/* USER CODE BEGIN GET_IDLE_TASK_MEMORY */
static StaticTask_t xIdleTaskTCBBuffer;
static StackType_t xIdleStack[configMINIMAL_STACK_SIZE];

void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize )
{
  *ppxIdleTaskTCBBuffer = &xIdleTaskTCBBuffer;
  *ppxIdleTaskStackBuffer = &xIdleStack[0];
  *pulIdleTaskStackSize = configMINIMAL_STACK_SIZE;
  /* place for user code */
}
/* USER CODE END GET_IDLE_TASK_MEMORY */

/**
  * @brief  FreeRTOS initialization
  * @param  None
  * @retval None
  */
void MX_FREERTOS_Init(void) {
  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* USER CODE BEGIN RTOS_MUTEX */
  /* add mutexes, ... */
  /* USER CODE END RTOS_MUTEX */

  /* USER CODE BEGIN RTOS_SEMAPHORES */
  /* add semaphores, ... */
  /* USER CODE END RTOS_SEMAPHORES */

  /* USER CODE BEGIN RTOS_TIMERS */
  /* start timers, add new ones, ... */
  /* USER CODE END RTOS_TIMERS */

  /* Create the queue(s) */
  /* definition and creation of myQueue */
  osMessageQDef(myQueue, 16, uint16_t);		/*参数：队列名称，队列项目大小，队员每个项目的类型*/
  myQueueHandle = osMessageCreate(osMessageQ(myQueue), NULL);		/*创建队列，成功返回队列句柄，失败返回NULL*/

  /* USER CODE BEGIN RTOS_QUEUES */
  /* add queues, ... */
  /* USER CODE END RTOS_QUEUES */

  /* Create the thread(s) */
  /* definition and creation of TaskSend */
  osThreadDef(TaskSend, StartTaskSend, osPriorityNormal, 0, 128);
  TaskSendHandle = osThreadCreate(osThread(TaskSend), NULL);			/*创建任务*/

  /* definition and creation of TaskReceive */
  osThreadDef(TaskReceive, StartTaskReceive, osPriorityNormal, 0, 128);
  TaskReceiveHandle = osThreadCreate(osThread(TaskReceive), NULL);

  /* USER CODE BEGIN RTOS_THREADS */
  /* add threads, ... */
  /* USER CODE END RTOS_THREADS */

}

/* USER CODE BEGIN Header_StartTaskSend */
/**
  * @brief  Function implementing the TaskSend thread.
  * @param  argument: Not used
  * @retval None
  */
/* USER CODE END Header_StartTaskSend */
void StartTaskSend(void const * argument)
{
  /* USER CODE BEGIN StartTaskSend */
	static uint16_t queue_datas = 1;/*创建需要传入队列的数据*/
	BaseType_t status = 0;						/*承接写队列函数返回值*/
  /* Infinite loop */
  for(;;)
  {
		if(HAL_GPIO_ReadPin(GPIOA ,GPIO_PIN_0) == GPIO_PIN_RESET)
		{
			osDelay(20);			/*防抖*/
			if(HAL_GPIO_ReadPin(GPIOA ,GPIO_PIN_0) == GPIO_PIN_RESET)
			{
				
				status = xQueueSend(myQueueHandle ,&queue_datas ,0);					/*写对列，参数：队列句柄 ，数据 ，阻塞时间*/
				if(status == pdTRUE)
				{
					printf("写入队列成功，写入值：%d\r\n",queue_datas);
				}
				else
				{
					printf("队列满了（最大长度为16），无法写入队列！\r\n");
				}
				queue_datas += 1;				/*队列数据：1～16*/
				if(queue_datas == 17)		/*队列写入17后，又从1开始写*/
				{
					queue_datas = 1;
				}
			}
			while(HAL_GPIO_ReadPin(GPIOA ,GPIO_PIN_0) == GPIO_PIN_RESET);			/*防止按键按下被多次触发*/
		}
    osDelay(10);
  }
  /* USER CODE END StartTaskSend */
}

/* USER CODE BEGIN Header_StartTaskReceive */
/**
* @brief Function implementing the TaskReceive thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartTaskReceive */
void StartTaskReceive(void const * argument)
{
  /* USER CODE BEGIN StartTaskReceive */
	uint16_t queue_datas;						/*缓存队列接收的数据*/
	BaseType_t status = 0;						/*承接读队列函数返回直接*/
  /* Infinite loop */
  for(;;)
  {
		if(HAL_GPIO_ReadPin(GPIOA ,GPIO_PIN_1) == GPIO_PIN_RESET)
		{
			osDelay(20);			/*防抖*/
			if(HAL_GPIO_ReadPin(GPIOA ,GPIO_PIN_1) == GPIO_PIN_RESET)
			{
				status = xQueueReceive(myQueueHandle ,&queue_datas ,0);					/*读对列，参数：队列句柄 ，数据 ，阻塞时间*/
				if(status == pdTRUE)
				{
					printf("读取队列成功，读取值：%d\r\n",queue_datas);
				}
				else
				{
					printf("读取失败，队列中没有值\r\n");
				}
				
			}
			while(HAL_GPIO_ReadPin(GPIOA ,GPIO_PIN_1) == GPIO_PIN_RESET);			/*防止按键按下被多次触发*/
		}
    osDelay(10);
  }
  /* USER CODE END StartTaskReceive */
}

/* Private application code --------------------------------------------------*/
/* USER CODE BEGIN Application */

/* USER CODE END Application */

大佬救我

关注

26
点赞
踩
25

收藏

觉得还不错? 一键收藏
0
评论
FreeRTOS学习——队列

队列又称消息队列，是一种常用于，队列可以在任务与任务间、中断和任务间传递信息。为什么不使用全局变量？如果使用全局变量，兔子（任务1）修改了变量 a ，等待树獭（任务3）处理，但树獭处理速度很慢，在处理数据的过程中，狐狸（任务2）有可能又修改了变量 a ，导致树獭有可能得到的不是正确的数据。在这种情况下，就可以使用队列。兔子和狐狸产生的数据放在流水线上，树獭可以慢慢一个个依次处理。：队列中的每一个数据；：队列能够存储队列项目的最大数量；创建队列时需要指定队列长度及队列项目大小。
复制链接

扫一扫