FreeTROS任务与任务通知

朱工FreeRTOS高级篇

一、FreeTROS 任务创建

1.1 任务创建

1.1.1 xTackCreate()

创建任务，需要RAM来保存与任务有关的状态信息（任务控制块），FreeRTOS自动从堆中分配RAM，因此需要使用内存管理文件heap_4.c。宏configSUPPORT_DYNAMIC_ALLOCATION必须为1.

                   BaseType_t xTaskCreate(
                            TaskFunction_t pvTaskCode,
                            const char * const pcName,
                            unsigned short usStackDepth,
                            void *pvParameters,
                            UBaseType_t uxPriority,
                            TaskHandle_t * pvCreatedTask
                          );
  • pvTaskCode：指针，指向任务函数的入口。任务永远不会返回（位于死循环内）。该参数类型TaskFunction_t定义在文件projdefs.h中，定义为：typedefvoid (*TaskFunction_t)( void * )。
  • pcName：任务描述。主要用于调试。字符串的最大长度由宏configMAX_TASK_NAME_LEN指定，该宏位于FreeRTOSConfig.h文件中。
  • usStackDepth：指定任务堆栈大小，能够支持的堆栈变量数量，而不是字节数。比如，在16位宽度的堆栈下，usStackDepth定义为100，则实际使用200字节堆栈存储空间。堆栈的宽度乘以深度必须不超过size_t类型所能表示的最大值。比如，size_t为16位，则可以表示的最大值是65535。
  • pvParameters：指针，当任务创建时，作为一个参数传递给任务。
  • uxPriority：任务的优先级。具有MPU支持的系统，可以通过置位优先级参数的portPRIVILEGE_BIT位，随意的在特权（系统）模式下创建任务。比如，创建一个优先级为2的特权任务，参数uxPriority可以设置为( 2 | - portPRIVILEGE_BIT )。
  • pvCreatedTask：用于回传一个句柄（ID），创建任务后可以使用这个句柄引用任务。
    PS:xTaskCreate()看上去很像函数，但其实是一个宏，真正被调用的函数是xTaskGenericCreate()
#define xTaskCreate( pvTaskCode, pcName, usStackDepth,pvParameters, uxPriority, pxCreatedTask )    \
      xTaskGenericCreate( ( pvTaskCode ),( pcName ), ( usStackDepth ), ( pvParameters ), ( uxPriority ), ( pxCreatedTask), ( NULL ), ( NULL ), ( NULL ) )

1.1.2 任务控制块

任务TCB（任务控制块），用于存储任务的状态信息，包括任务运行时的环境。每个任务都有自己的任务TCB，任务TCB是一个相对比较大的数据结构，与任务相关的代码占到整个FreeRTOS代码量的一半左右。

typedef struct tskTaskControlBlock
{
    volatile StackType_t    *pxTopOfStack; /*当前堆栈的栈顶,必须位于结构体的第一项*/
 
    #if ( portUSING_MPU_WRAPPERS == 1 )
        xMPU_SETTINGS   xMPUSettings;      /*MPU设置,必须位于结构体的第二项*/
    #endif
 //调度器就是通过把任务TCB中的状态列表项xStateListItem
//和事件列表项xEventListItem挂接到不同的列表中来实现上述过程的。
    ListItem_t          xStateListItem; /*任务的状态列表项，以引用的方式表示任务的状态*/
    ListItem_t          xEventListItem;    /*事件列表项，用于将任务以引用的方式挂接到事件列表*/
    UBaseType_t         uxPriority;        /*保存任务优先级，0表示最低优先级*/
    StackType_t         *pxStack;           /*指向堆栈的起始位置*/
    char               pcTaskName[ configMAX_TASK_NAME_LEN ];/*任务名字*/
 
    #if ( portSTACK_GROWTH > 0 )//向上增长
        StackType_t     *pxEndOfStack;     /*指向堆栈的尾部，用于检测是否溢出*/
    #endif
 
    #if ( portCRITICAL_NESTING_IN_TCB == 1 )
        UBaseType_t     uxCriticalNesting; /*保存临界区嵌套深度*/
    #endif
 
    #if ( configUSE_TRACE_FACILITY == 1 )
        UBaseType_t     uxTCBNumber;       /*保存一个数值，每个任务都有唯一的值，由内核指定*/
        UBaseType_t     uxTaskNumber;      /*存储一个特定数值，由参数指定*/
    #endif
 
    #if ( configUSE_MUTEXES == 1 )
        UBaseType_t     uxBasePriority;    /*保存任务的基础优先级*/
        UBaseType_t     uxMutexesHeld;
    #endif
 
    #if ( configUSE_APPLICATION_TASK_TAG == 1 )
        TaskHookFunction_t pxTaskTag;
    #endif
 
    #if( configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 )
        void *pvThreadLocalStoragePointers[configNUM_THREAD_LOCAL_STORAGE_POINTERS ];
    #endif
 
    #if( configGENERATE_RUN_TIME_STATS == 1 )
        uint32_t        ulRunTimeCounter;  /*记录任务在运行状态下执行的总时间*/
    #endif
 
    #if ( configUSE_NEWLIB_REENTRANT == 1 )
        /* 为任务分配一个Newlibreent结构体变量。Newlib是一个C库函数，并非FreeRTOS维护，FreeRTOS也不对使用结果负责。如果用户使用Newlib，必须熟知Newlib的细节*/
        struct _reent xNewLib_reent;
    #endif
 
    #if( configUSE_TASK_NOTIFICATIONS == 1 )
        volatile uint32_t ulNotifiedValue; /*与任务通知相关*/
        volatile uint8_t ucNotifyState;
    #endif
 
    #if( configSUPPORT_STATIC_ALLOCATION == 1 )
        uint8_t ucStaticAllocationFlags; /* 如果堆栈由静态数组分配，则设置为pdTRUE，如果堆栈是动态分配的，则设置为pdFALSE*/
    #endif
 
    #if( INCLUDE_xTaskAbortDelay == 1 )
        uint8_t ucDelayAborted;
    #endif
 
} tskTCB;
 
typedef tskTCB TCB_t;

TCB中指针pxTopOfStack和pxStack的区别
pxTopOfStack指向当前堆栈栈顶，随着进栈出栈，pxTopOfStack指向的位置是会变化的；pxStack指向当前堆栈的起始位置，一经分配后，堆栈起始位置就固定了，不会被改变了。那么为什么需要pxStack变量呢，这是因为随着任务的运行，堆栈可能会溢出，在堆栈向下增长的系统中，这个变量可用于检查堆栈是否溢出；

1.1.3 创建任务堆栈和任务TCB

调用函数prvAllocateTCBAndStack()创建任务堆栈和任务TCB。
两种：动态内存分配和静态变量来实现。
pvPortMallocAligned：分配堆栈空间和TCB空间

static TCB_t *prvAllocateTCBAndStack( const uint16_t usStackDepth, StackType_t * const puxStackBuffer, TCB_t * const pxTaskBuffer )
{
TCB_t *pxNewTCB;
StackType_t *pxStack;
 
    /* 分配堆栈空间*/
    pxStack = ( StackType_t * ) pvPortMallocAligned( ( ( ( size_t ) usStackDepth ) * sizeof( StackType_t ) ), puxStackBuffer );
    if( pxStack != NULL )
    {
        /* 分配TCB空间 */
        pxNewTCB = ( TCB_t * ) pvPortMallocAligned( sizeof( TCB_t ), pxTaskBuffer );
 
        if( pxNewTCB != NULL )
        {
            /* 将堆栈起始位置存入TCB*/
            pxNewTCB->pxStack = pxStack;
        }
        else
        {
            /* 如果TCB分配失败，释放之前申请的堆栈空间 */
            if( puxStackBuffer == NULL )
            {
                vPortFree( pxStack );
            }
        }
    }
    else
    {
        pxNewTCB = NULL;
    }
 
    if( pxNewTCB != NULL )
    {
        /* 如果需要，使用固定值填充堆栈 */
        #if( ( configCHECK_FOR_STACK_OVERFLOW> 1 ) || ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark== 1 ) )
        {
            /* 仅用于调试 */
            ( void ) memset( pxNewTCB->pxStack, ( int ) tskSTACK_FILL_BYTE, ( size_t ) usStackDepth * sizeof( StackType_t ) );
        }
        #endif
    }
 
    return pxNewTCB;
}

1.1.4 任务属性初始化

  1. 调用函数prvInitialiseTCBVariables()初始化任务TCB必要的字段。
  2. 调用函数pxPortInitialiseStack()初始化任务堆栈，并将最新的栈顶指针赋值给任务TCB的pxTopOfStack字段。对于不同的硬件架构，入栈的寄存器也不相同。
  3. 调用taskENTER_CRITICAL()进入临界区
  4. 在tasks.c中 ，定义了一些静态私有变量，用来跟踪任务的数量或者状态等等，其中变量uxCurrentNumberOfTasks表示当前任务的总数量，每创建一个任务，这个变量都会增加1。
  5. 如果这是第一个任务（uxCurrentNumberOfTasks等于1），则调用函数prvInitialiseTaskLists()初始化任务列表。
  6. 更新当前正在运行的任务TCB指针。
    PRIVILEGED_DATA TCB_t * volatile pxCurrentTCB= NULL
    这个变量用来指向当前正在运行的任务TCB。
    FreeRTOS的核心是确保处于优先级最高的就绪任务获得CPU运行权，任务切换就是找到优先级最高的就绪任务，而找出的这个最高优先级任务的TCB，就被赋给变量pxCurrentTCB。
  7. 将新创建的任务加入就绪列表数组
    调用prvAddTaskToReadyList(pxNewTCB)将创建的任务TCB加入到就绪列表数组中，任务的优先级确定了加入到就绪列表数组的哪个下标。
  8. 退出临界区：调用taskEXIT_CRITICAL()退出临界区，这是一个宏定义，最终退出临界区的代码由移植层提供。
  9. 执行上下文切换：判断当前任务的优先级是否大于新创建的任务优先级。如果新创建的任务优先级更高，则调用taskYIELD_IF_USING_PREEMPTION()强制进行一次上下文切换，切换后，新创建的任务将获得CPU控制权

1.1.5 任务删除 vTaskDelete()

voidvTaskDelete( TaskHandle_t xTask );
用户创建的内存需要用户自行释放掉，如调用vPortFree()将字节的内存释放掉，否则将导致内存泄露。
xTask：被删除任务的句柄。为NULL表示删除当前任务。

动态创建任务：

//任务优先级
#define START_TASK_PRIO     1
//任务堆栈大小    
#define START_STK_SIZE      128  
//任务句柄
TaskHandle_t StartTask_Handler;
//任务函数
void start_task(void *pvParameters);

int main(){
    //创建开始任务
    xTaskCreate((TaskFunction_t )start_task,            //任务函数
                (const char*    )"start_task",          //任务名称
                (uint16_t       )START_STK_SIZE,        //任务堆栈大小
                (void*          )NULL,                  //传递给任务函数的参数
                (UBaseType_t    )START_TASK_PRIO,       //任务优先级
                (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    vTaskStartScheduler();          //开启任务调度,FreeRTOS开始运行
}

//开始任务任务函数
void start_task(void *pvParameters)
{
    taskENTER_CRITICAL();           //进入临界区
    ...
    vTaskDelete(StartTask_Handler); //删除开始任务,这里的参数就是start_task任务的任务句柄。
    taskEXIT_CRITICAL();            //退出临界区
}

1.2 FreeRTOS任务控制

FreeRTOS任务控制API函数主要实现任务延时、任务挂起、解除任务挂起、任务优先级获取和设置等功能。

1.2.1 相对延时

void vTaskDelay( portTickTypexTicksToDelay )
调用vTaskDelay()函数后，任务会进入阻塞状态，持续时间由vTaskDelay()函数的参数xTicksToDelay指定，单位是系统节拍时钟周期。在文件FreeRTOSConfig.h中，宏INCLUDE_vTaskDelay 必须设置成1，此函数才能有效。

voidvTaskFunction( void * pvParameters )
 {
     /* 阻塞500ms. */
     constportTickType xDelay = 500 / portTICK_RATE_MS;
 
     for( ;; )
     {
         /* 每隔500ms触发一次LED， 触发后进入阻塞状态 */
         vToggleLED();
         vTaskDelay( xDelay );
     }
}

1.2.2 绝对延时

void vTaskDelayUntil( TickType_t *pxPreviousWakeTime, const TickType_txTimeIncrement );

  • pxPreviousWakeTime：指针，指向一个变量，该变量保存任务最后一次解除阻塞的时间。第一次使用前，该变量必须初始化为当前时间。之后这个变量会在vTaskDelayUntil()函数内自动更新。
  • xTimeIncrement：周期循环时间。当时间等于(*pxPreviousWakeTime + xTimeIncrement)时，任务解除阻塞。如果不改变参数xTimeIncrement的值，调用该函数的任务会按照固定频率执行。

这个函数不同于vTaskDelay()函数的一个重要之处在于：vTaskDelay()指定的延时时间是从调用vTaskDelay()之后（执行完该函数）开始算起的，但是vTaskDelayUntil()指定的延时时间是一个绝对时间，每当时间到达，则解除任务阻塞。

//每10次系统节拍执行一次
 void vTaskFunction( void * pvParameters )
 {
     static portTickType xLastWakeTime;
     const portTickType xFrequency = 10;
 
     // 使用当前时间初始化变量xLastWakeTime
     xLastWakeTime = xTaskGetTickCount();
 
     for( ;; )
     {
         //等待下一个周期
         vTaskDelayUntil( &xLastWakeTime,xFrequency );
 
         // 需要周期性执行代码放在这里
     }
 }

1.2.3 获取任务优先级

UBaseType_t uxTaskPriorityGet(TaskHandle_t xTask );
xTask：任务句柄。NULL表示获取当前任务的优先级。

1.2.4 设置任务优先级

设置指定任务的优先级。如果设置的优先级高于当前运行的任务，在函数返回前会进行一次上下文切换
void vTaskPrioritySet( TaskHandle_txTask, UBaseType_tuxNewPriority );

xTask：要设置优先级任务的句柄，为NULL表示设置当前运行的任务。
uxNewPriority：要设置的新优先级。

voidvAFunction( void )
 {
     xTaskHandle xHandle;
     // 创建任务，保存任务句柄。
     xTaskCreate( vTaskCode, "NAME",STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
     // ...
     // 使用句柄来提高创建任务的优先级
     vTaskPrioritySet( xHandle,tskIDLE_PRIORITY + 1 );
     // ...
     // 使用NULL参数来提高当前任务的优先级，设置成和创建的任务相同。
     vTaskPrioritySet( NULL, tskIDLE_PRIORITY +1 );
 }

1.2.5 任务挂起

挂起指定任务。被挂起的任务绝不会得到处理器时间，不管该任务具有什么优先级。
void vTaskSuspend( TaskHandle_txTaskToSuspend );

xTaskToSuspend：要挂起的任务句柄。为NULL表示挂起当前任务。

1.2.6 恢复挂起的任务

void vTaskResume( TaskHandle_txTaskToResume );

voidvAFunction( void )
 {
         xTaskHandle xHandle;
     // 创建任务，保存任务句柄
     xTaskCreate( vTaskCode, "NAME",STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
     // ...
     // 使用句柄挂起创建的任务
     vTaskSuspend( xHandle );
     // ...
     //任务不再运行，除非其它任务调用了vTaskResume(xHandle )    
          //...
     // 恢复挂起的任务.
     vTaskResume( xHandle );
     // 任务再一次得到处理器时间
     // 任务优先级与之前相同
 }

1.2.7 恢复挂起的任务（在中断服务函数中使用）

BaseType_t xTaskResumeFromISR(TaskHandle_t xTaskToResume );
用于恢复一个挂起的任务，用在ISR中。

xTaskHandlexHandle;               //注意这是一个全局变量
 
 void vAFunction( void )
 {
     // 创建任务并保存任务句柄
     xTaskCreate( vTaskCode, "NAME",STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
 
     // ... 剩余代码.
 }
 
 void vTaskCode( void *pvParameters )
 {
     for( ;; )
     {
         // ... 在这里执行一些其它功能
 
         // 挂起自己
         vTaskSuspend( NULL );
 
         //直到ISR恢复它之前，任务会一直挂起
     }
 }
 
 void vAnExampleISR( void )
 {
     portBASE_TYPE xYieldRequired;
 
     // 恢复被挂起的任务
     xYieldRequired = xTaskResumeFromISR(xHandle );
 
     if( xYieldRequired == pdTRUE )
     {
         // 我们应该进行一次上下文切换
         // 注:  如何做取决于你具体使用，可查看说明文档和例程
         portYIELD_FROM_ISR();
     }
 }

1.3 任务应用函数

任务应用函数是一组辅助类函数，一般用于调试信息输出、获取任务句柄、获取任务状态、操作任务标签值等等。
FreeRTOS任务应用函数

  1. 获取任务系统状态：UBaseType_t uxTaskGetSystemState(...)
  2. 获取当前任务句柄 TaskHandle_t xTaskGetCurrentTaskHandle(void );
  3. 获取空闲任务句柄 TaskHandle_t xTaskGetIdleTaskHandle(void );
  4. 获取任务堆栈最大使用深度 UBaseType_t uxTaskGetStackHighWaterMark( TaskHandle_t xTask );
    可以间接估算出一个任务最多需要多少堆栈空间
  5. 获取任务状态 eTaskState eTaskGetState( TaskHandle_txTask );
  6. 获取调度器状态 BaseType_t xTaskGetSchedulerState( void);
  7. 获取任务运行时间 void vTaskGetRunTimeStats( char*pcWriteBuffer );

二、 任务通知

任务通知。在大多数情况下，任务通知可以替代二进制信号量、计数信号量、事件组，可以替代长度为1的队列（可以保存一个32位整数或指针值），并且任务通知速度更快、使用的RAM更少。
每个RTOS任务都有一个32位的通知值，任务创建时，这个值被初始化为0。RTOS任务通知相当于直接向任务发送一个事件，接收到通知的任务可以解除阻塞状态，前提是这个阻塞事件是因等待通知而引起的。发送通知的同时，也可以可选的改变接收任务的通知值。
相比于使用信号量解除任务阻塞，使用任务通知可以快45%、使用更少的RAM

局限：任务通知有它自己的局限性，并不能完全代替信号量。

  • 一个任务只能阻塞到一个通知上，如想要实现多个任务阻塞到同一个事件上，只能使用信号量了。也正是因为这种局限性，使得任务通知实现起来简单高效，并且大多数情况下，任务通知的方法就已经能解决问题了。
  • 接收通知的任务可以因为等待通知而进入阻塞状态，但是发送通知的任务即便不能立即完成发送通知，也不能进入阻塞状态。

任务通知的数据结构嵌在任务TCB 。这两个字段占用5字节RAM（本文都是在32位系统下讨论），而一个队列数据结构至少占用76字节RAM！这不是同一数量级的，所以任务通知在RAM消耗上完胜。

volatile uint32_t ulNotifiedValue;  /*任务通知值*/  
volatile uint8_t ucNotifyState; /*任务通知状态，标识任务是否在等待通知等*/

在使用队列、信号量前，必须先创建队列和信号量，目的是为了创建队列数据结构。比如使用API函数xQueueCreate()创建队列，用API函数xSemaphoreCreateBinary()创建二进制信号量等等。再来看任务通知，由于任务通知的数据结构包含在任务TCB中，只要任务存在，任务通知数据结构就已经创建完毕，可以直接使用！在易用性上，任务通知再次获胜。
只有任务可以等待通知，中断服务函数中不可以。如果等待的通知无效，任务会进入阻塞状态，我们可以将等待通知的任务看作是消费者；其它任务和中断可以向等待通知的任务发送通知，发送通知的任务和中断服务函数可以认为是生产者。处于阻塞的消费者得到通知后会再次进入就绪态。

2.1 发送通知

使用API函数xTaskNotify()和xTaskNotifyGive()（中断保护等价函数为xTaskNotifyFromISR()和vTaskNotifyGiveFromISR()）发送通知。
收RTOS任务调用API函数xTaskNotifyWait()或ulTaskNotifyTake()。
限制：
只能有一个任务接收通知事件。
接收通知的任务可以因为等待通知而进入阻塞状态，但是发送通知的任务即便不能立即完成通知发送也不能进入阻塞状态。

BaseType_t xTaskGenericNotify( 
        TaskHandle_t xTaskToNotify, 
        uint32_t ulValue, 
        eNotifyAction eAction, 
        uint32_t *pulPreviousNotificationValue )

xTaskToNotify：被通知的任务句柄。
ulValue：更新的通知值
eAction：枚举类型，指明更新通知值的方法
pulPreviousNotifyValue：回传未被更新的任务通知值。如果不需要回传未被更新的任务通知值，这里设置为NULL


BaseType_t xTaskGenericNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue )
{
TCB_t * pxTCB;
BaseType_t xReturn = pdPASS;
uint8_t ucOriginalNotifyState;
 
 
    configASSERT( xTaskToNotify );
    pxTCB = ( TCB_t * ) xTaskToNotify;
 
 
    taskENTER_CRITICAL();
    {
        if( pulPreviousNotificationValue != NULL )
        {
            /* 回传更新前的通知值*/
            *pulPreviousNotificationValue = pxTCB->ulNotifiedValue;
        }
 
 
        ucOriginalNotifyState = pxTCB->ucNotifyState;
 
 
        pxTCB->ucNotifyState = taskNOTIFICATION_RECEIVED;
 
 
        switch( eAction )
        {
            case eSetBits   :
                pxTCB->ulNotifiedValue |= ulValue;
                break;
 
 
            case eIncrement :
                ( pxTCB->ulNotifiedValue )++;
                break;
 
 
            case eSetValueWithOverwrite :
                pxTCB->ulNotifiedValue = ulValue;
                break;
 
 
            case eSetValueWithoutOverwrite :
                if( ucOriginalNotifyState != taskNOTIFICATION_RECEIVED )
                {
                    pxTCB->ulNotifiedValue = ulValue;
                }
                else
                {
                    /* 上次的通知值还未取走,本次通知值丢弃 */
                    xReturn = pdFAIL;
                }
                break;
 
 
            case eNoAction:
                /* 不需要更新通知值*/
                break;
        }
 
 
        traceTASK_NOTIFY();
 
 
        /* 如果被通知的任务因为等待通知而阻塞,现在将它解除阻塞 */
        if( ucOriginalNotifyState == taskWAITING_NOTIFICATION )
        {
            ( void ) uxListRemove( &( pxTCB->xStateListItem ) );
            prvAddTaskToReadyList( pxTCB );
 
 
            if( pxTCB->uxPriority > pxCurrentTCB->uxPriority )
            {
                /* 如果被通知的任务优先级高于当前任务,则触发PendSV中断,退出临界区后进行上下文切换T*/
                taskYIELD_IF_USING_PREEMPTION();
            }
        }
    }
    taskEXIT_CRITICAL();
 
 
    return xReturn;
}

下面API函数是vTaskNotifyGive()的带中断保护版本，是专门设计用来在某些情况下代替二进制信号量和计数信号量的。

void vTaskNotifyGiveFromISR( TaskHandle_t xTaskToNotify, BaseType_t *pxHigherPriorityTaskWoken )
{
TCB_t * pxTCB;
uint8_t ucOriginalNotifyState;
UBaseType_t uxSavedInterruptStatus;
 
 
    pxTCB = ( TCB_t * ) xTaskToNotify;
 
 
    uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();
    {
        ucOriginalNotifyState = pxTCB->ucNotifyState;
        pxTCB->ucNotifyState = taskNOTIFICATION_RECEIVED;
 
 
        /* 通知值加1,相当于释放了一个信号量 */
        ( pxTCB->ulNotifiedValue )++;
 
 
        /* 如果目标任务因为等待通知而阻塞,现在将它解除阻塞*/
        if( ucOriginalNotifyState == taskWAITING_NOTIFICATION )
        {
            /* 如果调度器正常,将任务放入就绪列表,否则放入挂起就绪列表 */
            if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )
            {
                ( void ) uxListRemove( &( pxTCB->xStateListItem ) );
                prvAddTaskToReadyList( pxTCB );
            }
            else
            {
                vListInsertEnd( &( xPendingReadyList ), &( pxTCB->xEventListItem ) );
            }
 
 
            if( pxTCB->uxPriority > pxCurrentTCB->uxPriority )
            {
                /* 如果解除阻塞的任务优先级大于当前任务优先级,则设置上下文切换标识,等退出函数后手动切换上下文,或者在系统节拍中断服务程序中自动切换上下文*/
                if( pxHigherPriorityTaskWoken != NULL )
                {
                    *pxHigherPriorityTaskWoken = pdTRUE;    /* 设置手动切换标志 */
                }
                else
                {
                    xYieldPending = pdTRUE;                 /* 设置自动切换标志 */
                }
            }
        }
    }
    portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
}

2.2 等待通知

ulTaskNotifyTake()和xTaskNotifyWait ()。前者是为代替二进制信号量和计数信号量而专门设计的，它和发送通知API函数xTaskNotifyGive()、vTaskNotifyGiveFromISR()配合使用；后者是全功能版的等待通知，可以根据不同的参数实现轻量级二进制信号量、计数信号量、事件组和长度为1的队列。
等待通知API函数都带有最大阻塞时间参数，当任务因为等待通知而进入阻塞时，用来规定最大阻塞时间。

uint32_t ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait )
{
uint32_t ulReturn;
 
 
    taskENTER_CRITICAL();
    {
        /* 仅当通知值为0，才进行阻塞操作*/
        if( pxCurrentTCB->ulNotifiedValue == 0UL )
        {
            /* 设置标志,表示当前任务等待一个通知*/
            pxCurrentTCB->ucNotifyState = taskWAITING_NOTIFICATION;
 
 
            if( xTicksToWait > ( TickType_t ) 0 )
            {   
                /* 将任务加入延时列表 */
                prvAddCurrentTaskToDelayedList( xTicksToWait, pdTRUE );
                traceTASK_NOTIFY_TAKE_BLOCK();
 
 
                /* 触发PendSV中断,等到退出临界区时立即执行任务切换 */
                portYIELD_WITHIN_API();
            }
        }
    }
    taskEXIT_CRITICAL();
    /* 到这里说明其它任务或中断向这个任务发送了通知,或者任务阻塞超时,现在继续处理*/
    taskENTER_CRITICAL();
    {
        traceTASK_NOTIFY_TAKE();
        ulReturn = pxCurrentTCB->ulNotifiedValue;   
 
 
        if( ulReturn != 0UL )
        {
            if( xClearCountOnExit != pdFALSE )
            {
                pxCurrentTCB->ulNotifiedValue = 0UL;
            }
            else
            {
                pxCurrentTCB->ulNotifiedValue = ulReturn - 1;
            }
        }
        /* 设置标志,表示不需要等待通知 */
        pxCurrentTCB->ucNotifyState = taskNOT_WAITING_NOTIFICATION;
    }
    taskEXIT_CRITICAL();
 
 
    return ulReturn;    /* 如果返回值为0,说明是任务阻塞超时了 */
}
  • xClearCountOnExit：如果该参数设置为pdFALSE，则API函数xTaskNotifyTake()退出前，将任务的通知值减1；如果该参数设置为pdTRUE，则API函数xTaskNotifyTake()退出前，将任务通知值清零。
  • xTicksToWait：因等待通知而进入阻塞状态的最大时间。时间单位为系统节拍周期。宏pdMS_TO_TICKS用于将指定的毫秒时间转化为相应的系统节拍数。

xTaskNotifyWait()：根据参数的不同，可以灵活的用于实现轻量级的队列、二进制信号量、计数信号量和事件组功能
如果打算使用RTOS任务通知实现轻量级的二进制或计数信号量，推荐使用API函数ulTaskNotifyTake()来代替本函数。

  • ulBitsToClearOnEntry：在使用通知之前，先将任务的通知值与参数ulBitsToClearOnEntry的按位取反值,进行位与操作。设置参数ulBitsToClearOnEntry为0xFFFFFFFF(ULONG_MAX)，表示清零任务通知值。
  • ulBitsToClearOnExit：在函数xTaskNotifyWait()退出前，将任务的通知值与参数ulBitsToClearOnExit的按位取反值按位与操作。设置参数ulBitsToClearOnExit为0xFFFFFFFF(ULONG_MAX)，表示清零任务通知值。
  • pulNotificationValue：用于向外回传任务的通知值。这个通知值在参数ulBitsToClearOnExit起作用前将通知值拷贝到*pulNotificationValue中。如果不需要返回任务的通知值，这里设置成NULL。
  • xTicksToWait：因等待通知而进入阻塞状态的最大时间。时间单位为系统节拍周期。宏pdMS_TO_TICKS用于将指定的毫秒时间转化为相应的系统节拍数。
BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit,  \
                            uint32_t *pulNotificationValue, TickType_t xTicksToWait )
{
    BaseType_t xReturn;
 
 
    taskENTER_CRITICAL();
    {
        /* 只有任务没有等待通知，才会将任务阻塞 */
        if( pxCurrentTCB->ucNotifyState != taskNOTIFICATION_RECEIVED )
        {
            /* 使用任务通知值之前,先将参数ulBitsToClearOnEntryClear取反后与任务通知值位与.
              可以用这种方法在使用任务通知值之前,将通知值的某些或全部位清零 */
            pxCurrentTCB->ulNotifiedValue &= ~ulBitsToClearOnEntry;
 
 
            /* 设置任务状态标识:等待通知 */
            pxCurrentTCB->ucNotifyState = taskWAITING_NOTIFICATION;
 
 
            if( xTicksToWait > ( TickType_t ) 0 )
            {
                /* 阻塞当前任务 */
                prvAddCurrentTaskToDelayedList( xTicksToWait, pdTRUE );
                traceTASK_NOTIFY_WAIT_BLOCK();
 
 
                /* 触发PendSV中断,等到退出临界区后,执行任务切换 */
                portYIELD_WITHIN_API();
            }
        }
    }
    taskEXIT_CRITICAL();
 
 
    /* 到这里说明其它任务或中断向这个任务发送了通知,或者任务阻塞超时,现在继续处理*/
    taskENTER_CRITICAL();
    {
        traceTASK_NOTIFY_WAIT();
 
 
        if( pulNotificationValue != NULL )
        {
            /* 输出当前通知值,通过指针参数传递*/
            *pulNotificationValue = pxCurrentTCB->ulNotifiedValue;
        }
 
 
        /* 判断是否是因为任务阻塞超时 */
        if( pxCurrentTCB->ucNotifyState == taskWAITING_NOTIFICATION )
        {
            /* 没有收到任务通知,是阻塞超时 */
            xReturn = pdFALSE;
        }
        else
        {
            /* 收到任务值,先将参数ulBitsToClearOnExit取反后与通知值位与,用于在退出函数前,将通知值的某些或者全部位清零. */
            pxCurrentTCB->ulNotifiedValue &= ~ulBitsToClearOnExit;
            xReturn = pdTRUE;
        }
        /* 更改任务通知状态,解除任务通知等待 */
        pxCurrentTCB->ucNotifyState = taskNOT_WAITING_NOTIFICATION;
    }
    taskEXIT_CRITICAL();
 
 
    return xReturn;
}

任务通知并查询

         BaseType_t xTaskNotifyAndQuery(TaskHandle_t xTaskToNotify,
                                 uint32_tulValue,
                                 eNotifyActioneAction,
                                 uint32_t*pulPreviousNotifyValue );

此函数与任务通知API函数xTaskNotify()非常像，只不过此函数具有一个附加参数，用来回传任务当前的通知值，然后根据参数ulValue和eAction更新任务的通知值。
xTaskToNotify：被通知的任务句柄。
ulValue：通知更新值
eAction：枚举类型，指明更新通知值的方法，枚举变量成员以及作用见xTaskNotify()一节。
pulPreviousNotifyValue：回传未被更新的任务通知值。如果不需要回传未被更新的任务通知值，这里设置为NULL，这样就等价于调用xTaskNotify()函数。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 217,185评论 6赞 503
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 92,652评论 3赞 393
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 163,524评论 0赞 353
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 58,339评论 1赞 293
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 67,387评论 6赞 391
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 51,287评论 1赞 301
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 40,130评论 3赞 418
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 38,985评论 0赞 275
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 45,420评论 1赞 313
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 37,617评论 3赞 334
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 39,779评论 1赞 348
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 35,477评论 5赞 345
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 41,088评论 3赞 328
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 31,716评论 0赞 22
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,857评论 1赞 269
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 47,876评论 2赞 370
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 44,700评论 2赞 354

推荐阅读更多精彩内容

  • FreeRTOS 任务调度 任务创建
    @(嵌入式) 简述 FreeRTOS 的任务调度在 Source/include/task.c 中实现，包含了任务...
    orientlu阅读 8,272评论 0赞 5
  • Task
    多任务系统 1.FreeRTOS 是一个抢占式的实时多任务系统， 那么其任务调度器也是抢占式的，运行过程如下图所示...
    Swinner阅读 1,270评论 0赞 1
  • FreeRTOS Task
    1.多任务系统 1.FreeRTOS 是一个抢占式的实时多任务系统， 那么其任务调度器也是抢占式的，运行过程如下图...
    Swinner阅读 2,031评论 0赞 1
  • FreeRTOS学习笔记（2）——任务管理
    一、头文件 二、任务创建与启动 2.1 相关API说明 2.1.1 TaskHandle_t 任务句柄。例如，对x...
    Leung_ManWah阅读 4,522评论 0赞 4
  • FreeRTOS概念与任务概念
    操作系统允许多个任务同时运行，其任务调度器的责任就是：决定某一时刻究竟运行那个任务。有的OS调度方式：基于时间的任...
    QGv阅读 1,689评论 0赞 1