FreeRTOS任务管理

BaseType_t xTaskCreate( TaskFunction_t pxTaskCode,
                            const char * const pcName, 
                            const configSTACK_DEPTH_TYPE usStackDepth,
                            void * const pvParameters,
                            UBaseType_t uxPriority,
                            TaskHandle_t * const pxCreatedTask )

void Task1()
{
    while(1)
    {
        A();
        B();
        C();
    }
}

xTaskCreate(   Task1, 
                "Test", 
                configMINIMAL_STACK_SIZE, 
                NULL, 
                mainCHECK_TASK_PRIORITY, 
                NULL );

 BaseType_t xTaskCreate( TaskFunction_t pxTaskCode,
                            const char * const pcName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
                            const configSTACK_DEPTH_TYPE usStackDepth,
                            void * const pvParameters,
                            UBaseType_t uxPriority,
                            TaskHandle_t * const pxCreatedTask )
    {
        TCB_t * pxNewTCB;
        BaseType_t xReturn;
        StackType_t * pxStack;

            /* Allocate space for the stack used by the task being created. */
            pxStack = pvPortMallocStack( ( ( ( size_t ) usStackDepth ) * sizeof( StackType_t ) ) ); /*lint !e9079 All values returned by pvPortMalloc() have at least the alignment required by the MCU's stack and this allocation is the stack. */

            if( pxStack != NULL )
            {
                /* Allocate space for the TCB. */
                pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) ); /*lint !e9087 !e9079 All values returned by pvPortMalloc() have at least the alignment required by the MCU's stack, and the first member of TCB_t is always a pointer to the task's stack. */

                if( pxNewTCB != NULL )
                {
                    memset( ( void * ) pxNewTCB, 0x00, sizeof( TCB_t ) );

                    /* Store the stack location in the TCB. */
                    pxNewTCB->pxStack = pxStack;
                }
                else
                {
                    /* The stack cannot be used as the TCB was not created.  Free
                     * it again. */
                    vPortFreeStack( pxStack );
                }
            }
            else
            {
                pxNewTCB = NULL;
            }

        if( pxNewTCB != NULL )
        {
            #if ( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) /*lint !e9029 !e731 Macro has been consolidated for readability reasons. */
            {
                /* Tasks can be created statically or dynamically, so note this
                 * task was created dynamically in case it is later deleted. */
                pxNewTCB->ucStaticallyAllocated = tskDYNAMICALLY_ALLOCATED_STACK_AND_TCB;
            }
            #endif /* tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE */

            prvInitialiseNewTask( pxTaskCode, pcName, ( uint32_t ) usStackDepth, pvParameters, uxPriority, pxCreatedTask, pxNewTCB, NULL );
            prvAddNewTaskToReadyList( pxNewTCB );
            xReturn = pdPASS;
        }
        else
        {
            xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;
        }

        return xReturn;
    }

 pxStack = pvPortMallocStack( ( ( ( size_t ) usStackDepth ) * sizeof( StackType_t ) ) );

typedef struct tskTaskControlBlock       /* The old naming convention is used to prevent breaking kernel aware debuggers. */
{
    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. */
    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 ). */
    ListItem_t xEventListItem;                  /*< Used to reference a task from an event list. */
    UBaseType_t uxPriority;                     /*< The priority of the task.  0 is the lowest priority. */
    StackType_t * pxStack;                      /*< Points to the start of the stack. */
    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. */

    #if ( portCRITICAL_NESTING_IN_TCB == 1 )
        UBaseType_t uxCriticalNesting; /*< Holds the critical section nesting depth for ports that do not maintain their own count in the port layer. */
    #endif

    #if ( configUSE_TRACE_FACILITY == 1 )
        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. */
        UBaseType_t uxTaskNumber; /*< Stores a number specifically for use by third party trace code. */
    #endif

    #if ( configUSE_MUTEXES == 1 )
        UBaseType_t uxBasePriority; /*< The priority last assigned to the task - used by the priority inheritance mechanism. */
        UBaseType_t uxMutexesHeld;
    #endif

    #if ( configUSE_APPLICATION_TASK_TAG == 1 )
        TaskHookFunction_t pxTaskTag;
    #endif

    #if ( configGENERATE_RUN_TIME_STATS == 1 )
        configRUN_TIME_COUNTER_TYPE ulRunTimeCounter; /*< Stores the amount of time the task has spent in the Running state. */
    #endif

    #if ( configUSE_TASK_NOTIFICATIONS == 1 )
        volatile uint32_t ulNotifiedValue[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];
        volatile uint8_t ucNotifyState[ configTASK_NOTIFICATION_ARRAY_ENTRIES ];
    #endif

} tskTCB;
typedef tskTCB TCB_t;

 prvInitialiseNewTask( pxTaskCode, pcName, ( uint32_t ) usStackDepth, pvParameters, uxPriority, pxCreatedTask, pxNewTCB, NULL );

 prvAddNewTaskToReadyList( pxNewTCB );

void xPortPendSVHandler( void )
{
  /* This is a naked function.
    1.产生PendSV中断，硬件自动保存栈帧到任务A的栈中
    2.读取当前任务A的栈指针PSP，手动把一些寄存器压栈到当前任务栈。
    3.把当前任务A栈顶指针保存到任务A的任务控制块中。
    4.找到下一个任务B的任务控制块。（查找下一个优先级最高的就绪任务）
    5.把任务B控制块的栈顶指针指向的数据弹出到寄存器中
    6.更新PSP为任务B的栈顶指针。
    7.跳出PendSV中断。
    8.硬件自动弹出任务B栈中的栈帧。
 */
  __asm volatile
  (
  "  .syntax unified            \n" 
  "  mrs r0, psp              \n"/*将psp值放到r0,此时sp得值为msp*/
  "                    \n"
  "  ldr  r3, pxCurrentTCBConst      \n" /* Get the location of the current TCB. 获取当前任务控制块，其实就获取任务栈顶 */
  "  ldr  r2, [r3]            \n"/*将r3寄存器值作为指针取内容存到r2，此时r2保存的为任务控制块首地址*/
  "                    \n"
  "  subs r0, r0, #32          \n" /* Make space for the remaining low registers. */
  "  str r0, [r2]            \n" /* Save the new top of stack. */
  "  stmia r0!, {r4-r7}          \n" /* Store the low registers that are not saved automatically. */
  "   mov r4, r8              \n" /* Store the high registers. */
  "   mov r5, r9              \n"
  "   mov r6, r10              \n"
  "   mov r7, r11              \n"
  "   stmia r0!, {r4-r7}          \n"
  "                    \n"
  "  push {r3, r14}            \n"
  "  cpsid i                \n"
  "  bl vTaskSwitchContext        \n"/*执行上线文切换*/
  "  cpsie i                \n"
  "  pop {r2, r3}            \n" /* lr goes in r3. r2 now holds tcb pointer. */
  "                    \n"
  "  ldr r1, [r2]            \n"
  "  ldr r0, [r1]            \n" /* The first item in pxCurrentTCB is the task top of stack. */
  "  adds r0, r0, #16          \n" /* Move to the high registers. */
  "  ldmia r0!, {r4-r7}          \n" /* Pop the high registers. */
  "   mov r8, r4              \n"
  "   mov r9, r5              \n"
  "   mov r10, r6              \n"
  "   mov r11, r7              \n"
  "                    \n"
  "  msr psp, r0              \n" /* Remember the new top of stack for the task.记住新的栈顶指针 */
  "                    \n"
  "  subs r0, r0, #32          \n" /* Go back for the low registers that are not automatically restored. */
  "   ldmia r0!, {r4-r7}          \n" /* Pop low registers.  */
  "                    \n"
  "  bx r3                \n"
  "                    \n"
  "  .align 4              \n"
  "pxCurrentTCBConst: .word pxCurrentTCB    "
  );
}