STM32F1+HAL库+FreeTOTS学习16——队列集

已于 2024-10-20 15:57:35 修改
阅读量872 收藏 10
点赞数 27
分类专栏： FreeRTOS入门 文章标签： stm32 学习 FreeRTOS 操作系统 单片机
于 2024-10-11 09:43:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67907028/article/details/142844198
版权

STM32F1+HAL库+FreeTOTS学习16——队列集

上期我们介绍了互斥信号量。这一期我们来学习队列集

1. 队列集

1.1 队列集引入

前面我们介绍了队列和各种信号量，他们的作用都是解决FreeRTOS中任务之间的消息传递和信号同步问题而产生的，在实际的应用场景中，会存在有队列和信号量同时使用的情况，那么就有可能存在同一个任务不仅需要接收队列的消息，同时也需要等待信号量的释放。

按照之前学习的内容，我们会这样做：

在这里插入图片描述
这样做会有一个弊端，就是要求队列的消息必须比信号量释放提前发生，否则会造成信号量被队列阻塞。再者，也可能导致任务因为队列的消息未到来或者信号量未释放而阻塞，不管怎么样，这样现象都是我们不希望发生的，该如何解决呢，这个时候我们就需要引入队列集这个概念。

1.2 队列集简介

在使用队列进行任务之间的“沟通交流”时，一个队列只允许任务间传递的消息为同一种数据类型，如果需要传递不同数据类型的时候，就可以使用队列集。

FreeRTOS中的队列集可以对多个队列（信号量本质上也是队列）进行“监听”，只要被监听的队列中有一个队列有有效的消息，那么队列集的读取人都可以读取到消息。

使用队列集的好处在于，队列集可以在一个人任务中同时读取多个队列的消息，无需遍历所有待读取的队列，以确定具体读取哪一个队列。

使用队列集功能，需要在 FreeRTOSConfig.h 文件中将配置项 configUSE_QUEUE_SETS 配置为 1，来启用队列集功能。

在这里插入图片描述

2. 相关API函数

队列集的使用过程：创建队列集>创建队列或信号量-> 往队列集中添加信号量或者队列 -> 往队列发生消息或释放信号量->获取队列集消息，下面我们围绕几个步骤介绍队列集的相关API函数
常用的队列集API函数如下表：

函数描述
xQueueCreateSet()创建队列集
xQueueAddToSet()队列添加到队列集中
xQueueRemoveFromSet()从队列集中移除队列
xQueueSelectFromSet()获取队列集中有有效消息的队列
xQueueSelectFromSetFromISR()在中断中获取队列集中有有效消息的队列

2. 1 xQueueCreateSet()

此函数用于创建队列集，该函数在 queue.c 文件中有定义，函数的原型如下所示：

/**
 * @brief       xQueueCreateSet：创建队列集
 * @param       uxEventQueueLength：队列集可容纳的队列数量
 * @retval      返回值为NULL，表示创建失败，其他值表示为创建队列集的句柄
 */
QueueSetHandle_t xQueueCreateSet(const UBaseType_t uxEventQueueLength);

2.2 xQueueAddToSet()

此函数用于往队列集中添加队列，要注意的时，队列在被添加到队列集之前，队列中不能有有效的消息，该函数在 queue.c 文件中有定义，函数的原型如下所示：

/**
 * @brief       xQueueAddToSet：往队列集中添加队列
 * @param       xQueueOrSemaphore：需要被添加的队列
 * @param       xQueueSet：被添加的队列集
 * @retval      返回值为pdPASS，表示添加成功，返回值为pdFALL，表示添加失败
 */
BaseType_t xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore,
								 QueueSetHandle_t xQueueSet);

2.3 xQueueRemoveFromSet()

此函数用于从队列集中移除队列，要注意的时，队列在被队列集移除之前，队列中不能有有效的消息，该函数在 queue.c 文件中有定义，函数的原型如下所示：

/**
 * @brief       xQueueRemoveFromSet：从队列集中移除队列
 * @param       xQueueOrSemaphore：需要被移除的队列
 * @param       xQueueSet：被移除的队列集
 * @retval      返回值为pdPASS，表示移除成功，返回值为pdFALL，表示移除失败
 */
BaseType_t xQueueRemoveFromSet(QueueSetMemberHandle_t xQueueOrSemaphore,
 									 QueueSetHandle_t xQueueSet);

2.4 xQueueSelectFromSet()

此函数用于在任务中获取队列集中有有效消息的队列，该函数在 queue.c 文件中有定义，函数的原型如下所示：

/**
 * @brief       xQueueSelectFromSet：从队列集中获取有效信息
 * @param       xQueueSet：获取有效消息的队列集
 * @param       xTicksToWait：阻塞超时时间
 * @retval      返回值为NULL，表示获取消息失败，返回值为其他值，表示获取到消息的队列
 */
QueueSetMemberHandle_t xQueueSelectFromSet( QueueSetHandle_t xQueueSet,
											 TickType_t const xTicksToWait);

2.4 xQueueSelectFromSetFromISR()

此函数用于在中断中获取队列集中有有效消息的队列，该函数在 queue.c 文件中有定义，函数的原型如下所示：

/**
 * @brief       xQueueSelectFromSetFromISR：在中断中获取队列集的有效消息
 * @param       xQueueSet ：获取有效消息的队列集
 * @retval      返回值为NULL，表示获取消息失败，返回值为其他值，表示获取到消息的队列
 */
QueueSetMemberHandle_t xQueueSelectFromSetFromISR( QueueSetHandle_t xQueueSet );

3. 操作实验

3.1. 实验内容

在STM32F103RCT6上运行FreeRTOS，通过按键控制，完成对应的队列集操作，具体要求如下：

  • 定义一个队列集，一个队列、一个信号量。
  • 定义任务1：每次按下按键0，向队列发生消息，按下按键1，释放信号量。
  • 定义任务2：读取队列集中的消息。
  • 每完成一个步骤，通过串口打印相关信息。

3.2 代码实现

  1. freertos_demo.c


#include "freertos_demo.h"
#include "main.h"
#include "queue.h" 		//需要包含队列和任务相关的头文件
#include "task.h"
#include "key.h"		//包含按键相关头文件

/*FreeRTOS*********************************************************************************************/

/******************************************************************************************************/
/*FreeRTOS配置*/



/* TASK1 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 
 */
#define TASK1_PRIO      1                  /* 任务优先级 */
#define TASK1_STK_SIZE  128                 /* 任务堆栈大小 */
TaskHandle_t            Task1Task_Handler;  /* 任务句柄 */
void task1(void *pvParameters);					/*任务函数*/

/* TASK2 任务 配置
 * 包括: 任务句柄 任务优先级 堆栈大小 
 */
#define TASK2_PRIO      2                  /* 任务优先级 */
#define TASK2_STK_SIZE  128                 /* 任务堆栈大小 */
TaskHandle_t            Task2Task_Handler;  /* 任务句柄 */
void task2(void *pvParameters);					/*任务函数*/

QueueHandle_t xQueueHandle_t;					/* 队列句柄 */
#define xQueueLenth 2							/* 队列长度 */
#define  xQueueType uint8_t						/* 队列元素类型 */
#define xQueueSize sizeof(xQueueType)			/* 队列元素大小 */

SemaphoreHandle_t SemaphoreCountHandle_t;		/* 数值信号量句柄 */
#define SemaphoreCountMaxCount 3				/* 数值信号量的最大值 */
#define SemaphoreCountInitCount 0 				/* 数值信号量的初始值 */

QueueSetHandle_t xQueueSetHandle_t;			/* 队列集句柄 */
/* 为确保事件不会丢失，uxEventQueueLength 必须设置为 添加到队列集中的所有队列长度的总和，其中二进制信号量和互斥锁的长度为 1， 而计数信号量的长度由其最大计数值确定。 */
#define xQueueSetLenth  ( xQueueLenth + SemaphoreCountMaxCount )				/* 队列集长度：可容纳的队列或信号量数量 */
 
/******************************************************************************************************/

/**
 * @brief       FreeRTOS例程入口函数
 * @param       无
 * @retval      无
 */
void freertos_demo(void)
{
	BaseType_t errMessage;
	taskENTER_CRITICAL();           /* 进入临界区，关闭中断，此时停止任务调度*/

	/* 创建队列集 */
	 xQueueSetHandle_t = xQueueCreateSet(xQueueSetLenth);
	if(xQueueSetHandle_t == NULL)
	{
		printf("队列集创建失败\r\n");
	}
	else
	{
		printf("队列集创建成功,长度为：%d\r\n",xQueueSetLenth);
	}
	
	/* 创建队列 */
	 xQueueHandle_t = xQueueCreate( xQueueLenth,xQueueSize );
	if(xQueueHandle_t == NULL)
	{
		printf("队列创建失败\r\n");
	}
	else
	{
		printf("队列创建成功,长度为：%d,队列元素大小为：%d\r\n",xQueueLenth,xQueueSize);
	}
	
	/* 创建数值信号量 */
	 SemaphoreCountHandle_t = xSemaphoreCreateCounting( SemaphoreCountMaxCount,SemaphoreCountInitCount);
	if(SemaphoreCountHandle_t == NULL)
	{
		printf("数值信号量创建失败\r\n");
	}
	else
	{
		printf("数值信号量创建成功,信号量最大值为：%d,初始值为：%d\r\n",SemaphoreCountMaxCount,SemaphoreCountInitCount);
	}
	
	/* 往队列集里面添加队列 */
	 errMessage = xQueueAddToSet( xQueueHandle_t,xQueueSetHandle_t );
	if(errMessage == pdPASS)
	{
		printf("往队列集添加队列成功\r\n");
	}
	else
	{
		printf("往队列集添加队列失败\r\n");
	}
	
	/* 往队列集里面添加数值信号量 */
	errMessage = xQueueAddToSet( SemaphoreCountHandle_t,xQueueSetHandle_t );
	if(errMessage == pdPASS)
	{
		printf("往队列集添加数值信号量成功\r\n");
	}
	else
	{
		printf("往队列集添加数值信号量失败\r\n");
	}
    /* 创建任务1 */
    xTaskCreate((TaskFunction_t )task1,
                (const char*    )"task1",
                (uint16_t       )TASK1_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )TASK1_PRIO,
                (TaskHandle_t*  )&Task1Task_Handler);
    /* 创建任务2 */
    xTaskCreate((TaskFunction_t )task2,
                (const char*    )"task2",
                (uint16_t       )TASK2_STK_SIZE,
                (void*          )NULL,
                (UBaseType_t    )TASK2_PRIO,
                (TaskHandle_t*  )&Task2Task_Handler);

    taskEXIT_CRITICAL();            /* 退出临界区，重新开启中断，开启任务调度 */
    vTaskStartScheduler();		//开启任务调度
}

/**
* @brief       task1:用于按键扫描，检测按键0按下时，释放计数型信号量（资源数+1）
 * @param       pvParameters : 传入参数(未用到)
 * @retval      无
 */
void task1(void *pvParameters)
{
    
    while(1)
    {
		Key_One_Scan(Key_Name_Key0,Key0_Up_Task,Key0_Down_Task);
		Key_One_Scan(Key_Name_Key1,Key1_Up_Task,Key1_Down_Task);
    }
}	
/**
* @brief       task2:每1s获取计数信号量（资源数-1），当获取成功后，打印信号量的计数值（资源数）
 * @param       pvParameters : 传入参数(未用到)
 * @retval      无
 */
void task2(void *pvParameters)	
{	
	QueueSetMemberHandle_t  activeMember;
	uint8_t buffer;
	
	while(1)
    {	
		activeMember = xQueueSelectFromSet(xQueueSetHandle_t,portMAX_DELAY);
		if(activeMember == xQueueHandle_t)
		{
			xQueueReceive(activeMember,&buffer,portMAX_DELAY);
			printf("来自队列接收到的消息为：%d\r\n",buffer);
		}
		if(activeMember == SemaphoreCountHandle_t)
		{
			xSemaphoreTake(activeMember,portMAX_DELAY);
			printf("获取到数值信号量\r\n");
		}

    }

}
  1. key.c
/* USER CODE BEGIN 2 */

#include "freertos_demo.h"
#include "key.h"
#include "usart.h"

extern  QueueHandle_t xQueueHandle_t;					/* 队列句柄 */
extern SemaphoreHandle_t SemaphoreCountHandle_t;		/* 数值信号量句柄 */
uint8_t key0Num  = 0x00;								/* 写入队列的数据 */

void Key0_Down_Task(void)
{
	BaseType_t  errMessage;
	
	/* 向队列发送消息 */
	errMessage = xQueueSend(xQueueHandle_t,&key0Num,1000);
	if(errMessage == pdTRUE)
	{
		printf("队列发送消息成功\r\n");
	}
	else
	{
		printf("队列发送消息失败\r\n");
	}
}
void Key0_Up_Task(void)
{
	
}
void Key1_Down_Task(void)
{
	BaseType_t  errMessage;
	
	/* 释放数值信号量 */
	errMessage = xSemaphoreGive(SemaphoreCountHandle_t);
	if(errMessage == pdTRUE)
	{
		printf("数值信号量释放成功\r\n");
	}
	else
	{
		printf("数值信号量释放失败\r\n");
	}
}
void Key1_Up_Task(void)
{
	
}
void Key2_Down_Task(void)
{

}
void Key2_Up_Task(void)
{

}
void WKUP_Down_Task(void)
{

}
void WWKUP_Up_Task(void)
{

}

void Key_One_Scan(uint8_t KeyName ,void(*OnKeyOneUp)(void), void(*OnKeyOneDown)(void))
{
   static uint8_t Key_Val[Key_Name_Max];    //按键值的存放位置
   static uint8_t Key_Flag[Key_Name_Max];   //KEY0~2为0时表示按下，为1表示松开，WKUP反之
    
   Key_Val[KeyName] = Key_Val[KeyName] <<1;  //每次扫描完，将上一次扫描的结果左移保存
   
    switch(KeyName)
    {
        case Key_Name_Key0:  Key_Val[KeyName] = Key_Val[KeyName] | (HAL_GPIO_ReadPin(KEY0_GPIO_Port, KEY0_Pin));    //读取Key0按键值
            break;
        case Key_Name_Key1:  Key_Val[KeyName] = Key_Val[KeyName] | (HAL_GPIO_ReadPin(KEY1_GPIO_Port, KEY1_Pin));   //读取Key1按键值
            break;
        case Key_Name_Key2:  Key_Val[KeyName] = Key_Val[KeyName] | (HAL_GPIO_ReadPin(KEY2_GPIO_Port, KEY2_Pin));   //读取Key2按键值
            break;
//        case Key_Name_WKUP:  Key_Val[KeyName] = Key_Val[KeyName] | (HAL_GPIO_ReadPin(WKUP_GPIO_Port, WKUP_Pin));   //读取WKUP按键值
//            break; 
        default:
            break;
    }
//    if(KeyName == Key_Name_WKUP)     //WKUP的电路图与其他按键不同，所以需要特殊处理
//    {
//        //WKUP特殊情况
//        //当按键标志为1(松开)是，判断是否按下，WKUP按下时为0xff
//        if(Key_Val[KeyName] == 0xff && Key_Flag[KeyName] == 1)
//        {
//            (*OnKeyOneDown)();
//           Key_Flag[KeyName] = 0;
//        }
//        //当按键标志位为0（按下），判断按键是否松开,WKUP松开时为0x00
//        if(Key_Val[KeyName] == 0x00 && Key_Flag[KeyName] == 0)
//        {
//            (*OnKeyOneUp)();
//           Key_Flag[KeyName] = 1;
//        } 
//    }
//    else                               //Key0~2按键逻辑判断
//    {
        //Key0~2常规判断
          //当按键标志为1(松开)是，判断是否按下
        if(Key_Val[KeyName] == 0x00 && Key_Flag[KeyName] == 1)
        {
            (*OnKeyOneDown)();
           Key_Flag[KeyName] = 0;
        }
        //当按键标志位为0（按下），判断按键是否松开
        if(Key_Val[KeyName] == 0xff && Key_Flag[KeyName] == 0)
        {
            (*OnKeyOneUp)();
           Key_Flag[KeyName] = 1;
        }  
    }
     
   
//}
/* USER CODE END 2 */

以上就是本期内容的核心代码，下面我们来看一下实验结果：

3.2 实验结果

在这里插入图片描述

以上就是本期的所有内容，创造不易，点个关注再走呗。

在这里插入图片描述

不想写代码的我
关注
专栏目录
STM32 HAL freertos零基础（三） 队列
weixin_44597885的博客
09-10 278
在裸机开发时候，一般都是设定一个全局变量来数据修改传递等，但是在Freertos系统中，如果设定全局变量，当任务1对全局变量a进行操作，可能此时任务2也在对变量a进行操作，会出现问题，此时就需要队列。队列可以用于在不同的任务之间或者任务和中断服务程序之间传递数据。
STM32 串口环形队列
02-21
环形缓冲区，适用于接收外部数据时用作缓冲 STM32 QUEUE_DATA_TYPE* cbWrite(QueueBuffer *cb); QUEUE_DATA_TYPE* cbRead(QueueBuffer *cb); void cbReadFinish(QueueBuffer *cb); void cbWriteFinish(QueueBuffer *cb); //void cbPrint(QueueBuffer *cb); QUEUE_DATA_TYPE* cbWriteUsing(QueueBuffer *cb) ; int cbIsFull(QueueBuffer *cb) ; int cbIsEmpty(QueueBuffer *cb) ;
stm32环形队列
06-17
stm32环形队列
STM32队列
weixin_49001476的博客
06-09 2367
队列又称消息队列，是一种常用于任务间通信的数据结构，队列可以在任务与任务间、中断和任务间传递信息。为什么不使用全局变量？如果使用全局变量，兔子（任务1）修改了变量a，等待树獭（任务3）处理，但树獭处理速度很慢，在处理数据的过程中，狐狸（任务2）有可能又修改了变量a，导致树獭有可能得到的不是正确的数据。在这种情况下，就可以使用队列。兔子和狐狸产生的数据放在流水线上，树獭可以慢慢一个个依次处理。关于队列的几个名词：
STM32串口环形队列
大超人的博客
08-19 911
通过实验加深理解串口环形队列
STM32F1 + FreeRTOS 最简HAL库工程
10-19
这个"STM32F1 + FreeRTOS 最简HAL库工程"是一个基础的开发模板，可以帮助开发者快速搭建基于STM32F1的、使用FreeRTOS的项目框架。以下是该工程可能包含的一些关键知识点： 1. **STM32F1系列特性**：了解STM32F1的...
GPIO和宏定义实现的IIC队列发送和队列接收程序(STM32F1HAL版本)
最新发布
10-11
GPIO和宏定义实现的IIC队列发送和队列接收程序的演示用例，硬件和开发库平台为STM32F103ZGT6 + HAL。
STM32 DMA串口不定长数据收发+FreeRTOS操作系统 参考代码
08-08
使用CubeMX封装的FreeRTOS操作...如果是从我的文章来的，可以直接看stm32f1xx_it.c文件，所有的DMA处理逻辑基本就写在这个文件里面啦~ 因为中文注释会在CubeMX每一次代码初始化的时候被搞乱，所以只能用英文注释了 qaq
stm32f107vct6+ucos-ii模板，基于Keil MDK
03-18
STM32F107VCT6是一款由意法半导体（STMicroelectronics）推出的高性能、低成本的微控制器，属于STM32系列中的F1产品线。该芯片基于ARM Cortex-M3处理器内核，具备丰富的外设接口和强大的计算能力，适用于工业控制、...
STM32F1XX代码工程：：触摸屏操作.zip_stm32f1xx_dsp__stm32f1xx工程_触摸屏
09-20
5. **HAL/LL库使用**：ST提供的HAL（Hardware Abstraction Layer）库或LL（Low-Layer）库可以简化STM32的外设操作，工程可能使用了这些库来配置ADC和GPIO。 6. **调试技巧**：项目可能包括了如何使用调试工具，如...
【FreeRTOS】9.STM32移植-队列
qq_44078824的博客
08-23 342
定义： 队列是任务与任务、中断与任务直接通信二准备的。队列用于消息传递，又叫做消息队列。需要交流的数据保存在队列中，叫做队列项目。队列所能保存的队列项数量叫队列长度。 typedef struct QueueDefinition { int8_t *pcHead; //头 int8_t *pcTail; //尾 int8_t *pcWriteTo; //下一个空闲区域 union //联合体 { int8_t *pcReadFrom; //当用作队列指向
STM32移植FreeRTOS系列十七：队列
qq_51519091的博客
07-18 1014
链接：https://pan.baidu.com/s/1is1OMw4j2lWD_VSJ9YqQAw?pwd=rtos 提取码：rtos
STM32开发 数据包环形队列
qq_36365231的博客
08-16 1578
C语言版环形队列实现、数据包队列
构建驱动模块6--STM32 缓冲队列
u011996698的博客
10-30 665
构建驱动模块6--STM32 缓冲队列      缓冲区常常用于临时保存数据，特别是在通讯过程中，先把数据接收下后，后期等待任务空闲在进行处理，这样避免接收数据中处理数据而造成数据丢失。缓冲队列里经常使用为环形缓冲队列，环形队列是一个头尾相接的队列，一般定义当入队操作为缓冲写操作，而出队则定义为缓冲读。当一个数据或者一组消息来到时，进行入队操作；当需要解析消息时才有出队操作。针对该思想编写一个最...
stm32 打造自己环形队列
hbwang的博客
01-12 1854
本环形队列实现以数组形式批量写入和读取队列中数据。 写入数据时，对于队列剩余空间不足时，可以选择强制覆盖写入（会有覆盖部分原队列数据，请根据自己实现需要操作）；不覆盖，则不会写入； 读取数据时，如果超过队列中已存数据长度，则读取实际大小；没有超过，则正常读取。 本环形队列可用作串口数据缓存接收，尤为适用于有具体协议格式数据，方便查找TAG标识进行定位。但对于串口采用DMA方式，接收大量无协议格式的数据，暂不适用。
STM32串口环形队列程序
04-15
该程序为大数据量吞吐的串口收发例程，中断接收，边收边发，采用大数据环形队列，处理过程超快不丢包，接收buffer可以定义成2K,4K,8K均可。也可以用到其余单片机上
【学习笔记 三】循环队列在stm32 USART应用
qq_31983073的博客
10-11 404
【代码】【学习笔记 三】循环队列在stm32 USART应用。
【STM32 FreeRTOS】队列和缓冲区
目标：MVP
08-14 595
队列是任务到任务、任务到中断、中断到任务数据交流的一种机制。队列可以容纳有限数量的固定大小的数据项。一个队列可以容纳的最大项目数称为它的长度。数据入队出队方式：队列通常用作先进先出（FIFO）缓冲区，其中数据被写入队列的末尾，并从队列的头部删除。FreeRTOS中也可以配置为“后进先出”的方式。数据传递方式：FreeRTOS中队列采用实际值传递，即将数据拷贝到队列中进行传递，FreeRTOS采用拷贝数据传递，也可以传递指针，所以在传递较大数据的时候采用指针传递。多任务访问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不想写代码的我

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值