FreeRTOS学习笔记

// FreeRTOSv202112.00/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/init/startup.c
/* Prevent optimization so gcc does not replace code with memcpy */
__attribute__((optimize("O0")))
__attribute__((naked)) void
Reset_Handler(void)
{
    /* set stack pointer */
    __asm volatile("ldr r0, =_estack");
    __asm volatile("mov sp, r0");

    /* copy .data section from flash to RAM */
    for (uint32_t *src = &_sidata, *dest = &_sdata; dest < &_edata;)
    {
        *dest++ = *src++;
    }

    /* zero out .bss section */
    for (uint32_t *dest = &_sbss; dest < &_ebss;)
    {
        *dest++ = 0;
    }

    /* jump to board initialisation */
    void _start(void);
    _start();
}

// FreeRTOSv202112.00/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/init/startup.c

void _start(void)
{
    uart_init();
    main(0, 0);
    exit(0);
}

// FreeRTOSv202112.00/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/syscall.c

void uart_init()
{
    UART0_ADDR->BAUDDIV = 16;
    UART0_ADDR->CTRL = UART_CTRL_TX_EN;
}

// FreeRTOSv202112.00/FreeRTOS/Demo/CORTEX_M3_MPS2_QEMU_GCC/main_blinky.c

int main()
{
    main_blinky();
    return 0;
}

void main_blinky( void )
{
    /* Create the queue. */
    xQueue = xQueueCreate( mainQUEUE_LENGTH, sizeof( uint32_t ) );

    if( xQueue != NULL )
    {
        /* Start the two tasks as described in the comments at the top of this
         * file. */
        xTaskCreate( prvQueueReceiveTask,             /* The function that implements the task. */
                     "Rx",                            /* The text name assigned to the task - for debug only as it is not used by the kernel. */
                     configMINIMAL_STACK_SIZE,        /* The size of the stack to allocate to the task. */
                     NULL,                            /* The parameter passed to the task - not used in this case. */
                     mainQUEUE_RECEIVE_TASK_PRIORITY, /* The priority assigned to the task. */
                     NULL );                          /* The task handle is not required, so NULL is passed. */

        xTaskCreate( prvQueueSendTask,
                     "TX",
                     configMINIMAL_STACK_SIZE,
                     NULL,
                     mainQUEUE_SEND_TASK_PRIORITY,
                     NULL );

        /* Start the tasks and timer running. */
        vTaskStartScheduler();
    }

    /* If all is well, the scheduler will now be running, and the following
     * line will never be reached.  If the following line does execute, then
     * there was insufficient FreeRTOS heap memory available for the Idle and/or
     * timer tasks to be created.  See the memory management section on the
     * FreeRTOS web site for more details on the FreeRTOS heap
     * http://www.freertos.org/a00111.html. */
    for( ; ; )
    {
    }
}

// FreeRTOSv202112.00/FreeRTOS/Source/queue.c
QueueHandle_t xQueueGenericCreate( const UBaseType_t uxQueueLength,
                                    const UBaseType_t uxItemSize,
                                    const uint8_t ucQueueType )
    
// FreeRTOSv202112.00/FreeRTOS-Plus/Source/AWS/ota/test/cbmc/FreeRTOS-Kernel/include/queue.h
#define queueQUEUE_TYPE_BASE                  ( ( uint8_t ) 0U )
#define queueQUEUE_TYPE_SET                   ( ( uint8_t ) 0U )
#define queueQUEUE_TYPE_MUTEX                 ( ( uint8_t ) 1U )
#define queueQUEUE_TYPE_COUNTING_SEMAPHORE    ( ( uint8_t ) 2U )
#define queueQUEUE_TYPE_BINARY_SEMAPHORE      ( ( uint8_t ) 3U )
#define queueQUEUE_TYPE_RECURSIVE_MUTEX       ( ( uint8_t ) 4U )

BaseType_t xTaskResumeAll( void )

// FreeRTOSv202112.00/FreeRTOS/Source/list.c
void vListInitialise( List_t * const pxList )

typedef xQUEUE Queue_t;

typedef struct QueueDefinition
{
    int8_t *pcHead;    /*< 指向存储数据区开始处，即跳过头部区域 */
    int8_t *pcWriteTo; /*< 指向存储数据区可使用处，跳过已经入队的元素 */

    union
    {
        QueuePointers_t xQueue;     /*< 队列数据，pcTail指向存储数据区结束处；pcReadFrom指向存储数据区最后一元素区域 */
        SemaphoreData_t xSemaphore; /*< 信号量使用 */
    } u;

    List_t xTasksWaitingToSend;    /*< 阻塞等待写入数据的任务列表，按优先级排序 */
    List_t xTasksWaitingToReceive; /*< 阻塞等待读取数据的任务列表，按优先级排序. */

    volatile UBaseType_t uxMessagesWaiting; /*< 当前队列中元素个数 */
    UBaseType_t uxLength;                   /*< 队列元素个数. */
    UBaseType_t uxItemSize;                 /*< 队列元素大小 */

    volatile int8_t cRxLock; /*< 上锁时，存储从队列移除元素数；无锁时，值为queueUNLOCKED */
    volatile int8_t cTxLock; /*< 上锁时，存储向队列添加元素数；无锁时，值为queueUNLOCKED */

#if ((configSUPPORT_STATIC_ALLOCATION == 1) && (configSUPPORT_DYNAMIC_ALLOCATION == 1))
    uint8_t ucStaticallyAllocated; /*< Set to pdTRUE if the memory used by the queue was statically allocated to ensure no attempt is made to free the memory. */
#endif

#if (configUSE_QUEUE_SETS == 1)
    struct QueueDefinition *pxQueueSetContainer;
#endif

#if (configUSE_TRACE_FACILITY == 1)
    UBaseType_t uxQueueNumber;
    uint8_t ucQueueType;	/*< 队列类型 */
#endif
} xQUEUE;

typedef tskTCB TCB_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. */

    #if ( portUSING_MPU_WRAPPERS == 1 )
        xMPU_SETTINGS xMPUSettings; /*< The MPU settings are defined as part of the port layer.  THIS MUST BE THE SECOND MEMBER OF THE TCB STRUCT. */
    #endif

    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 ( ( portSTACK_GROWTH > 0 ) || ( configRECORD_STACK_HIGH_ADDRESS == 1 ) )
        StackType_t * pxEndOfStack; /*< Points to the highest valid address for the stack. */
    #endif

    #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 ( configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 )
        void * pvThreadLocalStoragePointers[ configNUM_THREAD_LOCAL_STORAGE_POINTERS ];
    #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_NEWLIB_REENTRANT == 1 )

        /* Allocate a Newlib reent structure that is specific to this task.
         * Note Newlib support has been included by popular demand, but is not
         * used by the FreeRTOS maintainers themselves.  FreeRTOS is not
         * responsible for resulting newlib operation.  User must be familiar with
         * newlib and must provide system-wide implementations of the necessary
         * stubs. Be warned that (at the time of writing) the current newlib design
         * implements a system-wide malloc() that must be provided with locks.
         *
         * See the third party link http://www.nadler.com/embedded/newlibAndFreeRTOS.html
         * for additional information. */
        struct  _reent xNewLib_reent;
    #endif

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

    /* See the comments in FreeRTOS.h with the definition of
     * tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE. */
    #if ( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) /*lint !e731 !e9029 Macro has been consolidated for readability reasons. */
        uint8_t ucStaticallyAllocated;                     /*< Set to pdTRUE if the task is a statically allocated to ensure no attempt is made to free the memory. */
    #endif

    #if ( INCLUDE_xTaskAbortDelay == 1 )
        uint8_t ucDelayAborted;
    #endif

    #if ( configUSE_POSIX_ERRNO == 1 )
        int iTaskErrno;
    #endif
} tskTCB;

uint8_t ucHeap[configTOTAL_HEAP_SIZE] __attribute__((section(".my_heap")));

uint8_t ucHeap[configTOTAL_HEAP_SIZE] @ 0x20000000;

typedef struct HeapRegion
{
    uint8_t *pucStartAddress;
    size_t xSizeInBytes;
} HeapRegion_t;

const HeapRegion_t xHeapRegion[] = 
{
    {(uint8_t *)0x00010000, 65*1024},
    {(uint8_t *)0x00020000, 32*1024},
    {(uint8_t *)0x00030000, 32*1024},
    {NULL,                  0},
};

int main(void)
{
    vPortDefineHeapRegions(xHeapRegion);
}

#define RAM1_HEAP_SIZE (30*1024)
static uint8_t ucHeap[RAM1_HEAP_SIZE];

const HeapRegion_t xHeapRegion[] = 
{
    {ucHeap,                RAM1_HEAP_SIZE},
    {(uint8_t *)0x00020000, 32*1024},
    {(uint8_t *)0x00030000, 32*1024},
    {NULL,                  0},
};

int main(void)
{
    vPortDefineHeapRegions(xHeapRegion);
}

size_t xPortGetFreeHeapSize( void );

size_t xPortGetMinimumEverFreeHeapSize( void );

void vApplicationMallocFailedHook( void );

// Listing 11
void ATaskFunction( void *pvParameters );

// Listing 12
void ATaskFunction( void *pvParameters )
{
    /* 变量可以像普通函数一样进行声明。使用此示例函数创建的每个任务实例，都有其lVariableExample变量的副本。如果变量声明为静态，这就是错误的。在这种情况下，变量只有一个副本，并且副本将被创建的任务实例共享。（变量名称中的前缀参考章节1.5 数据类型和编码风格指南。） */
    int32_t lVariableExample = 0;
    /* 任务通常被实现为无限循环。 */
    for( ;; )
    {
        /* 实现任务功能的代码写到这里。 */
    }
    /* 即使任务跳出循环，那么必须在其实现函数结束之前将任务删除。传递给vTaskDelete() API函数的NULL参数，它表示要删除的是调用（此）任务。API函数命名规范在0章节中已描述。 */
    vTaskDelete( NULL );
}

void ATaskFunction( void *pvParameters )
{
    int32_t lVariableExample = 0;
    /* 一般就是无限循环 */
    for( ;; )
    {
        /* 任务功能代码逻辑. */
    }
    /* 一定要返回，需要显示调用删除 */
    vTaskDelete( NULL );
}

BaseType_t xTaskCreate( TaskFunction_t pvTaskCode, 
                       const char * const pcName, 
                       uint16_t usStackDepth, 
                       void *pvParameters, 
                       UBaseType_t uxPriority, 
                       TaskHandle_t *pxCreatedTask );

void vTask1( void *pvParameters )
{
    const char *pcTaskName = "Task 1 is running\r\n";
    volatile uint32_t ul; /* volatile to ensure ul is not optimized away. */
    /* 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 examples will replace this crude
 loop with a proper delay/sleep function. */
        }
    }
}

void vTask2( void *pvParameters )
{
    const char *pcTaskName = "Task 2 is running\r\n";
    volatile uint32_t ul; /* volatile to ensure ul is not optimized away. */
    /* 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 examples will replace this crude
 loop with a proper delay/sleep function. */
        }
    }
}

int main( void )
{
    /* Create one of the two tasks. Note that a real application should check
 the return value of the xTaskCreate() call to ensure the task was created
 successfully. */
    xTaskCreate( vTask1, /* Pointer to the function that implements the task. */
                "Task 1",/* Text name for the task. This is to facilitate 
 debugging only. */
                1000, /* Stack depth - small microcontrollers will use much
 less stack than this. */
                NULL, /* This example does not use the task parameter. */
                1, /* This task will run at priority 1. */
                NULL ); /* This example does not use the task handle. */
    /* Create the other task in exactly the same way and at the same priority. */
    xTaskCreate( vTask2, "Task 2", 1000, NULL, 1, NULL );
    /* Start the scheduler so the 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 2 provides more information on heap memory management. */
    for( ;; );
}

void vTask1( void *pvParameters )
{
    const char *pcTaskName = "Task 1 is running\r\n";
    volatile uint32_t ul; /* volatile to ensure ul is not optimized away. */
    /* If this task code is executing then the scheduler must already have
 been started. Create the other task before entering the infinite loop. */
    xTaskCreate( vTask2, "Task 2", 1000, NULL, 1, NULL );
    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 examples will replace this crude
 loop with a proper delay/sleep function. */
        }
    }
}

void vTaskFunction( void *pvParameters )
{
    char *pcTaskName;
    volatile uint32_t ul; /* volatile to ensure ul is not optimized away. */
    /* 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\r\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 - 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 ); /* The task handle is not used in this 
 example. */
    /* 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 the 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 2 provides more information on heap memory management. */
    for( ;; );
}

void vTaskDelay( TickType_t xTicksToDelay );

void vTaskDelayUntil( TickType_t * pxPreviousWakeTime, TickType_t xTimeIncrement );

void vApplicationIdleHook( void );

void vTaskPrioritySet( TaskHandle_t pxTask, UBaseType_t uxNewPriority );

UBaseType_t uxTaskPriorityGet( TaskHandle_t pxTask );

void vTaskDelete( TaskHandle_t pxTaskToDelete );

QueueHandle_t xQueueCreate( UBaseType_t uxQueueLength, UBaseType_t uxItemSize );

BaseType_t xQueueSendToFront( QueueHandle_t xQueue,
                             const void * pvItemToQueue,
                             TickType_t xTicksToWait );
BaseType_t xQueueSendToBack( QueueHandle_t xQueue,
                            const void * pvItemToQueue,
                            TickType_t xTicksToWait );

BaseType_t xQueueReceive( QueueHandle_t xQueue,
                         void * const pvBuffer,
                         TickType_t xTicksToWait );

UBaseType_t uxQueueMessagesWaiting( QueueHandle_t xQueue );

QueueSetHandle_t xQueueCreateSet( const UBaseType_t uxEventQueueLength );

BaseType_t xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore, 
                          QueueSetHandle_t xQueueSet );

QueueSetMemberHandle_t xQueueSelectFromSet( QueueSetHandle_t xQueueSet,
                                           const TickType_t xTicksToWait );

BaseType_t xQueueOverwrite( QueueHandle_t xQueue, const void * pvItemToQueue );

BaseType_t xQueuePeek( QueueHandle_t xQueue,
                      void * const pvBuffer,
                      TickType_t xTicksToWait );

void ATimerCallback( TimerHandle_t xTimer );

TimerHandle_t xTimerCreate( const char * const pcTimerName,
                           TickType_t xTimerPeriodInTicks,
                           UBaseType_t uxAutoReload,
                           void * pvTimerID,
                           TimerCallbackFunction_t pxCallbackFunction );

BaseType_t xTimerStart( TimerHandle_t xTimer, TickType_t xTicksToWait );

void vTimerSetTimerID( const TimerHandle_t xTimer, void *pvNewID );

void *pvTimerGetTimerID( TimerHandle_t xTimer );

BaseType_t xTimerChangePeriod( TimerHandle_t xTimer, 
                              TickType_t xNewTimerPeriodInTicks,
                              TickType_t xTicksToWait );

BaseType_t xTimerReset( TimerHandle_t xTimer, TickType_t xTicksToWait );

portEND_SWITCHING_ISR( xHigherPriorityTaskWoken );
portYIELD_FROM_ISR( xHigherPriorityTaskWoken );

SemaphoreHandle_t xSemaphoreCreateBinary( void );

BaseType_t xSemaphoreTake( SemaphoreHandle_t xSemaphore, TickType_t xTicksToWait );

BaseType_t xSemaphoreGiveFromISR( SemaphoreHandle_t xSemaphore, 
                                 BaseType_t *pxHigherPriorityTaskWoken );

SemaphoreHandle_t xSemaphoreCreateCounting( UBaseType_t uxMaxCount,
                                           UBaseType_t uxInitialCount );

BaseType_t xTimerPendFunctionCallFromISR( PendedFunction_t xFunctionToPend,
                                         void *pvParameter1,
                                         uint32_t ulParameter2,
                                         BaseType_t *pxHigherPriorityTaskWoken );
void vPendableFunction( void *pvParameter1, uint32_t ulParameter2 );

BaseType_t xQueueSendToFrontFromISR( QueueHandle_t xQueue, 
                                    void *pvItemToQueue
                                    BaseType_t *pxHigherPriorityTaskWoken 
                                   );
BaseType_t xQueueSendToBackFromISR( QueueHandle_t xQueue, 
                                   void *pvItemToQueue
                                   BaseType_t *pxHigherPriorityTaskWoken 
                                  );

void vTaskSuspendAll( void );

BaseType_t xTaskResumeAll( void );

SemaphoreHandle_t xSemaphoreCreateMutex( void );

void vApplicationTickHook( void );

EventGroupHandle_t xEventGroupCreate( void );

EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup,
                               const EventBits_t uxBitsToSet );

BaseType_t xEventGroupSetBitsFromISR( EventGroupHandle_t xEventGroup,
                                     const EventBits_t uxBitsToSet,
                                     BaseType_t *pxHigherPriorityTaskWoken );

EventBits_t xEventGroupWaitBits( const EventGroupHandle_t xEventGroup,
                                const EventBits_t uxBitsToWaitFor,
                                const BaseType_t xClearOnExit,
                                const BaseType_t xWaitForAllBits,
                                TickType_t xTicksToWait );

EventBits_t xEventGroupSync( EventGroupHandle_t xEventGroup,
                            const EventBits_t uxBitsToSet,
                            const EventBits_t uxBitsToWaitFor,
                            TickType_t xTicksToWait );

BaseType_t xTaskNotifyGive( TaskHandle_t xTaskToNotify );

void vTaskNotifyGiveFromISR( TaskHandle_t xTaskToNotify, 
                            BaseType_t *pxHigherPriorityTaskWoken );

uint32_t ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait );

BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify, 
                       uint32_t ulValue, 
                       eNotifyAction eAction );
BaseType_t xTaskNotifyFromISR( TaskHandle_t xTaskToNotify, 
                              uint32_t ulValue, 
                              eNotifyAction eAction,
                              BaseType_t *pxHigherPriorityTaskWoken );

BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry,
                           uint32_t ulBitsToClearOnExit,
                           uint32_t *pulNotificationValue,
                           TickType_t xTicksToWait );

assert( pxMyPointer != NULL );

UBaseType_t uxTaskGetSystemState( TaskStatus_t * const pxTaskStatusArray,
                                 const UBaseType_t uxArraySize,
                                 uint32_t * const pulTotalRunTime );

typedef struct xTASK_STATUS
{
    TaskHandle_t xHandle;
    const char *pcTaskName;
    UBaseType_t xTaskNumber;
    eTaskState eCurrentState;
    UBaseType_t uxCurrentPriority; 
    UBaseType_t uxBasePriority;
    uint32_t ulRunTimeCounter; 
    uint16_t usStackHighWaterMark;
} TaskStatus_t;

void vTaskList( signed char *pcWriteBuffer );

void vTaskGetRunTimeStats( signed char *pcWriteBuffer );

UBaseType_t uxTaskGetStackHighWaterMark( TaskHandle_t xTask );

void vApplicationStackOverflowHook( TaskHandle_t *pxTask, signed char *pcTaskName );