FreeRTOS学习——队列

一、什么是队列？

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

为什么不使用全局变量？

        如果使用全局变量，兔子（任务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 */