FreeRTOS（3）：事件标志组、任务通知

原创已于 2023-08-02 18:26:51 修改 · 585 阅读

2 ·

CC 4.0 BY-SA版权

文章标签：

#stm32 #嵌入式硬件 #单片机

于 2023-08-02 18:26:32 首次发布

STM32 同时被 2 个专栏收录

16 篇文章

订阅专栏

RTOS

5 篇文章

订阅专栏

本文详细介绍了FreeRTOS中的事件标志组和任务通知功能，包括它们的原理、API函数使用、优势和劣势，以及在实际操作中的应用实例，如模拟二值信号量、计数型信号量、事件标志组和邮箱功能。

一、事件标志组

什么是事件标志组？

事件标志位：表明某个事件是否发生，联想：全局变量 flag。通常按位表示，每一个位表示一个事件（高8位不算）

事件标志组是一组事件标志位的集合，可以简单的理解事件标志组，就是一个整数。

事件标志组本质是一个 16 位或 32 位无符号的数据类型 EventBits_t ，由 configUSE_16_BIT_TICKS决定。

虽然使用了 32 位无符号的数据类型变量来存储事件标志，但其中的高8位用作存储事件标志组的控制信息，低 24 位用作存储事件标志，所以说一个事件组最多可以存储 24 个事件标志！

事件标志组相关 API 函数

函数	描述
xEventGroupCreate()	使用动态方式创建事件标志组
xEventGroupCreateStatic()	使用静态方式创建事件标志组
xEventGroupClearBits()	清零事件标志位
xEventGroupClearBitsFromISR()	在中断中清零事件标志位
xEventGroupSetBits()	设置事件标志位
xEventGroupSetBitsFromISR()	在中断中设置事件标志位
xEventGroupWaitBits()	等待事件标志位

1. 创建事件标志组

EventGroupHandle_t xEventGroupCreate( void );

参数：

无

返回值：

成功，返回对应事件标志组的句柄；

失败，返回 NULL 。

2. 设置事件标志位

EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup,
                const EventBits_t uxBitsToSet );

参数：

xEventGroup：对应事件组句柄。 uxBitsToSet：指定要在事件组中设置的一个或多个位的按位值。

返回值：

设置之后事件组中的事件标志位值。

3. 清除事件标志位

EventBits_t xEventGroupClearBits(EventGroupHandle_t xEventGroup,
                const EventBits_t uxBitsToClear );

参数：

xEventGroup：对应事件组句柄。 uxBitsToClear：指定要在事件组中清除的一个或多个位的按位值。

返回值：

清零之前事件组中事件标志位的值。

4. 等待事件标志位

EventBits_t xEventGroupWaitBits(
                const EventGroupHandle_t xEventGroup,
                const EventBits_t uxBitsToWaitFor,
                const BaseType_t xClearOnExit,
                const BaseType_t xWaitForAllBits,
                TickType_t xTicksToWait );

参数：

xEventGroup：对应的事件标志组句柄

uxBitsToWaitFor：指定事件组中要等待的一个或多个事件位的按位值

xClearOnExit：pdTRUE——清除对应事件位，pdFALSE——不清除

xWaitForAllBits：

pdTRUE——所有等待事件位全为1（逻辑与），pdFALSE——等待的事件位有一个为1（逻辑或）

xTicksToWait：超时

返回值：

等待的事件标志位值：等待事件标志位成功，返回等待到的事件标志位

其他值：等待事件标志位失败，返回事件组中的事件标志位

实操

实验需求

创建一个事件标志组和两个任务（ task1 和 task2），task1 检测按键，如果检测到 KEY1 和 KEY2，都按过，则执行 task2 。

代码实现


//任意一个按下都检测
		event_bit = xEventGroupWaitBits(eventgroup_handle,
                        0x01 | 0x02, pdTRUE, pdFALSE, portMAX_DELAY);
//两个全按过才检测
		event_bit = xEventGroupWaitBits(eventgroup_handle,
                        0x01 | 0x02, pdTRUE, pdTRUE, portMAX_DELAY);

/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN Variables */
EventGroupHandle_t eventgroup_handle;
/* USER CODE END Variables */


  /* USER CODE BEGIN RTOS_THREADS */
  /* add threads, ... */
	eventgroup_handle = xEventGroupCreate();
  /* USER CODE END RTOS_THREADS */


/* USER CODE BEGIN Header_Start_Task1 */
/**
  * @brief  Function implementing the Task1 thread.
  * @param  argument: Not used
  * @retval None
  */
/* USER CODE END Header_Start_Task1 */
void Start_Task1(void const * argument)
{
  /* USER CODE BEGIN Start_Task1 */
  /* Infinite loop */
  for(;;)
  {
		// 等待 KEY1 按下
		if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET)
		{
			osDelay(20);
			if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET)
			{
				xEventGroupSetBits(eventgroup_handle, 0x01);
			}
			while (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET);
		}

		// 等待 KEY2 按下
		if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET)
		{
			osDelay(20);
			if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET)
			{
				xEventGroupSetBits(eventgroup_handle, 0x02);
			}
			while (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET);
		}
    osDelay(1);
  }
  /* USER CODE END Start_Task1 */
}

/* USER CODE BEGIN Header_Start_Task2 */
/**
* @brief Function implementing the Task2 thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_Start_Task2 */
void Start_Task2(void const * argument)
{
  /* USER CODE BEGIN Start_Task2 */
	EventBits_t event_bit = 0;
  /* Infinite loop */
  for(;;)
  {
		//event_bit = xEventGroupWaitBits(eventgroup_handle, 0x01 | 0x02, pdTRUE, pdFALSE, portMAX_DELAY);
		event_bit = xEventGroupWaitBits(eventgroup_handle, 0x01 | 0x02, pdTRUE, pdTRUE, portMAX_DELAY);
		printf("%#x\r\n", event_bit);
    osDelay(1);
  }
  /* USER CODE END Start_Task2 */
}

二、任务通知

什么是任务通知？

FreeRTOS 从版本 V8.2.0 开始提供任务通知这个功能，每个任务都有一个 32 位的通知值。按照FreeRTOS 官方的说法，使用消息通知比通过二进制信号量方式解除阻塞任务快 45%，并且更加省内存（无需创建队列）。

在大多数情况下，任务通知可以替代二值信号量、计数信号量、事件标志组，可以替代长度为 1 的队列（可以保存一个 32 位整数或指针值），并且任务通知速度更快、使用的RAM更少！

任务通知值的更新方式

FreeRTOS 提供以下几种方式发送通知给任务：

发送消息给任务，如果有通知未读，不覆盖通知值

发送消息给任务，直接覆盖通知值

发送消息给任务，设置通知值的一个或者多个位

发送消息给任务，递增通知值

通过对以上方式的合理使用，可以在一定场合下替代原本的队列、信号量、事件标志组等。

任务通知的优势和劣势

任务通知的优势

1. 使用任务通知向任务发送事件或数据，比使用队列、事件标志组或信号量快得多。

2. 使用其他方法时都要先创建对应的结构体，使用任务通知时无需额外创建结构体。

任务通知的劣势

1. 只有任务可以等待通知，中断服务函数中不可以，因为中断没有 TCB 。

2. 通知只能一对一，因为通知必须指定任务。

3. 等待通知的任务可以被阻塞，但是发送消息的任务，任何情况下都不会被阻塞等待。

4. 任务通知是通过更新任务通知值来发送数据的，任务结构体中只有一个任务通知值，只能保

持一个数据。

任务通知相关 API 函数

1. 发送通知

函数	描述
xTaskNotify()	发送通知，带有通知值
xTaskNotifyAndQuery()	发送通知，带有通知值并且保留接收任务的原通知值
xTaskNotifyGive()	发送通知，不带通知值
xTaskNotifyFromISR()	在中断中发送任务通知
xTaskNotifyAndQueryFromISR()	在中断中发送任务通知
vTaskNotifyGiveFromISR()	在中断中发送任务通知

BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify,
                        uint32_t ulValue,
                        eNotifyAction eAction );

参数：

xTaskToNotify：需要接收通知的任务句柄；

ulValue：用于更新接收任务通知值，具体如何更新由形参 eAction 决定；

eAction：一个枚举，代表如何使用任务通知的值；

枚举值	描述
eNoAction	发送通知，但不更新值（参数ulValue未使用）
eSetBits	被通知任务的通知值按位或ulValue。（某些场景下可代替事件组，效率更高）
eIncrement	被通知任务的通知值增加1（参数ulValue未使用），相当于xTaskNotifyGive
eSetValueWithOverwrite	被通知任务的通知值设置为 ulValue。（某些场景下可代替xQueueOverwrite ，效率更高）
eSetValueWithoutOverwrite	如果被通知的任务当前没有通知，则被通知的任务的通知值设为ulValue。如果被通知任务没有取走上一个通知，又接收到了一个通知，则这次通知值丢弃，在这种情况下视为调用失败并返回pdFALSE (某些场景下可代替xQueueSend ，效率更高)

返回值：

如果被通知任务还没取走上一个通知，又接收了一个通知，则这次通知值未能更新并返回

pdFALSE，而其他情况均返回pdPASS。

BaseType_t xTaskNotifyAndQuery( TaskHandle_t xTaskToNotify,
                        uint32_t ulValue,
                        eNotifyAction eAction,
                        uint32_t *pulPreviousNotifyValue );

参数：

xTaskToNotify：需要接收通知的任务句柄；

ulValue：用于更新接收任务通知值，具体如何更新由形参 eAction 决定；

eAction：一个枚举，代表如何使用任务通知的值；

pulPreviousNotifyValue：对象任务的上一个任务通知值，如果为 NULL，则不需要回传，这个时候就等价于函数 xTaskNotify()。

返回值：

如果被通知任务还没取走上一个通知，又接收了一个通知，则这次通知值未能更新并返回pdFALSE，而其他情况均返回pdPASS。

BaseType_t xTaskNotifyGive( TaskHandle_t xTaskToNotify );

参数：

xTaskToNotify：接收通知的任务句柄，并让其自身的任务通知值加 1。

返回值：

总是返回 pdPASS。

2. 等待通知

等待通知API函数只能用在任务，不可应用于中断中！

函数	描述
ulTaskNotifyTake()	获取任务通知，可以设置在退出此函数的时候将任务通知值清零或者减一。当任务通知用作二值信号量或者计数信号量的时候，使用此函数来获取信号量。
xTaskNotifyWait()	获取任务通知，比 ulTaskNotifyTak()更为复杂，可获取通知值和清除通知值的指定位

uint32_t ulTaskNotifyTake( BaseType_t xClearCountOnExit,
                            TickType_t xTicksToWait );

参数：（关键）

xClearCountOnExit：指定在成功接收通知后，将通知值清零或减 1，

pdTRUE：把通知值清零（二值信号量）；

pdFALSE：把通知值减一（计数型信号量）；

xTicksToWait：阻塞等待任务通知值的最大时间；

返回值：

0：接收失败

非0：接收成功，返回任务通知的通知值

BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry,
                    uint32_t ulBitsToClearOnExit,
                    uint32_t *pulNotificationValue,
                    TickType_t xTicksToWait );

ulBitsToClearOnEntry：函数执行前清零任务通知值那些位。

ulBitsToClearOnExit：表示在函数退出前，清零任务通知值那些位，在清 0 前，接收到的任务通知值会先被保存到形参*pulNotificationValue 中。

pulNotificationValue：用于保存接收到的任务通知值。如果不需要使用，则设置为 NULL 即可。

xTicksToWait：等待消息通知的最大等待时间。

实操

1. 模拟二值信号量

/* USER CODE BEGIN Header_StartSend_Task */
/**
  * @brief  Function implementing the Send_Task thread.
  * @param  argument: Not used
  * @retval None
  */
/* USER CODE END Header_StartSend_Task */
void StartSend_Task(void const * argument)
{
  /* USER CODE BEGIN StartSend_Task */
  /* Infinite loop */
  for(;;)
  {
		// 等待 KEY1 按下
		if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET)
		{
			osDelay(20);
			if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET)
			{
				xTaskNotifyGive(Recieve_TaskHandle);
				printf("任务通知：模拟二值信号量发送成功！\r\n");
			}
			while (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET);
		}
    osDelay(1);
  }
  /* USER CODE END StartSend_Task */
}

/* USER CODE BEGIN Header_StartRecieve_Task */
/**
* @brief Function implementing the Recieve_Task thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_StartRecieve_Task */
void StartRecieve_Task(void const * argument)
{
  /* USER CODE BEGIN StartRecieve_Task */
	uint32_t rev = 0;
  /* Infinite loop */
  for(;;)
  {
		// 等待 KEY2 按下
		if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET)
		{
			osDelay(20);
			if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET)
			{
				rev = ulTaskNotifyTake(pdTRUE,portMAX_DELAY);
				if (rev != 0)
					printf("任务通知：模拟二值信号量接收成功！\r\n");
			}
			while (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET);
		}
    osDelay(1);
  }
  /* USER CODE END StartRecieve_Task */
}

2. 模拟计数型信号量

		// 等待 KEY2 按下
		if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET)
		{
			osDelay(20);
			if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET)
			{
				rev = ulTaskNotifyTake(pdFALSE,portMAX_DELAY);
				if (rev != 0)
					printf("任务通知：模拟二值信号量接收成功，rev = %d ！\r\n",rev);
			}
			while (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET);
		}

3. 模拟事件标志组

/* USER CODE BEGIN Header_Start_Task1 */
/**
  * @brief  Function implementing the Task1 thread.
  * @param  argument: Not used
  * @retval None
  */
/* USER CODE END Header_Start_Task1 */
void Start_Task1(void const * argument)
{
  /* USER CODE BEGIN Start_Task1 */
  /* Infinite loop */
  for(;;)
  {
		// 等待 KEY1 按下
		if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET)
		{
			osDelay(20);
			if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET)
			{
				printf("bit0置为1\r\n");
				xTaskNotify(Task2Handle,0x01,eSetBits);
			}
			while (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET);
		}

		// 等待 KEY2 按下
		if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET)
		{
			osDelay(20);
			if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET)
			{
				printf("bit1置为1\r\n");
				xTaskNotify(Task2Handle,0x02,eSetBits);
			}
			while (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET);
		}
    osDelay(1);
  }
  /* USER CODE END Start_Task1 */
}

/* USER CODE BEGIN Header_Start_Task2 */
/**
* @brief Function implementing the Task2 thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_Start_Task2 */
void Start_Task2(void const * argument)
{
  /* USER CODE BEGIN Start_Task2 */
	uint32_t notify_val = 0, event_bit = 0;
  /* Infinite loop */
  for(;;)
  {
		xTaskNotifyWait(0,0xFFFFFFFF,&notify_val,portMAX_DELAY);
		if (notify_val & 0x01)
			event_bit |= 0x01;
		if (notify_val & 0x02)
			event_bit |= 0x02;
		if (event_bit == (0x01 | 0x02))
		{
			printf("%#x\r\n",event_bit);
			event_bit = 0;
		}
    osDelay(1);
  }
  /* USER CODE END Start_Task2 */
}

4. 模拟邮箱

邮箱就是长度为1的队列

eSetValueWithOverwrite ==》eSetValueWithoutOverwrite 是否覆写

/* USER CODE BEGIN Header_Start_Task1 */
/**
  * @brief  Function implementing the Task1 thread.
  * @param  argument: Not used
  * @retval None
  */
/* USER CODE END Header_Start_Task1 */
void Start_Task1(void const * argument)
{
  /* USER CODE BEGIN Start_Task1 */
  /* Infinite loop */
  for(;;)
  {
		// 等待 KEY1 按下
		if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET)
		{
			osDelay(20);
			if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET)
			{
				printf("按键1按下\r\n");
				xTaskNotify(Task2Handle,1,eSetValueWithOverwrite);
			}
			while (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET);
		}

		// 等待 KEY2 按下
		if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET)
		{
			osDelay(20);
			if (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET)
			{
				printf("按键0按下\r\n");
				xTaskNotify(Task2Handle,2,eSetValueWithOverwrite);
			}
			while (HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_1) == GPIO_PIN_RESET);
		}
    osDelay(1);
  }
  /* USER CODE END Start_Task1 */
}

/* USER CODE BEGIN Header_Start_Task2 */
/**
* @brief Function implementing the Task2 thread.
* @param argument: Not used
* @retval None
*/
/* USER CODE END Header_Start_Task2 */
void Start_Task2(void const * argument)
{
  /* USER CODE BEGIN Start_Task2 */
	uint32_t notify_val = 0;
  /* Infinite loop */
  for(;;)
  {
		xTaskNotifyWait(0,0xFFFFFFFF,&notify_val,portMAX_DELAY);
		printf("%d\r\n",notify_val);
    osDelay(1);
  }
  /* USER CODE END Start_Task2 */
}