FreeRTOS进阶之任务创建完全解析

        BaseType_t xTaskCreate(
                            TaskFunction_tp vTaskCode,
                            const char * constpcName,
                            unsigned short usStackDepth,
                            void *pvParameters,
                            UBaseType_t uxPriority,
                            TaskHandle_t *pvCreatedTask
                          );

#define xTaskCreate( pvTaskCode, pcName, usStackDepth,pvParameters, uxPriority, pxCreatedTask )    \
      xTaskGenericCreate( ( pvTaskCode ),( pcName ), ( usStackDepth ), ( pvParameters ), ( uxPriority ), ( pxCreatedTask), ( NULL ), ( NULL ), ( NULL ) )

typedef struct tskTaskControlBlock
{
    volatile StackType_t    *pxTopOfStack; /*当前堆栈的栈顶,必须位于结构体的第一项*/
    #if ( portUSING_MPU_WRAPPERS == 1 )
        xMPU_SETTINGS   xMPUSettings;      /*MPU设置,必须位于结构体的第二项*/
    #endif
    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;

    TaskHandle_t xHandle；
    xTaskCreate(vTask_A,”Task A”,120,NULL,1,&xHandle);

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;
}

static void prvInitialiseTCBVariables( TCB_t * const pxTCB, const char * const pcName, UBaseType_t uxPriority,   \
                              const MemoryRegion_t * const xRegions, const uint16_t usStackDepth )
{
UBaseType_t x;
    /* 将任务描述存入TCB */
    for( x = ( UBaseType_t ) 0; x < ( UBaseType_t ) configMAX_TASK_NAME_LEN; x++ )
    {
        pxTCB->pcTaskName[ x ] = pcName[ x ];
        if( pcName[ x ] == 0x00 )
        {
            break;
        }
    }
    /* 确保字符串有结束 */
    pxTCB->pcTaskName[ configMAX_TASK_NAME_LEN - 1 ] = '\0';
 
    /* 调整优先级，宏configMAX_PRIORITIES的值在FreeRTOSConfig.h中设置 */
    if( uxPriority >= ( UBaseType_t ) configMAX_PRIORITIES )
    {
        uxPriority = ( UBaseType_t ) configMAX_PRIORITIES - ( UBaseType_t ) 1U;
    }
    pxTCB->uxPriority = uxPriority;
    #if ( configUSE_MUTEXES == 1 )              /*使用互斥量*/
    {  
        pxTCB->uxBasePriority = uxPriority;
        pxTCB->uxMutexesHeld = 0;
    }
    #endif /* configUSE_MUTEXES */
    /*初始化列表项*/
    vListInitialiseItem( &( pxTCB->xStateListItem ) );
    vListInitialiseItem( &( pxTCB->xEventListItem ) );
    /* 设置列表项xStateListItem的成员pvOwner指向当前任务控制块 */
    listSET_LIST_ITEM_OWNER( &( pxTCB->xStateListItem ), pxTCB );
    /* 设置列表项xEventListItem的成员xItemValue*/
    listSET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ), ( TickType_t ) configMAX_PRIORITIES - ( TickType_t ) uxPriority );
    /* 设置列表项xEventListItem的成员pvOwner指向当前任务控制块 */
    listSET_LIST_ITEM_OWNER( &( pxTCB->xEventListItem ), pxTCB );
    #if ( portCRITICAL_NESTING_IN_TCB ==1 )    /*使能临界区嵌套功能*/
    {  
        pxTCB->uxCriticalNesting = ( UBaseType_t ) 0U;
    }
    #endif /* portCRITICAL_NESTING_IN_TCB */
    #if ( configUSE_APPLICATION_TASK_TAG == 1 ) /*使能任务标签功能*/
    {  
        pxTCB->pxTaskTag = NULL;
    }
    #endif /* configUSE_APPLICATION_TASK_TAG */
    #if ( configGENERATE_RUN_TIME_STATS == 1 )  /*使能事件统计功能*/
    {
        pxTCB->ulRunTimeCounter = 0UL;
    }
    #endif /* configGENERATE_RUN_TIME_STATS */
    #if ( portUSING_MPU_WRAPPERS == 1 )         /*使用MPU功能*/
    {
        vPortStoreTaskMPUSettings( &( pxTCB->xMPUSettings ), xRegions, pxTCB->pxStack, usStackDepth );
    }
    #else /* portUSING_MPU_WRAPPERS */
    {
        ( void ) xRegions;
        ( void ) usStackDepth;
    }
    #endif /* portUSING_MPU_WRAPPERS */
    #if( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )/*使能线程本地存储指针*/
    {
        for( x = 0; x < ( UBaseType_t )configNUM_THREAD_LOCAL_STORAGE_POINTERS; x++ )
        {
            pxTCB->pvThreadLocalStoragePointers[ x ] = NULL;
        }
    }
    #endif
    #if ( configUSE_TASK_NOTIFICATIONS == 1 )   /*使能任务通知功能*/
    {
        pxTCB->ulNotifiedValue = 0;
        pxTCB->ucNotifyState = taskNOT_WAITING_NOTIFICATION;
    }
    #endif
    #if ( configUSE_NEWLIB_REENTRANT == 1 )     /*使用Newlib*/
    {
        _REENT_INIT_PTR( ( &( pxTCB->xNewLib_reent ) ) );
    }
    #endif
    #if( INCLUDE_xTaskAbortDelay == 1 )
    {
        pxTCB->ucDelayAborted = pdFALSE;
    }
    #endif
}

PRIVILEGED_DATAstatic List_t pxReadyTasksLists[ configMAX_PRIORITIES ];/*按照优先级排序的就绪态任务*/
PRIVILEGED_DATAstatic List_t xDelayedTaskList1;                        /*延时的任务 */
PRIVILEGED_DATAstatic List_t xDelayedTaskList2;                        /*延时的任务 */
PRIVILEGED_DATAstatic List_t xPendingReadyList;                        /*任务已就绪,但调度器被挂起 */
#if (INCLUDE_vTaskDelete == 1 )
    PRIVILEGED_DATA static List_t xTasksWaitingTermination;             /*任务已经被删除,但内存尚未释放*/
#endif
#if (INCLUDE_vTaskSuspend == 1 )
    PRIVILEGED_DATA static List_t xSuspendedTaskList;                   /*当前挂起的任务*/
#endif

static void prvInitialiseTaskLists( void )
{
UBaseType_tuxPriority;
    for( uxPriority = ( UBaseType_t ) 0U; uxPriority < ( UBaseType_t ) configMAX_PRIORITIES; uxPriority++ )
    {
        vListInitialise( &( pxReadyTasksLists[ uxPriority ] ) );
    }
    vListInitialise( &xDelayedTaskList1 );
    vListInitialise( &xDelayedTaskList2 );
    vListInitialise( &xPendingReadyList );
    #if ( INCLUDE_vTaskDelete == 1 )
    {
        vListInitialise( &xTasksWaitingTermination );
    }
    #endif /* INCLUDE_vTaskDelete */
 
    #if ( INCLUDE_vTaskSuspend == 1 )
    {
        vListInitialise( &xSuspendedTaskList );
    }
    #endif /* INCLUDE_vTaskSuspend */
    /* Start with pxDelayedTaskList using list1 and the pxOverflowDelayedTaskListusing list2. */
    pxDelayedTaskList = &xDelayedTaskList1;
    pxOverflowDelayedTaskList = &xDelayedTaskList2;
}

if( xSchedulerRunning == pdFALSE )
{
    if( pxCurrentTCB->uxPriority <= uxPriority )
    {
        pxCurrentTCB = pxNewTCB;
    }
    else
    {
        mtCOVERAGE_TEST_MARKER();
    }
}

#defineprvAddTaskToReadyList( pxTCB )                        \
    taskRECORD_READY_PRIORITY( ( pxTCB)->uxPriority );       \
    vListInsertEnd( &( pxReadyTasksLists[ (pxTCB )->uxPriority ] ), &( ( pxTCB )->xStateListItem ) );

 if( xReturn == pdPASS )
    {
        if( xSchedulerRunning != pdFALSE )
        {
            /* 如果新创建的任务优先级大于当前任务优先级，则新创建的任务应该被立即执行。*/
            if(pxCurrentTCB->uxPriority < uxPriority )
            {
                taskYIELD_IF_USING_PREEMPTION();
            }
        }
    }