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、写队列

FreeRTOS学习——队列_第1张图片

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 */

你可能感兴趣的:(学习)