FreeRTOS原理剖析：事件标志组

最新推荐文章于 2024-07-31 20:48:45 发布
最新推荐文章于 2024-07-31 20:48:45 发布
阅读量2k 收藏 11
点赞数 1
分类专栏： FreeRTOS原理剖析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31782183/article/details/102301470
版权

1. 事件标志组相关API函数

函数描述
xEventGroupCreate()使用动态方式创建事件标志组
xEventGroupCreateStatic()使用静态方式创建事件标志组
vEventGroupDelete()删除事件标志组
xEventGroupSetBits()将指定的事件位置1， 用于任务中
xEventGroupSetBitsFromISR()将指定的事件位置1，用于中断服务函数
xEventGroupClearBits()将指定的事件位清零， 用于任务
xEventGroupClearBitsFromISR()将指定的事件位清零，用于中断服务函数
xEventGroupGetBits获取当前事件标志组的值(各个事件位的值)，用在任务中
xEventGroupGetBitsFromISR()获取当前事件标志组的值， 用在中断服务中
xEventGroupWaitBits()事件组等待位
xEventGroupSync()事件组同步函数

事件标志组中其它重要的API函数：

函数描述
xTaskRemoveFromUnorderedEventList()将阻塞的任务从事件列表中移除，并添加到就绪列表中
vTaskPlaceOnUnorderedEventList()将任务添加到事件列表中
prvTestWaitCondition()判断当前事件位是否匹配当前等待的事件

2. 事件标志组的基本概念

事件标志组是实现多任务同步的有效机制之一。

事件标志组数据类型：

typedef struct xEventGroupDefinition
{
	/* 储存事件标志组中的事件位 */
	EventBits_t uxEventBits;	

	/* 事件标志组列表 */			
	List_t xTasksWaitingForBits;					

	/* 启用可视化跟踪调试 */
	#if( configUSE_TRACE_FACILITY == 1 )
		UBaseType_t uxEventGroupNumber;
	#endif

	/* 用于标记事件标志组申请内存的方式 */
	#if( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
		uint8_t ucStaticallyAllocated; 
	#endif
} EventGroup_t;

时间标志组中的事件位储存在EventBits_t类型变量中，其中：

typedef TickType_t EventBits_t;

又：

#if( configUSE_16_BIT_TICKS == 1 )
	typedef uint16_t TickType_t;
	#define portMAX_DELAY ( TickType_t ) 0xffff
#else
	typedef uint32_t TickType_t;
	#define portMAX_DELAY ( TickType_t ) 0xffffffffUL
	#define portTICK_TYPE_IS_ATOMIC 1
#endif

可以看出，当configUSE_16_BIT_TICKS为1时，EventBits_t是16位的数据类型，为0时，EventBits_t是32位的数据类型。
当EventBits_t是16位的数据类型，只储存8个事件位，当EventBits_t是32位的数据类型，只储存24个事件位，其高8位用于其他用途。

高8位用途：

#if configUSE_16_BIT_TICKS == 1
	#define eventCLEAR_EVENTS_ON_EXIT_BIT	0x0100U
	#define eventUNBLOCKED_DUE_TO_BIT_SET	0x0200U
	#define eventWAIT_FOR_ALL_BITS			0x0400U
	#define eventEVENT_BITS_CONTROL_BYTES	0xff00U
#else
	/* 表示事件退出时，是否需要删除事件位 */
	#define eventCLEAR_EVENTS_ON_EXIT_BIT	0x01000000UL

	/* 标记该任务事件位设置了，已解除阻塞 */
	#define eventUNBLOCKED_DUE_TO_BIT_SET	0x02000000UL
	
	/* 表示设置的所有事件位都为1才有效 */
	#define eventWAIT_FOR_ALL_BITS			0x04000000UL	

	#define eventEVENT_BITS_CONTROL_BYTES	0xff000000UL
#endif

#define taskEVENT_LIST_ITEM_VALUE_IN_USE	0x80000000UL

3. 事件标志组的创建

函数描述
xEventGroupCreate()动态方式创建事件标志组
xEventGroupCreateStatic()静态方式创建事件标志组
3.1 动态方式创建

使用动态方式创建事件标志组，需要将configSUPPORT_DYNAMIC_ALLOCATION设置为1。

函数原型如下：

/********************************************************
参数：无
返回：事件标志组的句柄
*********************************************************/
EventGroupHandle_t xEventGroupCreate( void )

EventGroupHandle_t是新定义的类型：

typedef void * EventGroupHandle_t;

函数源代码如下：

EventGroupHandle_t xEventGroupCreate( void )
{
	EventGroup_t *pxEventBits;

	/* 为事件标志组申请内存 */
	pxEventBits = ( EventGroup_t * ) pvPortMalloc( sizeof( EventGroup_t ) );

	if( pxEventBits != NULL )
	{
		pxEventBits->uxEventBits = 0;								/* 初始化事件位都为0 */
		vListInitialise( &( pxEventBits->xTasksWaitingForBits ) );	/* 初始化事件标志组的列表 */

		/* 如果使能了静态申请方式 */
		#if( configSUPPORT_STATIC_ALLOCATION == 1 )
		{
			/* 标记不是通过静态申请方式 */
			pxEventBits->ucStaticallyAllocated = pdFALSE;
		}
		#endif /* configSUPPORT_STATIC_ALLOCATION */

		traceEVENT_GROUP_CREATE( pxEventBits );
	}
	else
	{
		traceEVENT_GROUP_CREATE_FAILED();
	}

	return ( EventGroupHandle_t ) pxEventBits;	/* 返回事件标志组的句柄 */
}
3.1 静态方式创建

使用静态方式创建事件标志组，需要将configSUPPORT_STATIC_ALLOCATION设置为1。

函数原型如下：

/********************************************************
参数：pxEventGroupBuffer：指向一个StaticEventGroup_t类型变量的指针
                         用来保存事件标志组结构体
返回：事件标志组的句柄
*********************************************************/
EventGroupHandle_t xEventGroupCreateStatic( StaticEventGroup_t *pxEventGroupBuffer )

函数源代码如下：

EventGroupHandle_t xEventGroupCreateStatic( StaticEventGroup_t *pxEventGroupBuffer )
{
	EventGroup_t *pxEventBits;

	configASSERT( pxEventGroupBuffer );

	/* 获取事件标志组的句柄 */
	pxEventBits = ( EventGroup_t * ) pxEventGroupBuffer;

	if( pxEventBits != NULL )
	{
		pxEventBits->uxEventBits = 0;								/* 初始化事件位 */
		vListInitialise( &( pxEventBits->xTasksWaitingForBits ) );	/* 初始化事件标志列表 */

		/* 如果使能动态创建方式 */
		#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
		{
			/* 标记是使用静态方式创建 */
			pxEventBits->ucStaticallyAllocated = pdTRUE;
		}
		#endif /* configSUPPORT_DYNAMIC_ALLOCATION */

		traceEVENT_GROUP_CREATE( pxEventBits );
	}
	else
	{
		traceEVENT_GROUP_CREATE_FAILED();
	}

	return ( EventGroupHandle_t ) pxEventBits;
}

4. 事件标志组的删除

4.1 函数vEventGroupDelete()

事件标志组删除使用函数vEventGroupDelete()。

函数原型如下：

/********************************************************
参数：xEventGroup ：事件标志组句柄
返回：无
*********************************************************/
void vEventGroupDelete( EventGroupHandle_t xEventGroup )

函数源代码如下：

void vEventGroupDelete( EventGroupHandle_t xEventGroup )
{
	EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;
	const List_t *pxTasksWaitingForBits = &( pxEventBits->xTasksWaitingForBits );

	vTaskSuspendAll();	/* 挂起调度器 */
	{
		traceEVENT_GROUP_DELETE( xEventGroup );

		/* 当事件列表中存在列表项，即存在阻塞的任务 */
		while( listCURRENT_LIST_LENGTH( pxTasksWaitingForBits ) > ( UBaseType_t ) 0 )
		{
			configASSERT( pxTasksWaitingForBits->xListEnd.pxNext != ( ListItem_t * ) &( pxTasksWaitingForBits->xListEnd ) );
	
			/* 将任务从事件列表中移除，添加到就绪列表中 */		
			( void ) xTaskRemoveFromUnorderedEventList( pxTasksWaitingForBits->xListEnd.pxNext, eventUNBLOCKED_DUE_TO_BIT_SET );
		}

		/* 如果使能动态申请方式，没有使能静态申请方式 */
		#if( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 0 ) )
		{
			vPortFree( pxEventBits );
		}
		/* 如果使能了动态申请方式和静态申请方式 */
		#elif( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
		{
			/* 如果不是使用静态方式创建时间标志组 */
			if( pxEventBits->ucStaticallyAllocated == ( uint8_t ) pdFALSE )
			{
				vPortFree( pxEventBits );
			}
			/* 如果使用静态方式创建事件标志组，则需要用户手动释放内存 */
			else
			{
				mtCOVERAGE_TEST_MARKER();
			}
		}
		#endif /* configSUPPORT_DYNAMIC_ALLOCATION */
	}
	( void ) xTaskResumeAll();	/* 恢复调度器 */
}
4.2 函数xTaskRemoveFromUnorderedEventList()

该函数将阻塞的任务从事件列表中移除，并添加到就绪列表中，如果恢复的任务优先级比当前运行任务的优先级高，则标记需要进行任务切换。

函数原型如下：

/********************************************************
参数：pxEventListItem：某任务的事件列表项
          xItemValue：时间列表项的项值
返回： pdTRUE：可进行任务切换
     pdFALSE：不需要进行任务切换
*********************************************************/
BaseType_t xTaskRemoveFromUnorderedEventList( ListItem_t * pxEventListItem, const TickType_t xItemValue )

函数源代码如下：

BaseType_t xTaskRemoveFromUnorderedEventList( ListItem_t * pxEventListItem, const TickType_t xItemValue )
{
	TCB_t *pxUnblockedTCB;
	BaseType_t xReturn;

	configASSERT( uxSchedulerSuspended != pdFALSE );

	/* 
	 * taskEVENT_LIST_ITEM_VALUE_IN_USE为0x80000000UL 
	 * 	xItemValue等于eventUNBLOCKED_DUE_TO_BIT_SET，即为0x02000000UL
	 */
	listSET_LIST_ITEM_VALUE( pxEventListItem, xItemValue | taskEVENT_LIST_ITEM_VALUE_IN_USE );

	/* 获取因该事件而阻塞任务的TCB */
	pxUnblockedTCB = ( TCB_t * ) listGET_LIST_ITEM_OWNER( pxEventListItem );
	
	configASSERT( pxUnblockedTCB );
	
	( void ) uxListRemove( pxEventListItem );	/* 将该事件从事件列表中删除 */
	
	( void ) uxListRemove( &( pxUnblockedTCB->xStateListItem ) );	/* 删除任务的状态信息，如阻塞态 */
	prvAddTaskToReadyList( pxUnblockedTCB );	/* 将任务添加到就绪列表中 */

	/* 当前阻塞的任务优先级大于当前运行的任务 */
	if( pxUnblockedTCB->uxPriority > pxCurrentTCB->uxPriority )
	{
		xReturn = pdTRUE;
		xYieldPending = pdTRUE;	/* 标记调度器挂起 */
	}
	else
	{
		xReturn = pdFALSE;
	}

	return xReturn;
}

5. 事件标志位的设置

函数描述
xEventGroupSetBits()将指定的事件位置1， 用在任务中
xEventGroupSetBitsFromISR()将指定的事件位置1，用在中断服务函数中
5.1 函数xEventGroupSetBits()

函数原型如下：

/********************************************************
参数：xEventGroup：事件标志组的句柄
     uxBitsToSet：需要设置的事件位
返回：EventBits_t：事件位
*********************************************************/
EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup, 
  								const EventBits_t  uxBitsToSet )

函数源代码如下：

EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet )
{
	ListItem_t *pxListItem, *pxNext;
	ListItem_t const *pxListEnd;
	List_t *pxList;
	EventBits_t uxBitsToClear = 0, uxBitsWaitedFor, uxControlBits;
	EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;
	BaseType_t xMatchFound = pdFALSE;

	configASSERT( xEventGroup );
	configASSERT( ( uxBitsToSet & eventEVENT_BITS_CONTROL_BYTES ) == 0 );

	pxList = &( pxEventBits->xTasksWaitingForBits );	/* 获取事件标志组对应的事件列表 */
	pxListEnd = listGET_END_MARKER( pxList ); 			/* 获取列表中最后一个列表项，即Mini列表项 */
	
	vTaskSuspendAll();	/* 挂起任务调度器 */
	{
		traceEVENT_GROUP_SET_BITS( xEventGroup, uxBitsToSet );

		pxListItem = listGET_HEAD_ENTRY( pxList );	/* 得到第一个列表项，即第一个因事件而阻塞的任务 */
		pxEventBits->uxEventBits |= uxBitsToSet;	/* 设置事件位 */

		/* 如果事件列表中有列表项，即有阻塞任务，则进入循环中 */
		while( pxListItem != pxListEnd )
		{
			pxNext = listGET_NEXT( pxListItem );	/* 获取下一个任务 */
			uxBitsWaitedFor = listGET_LIST_ITEM_VALUE( pxListItem );	/* 获取对应任务的项值 */
			xMatchFound = pdFALSE;

			/* 
			 * eventEVENT_BITS_CONTROL_BYTES为0xff000000UL 
			 * 将高8位和事件位分别存在uxControlBits和uxBitsWaitedFor 
			 */
			uxControlBits = uxBitsWaitedFor & eventEVENT_BITS_CONTROL_BYTES;
			uxBitsWaitedFor &= ~eventEVENT_BITS_CONTROL_BYTES;

			/* 如果不要等待所有的事件位都为1才有效 */
			if( ( uxControlBits & eventWAIT_FOR_ALL_BITS ) == ( EventBits_t ) 0 )
			{
				/* 
				 * 每个任务的事件位和控制位(高8位)存在任务的项值中，即uxBitsWaitedFor
				 * pxEventBits->uxEventBits表示用户设置了某事件位，存在事件标志组中
				 */
				if( ( uxBitsWaitedFor & pxEventBits->uxEventBits ) != ( EventBits_t ) 0 )
				{
					xMatchFound = pdTRUE;
				}
				else
				{
					mtCOVERAGE_TEST_MARKER();
				}
			}
			/* 需要等待所有的事件位，通过eventWAIT_FOR_ALL_BITS决定 */
			else if( ( uxBitsWaitedFor & pxEventBits->uxEventBits ) == uxBitsWaitedFor )
			{
				/* 所有的事件位都设置了 */
				xMatchFound = pdTRUE;
			}
			else
			{
				/* 运行到这里，表示需要等待所有的事件位，但其中有事件位不存在 */
			}

			/* 如果匹配成功 */
			if( xMatchFound != pdFALSE )
			{
				/* 
				 * eventCLEAR_EVENTS_ON_EXIT_BIT为0x01000000UL
				 * 表示事件退出时，是否需要删除事件位
				 */
				if( ( uxControlBits & eventCLEAR_EVENTS_ON_EXIT_BIT ) != ( EventBits_t ) 0 )
				{
					uxBitsToClear |= uxBitsWaitedFor;	/* 获取要删除的位 */
				}
				else
				{
					mtCOVERAGE_TEST_MARKER();
				}

				/* 将任务从事件列表中移除，添加到就绪列表中 */	
				( void ) xTaskRemoveFromUnorderedEventList( pxListItem, pxEventBits->uxEventBits | eventUNBLOCKED_DUE_TO_BIT_SET );
			}
			pxListItem = pxNext;	/* 指向下一个阻塞的任务 */
		}
		pxEventBits->uxEventBits &= ~uxBitsToClear;	/* 删除事件位 */
	}
	( void ) xTaskResumeAll();	/* 恢复调度器 */

	return pxEventBits->uxEventBits;	/* 返回事件位 */
}
5.2 函数xEventGroupSetBitsFromISR()

该函数是中断版的事件位设置，用于中断函数。

函数原型如下：

/********************************************************
参数：xEventGroup：事件标志组的句柄
返回：EventBits_t：事件位
*********************************************************/
EventBits_t xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup )

函数源代码如下：

EventBits_t xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup )
{
	UBaseType_t uxSavedInterruptStatus;
	EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;
	EventBits_t uxReturn;

	/* 关闭中断，进入临界区 */
	uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();	
	{
		uxReturn = pxEventBits->uxEventBits;
	}
	/* 开启中断，退出临界区 */
	portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );

	return uxReturn;
}

5. 事件标志位的清除

函数描述
xEventGroupClearBits()将指定的事件位清零， 用在任务中
xEventGroupClearBitsFromISR()将指定的事件位清零，用在中断服务函数中
5.1 函数xEventGroupClearBits()

函数原型如下：

/********************************************************
参数：xEventGroup：事件标志组的句柄
   uxBitsToClear：需要清除的事件位
返回：EventBits_t：事件位
*********************************************************/
EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear )

函数源代码如下：

EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear )
{
	EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;
	EventBits_t uxReturn;

	configASSERT( xEventGroup );
	configASSERT( ( uxBitsToClear & eventEVENT_BITS_CONTROL_BYTES ) == 0 );

	taskENTER_CRITICAL();	/* 进入临界区 */
	{
		traceEVENT_GROUP_CLEAR_BITS( xEventGroup, uxBitsToClear );

		/* 获取事件标志位 */
		uxReturn = pxEventBits->uxEventBits;

		/* 清除事件标志位 */
		pxEventBits->uxEventBits &= ~uxBitsToClear;
	}
	taskEXIT_CRITICAL();	/* 退出临界区 */

	return uxReturn;
}
5.2 函数xEventGroupClearBitsFromISR()

清除事件标志组中事件位的中断版本，用于中断函数中。

函数原型如下：

/********************************************************
参数：xEventGroup：事件标志组的句柄
   uxBitsToClear：需要清除的事件位
返回：BaseType_t：事件位
*********************************************************/
BaseType_t xEventGroupClearBitsFromISR( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear )

函数源代码如下：

BaseType_t xEventGroupClearBitsFromISR( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear )
{
	BaseType_t xReturn;

	traceEVENT_GROUP_CLEAR_BITS_FROM_ISR( xEventGroup, uxBitsToClear );
	
	xReturn = xTimerPendFunctionCallFromISR( vEventGroupClearBitsCallback, ( void * ) xEventGroup, ( uint32_t ) uxBitsToClear, NULL );

	return xReturn;
}

6. 事件标志位的获取

函数描述
xEventGroupGetBits获取当前事件标志组的值(各个事件位的值)，用在任务中
xEventGroupGetBitsFromISR()获取当前事件标志组的值， 用在中断服务中
6.1 函数xEventGroupGetBits()

函数通过宏定义，其调用函数xEventGroupClearBits()，如下：

#define xEventGroupGetBits( xEventGroup ) xEventGroupClearBits( xEventGroup, 0 )

通过函数xEventGroupClearBits()，可以返回当前事件位，同时设置清除的事件位为0，即不清除事件位。
通过函数xEventGroupGetBits()，并不会阻塞函数，而是通过其返回值判断来执行相应的程序。

6.2 函数xEventGroupGetBitsFromISR()

该函数获取事件位，用于中断服务函数中。

函数原型如下：

/********************************************************
参数：xEventGroup：事件标志组的句柄
返回：EventBits_t：事件位
*********************************************************/
EventBits_t xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup )

函数源代码如下：

EventBits_t xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup )
{
	UBaseType_t uxSavedInterruptStatus;
	EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;
	EventBits_t uxReturn;

	/* 进入临界区 */
	uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
	{
		uxReturn = pxEventBits->uxEventBits;
	}
	/* 退出临界区 */
	portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );

	return uxReturn;
}

7. 事件标志位等待

7.1 函数xEventGroupWaitBits()

函数xEventGroupWaitBits()可以在阻塞状态下等待事件组中一个或者多个事件。

函数原型如下：

/********************************************************
参数：
     xEventGroup：事件标志组的句柄
 uxBitsToWaitFor：需要等待的事件位
    xClearOnExit：若为pdTURE,退出时，所有事件位删除
                  若为pdFALSE，退出时，事件位不删除
 xWaitForAllBits：若为pdTURE,所有事件位都为1或阻塞时间到，则有效
                  若为pdFALSE，任意其中一个为1或阻塞时间到，则有效
    xTicksToWait：设置阻塞事件，单位为节拍数
返回：EventBits_t：事件位
*********************************************************/
EventBits_t xEventGroupWaitBits(EventGroupHandle_t xEventGroup, 
								const EventBits_t  uxBitsToWaitFor, 
								const BaseType_t   xClearOnExit, 
								const BaseType_t   xWaitForAllBits, 
								TickType_t         xTicksToWait )

函数源代码如下：

EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToWaitFor, const BaseType_t xClearOnExit, const BaseType_t xWaitForAllBits, TickType_t xTicksToWait )
{
	EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;
	EventBits_t uxReturn, uxControlBits = 0;
	BaseType_t xWaitConditionMet, xAlreadyYielded;
	BaseType_t xTimeoutOccurred = pdFALSE;

	configASSERT( xEventGroup );
	configASSERT( ( uxBitsToWaitFor & eventEVENT_BITS_CONTROL_BYTES ) == 0 );
	configASSERT( uxBitsToWaitFor != 0 );
	
	/* 如果使能函数xTaskGetSchedulerState()或启动软件定时器功能 */
	#if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
	{
		configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );
	}
	#endif

	vTaskSuspendAll();	/* 挂起任务调度器 */
	{
		const EventBits_t uxCurrentEventBits = pxEventBits->uxEventBits;

		/* 判断当前事件位是否匹配 */
		xWaitConditionMet = prvTestWaitCondition( uxCurrentEventBits, uxBitsToWaitFor, xWaitForAllBits );

		/* 如果当前事件位符合要求 */
		if( xWaitConditionMet != pdFALSE )
		{
			uxReturn = uxCurrentEventBits;
			xTicksToWait = ( TickType_t ) 0;

			/* 如果退出时，需要删除事件位，则进入 */
			if( xClearOnExit != pdFALSE )
			{
				pxEventBits->uxEventBits &= ~uxBitsToWaitFor;
			}
			else
			{
				mtCOVERAGE_TEST_MARKER();
			}
		}
		/* 如果设置阻塞时间为0 */
		else if( xTicksToWait == ( TickType_t ) 0 )
		{
			uxReturn = uxCurrentEventBits;
		}
		else
		{
			/* 如果退出时，需要删除事件位，则进入 */
			if( xClearOnExit != pdFALSE )
			{
				/* 设置相应的控制位，高8位中 */
				uxControlBits |= eventCLEAR_EVENTS_ON_EXIT_BIT;
			}
			else
			{
				mtCOVERAGE_TEST_MARKER();
			}
			/* 如果需要等待所有的事件位为1，则有效 */
			if( xWaitForAllBits != pdFALSE )
			{
				/* 设置相应的控制位，在高8位中 */
				uxControlBits |= eventWAIT_FOR_ALL_BITS;
			}
			else
			{
				mtCOVERAGE_TEST_MARKER();
			}

			/* 将任务添加到相应的事件列表中 */
			vTaskPlaceOnUnorderedEventList( &( pxEventBits->xTasksWaitingForBits ), ( uxBitsToWaitFor | uxControlBits ), xTicksToWait );

			uxReturn = 0;

			traceEVENT_GROUP_WAIT_BITS_BLOCK( xEventGroup, uxBitsToWaitFor );
		}
	}
	xAlreadyYielded = xTaskResumeAll();	/* 恢复任务调度器，可能会执行任务切换 */

	/* 如果设置的阻塞时钟节拍数不为0 */
	if( xTicksToWait != ( TickType_t ) 0 )
	{
		/* 恢复调度器时没有进行任务切换 */
		if( xAlreadyYielded == pdFALSE )
		{
			portYIELD_WITHIN_API();	/* 执行任务切换 */
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}

		uxReturn = uxTaskResetEventItemValue();	/* 获取事件列表项的项值 */

		/* eventUNBLOCKED_DUE_TO_BIT_SET用来表示任务已经解挂 */
		if( ( uxReturn & eventUNBLOCKED_DUE_TO_BIT_SET ) == ( EventBits_t ) 0 )
		{
			taskENTER_CRITICAL();	/* 进入临界区 */
			{

				uxReturn = pxEventBits->uxEventBits;

				/* 如果事件位符合匹配 */
				if( prvTestWaitCondition( uxReturn, uxBitsToWaitFor, xWaitForAllBits ) != pdFALSE )
				{
					/* 如果设置事件退出时清除事件位 */
					if( xClearOnExit != pdFALSE )
					{
						pxEventBits->uxEventBits &= ~uxBitsToWaitFor;
					}
					else
					{
						mtCOVERAGE_TEST_MARKER();
					}
				}
				else
				{
					mtCOVERAGE_TEST_MARKER();
				}
			}
			taskEXIT_CRITICAL();	/* 退出临界区 */

			xTimeoutOccurred = pdFALSE;
		}
		else
		{
			/* 执行到这里，表示任务已经解除阻塞态 */
		}
		
		uxReturn &= ~eventEVENT_BITS_CONTROL_BYTES;	/* 清除控制位 */
	}
	traceEVENT_GROUP_WAIT_BITS_END( xEventGroup, uxBitsToWaitFor, xTimeoutOccurred );

	return uxReturn;
}
7.2 函数prvTestWaitCondition()

函数原型如下：

/********************************************************
参数：
     xEventGroup：事件标志组的句柄
 uxBitsToWaitFor：需要等待的事件位
    xClearOnExit：若为pdTURE,退出时，所有事件位删除
                  若为pdFALSE，退出时，事件位不删除
 xWaitForAllBits：若为pdTURE,所有事件位都为1或阻塞时间到，则有效
                  若为pdFALSE，任意其中一个为1或阻塞时间到，则有效
    xTicksToWait：设置阻塞事件，单位为节拍数
返回：EventBits_t：事件位
*********************************************************/
static BaseType_t prvTestWaitCondition( const EventBits_t uxCurrentEventBits, const EventBits_t uxBitsToWaitFor, const BaseType_t xWaitForAllBits )

函数源代码如下：

static BaseType_t prvTestWaitCondition( const EventBits_t uxCurrentEventBits, const EventBits_t uxBitsToWaitFor, const BaseType_t xWaitForAllBits )
{
	BaseType_t xWaitConditionMet = pdFALSE;

	/* 如果某个事件位为1，则有效 */
	if( xWaitForAllBits == pdFALSE )
	{
		/* 如果匹配到某个事件位 */
		if( ( uxCurrentEventBits & uxBitsToWaitFor ) != ( EventBits_t ) 0 )
		{
			xWaitConditionMet = pdTRUE;
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}
	}
	else	/* 要全部设置的事件位为1，则有效 */
	{
		/* 如果所有的事件位都为1 */
		if( ( uxCurrentEventBits & uxBitsToWaitFor ) == uxBitsToWaitFor )
		{
			xWaitConditionMet = pdTRUE;
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}
	}

	return xWaitConditionMet;
}
7.3 函数vTaskPlaceOnUnorderedEventList()
void vTaskPlaceOnUnorderedEventList( List_t * pxEventList, const TickType_t xItemValue, const TickType_t xTicksToWait )
{
	configASSERT( pxEventList );

	configASSERT( uxSchedulerSuspended != 0 );

	/* 设置相应的列表项中的项值 */
	listSET_LIST_ITEM_VALUE( &( pxCurrentTCB->xEventListItem ), xItemValue | taskEVENT_LIST_ITEM_VALUE_IN_USE );

	/* 将任务插入到事件列表中 */
	vListInsertEnd( pxEventList, &( pxCurrentTCB->xEventListItem ) );

	/* 添加当前任务到延时列表中 */
	prvAddCurrentTaskToDelayedList( xTicksToWait, pdTRUE );
}

8. 事件的同步

函数xEventGroupSync()能使多个任务彼此之间同步。

函数原型如下：

/********************************************************
参数：
     xEventGroup：事件标志组的句柄
     uxBitsToSet：设置事件位
 uxBitsToWaitFor：需要等待的事件位
    xTicksToWait：设置阻塞事件，单位为节拍数
返回：EventBits_t：事件位
*********************************************************/
EventBits_t xEventGroupSync(EventGroupHandle_t xEventGroup, 
							const EventBits_t  uxBitsToSet, 
							const EventBits_t  uxBitsToWaitFor, 
							TickType_t         xTicksToWait )

函数源代码如下：

EventBits_t xEventGroupSync( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, const EventBits_t uxBitsToWaitFor, TickType_t xTicksToWait )
{
	EventBits_t uxOriginalBitValue, uxReturn;
	EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;
	BaseType_t xAlreadyYielded;
	BaseType_t xTimeoutOccurred = pdFALSE;

	configASSERT( ( uxBitsToWaitFor & eventEVENT_BITS_CONTROL_BYTES ) == 0 );
	configASSERT( uxBitsToWaitFor != 0 );
	
	/* 如果使能函数xTaskGetSchedulerState()或启动软件定时器功能 */
	#if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )
	{
		configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );
	}
	#endif

	vTaskSuspendAll();	/* 挂起调度器 */
	{
		uxOriginalBitValue = pxEventBits->uxEventBits;	/* 记录原有事件位 */

		( void ) xEventGroupSetBits( xEventGroup, uxBitsToSet );

		/* 如果所有事件位都为1 */
		if( ( ( uxOriginalBitValue | uxBitsToSet ) & uxBitsToWaitFor ) == uxBitsToWaitFor )
		{
			uxReturn = ( uxOriginalBitValue | uxBitsToSet );

			pxEventBits->uxEventBits &= ~uxBitsToWaitFor;	/* 清除事件位 */

			xTicksToWait = 0;
		}
		else
		{
			/* 如果设置阻塞时间xTicksToWait不为0 */
			if( xTicksToWait != ( TickType_t ) 0 )
			{
				traceEVENT_GROUP_SYNC_BLOCK( xEventGroup, uxBitsToSet, uxBitsToWaitFor );

				/* 将任务添加到相应的事件列表中 */
				vTaskPlaceOnUnorderedEventList( &( pxEventBits->xTasksWaitingForBits ), ( uxBitsToWaitFor | eventCLEAR_EVENTS_ON_EXIT_BIT | eventWAIT_FOR_ALL_BITS ), xTicksToWait );

				uxReturn = 0;
			}
			else
			{
				uxReturn = pxEventBits->uxEventBits;
			}
		}
	}
	xAlreadyYielded = xTaskResumeAll();	/* 恢复调度器，有可能进行任务切换 */

	/* 如果设置阻塞时间xTicksToWait不为0 */
	if( xTicksToWait != ( TickType_t ) 0 )
	{
		/* 如果没有进行任务切换 */
		if( xAlreadyYielded == pdFALSE )
		{
			portYIELD_WITHIN_API();
		}
		else
		{
			mtCOVERAGE_TEST_MARKER();
		}

		/* 获取事件列表项的项值 */
		uxReturn = uxTaskResetEventItemValue();

		/* eventUNBLOCKED_DUE_TO_BIT_SET用来任务已经解挂 */
		if( ( uxReturn & eventUNBLOCKED_DUE_TO_BIT_SET ) == ( EventBits_t ) 0 )
		{
			/* 进入临界区 */
			taskENTER_CRITICAL();
			{
				uxReturn = pxEventBits->uxEventBits;

				/* 如果设置事件退出时清除事件位 */
				if( ( uxReturn & uxBitsToWaitFor ) == uxBitsToWaitFor )
				{
					pxEventBits->uxEventBits &= ~uxBitsToWaitFor;
				}
				else
				{
					mtCOVERAGE_TEST_MARKER();
				}
			}
			taskEXIT_CRITICAL();	/* 退出临界区 */

			xTimeoutOccurred = pdTRUE;
		}
		else
		{
			/* 执行到这里，表示任务已经解除阻塞态 */
		}

		uxReturn &= ~eventEVENT_BITS_CONTROL_BYTES;	/*  清除高8位的控制位 */
	}

	traceEVENT_GROUP_SYNC_END( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTimeoutOccurred );

	return uxReturn;
}

当使用事件组进行任务同步时，有：

  • 参与同步的任务分配唯一的事件位。
  • 每个任务达到同步点设置自己的事件位。
  • 当事件设置事件位后，任务会进入阻塞态以等待其他任务的同步。

假设有任务A、任务B、任务C三个任务。任务A的执行是需要任务B、任务C同步后才进行下一步。我们不能使用函数xEventGroupSetBits()和函数xEventGroupWaitBits()。

  • 每个任务任务获取事件位都是单独操作的，假如任务B和任务C此时获得了事件位，即这两个任务达到同步，此时他们会处于阻塞态，等待任务C的同步。
  • 任务A达到同步点，并调用函数xEventGroupWaitBits()设置事件位，一旦设置任务A的事件位，任务B和任务C事件位被删除，由于此时任务A没有进入阻塞态，不会清除事件位，任务A和任务B离开各自同步点，同步失败。

而对于函数xEventGroupSync()即使任务B和任务C事件位被删除，但记录了原有的事件位uxOriginalBitValue，通过变量uxOriginalBitValue判断达到任务A同步。

千行代码
关注
专栏目录
【FreeRTOS】事件组的使用
凉开水白菜的博客
11-07 756
事件组与信号量类似，我们可以把事件组理解为一个整数（在FreeRTOSConfig.h文件中），用其中一位来表示一个任务的状态0-1，我们可以通过这些任务的组合来进行任务执行的判断标准；他与信号量不同的是事件组能针对1对多，多对多的任务，例如我们按键按下事件组可以通知多个任务开始执行，或者某个任务可以等待多个任务完成后在执行等；如果configUSE_16_BIT_TICKS是1，那么这个整数就是16位的，低8位用来表示事件。
FreeRTOS_事件组的使用
only_print的博客
04-21 498
之前我们学习了队列和队列延伸出的信号量、互斥量的使用，但是这些有些局限性，只能同时进行一项任务，我们这次实验来学习如何同一时间使多个任务（。本次实验采用STM32F103ZET6主芯片的开发板，使用HAL库开发。
FreeRTOS中的事件组：xEventGroupCreate、xEventGroupSetBits、xEventGroupWaitBits、xEventGroupSetBitsFromISR
最新发布
浮若于心
07-31 785
假设我们有一个中断服务例程（ISR），它需要通知一个任务某个事件发生，可以使用。： 在中断上下文中设置事件组中的一个或多个位。：等待指定的位被设置，带有可选的超时参数。：设置事件组中的一个或多个位。：事件组在调用此函数之前的值。：清除事件组中的一个或多个位。：事件组在调用此函数之前的值。：满足条件时事件组的值。：创建一个新的事件组。：获取当前事件组的值。
【内存管理】freeRTOS的5种内存管理的实现原理及源码分析
一个专注于嵌入式IoT领域的架构师，深耕IoT领域多年，深度掌握IoT领域的相关技术栈，包括但不限于RTOS内核的实现及其移植、硬件驱动移植开发、网络通讯协议开发、编译构建原理及其实现、底层汇编及编译原理、编译优化及代码重构、嵌入式IoT系统的架构设计等。
11-07 7195
本文主要结合源码介绍了freeRTOS的5种内存管理的策略。
【ESP32--FreeRTOS 任务间的同步与通信】
欢迎私信、留言交流
09-06 620
本文主要记录【ESP32--FreeRTOS 任务间的同步与通信】的学习记录，邮件，信号量，事件组的使用和优缺点以及应用场景
FreeRTOS事件组----任务同步
weixin_45045399的博客
01-03 2906
有时，应用程序的设计需要两个或多个任务才能彼此同步。例如，考虑一个设计，其中任务A接收一个事件，然后将事件所需的一些处理提供给其他三个任务：任务B，任务C和任务D。如果任务A在任务B，C和D已经全部完成了对上一个事件的处理，那么所有这四个任务将需要彼此同步。每个任务的同步点将在该任务完成其处理之后，并且无法继续进行，直到其他每个任务都完成了相同的任务。在所有四个任务都达到其同步点之后，任务A才能接...
stm32f103 FreeRTOS任务通知模拟事件标志组实验.zip
03-07
本实验主要探讨如何在STM32F103上移植并使用FreeRTOS，并利用任务通知功能模拟事件标志组，以实现更高效的任务间通信。FreeRTOS任务通知是一种灵活的机制，允许任务之间传递简单的状态信息，而无需复杂的同步原语。 ...
FreeRTOS事件标志组
12-18
通过学习和分析这个示例，开发者可以更好地理解事件标志组的工作原理，并将其应用到自己的项目中。 在实际开发中，正确地使用FreeRTOS事件标志组能有效避免资源竞争，提高程序的可读性和可维护性。它不仅可以用于...
9. 事件标志组.zip
01-17
事件标志组"的源代码，我们可以学习到如何在实际项目中应用这些概念，理解事件标志组在FreeRTOS中的工作原理，从而提升嵌入式系统设计和调试的能力。记住，每个示例都可能包含不同的应用场景，例如多任务协作、...
STM32单片机FreeRTOS实战：掌握FreeRTOS原理和应用技巧，打造多任务嵌入式系统
[STM32单片机FreeRTOS实战：掌握FreeRTOS原理和应用技巧，打造多任务嵌入式系统](https://img-blog.csdnimg.cn/3ce6c8891127453d93c9442c628b4e10.png) # 1. FreeRTOS简介与原理 FreeRTOS（Free Real-Time ...
FreeRTOS源码分析-10 事件标志组_#define eventclear_events_on_exit_bit 0x01000000ul
hnsgsdsagaaq的博客
04-04 216
注意，xEvetnGroupSync函数是一个阻塞函数，即在等待期间会阻塞当前任务的执行。如果有其他任务在等待相同的事件组，则它们可能会被唤醒以执行后续操作。因此，在使用xEvetnGroupSync函数时需要谨慎设计，以避免出现死锁或优先级反转等问题。
【FreeRTOS】10 事件标志组
小白白学电子
07-19 1441
本节我们来讲讲freeRTOS的事件标志组。它也是一种用于任务间通信和同步的机制，和信号量有一些相似的功能，但也有自己的特点。
Free的事件标志组
qq_44318582的博客
04-27 195
一、简介 使用信号量来同步的话任务只能与单个的事件或任务进行同步，但是有时候需要多个事件或者多个任务进行同步，这时候就不适合使用信号量。 1、事件位 事件位用来表示某个事件是否发生，事件位通常用作事件标志。比如以下的几个例子： 当收到一条消息并且把这条消息处理掉以后就可以将某个位(标志)置 1，当队列中没有消息需要处理的时候就可以将这个位(标志)置 0。 当把队列中的消息通过网络发送输出以后就可以将某个位(标志)置 1，当没有数据需要从网络发送出去的话就将这个位(标志)置 0。 现在需要向网络中发送一个心
FreeRTOS学习笔记 & 事件标志组
hulongjie123的博客
04-29 489
事件通讯是一种任务之间的通讯机制，实现任务之间信息同步事件通讯只能实现事件类型数据通讯，不提供数据传输功能（与消息队列不同）事件通讯可以等待单个或多个事件的发生，来唤醒阻塞任务进行处理。
FreeRTOS学习-事件组（Event Groups）
Duran.L的专栏
04-16 1575
事件组是FreeRTOS提供的另一种同步机制。允许任务进入blocked状态，等待一个或者多个事件；事件组会唤醒所有等待这个事件或事件组的任务。所以，事件组通常用于多个任务（中断）之间的同步。
FreeRTOS个人笔记-事件
weixin_47077788的博客
07-26 758
根据个人的学习方向，学习FreeRTOS。由于野火小哥把FreeRTOS讲得比较含蓄，打算在本专栏尽量细化一点。作为个人笔记，仅供参考或查阅。配套资料FreeRTOS内核实现与应用开发实战指南、野火FreeRTOS配套视频源码、b站野火FreeRTOS视频。搭配来看更佳哟！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
FREERTOS事件标志组
stone_mj的博客
04-06 1363
FREERTOS事件组描述
FreeRTOS_第20章_事件
a1103688841的博客
12-04 541
文章目录简介：FreeRTOS 提供的事件具有如下特点事件变量和结构体事件结构体和一些事件现场的宏函数详解事件组创建 xEventGroupCreate( )事件删除函数 vEventGroupDelete()事件组置位函数，寻找相应等待事件的任务并唤醒 xEventGroupSetBits()将任务移除事件等待列表添加到就绪列表xTaskRemoveFromUnorderedEventList（）等待事件函数xEventGroupWaitBits()代码详解 简介： 学习[野火®]《FreeRTOS 内核
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值