STM32与Freertos入门（六）队列

最新推荐文章于 2024-04-03 14:52:40 发布
最新推荐文章于 2024-04-03 14:52:40 发布
阅读量717 收藏 4
点赞数
文章标签： stm32 嵌入式硬件 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44597885/article/details/135031322
版权

1、队列介绍

队列是FreeRTOS提供的一种重要的通信机制，用于在任务之间传递数据。

FreeRTOS队列是一种先进先出（FIFO）的数据结构，用于在任务之间传递消息或数据项。它允许一个任务将数据项发送到队列，而另一个任务则可以从队列中接收这些数据项。

以下是FreeRTOS队列的一些重要特点和用法：

  1. 队列创建：可以使用FreeRTOS提供的API函数创建队列。在创建队列时，需要指定队列的最大长度和每个数据项的大小。

  2. 发送数据：任务可以使用xQueueSend()函数将数据项发送到队列中。如果队列已满，发送操作将被阻塞，直到有空间可用。

  3. 接收数据：任务可以使用xQueueReceive()函数从队列中接收数据项。如果队列为空，接收操作将被阻塞，直到有数据可用。

  4. 队列优先级：FreeRTOS队列还支持优先级功能。可以为队列设置优先级，使得在同时有多个任务等待发送或接收数据时，根据优先级决定哪个任务先进行操作。

  5. 队列长度：通过查询队列的长度，可以了解当前队列中待处理的数据项数量。这对于任务调度和资源管理非常有用。

使用FreeRTOS队列时，需要注意以下几点：

  • 需要合理设置队列的长度，确保不会超过任务处理能力。
  • 当队列满或空时，任务可能会被阻塞，因此要小心处理该种情况以避免死锁。
  • 在多任务环境下，要注意同步和竞争条件，以确保数据的正确性和一致性。

总的来说，FreeRTOS队列提供了一种方便和高效的任务间通信机制，可以在嵌入式系统中实现数据传递和同步。它是FreeRTOS强大功能的一部分，帮助开发人员编写可靠的实时应用程序。

2、队列测试

2.1 任务创建

2.2 队列建立

3、队列API

 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、KEIL 5代码设计

4.1 写队列函数

void StartTask_send(void const * argument)
{
  /* USER CODE BEGIN StartTask_send */
	uint16_t buf = 100;
	BaseType_t status;
  /* Infinite loop */
  for(;;)
  {
		if(key==0){ 
			osDelay(20);
			if(key==0){
				printf("key按下\r\n");
				status=xQueueSend(myQueueHandle,&buf,0);
				if(status == pdTRUE){
					printf("写入队列成功，写入值%d\r\n",buf);
				}
				else{
					printf("写入失败\r\n");
				}
			}	
			while(key==0);
		}
		osDelay(10);
  }
  /* USER CODE END StartTask_send */
}

4.2 读队列函数

void StartTask_receive(void const * argument)
{
  /* USER CODE BEGIN StartTask_receive */
	uint16_t buf;
	BaseType_t status;
  /* Infinite loop */
  for(;;)
  {
    if(key2==0){ 
			osDelay(20);
			if(key2==0){
				printf("key2按下\r\n");
				status=xQueueReceive(myQueueHandle,&buf,0);
				if(status == pdTRUE){
					printf("读取队列成功，读出值%d\r\n",buf);
				}
				else{
					printf("读取失败\r\n");
				}
			}	
			while(key2==0);
		}
		osDelay(10);
  }
  /* USER CODE END StartTask_receive */
}

freertos.c代码如下：

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * File Name          : freertos.c
  * Description        : Code for freertos applications
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2023 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 */

/* 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 Task_sendHandle;
osThreadId Task_receiveHandle;
osMessageQId myQueueHandle;

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

/* USER CODE END FunctionPrototypes */

void StartTask_send(void const * argument);
void StartTask_receive(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 Task_send */
  osThreadDef(Task_send, StartTask_send, osPriorityNormal, 0, 128);
  Task_sendHandle = osThreadCreate(osThread(Task_send), NULL);

  /* definition and creation of Task_receive */
  osThreadDef(Task_receive, StartTask_receive, osPriorityBelowNormal, 0, 128);
  Task_receiveHandle = osThreadCreate(osThread(Task_receive), NULL);

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

}

/* USER CODE BEGIN Header_StartTask_send */
/**
  * @brief  Function implementing the Task_send thread.
  * @param  argument: Not used
  * @retval None
  */
/* USER CODE END Header_StartTask_send */
void StartTask_send(void const * argument)
{
  /* USER CODE BEGIN StartTask_send */
	uint16_t buf = 100;
	BaseType_t status;
  /* Infinite loop */
  for(;;)
  {
		if(key==0){ 
			osDelay(20);
			if(key==0){
				printf("key按下\r\n");
				status=xQueueSend(myQueueHandle,&buf,0);
				if(status == pdTRUE){
					printf("写入队列成功，写入值%d\r\n",buf);
				}
				else{
					printf("写入失败\r\n");
				}
			}	
			while(key==0);
		}
		osDelay(10);
  }
  /* USER CODE END StartTask_send */
}

/* USER CODE BEGIN Header_StartTask_receive */
/**
* @brief Function implementing the Task_receive thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartTask_receive */
void StartTask_receive(void const * argument)
{
  /* USER CODE BEGIN StartTask_receive */
	uint16_t buf;
	BaseType_t status;
  /* Infinite loop */
  for(;;)
  {
    if(key2==0){ 
			osDelay(20);
			if(key2==0){
				printf("key2按下\r\n");
				status=xQueueReceive(myQueueHandle,&buf,0);
				if(status == pdTRUE){
					printf("读取队列成功，读出值%d\r\n",buf);
				}
				else{
					printf("读取失败\r\n");
				}
			}	
			while(key2==0);
		}
		osDelay(10);
  }
  /* USER CODE END StartTask_receive */
}
/* Private application code --------------------------------------------------*/
/* USER CODE BEGIN Application */

/* USER CODE END Application */

啥也不会的小白研究生
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
stm32——freeRTOS队列
2302_76515999的博客
05-11 224
队列又称消息队列，是一种常用于任务间通信的数据结构，队列可以在任务与任务间、中断和任务间传递消息。为什么不使用全局变量？如果使用全局变量，兔子（任务1）修改了变量a，等待树獭（任务3）处理，但树獭处理速度很慢，在处理数据的过程中，狐狸（任务2）有可能又修改了变量a，导致树獭有可能得到的不是正确的数据。在这种情况下，就可以使用队列。兔子和狐狸产生的数据放在流水线上，树獭可以慢慢一个个依次处理。关于队列的几个名词：队列项目：队列中的每一个数据；
STM32搭载RTOS实现任务+消息队列+串口通信完整项目代码
07-25
本项目在cortex-m3 STM32奋斗开发板V5上成功运行.平台:KEIL4 搭载FreeRTOS系统，任务一向消息队列填充数字，任务二从消息队列提取数据并发送到串口1，同时有LED灯跟随数据传送亮灭。 这里我们的课程设计内容。 对于STM32和FreeRTOS初学者以及想了解RTOS的任务机制与消息队列的好例程。
基于STM32的FreeRTOS串口队列通信
03-23
最简单的任务和中断之间的数据传输：队列 将程序修改为通过队列传送数据 串口中断服务程序中，将读取到的数据发送到队列中 在OnCommunicationTask()中，将接收到的数据通过串口发送出来
STM32 FreeRTOS系列教程（五）FreeRTOS队列
输出每日所学，供大家学习使用
09-16 1820
队列又称消息队列，是一种常用于任务间通信的数据结构，队列可以在任务与任务间、 中断和任务间传递信息，实现了任务接收来自其他任务或中断的不固定长度的消息，任务 能够从队列里面读取消息，当队列中的消息是空时，读取消息的任务将被阻塞，用户还可 以指定阻塞的任务时间xTicksToWait，在这段时间中，如果队列为空，该任务将保持阻塞 状态以等待队列数据有效。当队列中有新消息时，被阻塞的任务会被唤醒并处理新消息； 当等待的时间超过了指定的阻塞时间，即使队列中尚无有效数据，任务也会自动从阻塞态 转为就绪态。消息队列是
RTX RTOS 操作实例分析之---线程（thread）
最新发布
Andy的博客
04-03 530
thread分析
FreeRTOS队列【STM32F1】
qq_41861216的博客
05-29 175
函数xQueueCreate是动态创建队列的方式，xQueueCreateStatic则是静态创建队列。其中参数表队列长度，uxItemSize指队列项目的大小。如果队列创建失败会返回NULL，创建成功则返回其他值（队列的起始地址）。函数 xQueueCreate()实际上是调用了函数 xQueueGenericCreate()。其中指队列存储区域起始地址，指静态队列结构体，创建成功返回非NULL。
STM32FreeRTOS消息队列（STM32Cube高效开发）
qq_37281984的博客
03-05 2036
使用STM32cube配置FreeRTOS，实现队列函数的介绍和示例的编写
【FreeRTOS】9.STM32移植-队列
qq_44078824的博客
08-23 296
定义： 队列是任务与任务、中断与任务直接通信二准备的。队列用于消息传递，又叫做消息队列。需要交流的数据保存在队列中，叫做队列项目。队列所能保存的队列项数量叫队列长度。 typedef struct QueueDefinition { int8_t *pcHead; //头 int8_t *pcTail; //尾 int8_t *pcWriteTo; //下一个空闲区域 union //联合体 { int8_t *pcReadFrom; //当用作队列指向
STM32F429 FreeRTOS开发手册V1_stm32f429freertos_freertos入门_freertos_源
09-11
FreeRTOS入门部分可能会涵盖如何设置开发环境，比如使用Keil uVision或GCC编译器，以及如何配置工程以支持FreeRTOS。此外，手册可能还会介绍FreeRTOS内核的初始化，包括任务创建、调度策略、优先级设置等基础知识。...
STM32CubeMX FreeRTOS学习[4]-消息队列
12-03
前提：默认已经装好 MDK V5 和 STM32CubeMX，并安装了 STM32F1xx 系列的支持包。 硬件平台：STM32F1xx 系列。 目的：学习消息队列的使用。
STM32+FreeRTOS消息队列源码
05-24
本实例是基于STM32系列单片机+FreeRTOS系统实现消息队列的串口通信，了解消息队列的实现过程！
stm32f103+FreeRTOS+模板
02-23
stm32f103 FreeRTOS的模板，可以根据自己的项目添加任务。 FreeRTOS是当下热门的操作系统之一，并且开源免费，相较于ucos这个系统来说代码量比较小，能够移植到大部分微处理器上，特别适合新入门的学习。 FreeRTOS是...
STM32F103C8T6 FreeRTOS
11-15
STM32F103C8T6是意法半导体（STMicroelectronics）生产的一款基于ARM Cortex-M3内核的微控制器，属于STM32系列的入门级产品。这款芯片具有丰富的外设接口和高性能计算能力，常用于嵌入式系统开发。FreeRTOS是一款轻...
freertos_stm32.rar
08-12
FreeRTOS是一种轻量级的实时操作系统（RTOS），它被广泛应用于微控制器，特别是像STM32这样的嵌入式系统中。STM32是由意法半导体（STMicroelectronics）生产的基于ARM Cortex-M内核的微控制器系列，具有高性能、低...
stm32 freeRTOS 消息队列实验 （HAL版本）
Miseñor博客
08-18 2067
消息队列实验是在 FreeRTOS 中创建了两个任务，一个是发送消息任务，一个是获取消息任务，两个任务独立运行，发送消息任务是通过检测按键的按下情况来发送消息，假如发送消息不成功，就把返回的错误情代码在串口打印出来，另一个任务是获取消息任务，在消息队列没有消息之前一直等待消息，一旦获取到消息就把消息打印在串口调试助手里。
STM32移植FreeRTOS系列十七：队列
qq_51519091的博客
07-18 703
链接：https://pan.baidu.com/s/1is1OMw4j2lWD_VSJ9YqQAw?pwd=rtos 提取码：rtos
STM32通过STM32cueMX生成FreeRTOS操作队列消息
sea1216的博客
03-12 3608
一、目的 掌握基础的消息队列操作。 先定义一个队列，两个任务，一个任务根据GPIO值向消息队列发数据，另一个任务一直等待消息队列里的数据，有数据了就输出，没有则一直等待。 二、配置 在STM32cueMX中的FreeRTOS界面tasks and queues中，添加两个任务，一个用于检测按键是否按下，并消息入队，一个用于接收队列消息并输出信息，另外添加一个queue，设置为数量为1，数据大小为uint8_t。 三、主要程序 注意：在STM32cueMX生成的FreeRT...
【实战】STM32 FreeRTOS移植系列教程5：FreeRTOS消息队列
华清远见IT实验室专栏
08-26 755
写在前面： 本文章为《STM32MP157资源扩展板驱动移植篇》系列中的一篇，笔者使用的开发平台为华清远见FS-MP1A开发板（STM32MP157开发板）。资源扩展板是FS-MP1A开发板的扩展模块，主要包含了10余种主流传感器、执行器件、总线控制器件，非常方便项目扩展用。可拓展开发智慧家庭、智能医疗、智能安防、工业控制、图像识别、环境检测等方向的10个左右综合项目，华清远见开发板也将配套提供所有项目的说明文档、实验源码、应用程序等资料。 针对FS-MP1A开发板，除了资源扩展板驱动移植篇外，还包
stm32 hal freertos 串口消息队列
07-14
### 回答1： STM32是一款32位嵌入式微控制器系列，其中HAL（硬件抽象层）是一个软件库，用于与STM32微控制器的硬件进行高级的交互操作。FreeRTOS（实时操作系统）是一个开源的实时操作系统内核，用于实现多任务处理和任务调度。串口消息队列是HAL和FreeRTOS的结合应用，用于实现串口通信过程中的消息传递和任务调度。 在STM32中，通过HAL库中的串口接口可以实现与其他设备的串口通信。而使用FreeRTOS的串口消息队列，可以将串口接收到的消息经过处理后，以队列形式存储，等待任务调度进行处理。该消息队列可以是有大小限制的，根据实际需求进行设置。 当串口收到消息时，HAL库会触发中断，将接收到的数据存储到缓冲区中。然后，通过FreeRTOS的任务和队列机制，将数据从缓冲区移动到消息队列中。任务可以从消息队列中获取消息，并进行处理，例如解析数据、执行相应的操作等。 在使用STM32 HAL与FreeRTOS的串口消息队列时，需要注意以下几点： 1. 配置串口参数：使用HAL库的API函数配置串口的通信参数，如波特率、数据位、停止位等。 2. 创建任务：使用FreeRTOS的任务创建函数创建串口任务，指定任务优先级和任务堆栈大小。 3. 创建消息队列：使用FreeRTOS的消息队列创建函数创建串口消息队列，指定消息队列的长度和消息大小。 4. 中断处理：在串口中断中，通过HAL库提供的函数将接收到的数据存储到缓冲区中。 5. 任务调度：使用FreeRTOS的任务调度机制，从缓冲区中将数据移动到消息队列中，并让任务从消息队列中获取消息进行处理。 6. 数据处理：任务从消息队列中获取消息后，根据消息进行相应的数据处理和操作。 通过STM32 HAL与FreeRTOS的串口消息队列，可以实现高效的串口通信和任务调度。这样可以将不同的串口任务分配给不同的任务进行处理，提高系统的实时性和并行处理能力。同时，通过消息队列机制，可以避免数据的丢失和冲突，提高系统的稳定性和可靠性。 ### 回答2： stm32是一款基于ARM Cortex-M处理器的微控制器系列，具有强大的性能和丰富的外设功能。HAL (Hardware Abstraction Layer)是一种抽象硬件层，提供了简化外设驱动程序编写的API接口。FreeRTOS是一款开源的实时操作系统，能够提供任务调度和同步机制。 在使用stm32 hal freertos时，可以通过串口消息队列来实现任务间的通信。消息队列是一种先进先出的数据结构，用于在任务之间传递数据。 首先，需要初始化一个消息队列，通过调用FreeRTOS提供的API函数来创建。可以指定队列的大小和每个消息的大小。 然后，可以在发送任务中使用hal库提供的串口发送函数，将需要传递的消息发送给消息队列。发送任务可以使用FreeRTOS提供的队列发送函数来向消息队列发送消息。 接收任务可以使用hal库提供的串口接收函数，然后调用FreeRTOS提供的队列接收函数来从消息队列中接收消息。 通过消息队列，发送任务可以将消息放入队列，接收任务可以从队列中获取消息。这样就实现了任务间的通信。 需要注意的是，由于消息队列是有限大小的，当队列已满时，发送任务可能会被阻塞。类似地，当队列为空时，接收任务可能会被阻塞。因此，在使用串口消息队列时，需要合理地设计队列的大小，以免造成问题。 总之，通过使用stm32 hal freertos和串口消息队列，可以方便地实现任务间的通信，实现数据的传递和处理。这对于复杂的嵌入式系统开发是非常有用的。 ### 回答3： stm32是一种微控制器品牌，HAL（Hardware Abstraction Layer）是一种硬件抽象层，FreeRTOS是一款开源的实时操作系统。 在使用stm32微控制器时，我们可以使用HAL库来简化与硬件的交互。针对串口通信，HAL库提供了一系列的函数，使我们可以方便地通过串口与其他设备进行数据传输。 而FreeRTOS则可以帮助我们实现任务调度和管理。在使用串口进行数据传输时，我们可以利用FreeRTOS提供的消息队列特性来实现线程间的高效通信。 消息队列是一种用来在不同任务之间传递数据的机制。当一个任务需要发送数据时，它可以将数据封装成一个消息并将其发送到消息队列中。其他任务可以从消息队列中接收消息，并根据接收到的消息做出相应的处理。 使用HAL库和FreeRTOS时，我们可以通过以下步骤来实现串口消息队列： 1. 初始化串口：使用HAL库中的函数初始化串口，设置好串口的参数和通信速率。 2. 创建消息队列：使用FreeRTOS中的函数创建一个消息队列，设置好队列的长度和消息的大小。 3. 发送消息：在需要发送数据的任务中，使用FreeRTOS提供的函数将数据封装成消息，并将消息发送到消息队列中。 4. 接收消息：在需要接收数据的任务中，使用FreeRTOS提供的函数从消息队列中接收消息，并根据接收到的消息进行处理。 通过以上步骤，我们可以实现多个任务之间的串口通信，并且保证数据的安全传输和高效处理。 总结起来，使用stm32的HAL库和FreeRTOS的消息队列特性，可以方便地实现串口通信，并且保证多任务间的高效通信。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值