FreeRTOS学习笔记——（4）同步与互斥之队列

已于 2022-05-25 20:53:01 修改
阅读量551 收藏 6
点赞数
分类专栏： FreeRTOS学习笔记 文章标签： 学习
于 2022-05-25 20:35:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_67090148/article/details/124940557
版权

系列文章目录

FreeRTOS学习笔记—— 系列文章目录

文章目录

同步与互斥

同步：就是：我（A）正在用会议室，你（B）等会再用。
互斥：就是：我（A）正在用会议室，你（B）不能进来用。
互斥可以使用同步来实现，你（B）等我（A）用完会议室，你（B）再用会议室。这就是使用同步来实现互斥。
在这个过程中，A、B是互斥地访问会议室，会议室被称之为临界资源。这里使用了同步机制实现了“临界资源”的“互斥访问”。
任务A、B都要使用串口来打印，串口就是临界资源。如果A、B同时使用串口，那么打印出来的信息就是A、B混杂，无法分辨。所以使用串口时，应该：A用完，B再用；B用完，A再用。

能实现同步、互斥的内核方法有：队列(queue)、信号量(semaphoe)、互斥量(mutex)、事件组(event group)、任务通知(task notification)。

队列

队列包含若干个数据：队列中有若干项，这被称为"长度"(length)，每个数据大小固定，创建队列时就要指定长度、数据大小。

一、队列函数

1、创建

队列的创建有两种方法：动态分配内存、静态分配内存

动态创建队列函数：xQueueCreate，在函数内部动态分配内存。函数说明如下：

/* 函数原型
 * 参数：uxQueueLength：队列长度，最多能存放多少个数据（item）
 * 参数：uxItemSize   ：每个数据（item）的大小，以字节为单位。
 * 返回值：非 0 ：创建成功，返回句柄，使用这个句柄操作这个队列。
 *		   NULL：创建失败,内存不足
 */
QueueHandle_t xQueueCreate( UBaseType_t uxQueueLength, UBaseType_t uxItemSize );

静态创建队列函数：xQueueCreateStatic，队列的内存事先分配好，函数说明如下：

/* 函数原型
 * 参数1：uxQueueLength：队列长度，最多能存放多少个数据（item）
 * 参数2：uxItemSize   ：每个数据（item）的大小，以字节为单位。
 * 参数3：pucQueueStorageBuffer：必须指向一个 uint8_t 数组，此数组大小至少为  uxQueueLength * uxItemSize
 * 参数4：pxQueueBuffer：必须定义一个StaticQueue_t结构体，用来保存队列的数据结构
 * 返回值：非 0 ：创建成功，返回句柄，使用这个句柄操作这个队列。
 *		   NULL：创建失败，pxQueueBuffer 为 NULL
 */
QueueHandle_t xQueueCreateStatic(
             UBaseType_t uxQueueLength,
             UBaseType_t uxItemSize,
             uint8_t *pucQueueStorageBuffer,
             StaticQueue_t *pxQueueBuffer
           );

2、复位

复位队列函数： xQueueReset，把队列恢复为初始状态

/* 参数：pxQueue : 复位队列的句柄
 * 返回值: pdPASS(必定成功)
 */
BaseType_t xQueueReset( QueueHandle_t pxQueue);

3、删除

删除队列函数： vQueueDelete，只能删除动态方法创建的队列，释放内存

/* 参数：xQueue : 要删除队列的句柄
 */
void vQueueDelete( QueueHandle_t xQueue );

4、写队列

可以把数据写到队列的头部，也可以写到尾部，写队列函数有两个版本：在任务中使用、在中断中使用（函数后缀为 ISR 的是在中断中使用）

/* 
 * 参数：xQueue        ：队列句柄，要写哪个队列
 * 
 * 参数：pvItemToQueue ：数据指针，这个数据的值会被复制进队列
 * 
 * 参数：xTicksToWait  ：如果队列满则无法写入新数据，可以让任务进入阻塞状态，xTicksToWait表示阻塞的最大时间(Tick Count)。
						如果被设为0，无法写入数据时函数会立刻返回；
						如果被设为portMAX_DELAY，则会一直阻塞直到有空间可写
						
 * 返回值：pdPASS       ：数据成功写入了队列
 *		  errQUEUE_FULL：写入失败，因为队列满了。
 */



/* 
* 往队列尾部写入数据，如果没有空间，阻塞时间为xTicksToWait
*/
BaseType_t xQueueSend( //等同于xQueueSendToBack
                QueueHandle_t   xQueue,
                const void    *pvItemToQueue,
                TickType_t    xTicksToWait
             );
/*
* 往队列尾部写入数据，如果没有空间，阻塞时间为xTicksToWait
*/
BaseType_t xQueueSendToBack(
                QueueHandle_t   xQueue,
                const void    *pvItemToQueue,
                TickType_t    xTicksToWait
             );
/*
* 往队列尾部写入数据，此函数可以在中断函数中使用，不可阻塞
*/
BaseType_t xQueueSendToBackFromISR(
                   QueueHandle_t xQueue,
                   const void *pvItemToQueue,
                   BaseType_t *pxHigherPriorityTaskWoken
                 );
/*
* 往队列头部写入数据，如果没有空间，阻塞时间为xTicksToWait
*/
BaseType_t xQueueSendToFront(
                QueueHandle_t   xQueue,
                const void    *pvItemToQueue,
                TickType_t    xTicksToWait
                );
/*
* 往队列头部写入数据，此函数可以在中断函数中使用，不可阻塞
*/
BaseType_t xQueueSendToFrontFromISR(
                   QueueHandle_t xQueue,
                   const void *pvItemToQueue,
                   BaseType_t *pxHigherPriorityTaskWoken
                   );

5、读队列

读到一个数据后，队列中该数据会被移除。读队列函数有两个版本：在任务中使用、在中断中使用

/* 
 * 参数：xQueue        ：队列句柄，要读哪个队列
 * 
 * 参数：pvBuffer      ：bufer指针，队列的数据会被复制到这个buffer
 * 
 * 参数：xTicksToWait  ：如果队列空则无法读出数据，可以让任务进入阻塞状态，xTicksToWait表示阻塞的最大时间(Tick Count)。
						如果被设为0，无法读出数据时函数会立刻返回；
						如果被设为portMAX_DELAY，则会一直阻塞直到有数据可读
						
 * 返回值：pdPASS        ：数据成功读出
 *		  errQUEUE_EMPTY：读取失败，因为队列空了。
 */

BaseType_t xQueueReceive( QueueHandle_t xQueue,
            			 void * const pvBuffer,
             			 TickType_t xTicksToWait 
                         );
BaseType_t xQueueReceiveFromISR(
                  QueueHandle_t   xQueue,
                  void       *pvBuffer,
                  BaseType_t    *pxTaskWoken
               );

6、查询

可以查询队列中有多少个数据、有多少空余的空间。

// 返回队列中可用数据的个数
UBaseType_t uxQueueMessagesWaiting( const QueueHandle_t xQueue );

// 返回队列中可用空间的个数
UBaseType_t uxQueueSpacesAvailable( const QueueHandle_t xQueue );

7、覆盖、偷看

覆盖：当队列长度为1时，可以使用 xQueueOverwrite() 或 xQueueOverwriteFromISR() 来覆盖数据。队列长度必须为1。

/* 覆盖队列
* xQueue: 写队列
* pvItemToQueue: 数据地址
* 返回值: pdTRUE表示成功, pdFALSE表示失败
*/
BaseType_t xQueueOverwrite(
             QueueHandle_t xQueue,
             const void * pvItemToQueue
          );
BaseType_t xQueueOverwriteFromISR(
             QueueHandle_t xQueue,
             const void * pvItemToQueue,
             BaseType_t *pxHigherPriorityTaskWoken
          );

偷看：队列中的数据供多方读取，也就是读取队列中的数据但不移除队列中的数据。从队列中复制出数据，但不移除，如果队列中没有数据，那么偷看时会导致阻塞；一旦队列中有数据，以后每次偷看都会成功。

/* 偷看队列
* xQueue: 偷看的队列
* pvItemToQueue: 数据地址, 用来保存复制出来的数据
* xTicksToWait: 如果没有数据，阻塞一会
* 返回值: pdTRUE表示成功, pdFALSE表示失败
*/
BaseType_t xQueuePeek(
             QueueHandle_t xQueue,
             void * const pvBuffer,
             TickType_t xTicksToWait
          );
BaseType_t xQueuePeekFromISR(
                QueueHandle_t xQueue,
                void *pvBuffer,
              );

二、队列的应用

1、串口发送字符串

  1. 创建队列：长度为 1 ，传输 char * 指针
  2. 发送任务的优先级为 1 ，将字符串写入 参数，将参数的地址写入队列。
  3. 接收任务的优先级为 2 ，读队列得到 char * 的值，通过串口打印

在main函数中创建了队列、创建了发送任务、接收任务


QueueHandle_t xQueue;   //队列句柄

int main( void )
{
		
	prvSetupHardware();
	
	xQueue = xQueueCreate(1, sizeof( char * ));  // 创建队列: 长度为1，数据大小为4字节(存放一个char指针)
	if(xQueue == NULL)
	{
		printf("can not create queue\r\n");
	}
	
	printf( "Runing.\r\n" );
	/* 创建2个任务用于写队列
	*  优先级为1
	*/
	xTaskCreate(vSenderTask, "Sender1", 100, "Task1 is Runing!\r\n", 1, NULL); 
	xTaskCreate(vSenderTask, "Sender2", 100, "Task2 is Runing!\r\n", 1, NULL);
	
	/* 创建1个任务用于读队列
	*  优先级为2，高于写队列的任务，队列里一有数据就被读走
	*/
	xTaskCreate(vReceiverTask, "Recevier", 100, NULL, 2, NULL);

	/* 启动调度器. */
	vTaskStartScheduler();

	/* Will only get here if there was not enough heap space to create the
	idle task. */
	return 0;
}

写队列函数：将字符串地址写入队列

static void vSenderTask(void * param)
{
	char * ValToSend; //接收到的字符存入 ValToSend
	BaseType_t xStatus;  // 写队列函数的返回值，用来判断是否写入成功
	
	ValToSend = ( char * )param;
	
	while (1)
	{
		
		xStatus = xQueueSend(xQueue, &ValToSend, portMAX_DELAY);
		
		if(xStatus != pdTRUE)
		{
			printf( "Could not send to the queue.\r\n" );
		}

	}
}

读队列函数：

static void vReceiverTask(void * param)
{
	BaseType_t  xStatus;
	char *    ValToReceived;
	const TickType_t xTicksToWait = pdMS_TO_TICKS( 100UL );
	
	while(1)
	{
		xStatus = xQueueReceive( xQueue, &ValToReceived, xTicksToWait );
		if(xStatus == pdTRUE)
		{
			printf("%s", ValToReceived);
		}
		else
		{
			printf( "Could not receive from the queue.\r\n" );
		}
	}
}

运行结果：
在这里插入图片描述

2、分辨数据源（ 多个数据来源，一个队列 ）

当有多个发送任务，通过同一个队列发出数据，这就要区分数据的来源。可以通过写入队列结构体，在结构体中定义成员表明数据来源。接下来上代码。

  1. 创建队列：用来发送结构体，数据的大小就是结构体的大小
  2. 发送任务的优先级为 2 ，往队列里写入结构体（结构体里标明了数据来源）
  3. 接收任务的优先级为 1 ，读队列、根据数据来源打印信息

main 函数中

typedef enum 
{
	Source01,
	Source02
} ID_t;  //  定义 枚举 类型，数据来源

typedef struct 
{
	ID_t eDataID;
	char * lDataValue;
	uint32_t val;
} Data_t;    //定义队列中的传输格式  结构体

// 定义结构体 数组，不同的数据来源，不同的数据
static const Data_t xStructToSend[ 2 ] = { {Source01, "Hello world", 6},
						                   {Source02, "Welcome", 8}
									     };
QueueHandle_t xQueue;   //队列句柄

int main( void )
{
	prvSetupHardware();
	
	xQueue = xQueueCreate(5, sizeof( Data_t )); // 创建队列: 长度为5，数据大小为结构体的大小
	if(xQueue == NULL)
	{
		printf("can not create queue\r\n");
	}
	
	/* 创建2个任务用于写队列，传入的参数是  结构体的地址
	*  优先级为2
	*/
	xTaskCreate(vSenderTask, "Source01 Task", 1000, (void *) &(xStructToSend[0]), 2, NULL);
	xTaskCreate(vSenderTask, "Source02 Task", 1000, (void *) &(xStructToSend[1]), 2, NULL);
	
	/* 创建1个任务用于读队列
	*  优先级为1，低于写队列的任务，发送任务优先执行，队列是满的
	*/
	xTaskCreate(vReceiverTask, "Recevier", 1000, NULL, 1, NULL);
	

	/* Start the scheduler. */
	vTaskStartScheduler();

	/* Will only get here if there was not enough heap space to create the
	idle task. */
	return 0;
}

写队列函数：将结构体地址写入队列

static void vSenderTask(void * param)
{
	
	BaseType_t xStatus; // 写队列函数的返回值，用来判断是否写入成功
	
	while (1)
	{
		
		xStatus = xQueueSend(xQueue, param, portMAX_DELAY);
		
		if(xStatus != pdTRUE)
		{
			printf( "Could not send to the queue.\r\n" );
		}

	}
}

读队列函数：

static void vReceiverTask(void * param)
{
	BaseType_t  xStatus;
	Data_t   DateToReceived;  /* 读取队列时, 用这个变量来存放数据 */
	
	while(1)
	{
		
		
		xStatus = xQueueReceive( xQueue, &DateToReceived, 0 );
		if(xStatus == pdTRUE)
		{
			//读到数据
			if(DateToReceived.eDataID == Source01)  //判断数据源，做不同的事情
			{
				printf("From Source01 \r\nval = %d \r\n%s \r\n\r\n",  DateToReceived.val,  DateToReceived.lDataValue);
			}
			else if(DateToReceived.eDataID == Source02)
			{
				printf("From Source02 \r\nval = %d \r\n%s \r\n\r\n",  DateToReceived.val,  DateToReceived.lDataValue);
			}

		}
		else
		{
			printf( "Could not receive from the queue.\r\n" );
		}
	}
}

运行结果：
在这里插入图片描述

3、队列集（ 可监测多个队列 ）

如果某系统支持鼠标输入、按键输入、触摸屏输入等，每种输入设备都会产生数据，产生的数据就可以放到对应的队列中，在应用程序中要去读取这三个队列，任意一个队列有数据都可以唤醒应用，这时就需要队列集

队列集可以监测多个队列，从多个队列中挑出有数据的队列，去读队列。

队列集也是队列，队列集中放的是队列。队列集的大小是检测队列的长度和，例如：要检测三个队列A、B、C，则队列集的长度为：队列A的长度 + 队列B的长度 + 队列C的长度。

  1. 创建队列（ queue ）、队列集（queue set）
  2. 与队列建立联系
  3. A设备产生数据就会写 A 对应的队列，同时会将 队列 A 的句柄放到队列集中；也就是写队列一次就会写队列集一次。
  4. 读队列集，回返回某队列的句柄。
  5. 根据队列集返回的队列句柄去读队列

程序
创建两个队列，使用队列集监测这两个队列，队列中有数据就读出来。
main函数

static QueueHandle_t xQueueHandle1;  //队列的句柄
static QueueHandle_t xQueueHandle2;  //队列的句柄
static QueueSetHandle_t xQueueHandle_Set;  //队列集的句柄

int main( void )
{
	
		
	prvSetupHardware();

	//1、创建2个队列
	xQueueHandle1 = xQueueCreate(2, sizeof( int ));
	if(xQueueHandle1 == NULL)
	{
		printf("can not create queue\r\n");
	}
	xQueueHandle2 = xQueueCreate(2, sizeof( int ));
	if(xQueueHandle2 == NULL)
	{
		printf("can not create queue\r\n");
	}
	
	//2、创建队列集
	// xQueueCreateSet();是创建队列集函数，参数为队列集的大小（4） = 队列1的大小（2）  +  队列2的大小（2）
	xQueueHandle_Set = xQueueCreateSet(4); 
	
	//3、队列与队列集建立联系
	xQueueAddToSet(xQueueHandle1, xQueueHandle_Set);  //利用xQueueAddToSet(); 将 xQueueHandle1（队列1） 添加到 xQueueHandle_Set（队列集）中
	xQueueAddToSet(xQueueHandle2, xQueueHandle_Set);  //利用xQueueAddToSet(); 将 xQueueHandle2（队列2） 添加到 xQueueHandle_Set（队列集）中

	//4、创建3个任务
	
	xTaskCreate(Task1Function, "Task1", 100, NULL, 1, NULL);
	xTaskCreate(Task2Function, "Task2", 100, NULL, 1, NULL);
	xTaskCreate(Task3Function, "Task3", 100, NULL, 1, NULL);
	

	/* Start the scheduler. */
	vTaskStartScheduler();

	/* Will only get here if there was not enough heap space to create the
	idle task. */
	return 0;
}

三个任务函数：
任务 1：隔一段时间就往队列 1 中写数据

static void Task1Function(void * param)
{
	
	BaseType_t xStatus;
	int i = 0;
	
	while (1)
	{
		// 任务 1：隔一段时间就往队列 1 中写数据
		xStatus = xQueueSend(xQueueHandle1, &i, portMAX_DELAY);
		if(xStatus != pdTRUE)
		{
			printf( "Could not send to the queue.\r\n" );
		}

		i++;
		vTaskDelay(100);
		
	}
}

任务 2：隔一段时间就往队列 2 中写数据

static void Task2Function(void * param)
{
	
	BaseType_t xStatus;
	int i = -1;
	
	while (1)
	{
		// 任务 2：隔一段时间就往队列 2 中写数据
		xStatus = xQueueSend(xQueueHandle2, &i, portMAX_DELAY);
		if(xStatus != pdTRUE)
		{
			printf( "Could not send to the queue.\r\n" );
		}

		i--;
		vTaskDelay(200);
		
	}
}

任务 3：监测队列 1 和 队列 2 ，两个队列中有数据就读出来

static void Task3Function(void * param)
{
	QueueSetMemberHandle_t handler;
	int i;
	
	//任务 3：监测队列 1 和 队列 2  ，两个队列中有数据就读出来
	while (1)
	{
		//读队列集函数xQueueSelectFromSet(); 看哪个队列有数据,返回值为有数据的队列句柄，参数为队列集的句柄和等待时间
		handler = xQueueSelectFromSet(xQueueHandle_Set, portMAX_DELAY);
		
		//读有数据的队列
		xQueueReceive(handler, &i, 0);

		//打印出来
		printf("get data : %d\r\n", i);
	}
}

注意： 在使用函数来创建队列集，使用队列集的相关函数时要配置下面的宏：

#define configUSE_QUEUE_SETS        1

如果要使用 xQueueCreateSet(); 来创建队列集要配置两个宏，如下图：
在这里插入图片描述
其中第二个宏在FreeRTOS.h中被自动配置为 1 ：
在这里插入图片描述
其中第一个宏在FreeRTOS.h中被自动配置为 0 ：
在这里插入图片描述
所以需要增加配置宏

#define configUSE_QUEUE_SETS        1

运行结果：
在这里插入图片描述

嵌入式小白的进阶之路
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
FreeRTOS学习笔记之——-FreeRTOS队列基础知识 2020.3.30
01-06
知识点： 1.（为什么要使用队列？） 在没有操作系统的时候，两个应用程序进行消息传递一般是使用全局变量的方式，但是如果在使用操作系统的应用中用全局变量来传递消息，则会涉及资源管理的问题。 2.队列是为了任务与任务、任务与中断之间的通信而准备的，可以在任务与任务、任务与中断之间传递消息，队列中可以存储有限的、大小固定的数据项目。 3.队列能保存的最大数据项目数量叫队列的长度。 4.通常，队列采用的是先进先出的（FIFO）的存储缓冲机制，也就是往队列中发送数据的时候（也叫入队）永远都是发送到队列的尾部，而从队列中提取数据的时候（也叫出队）是从队列的头部提取的。 5.发送数据和读取数据有两种方式，一
【Freertos基础入门】同步互斥与通信
m0_62599305的博客
08-21 525
本系列基于stm32系列单片机来使用freerots任务管理是实时操作系统（RTOS）的核心功能之一，它允许开发者以并发的方式组织和管理多个任务。FreeRTOS 是一个流行的开源RTOS，它提供了强大的任务管理功能，让开发者能够轻松创建和控制任务。本文将介绍 FreeRTOS 的任务管理功能，包括任务的创建、删除、挂起、恢复和优先级控制等方面的内容。在FreeRTOS中，同步互斥与通信是实现任务之间有效协作的重要概念。本文对FreeRTOS中的同步互斥与通信机制进行了总结，以帮助读者理解它们的作用和特点。
【FreeRTOS】RTOS任务的同步与互斥：（一）队列
最新发布
weixin_46216674的博客
04-19 862
任务的同步与互斥是学习FreeRTOS的核心内容。同步则指A等待B做完某件事后执行，而互斥表示某一资源同一时间仅能有一个用户访问。队列又称消息队列，是一种常用于任务间通信的数据结构，队列可以在任务与任务间、中断和任务间传递信息。队列通常采用先进先出（FIFO）的数据存储缓冲机制，即先入队的数据会先从队列中被读取。队列采用实际值传递，即将数据拷贝到队列中进行传递，在传递较大的数据的时候采用指针传递；队列不属于某个任务，任何任务和中断都可以向队列发送/读取消息，当任务向一个队列发送消息时，可以指定一个阻塞时间。
七，FreeRTOS之——队列同步与互斥
m0_51095029的博客
09-26 1881
声明：本专栏参考韦东山，野火，正点原子以及其他博主的FreeRTOS教程，如若侵权请告知，马上删帖致歉，个人总结，如有不对，欢迎指正。转：同步与互斥概念理解link实验一：同步实验代码划重点创建队列任务句柄，在这之前得要加入队列头文件创建队列函数各任务处理事件实验二：互斥实验代码划重点 转：同步与互斥概念理解link 实验一：同步 还是来看看同步实验怎么做吧 实验代码 /** FreeRTOS v9.0.0 + STM32 动态创建任务 实验平台:韦东山 STM32F103ZE开.
【RTOS】快速体验FreeRTOS所有常用API（3）同步与互斥
xifan的博客
01-17 445
队列(queue)、信号量(semaphoe)、互斥量(mutex)、事件组(event group)、任务通知(task notification)，都能实现同步、互斥。总结括它们的联系、区别以及在使用时的如何选择。
7、FreeRTOS - 不同任务之间的沟通：互斥、同步、通信
wefaj的博客
10-16 335
同步：同步，是协调的意思，协调工作的进行，用于在多个任务的执行中控制轮到哪个任务执行和什么时候执行。例如，把任务比成班级里的同学，同学 A 和同学 B 一起完成一道数学大题，题被分成两小题，同学 A 做第一小题，同学 B 做第二小题，不过第二小题需要第一小题的计算结果才能继续往下算，所以同学 B 需要一直等待同学 A，只有等同学 A 做完后告诉同学 B 结果，同学 B 才能开始做题。（B 需要 A 的答案才能做题，所以等待的过程中什么都做不了，这个等待过程就被称为阻塞）互斥：用于保护共享资源，避免数据错误。
四、freeRTOS_同步互斥与通信概述
qq_41682371的博客
08-02 478
同步互斥与通信概述
FreeRTOS同步与互斥：（一）队列
Pluto__xu的博客
10-01 718
注：本文摘自韦东山《FreeRTOS完全开发手册，如有侵权请告知》
FreeRTOS入门教程（同步与互斥）
m0_49476241的博客
10-01 814
前几篇文章一直在围绕FreeRTOS中的任务创建，删除，优先级，调度算法进行讲解，那么从本篇文章开始将围绕同步与互斥来展开讲解。本篇文章主要讲解了同步和互斥的基本概念。
FreeRTOS学习---“消息队列”篇
小人物的编程
12-28 2226
介绍FreeRTOS的消息队列功能
FreeRTOS队列与消息传递-3队列实现串口守护任务
weixin_45739317的博客
10-04 606
队列是一种特殊的数据结构，可以保存有限个具有长度的数据单元，一般采用先进先出的存取方式。FreeRTOS利用队列实现任务间的通信，消息传递，后面将要介绍的信号量也是队列来实现的。
S32K+FreeRTOS学习笔记.pdf
03-18
该问主要是FreeRTOS使用过程中的学习笔记。是FreeRTOS的核心要点提取。
FreeRTOS学习笔记
04-20
FreeRTOS初学者的福音
STM32CubeMX FreeRTOS学习[4]-消息队列
12-03
前提：默认已经装好 MDK V5 和 STM32CubeMX，并安装了 STM32F1xx 系列的支持包。 硬件平台：STM32F1xx 系列。 目的：学习消息队列的使用。
【FreeRTOS】详细讲解FreeRTOS中消息队列并通过示例讲述其用法
黑心萝卜三条杠的博客
01-31 7736
本文详细地讲解了FreeRTOS消息队列的相关函数及其用法，使用用示例讲解各个函数实际用法以及实际使用过程中碰到的问题。
FREERTOS学习笔记三-消息队列
qq_46384359的博客
02-03 1802
FREERTOS学习笔记三-消息队列 1.实验内容 ​ 实验二内容：创建两个动态任务，任务一控制LED的闪烁，任务二用于检测按键。当按键KEY0按下时，任务一被挂起；当按键KEY1被按下时，任务一被取消挂起。 ​ 实验三是在实验二的基础上进行修改，增加一个消息队列和两个任务进程；任务二按键检测，当按键被按下时，会发生消息；任务三和任务四负责接收消息。 2.CubeMX的配置 1.1添加两个优先级相同的任务 1.2添加消息队列 消息大小为16，消息格式为无符号的16位 1.3添加调试串口 2.程序编
FreeRTOS操作系统——队列及队列API函数（十）
戚晨夕的博客
01-19 3190
FreeRTOS操作系统学习 文章目录FreeRTOS操作系统学习前言一、队列功能介绍1.数据存储2.多任务访问3.出队阻塞4.入队阻塞二、队列工作过程1.API函数1.队列创建函数2.入队函数2.队列操作实验总结 前言 队列是为了任务与任务、任务与中断之间的通信而准备的，可以在任务与任务、任务与中断之间传递消息，队列中可以存储有限的、大小固定的数据项目。任务与任务、任务与中断之间要交流的数据保存在队列中，叫做队列项目。队列所能保存的最大数据项目数量叫做队列的长度，创建队列的时候会指定数据项目的大小和队
FreeRTOS实时操作系统（十一）队列集
贾saisai的博客
07-06 410
队列只允许传递一种数据类型，队列集可以传递多种消息。作用：用于对多个队列或信号量进行“监听”，其中不管哪一个消息到来，都可让任务退出阻塞状态。
freertos学习笔记野火
07-28
抱歉，我无法回答你的问题。我的回答只限于提供的引用内容范围内。 #### 引用[.reference_title] - *1* *2* *3* [STM32F407霸天虎FreeRTOS学习笔记——移植FreeRTOS到开发板上](https://blog.csdn.net/weixin_43329283/article/details/126910114)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insert_down28v1,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值