task.h File Reference

#include "list.h"

Go to the source code of this file.

Classes
struct	xTIME_OUT
struct	xMEMORY_REGION
struct	xTASK_PARAMETERS
struct	xTASK_STATUS

Macros
#define	tskKERNEL_VERSION_NUMBER   "V9.0.0"
#define	tskKERNEL_VERSION_MAJOR   9
#define	tskKERNEL_VERSION_MINOR   0
#define	tskKERNEL_VERSION_BUILD   0
#define	tskIDLE_PRIORITY   ( ( UBaseType_t ) 0U )
#define	taskYIELD()   portYIELD()
#define	taskENTER_CRITICAL()   portENTER_CRITICAL()
#define	taskENTER_CRITICAL_FROM_ISR()   portSET_INTERRUPT_MASK_FROM_ISR()
#define	taskEXIT_CRITICAL()   portEXIT_CRITICAL()
#define	taskEXIT_CRITICAL_FROM_ISR(x)   portCLEAR_INTERRUPT_MASK_FROM_ISR( x )
#define	taskDISABLE_INTERRUPTS()   portDISABLE_INTERRUPTS()
#define	taskENABLE_INTERRUPTS()   portENABLE_INTERRUPTS()
#define	taskSCHEDULER_SUSPENDED   ( ( BaseType_t ) 0 )
#define	taskSCHEDULER_NOT_STARTED   ( ( BaseType_t ) 1 )
#define	taskSCHEDULER_RUNNING   ( ( BaseType_t ) 2 )
#define	xTaskNotify(xTaskToNotify, ulValue, eAction)   xTaskGenericNotify( ( xTaskToNotify ), ( ulValue ), ( eAction ), NULL )
#define	xTaskNotifyAndQuery(xTaskToNotify, ulValue, eAction, pulPreviousNotifyValue)   xTaskGenericNotify( ( xTaskToNotify ), ( ulValue ), ( eAction ), ( pulPreviousNotifyValue ) )
#define	xTaskNotifyFromISR(xTaskToNotify, ulValue, eAction, pxHigherPriorityTaskWoken)   xTaskGenericNotifyFromISR( ( xTaskToNotify ), ( ulValue ), ( eAction ), NULL, ( pxHigherPriorityTaskWoken ) )
#define	xTaskNotifyAndQueryFromISR(xTaskToNotify, ulValue, eAction, pulPreviousNotificationValue, pxHigherPriorityTaskWoken)   xTaskGenericNotifyFromISR( ( xTaskToNotify ), ( ulValue ), ( eAction ), ( pulPreviousNotificationValue ), ( pxHigherPriorityTaskWoken ) )
#define	xTaskNotifyGive(xTaskToNotify)   xTaskGenericNotify( ( xTaskToNotify ), ( 0 ), eIncrement, NULL )

Typedefs
typedef void *	TaskHandle_t
typedef BaseType_t(*	TaskHookFunction_t) (void *)
typedef struct xTIME_OUT	TimeOut_t
typedef struct xMEMORY_REGION	MemoryRegion_t
typedef struct xTASK_PARAMETERS	TaskParameters_t
typedef struct xTASK_STATUS	TaskStatus_t

Enumerations
enum	eTaskState {   eRunning = 0, eReady, eBlocked, eSuspended,   eDeleted, eInvalid }
enum	eNotifyAction {   eNoAction = 0, eSetBits, eIncrement, eSetValueWithOverwrite,   eSetValueWithoutOverwrite }
enum	eSleepModeStatus { eAbortSleep = 0, eStandardSleep, eNoTasksWaitingTimeout }

Functions
PRIVILEGED_FUNCTION void	vTaskAllocateMPURegions (TaskHandle_t xTask, const MemoryRegion_t *const pxRegions)
PRIVILEGED_FUNCTION void	vTaskDelete (TaskHandle_t xTaskToDelete)
PRIVILEGED_FUNCTION void	vTaskDelay (const TickType_t xTicksToDelay)
PRIVILEGED_FUNCTION void	vTaskDelayUntil (TickType_t *const pxPreviousWakeTime, const TickType_t xTimeIncrement)
PRIVILEGED_FUNCTION BaseType_t	xTaskAbortDelay (TaskHandle_t xTask)
PRIVILEGED_FUNCTION UBaseType_t	uxTaskPriorityGet (TaskHandle_t xTask)
PRIVILEGED_FUNCTION UBaseType_t	uxTaskPriorityGetFromISR (TaskHandle_t xTask)
PRIVILEGED_FUNCTION eTaskState	eTaskGetState (TaskHandle_t xTask)
PRIVILEGED_FUNCTION void	vTaskGetInfo (TaskHandle_t xTask, TaskStatus_t *pxTaskStatus, BaseType_t xGetFreeStackSpace, eTaskState eState)
PRIVILEGED_FUNCTION void	vTaskPrioritySet (TaskHandle_t xTask, UBaseType_t uxNewPriority)
PRIVILEGED_FUNCTION void	vTaskSuspend (TaskHandle_t xTaskToSuspend)
PRIVILEGED_FUNCTION void	vTaskResume (TaskHandle_t xTaskToResume)
PRIVILEGED_FUNCTION BaseType_t	xTaskResumeFromISR (TaskHandle_t xTaskToResume)
PRIVILEGED_FUNCTION void	vTaskStartScheduler (void)
PRIVILEGED_FUNCTION void	vTaskEndScheduler (void)
PRIVILEGED_FUNCTION void	vTaskSuspendAll (void)
PRIVILEGED_FUNCTION BaseType_t	xTaskResumeAll (void)
PRIVILEGED_FUNCTION TickType_t	xTaskGetTickCount (void)
PRIVILEGED_FUNCTION TickType_t	xTaskGetTickCountFromISR (void)
PRIVILEGED_FUNCTION UBaseType_t	uxTaskGetNumberOfTasks (void)
PRIVILEGED_FUNCTION char *	pcTaskGetName (TaskHandle_t xTaskToQuery)
PRIVILEGED_FUNCTION TaskHandle_t	xTaskGetHandle (const char *pcNameToQuery)
PRIVILEGED_FUNCTION UBaseType_t	uxTaskGetStackHighWaterMark (TaskHandle_t xTask)
PRIVILEGED_FUNCTION BaseType_t	xTaskCallApplicationTaskHook (TaskHandle_t xTask, void *pvParameter)
PRIVILEGED_FUNCTION TaskHandle_t	xTaskGetIdleTaskHandle (void)
PRIVILEGED_FUNCTION UBaseType_t	uxTaskGetSystemState (TaskStatus_t *const pxTaskStatusArray, const UBaseType_t uxArraySize, uint32_t *const pulTotalRunTime)
PRIVILEGED_FUNCTION void	vTaskList (char *pcWriteBuffer)
PRIVILEGED_FUNCTION void	vTaskGetRunTimeStats (char *pcWriteBuffer)
PRIVILEGED_FUNCTION BaseType_t	xTaskGenericNotify (TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue)
PRIVILEGED_FUNCTION BaseType_t	xTaskGenericNotifyFromISR (TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue, BaseType_t *pxHigherPriorityTaskWoken)
PRIVILEGED_FUNCTION BaseType_t	xTaskNotifyWait (uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait)
PRIVILEGED_FUNCTION void	vTaskNotifyGiveFromISR (TaskHandle_t xTaskToNotify, BaseType_t *pxHigherPriorityTaskWoken)
PRIVILEGED_FUNCTION uint32_t	ulTaskNotifyTake (BaseType_t xClearCountOnExit, TickType_t xTicksToWait)
BaseType_t	xTaskNotifyStateClear (TaskHandle_t xTask)
PRIVILEGED_FUNCTION BaseType_t	xTaskIncrementTick (void)
PRIVILEGED_FUNCTION void	vTaskPlaceOnEventList (List_t *const pxEventList, const TickType_t xTicksToWait)
PRIVILEGED_FUNCTION void	vTaskPlaceOnUnorderedEventList (List_t *pxEventList, const TickType_t xItemValue, const TickType_t xTicksToWait)
PRIVILEGED_FUNCTION void	vTaskPlaceOnEventListRestricted (List_t *const pxEventList, TickType_t xTicksToWait, const BaseType_t xWaitIndefinitely)
PRIVILEGED_FUNCTION BaseType_t	xTaskRemoveFromEventList (const List_t *const pxEventList)
PRIVILEGED_FUNCTION BaseType_t	xTaskRemoveFromUnorderedEventList (ListItem_t *pxEventListItem, const TickType_t xItemValue)
PRIVILEGED_FUNCTION void	vTaskSwitchContext (void)
PRIVILEGED_FUNCTION TickType_t	uxTaskResetEventItemValue (void)
PRIVILEGED_FUNCTION TaskHandle_t	xTaskGetCurrentTaskHandle (void)
PRIVILEGED_FUNCTION void	vTaskSetTimeOutState (TimeOut_t *const pxTimeOut)
PRIVILEGED_FUNCTION BaseType_t	xTaskCheckForTimeOut (TimeOut_t *const pxTimeOut, TickType_t *const pxTicksToWait)
PRIVILEGED_FUNCTION void	vTaskMissedYield (void)
PRIVILEGED_FUNCTION BaseType_t	xTaskGetSchedulerState (void)
PRIVILEGED_FUNCTION void	vTaskPriorityInherit (TaskHandle_t const pxMutexHolder)
PRIVILEGED_FUNCTION BaseType_t	xTaskPriorityDisinherit (TaskHandle_t const pxMutexHolder)
PRIVILEGED_FUNCTION UBaseType_t	uxTaskGetTaskNumber (TaskHandle_t xTask)
PRIVILEGED_FUNCTION void	vTaskSetTaskNumber (TaskHandle_t xTask, const UBaseType_t uxHandle)
PRIVILEGED_FUNCTION void	vTaskStepTick (const TickType_t xTicksToJump)
PRIVILEGED_FUNCTION eSleepModeStatus	eTaskConfirmSleepModeStatus (void)
PRIVILEGED_FUNCTION void *	pvTaskIncrementMutexHeldCount (void)

Macro Definition Documentation

tskKERNEL_VERSION_NUMBER

#define tskKERNEL_VERSION_NUMBER   "V9.0.0"

tskKERNEL_VERSION_MAJOR

#define tskKERNEL_VERSION_MAJOR   9

tskKERNEL_VERSION_MINOR

#define tskKERNEL_VERSION_MINOR   0

tskKERNEL_VERSION_BUILD

#define tskKERNEL_VERSION_BUILD   0

tskIDLE_PRIORITY

#define tskIDLE_PRIORITY   ( ( UBaseType_t ) 0U )

Defines the priority used by the idle task. This must not be modified.

taskYIELD

#define taskYIELD

(

)

portYIELD()

taskENTER_CRITICAL

#define taskENTER_CRITICAL

(

)

portENTER_CRITICAL()

taskENTER_CRITICAL_FROM_ISR

#define taskENTER_CRITICAL_FROM_ISR

(

)

portSET_INTERRUPT_MASK_FROM_ISR()

taskEXIT_CRITICAL

#define taskEXIT_CRITICAL

(

)

portEXIT_CRITICAL()

taskEXIT_CRITICAL_FROM_ISR

#define taskEXIT_CRITICAL_FROM_ISR

(

x

)

portCLEAR_INTERRUPT_MASK_FROM_ISR( x )

taskDISABLE_INTERRUPTS

#define taskDISABLE_INTERRUPTS

(

)

portDISABLE_INTERRUPTS()

taskENABLE_INTERRUPTS

#define taskENABLE_INTERRUPTS

(

)

portENABLE_INTERRUPTS()

taskSCHEDULER_SUSPENDED

#define taskSCHEDULER_SUSPENDED   ( ( BaseType_t ) 0 )

taskSCHEDULER_NOT_STARTED

#define taskSCHEDULER_NOT_STARTED   ( ( BaseType_t ) 1 )

taskSCHEDULER_RUNNING

#define taskSCHEDULER_RUNNING   ( ( BaseType_t ) 2 )

xTaskNotify

#define xTaskNotify	(		xTaskToNotify,
			ulValue,
			eAction
	)		xTaskGenericNotify( ( xTaskToNotify ), ( ulValue ), ( eAction ), NULL )

xTaskNotifyAndQuery

#define xTaskNotifyAndQuery	(		xTaskToNotify,
			ulValue,
			eAction,
			pulPreviousNotifyValue
	)		xTaskGenericNotify( ( xTaskToNotify ), ( ulValue ), ( eAction ), ( pulPreviousNotifyValue ) )

xTaskNotifyFromISR

#define xTaskNotifyFromISR	(		xTaskToNotify,
			ulValue,
			eAction,
			pxHigherPriorityTaskWoken
	)		xTaskGenericNotifyFromISR( ( xTaskToNotify ), ( ulValue ), ( eAction ), NULL, ( pxHigherPriorityTaskWoken ) )

xTaskNotifyAndQueryFromISR

#define xTaskNotifyAndQueryFromISR	(		xTaskToNotify,
			ulValue,
			eAction,
			pulPreviousNotificationValue,
			pxHigherPriorityTaskWoken
	)		xTaskGenericNotifyFromISR( ( xTaskToNotify ), ( ulValue ), ( eAction ), ( pulPreviousNotificationValue ), ( pxHigherPriorityTaskWoken ) )

xTaskNotifyGive

#define xTaskNotifyGive

(

xTaskToNotify

)

xTaskGenericNotify( ( xTaskToNotify ), ( 0 ), eIncrement, NULL )

Typedef Documentation

TaskHandle_t

typedef void* TaskHandle_t

TaskHookFunction_t

typedef BaseType_t(* TaskHookFunction_t) (void *)

TimeOut_t

typedef struct xTIME_OUT TimeOut_t

MemoryRegion_t

typedef struct xMEMORY_REGION MemoryRegion_t

TaskParameters_t

typedef struct xTASK_PARAMETERS TaskParameters_t

TaskStatus_t

typedef struct xTASK_STATUS TaskStatus_t

Enumeration Type Documentation

eTaskState

enum eTaskState

Enumerator
eRunning
eReady
eBlocked
eSuspended
eDeleted
eInvalid

{
    eRunning = 0,   /* A task is querying the state of itself, so must be running. */
    eReady,         /* The task being queried is in a read or pending ready list. */
    eBlocked,       /* The task being queried is in the Blocked state. */
    eSuspended,     /* The task being queried is in the Suspended state, or is in the Blocked state with an infinite time out. */
    eDeleted,       /* The task being queried has been deleted, but its TCB has not yet been freed. */
    eInvalid            /* Used as an 'invalid state' value. */
} eTaskState;

eNotifyAction

enum eNotifyAction

Enumerator
eNoAction
eSetBits
eIncrement
eSetValueWithOverwrite
eSetValueWithoutOverwrite

{
    eNoAction = 0,              /* Notify the task without updating its notify value. */
    eSetBits,                   /* Set bits in the task's notification value. */
    eIncrement,                 /* Increment the task's notification value. */
    eSetValueWithOverwrite,     /* Set the task's notification value to a specific value even if the previous value has not yet been read by the task. */
    eSetValueWithoutOverwrite   /* Set the task's notification value if the previous value has been read by the task. */
} eNotifyAction;

eSleepModeStatus

enum eSleepModeStatus

Enumerator
eAbortSleep
eStandardSleep
eNoTasksWaitingTimeout

{
    eAbortSleep = 0,        /* A task has been made ready or a context switch pended since portSUPPORESS_TICKS_AND_SLEEP() was called - abort entering a sleep mode. */
    eStandardSleep,         /* Enter a sleep mode that will not last any longer than the expected idle time. */
    eNoTasksWaitingTimeout  /* No tasks are waiting for a timeout so it is safe to enter a sleep mode that can only be exited by an external interrupt. */
} eSleepModeStatus;

Function Documentation

vTaskAllocateMPURegions()

PRIVILEGED_FUNCTION void vTaskAllocateMPURegions	(	TaskHandle_t	xTask,
		const MemoryRegion_t *const	pxRegions
	)

vTaskDelete()

PRIVILEGED_FUNCTION void vTaskDelete

(

TaskHandle_t

xTaskToDelete

)

Here is the caller graph for this function:

vTaskDelay()

PRIVILEGED_FUNCTION void vTaskDelay

(

const TickType_t

xTicksToDelay

)

Here is the caller graph for this function:

vTaskDelayUntil()

PRIVILEGED_FUNCTION void vTaskDelayUntil	(	TickType_t *const	pxPreviousWakeTime,
		const TickType_t	xTimeIncrement
	)

Here is the caller graph for this function:

xTaskAbortDelay()

PRIVILEGED_FUNCTION BaseType_t xTaskAbortDelay

(

TaskHandle_t

xTask

)

Here is the caller graph for this function:

uxTaskPriorityGet()

PRIVILEGED_FUNCTION UBaseType_t uxTaskPriorityGet

(

TaskHandle_t

xTask

)

Here is the caller graph for this function:

uxTaskPriorityGetFromISR()

PRIVILEGED_FUNCTION UBaseType_t uxTaskPriorityGetFromISR

(

TaskHandle_t

xTask

)

task. h

UBaseType_t uxTaskPriorityGetFromISR( TaskHandle_t xTask );

A version of uxTaskPriorityGet() that can be used from an ISR.

Here is the caller graph for this function:

eTaskGetState()

PRIVILEGED_FUNCTION 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

xTask

Handle 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.

vTaskGetInfo()

PRIVILEGED_FUNCTION void vTaskGetInfo	(	TaskHandle_t	xTask,
		TaskStatus_t *	pxTaskStatus,
		BaseType_t	xGetFreeStackSpace,
		eTaskState	eState
	)

vTaskPrioritySet()

PRIVILEGED_FUNCTION void vTaskPrioritySet	(	TaskHandle_t	xTask,
		UBaseType_t	uxNewPriority
	)

Here is the caller graph for this function:

vTaskSuspend()

PRIVILEGED_FUNCTION void vTaskSuspend

(

TaskHandle_t

xTaskToSuspend

)

Here is the caller graph for this function:

vTaskResume()

PRIVILEGED_FUNCTION void vTaskResume

(

TaskHandle_t

xTaskToResume

)

Here is the caller graph for this function:

xTaskResumeFromISR()

PRIVILEGED_FUNCTION BaseType_t xTaskResumeFromISR

(

TaskHandle_t

xTaskToResume

)

Here is the caller graph for this function:

vTaskStartScheduler()

PRIVILEGED_FUNCTION void vTaskStartScheduler

(

void

)

{
BaseType_t xReturn;
 
    /* Add the idle task at the lowest priority. */
    #if( configSUPPORT_STATIC_ALLOCATION == 1 )
    {
        StaticTask_t *pxIdleTaskTCBBuffer = NULL;
        StackType_t *pxIdleTaskStackBuffer = NULL;
        uint32_t ulIdleTaskStackSize;
 
        /* The Idle task is created using user provided RAM - obtain the
        address of the RAM then create the idle task. */
        vApplicationGetIdleTaskMemory( &pxIdleTaskTCBBuffer, &pxIdleTaskStackBuffer, &ulIdleTaskStackSize );
        xIdleTaskHandle = xTaskCreateStatic(    prvIdleTask,
                                                "IDLE",
                                                ulIdleTaskStackSize,
                                                ( void * ) NULL,
                                                ( tskIDLE_PRIORITY | portPRIVILEGE_BIT ),
                                                pxIdleTaskStackBuffer,
                                                pxIdleTaskTCBBuffer ); /*lint !e961 MISRA exception, justified as it is not a redundant explicit cast to all supported compilers. */
 
        if( xIdleTaskHandle != NULL )
        {
            xReturn = pdPASS;
        }
        else
        {
            xReturn = pdFAIL;
        }
    }
    #else
    {
        /* The Idle task is being created using dynamically allocated RAM. */
        xReturn = xTaskCreate(  prvIdleTask,
                                "IDLE", configMINIMAL_STACK_SIZE,
                                ( void * ) NULL,
                                ( tskIDLE_PRIORITY | portPRIVILEGE_BIT ),
                                &xIdleTaskHandle ); /*lint !e961 MISRA exception, justified as it is not a redundant explicit cast to all supported compilers. */
    }
    #endif /* configSUPPORT_STATIC_ALLOCATION */
 
    #if ( configUSE_TIMERS == 1 )
    {
        if( xReturn == pdPASS )
        {
            xReturn = xTimerCreateTimerTask();
        }
        else
        {
            mtCOVERAGE_TEST_MARKER();
        }
    }
    #endif /* configUSE_TIMERS */
 
    if( xReturn == pdPASS )
    {
        /* Interrupts are turned off here, to ensure a tick does not occur
        before or during the call to xPortStartScheduler().  The stacks of
        the created tasks contain a status word with interrupts switched on
        so interrupts will automatically get re-enabled when the first task
        starts to run. */
        portDISABLE_INTERRUPTS();
 
        #if ( configUSE_NEWLIB_REENTRANT == 1 )
        {
            /* Switch Newlib's _impure_ptr variable to point to the _reent
            structure specific to the task that will run first. */
            _impure_ptr = &( pxCurrentTCB->xNewLib_reent );
        }
        #endif /* configUSE_NEWLIB_REENTRANT */
 
        xNextTaskUnblockTime = portMAX_DELAY;
        xSchedulerRunning = pdTRUE;
        xTickCount = ( TickType_t ) 0U;
 
        /* If configGENERATE_RUN_TIME_STATS is defined then the following
        macro must be defined to configure the timer/counter used to generate
        the run time counter time base. */
        portCONFIGURE_TIMER_FOR_RUN_TIME_STATS();
 
        /* Setting up the timer tick is hardware specific and thus in the
        portable interface. */
        if( xPortStartScheduler() != pdFALSE )
        {
            /* Should not reach here as if the scheduler is running the
            function will not return. */
        }
        else
        {
            /* Should only reach here if a task calls xTaskEndScheduler(). */
        }
    }
    else
    {
        /* This line will only be reached if the kernel could not be started,
        because there was not enough FreeRTOS heap to create the idle task
        or the timer task. */
        configASSERT( xReturn != errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY );
    }
 
    /* Prevent compiler warnings if INCLUDE_xTaskGetIdleTaskHandle is set to 0,
    meaning xIdleTaskHandle is not used anywhere else. */
    ( void ) xIdleTaskHandle;
}

Here is the call graph for this function:

Here is the caller graph for this function:

vTaskEndScheduler()

PRIVILEGED_FUNCTION void vTaskEndScheduler

(

void

)

{
    /* Stop the scheduler interrupts and call the portable scheduler end
    routine so the original ISRs can be restored if necessary.  The port
    layer must ensure interrupts enable bit is left in the correct state. */
    portDISABLE_INTERRUPTS();
    xSchedulerRunning = pdFALSE;
    vPortEndScheduler();
}

Here is the call graph for this function:

vTaskSuspendAll()

PRIVILEGED_FUNCTION void vTaskSuspendAll

(

void

)

{
    /* A critical section is not required as the variable is of type
    BaseType_t.  Please read Richard Barry's reply in the following link to a
    post in the FreeRTOS support forum before reporting this as a bug! -
    http://goo.gl/wu4acr */
    ++uxSchedulerSuspended;
}

Here is the caller graph for this function:

xTaskResumeAll()

PRIVILEGED_FUNCTION BaseType_t xTaskResumeAll

(

void

)

{
TCB_t *pxTCB = NULL;
BaseType_t xAlreadyYielded = pdFALSE;
 
    /* If uxSchedulerSuspended is zero then this function does not match a
    previous call to vTaskSuspendAll(). */
    configASSERT( uxSchedulerSuspended );
 
    /* It is possible that an ISR caused a task to be removed from an event
    list while the scheduler was suspended.  If this was the case then the
    removed task will have been added to the xPendingReadyList.  Once the
    scheduler has been resumed it is safe to move all the pending ready
    tasks from this list into their appropriate ready list. */
    taskENTER_CRITICAL();
    {
        --uxSchedulerSuspended;
 
        if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )
        {
            if( uxCurrentNumberOfTasks > ( UBaseType_t ) 0U )
            {
                /* Move any readied tasks from the pending list into the
                appropriate ready list. */
                while( listLIST_IS_EMPTY( &xPendingReadyList ) == pdFALSE )
                {
                    pxTCB = ( TCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( ( &xPendingReadyList ) );
                    ( void ) uxListRemove( &( pxTCB->xEventListItem ) );
                    ( void ) uxListRemove( &( pxTCB->xStateListItem ) );
                    prvAddTaskToReadyList( pxTCB );
 
                    /* If the moved task has a priority higher than the current
                    task then a yield must be performed. */
                    if( pxTCB->uxPriority >= pxCurrentTCB->uxPriority )
                    {
                        xYieldPending = pdTRUE;
                    }
                    else
                    {
                        mtCOVERAGE_TEST_MARKER();
                    }
                }
 
                if( pxTCB != NULL )
                {
                    /* A task was unblocked while the scheduler was suspended,
                    which may have prevented the next unblock time from being
                    re-calculated, in which case re-calculate it now.  Mainly
                    important for low power tickless implementations, where
                    this can prevent an unnecessary exit from low power
                    state. */
                    prvResetNextTaskUnblockTime();
                }
 
                /* If any ticks occurred while the scheduler was suspended then
                they should be processed now.  This ensures the tick count does
                not slip, and that any delayed tasks are resumed at the correct
                time. */
                {
                    UBaseType_t uxPendedCounts = uxPendedTicks; /* Non-volatile copy. */
 
                    if( uxPendedCounts > ( UBaseType_t ) 0U )
                    {
                        do
                        {
                            if( xTaskIncrementTick() != pdFALSE )
                            {
                                xYieldPending = pdTRUE;
                            }
                            else
                            {
                                mtCOVERAGE_TEST_MARKER();
                            }
                            --uxPendedCounts;
                        } while( uxPendedCounts > ( UBaseType_t ) 0U );
 
                        uxPendedTicks = 0;
                    }
                    else
                    {
                        mtCOVERAGE_TEST_MARKER();
                    }
                }
 
                if( xYieldPending != pdFALSE )
                {
                    #if( configUSE_PREEMPTION != 0 )
                    {
                        xAlreadyYielded = pdTRUE;
                    }
                    #endif
                    taskYIELD_IF_USING_PREEMPTION();
                }
                else
                {
                    mtCOVERAGE_TEST_MARKER();
                }
            }
        }
        else
        {
            mtCOVERAGE_TEST_MARKER();
        }
    }
    taskEXIT_CRITICAL();
 
    return xAlreadyYielded;
}

Here is the call graph for this function:

Here is the caller graph for this function:

xTaskGetTickCount()

PRIVILEGED_FUNCTION TickType_t xTaskGetTickCount

(

void

)

{
TickType_t xTicks;
 
    /* Critical section required if running on a 16 bit processor. */
    portTICK_TYPE_ENTER_CRITICAL();
    {
        xTicks = xTickCount;
    }
    portTICK_TYPE_EXIT_CRITICAL();
 
    return xTicks;
}

Here is the caller graph for this function:

xTaskGetTickCountFromISR()

PRIVILEGED_FUNCTION TickType_t xTaskGetTickCountFromISR

(

void

)

{
TickType_t xReturn;
UBaseType_t uxSavedInterruptStatus;
 
    /* RTOS ports that support interrupt nesting have the concept of a maximum
    system call (or maximum API call) interrupt priority.  Interrupts that are
    above the maximum system call priority are kept permanently enabled, even
    when the RTOS kernel is in a critical section, but cannot make any calls to
    FreeRTOS API functions.  If configASSERT() is defined in FreeRTOSConfig.h
    then portASSERT_IF_INTERRUPT_PRIORITY_INVALID() will result in an assertion
    failure if a FreeRTOS API function is called from an interrupt that has been
    assigned a priority above the configured maximum system call priority.
    Only FreeRTOS functions that end in FromISR can be called from interrupts
    that have been assigned a priority at or (logically) below the maximum
    system call interrupt priority.  FreeRTOS maintains a separate interrupt
    safe API to ensure interrupt entry is as fast and as simple as possible.
    More information (albeit Cortex-M specific) is provided on the following
    link: http://www.freertos.org/RTOS-Cortex-M3-M4.html */
    portASSERT_IF_INTERRUPT_PRIORITY_INVALID();
 
    uxSavedInterruptStatus = portTICK_TYPE_SET_INTERRUPT_MASK_FROM_ISR();
    {
        xReturn = xTickCount;
    }
    portTICK_TYPE_CLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );
 
    return xReturn;
}

Here is the caller graph for this function:

uxTaskGetNumberOfTasks()

PRIVILEGED_FUNCTION UBaseType_t uxTaskGetNumberOfTasks

(

void

)

{
    /* A critical section is not required because the variables are of type
    BaseType_t. */
    return uxCurrentNumberOfTasks;
}

pcTaskGetName()

PRIVILEGED_FUNCTION char* pcTaskGetName

(

TaskHandle_t

xTaskToQuery

)

{
TCB_t *pxTCB;
 
    /* If null is passed in here then the name of the calling task is being
    queried. */
    pxTCB = prvGetTCBFromHandle( xTaskToQuery );
    configASSERT( pxTCB );
    return &( pxTCB->pcTaskName[ 0 ] );
}

xTaskGetHandle()

PRIVILEGED_FUNCTION TaskHandle_t xTaskGetHandle

(

const char *

pcNameToQuery

)

uxTaskGetStackHighWaterMark()

PRIVILEGED_FUNCTION UBaseType_t uxTaskGetStackHighWaterMark

(

TaskHandle_t

xTask

)

task.h

UBaseType_t uxTaskGetStackHighWaterMark( TaskHandle_t xTask );

INCLUDE_uxTaskGetStackHighWaterMark must be set to 1 in FreeRTOSConfig.h for this function to be available.

Returns the high water mark of the stack associated with xTask. That is, the minimum free stack space there has been (in words, so on a 32 bit machine a value of 1 means 4 bytes) since the task started. The smaller the returned number the closer the task has come to overflowing its stack.

Parameters

xTask

Handle of the task associated with the stack to be checked. Set xTask to NULL to check the stack of the calling task.

Returns

The smallest amount of free stack space there has been (in words, so actual spaces on the stack rather than bytes) since the task referenced by xTask was created.

xTaskCallApplicationTaskHook()

PRIVILEGED_FUNCTION BaseType_t xTaskCallApplicationTaskHook	(	TaskHandle_t	xTask,
		void *	pvParameter
	)

task.h

BaseType_t xTaskCallApplicationTaskHook( TaskHandle_t xTask, void *pvParameter );

Calls the hook function associated with xTask. Passing xTask as NULL has the effect of calling the Running tasks (the calling task) hook function.

pvParameter is passed to the hook function for the task to interpret as it wants. The return value is the value returned by the task hook function registered by the user.

xTaskGetIdleTaskHandle()

PRIVILEGED_FUNCTION TaskHandle_t xTaskGetIdleTaskHandle

(

void

)

xTaskGetIdleTaskHandle() is only available if INCLUDE_xTaskGetIdleTaskHandle is set to 1 in FreeRTOSConfig.h.

Simply returns the handle of the idle task. It is not valid to call xTaskGetIdleTaskHandle() before the scheduler has been started.

uxTaskGetSystemState()

PRIVILEGED_FUNCTION 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

pxTaskStatusArray	A 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.
uxArraySize	The 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.
pulTotalRunTime	If 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 );
    }
 }
 

vTaskList()

PRIVILEGED_FUNCTION void vTaskList

(

char *

pcWriteBuffer

)

Here is the caller graph for this function:

vTaskGetRunTimeStats()

PRIVILEGED_FUNCTION void vTaskGetRunTimeStats

(

char *

pcWriteBuffer

)

xTaskGenericNotify()

PRIVILEGED_FUNCTION BaseType_t xTaskGenericNotify	(	TaskHandle_t	xTaskToNotify,
		uint32_t	ulValue,
		eNotifyAction	eAction,
		uint32_t *	pulPreviousNotificationValue
	)

Here is the caller graph for this function:

xTaskGenericNotifyFromISR()

PRIVILEGED_FUNCTION BaseType_t xTaskGenericNotifyFromISR	(	TaskHandle_t	xTaskToNotify,
		uint32_t	ulValue,
		eNotifyAction	eAction,
		uint32_t *	pulPreviousNotificationValue,
		BaseType_t *	pxHigherPriorityTaskWoken
	)

Here is the caller graph for this function:

xTaskNotifyWait()

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

Here is the caller graph for this function:

vTaskNotifyGiveFromISR()

PRIVILEGED_FUNCTION void vTaskNotifyGiveFromISR	(	TaskHandle_t	xTaskToNotify,
		BaseType_t *	pxHigherPriorityTaskWoken
	)

ulTaskNotifyTake()

PRIVILEGED_FUNCTION uint32_t ulTaskNotifyTake	(	BaseType_t	xClearCountOnExit,
		TickType_t	xTicksToWait
	)

xTaskNotifyStateClear()

BaseType_t xTaskNotifyStateClear

(

TaskHandle_t

xTask

)

xTaskIncrementTick()

PRIVILEGED_FUNCTION BaseType_t xTaskIncrementTick

(

void

)

{
TCB_t * pxTCB;
TickType_t xItemValue;
BaseType_t xSwitchRequired = pdFALSE;
 
    /* Called by the portable layer each time a tick interrupt occurs.
    Increments the tick then checks to see if the new tick value will cause any
    tasks to be unblocked. */
    traceTASK_INCREMENT_TICK( xTickCount );
    if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )
    {
        /* Minor optimisation.  The tick count cannot change in this
        block. */
        const TickType_t xConstTickCount = xTickCount + 1;
 
        /* Increment the RTOS tick, switching the delayed and overflowed
        delayed lists if it wraps to 0. */
        xTickCount = xConstTickCount;
 
        if( xConstTickCount == ( TickType_t ) 0U )
        {
            taskSWITCH_DELAYED_LISTS();
        }
        else
        {
            mtCOVERAGE_TEST_MARKER();
        }
 
        /* See if this tick has made a timeout expire.  Tasks are stored in
        the queue in the order of their wake time - meaning once one task
        has been found whose block time has not expired there is no need to
        look any further down the list. */
        if( xConstTickCount >= xNextTaskUnblockTime )
        {
            for( ;; )
            {
                if( listLIST_IS_EMPTY( pxDelayedTaskList ) != pdFALSE )
                {
                    /* The delayed list is empty.  Set xNextTaskUnblockTime
                    to the maximum possible value so it is extremely
                    unlikely that the
                    if( xTickCount >= xNextTaskUnblockTime ) test will pass
                    next time through. */
                    xNextTaskUnblockTime = portMAX_DELAY; /*lint !e961 MISRA exception as the casts are only redundant for some ports. */
                    break;
                }
                else
                {
                    /* The delayed list is not empty, get the value of the
                    item at the head of the delayed list.  This is the time
                    at which the task at the head of the delayed list must
                    be removed from the Blocked state. */
                    pxTCB = ( TCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxDelayedTaskList );
                    xItemValue = listGET_LIST_ITEM_VALUE( &( pxTCB->xStateListItem ) );
 
                    if( xConstTickCount < xItemValue )
                    {
                        /* It is not time to unblock this item yet, but the
                        item value is the time at which the task at the head
                        of the blocked list must be removed from the Blocked
                        state - so record the item value in
                        xNextTaskUnblockTime. */
                        xNextTaskUnblockTime = xItemValue;
                        break;
                    }
                    else
                    {
                        mtCOVERAGE_TEST_MARKER();
                    }
 
                    /* It is time to remove the item from the Blocked state. */
                    ( void ) uxListRemove( &( pxTCB->xStateListItem ) );
 
                    /* Is the task waiting on an event also?  If so remove
                    it from the event list. */
                    if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL )
                    {
                        ( void ) uxListRemove( &( pxTCB->xEventListItem ) );
                    }
                    else
                    {
                        mtCOVERAGE_TEST_MARKER();
                    }
 
                    /* Place the unblocked task into the appropriate ready
                    list. */
                    prvAddTaskToReadyList( pxTCB );
 
                    /* A task being unblocked cannot cause an immediate
                    context switch if preemption is turned off. */
                    #if (  configUSE_PREEMPTION == 1 )
                    {
                        /* Preemption is on, but a context switch should
                        only be performed if the unblocked task has a
                        priority that is equal to or higher than the
                        currently executing task. */
                        if( pxTCB->uxPriority >= pxCurrentTCB->uxPriority )
                        {
                            xSwitchRequired = pdTRUE;
                        }
                        else
                        {
                            mtCOVERAGE_TEST_MARKER();
                        }
                    }
                    #endif /* configUSE_PREEMPTION */
                }
            }
        }
 
        /* Tasks of equal priority to the currently running task will share
        processing time (time slice) if preemption is on, and the application
        writer has not explicitly turned time slicing off. */
        #if ( ( configUSE_PREEMPTION == 1 ) && ( configUSE_TIME_SLICING == 1 ) )
        {
            if( listCURRENT_LIST_LENGTH( &( pxReadyTasksLists[ pxCurrentTCB->uxPriority ] ) ) > ( UBaseType_t ) 1 )
            {
                xSwitchRequired = pdTRUE;
            }
            else
            {
                mtCOVERAGE_TEST_MARKER();
            }
        }
        #endif /* ( ( configUSE_PREEMPTION == 1 ) && ( configUSE_TIME_SLICING == 1 ) ) */
 
        #if ( configUSE_TICK_HOOK == 1 )
        {
            /* Guard against the tick hook being called when the pended tick
            count is being unwound (when the scheduler is being unlocked). */
            if( uxPendedTicks == ( UBaseType_t ) 0U )
            {
                vApplicationTickHook();
            }
            else
            {
                mtCOVERAGE_TEST_MARKER();
            }
        }
        #endif /* configUSE_TICK_HOOK */
    }
    else
    {
        ++uxPendedTicks;
 
        /* The tick hook gets called at regular intervals, even if the
        scheduler is locked. */
        #if ( configUSE_TICK_HOOK == 1 )
        {
            vApplicationTickHook();
        }
        #endif
    }
 
    #if ( configUSE_PREEMPTION == 1 )
    {
        if( xYieldPending != pdFALSE )
        {
            xSwitchRequired = pdTRUE;
        }
        else
        {
            mtCOVERAGE_TEST_MARKER();
        }
    }
    #endif /* configUSE_PREEMPTION */
 
    return xSwitchRequired;
}

Here is the call graph for this function:

Here is the caller graph for this function:

vTaskPlaceOnEventList()

PRIVILEGED_FUNCTION void vTaskPlaceOnEventList	(	List_t *const	pxEventList,
		const TickType_t	xTicksToWait
	)

{
    configASSERT( pxEventList );
 
    /* THIS FUNCTION MUST BE CALLED WITH EITHER INTERRUPTS DISABLED OR THE
    SCHEDULER SUSPENDED AND THE QUEUE BEING ACCESSED LOCKED. */
 
    /* Place the event list item of the TCB in the appropriate event list.
    This is placed in the list in priority order so the highest priority task
    is the first to be woken by the event.  The queue that contains the event
    list is locked, preventing simultaneous access from interrupts. */
    vListInsert( pxEventList, &( pxCurrentTCB->xEventListItem ) );
 
    prvAddCurrentTaskToDelayedList( xTicksToWait, pdTRUE );
}

Here is the call graph for this function:

Here is the caller graph for this function:

vTaskPlaceOnUnorderedEventList()

PRIVILEGED_FUNCTION void vTaskPlaceOnUnorderedEventList	(	List_t *	pxEventList,
		const TickType_t	xItemValue,
		const TickType_t	xTicksToWait
	)

{
    configASSERT( pxEventList );
 
    /* THIS FUNCTION MUST BE CALLED WITH THE SCHEDULER SUSPENDED.  It is used by
    the event groups implementation. */
    configASSERT( uxSchedulerSuspended != 0 );
 
    /* Store the item value in the event list item.  It is safe to access the
    event list item here as interrupts won't access the event list item of a
    task that is not in the Blocked state. */
    listSET_LIST_ITEM_VALUE( &( pxCurrentTCB->xEventListItem ), xItemValue | taskEVENT_LIST_ITEM_VALUE_IN_USE );
 
    /* Place the event list item of the TCB at the end of the appropriate event
    list.  It is safe to access the event list here because it is part of an
    event group implementation - and interrupts don't access event groups
    directly (instead they access them indirectly by pending function calls to
    the task level). */
    vListInsertEnd( pxEventList, &( pxCurrentTCB->xEventListItem ) );
 
    prvAddCurrentTaskToDelayedList( xTicksToWait, pdTRUE );
}

Here is the call graph for this function:

Here is the caller graph for this function:

vTaskPlaceOnEventListRestricted()

PRIVILEGED_FUNCTION void vTaskPlaceOnEventListRestricted	(	List_t *const	pxEventList,
		TickType_t	xTicksToWait,
		const BaseType_t	xWaitIndefinitely
	)

xTaskRemoveFromEventList()

PRIVILEGED_FUNCTION BaseType_t xTaskRemoveFromEventList

(

const List_t *const

pxEventList

)

{
TCB_t *pxUnblockedTCB;
BaseType_t xReturn;
 
    /* THIS FUNCTION MUST BE CALLED FROM A CRITICAL SECTION.  It can also be
    called from a critical section within an ISR. */
 
    /* The event list is sorted in priority order, so the first in the list can
    be removed as it is known to be the highest priority.  Remove the TCB from
    the delayed list, and add it to the ready list.
 
    If an event is for a queue that is locked then this function will never
    get called - the lock count on the queue will get modified instead.  This
    means exclusive access to the event list is guaranteed here.
 
    This function assumes that a check has already been made to ensure that
    pxEventList is not empty. */
    pxUnblockedTCB = ( TCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxEventList );
    configASSERT( pxUnblockedTCB );
    ( void ) uxListRemove( &( pxUnblockedTCB->xEventListItem ) );
 
    if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )
    {
        ( void ) uxListRemove( &( pxUnblockedTCB->xStateListItem ) );
        prvAddTaskToReadyList( pxUnblockedTCB );
    }
    else
    {
        /* The delayed and ready lists cannot be accessed, so hold this task
        pending until the scheduler is resumed. */
        vListInsertEnd( &( xPendingReadyList ), &( pxUnblockedTCB->xEventListItem ) );
    }
 
    if( pxUnblockedTCB->uxPriority > pxCurrentTCB->uxPriority )
    {
        /* Return true if the task removed from the event list has a higher
        priority than the calling task.  This allows the calling task to know if
        it should force a context switch now. */
        xReturn = pdTRUE;
 
        /* Mark that a yield is pending in case the user is not using the
        "xHigherPriorityTaskWoken" parameter to an ISR safe FreeRTOS function. */
        xYieldPending = pdTRUE;
    }
    else
    {
        xReturn = pdFALSE;
    }
 
    #if( configUSE_TICKLESS_IDLE != 0 )
    {
        /* If a task is blocked on a kernel object then xNextTaskUnblockTime
        might be set to the blocked task's time out time.  If the task is
        unblocked for a reason other than a timeout xNextTaskUnblockTime is
        normally left unchanged, because it is automatically reset to a new
        value when the tick count equals xNextTaskUnblockTime.  However if
        tickless idling is used it might be more important to enter sleep mode
        at the earliest possible time - so reset xNextTaskUnblockTime here to
        ensure it is updated at the earliest possible time. */
        prvResetNextTaskUnblockTime();
    }
    #endif
 
    return xReturn;
}

Here is the call graph for this function:

Here is the caller graph for this function:

xTaskRemoveFromUnorderedEventList()

PRIVILEGED_FUNCTION BaseType_t xTaskRemoveFromUnorderedEventList	(	ListItem_t *	pxEventListItem,
		const TickType_t	xItemValue
	)

{
TCB_t *pxUnblockedTCB;
BaseType_t xReturn;
 
    /* THIS FUNCTION MUST BE CALLED WITH THE SCHEDULER SUSPENDED.  It is used by
    the event flags implementation. */
    configASSERT( uxSchedulerSuspended != pdFALSE );
 
    /* Store the new item value in the event list. */
    listSET_LIST_ITEM_VALUE( pxEventListItem, xItemValue | taskEVENT_LIST_ITEM_VALUE_IN_USE );
 
    /* Remove the event list form the event flag.  Interrupts do not access
    event flags. */
    pxUnblockedTCB = ( TCB_t * ) listGET_LIST_ITEM_OWNER( pxEventListItem );
    configASSERT( pxUnblockedTCB );
    ( void ) uxListRemove( pxEventListItem );
 
    /* Remove the task from the delayed list and add it to the ready list.  The
    scheduler is suspended so interrupts will not be accessing the ready
    lists. */
    ( void ) uxListRemove( &( pxUnblockedTCB->xStateListItem ) );
    prvAddTaskToReadyList( pxUnblockedTCB );
 
    if( pxUnblockedTCB->uxPriority > pxCurrentTCB->uxPriority )
    {
        /* Return true if the task removed from the event list has
        a higher priority than the calling task.  This allows
        the calling task to know if it should force a context
        switch now. */
        xReturn = pdTRUE;
 
        /* Mark that a yield is pending in case the user is not using the
        "xHigherPriorityTaskWoken" parameter to an ISR safe FreeRTOS function. */
        xYieldPending = pdTRUE;
    }
    else
    {
        xReturn = pdFALSE;
    }
 
    return xReturn;
}

Here is the call graph for this function:

Here is the caller graph for this function:

vTaskSwitchContext()

PRIVILEGED_FUNCTION void vTaskSwitchContext

(

void

)

{
    if( uxSchedulerSuspended != ( UBaseType_t ) pdFALSE )
    {
        /* The scheduler is currently suspended - do not allow a context
        switch. */
        xYieldPending = pdTRUE;
    }
    else
    {
        xYieldPending = pdFALSE;
        traceTASK_SWITCHED_OUT();
 
        #if ( configGENERATE_RUN_TIME_STATS == 1 )
        {
                #ifdef portALT_GET_RUN_TIME_COUNTER_VALUE
                    portALT_GET_RUN_TIME_COUNTER_VALUE( ulTotalRunTime );
                #else
                    ulTotalRunTime = portGET_RUN_TIME_COUNTER_VALUE();
                #endif
 
                /* Add the amount of time the task has been running to the
                accumulated time so far.  The time the task started running was
                stored in ulTaskSwitchedInTime.  Note that there is no overflow
                protection here so count values are only valid until the timer
                overflows.  The guard against negative values is to protect
                against suspect run time stat counter implementations - which
                are provided by the application, not the kernel. */
                if( ulTotalRunTime > ulTaskSwitchedInTime )
                {
                    pxCurrentTCB->ulRunTimeCounter += ( ulTotalRunTime - ulTaskSwitchedInTime );
                }
                else
                {
                    mtCOVERAGE_TEST_MARKER();
                }
                ulTaskSwitchedInTime = ulTotalRunTime;
        }
        #endif /* configGENERATE_RUN_TIME_STATS */
 
        /* Check for stack overflow, if configured. */
        taskCHECK_FOR_STACK_OVERFLOW();
 
        /* Select a new task to run using either the generic C or port
        optimised asm code. */
        taskSELECT_HIGHEST_PRIORITY_TASK();
        traceTASK_SWITCHED_IN();
 
        #if ( configUSE_NEWLIB_REENTRANT == 1 )
        {
            /* Switch Newlib's _impure_ptr variable to point to the _reent
            structure specific to this task. */
            _impure_ptr = &( pxCurrentTCB->xNewLib_reent );
        }
        #endif /* configUSE_NEWLIB_REENTRANT */
    }
}

uxTaskResetEventItemValue()

PRIVILEGED_FUNCTION TickType_t uxTaskResetEventItemValue

(

void

)

{
TickType_t uxReturn;
 
    uxReturn = listGET_LIST_ITEM_VALUE( &( pxCurrentTCB->xEventListItem ) );
 
    /* Reset the event list item to its normal value - so it can be used with
    queues and semaphores. */
    listSET_LIST_ITEM_VALUE( &( pxCurrentTCB->xEventListItem ), ( ( TickType_t ) configMAX_PRIORITIES - ( TickType_t ) pxCurrentTCB->uxPriority ) ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */
 
    return uxReturn;
}

Here is the caller graph for this function:

xTaskGetCurrentTaskHandle()

PRIVILEGED_FUNCTION TaskHandle_t xTaskGetCurrentTaskHandle

(

void

)

Here is the caller graph for this function:

vTaskSetTimeOutState()

PRIVILEGED_FUNCTION void vTaskSetTimeOutState

(

TimeOut_t *const

pxTimeOut

)

{
    configASSERT( pxTimeOut );
    pxTimeOut->xOverflowCount = xNumOfOverflows;
    pxTimeOut->xTimeOnEntering = xTickCount;
}

Here is the caller graph for this function:

xTaskCheckForTimeOut()

PRIVILEGED_FUNCTION BaseType_t xTaskCheckForTimeOut	(	TimeOut_t *const	pxTimeOut,
		TickType_t *const	pxTicksToWait
	)

{
BaseType_t xReturn;
 
    configASSERT( pxTimeOut );
    configASSERT( pxTicksToWait );
 
    taskENTER_CRITICAL();
    {
        /* Minor optimisation.  The tick count cannot change in this block. */
        const TickType_t xConstTickCount = xTickCount;
 
        #if( INCLUDE_xTaskAbortDelay == 1 )
            if( pxCurrentTCB->ucDelayAborted != pdFALSE )
            {
                /* The delay was aborted, which is not the same as a time out,
                but has the same result. */
                pxCurrentTCB->ucDelayAborted = pdFALSE;
                xReturn = pdTRUE;
            }
            else
        #endif
 
        #if ( INCLUDE_vTaskSuspend == 1 )
            if( *pxTicksToWait == portMAX_DELAY )
            {
                /* If INCLUDE_vTaskSuspend is set to 1 and the block time
                specified is the maximum block time then the task should block
                indefinitely, and therefore never time out. */
                xReturn = pdFALSE;
            }
            else
        #endif
 
        if( ( xNumOfOverflows != pxTimeOut->xOverflowCount ) && ( xConstTickCount >= pxTimeOut->xTimeOnEntering ) ) /*lint !e525 Indentation preferred as is to make code within pre-processor directives clearer. */
        {
            /* The tick count is greater than the time at which
            vTaskSetTimeout() was called, but has also overflowed since
            vTaskSetTimeOut() was called.  It must have wrapped all the way
            around and gone past again. This passed since vTaskSetTimeout()
            was called. */
            xReturn = pdTRUE;
        }
        else if( ( ( TickType_t ) ( xConstTickCount - pxTimeOut->xTimeOnEntering ) ) < *pxTicksToWait ) /*lint !e961 Explicit casting is only redundant with some compilers, whereas others require it to prevent integer conversion errors. */
        {
            /* Not a genuine timeout. Adjust parameters for time remaining. */
            *pxTicksToWait -= ( xConstTickCount - pxTimeOut->xTimeOnEntering );
            vTaskSetTimeOutState( pxTimeOut );
            xReturn = pdFALSE;
        }
        else
        {
            xReturn = pdTRUE;
        }
    }
    taskEXIT_CRITICAL();
 
    return xReturn;
}

Here is the call graph for this function:

Here is the caller graph for this function:

vTaskMissedYield()

PRIVILEGED_FUNCTION void vTaskMissedYield

(

void

)

{
    xYieldPending = pdTRUE;
}

Here is the caller graph for this function:

xTaskGetSchedulerState()

PRIVILEGED_FUNCTION BaseType_t xTaskGetSchedulerState

(

void

)

Here is the caller graph for this function:

vTaskPriorityInherit()

PRIVILEGED_FUNCTION void vTaskPriorityInherit

(

TaskHandle_t const

pxMutexHolder

)

Here is the caller graph for this function:

xTaskPriorityDisinherit()

PRIVILEGED_FUNCTION BaseType_t xTaskPriorityDisinherit

(

TaskHandle_t const

pxMutexHolder

)

Here is the caller graph for this function:

uxTaskGetTaskNumber()

PRIVILEGED_FUNCTION UBaseType_t uxTaskGetTaskNumber

(

TaskHandle_t

xTask

)

vTaskSetTaskNumber()

PRIVILEGED_FUNCTION void vTaskSetTaskNumber	(	TaskHandle_t	xTask,
		const UBaseType_t	uxHandle
	)

vTaskStepTick()

PRIVILEGED_FUNCTION void vTaskStepTick

(

const TickType_t

xTicksToJump

)

eTaskConfirmSleepModeStatus()

PRIVILEGED_FUNCTION eSleepModeStatus eTaskConfirmSleepModeStatus

(

void

)

pvTaskIncrementMutexHeldCount()

PRIVILEGED_FUNCTION void* pvTaskIncrementMutexHeldCount

(

void

)

Here is the caller graph for this function: