22.3 任务通知的数据结构

下面第51-53行

  1. typedef struct tskTaskControlBlock
  2. {
  3.     volatile StackType_t    *pxTopOfStack;    /*< Points to the location of the last item placed on the tasks stack.  THIS MUST BE THE FIRST MEMBER OF THE TCB STRUCT. */
  5.     #if ( portUSING_MPU_WRAPPERS == 1 )
  6.         xMPU_SETTINGS    xMPUSettings;        /*< The MPU settings are defined as part of the port layer.  THIS MUST BE THE SECOND MEMBER OF THE TCB STRUCT. */
  7.     #endif
  9.     ListItem_t            xStateListItem;        /*< The list that the state list item of a task is reference from denotes the state of that task (Ready, Blocked, Suspended ). */
  10.     ListItem_t            xEventListItem;        /*< Used to reference a task from an event list. */
  11.     UBaseType_t            uxPriority;            /*< The priority of the task.  0 is the lowest priority. */
  12.     StackType_t            *pxStack;            /*< Points to the start of the stack. */
  13.     char                pcTaskName[ configMAX_TASK_NAME_LEN ];/*< Descriptive name given to the task when created.  Facilitates debugging only. */ /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
  15.     #if ( portSTACK_GROWTH > 0 )
  16.         StackType_t        *pxEndOfStack;        /*< Points to the end of the stack on architectures where the stack grows up from low memory. */
  17.     #endif
  19.     #if ( portCRITICAL_NESTING_IN_TCB == 1 )
  20.         UBaseType_t        uxCriticalNesting;    /*< Holds the critical section nesting depth for ports that do not maintain their own count in the port layer. */
  21.     #endif
  23.     #if ( configUSE_TRACE_FACILITY == 1 )
  24.         UBaseType_t        uxTCBNumber;        /*< Stores a number that increments each time a TCB is created.  It allows debuggers to determine when a task has been deleted and then recreated. */
  25.         UBaseType_t        uxTaskNumber;        /*< Stores a number specifically for use by third party trace code. */
  26.     #endif
  28.     #if ( configUSE_MUTEXES == 1 )
  29.         UBaseType_t        uxBasePriority;        /*< The priority last assigned to the task - used by the priority inheritance mechanism. */
  30.         UBaseType_t        uxMutexesHeld;
  31.     #endif
  33.     #if ( configUSE_APPLICATION_TASK_TAG == 1 )
  34.         TaskHookFunction_t pxTaskTag;
  35.     #endif
  37.     #if( configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 )
  38.         void *pvThreadLocalStoragePointers[ configNUM_THREAD_LOCAL_STORAGE_POINTERS ];
  39.     #endif
  41.     #if( configGENERATE_RUN_TIME_STATS == 1 )
  42.         uint32_t        ulRunTimeCounter;    /*< Stores the amount of time the task has spent in the Running state. */
  43.     #endif
  45.     #if ( configUSE_NEWLIB_REENTRANT == 1 )
  46.         struct    _reent xNewLib_reent;
  47.     #endif
  49.     #if( configUSE_TASK_NOTIFICATIONS == 1 )
  50.         // 任务通知的值， 可以保存一个 32 位整数或指针值。
  51.         volatile uint32_t ulNotifiedValue;    
  52.         // 任务通知状态， 用于标识任务是否在等待通知。
  53.         volatile uint8_t ucNotifyState;
  54.     #endif
  56.     #if( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 )
  57.         uint8_t    ucStaticallyAllocated;         /*< Set to pdTRUE if the task is a statically allocated to ensure no attempt is made to free the memory. */
  58.     #endif
  60.     #if( INCLUDE_xTaskAbortDelay == 1 )
  61.         uint8_t ucDelayAborted;
  62.     #endif
  64. } tskTCB;

22.4 任务通知的函数接口讲解

功能 普通 中断
+1 操作 xTaskGenericNotify vTaskNotifyGiveFromISR
其它操作 xTaskNotify xTaskNotifyFromISR
带返回值的(之前的通知) xTaskNotifyAndQuery xTaskNotifyAndQueryFromISR

22.4.1 发送任务通知函数xTaskGenericNotify()

发送通知 API 函数。这类函数比较多，有 6 个。但仔细分析会发现它们只能完成 3 种操作，每种操作有两个 API 函数，分别为带中断保护版本和不带中断保护版本。
所有的函数都是一个宏定义， 在任务中发送任务通知的函数均是调用 xTaskGenericNotify()函数进行发送通知。

参数：
TaskHandle_t xTaskToNotify：被通知的任务句柄，指定通知的任务。
uint32_t ulValue：发送的通知值。
eNotifyAction eAction：枚举类型，指明更新通知值的方式。
uint32_t *pulPreviousNotificationValue：任务原本的通知值返回。

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

1.xTaskNotifyGive()

代替：二值信号量
xTaskNotifyGive()是一个宏，宏展开是调用函数 xTaskNotify( ( xTaskToNotify ), ( 0 ),eIncrement )， 即向一个任务发送通知，并将对方的任务通知值加 1。该函数可以作为二值信号量和计数信号量的一种轻量型的实现，速度更快， 在这种情况下对象任务在等待任务通 知 的 时 候 应 该 是 使 用 函 数 ulTaskNotifyTake() 而 不 是 xTaskNotifyWait() 。 xTaskNotifyGive() 不能在中断里面使用，而是使用具有中断保护功能的
vTaskNotifyGiveFromISR()来代替。
image.png
应用：

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

2.vTaskNotifyGiveFromISR()

vTaskNotifyGiveFromISR()是 vTaskNotifyGive()的中断保护版本。 用于在中断中向指定任务发送任务通知，并更新对方的任务通知值（加 1 操作） ，在某些场景中可以替代信号量操作，因为这两个通知都是不带有通知值的。
image.png
从上面的函数说明我们大概知道 vTaskNotifyGiveFromISR()函数作用， 每次调用该函数都会增加任务的通知值， 任务通过接收函数返回值是否大于零，判断是否获取到了通知，任务通知值初始化为 0， （如果与信号量做对比）则对应为信号量无效。当中断调用vTaskNotifyGiveFromISR()通知函数给任务的时候，任务的通知值增加，使其大于零，使其表示的通知值变为有效，任务获取有效的通知值将会被恢复。 

  1. #if( configUSE_TASK_NOTIFICATIONS == 1 )
  3. void vTaskNotifyGiveFromISR( TaskHandle_t xTaskToNotify, 
  4.                             BaseType_t *pxHigherPriorityTaskWoken )
  5. {
  6.     TCB_t * pxTCB;
  7.     uint8_t ucOriginalNotifyState;
  8.     UBaseType_t uxSavedInterruptStatus;
  9.     // 获取通知的任务块
  10.     pxTCB = ( TCB_t * ) xTaskToNotify;
  11.     //进入中断
  12.     uxSavedInterruptSta    tus = portSET_INTERRUPT_MASK_FROM_ISR();
  13.     {
  14.         //保存任务通知的原始状态，
  15.         //看看任务是否在等待通知，方便在发送通知后恢复任务
  16.         ucOriginalNotifyState = pxTCB->ucNotifyState;
  17.         pxTCB->ucNotifyState = taskNOTIFICATION_RECEIVED;
  19.         /* 通知值自加，类似于信号量的释放 */
  20.         ( pxTCB->ulNotifiedValue )++;
  22.         traceTASK_NOTIFY_GIVE_FROM_ISR();
  24.         /* 如果任务在阻塞等待通知 */
  25.         if( ucOriginalNotifyState == taskWAITING_NOTIFICATION )
  26.         {
  27.             //如果任务调度器运行中
  28.             configASSERT( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) == NULL );
  30.             if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )
  31.             {
  32.                 /* 唤醒任务，将任务从阻塞列表中移除，添加到就绪列表中 */
  33.                 ( void ) uxListRemove( &( pxTCB->xStateListItem ) );
  34.                 prvAddTaskToReadyList( pxTCB );
  35.             }
  36.             else
  37.             {
  38.                 /* 调度器处于挂起状态，中断依然正常发生，但是不能直接操作就绪列表
  39.                 将任务加入到就绪挂起列表，任务调度恢复后会移动到就绪列表 */
  40.                 vListInsertEnd( &( xPendingReadyList ), &( pxTCB->xEventListItem ) );
  41.             }
  43.             // 判断优先级 是否需要切换上下文
  44.             if( pxTCB->uxPriority > pxCurrentTCB->uxPriority )
  45.             {
  47.                 if( pxHigherPriorityTaskWoken != NULL )
  48.                 {
  49.                     *pxHigherPriorityTaskWoken = pdTRUE;
  50.                 }
  51.                 else
  52.                 {
  53.                     // 切换标志
  54.                     xYieldPending = pdTRUE;
  55.                 }
  56.             }
  57.             else
  58.             {
  59.                 mtCOVERAGE_TEST_MARKER();
  60.             }
  61.         }
  62.     }
  63.     portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
  64. }
  66. #endif /* configUSE_TASK_NOTIFICATIONS */
  68. /*-----------------------------------------------------------*/

使用示例：
DMA使用

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

3. xTaskNotify()

推荐：代替事件组
FreeRTOS 每个任务都有一个 32 位的变量用于实现任务通知，在任务创建的时候初始化为 0。 这个 32 位的通知值在任务控制块 TCB 里面定义，具体见代码清单 22-6。xTaskNotify()用于在任务中直接向另外一个任务发送一个事件， 接收到该任务通知的任务有可能解锁。 如果你想使用任务通知来实现二值信号量和计数信号量，那么应该使用更加简单的函数 xTaskNotifyGive() ， 而不是使用 xTaskNotify()， xTaskNotify()函数在发送任务通知的时候会指定一个通知值， 并且用户可以指定通知值发送的方式。
注意：该函数不能在中断里面使用， 而是使用具体中断保护功能的版本函数xTaskNotifyFromISR()。
任务通知在任务控制块中的定义：

  1. #if( configUSE_TASK_NOTIFICATIONS == 1 )
  2.     volatile uint32_t ulNotifiedValue;
  3.     volatile uint8_t ucNotifyState;
  4. #endif

image.png
image.png
示例：

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

4.xTaskNotifyFrmoISR()

xTaskNotifyFromISR()是 xTaskNotify()的中断保护版本，真正起作用的函数是中断发送任务通知通用函数 xTaskGenericNotifyFromISR()，而 xTaskNotifyFromISR()是一个宏定义，.

  1. #define xTaskNotifyFromISR( xTaskToNotify,         \
  2.                             ulValue,     \
  3.                             eAction,     \
  4.                             pxHigherPriorityTaskWoken )     \
  5.   xTaskGenericNotifyFromISR( ( xTaskToNotify ),     \
  6.                             ( ulValue ),             \
  7.                             ( eAction ),            \
  8.                             NULL,                     \
  9.                             ( pxHigherPriorityTaskWoken ) )


image.png

5.中断中发送任务通知通用函数 xTaskGenericNotifyFromISR()

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

参数：
TaskHandle_t xTaskToNotify：指定接收通知的任务句柄
uint32_t ulValue：用于更新接收任务通知值， 具体如何更新由形参 eAction 决定。
eNotifyAction eAction：任务通知值更新方式。
uint32_t pulPreviousNotificationValue：用于保存任务上一个通知值。
BaseType_t pxHigherPriorityTaskWoken：中断切换上下文

  1. #if( configUSE_TASK_NOTIFICATIONS == 1 )
  3. BaseType_t xTaskGenericNotifyFromISR( TaskHandle_t xTaskToNotify, 
  4.                                      uint32_t ulValue, 
  5.                                      eNotifyAction eAction, 
  6.                                      uint32_t *pulPreviousNotificationValue, 
  7.                                      BaseType_t *pxHigherPriorityTaskWoken )
  8. {
  9.     TCB_t * pxTCB;
  10.     uint8_t ucOriginalNotifyState;
  11.     BaseType_t xReturn = pdPASS;
  12.     UBaseType_t uxSavedInterruptStatus;
  14.     configASSERT( xTaskToNotify );
  16.     portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
  18.     // 获取要通知任务的PCB
  19.     pxTCB = ( TCB_t * ) xTaskToNotify;
  20.     // 临界区
  21.     uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
  22.     {
  23.         if( pulPreviousNotificationValue != NULL )
  24.         {
  25.             // 保存之前的通知值
  26.             *pulPreviousNotificationValue = pxTCB->ulNotifiedValue;
  27.         }
  29.         // 获取当前通知的状态
  30.         ucOriginalNotifyState = pxTCB->ucNotifyState;
  31.         // 设置标记位
  32.         pxTCB->ucNotifyState = taskNOTIFICATION_RECEIVED;
  34.         // 根据情况进行处理 到这里基本和普通任务是一样的
  35.         switch( eAction )
  36.         {
  37.             case eSetBits    :
  38.                 pxTCB->ulNotifiedValue |= ulValue;
  39.                 break;
  41.             case eIncrement    :
  42.                 ( pxTCB->ulNotifiedValue )++;
  43.                 break;
  45.             case eSetValueWithOverwrite    :
  46.                 pxTCB->ulNotifiedValue = ulValue;
  47.                 break;
  49.             case eSetValueWithoutOverwrite :
  50.                 if( ucOriginalNotifyState != taskNOTIFICATION_RECEIVED )
  51.                 {
  52.                     pxTCB->ulNotifiedValue = ulValue;
  53.                 }
  54.                 else
  55.                 {
  56.                     xReturn = pdFAIL;
  57.                 }
  58.                 break;
  60.             case eNoAction :
  62.                 break;
  63.         }
  64.         // 退出
  65.         traceTASK_NOTIFY_FROM_ISR();
  67.         /* 如果任务在阻塞等待通知 */
  68.         if( ucOriginalNotifyState == taskWAITING_NOTIFICATION )
  69.         {
  70.             //如果任务调度器运行中，表示可用操作就绪级列表
  71.             configASSERT( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) == NULL );
  72.             /* 唤醒任务，将任务从阻塞列表中移除，添加到就绪列表中 */
  73.             if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )
  74.             {
  75.                 ( void ) uxListRemove( &( pxTCB->xStateListItem ) );
  76.                 prvAddTaskToReadyList( pxTCB );
  77.             }
  78.             else
  79.             {
  80.                 // 否则放入挂起列表
  81.                 vListInsertEnd( &( xPendingReadyList ), &( pxTCB->xEventListItem ) );
  82.             }
  83.             // 刚刚唤醒的任务优先级比当前任务高
  84.             if( pxTCB->uxPriority > pxCurrentTCB->uxPriority )
  85.             {
  86.                 if( pxHigherPriorityTaskWoken != NULL )
  87.                 {
  88.                     // 设置为TRUE 中断处理完要进行切换
  89.                     *pxHigherPriorityTaskWoken = pdTRUE;
  90.                 }
  91.                 else
  92.                 {
  93.                     xYieldPending = pdTRUE;
  94.                 }
  95.             }
  96.             else
  97.             {
  98.                 mtCOVERAGE_TEST_MARKER();
  99.             }
  100.         }
  101.     }
  102.     portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
  104.     return xReturn;
  105. }
  107. #endif /* configUSE_TASK_NOTIFICATIONS */
  108. /*-----------------------------------------------------------*/


使用示例：

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

6.xTaskNotifyAndQuery()

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

  1. #define xTaskNotifyAndQuery( xTaskToNotify,             \
  2.                             ulValue,     \
  3.                             eAction,     \
  4.                             pulPreviousNotifyValue )     \
  5.     xTaskGenericNotify( ( xTaskToNotify ),     \
  6.                        ( ulValue ),     \
  7.                        ( eAction ),    \
  8.                        ( pulPreviousNotifyValue ) )

image.png

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

7.xTaskNotifyAndQueryFromISR()

image.png

  1. void vAnISR( void )
  2. {
  3.     /* xHigherPriorityTaskWoken 在使用之前必须设置为 pdFALSE */
  4.     BaseType_t xHigherPriorityTaskWoken = pdFALSE;
  5.     uint32_t ulPreviousValue;
  6.     /* 设置目标任务 xTask1Handle 的任务通知值的位 8 为 1
  7.     在任务通知值的位 8 被更新之前把上一次的值存储在变量 ulPreviousValue 中*/
  8.     xTaskNotifyAndQueryFromISR( xTask1Handle, 
  9.                                ( 1UL << 8UL ), 
  10.                                eSetBits,
  11.                                &ulPreviousValue,
  12.                                &xHigherPriorityTaskWoken);
  13.     portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
  15. }

22.4.2 获取任务通知函数

获取任务通知函数只能用在任 中，没有带中断保护版本，因 此只有两 个 API 函 数： ulTaskNotifyTake() 和
xTaskNotifyWait ()。前者是为代替二值信号量和计数信号量而专门设计的，它和发送通知API 函数 xTaskNotifyGive()、 vTaskNotifyGiveFromISR()配合使用；后者是全功能版的等待通知，可以根据不同的参数实现轻量级二值信号量、计数信号量、事件组和长度为 1 的队列。

1.ulTaskNotifyTake()

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

  1. 在函数退出时将通知值清零，这种方法适用于实现二值信号量
  2. 在函数退出时将通知值减 1， 这种方法适用于实现计数信号量

当一个任务使用其自身的任务通知值作为二值信号量或者计数信号量时， 其他任务应该使用函数 xTaskNotifyGive()或者 xTaskNotify( ( xTaskToNotify ), ( 0 ), eIncrement )来向其发送信号量。
image.png
ulTaskNotifyTake（）

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

使用示例：

  1. /* 中断服务程序：向一个任务发送任务通知 */
  3. void vANInterruptHandler( void )
  4. {
  5.     BaseType_t xHigherPriorityTaskWoken;
  7.     /* 清除中断 */
  8.     prvClearInterruptSource();
  10.     xHigherPriorityTaskWoken = pdFALSE;
  12.     /* 发送任务通知，并解锁阻塞在该任务通知下的任务 */
  13.     vTaskNotifyGiveFromISR( xHandlingTask, &xHigherPriorityTaskWoken );
  15.     portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
  17. }
  19. /* 任务：阻塞在一个任务通知上 */
  21. void vHandlingTask( void *pvParameters )
  22. {
  23.     for ( ;; ) {
  24.         ulTaskNotifyTake( pdTRUE, /* 在退出前清 0 任务通知值 */
  25.                          portMAX_DELAY ); /* 无限阻塞 */
  27.         /* RTOS 任务通知被当作二值信号量使用
  28.         当处理完所有的事情后继续等待下一个任务通知*/
  29.         do {
  30.             xEvent = xQueryPeripheral();
  32.             if ( xEvent != NO_MORE_EVENTS ) {
  33.                 vProcessPeripheralEvent( xEvent );
  34.             }
  35.         }while ( xEvent != NO_MORE_EVENTS );
  37.     }
  38. }

2.xTaskNotifyWait()

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

  1. #if( configUSE_TASK_NOTIFICATIONS == 1 )
  3. BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, 
  4.                            uint32_t ulBitsToClearOnExit,
  5.                            uint32_t *pulNotificationValue, 
  6.                            TickType_t xTicksToWait )
  7. {
  8.     BaseType_t xReturn;
  10.     taskENTER_CRITICAL();    // 进入临界区
  11.     {
  12.         /* 只有任务当前没有收到任务通知，才会将任务阻塞 */
  13.         if( pxCurrentTCB->ucNotifyState != taskNOTIFICATION_RECEIVED )
  14.         {
  15.             /* 使用任务通知值之前,根据用户指定参数 ulBitsToClearOnEntryClear
  16.             将通知值的某些或全部位清零 */
  17.             pxCurrentTCB->ulNotifiedValue &= ~ulBitsToClearOnEntry;
  19.             /* 设置任务状态标识:等待通知 */
  20.             pxCurrentTCB->ucNotifyState = taskWAITING_NOTIFICATION;
  22.             /* 设置阻塞，添加到延迟列表 */
  23.             if( xTicksToWait > ( TickType_t ) 0 )
  24.             {
  25.                 prvAddCurrentTaskToDelayedList( xTicksToWait, pdTRUE );
  26.                 traceTASK_NOTIFY_WAIT_BLOCK();
  28.                 portYIELD_WITHIN_API();
  29.             }
  30.             else
  31.             {
  32.                 mtCOVERAGE_TEST_MARKER();
  33.             }
  34.         }
  35.         else
  36.         {
  37.             mtCOVERAGE_TEST_MARKER();
  38.         }
  39.     }
  40.     taskEXIT_CRITICAL();
  42.     /* 等到通知 */
  43.     taskENTER_CRITICAL();
  44.     {
  45.         traceTASK_NOTIFY_WAIT();
  46.         /* 判断是不是无效的参数 */
  47.         if( pulNotificationValue != NULL )
  48.         {
  49.             /* 返回当前通知值,通过指针参数传递 */
  50.             *pulNotificationValue = pxCurrentTCB->ulNotifiedValue;
  51.         }
  52.         /* 判断是否是因为任务阻塞超时，因为如果有
  53.         任务发送了通知的话，任务通知状态会被改变 */
  54.         if( pxCurrentTCB->ucNotifyState == taskWAITING_NOTIFICATION )
  55.         {
  56.             /* 没有收到任务通知,是阻塞超时 */
  57.             xReturn = pdFALSE;
  58.         }
  59.         else
  60.         {
  61.             /* 收到任务值,先将参数 ulBitsToClearOnExit 取反后与通知值位做按位与运算
  62.             在退出函数前,将通知值的某些或者全部位清零. */
  63.             pxCurrentTCB->ulNotifiedValue &= ~ulBitsToClearOnExit;
  65.             xReturn = pdTRUE;
  66.         }
  68.         // 设置任务的通知状态
  69.         pxCurrentTCB->ucNotifyState = taskNOT_WAITING_NOTIFICATION;
  70.     }
  71.     taskEXIT_CRITICAL();
  73.     return xReturn;
  74. }
  76. #endif /* configUSE_TASK_NOTIFICATIONS */
  77. /*-----------------------------------------------------------*/


使用示例：
这个通知的话

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