FreeRTOS（2）：队列、信号量、互斥量

最新推荐文章于 2024-05-16 00:15:00 发布
最新推荐文章于 2024-05-16 00:15:00 发布
阅读量415 收藏 1
点赞数
分类专栏： STM32 RTOS 文章标签： stm32 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_73379310/article/details/132011010
版权
STM32 同时被 2 个专栏收录
15 篇文章 9 订阅
订阅专栏
RTOS
5 篇文章 1 订阅
订阅专栏

目录

一、队列

1.什么是队列？

2.队列特点

1. 数据入队出队方式

2. 数据传递方式

3. 多任务访问

4. 出队、入队阻塞

3.队列相关 API 函数

1. 创建队列

2. 写队列

3. 读队列

4.实操

实验需求

cubeMX配置

代码实现

二、二值信号量

1.什么是信号量？

2.什么是二值信号量？

3.二值信号量相关 API 函数

(1). 创建二值信号量

(2). 释放二值信号量

(3). 获取二值信号量

4.实操

实验需求

cubeMX配置

代码实现 

七、计数型信号量

1.什么是计数型信号量？

2.计数型信号量相关 API 函数

3.实操

实验需求

cubeMX配置

 代码实现

 八、互斥量

1.什么是互斥量？

2.什么是优先级翻转？

3.互斥量相关 API 函数

4.实操

实验需求

cubeMX配置

代码实现 

一、队列

1.什么是队列？

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

为什么不使用全局变量？

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

        在这种情况下，就可以使用队列。任务1和任务2产生的数据放在流水线上，任务3可以慢慢一个个依次处理。

关于队列的几个名词：

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

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

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

2.队列特点

1. 数据入队出队方式

通常采用 先进先出（FIFO）的数据存储缓冲机制，即先入队的数据会先从队列中被读取。

也可以配置为后进先出（LIFO）方式，但用得比较少。

2. 数据传递方式

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

采用指针传递。

3. 多任务访问

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

4. 出队、入队阻塞

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

阻塞时间如果设置为：

        0：直接返回不会等待；

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

                                             再等待；

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

3.队列相关 API 函数

1. 创建队列

QueueHandle_t xQueueCreate( UBaseType_t uxQueueLength,UBaseType_t uxItemSize );

参数：

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

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

返回值：

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

则返回 NULL。

2. 写队列

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

函数描述
xQueueSend()往队列的尾部写入消息
xQueueSendToBack()同 xQueueSend()
xQueueSendToFront()往队列的头部写入消息
xQueueOverwrite()覆写队列消息（只用于队列长度为 1 的情况）
xQueueSendFromISR()在中断中往队列的尾部写入消息
xQueueSendToBackFromISR()同 xQueueSendFromISR()
xQueueSendToFrontFromISR()在中断中往队列的头部写入消息
xQueueOverwriteFromISR()在中断中覆写队列消息（只用于队列长度为 1 的情况）
BaseType_t xQueueSend(QueueHandle_t xQueue,const void * pvItemToQueue,
                        TickType_t xTicksToWait);

参数：

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

        pvItemToQueue：待写入数据

        xTicksToWait：阻塞超时时间

返回值：

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

3. 读队列

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

函数描述
xQueueReceive()从队列头部读取消息，并删除消息
xQueuePeek()从队列头部读取消息，但是不删除消息
xQueueReceiveFromISR()在中断中从队列头部读取消息，并删除消息
xQueuePeekFromISR()在中断中从队列头部读取消息
BaseType_t xQueueReceive(QueueHandle_t xQueue,void *pvBuffer,
                            TickType_t xTicksToWait);

参数：

        xQueue：待读取的队列

        pvItemToQueue：数据读取缓冲区

        xTicksToWait：阻塞超时时间

返回值：

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

4.实操

实验需求

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

cubeMX配置

 生成的代码：创建队列

  /* Create the queue(s) */
  /* definition and creation of myQueue01 */
  osMessageQDef(myQueue01, 16, uint16_t);
  myQueue01Handle = osMessageCreate(osMessageQ(myQueue01), NULL);

代码实现

设置容量16，则可以写入最多16次

/* USER CODE BEGIN Header_Start_sendTask */
/**
  * @brief  Function implementing the sendTask thread.
  * @param  argument: Not used
  * @retval None
  */
/* USER CODE END Header_Start_sendTask */
void Start_sendTask(void const * argument)
{
  /* USER CODE BEGIN Start_sendTask */
	static uint16_t buf = 123;
	BaseType_t status;
  /* Infinite loop */
  for(;;)
  {
		if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) == GPIO_PIN_RESET)
		{
			osDelay(10);//防抖
			if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) == GPIO_PIN_RESET)
			{
				printf("按键1按下\r\n");
				status = xQueueSend(myQueue01Handle,&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 Start_sendTask */
}

/* USER CODE BEGIN Header_Start_receiveTask */
/**
* @brief Function implementing the receiveTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_Start_receiveTask */
void Start_receiveTask(void const * argument)
{
  /* USER CODE BEGIN Start_receiveTask */
	static uint16_t buf;
	BaseType_t status;
  /* Infinite loop */
  for(;;)
  {
		if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_1) == GPIO_PIN_RESET)
		{
			osDelay(10);//防抖
			if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_1) == GPIO_PIN_RESET)
			{
				printf("按键2按下\r\n");
				status = xQueueReceive(myQueue01Handle,&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(10);
  }
  /* USER CODE END Start_receiveTask */
}

二、二值信号量

1.什么是信号量？

信号量（Semaphore），是在多任务环境下使用的一种机制，是可以用来保证两个或多个关键代

码段不被并发调用。

信号量这个名字，我们可以把它拆分来看，信号可以起到通知信号的作用，然后我们的量还可以用来表示资源的数量，当我们的量只有0和1的时候，它就可以被称作二值信号量，只有两个状态，当我们的那个量没有限制的时候，它就可以被称作为计数型信号量。

信号量也是队列的一种。

2.什么是二值信号量？

二值信号量其实就是一个长度为1，大小为零的队列，只有0和1两种状态，通常情况下，我们用它来进行互斥访问或任务同步。

互斥访问：比如门钥匙，只有获取到钥匙才可以开门

任务同步：比如我录完视频你才可以看视频

3.二值信号量相关 API 函数

函数描述
xSemaphoreCreateBinary()使用动态方式创建二值信号量
xSemaphoreCreateBinaryStatic()使用静态方式创建二值信号量
xSemaphoreGive()释放信号量
xSemaphoreGiveFromISR()在中断中释放信号量
xSemaphoreTake()获取信号量
xSemaphoreTakeFromISR()在中断中获取信号量

(1). 创建二值信号量

SemaphoreHandle_t xSemaphoreCreateBinary( void )

参数：

        无

返回值：

        成功，返回对应二值信号量的句柄；

        失败，返回 NULL 。 

(2). 释放二值信号量

BaseType_t xSemaphoreGive( SemaphoreHandle_t xSemaphore )

参数：

        xSemaphore：要释放的信号量句柄

返回值：

        成功，返回 pdPASS ；

        失败，返回 errQUEUE_FULL 。

(3). 获取二值信号量

BaseType_t xSemaphoreTake( SemaphoreHandle_t xSemaphore,TickType_t xTicksToWait );

参数：

        xSemaphore：要获取的信号量句柄

        xTicksToWait：超时时间，0 表示不超时，portMAX_DELAY表示卡死等待；

返回值：

        成功，返回 pdPASS ；

        失败，返回 errQUEUE_FULL 。

4.实操

实验需求

创建一个二值信号量，按下 KEY1 则释放信号量，按下 KEY2 获取信号量。

cubeMX配置

 

代码实现 

 现象：本身以及有一个信号量被创建在里面了，所以第一次创建会失败

  /* Create the semaphores(s) */
  /* definition and creation of myBinarySem01 */
  osSemaphoreDef(myBinarySem01);
  myBinarySem01Handle = osSemaphoreCreate(osSemaphore(myBinarySem01), 1);

  /* USER CODE BEGIN RTOS_SEMAPHORES */



/* USER CODE BEGIN Header_Start_sendTask */
/**
  * @brief  Function implementing the sendTask thread.
  * @param  argument: Not used
  * @retval None
  */
/* USER CODE END Header_Start_sendTask */
void Start_sendTask(void const * argument)
{
  /* USER CODE BEGIN Start_sendTask */

  /* Infinite loop */
  for(;;)
  {
		if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) == GPIO_PIN_RESET)
		{
			osDelay(10);//防抖
			if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) == GPIO_PIN_RESET)
			{
				printf("按键1按下\r\n");
				
				if(xSemaphoreGive(myBinarySem01Handle) == pdTRUE)
					printf("发送成功\r\n");
				else
					printf("写入失败\r\n");
			}
			while(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) == GPIO_PIN_RESET);
		}
    osDelay(10);
  }
  /* USER CODE END Start_sendTask */
}

/* USER CODE BEGIN Header_Start_receiveTask */
/**
* @brief Function implementing the receiveTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_Start_receiveTask */
void Start_receiveTask(void const * argument)
{
  /* USER CODE BEGIN Start_receiveTask */
  /* Infinite loop */
  for(;;)
  {
		if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_1) == GPIO_PIN_RESET)
		{
			osDelay(10);//防抖
			if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_1) == GPIO_PIN_RESET)
			{
				printf("按键2按下\r\n");
				if(xSemaphoreTake(myBinarySem01Handle, 0)== pdTRUE)
					printf("读取成功\r\n");
				else
					printf("读取失败\r\n");
			}
			while(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_1) == GPIO_PIN_RESET);
		}
    osDelay(10);
  }
  /* USER CODE END Start_receiveTask */
}

 一直卡住：

xSemaphoreTake(myBinarySemHandle, portMAX_DELAY);

七、计数型信号量

1.什么是计数型信号量？

计数型信号量相当于队列长度大于1 的队列，因此计数型信号量能够容纳多个资源，这在计数型

信号量被创建的时候确定的。

2.计数型信号量相关 API 函数

函数描述
xSemaphoreCreateCounting()使用动态方法创建计数型信号量。
xSemaphoreCreateCountingStatic()使用静态方法创建计数型信号量
uxSemaphoreGetCount()获取信号量的计数值

计数型信号量的释放和获取与二值信号量完全相同 ！

SemaphoreHandle_t xSemaphoreCreateCounting( UBaseType_t uxMaxCount,
                    UBaseType_t uxInitialCount);

参数：

        uxMaxCount：可以达到的最大计数值

        uxInitialCount：创建信号量时分配给信号量的计数值

返回值：

        成功，返回对应计数型信号量的句柄；

        失败，返回 NULL 。

3.实操

实验需求

创建一个计数型信号量，按下 KEY1 则释放信号量，按下 KEY2 获取信号量。

cubeMX配置

将 Config parameters 标签里的 USE_COUNTING_SEMAPHORES 设置为 Enabled 。

可自行设置数量 

 代码实现

初始已经存在三个值了。 

同样0换成portMAX_DELAY也可以卡住 

  /* Create the semaphores(s) */
  /* definition and creation of myCountingSem01 */
  osSemaphoreDef(myCountingSem01);
  myCountingSem01Handle = osSemaphoreCreate(osSemaphore(myCountingSem01), 3);

  /* USER CODE BEGIN RTOS_SEMAPHORES */



/* USER CODE BEGIN Header_Start_sendTask */
/**
  * @brief  Function implementing the sendTask thread.
  * @param  argument: Not used
  * @retval None
  */
/* USER CODE END Header_Start_sendTask */
void Start_sendTask(void const * argument)
{
  /* USER CODE BEGIN Start_sendTask */

  /* Infinite loop */
  for(;;)
  {
		if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) == GPIO_PIN_RESET)
		{
			osDelay(10);//防抖
			if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) == GPIO_PIN_RESET)
			{
				printf("按键1按下\r\n");
				
				if(xSemaphoreGive(myCountingSem01Handle) == pdTRUE)
					printf("发送成功：%d\r\n",(int)uxSemaphoreGetCount(myCountingSem01Handle));
				else
					printf("写入失败\r\n");
			}
			while(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) == GPIO_PIN_RESET);
		}
    osDelay(10);
  }
  /* USER CODE END Start_sendTask */
}

/* USER CODE BEGIN Header_Start_receiveTask */
/**
* @brief Function implementing the receiveTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_Start_receiveTask */
void Start_receiveTask(void const * argument)
{
  /* USER CODE BEGIN Start_receiveTask */
  /* Infinite loop */
  for(;;)
  {
		if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_1) == GPIO_PIN_RESET)
		{
			osDelay(10);//防抖
			if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_1) == GPIO_PIN_RESET)
			{
				printf("按键2按下\r\n");
				if(xSemaphoreTake(myCountingSem01Handle, 0)== pdTRUE)
					printf("读取成功：%d\r\n",(int)uxSemaphoreGetCount(myCountingSem01Handle));
				else
					printf("读取失败\r\n");
			}
			while(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_1) == GPIO_PIN_RESET);
		}
    osDelay(10);
  }
  /* USER CODE END Start_receiveTask */
}

 八、互斥量

1.什么是互斥量？

在多数情况下，互斥型信号量和二值型信号量非常相似，但是从功能上二值型信号量用于同步，而互斥型信号量用于资源保护。

互斥型信号量和二值型信号量还有一个最大的区别，互斥型信号量可以有效解决优先级反转现

象。

2.什么是优先级翻转？

以上图为例，系统中有3个不同优先级的任务H/M/L，最高优先级任务H和最低优先级任务L通过信号量机制，共享资源。目前任务L占有资源，锁定了信号量，Task H运行后将被阻塞，直到TaskL释放信号量后，Task H才能够退出阻塞状态继续运行。但是Task H在等待Task L释放信号量的过程中，中等优先级任务M抢占了任务L，从而延迟了信号量的释放时间，导致Task H阻塞了更长时间，这种现象称为优先级倒置或反转。

优先级继承：当一个互斥信号量正在被一个低优先级的任务持有时， 如果此时有个高优先级的任务也尝试获取这个互斥信号量，那么这个高优先级的任务就会被阻塞。不过这个高优先级的任务会将低优先级任务的优先级提升到与自己相同的优先级。

优先级继承并不能完全的消除优先级翻转的问题，它只是尽可能的降低优先级翻转带来的影响。

3.互斥量相关 API 函数

互斥信号量不能用于中断服务函数中！

函数描述
xSemaphoreCreateMutex()使用动态方法创建互斥信号量。
xSemaphoreCreateMutexStatic()使用静态方法创建互斥信号量。

SemaphoreHandle_t xSemaphoreCreateMutex( void )

参数：

        无

返回值：

        成功，返回对应互斥量的句柄；

        失败，返回 NULL 。

4.实操

实验需求

1. 演示优先级翻转

2. 使用互斥量优化优先级翻转问题

cubeMX配置

代码实现 

不使用互斥量

 使用互斥量

 

  /* definition and creation of myMutex01 */
  osMutexDef(myMutex01);
  myMutex01Handle = osMutexCreate(osMutex(myMutex01));

  /* USER CODE BEGIN RTOS_MUTEX */




/* USER CODE BEGIN Header_Start_sendTask */
/**
  * @brief  Function implementing the sendTask thread.
  * @param  argument: Not used
  * @retval None
  */
/* USER CODE END Header_Start_sendTask */
void Start_sendTask(void const * argument)
{
  /* USER CODE BEGIN Start_sendTask */

  /* Infinite loop */
  for(;;)
  {
		xSemaphoreTake(myMutex01Handle, portMAX_DELAY);
		printf("High开始\r\n");
		HAL_Delay(1000);
		printf("High结束\r\n");
		xSemaphoreGive(myMutex01Handle);
		
		osDelay(1000);
  }
  /* USER CODE END Start_sendTask */
}

/* USER CODE BEGIN Header_Start_receiveTask */
/**
* @brief Function implementing the receiveTask thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_Start_receiveTask */
void Start_receiveTask(void const * argument)
{
  /* USER CODE BEGIN Start_receiveTask */
  /* Infinite loop */
  for(;;)
  {
		printf("Mid抢占cpu\r\n");
    osDelay(1000);
  }
  /* USER CODE END Start_receiveTask */
}

/* USER CODE BEGIN Header_StartTask03 */
/**
* @brief Function implementing the Low thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartTask03 */
void StartTask03(void const * argument)
{
  /* USER CODE BEGIN StartTask03 */
  /* Infinite loop */
  for(;;)
  {
		xSemaphoreTake(myMutex01Handle, portMAX_DELAY);
		printf("Low开始\r\n");
		HAL_Delay(3000);
		printf("Low结束\r\n");
		xSemaphoreGive(myMutex01Handle);
		
    osDelay(1000);
  }
  /* USER CODE END StartTask03 */
}

我有在好好学习
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
FreeRTOS：队列、信号量、软件定时器、事件标志组实验
07-07
2. 实现互斥访问资源的信号量示例，比如共享内存区域。 3. 设定和管理软件定时器，观察其在触发回调函数时的行为。 4. 使用事件标志组来同步多个任务，等待特定事件组合的发生。 通过这些实验，你将能更好地理解...
μC/OS-II任务，信号量、邮箱、队列及其区别
08-03
看了《嵌入式实时操作系统uC/OS-II》也快一个星期了，期间断断续续的边工作边看，依照书的目录，大致细分了系统各个功能：任务管理，时间管理，事 件控制，信号量管理，互斥型信号量管理，事件标志组管理，信息邮箱管理，信息队列管理，内存管理等，这个次序也是以后要逐个理解学习的次序。
队列与信号量
月上柳梢头的博客
12-29 940
队列与信号量
FreeRTOS高级篇5---FreeRTOS队列分析
热门推荐
朱工的专栏
05-26 5万+
FreeRTOS提供了多种任务间通讯方式，包括：任务通知（版本V8.2以及以上版本）队列二进制信号量计数信号量互斥量递归互斥量 其中，二进制信号量、计数信号量、互斥量和递归互斥量都是使用队列来实现的，因此掌握队列的运行机制，是很有必要的。 队列是FreeRTOS主要的任务间通讯方式。可以在任务与任务间、中断和任务间传送信息。发送到队列的消息是通过拷贝实现的，这意味着队列存储的数...
Free RTOS中Semaphore（二值信号量）的使用介绍
mftang的博客
05-16 1565
本文主要介绍Free RTOS中Semaphore的使用方法，包括使用STM32Cube中配置FreeRTOS，并且使能Semaphore，还介绍了Free RTOS中Semaphore中相关的函数。还通过一个简单的实例，来介绍Semaphore的使用方法。
FreeRTOS五种方式传递信号（队列，信号量，互斥量，事件组，任务通知）
电子第一课，点亮LED；第二课，点亮钽电容；第三课，点亮MOS管
07-15 2152
在裸机编程中，一般信号传递都是全局变量，数组或者是返回值函数等等其他方式，在freertos中，我们不再使用裸机编程方式，而是使用统一的（五种）方式传递信号量，更加规范的，安全，传递（通知）信号。
【STM32】FreeRTOS消息队列和信号量学习
科昂的博客
08-12 1406
队列是一种用于实现任务与任务之间，任务与中断之间消息交流的机制。二、信号量 消息队列用于传输多个数据，占用时间也相对较长，但有时只需要传输状态，因此引入信号量。信号量也是队列的一种。信号量有两种，如果它的量只有0（被拿走的状态）和1（被填入的状态）两种状态，就称为二进制的信号量；当量的状态大于两种，就称为计数型信号量。
RTOS--信号量
MHD0815的博客
03-21 797
一 信号量介绍：RTOS（实时操作系统）中的信号量（Semaphore）是一种用于解决同步问题的机制，它主要用于任务间和中断服务例程（ISR）间的通信，以实现对共享资源的有序访问。信号量通常用于控制对共享资源的访问和任务同步，确保只有一个任务或中断服务例程可以访问共享资源，从而避免资源冲突。信号量主要分为两种类型：计数信号量和二值信号量。：假设有10个共享资源，每个资源都需要独立的访问控制。可以初始化一个计数为10的计数信号量。当任务需要访问资源时，它会尝试获取信号量。
FreeRTOS消息队列、信号量、事件组、任务通知之间的总结
hbzdsXCV的博客
12-10 1448
FreeRTOS消息队列、信号量、事件标志组、任务通知详细总结
STM32F429 FreeRTOS实战：实现FreeRTOS互斥信号量操作【支持STM32F42X系列单片机】.zip
12-15
FreeRTOS是为嵌入式系统设计的开源RTOS，它提供了调度、任务、信号量、互斥锁、消息队列等多种功能，帮助开发者构建复杂的实时系统。STM32F429是STMicroelectronics公司推出的高性能ARM Cortex-M4内核MCU，具备浮点...
[FreeRTOS ] 信号量 功能应用
最新发布
06-24
本实验是基于STM32F103开发移植FreeRTOS实时操作系统，信号量实战操作。 使用工具：Keil、串口工具 描述： 信号量是一个抽象的数据类型，通常包含一个整数值以及一个等待该值变为正数的任务列表（也称为等待队列）。...
NXP i.MX RT1052 FreeRTOS实战：消息队列
12-01
NXP i.MX RT1052是一款高性能、低延迟的跨界处理器，适合实时应用，而FreeRTOS则是一种轻量级实时操作系统，适合嵌入式系统，它提供了多任务调度、信号量、互斥锁、事件标志组以及我们关注的消息队列等核心功能。...
野火FreeRTOS实战：14-2+3
01-10
1. **FreeRTOS核心概念**：首先，我们需要理解FreeRTOS的核心组件，如任务（Task）、信号量（Semaphore）、互斥锁（Mutex）、队列（Queue）、事件标志组（Event Group）以及定时器（Timer）。这些是构建实时系统的...
FreeRTOS-信号量详解
k666499436的博客
01-27 1万+
本文将详细全方位的讲解FreeRTOS的信量量，其实你学完了《FreeRTOS-消息队列详解》信号量的学习就非常简单了，因为所有的信号量的本质的都是特殊的队列(特殊在哪里：信号量只有队列头部，并没有后面的环形存储区，也就是说信号量只负责消息传递，并不传递数据)，当然这么多信号量也是有区别的，不同的信号量对应不同的应用场景，还是以源码分析为主，源码分析透了，这几种信号量的区别，或者特殊机制(互斥量的优先级继承)就一清二楚了。《FreeRTOS-消息队列详解》
FreeRTOS学习------信号量（实践）
小微分享驿站
03-22 2257
本文介绍有关FreeRTOS中信号量和计数信号量在使用过程中需要注意的细节，以及自己在过程中的分享的一些有关遇到的问题和注意点。
Free RTOS学习笔记 - 队列，信号量，互斥量，事件组，任务通知
zfh_persistence的博客
12-08 272
1、队列的特点数据的操作采用先进先出的方法（FIFO），写数据时放到尾部，读数据时从头部开始读取。也可以强制写队列头部，但不会覆盖头部数据。队列中每个数据的大小时固定的。创建队列时要指定长度，数据大小。2、队列的使用在创建队列时，会创建两个链表，分别存放等待数据的任务和等待向队列中写的数据，buf中存放队列的数据。1）创建队列可以看到xQueueXCreat()最后调用的是xQueueGenericCreate()。创建队列时，会创建几个指针，pcHead始终指向头部，不会移动；
FreeRTOS内部机制学习笔记三——互斥的引入
qq_46384359的博客
03-23 560
FreeRTOS内部机制学习笔记三——互斥的引入 在多任务系统中，如果有两个或者多个任务需要使用同一个变量，那么会出现一些数据错误。 ​ 比如任务A和任务B都需要实现对某个全局变量的自加，而变量自加需要三个过程：①从内存读取数据②对数据进行自加一③向内存写入数据。如果任务A在执行完过程①后被切换带任务B，任务B会对变量值进行修改，当时间片再次分配给任务A时，任务A会继续执行上次中断在过程①的任务，当执行完过程③之后，将数据写入内存中，这时上次任务B对全局变量的数据操作将不会起作用，因为被这次操作将上次任务B
线程互斥量、线程信号量 编程案例
m0_56051805的博客
07-20 246
线程互斥量、线程信号量 编程案例
RT-Thread 线程同步及通信 -- 信号量、互斥量、事件、邮箱、消息队列
Ningjianwen的专栏
05-24 2510
目录 一 RT-Thread 信号量 二 RT-Thread 互斥量 三 RT-Thread 事件标志组 四 RT-Thread邮箱 五 RT-Thread消息队列 一 RT-Thread 信号量 1.信号量相关函数 创建信号量 /** @paramname：信号量名称 * @paramvalue：信号量初始值 * @...
FreeRTOS核心API深度解析：任务、队列与信号量操作指南
本文档详细介绍了FreeRTOS的关键API函数，涵盖了任务创建、任务控制、内核控制、队列管理和信号量等核心功能。 1. **任务创建**： - `xTaskCreate` 是创建新任务的基本函数，允许开发者定义任务的入口函数、优先级...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值