Microchip® Advanced Software Framework

tasks.c File Reference
#include <stdlib.h>
#include <string.h>
#include "FreeRTOS.h"
#include "task.h"
#include "timers.h"
#include "stack_macros.h"
#include <stdio.h>

Data Structures

struct  tskTaskControlBlock
 

Macros

#define configIDLE_TASK_NAME   "IDLE"
 
#define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
 
#define prvAddTaskToReadyList(pxTCB)
 
#define prvGetTCBFromHandle(pxHandle)   ( ( ( pxHandle ) == NULL ) ? ( TCB_t * ) pxCurrentTCB : ( TCB_t * ) ( pxHandle ) )
 
#define taskEVENT_LIST_ITEM_VALUE_IN_USE   0x80000000UL
 
#define taskNOT_WAITING_NOTIFICATION   ( ( uint8_t ) 0 )
 
#define taskNOTIFICATION_RECEIVED   ( ( uint8_t ) 2 )
 
#define taskRECORD_READY_PRIORITY(uxPriority)   portRECORD_READY_PRIORITY( uxPriority, uxTopReadyPriority )
 
#define taskRESET_READY_PRIORITY(uxPriority)
 
#define taskSELECT_HIGHEST_PRIORITY_TASK()
 
#define taskSWITCH_DELAYED_LISTS()
 
#define taskWAITING_NOTIFICATION   ( ( uint8_t ) 1 )
 
#define taskYIELD_IF_USING_PREEMPTION()   portYIELD_WITHIN_API()
 
#define tskBLOCKED_CHAR   ( 'B' )
 
#define tskDELETED_CHAR   ( 'D' )
 
#define tskDYNAMICALLY_ALLOCATED_STACK_AND_TCB   ( ( uint8_t ) 0 )
 
#define tskREADY_CHAR   ( 'R' )
 
#define tskSET_NEW_STACKS_TO_KNOWN_VALUE   1
 
#define tskSTACK_FILL_BYTE   ( 0xa5U )
 
#define tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE   ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
 
#define tskSTATICALLY_ALLOCATED_STACK_AND_TCB   ( ( uint8_t ) 2 )
 
#define tskSTATICALLY_ALLOCATED_STACK_ONLY   ( ( uint8_t ) 1 )
 
#define tskSUSPENDED_CHAR   ( 'S' )
 

Typedefs

typedef tskTCB TCB_t
 
typedef struct tskTaskControlBlock tskTCB
 

Functions

eTaskState eTaskGetState (TaskHandle_t xTask)
 task. More...
 
char * pcTaskGetName (TaskHandle_t xTaskToQuery)
 
static portTASK_FUNCTION (prvIdleTask, pvParameters)
 
static void prvAddCurrentTaskToDelayedList (TickType_t xTicksToWait, const BaseType_t xCanBlockIndefinitely)
 
static void prvAddNewTaskToReadyList (TCB_t *pxNewTCB)
 
static void prvCheckTasksWaitingTermination (void)
 
static void prvDeleteTCB (TCB_t *pxTCB)
 
static void prvInitialiseNewTask (TaskFunction_t pxTaskCode, const char *const pcName, const uint32_t ulStackDepth, void *const pvParameters, UBaseType_t uxPriority, TaskHandle_t *const pxCreatedTask, TCB_t *pxNewTCB, const MemoryRegion_t *const xRegions)
 
static void prvInitialiseTaskLists (static void prvCheckTasksWaitingTermination void)
 
static void prvInitialiseTaskLists (void)
 
static UBaseType_t prvListTasksWithinSingleList (TaskStatus_t *pxTaskStatusArray, List_t *pxList, eTaskState eState)
 
static void prvResetNextTaskUnblockTime (void)
 
static uint16_t prvTaskCheckFreeStackSpace (const uint8_t *pucStackByte)
 
static BaseType_t prvTaskIsTaskSuspended (const TaskHandle_t xTask) PRIVILEGED_FUNCTION
 Utility task that simply returns pdTRUE if the task referenced by xTask is currently in the Suspended state, or pdFALSE if the task referenced by xTask is in any other state. More...
 
static char * prvWriteNameToBuffer (char *pcBuffer, const char *pcTaskName)
 
void * pvTaskIncrementMutexHeldCount (void)
 
uint32_t ulTaskNotifyTake (BaseType_t xClearCountOnExit, TickType_t xTicksToWait)
 
UBaseType_t uxTaskGetNumberOfTasks (void)
 
UBaseType_t uxTaskGetSystemState (TaskStatus_t *const pxTaskStatusArray, const UBaseType_t uxArraySize, uint32_t *const pulTotalRunTime)
 configUSE_TRACE_FACILITY must be defined as 1 in FreeRTOSConfig.h for uxTaskGetSystemState() to be available. More...
 
UBaseType_t uxTaskGetTaskNumber (TaskHandle_t xTask)
 
UBaseType_t uxTaskPriorityGet (TaskHandle_t xTask)
 
UBaseType_t uxTaskPriorityGetFromISR (TaskHandle_t xTask)
 task. More...
 
TickType_t uxTaskResetEventItemValue (void)
 
void vApplicationStackOverflowHook (TaskHandle_t xTask, char *pcTaskName)
 
void vApplicationTickHook (void)
 This function is called by FreeRTOS each tick. More...
 
void vTaskDelay (const TickType_t xTicksToDelay)
 
void vTaskDelayUntil (TickType_t *const pxPreviousWakeTime, const TickType_t xTimeIncrement)
 
void vTaskDelete (TaskHandle_t xTaskToDelete)
 
void vTaskEndScheduler (void)
 
void vTaskGetInfo (TaskHandle_t xTask, TaskStatus_t *pxTaskStatus, BaseType_t xGetFreeStackSpace, eTaskState eState)
 
void vTaskInternalSetTimeOutState (TimeOut_t *const pxTimeOut)
 
void vTaskList (char *pcWriteBuffer)
 
void vTaskMissedYield (void)
 
void vTaskNotifyGiveFromISR (TaskHandle_t xTaskToNotify, BaseType_t *pxHigherPriorityTaskWoken)
 
void vTaskPlaceOnEventList (List_t *const pxEventList, const TickType_t xTicksToWait)
 
void vTaskPlaceOnEventListRestricted (List_t *const pxEventList, TickType_t xTicksToWait, const BaseType_t xWaitIndefinitely)
 
void vTaskPlaceOnUnorderedEventList (List_t *pxEventList, const TickType_t xItemValue, const TickType_t xTicksToWait)
 
void vTaskPriorityDisinheritAfterTimeout (TaskHandle_t const pxMutexHolder, UBaseType_t uxHighestPriorityWaitingTask)
 
void vTaskPrioritySet (TaskHandle_t xTask, UBaseType_t uxNewPriority)
 
void vTaskRemoveFromUnorderedEventList (ListItem_t *pxEventListItem, const TickType_t xItemValue)
 
void vTaskResume (TaskHandle_t xTaskToResume)
 
void vTaskSetTaskNumber (TaskHandle_t xTask, const UBaseType_t uxHandle)
 
void vTaskSetTimeOutState (TimeOut_t *const pxTimeOut)
 
void vTaskStartScheduler (void)
 
void vTaskSuspend (TaskHandle_t xTaskToSuspend)
 
void vTaskSuspendAll (void)
 
void vTaskSwitchContext (void)
 
BaseType_t xTaskCheckForTimeOut (TimeOut_t *const pxTimeOut, TickType_t *const pxTicksToWait)
 
BaseType_t xTaskGenericNotify (TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue)
 
BaseType_t xTaskGenericNotifyFromISR (TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue, BaseType_t *pxHigherPriorityTaskWoken)
 
TaskHandle_t xTaskGetCurrentTaskHandle (void)
 
BaseType_t xTaskGetSchedulerState (void)
 
TickType_t xTaskGetTickCount (void)
 
TickType_t xTaskGetTickCountFromISR (void)
 
BaseType_t xTaskIncrementTick (void)
 
BaseType_t xTaskNotifyStateClear (TaskHandle_t xTask)
 
BaseType_t xTaskNotifyWait (uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait)
 
BaseType_t xTaskPriorityDisinherit (TaskHandle_t const pxMutexHolder)
 
BaseType_t xTaskPriorityInherit (TaskHandle_t const pxMutexHolder)
 
BaseType_t xTaskRemoveFromEventList (const List_t *const pxEventList)
 
BaseType_t xTaskResumeAll (void)
 
BaseType_t xTaskResumeFromISR (TaskHandle_t xTaskToResume)
 

Variables

PRIVILEGED_DATA TCB_t *volatile pxCurrentTCB = NULL
 
static PRIVILEGED_DATA List_t
*volatile 
pxDelayedTaskList
 
static PRIVILEGED_DATA List_t
*volatile 
pxOverflowDelayedTaskList
 
static PRIVILEGED_DATA List_t pxReadyTasksLists [configMAX_PRIORITIES]
 
static PRIVILEGED_DATA
volatile UBaseType_t 
uxCurrentNumberOfTasks = ( UBaseType_t ) 0U
 
static PRIVILEGED_DATA
volatile UBaseType_t 
uxDeletedTasksWaitingCleanUp = ( UBaseType_t ) 0U
 
static PRIVILEGED_DATA
volatile UBaseType_t 
uxPendedTicks = ( UBaseType_t ) 0U
 
static PRIVILEGED_DATA
volatile UBaseType_t 
uxSchedulerSuspended = ( UBaseType_t ) pdFALSE
 
static PRIVILEGED_DATA UBaseType_t uxTaskNumber = ( UBaseType_t ) 0U
 
static PRIVILEGED_DATA
volatile UBaseType_t 
uxTopReadyPriority = tskIDLE_PRIORITY
 
static PRIVILEGED_DATA List_t xDelayedTaskList1
 
static PRIVILEGED_DATA List_t xDelayedTaskList2
 
static PRIVILEGED_DATA TaskHandle_t xIdleTaskHandle = NULL
 
static PRIVILEGED_DATA
volatile TickType_t 
xNextTaskUnblockTime = ( TickType_t ) 0U
 
static PRIVILEGED_DATA
volatile BaseType_t 
xNumOfOverflows = ( BaseType_t ) 0
 
static PRIVILEGED_DATA List_t xPendingReadyList
 
static PRIVILEGED_DATA
volatile BaseType_t 
xSchedulerRunning = pdFALSE
 
static PRIVILEGED_DATA List_t xSuspendedTaskList
 
static PRIVILEGED_DATA List_t xTasksWaitingTermination
 
static PRIVILEGED_DATA
volatile TickType_t 
xTickCount = ( TickType_t ) configINITIAL_TICK_COUNT
 
static PRIVILEGED_DATA
volatile BaseType_t 
xYieldPending = pdFALSE
 

#define configIDLE_TASK_NAME   "IDLE"

Referenced by vTaskStartScheduler().

#define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
#define prvAddTaskToReadyList (   pxTCB)
Value:
taskRECORD_READY_PRIORITY( ( pxTCB )->uxPriority ); \
vListInsertEnd( &( pxReadyTasksLists[ ( pxTCB )->uxPriority ] ), &( ( pxTCB )->xStateListItem ) ); \
static PRIVILEGED_DATA List_t pxReadyTasksLists[configMAX_PRIORITIES]
Definition: tasks.c:351
#define traceMOVED_TASK_TO_READY_STATE(pxTCB)
Definition: FreeRTOS.h:389
#define taskRECORD_READY_PRIORITY(uxPriority)
Definition: tasks.c:182
#define tracePOST_MOVED_TASK_TO_READY_STATE(pxTCB)
Definition: FreeRTOS.h:393
void vListInsertEnd(List_t *const pxList, ListItem_t *const pxNewListItem)
Definition: list.c:75

Referenced by prvAddNewTaskToReadyList(), vTaskNotifyGiveFromISR(), vTaskPriorityDisinheritAfterTimeout(), vTaskPrioritySet(), vTaskRemoveFromUnorderedEventList(), vTaskResume(), xTaskGenericNotify(), xTaskGenericNotifyFromISR(), xTaskIncrementTick(), xTaskPriorityDisinherit(), xTaskPriorityInherit(), xTaskRemoveFromEventList(), xTaskResumeAll(), and xTaskResumeFromISR().

#define prvGetTCBFromHandle (   pxHandle)    ( ( ( pxHandle ) == NULL ) ? ( TCB_t * ) pxCurrentTCB : ( TCB_t * ) ( pxHandle ) )
#define taskNOT_WAITING_NOTIFICATION   ( ( uint8_t ) 0 )
#define taskNOTIFICATION_RECEIVED   ( ( uint8_t ) 2 )
#define taskRECORD_READY_PRIORITY (   uxPriority)    portRECORD_READY_PRIORITY( uxPriority, uxTopReadyPriority )
#define taskRESET_READY_PRIORITY (   uxPriority)
Value:
{ \
if( listCURRENT_LIST_LENGTH( &( pxReadyTasksLists[ ( uxPriority ) ] ) ) == ( UBaseType_t ) 0 ) \
{ \
portRESET_READY_PRIORITY( ( uxPriority ), ( uxTopReadyPriority ) ); \
} \
}
static PRIVILEGED_DATA List_t pxReadyTasksLists[configMAX_PRIORITIES]
Definition: tasks.c:351
static PRIVILEGED_DATA volatile UBaseType_t uxTopReadyPriority
Definition: tasks.c:374
#define listCURRENT_LIST_LENGTH(pxList)
Definition: list.h:255

Referenced by vTaskDelete(), vTaskPriorityDisinheritAfterTimeout(), vTaskSuspend(), xTaskPriorityDisinherit(), and xTaskPriorityInherit().

#define taskSELECT_HIGHEST_PRIORITY_TASK ( )
Value:
{ \
UBaseType_t uxTopPriority; \
\
/* Find the highest priority list that contains ready tasks. */ \
portGET_HIGHEST_PRIORITY( uxTopPriority, uxTopReadyPriority ); \
configASSERT( listCURRENT_LIST_LENGTH( &( pxReadyTasksLists[ uxTopPriority ] ) ) > 0 ); \
} /* taskSELECT_HIGHEST_PRIORITY_TASK() */
static PRIVILEGED_DATA List_t pxReadyTasksLists[configMAX_PRIORITIES]
Definition: tasks.c:351
#define listGET_OWNER_OF_NEXT_ENTRY(pxTCB, pxList)
Definition: list.h:277
PRIVILEGED_DATA TCB_t *volatile pxCurrentTCB
Definition: tasks.c:348
#define configASSERT(x)
Definition: FreeRTOSConfig.h:137
static PRIVILEGED_DATA volatile UBaseType_t uxTopReadyPriority
Definition: tasks.c:374
#define listCURRENT_LIST_LENGTH(pxList)
Definition: list.h:255

Referenced by vTaskSwitchContext().

#define taskSWITCH_DELAYED_LISTS ( )
Value:
{ \
List_t *pxTemp; \
\
/* The delayed tasks list should be empty when the lists are switched. */ \
\
pxTemp = pxDelayedTaskList; \
}
static PRIVILEGED_DATA volatile BaseType_t xNumOfOverflows
Definition: tasks.c:378
static void prvResetNextTaskUnblockTime(void)
Definition: tasks.c:3730
#define configASSERT(x)
Definition: FreeRTOSConfig.h:137
#define listLIST_IS_EMPTY(pxList)
Definition: list.h:250
static PRIVILEGED_DATA List_t *volatile pxDelayedTaskList
Definition: tasks.c:354
struct xLIST List_t
static PRIVILEGED_DATA List_t *volatile pxOverflowDelayedTaskList
Definition: tasks.c:355

Referenced by xTaskIncrementTick().

#define taskWAITING_NOTIFICATION   ( ( uint8_t ) 1 )
#define taskYIELD_IF_USING_PREEMPTION ( )    portYIELD_WITHIN_API()
#define tskBLOCKED_CHAR   ( 'B' )

Referenced by vTaskList().

#define tskDELETED_CHAR   ( 'D' )

Referenced by vTaskList().

#define tskDYNAMICALLY_ALLOCATED_STACK_AND_TCB   ( ( uint8_t ) 0 )

Referenced by prvDeleteTCB().

#define tskREADY_CHAR   ( 'R' )

Referenced by vTaskList().

#define tskSET_NEW_STACKS_TO_KNOWN_VALUE   1
#define tskSTACK_FILL_BYTE   ( 0xa5U )
#define tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE   ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
#define tskSTATICALLY_ALLOCATED_STACK_AND_TCB   ( ( uint8_t ) 2 )

Referenced by prvDeleteTCB().

#define tskSTATICALLY_ALLOCATED_STACK_ONLY   ( ( uint8_t ) 1 )

Referenced by prvDeleteTCB().

#define tskSUSPENDED_CHAR   ( 'S' )

Referenced by vTaskList().

typedef tskTCB TCB_t
typedef struct tskTaskControlBlock tskTCB

eTaskState eTaskGetState ( TaskHandle_t  xTask)

task.

h

eTaskState eTaskGetState( TaskHandle_t xTask );

INCLUDE_eTaskGetState must be defined as 1 for this function to be available. See the configuration section for more information.

Obtain the state of any task. States are encoded by the eTaskState enumerated type.

Parameters
xTaskHandle of the task to be queried.
Returns
The state of xTask at the time the function was called. Note the state of the task might change between the function being called, and the functions return value being tested by the calling task.

References configASSERT, eBlocked, eDeleted, eReady, eRunning, eSuspended, listLIST_ITEM_CONTAINER, pxCurrentTCB, pxDelayedTaskList, pxOverflowDelayedTaskList, taskENTER_CRITICAL, taskEXIT_CRITICAL, tskTaskControlBlock::xEventListItem, tskTaskControlBlock::xStateListItem, xSuspendedTaskList, and xTasksWaitingTermination.

Referenced by vTaskGetInfo().

char* pcTaskGetName ( TaskHandle_t  xTaskToQuery)
static void prvCheckTasksWaitingTermination ( void  )
static
static void prvInitialiseTaskLists ( static void prvCheckTasksWaitingTermination  void)
static
static UBaseType_t prvListTasksWithinSingleList ( TaskStatus_t pxTaskStatusArray,
List_t pxList,
eTaskState  eState 
)
static
static uint16_t prvTaskCheckFreeStackSpace ( const uint8_t *  pucStackByte)
static

References tskSTACK_FILL_BYTE.

Referenced by vTaskGetInfo().

static BaseType_t prvTaskIsTaskSuspended ( const TaskHandle_t  xTask)
static

Utility task that simply returns pdTRUE if the task referenced by xTask is currently in the Suspended state, or pdFALSE if the task referenced by xTask is in any other state.

References configASSERT, listIS_CONTAINED_WITHIN, mtCOVERAGE_TEST_MARKER, pdFALSE, pdTRUE, tskTaskControlBlock::xEventListItem, xPendingReadyList, tskTaskControlBlock::xStateListItem, and xSuspendedTaskList.

Referenced by vTaskResume(), and xTaskResumeFromISR().

static char* prvWriteNameToBuffer ( char *  pcBuffer,
const char *  pcTaskName 
)
static

References configMAX_TASK_NAME_LEN.

Referenced by vTaskList().

void* pvTaskIncrementMutexHeldCount ( void  )
UBaseType_t uxTaskGetNumberOfTasks ( void  )

References uxCurrentNumberOfTasks.

Referenced by task_monitor().

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

configUSE_TRACE_FACILITY must be defined as 1 in FreeRTOSConfig.h for uxTaskGetSystemState() to be available.

uxTaskGetSystemState() populates an TaskStatus_t structure for each task in the system. TaskStatus_t structures contain, among other things, members for the task handle, task name, task priority, task state, and total amount of run time consumed by the task. See the TaskStatus_t structure definition in this file for the full member list.

NOTE: This function is intended for debugging use only as its use results in the scheduler remaining suspended for an extended period.

Parameters
pxTaskStatusArrayA pointer to an array of TaskStatus_t structures. The array must contain at least one TaskStatus_t structure for each task that is under the control of the RTOS. The number of tasks under the control of the RTOS can be determined using the uxTaskGetNumberOfTasks() API function.
uxArraySizeThe size of the array pointed to by the pxTaskStatusArray parameter. The size is specified as the number of indexes in the array, or the number of TaskStatus_t structures contained in the array, not by the number of bytes in the array.
pulTotalRunTimeIf configGENERATE_RUN_TIME_STATS is set to 1 in FreeRTOSConfig.h then *pulTotalRunTime is set by uxTaskGetSystemState() to the total run time (as defined by the run time stats clock, see http://www.freertos.org/rtos-run-time-stats.html) since the target booted. pulTotalRunTime can be set to NULL to omit the total run time information.
Returns
The number of TaskStatus_t structures that were populated by uxTaskGetSystemState(). This should equal the number returned by the uxTaskGetNumberOfTasks() API function, but will be zero if the value passed in the uxArraySize parameter was too small.

Example usage:

This example demonstrates how a human readable table of run time stats
information is generated from raw data provided by uxTaskGetSystemState().
The human readable table is written to pcWriteBuffer
    void vTaskGetRunTimeStats( char *pcWriteBuffer )
    {
    TaskStatus_t *pxTaskStatusArray;
    volatile UBaseType_t uxArraySize, x;
    uint32_t ulTotalRunTime, ulStatsAsPercentage;
Make sure the write buffer does not contain a string.
         pcWriteBuffer = 0x00;
Take a snapshot of the number of tasks in case it changes while this
function is executing.
        uxArraySize = uxTaskGetNumberOfTasks();
Allocate a TaskStatus_t structure for each task.  An array could be
allocated statically at compile time.
        pxTaskStatusArray = pvPortMalloc( uxArraySize * sizeof( TaskStatus_t ) );
        if( pxTaskStatusArray != NULL )
        {
Generate raw status information about each task.
            uxArraySize = uxTaskGetSystemState( pxTaskStatusArray, uxArraySize, &ulTotalRunTime );
For percentage calculations.
            ulTotalRunTime /= 100UL;
Avoid divide by zero errors.
            if( ulTotalRunTime > 0 )
            {
For each populated position in the pxTaskStatusArray array,
format the raw data as human readable ASCII data
                for( x = 0; x < uxArraySize; x++ )
                {
What percentage of the total run time has the task used?
This will always be rounded down to the nearest integer.
ulTotalRunTimeDiv100 has already been divided by 100.
                    ulStatsAsPercentage = pxTaskStatusArray[ x ].ulRunTimeCounter / ulTotalRunTime;
                    if( ulStatsAsPercentage > 0UL )
                    {
                        sprintf( pcWriteBuffer, "%s\t\t%lu\t\t%lu%%\r\n", pxTaskStatusArray[ x ].pcTaskName, pxTaskStatusArray[ x ].ulRunTimeCounter, ulStatsAsPercentage );
                    }
                    else
                    {
If the percentage is zero here then the task has
consumed less than 1% of the total run time.
                        sprintf( pcWriteBuffer, "%s\t\t%lu\t\t<1%%\r\n", pxTaskStatusArray[ x ].pcTaskName, pxTaskStatusArray[ x ].ulRunTimeCounter );
                    }
                    pcWriteBuffer += strlen( ( char * ) pcWriteBuffer );
                }
            }
The array is no longer needed, free the memory it consumes.
            vPortFree( pxTaskStatusArray );
        }
    }
    

References configMAX_PRIORITIES, eBlocked, eDeleted, eReady, eSuspended, mtCOVERAGE_TEST_MARKER, prvListTasksWithinSingleList(), pxDelayedTaskList, pxOverflowDelayedTaskList, pxReadyTasksLists, uxCurrentNumberOfTasks, vTaskSuspendAll(), xSuspendedTaskList, xTaskResumeAll(), and xTasksWaitingTermination.

Referenced by vTaskList().

UBaseType_t uxTaskGetTaskNumber ( TaskHandle_t  xTask)
UBaseType_t uxTaskPriorityGet ( TaskHandle_t  xTask)
void vApplicationStackOverflowHook ( TaskHandle_t  xTask,
char *  pcTaskName 
)
void vApplicationTickHook ( void  )

This function is called by FreeRTOS each tick.

Referenced by xTaskIncrementTick().

void vTaskDelayUntil ( TickType_t *const  pxPreviousWakeTime,
const TickType_t  xTimeIncrement 
)
void vTaskEndScheduler ( void  )
void vTaskMissedYield ( void  )

References pdTRUE, and xYieldPending.

Referenced by prvUnlockQueue().

void vTaskPlaceOnEventList ( List_t *const  pxEventList,
const TickType_t  xTicksToWait 
)
void vTaskPlaceOnEventListRestricted ( List_t *const  pxEventList,
TickType_t  xTicksToWait,
const BaseType_t  xWaitIndefinitely 
)
void vTaskPlaceOnUnorderedEventList ( List_t pxEventList,
const TickType_t  xItemValue,
const TickType_t  xTicksToWait 
)
void vTaskSetTaskNumber ( TaskHandle_t  xTask,
const UBaseType_t  uxHandle 
)
TaskHandle_t xTaskGetCurrentTaskHandle ( void  )
TickType_t xTaskGetTickCount ( void  )

PRIVILEGED_DATA volatile UBaseType_t uxDeletedTasksWaitingCleanUp = ( UBaseType_t ) 0U
static
PRIVILEGED_DATA volatile UBaseType_t uxPendedTicks = ( UBaseType_t ) 0U
static
PRIVILEGED_DATA UBaseType_t uxTaskNumber = ( UBaseType_t ) 0U
static
PRIVILEGED_DATA volatile UBaseType_t uxTopReadyPriority = tskIDLE_PRIORITY
static
PRIVILEGED_DATA List_t xDelayedTaskList1
static

Referenced by prvInitialiseTaskLists().

PRIVILEGED_DATA List_t xDelayedTaskList2
static

Referenced by prvInitialiseTaskLists().

PRIVILEGED_DATA TaskHandle_t xIdleTaskHandle = NULL
static

Referenced by vTaskStartScheduler().

PRIVILEGED_DATA volatile TickType_t xNextTaskUnblockTime = ( TickType_t ) 0U
static
PRIVILEGED_DATA volatile BaseType_t xNumOfOverflows = ( BaseType_t ) 0
static