• FreeRTOS个人笔记-任务通知

    根据个人的学习方向，学习FreeRTOS。由于野火小哥把FreeRTOS讲得比较含蓄，打算在本专栏尽量细化一点。作为个人笔记，仅供参考或查阅。

    配套资料：FreeRTOS内核实现与应用开发实战指南、野火FreeRTOS配套视频源码、b站野火FreeRTOS视频。搭配来看更佳哟！！！

    任务通知

    每个任务都有一个 32 位的通知值，在大多数情况下，任务通知可以替代二值信号量、计数信号量、事件组，也可以替代长度为 1 的队列（可以保存一个 32 位整数或指针值）。
    想要使用任务通知，必须将 FreeRTOSConfig.h 中的宏定义 configUSE_TASK_NOTIFICATIONS 设置为 1，其实FreeRTOS 默认是为 1 的， 所以任务通知是默认使能的。
    FreeRTOS 提供以下几种方式发送通知给任务 ：
     发送通知给任务，如果有通知未读，不覆盖通知值。
     发送通知给任务，直接覆盖通知值。
     发送通知给任务，设置通知值的一个或者多个位，可以当做事件组来使用。
     发送通知给任务，递增通知值，可以当做计数信号量使用。
    通过对以上任务通知方式的合理使用，可以在一定场合下替代 FreeRTOS 的信号量，队列、事件组等。
    消息通知虽然处理更快，RAM 开销更小，但也有以下限制 ：
     只能有一个任务接收通知消息，因为必须指定接收通知的任务。
     只有等待通知的任务可以被阻塞，发送通知的任务，在任何情况下都不会因为发送失败而进入阻塞态。

    任务通知可以在任务中向指定任务发送通知，也可以在中断中向指定任务发送通知，FreeRTOS 的每个任务都有一个 32 位的通知值，任务控制块中的成员变量 ulNotifiedValu就是这个通知值。
    只有在任务中可以等待通知，而不允许在中断中等待通知。如果任务等待的通知暂时无效，任务会根据用户指定的阻塞超时时间进入阻塞状态，我们可以将等待通知的任务看作是消费者；
    其它任务和中断可以向等待通知的任务发送通知，发送通知的任务和中断服务函数可以看作是生产者，当其他任务或者中断向这个任务发送任务通知，任务获得通知以后，该任务就会从阻塞态中解除，这与 FreeRTOS 中内核的其他通信机制一致。


    ulNotifiedValue为任务通知的值，可以保存一个 32 位整数或指针值。
    ucNotifyState为务通知状态，用于标识任务是否在等待通知。

     

    发送任务通知

    xTaskGenericNotify()用于发送任务通知。

    1. #if( configUSE_TASK_NOTIFICATIONS == 1 )
    2.  
    3. 	/*
    4. 	xTaskToNotify，被通知的任务句柄，指定通知的任务
    5. 	ulValue，发送的通知值
    6. 	eAction，指明更新通知值的方式
    7. 	pulPreviousNotificationValue，任务原本的通知值返回
    8. 	*/
    9. 	BaseType_t xTaskGenericNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue )
    10. 	{
    11. 		TCB_t * pxTCB;
    12. 		BaseType_t xReturn = pdPASS;
    13. 		uint8_t ucOriginalNotifyState;
    14.  
    15. 		configASSERT( xTaskToNotify );
    16. 		pxTCB = ( TCB_t * ) xTaskToNotify;
    17.  
    18. 		taskENTER_CRITICAL();
    19. 		{
    20. 			if( pulPreviousNotificationValue != NULL )
    21. 			{
    22. 				*pulPreviousNotificationValue = pxTCB->ulNotifiedValue;		/* 回传未被更新的任务通知值 */
    23. 			}
    24.  
    25. 			ucOriginalNotifyState = pxTCB->ucNotifyState;					/* 获取任务通知的状态，看看任务是否在等待通知，方便在发送通知后恢复任务 */
    26.  
    27. 			pxTCB->ucNotifyState = taskNOTIFICATION_RECEIVED;				/* 不管状态是怎么样的，反正现在发送通知，任务就收到任务通知 */
    28.  
    29. 			switch( eAction )												/* 指定更新任务通知的方式 */
    30. 			{
    31. 				case eSetBits	:											/* 使用这种方法可以某些场景下代替事件组，但执行速度更快。 */
    32. 					pxTCB->ulNotifiedValue |= ulValue;
    33. 					break;
    34.  
    35. 				case eIncrement	:											/* 这种发送通知方式，参数 ulValue 未使用 */
    36. 					( pxTCB->ulNotifiedValue )++;
    37. 					break;
    38.  
    39. 				/* 将被通知任务的通知值设置为 ulValue。无论任务是否还有通知，都覆盖当前任务通知值。使用这种方法，可以在某些场景下代替 xQueueoverwrite()函数，但执行速度更快。 */
    40. 				case eSetValueWithOverwrite	:
    41. 					pxTCB->ulNotifiedValue = ulValue;
    42. 					break;
    43.  
    44. 				/* 如果被通知任务当前没有通知，则被通知任务的通知值设置为 ulValue；在某些场景下替代长度为 1 的 xQueuesend()，但速度更快。 */
    45. 				case eSetValueWithoutOverwrite :
    46. 					if( ucOriginalNotifyState != taskNOTIFICATION_RECEIVED )
    47. 					{
    48. 						pxTCB->ulNotifiedValue = ulValue;
    49. 					}
    50. 					else
    51. 					{
    52. 						/* 如果被通知任务还没取走上一个通知，本次发送通知，任务又接收到了一个通知，则这次通知值丢弃，在这种情况下，函数调用失败并返回 pdFALSE。 */
    53. 						xReturn = pdFAIL;
    54. 					}
    55. 					break;
    56.  
    57. 				case eNoAction:
    58. 					/* 发送通知但不更新通知值，这意味着参数 ulValue 未使用。 */
    59. 					break;
    60. 			}
    61.  
    62. 			traceTASK_NOTIFY();
    63.  
    64. 			/* 如果被通知任务由于等待任务通知而挂起 */
    65. 			if( ucOriginalNotifyState == taskWAITING_NOTIFICATION )
    66. 			{
    67. 				/* 唤醒任务，将任务从阻塞列表中移除，添加到就绪列表中 */
    68. 				( void ) uxListRemove( &( pxTCB->xStateListItem ) );
    69. 				prvAddTaskToReadyList( pxTCB );
    70.  
    71. 				// 刚刚唤醒的任务优先级比当前任务高
    72. 				configASSERT( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) == NULL );
    73.  
    74. 				#if( configUSE_TICKLESS_IDLE != 0 )
    75. 				{
    76. 					prvResetNextTaskUnblockTime();
    77. 				}
    78. 				#endif
    79.  
    80. 				if( pxTCB->uxPriority > pxCurrentTCB->uxPriority )
    81. 				{
    82. 					taskYIELD_IF_USING_PREEMPTION();
    83. 				}
    84. 				else
    85. 				{
    86. 					mtCOVERAGE_TEST_MARKER();
    87. 				}
    88. 			}
    89. 			else
    90. 			{
    91. 				mtCOVERAGE_TEST_MARKER();
    92. 			}
    93. 		}
    94. 		taskEXIT_CRITICAL();
    95.  
    96. 		return xReturn;
    97. 	}
    98.  
    99. #endif /* configUSE_TASK_NOTIFICATIONS */

            

    xTaskNotifyGive()用于向一个任务发送通知，并将对方的任务通知值加 1，不能在中断里面使用。该函数可以作为二值信号量和计数信号量的一种轻量型的实现，速度更快。
    在这种情况下对象任务在等待任务通知的时候应该是使用函数 ulTaskNotifyTake() 而不是 xTaskNotifyWait()。

    #define xTaskNotifyGive( xTaskToNotify ) 	xTaskGenericNotify( ( xTaskToNotify ), ( 0 ), eIncrement, NULL )

    xTaskNotifyGive()实例

    1. /*定义任务句柄 */
    2. static TaskHandle_t xTask1 = NULL, xTask2 = NULL;
    3.  
    4. /* 主函数:创建两个任务，然后开始任务调度 */
    5. void main( void )
    6.  {
    7. 	xTaskCreate(prvTask1, "Task1", 200, NULL, tskIDLE_PRIORITY, &xTask1);
    8. 	xTaskCreate(prvTask2, "Task2", 200, NULL, tskIDLE_PRIORITY, &xTask2);
    9. 	vTaskStartScheduler();
    10.  }
    11.  
    12.  static void prvTask1( void *pvParameters )
    13.  {
    14. 	for ( ;; ) 
    15. 	{
    16. 		/* 向 prvTask2()发送一个任务通知，让其退出阻塞状态 */
    17. 		xTaskNotifyGive( xTask2 );
    18. 		
    19. 		/* 阻塞在 prvTask2()的任务通知上，如果没有收到通知，则一直等待*/
    20. 		ulTaskNotifyTake( pdTRUE, portMAX_DELAY );
    21. 	}
    22.  }
    23.  
    24.  static void prvTask2( void *pvParameters )
    25.  {
    26. 	for ( ;; ) 
    27. 	{
    28. 		/* 阻塞在 prvTask1()的任务通知上，如果没有收到通知，则一直等待 */
    29. 		ulTaskNotifyTake( pdTRUE, portMAX_DELAY );
    30.  
    31. 		/* 向 prvTask1()发送一个任务通知，让其退出阻塞状态 */
    32. 		xTaskNotifyGive( xTask1 );
    33. 	}
    34. }

    vTaskNotifyGiveFromISR()是 vTaskNotifyGive()的中断保护版本。在某些场景中可以替代信号量操作，因为这两个通知都是不带有通知值的。
    *pxHigherPriorityTaskWoken 在使用之前必须先初始化为pdFALSE。当调用该函数发送一个任务通知时，目标任务接收到通知后将从阻塞态变为就绪态，并且如果其优先级比当前运行的任务的优先级高，
    那么*pxHigherPriorityTaskWoken 会被设置为 pdTRUE，然后在中断退出前执行一次上下文切换，去执行刚刚被唤醒的中断优先级较高的任务。pxHigherPriorityTaskWoken是一个可选的参数可以设置为 NULL。

    1. #if( configUSE_TASK_NOTIFICATIONS == 1 )
    2.  
    3. 	void vTaskNotifyGiveFromISR( TaskHandle_t xTaskToNotify, BaseType_t *pxHigherPriorityTaskWoken )
    4. 	{
    5. 		TCB_t * pxTCB;
    6. 		uint8_t ucOriginalNotifyState;
    7. 		UBaseType_t uxSavedInterruptStatus;
    8.  
    9. 		configASSERT( xTaskToNotify );
    10.  
    11. 		portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
    12.  
    13. 		pxTCB = ( TCB_t * ) xTaskToNotify;
    14.  
    15. 		uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();	//进入中断
    16. 		{
    17. 			ucOriginalNotifyState = pxTCB->ucNotifyState;			//保存任务通知的原始状态，看看任务是否在等待通知，方便在发送通知后恢复任务
    18. 			pxTCB->ucNotifyState = taskNOTIFICATION_RECEIVED;		/* 不管状态是怎么样的，反正现在发送通知，任务就收到任务通知 */
    19.  
    20. 			( pxTCB->ulNotifiedValue )++;							/* 通知值自加，类似于信号量的释放 */
    21.  
    22. 			traceTASK_NOTIFY_GIVE_FROM_ISR();
    23.  
    24. 			if( ucOriginalNotifyState == taskWAITING_NOTIFICATION )	/* 如果任务在阻塞等待通知 */
    25. 			{
    26. 				configASSERT( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) == NULL );
    27.  
    28. 				if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )		//如果任务调度器运行中
    29. 				{
    30. 					( void ) uxListRemove( &( pxTCB->xStateListItem ) );	/* 唤醒任务，将任务从阻塞列表中移除，添加到就绪列表中 */
    31. 					prvAddTaskToReadyList( pxTCB );
    32. 				}
    33. 				else
    34. 				{
    35. 					/* 调度器处于挂起状态，中断依然正常发生，但是不能直接操作就绪列表，将任务加入到就绪挂起列表，任务调度恢复后会移动到就绪列表 */
    36. 					vListInsertEnd( &( xPendingReadyList ), &( pxTCB->xEventListItem ) );	
    37. 				}
    38.  
    39. 				/* 如果刚刚唤醒的任务优先级比当前任务高,则设置上下文切换标识,等退出函数后手动切换上下文,或者在系统节拍中断服务程序中自动切换上下文 */
    40. 				if( pxTCB->uxPriority > pxCurrentTCB->uxPriority )
    41. 				{
    42. 					if( pxHigherPriorityTaskWoken != NULL )			/* 设置返回参数，表示需要任务切换，在退出中断前进行任务切换 */
    43. 					{
    44. 						*pxHigherPriorityTaskWoken = pdTRUE;
    45. 					}
    46. 					else
    47. 					{
    48. 						xYieldPending = pdTRUE;						/* 设置自动切换标志 */
    49. 					}
    50. 				}
    51. 				else
    52. 				{
    53. 					mtCOVERAGE_TEST_MARKER();
    54. 				}
    55. 			}
    56. 		}
    57. 		portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
    58. 	}
    59.  
    60. #endif /* configUSE_TASK_NOTIFICATIONS */

    任务通过接收函数返回值是否大于零，判断是否获取到了通知，任务通知值初始化为 0，（如果与信号量做对比）则对应为信号量无效。
    当中断调用 vTaskNotifyGiveFromISR()通知函数给任务的时候，任务的通知值增加，使其大于零，使其表示的通知值变为有效，任务获取有效的通知值将会被恢复。 

    vTaskNotifyGiveFromISR()实例

    1. static TaskHandle_t xTaskToNotify = NULL;
    2.  
    3. /* 外设驱动的数据传输函数 */
    4. void StartTransmission( uint8_t *pcData, size_t xDataLength )
    5. {
    6. 	/* 在这个时候，xTaskToNotify 应为 NULL，因为发送并没有进行。如果有必要，对外设的访问可以用互斥量来保护*/
    7. 	configASSERT( xTaskToNotify == NULL );
    8. 	
    9. 	/* 获取调用函数 StartTransmission()的任务的句柄 */
    10. 	xTaskToNotify = xTaskGetCurrentTaskHandle();
    11. 	
    12. 	/* 开始传输，当数据传输完成时产生一个中断 */
    13. 	vStartTransmit( pcData, xDatalength );
    14. }
    15.  
    16. /* 数据传输完成中断 */
    17. void vTransmitEndISR( void )
    18. {
    19. 	BaseType_t xHigherPriorityTaskWoken = pdFALSE;
    20.  
    21. 	/* 这个时候不应该为 NULL，因为数据传输已经开始 */
    22. 	configASSERT( xTaskToNotify != NULL );
    23. 	
    24. 	/* 通知任务传输已经完成 */
    25. 	vTaskNotifyGiveFromISR( xTaskToNotify, &xHigherPriorityTaskWoken );
    26. 	
    27. 	/* 传输已经完成，所以没有任务需要通知 */
    28. 	xTaskToNotify = NULL;
    29. 	
    30. 	/* 如果为 pdTRUE，则进行一次上下文切换 */
    31. 	portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
    32. }
    33.  
    34.  /* 任务：启动数据传输，然后进入阻塞态，直到数据传输完成 */
    35.  void vAFunctionCalledFromATask( uint8_t ucDataToTransmit, size_t xDataLength )
    36.  {
    37. 	uint32_t ulNotificationValue;
    38. 	const TickType_t xMaxBlockTime = pdMS_TO_TICKS( 200 );
    39.  
    40. 	/* 调用上面的函数 StartTransmission()启动传输 */
    41. 	StartTransmission( ucDataToTransmit, xDataLength );
    42.  
    43. 	/* 等待传输完成 */
    44. 	ulNotificationValue = ulTaskNotifyTake( pdFALSE, xMaxBlockTime );
    45.  
    46. 	/* 当传输完成时，会产生一个中断在中断服务函数中调用 vTaskNotifyGiveFromISR()向启动数据传输的任务发送一个任务通知，并
    47. 	将对象任务的任务通知值加 1，任务通知值在任务创建的时候是初始化为 0 的，当接收到任务后就变成 1 */
    48. 	if ( ulNotificationValue == 1 ) 
    49. 	{
    50. 		/* 传输按预期完成 */
    51. 	} else 
    52. 	{
    53. 		/* 调用函数 ulTaskNotifyTake()超时 */
    54. 	}
    55. }

    xTaskNotify()用于在任务中直接向另外一个任务发送一个事件，接收到该任务通知的任务有可能解锁，不能在中断里面使用。xTaskNotify()函数在发送任务通知的时候会指定一个通知值，并且用户可以指定通知值发送的方式。
    如果你想使用任务通知来实现二值信号量和计数信号量，那么应该使用更加简单的函数 xTaskNotifyGive()，而不是使用 xTaskNotify()。

    #define 	xTaskNotify( xTaskToNotify, ulValue, eAction ) 	xTaskGenericNotify( ( xTaskToNotify ), ( ulValue ), ( eAction ), NULL )

    eAction取值

    1. typedef enum
    2. {
    3. 	eNoAction = 0,				
    4. 	eSetBits,					
    5. 	eIncrement,					
    6. 	eSetValueWithOverwrite,		
    7. 	eSetValueWithoutOverwrite	
    8. }eNotifyAction;

    xTaskNotify()函数实例

    1. xTaskNotify( xTask1Handle, ( 1UL << 8UL ), eSetBits );		/* 设置任务 xTask1Handle 的任务通知值的位 8 为 1*/
    2. 	
    3. xTaskNotify( xTask2Handle, 0, eNoAction );					/* 向任务 xTask2Handle 发送一个任务通知，有可能会解除该任务的阻塞状态，但是并不会更新该任务自身的任务通知值 */
    4.  
    5. xTaskNotify( xTask3Handle, 0x50, eSetValueWithOverwrite );	/* 向任务 xTask3Handle 发送一个任务通知并把该任务自身的任务通知值更新为 0x50 即使该任务的上一次的任务通知都没有读取的情况下即覆盖写 */
    6.  
    7. /* 向任务 xTask4Handle 发送一个任务通知，并把该任务自身的任务通知值更新为 0xfff，但是并不会覆盖该任务之前接收到的任务通知值 */
    8. if(xTaskNotify(xTask4Handle,0xfff,eSetValueWithoutOverwrite) == pdPASS )
    9. {
    10. 	/* 任务 xTask4Handle 的任务通知值已经更新 */
    11. } else
    12. {
    13. 	/* 任务 xTask4Handle 的任务通知值没有更新，即上一次的通知值还没有被取走*/
    14. }

    xTaskNotifyFromISR()是 xTaskNotify()的中断保护版本，真正起作用的函数是中断发送任务通知通用函数 xTaskGenericNotifyFromISR()。
    xTaskNotifyFromISR()用于在中断中向指定的任务发送一个任务通知，该任务通知是带有通知值并且用户可以指定通知的发送方式，不返回上一个任务在的通知值。 

    #define xTaskNotifyFromISR( xTaskToNotify, ulValue, eAction, pxHigherPriorityTaskWoken ) xTaskGenericNotifyFromISR( ( xTaskToNotify ), ( ulValue ), ( eAction ), NULL, ( pxHigherPriorityTaskWoken ) )

    xTaskNotifyFromISR()实例

    中断：向一个任务发送任务通知，并根据不同的中断将目标任务的任务通知值的相应位置 1。

    1. void vANInterruptHandler( void )
    2. {
    3. 	BaseType_t xHigherPriorityTaskWoken;
    4. 	uint32_t ulStatusRegister;
    5.  
    6. 	/* 读取中断状态寄存器，判断到来的是哪个中断这里假设了 Rx、 Tx 和 buffer overrun 三个中断 */
    7. 	ulStatusRegister = ulReadPeripheralInterruptStatus();
    8.  
    9. 	/* 清除中断标志位 */
    10. 	vClearPeripheralInterruptStatus( ulStatusRegister );
    11.  
    12. 	/* xHigherPriorityTaskWoken 在使用之前必须初始化为 pdFALSE。如果调用函数 xTaskNotifyFromISR()解锁了解锁了接收该通知的任务，
    13. 	而且该任务的优先级比当前运行的任务的优先级高，那么xHigherPriorityTaskWoken 就会自动的被设置为 pdTRUE*/
    14. 	xHigherPriorityTaskWoken = pdFALSE;
    15.  
    16. 	/* 向任务 xHandlingTask 发送任务通知，并将其任务通知值与 ulStatusRegister 的值相或，这样可以不改变任务通知其它位的值*/
    17. 	xTaskNotifyFromISR( xHandlingTask,ulStatusRegister,eSetBits,&xHigherPriorityTaskWoken );
    18.  
    19. 	/* 如果 xHigherPriorityTaskWoken 的值为 pdRTUE，则执行一次上下文切换*/
    20. 	portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
    21. }
    22.  
    23. /* 任务：等待任务通知，然后处理相关的事情 */
    24. void vHandlingTask( void *pvParameters )
    25. {
    26. 	uint32_t ulInterruptStatus;
    27. 	
    28. 	for ( ;; ) 
    29. 	{
    30. 		/* 等待任务通知，无限期阻塞（没有超时，所以没有必要检查函数返回值） */
    31. 		xTaskNotifyWait( 	0x00, 				/* 在进入的时候不清除通知值的任何位 */
    32. 							ULONG_MAX, 			/* 在退出的时候复位通知值为 0 */
    33. 							&ulNotifiedValue, 	/* 任务通知值传递到变量 ulNotifiedValue 中*/
    34. 							portMAX_DELAY ); 	/* 无限期等待 */
    35. 		
    36. 		/* 根据任务通知值里面的各个位的值处理事情 */
    37. 		if ( ( ulInterruptStatus & 0x01 ) != 0x00 ) 
    38. 		{
    39. 			/* Rx 中断 */
    40. 			prvProcessRxInterrupt();
    41. 		}
    42. 		
    43. 		if ( ( ulInterruptStatus & 0x02 ) != 0x00 ) 
    44. 		{
    45. 			/* Tx 中断 */
    46. 			prvProcessTxInterrupt();
    47. 		}
    48. 		
    49. 		if ( ( ulInterruptStatus & 0x04 ) != 0x00 ) 
    50. 		{
    51. 			/* 缓冲区溢出中断 */
    52. 			prvClearBufferOverrun();
    53. 		}
    54. 	}
    55. }

    xTaskGenericNotifyFromISR() 是一个在中断中发送任务通知的通用函数，xTaskNotifyFromISR()、xTaskNotifyAndQueryFromISR()等函数都是以其为基础，采用宏定义的方式实现。 

    xTaskGenericNotifyFromISR()如下

    1. #if( configUSE_TASK_NOTIFICATIONS == 1 )
    2.  
    3. 	BaseType_t xTaskGenericNotifyFromISR( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue, BaseType_t *pxHigherPriorityTaskWoken )
    4. 	{
    5. 		TCB_t * pxTCB;
    6. 		uint8_t ucOriginalNotifyState;
    7. 		BaseType_t xReturn = pdPASS;
    8. 		UBaseType_t uxSavedInterruptStatus;
    9.  
    10. 		configASSERT( xTaskToNotify );
    11.  
    12. 		portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
    13.  
    14. 		pxTCB = ( TCB_t * ) xTaskToNotify;
    15.  
    16. 		uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
    17. 		{
    18. 			if( pulPreviousNotificationValue != NULL )
    19. 			{
    20. 				*pulPreviousNotificationValue = pxTCB->ulNotifiedValue;		//回传未被更新的任务通知值
    21. 			}
    22.  
    23. 			ucOriginalNotifyState = pxTCB->ucNotifyState;					//保存任务通知的原始状态，看看任务是否在等待通知，方便在发送通知后恢复任务
    24. 			pxTCB->ucNotifyState = taskNOTIFICATION_RECEIVED;				/* 不管状态是怎么样的，反正现在发送通知，任务就收到任务通知 */
    25.  
    26. 			switch( eAction )
    27. 			{
    28. 				case eSetBits	:											/*通知值按位或上 ulValue。使用这种方法可以某些场景下代替事件组，但执行速度更快。 */
    29. 					pxTCB->ulNotifiedValue |= ulValue;
    30. 					break;
    31.  
    32. 				case eIncrement	:											/* 被通知任务的通知值增加 1，这种发送通知方式，参数 ulValue 未使用，在某些场景下可以代替信号量，执行速度更快 */
    33. 					( pxTCB->ulNotifiedValue )++;
    34. 					break;
    35. 				/* 将被通知任务的通知值设置为 ulValue。无论任务是否还有通知，都覆盖当前任务通知值。使用这种方法，可以在某些场景下代替 xQueueoverwrite()函数，但执行速度更快。 */ 
    36. 				case eSetValueWithOverwrite	:								
    37. 					pxTCB->ulNotifiedValue = ulValue;
    38. 					break;
    39.  
    40. 				case eSetValueWithoutOverwrite :							//采用不覆盖发送任务通知的方式
    41. 					if( ucOriginalNotifyState != taskNOTIFICATION_RECEIVED )/* 如果被通知任务当前没有通知，则被通知任务的通知值设置为 ulValue；在某些场景下替代长度为 1 的 xQueuesend()，但速度更快。 */
    42. 					{
    43. 						pxTCB->ulNotifiedValue = ulValue;
    44. 					}
    45. 					else	/*如果被通知任务还没取走上一个通知，本次发送通知，任务又接收到了一个通知，则这次通知值丢弃，在这种情况下，函数调用失败并返回 pdFALSE。 */
    46. 					{
    47. 						xReturn = pdFAIL;
    48. 					}
    49. 					break;
    50.  
    51. 				case eNoAction :
    52. 					break;
    53. 			}
    54.  
    55. 			traceTASK_NOTIFY_FROM_ISR();
    56.  
    57. 			if( ucOriginalNotifyState == taskWAITING_NOTIFICATION )		/* 如果任务在阻塞等待通知 */
    58. 			{
    59. 				configASSERT( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) == NULL );
    60.  
    61. 				if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )	//如果任务调度器运行中，表示可用操作就绪级列表
    62. 				{
    63. 					( void ) uxListRemove( &( pxTCB->xStateListItem ) );	/* 唤醒任务，将任务从阻塞列表中移除，添加到就绪列表中 */
    64. 					prvAddTaskToReadyList( pxTCB );
    65. 				}
    66. 				else
    67. 				{
    68. 					/* 调度器处于挂起状态，中断依然正常发生，但是不能直接操作就绪列表，将任务加入到就绪挂起列表，任务调度恢复后会移动到就绪列表 */
    69. 					vListInsertEnd( &( xPendingReadyList ), &( pxTCB->xEventListItem ) );
    70. 				}
    71. 				/* 如果刚刚唤醒的任务优先级比当前任务高,则设置上下文切换标识,等退出函数后手动切换上下文,或者自动切换上下文 */
    72. 				if( pxTCB->uxPriority > pxCurrentTCB->uxPriority )
    73. 				{
    74. 					if( pxHigherPriorityTaskWoken != NULL )				/* 设置返回参数，表示需要任务切换，在退出中断前进行任务切换 */
    75. 					{
    76. 						*pxHigherPriorityTaskWoken = pdTRUE;
    77. 					}
    78. 					else
    79. 					{
    80. 						xYieldPending = pdTRUE;							/*设置自动切换标志，等高优先级任务释放 CPU 使用权 */
    81. 					}
    82. 				}
    83. 				else
    84. 				{
    85. 					mtCOVERAGE_TEST_MARKER();
    86. 				}
    87. 			}
    88. 		}
    89. 		portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
    90.  
    91. 		return xReturn;
    92. 	}
    93.  
    94. #endif /* configUSE_TASK_NOTIFICATIONS */

    xTaskNotifyAndQuery()与 xTaskNotify()很像，都是调用通用的任务通知发送函数 xTaskGenericNotify() 来实现通知的发送 ，不同的是多了一个附加的参数 pulPreviousNotifyValue 用于回传接收任务的上一个通知值，xTaskNotifyAndQuery()函数不能用在中断。

    #define xTaskNotifyAndQuery( xTaskToNotify, ulValue, eAction, pulPreviousNotifyValue ) xTaskGenericNotify( ( xTaskToNotify ), ( ulValue ), ( eAction ), ( pulPreviousNotifyValue ) )

    xTaskNotifyAndQuery()实例

    1. uint32_t ulPreviousValue;
    2.  
    3. /* 设置对象任务 xTask1Handle 的任务通知值的位 8 为 1，在更新位 8 的值之前把任务通知值回传存储在变量 ulPreviousValue 中*/
    4. xTaskNotifyAndQuery( xTask1Handle, ( 1UL << 8UL ), eSetBits,&ulPreviousValue );
    5.  
    6. /* 向对象任务 xTask2Handle 发送一个任务通知，有可能解除对象任务的阻塞状态，但是不更新对象任务的通知值，并将对象任务的通知值存储在变量 ulPreviousValue 中 */
    7. xTaskNotifyAndQuery( xTask2Handle, 0, eNoAction, &ulPreviousValue );
    8.  
    9. /* 覆盖式设置对象任务的任务通知值为 0x50，且对象任务的任务通知值不用回传，则最后一个形参设置为 NULL */
    10. xTaskNotifyAndQuery( xTask3Handle, 0x50, eSetValueWithOverwrite, NULL );
    11.  
    12. /* 设置对象任务的任务通知值为 0xfff，但是并不会覆盖对象任务通过 xTaskNotifyWait()和 ulTaskNotifyTake()这两个函数获取到的已经存在的任务通知值。对象任务的前一个任务通知值存储在变量 ulPreviousValue 中*/
    13. if ( xTaskNotifyAndQuery( xTask4Handle,0xfff,eSetValueWithoutOverwrite,&ulPreviousValue ) == pdPASS )
    14. {
    15. 	/* 任务通知值已经更新 */
    16. } else
    17. {
    18. 	/* 任务通知值没有更新 */
    19. }

    xTaskNotifyAndQueryFromISR()是 xTaskNotifyAndQuery ()的中断版本，用于向指定的任务发送一个任务通知， 并返回对象任务的上一个通知值。

    xTaskToNotify，需要接收通知的任务句柄。
    ulValue，用于更新接收任务通知的任务通知值。
    eAction，任务通知值的状态。
    pulPreviousNotificationValue，对象任务的上一个任务通知值。 如果为 NULL， 则不需要回传。
    *pxHigherPriorityTaskWoken 在使用之前必须先初始化为pdFALSE。 当调用该函数发送一个任务通知时，目标任务接收到通知后将从阻塞态变为就绪态，并且如果其优
    先级比当前运行的任务的优先级高 ，那么 *pxHigherPriorityTaskWoken 会被设置为 pdTRUE，然后在中断退出前执行一次上下文切换，去执行刚刚被唤醒的中断优先级较高的任务。 
    pxHigherPriorityTaskWoken是一个可选的参数可以设置为 NULL。
    参数 eAction 为 eSetValueWithoutOverwrite 时，如果被通知任务还没取走上一个通知，又接收到了一个通知，则这次通知值未能更新并返回 pdFALSE，其他情况均返回pdPASS。

    #define xTaskNotifyAndQueryFromISR( xTaskToNotify, ulValue, eAction, pulPreviousNotificationValue, pxHigherPriorityTaskWoken ) xTaskGenericNotifyFromISR( ( xTaskToNotify ), ( ulValue ), ( eAction ), ( pulPreviousNotificationValue ), ( pxHigherPriorityTaskWoken ) )

    xTaskNotifyAndQueryFromISR()实例

    1. void vAnISR( void )
    2. {
    3. 	/* xHigherPriorityTaskWoken 在使用之前必须设置为 pdFALSE */
    4. 	BaseType_t xHigherPriorityTaskWoken = pdFALSE.
    5. 	uint32_t ulPreviousValue;
    6.  
    7. 	/* 设置目标任务 xTask1Handle 的任务通知值的位 8 为 1，在任务通知值的位 8 被更新之前把上一次的值存储在变量 ulPreviousValue 中*/
    8. 	xTaskNotifyAndQueryFromISR( xTask1Handle,( 1UL << 8UL ),eSetBits,&ulPreviousValue,&xHigherPriorityTaskWoken );
    9.  
    10. 	/* 如果任务 xTask1Handle 阻塞在任务通知上，那么现在已经被解锁进入就绪态。如果其优先级比当前正在运行的任务的优先级高，则 xHigherPriorityTaskWoken会被设置为 pdRTUE，
    11. 	然后在中断退出前执行一次上下文切换，在中断退出后则去执行这个被唤醒的高优先级的任务 */
    12. 	portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
    13. }

    至此，发送任务通知内容就已经结束，多数函数都已经被官方封装好，我们直接用就行。
    xTaskNotifyGive( xTaskToNotify )                                    发送任务通知
    vTaskNotifyGiveFromISR()                                              vTaskNotifyGive()的中断保护版本

    xTaskNotify( xTaskToNotify, ulValue, eAction )                发送任务通知
    xTaskNotifyFromISR()                                                     xTaskNotify()的中断保护版本

    xTaskNotifyAndQuery( xTaskToNotify, ulValue, eAction, pulPreviousNotifyValue )
    xTaskNotifyAndQueryFromISR( xTaskToNotify, ulValue, eAction, pulPreviousNotificationValue, pxHigherPriorityTaskWoken )

    获取任务通知

    ulTaskNotifyTake()作为二值信号量和计数信号量的一种轻量级实现，速度更快。如果FreeRTOS 中使用函数 xSemaphoreTake() 来获取信号量，这个时候则可以试试使用函数ulTaskNotifyTake()来代替。
    任务通知值为 0，对应信号量无效，如果任务设置了阻塞等待，任务被阻塞挂起。
    当其他任务或中断发送了通知值使其不为 0 后，通知变为有效，等待通知的任务将获取到通知， 并且在退出时候根据用户传递的第一个参数 xClearCountOnExit 选择清零通知值或者执行减一操作。

    xTaskNotifyTake()在退出的时候处理任务的通知值的时候有两种方法，一种是在函数退出时将通知值清零，这种方法适用于实现二值信号量；另外一种是在函数退出时将通知值减 1，这种方法适用于实现计数信号量。
    当一个任务使用其自身的任务通知值作为二值信号量或者计数信号量时， 其他任务应该使用函数 xTaskNotifyGive()或者 xTaskNotify( ( xTaskToNotify ), ( 0 ), eIncrement )来向其发送信号量。 如果是在中断中，则应该使用他们的中断版本函数。 

    1. #if( configUSE_TASK_NOTIFICATIONS == 1 )
    2.  
    3. 	uint32_t ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait )
    4. 	{
    5. 		uint32_t ulReturn;
    6.  
    7. 		taskENTER_CRITICAL();
    8. 		{
    9. 			// 如果通知值为 0，阻塞任务。默认初始化通知值为 0，说明没有未读通知
    10. 			if( pxCurrentTCB->ulNotifiedValue == 0UL )
    11. 			{
    12. 				pxCurrentTCB->ucNotifyState = taskWAITING_NOTIFICATION;			/* 标记任务状态 ： 等待消息通知 */
    13.  
    14. 				if( xTicksToWait > ( TickType_t ) 0 )							//用户指定超时时间了，那就进入等待状态
    15. 				{
    16. 					prvAddCurrentTaskToDelayedList( xTicksToWait, pdTRUE );		//根据用户指定超时时间将任务添加到延时列表
    17. 					traceTASK_NOTIFY_TAKE_BLOCK();
    18.  
    19. 					portYIELD_WITHIN_API();
    20. 				}
    21. 				else
    22. 				{
    23. 					mtCOVERAGE_TEST_MARKER();
    24. 				}
    25. 			}
    26. 			else
    27. 			{
    28. 				mtCOVERAGE_TEST_MARKER();
    29. 			}
    30. 		}
    31. 		taskEXIT_CRITICAL();
    32. 		// 到这里说明其它任务或中断向这个任务发送了通知,或者任务阻塞超时,现在继续处理
    33. 		taskENTER_CRITICAL();
    34. 		{
    35. 			traceTASK_NOTIFY_TAKE();					// 获取任务通知值
    36. 			ulReturn = pxCurrentTCB->ulNotifiedValue;
    37.  
    38. 			if( ulReturn != 0UL )						// 看看任务通知是否有效，有效则返回
    39. 			{
    40. 				if( xClearCountOnExit != pdFALSE )		//是否需要清除通知
    41. 				{
    42. 					pxCurrentTCB->ulNotifiedValue = 0UL;
    43. 				}
    44. 				else
    45. 				{
    46. 					pxCurrentTCB->ulNotifiedValue = ulReturn - ( uint32_t ) 1;		// 不清除，就减一
    47. 				}
    48. 			}
    49. 			else
    50. 			{
    51. 				mtCOVERAGE_TEST_MARKER();
    52. 			}
    53.  
    54. 			pxCurrentTCB->ucNotifyState = taskNOT_WAITING_NOTIFICATION;				//恢复任务通知状态变量
    55. 		}
    56. 		taskEXIT_CRITICAL();
    57.  
    58. 		return ulReturn;
    59. 	}
    60.  
    61. #endif /* configUSE_TASK_NOTIFICATIONS */

    与获取二值信号量和获取计数信号量的函数相比， ulTaskNotifyTake()函数少了很多调用子函数开销、少了很多判断、少了事件列表处理、少了队列上锁与解锁处理等等，因此ulTaskNotifyTake()函数相对效率很高。

    ulTaskNotifyTake()函数实例

    1. /* 中断服务程序：向一个任务发送任务通知 */
    2. void vANInterruptHandler( void )
    3. {
    4. 	BaseType_t xHigherPriorityTaskWoken;
    5.  
    6. 	prvClearInterruptSource();	/* 清除中断 */
    7.  
    8. 	/* xHigherPriorityTaskWoken 在使用之前必须设置为 pdFALSE。如果调用 vTaskNotifyGiveFromISR()会解除 vHandlingTask 任务的阻塞状态，
    9. 	并且 vHandlingTask 任务的优先级高于当前处于运行状态的任务，则 xHigherPriorityTaskWoken 将会自动被设置为 pdTRUE */
    10. 	xHigherPriorityTaskWoken = pdFALSE;
    11.  
    12. 	/* 发送任务通知，并解锁阻塞在该任务通知下的任务 */
    13. 	vTaskNotifyGiveFromISR( xHandlingTask, &xHigherPriorityTaskWoken );
    14.  
    15. 	/* 如果被解锁的任务优先级比当前运行的任务的优先级高，则在中断退出前执行一次上下文切换，在中断退出后去执行刚刚被唤醒的优先级更高的任务*/
    16. 	portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
    17.  
    18. }
    19.  
    20.  /* 任务：阻塞在一个任务通知上 */
    21. void vHandlingTask( void *pvParameters )
    22. {
    23. 	BaseType_t xEvent;
    24. 	
    25. 	for ( ;; ) 
    26. 	{
    27. 		/* 一直阻塞（没有时间限制，所以没有必要检测函数的返回值）。这里 RTOS 的任务通知值被用作二值信号量，所以在函数退出时，任务通知值要被清 0 。要注意的是真正的应用程序不应该无限期的阻塞*/
    28. 		ulTaskNotifyTake( 	pdTRUE, 			/* 在退出前清 0 任务通知值 */
    29. 							portMAX_DELAY ); 	/* 无限阻塞 */
    30. 		
    31. 		/* RTOS 任务通知被当作二值信号量使用，当处理完所有的事情后继续等待下一个任务通知*/
    32. 		do 
    33. 		{
    34. 			xEvent = xQueryPeripheral();
    35. 			
    36. 			if ( xEvent != NO_MORE_EVENTS ) 
    37. 			{
    38. 				vProcessPeripheralEvent( xEvent );
    39. 			}
    40. 		
    41. 		} while ( xEvent != NO_MORE_EVENTS );
    42. 	}
    43. }

    xTaskNotifyWait()函数用于实现全功能版的等待任务通知，根据用户指定的参数的不同，可以灵活的用于实现轻量级的消息队列队列、二值信号量、计数信号量和事件组功能，并带有超时等待。

    ulBitsToClearOnEntry 表示在使用通知之前，将任务通知值的哪些位清 0 ，实现过程就是将任务的通知值与参数 ulBitsToClearOnEntry 的按位取反值按位与操作。
    ulBitsToClearOnExit 表示在函数 xTaskNotifyWait()退出前， 决定任务接收到的通知值的哪些位会被清 0，实现过程就是将任务的通知值与参数 ulBitsToClearOnExit 的按位取反值按位与操作。 
    在清 0 前，接收到的任务通知值会先被保存到形参 *pulNotificationValue 中。
    pulNotificationValue 用于保存接收到的任务通知值。 如果接收到的任务通知不需要使用，则设置为 NULL 即可。 

    1. #if( configUSE_TASK_NOTIFICATIONS == 1 )
    2.  
    3. 	BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait )
    4. 	{
    5. 		BaseType_t xReturn;
    6.  
    7. 		taskENTER_CRITICAL();
    8. 		{
    9. 			if( pxCurrentTCB->ucNotifyState != taskNOTIFICATION_RECEIVED )	/* 只有任务当前没有收到任务通知，才会将任务阻塞 */
    10. 			{
    11. 				pxCurrentTCB->ulNotifiedValue &= ~ulBitsToClearOnEntry;		/* 使用任务通知值之前,根据用户指定参数 ulBitsToClearOnEntryClear 将通知值的某些或全部位清零 */
    12.  
    13. 				pxCurrentTCB->ucNotifyState = taskWAITING_NOTIFICATION;		/* 设置任务状态标识:等待通知 */
    14.  
    15. 				if( xTicksToWait > ( TickType_t ) 0 )						/* 挂起任务等待通知或者进入阻塞态 */
    16. 				{
    17. 					prvAddCurrentTaskToDelayedList( xTicksToWait, pdTRUE );	/* 根据用户指定超时时间将任务添加到延时列表 */
    18. 					traceTASK_NOTIFY_WAIT_BLOCK();
    19.  
    20. 					portYIELD_WITHIN_API();
    21. 				}
    22. 				else
    23. 				{
    24. 					mtCOVERAGE_TEST_MARKER();
    25. 				}
    26. 			}
    27. 			else
    28. 			{
    29. 				mtCOVERAGE_TEST_MARKER();
    30. 			}
    31. 		}
    32. 		taskEXIT_CRITICAL();
    33. 		//程序能执行到这里说明其它任务或中断向这个任务发送了通知或者任务阻塞超时,现在继续处理
    34. 		taskENTER_CRITICAL();
    35. 		{
    36. 			traceTASK_NOTIFY_WAIT();
    37.  
    38. 			if( pulNotificationValue != NULL )
    39. 			{
    40. 				*pulNotificationValue = pxCurrentTCB->ulNotifiedValue;		/* 返回当前通知值,通过指针参数传递 */
    41. 			}
    42.  
    43. 			if( pxCurrentTCB->ucNotifyState != taskNOTIFICATION_RECEIVED )	/* 判断是否是因为任务阻塞超时，因为如果有任务发送了通知的话，任务通知状态会被改变 */
    44. 			{
    45. 				xReturn = pdFALSE;											/* 没有收到任务通知,是阻塞超时 */
    46. 			}
    47. 			else
    48. 			{
    49. 				pxCurrentTCB->ulNotifiedValue &= ~ulBitsToClearOnExit;		/* 收到任务值,先将参数 ulBitsToClearOnExit 取反后与通知值位做按位与运算，在退出函数前,将通知值的某些或者全部位清零 */
    50. 				xReturn = pdTRUE;
    51. 			}
    52.  
    53. 			pxCurrentTCB->ucNotifyState = taskNOT_WAITING_NOTIFICATION;		//重新设置任务通知状态
    54. 		}
    55. 		taskEXIT_CRITICAL();
    56.  
    57. 		return xReturn;
    58. 	}
    59.  
    60. #endif /* configUSE_TASK_NOTIFICATIONS */

    xTaskNotifyWait()实例

    1. /* 这个任务展示使用任务通知值的位来传递不同的事件这在某些情况下可以代替事件标志组。 */
    2. void vAnEventProcessingTask( void *pvParameters )
    3. {
    4. 	uint32_t ulNotifiedValue;
    5.  
    6. 	for ( ;; ) 
    7. 	{
    8. 		/* 等待任务通知，无限期阻塞（没有超时，所以没有必要检查函数返回值）。这个任务的任务通知值的位由标志事件发生的任务或者中断来设置*/
    9. 		xTaskNotifyWait( 	0x00, 					/* 在进入的时候不清除通知值的任何位 */
    10. 							ULONG_MAX, 				/* 在退出的时候复位通知值为 0 */
    11. 							&ulNotifiedValue,		/* 任务通知值传递到变量 ulNotifiedValue 中*/
    12. 							portMAX_DELAY ); 		/* 无限期等待 */
    13. 		
    14.  
    15. 		/* 根据任务通知值里面的各个位的值处理事情 */
    16. 		if ( ( ulNotifiedValue & 0x01 ) != 0 ) 	/* 位 0 被置 1 */
    17. 		{
    18. 			prvProcessBit0Event();
    19. 		}
    20. 		
    21. 		if ( ( ulNotifiedValue & 0x02 ) != 0 ) /* 位 1 被置 1 */
    22. 		{
    23. 			prvProcessBit1Event();
    24. 		}
    25. 		
    26. 		if ( ( ulNotifiedValue & 0x04 ) != 0 ) /* 位 2 被置 1 */
    27. 		{
    28. 	
    29. 			prvProcessBit2Event();
    30. 		}
    31. 	
    32. 		/* ... 等等 */
    33. 	}
    34. }

    至此，获取任务通知内容就已经结束，多数函数都已经被官方封装好，我们直接用就行。

    ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait )                                                                                                        

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

    任务通知实验

    任务通知代替消息队列

    在 FreeRTOS 中创建了三个任务， 其中两个任务是用于接收任务通知，另一个任务发送任务通知。三个任务独立运行。
    发送消息任务是通过检测按键的按下情况来发送消息通知，另两个任务获取消息通知，在任务通知中没有可用的通知之前就一直等待消息，一旦获取到消息通知就把消息打印在串口调试助手里。

    1. #include "FreeRTOS.h"
    2. #include "task.h"
    3. #include "bsp_led.h"
    4. #include "bsp_usart.h"
    5. #include "bsp_key.h"
    6. #include "limits.h"
    7.  
    8. static TaskHandle_t AppTaskCreate_Handle = NULL;	/*创建任务句柄 */
    9. static TaskHandle_t Receive1_Task_Handle = NULL;	/*Receive1_Task 任务句柄 */
    10. static TaskHandle_t Receive2_Task_Handle = NULL;	/*Receive2_Task 任务句柄 */
    11. static TaskHandle_t Send_Task_Handle 	 = NULL;	/* Send_Task 任务句柄 */
    12.  
    13. #define USE_CHAR 0 /* 测试字符串的时候配置为 1 ，测试变量配置为 0 */
    14.  
    15. int main(void)
    16. {
    17. 	BaseType_t xReturn = pdPASS;	/* 定义一个创建信息返回值，默认为 pdPASS */
    18. 	
    19. 	BSP_Init();
    20. 	printf("按下 KEY1 或者 KEY2 向任务发送消息通知\n");
    21. 	
    22. 	xReturn = xTaskCreate(	(TaskFunction_t )AppTaskCreate, 		/*任务入口函数 */
    23. 							(const char* )"AppTaskCreate",			/* 任务名字 */
    24. 							(uint16_t )512, 						/* 任务栈大小 */
    25. 							(void* )NULL,							/* 任务入口函数参数 */
    26. 							(UBaseType_t )1, 						/* 任务的优先级 */
    27. 							(TaskHandle_t* )&AppTaskCreate_Handle);	/* 任务控制块指针 */
    28. 	
    29. 	if (pdPASS == xReturn)
    30. 		vTaskStartScheduler(); 	/* 启动任务，开启调度 */
    31. 	else
    32. 		return -1;
    33. 	
    34. 	while (1); 	/* 正常不会执行到这里 */
    35. }
    36.  
    37. static void AppTaskCreate(void)
    38. {
    39. 	BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为 pdPASS */
    40. 	
    41. 	taskENTER_CRITICAL(); //进入临界区
    42. 	
    43. 	
    44. 	xReturn = xTaskCreate(	(TaskFunction_t )Receive1_Task,				/*任务入口函数 */
    45. 							(const char* )"Receive1_Task",				/* 任务名字 */
    46. 							(uint16_t )512, 							/* 任务栈大小 */
    47. 							(void* )NULL, 								/* 任务入口函数参数 */
    48. 							(UBaseType_t )2, 							/* 任务的优先级 */
    49. 							(TaskHandle_t*)&Receive1_Task_Handle);		/*任务控制块指针 */
    50. 	if (pdPASS == xReturn)
    51. 		printf("创建 Receive1_Task 任务成功!\r\n");
    52. 	
    53. 	xReturn = xTaskCreate(	(TaskFunction_t )Receive2_Task, 			/* 任务入口函数*/
    54. 							(const char* )"Receive2_Task",				/* 任务名字 */
    55. 							(uint16_t )512, 							/* 任务栈大小 */
    56. 							(void* )NULL, 								/* 任务入口函数参数 */
    57. 							(UBaseType_t )3, 							/* 任务的优先级 */
    58. 							(TaskHandle_t*)&Receive2_Task_Handle);		/*任务控制块指针 */
    59. 	if (pdPASS == xReturn)
    60. 		printf("创建 Receive2_Task 任务成功!\r\n");
    61. 	
    62. 	xReturn = xTaskCreate(	(TaskFunction_t )Send_Task, /* 任务入口函数 */
    63. 							(const char* )"Send_Task",/* 任务名字 */
    64. 							(uint16_t )512, /* 任务栈大小 */
    65. 							(void* )NULL,/* 任务入口函数参数 */
    66. 							(UBaseType_t )4, /* 任务的优先级 */
    67. 							(TaskHandle_t* )&Send_Task_Handle);/* 任务控制块指针 */
    68. 	if (pdPASS == xReturn)
    69. 		printf("创建 Send_Task 任务成功!\n\n");
    70. 	
    71. 	vTaskDelete(AppTaskCreate_Handle); //删除 AppTaskCreate 任务
    72. 	
    73. 	taskEXIT_CRITICAL(); //退出临界区
    74. }
    75.  
    76. static void Receive1_Task(void* parameter)
    77. {
    78. 	BaseType_t xReturn = pdTRUE;/* 定义一个创建信息返回值，默认为 pdPASS */
    79. 	
    80. #if USE_CHAR
    81. 	char *r_char;
    82. #else
    83. 	uint32_t r_num;
    84. #endif
    85.  
    86. 	while (1) 
    87. 	{
    88. 		//获取任务通知 ,没获取到则一直等待
    89. 		xReturn=xTaskNotifyWait(	0x0, 		//进入函数的时候不清除任务 bit
    90. 									ULONG_MAX, 	//退出函数的时候清除所有的 bit
    91. #if USE_CHAR
    92. 									(uint32_t *)&r_char,//保存任务通知值
    93. #else
    94. 									&r_num, 			//保存任务通知值
    95. #endif
    96. 									portMAX_DELAY); 	//阻塞时间
    97. 		if ( pdTRUE == xReturn )
    98. #if USE_CHAR
    99. 			printf("Receive1_Task 任务通知为 %s \n",r_char);
    100. #else
    101. 			printf("Receive1_Task 任务通知为 %d \n",r_num);
    102. #endif
    103. 			
    104. 		LED1_TOGGLE;
    105. 	}
    106. }
    107.  
    108. static void Receive2_Task(void* parameter)
    109. {
    110. 	BaseType_t xReturn = pdTRUE;		/* 定义一个创建信息返回值，默认为 pdPASS */
    111. #if USE_CHAR
    112. 	char *r_char;
    113. #else
    114. 	uint32_t r_num;
    115. #endif
    116.  
    117. 	while (1) 
    118. 	{
    119. 		//获取任务通知 ,没获取到则一直等待
    120. 		xReturn=xTaskNotifyWait(	0x0, //进入函数的时候不清除任务 bit
    121. 									ULONG_MAX, //退出函数的时候清除所有的 bit
    122. #if USE_CHAR
    123. 									(uint32_t *)&r_char, //保存任务通知值
    124. #else
    125. 									&r_num, //保存任务通知值
    126. #endif
    127. 									portMAX_DELAY); //阻塞时间
    128. 		if ( pdTRUE == xReturn )
    129. #if USE_CHAR
    130. 			printf("Receive2_Task 任务通知为 %s \n",r_char);
    131. #else
    132. 			printf("Receive2_Task 任务通知为 %d \n",r_num);
    133. #endif
    134. 		LED2_TOGGLE;
    135. 	}
    136. }
    137.  
    138. static void Send_Task(void* parameter)
    139. {
    140. 	BaseType_t xReturn = pdPASS;	/* 定义一个创建信息返回值，默认为 pdPASS */
    141. #if USE_CHAR
    142. 	char test_str1[] = "this is a mail test 1";		/* 消息 test1 */
    143. 	char test_str2[] = "this is a mail test 2";		/* 消息 test2 */
    144. #else
    145. 	uint32_t send1 = 1;
    146. 	uint32_t send2 = 2;
    147. #endif
    148.  
    149. 	while (1) 
    150. 	{
    151.  
    152. 		if ( Key_Scan(KEY1_GPIO_PORT,KEY1_GPIO_PIN) == KEY_ON ) 	/* KEY1 被按下 */
    153. 		{
    154. 			xReturn = xTaskNotify( 	Receive1_Task_Handle,		/*任务句柄*/
    155. #if USE_CHAR		
    156. 									(uint32_t)&test_str1,		/*发送的数据，最大为 4 字节 */
    157. #else		
    158. 									send1, 				 		/* 发送的数据，最大为 4 字节 */
    159. #endif
    160. 									eSetValueWithOverwrite ); 	/*覆盖当前通知*/
    161.  
    162. 			if ( xReturn == pdPASS )
    163. 				printf("Receive1_Task_Handle 任务通知释放成功!\r\n");
    164. 		}
    165.  
    166. 		if ( Key_Scan(KEY2_GPIO_PORT,KEY2_GPIO_PIN) == KEY_ON ) 	/* KEY2 被按下 */
    167. 		{
    168. 			xReturn = xTaskNotify( 	Receive2_Task_Handle, /*任务句柄*/
    169. #if USE_CHAR
    170. 									(uint32_t)&test_str2,/* 发送的数据，最大为 4 字节 */
    171. #else
    172. 									send2, /* 发送的数据，最大为 4 字节 */
    173. #endif
    174. 									eSetValueWithOverwrite );/*覆盖当前通知*/
    175. 			/* 此函数只会返回 pdPASS */
    176. 			if ( xReturn == pdPASS )
    177. 				printf("Receive2_Task_Handle 任务通知释放成功!\r\n");
    178. 		}
    179. 		vTaskDelay(20);
    180. 	}
    181. }

    任务通知代替二值信号量

    在 FreeRTOS 中创建了三个任务，其中两个任务是用于接收任务通知，另一个任务发送任务通知。三个任务独立运行。
    发送通知任务是通过检测按键的按下情况来发送通知，另两个任务获取通知，在任务通知中没有可用的通知之前就一直等待任务通知，获取到通知以后就将通知值清 0，这样子是为了代替二值信号量，任务同步成功则继续执行，然后在串口调试助手里将运行信息打印出来。

    1. #include "FreeRTOS.h"
    2. #include "task.h"
    3. #include "bsp_led.h"
    4. #include "bsp_usart.h"
    5. #include "bsp_key.h"
    6.  
    7. static TaskHandle_t AppTaskCreate_Handle = NULL;	/*创建任务句柄 */
    8. static TaskHandle_t Receive1_Task_Handle = NULL;	/*Receive1_Task 任务句柄 */
    9. static TaskHandle_t Receive2_Task_Handle = NULL;	/*Receive2_Task 任务句柄 */
    10. static TaskHandle_t Send_Task_Handle 	 = NULL;	/* Send_Task 任务句柄 */
    11.  
    12. int main(void)
    13. {
    14. 	BaseType_t xReturn = pdPASS;	/* 定义一个创建信息返回值，默认为 pdPASS */
    15. 	
    16. 	BSP_Init();
    17. 	printf("按下 KEY1 或者 KEY2 进行任务与任务间的同步\n");
    18. 	
    19. 	xReturn = xTaskCreate(	(TaskFunction_t )AppTaskCreate, 		/*任务入口函数 */
    20. 							(const char* )"AppTaskCreate",			/* 任务名字 */
    21. 							(uint16_t )512, 						/* 任务栈大小 */
    22. 							(void* )NULL,							/* 任务入口函数参数 */
    23. 							(UBaseType_t )1, 						/* 任务的优先级 */
    24. 							(TaskHandle_t* )&AppTaskCreate_Handle);	/* 任务控制块指针 */
    25. 	
    26. 	if (pdPASS == xReturn)
    27. 		vTaskStartScheduler(); 	/* 启动任务，开启调度 */
    28. 	else
    29. 		return -1;
    30. 	
    31. 	while (1); 	/* 正常不会执行到这里 */
    32. }
    33.  
    34. static void AppTaskCreate(void)
    35. {
    36. 	BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为 pdPASS */
    37. 	
    38. 	taskENTER_CRITICAL(); //进入临界区
    39. 	
    40. 	
    41. 	xReturn = xTaskCreate(	(TaskFunction_t )Receive1_Task,				/*任务入口函数 */
    42. 							(const char* )"Receive1_Task",				/* 任务名字 */
    43. 							(uint16_t )512, 							/* 任务栈大小 */
    44. 							(void* )NULL, 								/* 任务入口函数参数 */
    45. 							(UBaseType_t )2, 							/* 任务的优先级 */
    46. 							(TaskHandle_t*)&Receive1_Task_Handle);		/*任务控制块指针 */
    47. 	if (pdPASS == xReturn)
    48. 		printf("创建 Receive1_Task 任务成功!\r\n");
    49. 	
    50. 	xReturn = xTaskCreate(	(TaskFunction_t )Receive2_Task, 			/* 任务入口函数*/
    51. 							(const char* )"Receive2_Task",				/* 任务名字 */
    52. 							(uint16_t )512, 							/* 任务栈大小 */
    53. 							(void* )NULL, 								/* 任务入口函数参数 */
    54. 							(UBaseType_t )3, 							/* 任务的优先级 */
    55. 							(TaskHandle_t*)&Receive2_Task_Handle);		/*任务控制块指针 */
    56. 	if (pdPASS == xReturn)
    57. 		printf("创建 Receive2_Task 任务成功!\r\n");
    58. 	
    59. 	xReturn = xTaskCreate(	(TaskFunction_t )Send_Task, /* 任务入口函数 */
    60. 							(const char* )"Send_Task",/* 任务名字 */
    61. 							(uint16_t )512, /* 任务栈大小 */
    62. 							(void* )NULL,/* 任务入口函数参数 */
    63. 							(UBaseType_t )4, /* 任务的优先级 */
    64. 							(TaskHandle_t* )&Send_Task_Handle);/* 任务控制块指针 */
    65. 	if (pdPASS == xReturn)
    66. 		printf("创建 Send_Task 任务成功!\n\n");
    67. 	
    68. 	vTaskDelete(AppTaskCreate_Handle); //删除 AppTaskCreate 任务
    69. 	
    70. 	taskEXIT_CRITICAL(); //退出临界区
    71. }
    72.  
    73. static void Receive1_Task(void* parameter)
    74. {
    75. 	while (1) 
    76. 	{
    77. 		 /* uint32_t ulTaskNotifyTake(BaseType_t xClearCountOnExit,TickType_t TicksToWait );
    78. 		  * xClearCountOnExit： pdTRUE 在退出函数的时候任务任务通知值清零，类似二值信号量 pdFALSE 在退出函数 ulTaskNotifyTakeO 的时候任务通知值减一，类似计数型信号量。
    79. 		  */
    80. 		
    81. 		//获取任务通知 ,没获取到则一直等待
    82. 		ulTaskNotifyTake(pdTRUE,portMAX_DELAY);
    83. 		
    84. 		printf("Receive1_Task 任务通知获取成功!\n\n");
    85. 		
    86. 		LED1_TOGGLE;
    87. 	}
    88. }
    89.  
    90. static void Receive2_Task(void* parameter)
    91. {
    92. 	while (1) 
    93. 	{
    94. 		 /* uint32_t ulTaskNotifyTake(BaseType_t xClearCountOnExit,TickType_t TicksToWait );
    95. 		  * xClearCountOnExit： pdTRUE 在退出函数的时候任务任务通知值清零，类似二值信号量 pdFALSE 在退出函数 ulTaskNotifyTakeO 的时候任务通知值减一，类似计数型信号量。
    96. 		  */
    97. 		
    98. 		//获取任务通知 ,没获取到则一直等待
    99. 		ulTaskNotifyTake(pdTRUE,portMAX_DELAY);
    100. 		
    101. 		printf("Receive2_Task 任务通知获取成功!\n\n");
    102. 		
    103. 		LED2_TOGGLE;
    104. 	}
    105. }
    106.  
    107. static void Send_Task(void* parameter)
    108. {
    109. 	BaseType_t xReturn = pdPASS;	/* 定义一个创建信息返回值，默认为 pdPASS */
    110.  
    111. 	while (1) 
    112. 	{
    113.  
    114. 		if ( Key_Scan(KEY1_GPIO_PORT,KEY1_GPIO_PIN) == KEY_ON ) 	/* KEY1 被按下 */
    115. 		{
    116. 			/* 原型:BaseType_t xTaskNotifyGive( TaskHandle_t xTaskToNotify ); */
    117. 			xReturn = xTaskNotifyGive(Receive1_Task_Handle);
    118. 			
    119. 			/* 此函数只会返回 pdPASS */
    120. 			if ( xReturn == pdPASS )
    121. 				printf("Receive1_Task_Handle 任务通知释放成功!\r\n");
    122. 		}
    123.  
    124. 		if ( Key_Scan(KEY2_GPIO_PORT,KEY2_GPIO_PIN) == KEY_ON ) 	/* KEY2 被按下 */
    125. 		{
    126. 			/* 原型:BaseType_t xTaskNotifyGive( TaskHandle_t xTaskToNotify ); */
    127. 			xReturn = xTaskNotifyGive(Receive2_Task_Handle);
    128. 			
    129. 			/* 此函数只会返回 pdPASS */
    130. 			if ( xReturn == pdPASS )
    131. 				printf("Receive2_Task_Handle 任务通知释放成功!\r\n");
    132. 		}
    133. 		vTaskDelay(20);
    134. 	}
    135. }

    任务通知代替计数信号量

    1. #include "FreeRTOS.h"
    2. #include "task.h"
    3. #include "queue.h"
    4. #include "semphr.h"
    5. #include "bsp_led.h"
    6. #include "bsp_usart.h"
    7. #include "bsp_key.h"
    8.  
    9. static TaskHandle_t AppTaskCreate_Handle 	= NULL;		/* 创建任务句柄 */
    10. static TaskHandle_t Take_Task_Handle		= NULL;		/* Take_Task 任务句柄 */
    11. static TaskHandle_t Give_Task_Handle		= NULL;		/* Give_Task 任务句柄 */
    12.  
    13. SemaphoreHandle_t CountSem_Handle =NULL;
    14.  
    15. int main(void)
    16. {
    17. 	BaseType_t xReturn = pdPASS;	/* 定义一个创建信息返回值，默认为 pdPASS */
    18. 	
    19. 	BSP_Init();
    20. 	printf("车位默认值为 0 个，按下 KEY1 申请车位，按下 KEY2 释放车位！ \n\n");
    21. 	xReturn = xTaskCreate(	(TaskFunction_t )AppTaskCreate, 		/*任务入口函数 */
    22. 							(const char* )"AppTaskCreate",			/* 任务名字 */
    23. 							(uint16_t )512, 						/* 任务栈大小 */
    24. 							(void* )NULL,							/* 任务入口函数参数 */
    25. 							(UBaseType_t )1, 						/* 任务的优先级 */
    26. 							(TaskHandle_t* )&AppTaskCreate_Handle);	/* 任务控制块指针 */
    27. 	
    28. 	if (pdPASS == xReturn)
    29. 		vTaskStartScheduler(); 	/* 启动任务，开启调度 */
    30. 	else
    31. 		return -1;
    32. 	
    33. 	while (1); 	/* 正常不会执行到这里 */
    34. }
    35.  
    36. static void AppTaskCreate(void)
    37. {
    38. 	BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为 pdPASS */
    39. 	
    40. 	taskENTER_CRITICAL(); //进入临界区
    41. 		
    42. 	xReturn = xTaskCreate(	(TaskFunction_t )Take_Task,				/*任务入口函数 */
    43. 							(const char* )"Take_Task",				/* 任务名字 */
    44. 							(uint16_t )512, 						/* 任务栈大小 */
    45. 							(void* )NULL, 							/* 任务入口函数参数 */
    46. 							(UBaseType_t )2, 						/* 任务的优先级 */
    47. 							(TaskHandle_t*)&Take_Task_Handle);		/*任务控制块指针 */
    48. 	if (pdPASS == xReturn)
    49. 		printf("创建 Take_Task 任务成功!\r\n");
    50. 	
    51. 	xReturn = xTaskCreate(	(TaskFunction_t )Give_Task, 			/* 任务入口函数*/
    52. 							(const char* )"Give_Task",				/* 任务名字 */
    53. 							(uint16_t )512, 						/* 任务栈大小 */
    54. 							(void* )NULL, 							/* 任务入口函数参数 */
    55. 							(UBaseType_t )3, 						/* 任务的优先级 */
    56. 							(TaskHandle_t*)&Give_Task_Handle);		/*任务控制块指针 */
    57. 	if (pdPASS == xReturn)
    58. 		printf("创建 Give_Task 任务成功!\r\n");
    59. 	
    60. 	xReturn = xTaskCreate(	(TaskFunction_t )Send_Task, /* 任务入口函数 */
    61. 							(const char* )"Send_Task",/* 任务名字 */
    62. 							(uint16_t )512, /* 任务栈大小 */
    63. 							(void* )NULL,/* 任务入口函数参数 */
    64. 							(UBaseType_t )4, /* 任务的优先级 */
    65. 							(TaskHandle_t* )&Send_Task_Handle);/* 任务控制块指针 */
    66. 	if (pdPASS == xReturn)
    67. 		printf("创建 Send_Task 任务成功!\n\n");
    68. 	
    69. 	vTaskDelete(AppTaskCreate_Handle); //删除 AppTaskCreate 任务
    70. 	
    71. 	taskEXIT_CRITICAL(); //退出临界区
    72. }
    73.  
    74. static void Take_Task(void* parameter)
    75. {
    76. 	uint32_t take_num = pdTRUE;		/* 定义一个创建信息返回值，默认为 pdPASS */
    77.  
    78. 	while (1) 
    79. 	{
    80. 	
    81. 		if ( Key_Scan(KEY1_GPIO_PORT,KEY1_GPIO_PIN) == KEY_ON ) 	//如果 KEY1 被按下
    82. 		{
    83. 			/*uint32_t ulTaskNotifyTake(BaseType_t xClearCountOnExit,TickType_t xTicksToWait );
    84. 			* xClearCountOnExit： pdTRUE 在退出函数的时候任务任务通知值清零，类似二值信号量 pdFALSE 在退出函数 ulTaskNotifyTakeO 的时候任务通知值减一，类似计数型信号量。
    85. 			*/
    86. 			//获取任务通知 ,没获取到则不等待
    87. 			take_num=ulTaskNotifyTake(pdFALSE,0);
    88. 			
    89. 			if (take_num > 0)
    90. 				printf( "KEY1 被按下， 成功申请到停车位。当前车位为 %d \n", take_num - 1);
    91. 			else
    92. 				printf( "KEY1 被按下， 车位已经没有了。按 KEY2 释放车位\n" );
    93. 		}
    94. 		vTaskDelay(20); //每 20ms 扫描一次
    95. 	}
    96. }
    97.  
    98. static void Give_Task(void* parameter)
    99. {
    100. 	BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为 pdPASS */
    101.  
    102. 	while (1) 
    103. 	{
    104. 		if ( Key_Scan(KEY2_GPIO_PORT,KEY2_GPIO_PIN) == KEY_ON ) 	//如果 KEY2 被按下
    105. 		{
    106. 			/* 释放一个任务通知 */
    107. 			xTaskNotifyGive(Take_Task_Handle);//发送任务通知
    108. 			/* 此函数只会返回 pdPASS */
    109. 			if ( pdPASS == xReturn )
    110. 				printf( "KEY2 被按下， 释放 1 个停车位。 \n" );
    111. 		}
    112. 		vTaskDelay(20); //每 20ms 扫描一次
    113. 	}
    114. }

    任务通知代替事件组

    在 FreeRTOS 中创建了两个任务，一个是发送事件通知任务，一个是等待事件通知任务，两个任务独立运行。
    发送事件通知任务通过检测按键的按下情况设置不同的通知值位，等待事件通知任务则获取这任务通知值，并且根据通知值判断两个事件是否都发生，如果是则输出相应信息，LED 进行翻转。
    等待事件通知任务的等待时间是 portMAX_DELAY，一直在等待事件通知的发生，等待获取到事件之后清除对应的任务通知值的位。

    1. #include "FreeRTOS.h"
    2. #include "task.h"
    3. #include "event_groups.h"
    4. #include "bsp_led.h"
    5. #include "bsp_usart.h"
    6. #include "bsp_key.h"
    7. #include "limits.h"
    8.  
    9. static TaskHandle_t AppTaskCreate_Handle = NULL;	/* 创建任务句柄 */
    10. static TaskHandle_t LED_Task_Handle 	 = NULL;	/* LED_Task 任务句柄 */
    11. static TaskHandle_t KEY_Task_Handle 	 = NULL;	/* KEY_Task 任务句柄 */
    12.  
    13. static EventGroupHandle_t Event_Handle   = NULL;
    14.  
    15. #define KEY1_EVENT (0x01 << 0)						//设置事件掩码的位 0 
    16. #define KEY2_EVENT (0x01 << 1)						//设置事件掩码的位 1
    17. 						
    18. int main(void)
    19. {
    20. 	BaseType_t xReturn = pdPASS;					/* 定义一个创建信息返回值，默认为 pdPASS */
    21.  
    22. 	BSP_Init();
    23. 	printf("按下 KEY1|KEY2 发送任务事件通知！\n");
    24. 	xReturn = xTaskCreate(	(TaskFunction_t )AppTaskCreate,			/* 任务入口函数 */
    25. 							(const char* )"AppTaskCreate",			/* 任务名字 */
    26. 							(uint16_t )512, 						/* 任务栈大小 */
    27. 							(void* )NULL,							/* 任务入口函数参数 */
    28. 							(UBaseType_t )1, 						/* 任务的优先级 */
    29. 							(TaskHandle_t*)&AppTaskCreate_Handle);	/* 任务控制块指针 */
    30.  
    31. 	if (pdPASS == xReturn)
    32. 		vTaskStartScheduler(); /* 启动任务，开启调度 */
    33. 	else
    34. 		return -1;
    35.  
    36. 	while (1); /* 正常不会执行到这里 */
    37.  }
    38.  
    39. static void AppTaskCreate(void)
    40. {
    41. 	BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为 pdPASS */
    42.  
    43. 	taskENTER_CRITICAL(); //进入临界区
    44.  
    45. 	/* 创建 Event_Handle */
    46. 	Event_Handle = xEventGroupCreate();
    47. 	if (NULL != Event_Handle)
    48. 		printf("Event_Handle 事件创建成功!\r\n");
    49.  
    50. 	xReturn = xTaskCreate(	(TaskFunction_t )LED_Task, 			/* 任务入口函数 */
    51. 							(const char* )"LED_Task",			/* 任务名字 */
    52. 							(uint16_t )512, 					/* 任务栈大小 */
    53. 							(void* )NULL, 						/* 任务入口函数参数 */
    54. 							(UBaseType_t )2, 					/* 任务的优先级 */
    55. 							(TaskHandle_t* )&LED_Task_Handle);	/* 任务控制块指针 */
    56. 	if (pdPASS == xReturn)
    57. 		printf("创建 LED_Task 任务成功!\r\n");
    58.  
    59. 	xReturn = xTaskCreate(	(TaskFunction_t )KEY_Task, 			/* 任务入口函数 */
    60. 							(const char* )"KEY_Task",			/* 任务名字 */
    61. 							(uint16_t )512, 					/* 任务栈大小 */
    62. 							(void* )NULL,						/* 任务入口函数参数 */
    63. 							(UBaseType_t )3, 					/* 任务的优先级 */
    64. 							(TaskHandle_t* )&KEY_Task_Handle);	/* 任务控制块指针 */
    65. 	if (pdPASS == xReturn)
    66. 		printf("创建 KEY_Task 任务成功!\n");
    67. 	
    68. 	vTaskDelete(AppTaskCreate_Handle); //删除 AppTaskCreate 任务
    69.  
    70. 	taskEXIT_CRITICAL(); //退出临界区
    71. }
    72.  
    73. static void LED_Task(void* parameter) 
    74. { 
    75. 	uint32_t r_event = 0; 			/* 定义一个事件接收变量 */ 
    76. 	uint32_t last_event = 0;		/* 定义一个保存事件的变量 */ 
    77. 	BaseType_t xReturn = pdTRUE;	/* 定义一个创建信息返回值，默认为 pdPASS */ 
    78.  
    79. 	while (1) 
    80. 	{ 
    81. 		/* BaseType_t xTaskNotifyWait(uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait ); 
    82. 		* ulBitsToClearOnEntry：当没有接收到任务通知的时候将任务通知值与此参数的取反值进行按位与运算，当此参数为 Oxfffff 或者 ULONG_MAX 的时候就会将任务通知值清零。 
    83. 		* ulBits ToClearOnExit：如果接收到了任务通知，在做完相应的处理退出函数之前将任务通知值与此参数的取反值进行按位与运算，当此参数为 0xfffff 或者 ULONG MAX 的时候就会将任务通知值清零。 
    84. 		* pulNotification Value：此参数用来保存任务通知值。 
    85. 		* xTick ToWait：阻塞时间。 
    86. 		* 
    87. 		* 返回值：pdTRUE：获取到了任务通知。pdFALSE：任务通知获取失败。 
    88. 		*/ 
    89. 		//获取任务通知 ,没获取到则一直等待 
    90. 		xReturn = xTaskNotifyWait(	0x0, 				//进入函数的时候不清除任务 bit 
    91. 									ULONG_MAX, 			//退出函数的时候清除所有的 bitR 
    92. 									&r_event, 			//保存任务通知值 
    93. 									portMAX_DELAY); 	//阻塞时间 
    94. 		if ( pdTRUE == xReturn ) 
    95. 		{ 
    96. 			last_event |= r_event; 
    97. 			/* 如果接收完成并且正确 */ 
    98. 			if (last_event == (KEY1_EVENT|KEY2_EVENT)) 
    99. 			{ 
    100. 				last_event = 0; /* 上一次的事件清零 */ 
    101. 				printf ( "Key1 与 Key2 都按下\n"); 
    102. 				LED1_TOGGLE; //LED1 反转 
    103. 			} else /* 否则就更新事件 */ 
    104. 			last_event = r_event; /* 更新上一次触发的事件 */ 
    105. 		} 
    106. 	} 
    107. }
    108.  
    109. static void KEY_Task(void* parameter) 
    110. {
    111. 	while (1) 
    112. 	{ 
    113. 		if ( Key_Scan(KEY1_GPIO_PORT,KEY1_GPIO_PIN) == KEY_ON ) 
    114. 		{ 
    115. 			printf ( "KEY1 被按下\n" ); 
    116. 			/* 原型:BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction ); 
    117. 			* eNoAction = 0，通知任务而不更新其通知值。 
    118. 			* eSetBits， 	 设置任务通知值中的位。 
    119. 			* eIncrement， 	 增加任务的通知值。 
    120. 			* eSetvaluewithoverwrite，覆盖当前通知 
    121. 			* eSetValueWithoutoverwrite 不覆盖当前通知 
    122. 			* 
    123. 			* pdFAIL：当参数 eAction 设置为 eSetValueWithoutOverwrite 的时候，如果任务通知值没有更新成功就返回 pdFAIL。 
    124. 			* pdPASS: eAction 设置为其他选项的时候统一返回 pdPASS。 
    125. 			*/ 
    126. 			/* 触发一个事件 1 */ 
    127. 			xTaskNotify((TaskHandle_t)LED_Task_Handle,//接收任务通知的任务句柄 
    128. 						(uint32_t)KEY1_EVENT, 		  //要触发的事件 
    129. 						(eNotifyAction)eSetBits); 	  //设置任务通知值中的位 
    130. 		} 
    131. 		
    132. 		if ( Key_Scan(KEY2_GPIO_PORT,KEY2_GPIO_PIN) == KEY_ON ) 
    133. 		{ 
    134. 			printf ( "KEY2 被按下\n" ); 
    135. 			/* 触发一个事件 2 */ 
    136. 			xTaskNotify((TaskHandle_t )LED_Task_Handle, //接收任务通知的任务句柄 
    137. 						(uint32_t )KEY2_EVENT, 			//要触发的事件 
    138. 						(eNotifyAction)eSetBits); 		//设置任务通知值中的位 
    139. 		} 			
    140. 		vTaskDelay(20); //每 20ms 扫描一次 
    141. 	} 
    142. }
  • 相关阅读:
    巧用 “火焰图” 快速分析链路性能
    记录小技巧--前端等所有的请求都结束了再刷新页面，button对齐input
    php操作服务器中json文件 进行读写操作用ajax交互
    Docker Registry 详解
    马斯克要求推特工程师默写代码，开始着手整顿美国职场？
    webgl着色器学习 - webpack 打包glsl文件
    网络工程师知识点7
    设计模式-结构型模式
    架构开发与优化咨询和实施服务
    java开源商城免费搭建 VR全景商城 saas商城 b2b2c商城 o2o商城 积分商城 秒杀商城 拼团商城 分销商城 短视频商城
  • 原文地址：https://blog.csdn.net/weixin_47077788/article/details/126022090