FreeRTOS篇7：队列

news2024/11/23 19:49:08

一.什么是队列

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

为什么不使用全局变量？

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

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

关于队列的几个名词：

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

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

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

二.队列特点

1. 数据入队出队方式

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

2. 数据传递方式

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

3. 多任务访问

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

4. 出队、入队阻塞

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

0：直接返回不会等待；

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

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

三.队列相关 API 函数

1. 创建队列

参数：

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

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

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

2. 写队列

写队列总共有以下几个函数：

参数：

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

pvItemToQueue：待写入数据

xTicksToWait：阻塞超时时间

返回值：

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

3. 读队列

读队列总共有以下几个函数：

参数：

xQueue：待读取的队列

pvItemToQueue：数据读取缓冲区

xTicksToWait：阻塞超时时间

返回值：

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

四.实操

1.实验需求

创建一个队列，按下 KEY1 向队列发送数据，按下 KEY2 向队列读取数据。

2.cubeMX配置

创建2个任务

创建队列

3.代码实现

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

  /* 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, osPriorityIdle, 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 */
	uint16_t buf =100;
	BaseType_t status;
  /* 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,&buf,0);
				if(status==pdTRUE)
					printf("写入队列成功，写入值%d\r\n",buf);
				else
				printf("写入队列失败\r\n");
			}
			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 buf =100;
	  BaseType_t status;
  /* 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,&buf,0);
				if(status==pdTRUE)
					printf("读取队列成功，读出值%d\r\n",buf);
				else
				printf("读取队列失败\r\n");
			}
			while(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_1)==GPIO_PIN_RESET);
		}
    osDelay(1);
  }
  /* USER CODE END StartTaskReceive */
}

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

/* USER CODE END Application */

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2186161.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！