[PIC®/AVR®/dsPIC®产品] (三)FreeRTOS创建和删除任务

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;



/* If the stack grows down then allocate the stack then the TCB so the stack

does not grow into the TCB.  Likewise if the stack grows up then allocate

the TCB then the stack. */

#if (portSTACK_GROWTH > 0)

        {

                /* Allocate space for the TCB.  Where the memory comes from depends on

                the implementation of the port malloc function and whether or not static

                allocation is being used. */

                pxNewTCB = (TCB_t *)pvPortMalloc(sizeof(TCB_t));



                if (pxNewTCB != NULL) {

                        /* Allocate space for the stack used by the task being created.

                        The base of the stack memory stored in the TCB so the task can

                        be deleted later if required. */

                        pxNewTCB->pxStack = (StackType_t *)pvPortMalloc((

                            ((size_t)usStackDepth)

                            * sizeof(StackType_t))); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */



                        if (pxNewTCB->pxStack == NULL) {

                                /* Could not allocate the stack.  Delete the allocated TCB. */

                                vPortFree(pxNewTCB);

                                pxNewTCB = NULL;

                        }

                }

        }

#else  /* portSTACK_GROWTH */

        {

                StackType_t *pxStack;



                /* Allocate space for the stack used by the task being created. */

                pxStack = (StackType_t *)pvPortMalloc(

                    (((size_t)usStackDepth)

                     * sizeof(StackType_t))); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */



                if (pxStack != NULL) {

                        /* Allocate space for the TCB. */

                        pxNewTCB = (TCB_t *)pvPortMalloc(

                            sizeof(TCB_t)); /*lint !e961 MISRA exception as the casts are only redundant for some paths. */



                        if (pxNewTCB != NULL) {

                                /* 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. */

                                vPortFree(pxStack);

                        }

                } else {

                        pxNewTCB = NULL;

                }

        }

#endif /* portSTACK_GROWTH */



        if (pxNewTCB != NULL) {

#if (tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE                                                                         \

     != 0) /*lint !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 /* configSUPPORT_STATIC_ALLOCATION */



                prvInitialiseNewTask(

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

                prvAddNewTaskToReadyList(pxNewTCB);

                xReturn = pdPASS;

        } else {

                xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;

        }



        return xReturn;

}

void vTaskFunction( void *pvParameters )

{

    char *pcTaskName;

    volatile unsigned long ul;

    /* The string to print out is passed in via the parameter. Cast this to a

    character pointer. */

    pcTaskName = ( char * ) pvParameters;

    /* As per most tasks, this task is implemented in an infinite loop. */

    for( ;; )

    {

        /* Print out the name of this task. */

        vPrintString( pcTaskName );

        /* Delay for a period. */

        for( ul = 0; ul < mainDELAY_LOOP_COUNT; ul++ )

        {

        /* This loop is just a very crude delay implementation. There is

        nothing to do in here. Later exercises will replace this crude

        loop with a proper delay/sleep function. */

        }

    }

}

/* Define the strings that will be passed in as the task parameters. These are

defined const and not on the stack to ensure they remain valid when the tasks are

executing. */

static const char *pcTextForTask1 = “Task 1 is running\r\n”;

static const char *pcTextForTask2 = “Task 2 is running\t\n”;

int main( void )

{

        /* Create one of the two tasks. */

        xTaskCreate( vTaskFunction, /* Pointer to the function that implements

        the task. */

        "Task 1", /* Text name for the task. This is to

        facilitate debugging only. */

        1000, /* Stack depth - most small microcontrollers

        will use much less stack than this. */

        (void*)pcTextForTask1, /* Pass the text to be printed into the task

        using the task parameter. */

        1, /* This task will run at priority 1. */

        NULL ); /* We are not using the task handle. */

        /* Create the other task in exactly the same way. Note this time that multiple

        tasks are being created from the SAME task implementation (vTaskFunction). Only

        the value passed in the parameter is different.  Two instances of the same

        task are being created. */

        xTaskCreate( vTaskFunction, "Task 2", 1000, (void*)pcTextForTask2, 1, NULL );

        /* Start the scheduler so our tasks start executing. */

        vTaskStartScheduler();

        /* If all is well then main() will never reach here as the scheduler will

        now be running the tasks. If main() does reach here then it is likely that

        there was insufficient heap memory available for the idle task to be created.

        CHAPTER 5 provides more information on memory management. */

        for( ;; );

}

void vTaskDelete( xTaskHandle pxTaskToDelete );