#include <stdlib.h>
#include <string.h>
#include "FreeRTOS.h"
#include "task.h"
#include "timers.h"
#include "stack_macros.h"

Data Structures
struct	tskTaskControlBlock

Macros
#define	configIDLE_TASK_NAME "IDLE"

#define	MPU_WRAPPERS_INCLUDED_FROM_API_FILE

#define	portRESET_READY_PRIORITY(uxPriority, uxTopReadyPriority)

#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)

#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()

#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 0

#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
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	prvInitialiseTaskLists (static void prvCheckTasksWaitingTermination void)
	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 void	prvInitialiseTaskLists (void)

static void	prvResetNextTaskUnblockTime (void)

UBaseType_t	uxTaskGetNumberOfTasks (void)

TickType_t	uxTaskResetEventItemValue (void)

void	vTaskEndScheduler (void)

void	vTaskInternalSetTimeOutState (TimeOut_t *const pxTimeOut)

void	vTaskMissedYield (void)

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

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

void	vTaskRemoveFromUnorderedEventList (ListItem_t *pxEventListItem, const TickType_t xItemValue)

void	vTaskSetTimeOutState (TimeOut_t *const pxTimeOut)

void	vTaskStartScheduler (void)

void	vTaskSuspendAll (void)

void	vTaskSwitchContext (void)

BaseType_t	xTaskCheckForTimeOut (TimeOut_t const pxTimeOut, TickType_t const pxTicksToWait)

TickType_t	xTaskGetTickCount (void)

TickType_t	xTaskGetTickCountFromISR (void)

BaseType_t	xTaskIncrementTick (void)

BaseType_t	xTaskRemoveFromEventList (const List_t *const pxEventList)

BaseType_t	xTaskResumeAll (void)

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	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 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 portRESET_READY_PRIORITY	(	uxPriority,
		uxTopReadyPriority
	)

Referenced by prvAddCurrentTaskToDelayedList().

#define prvAddTaskToReadyList ( pxTCB )

Value:

traceMOVED_TASK_TO_READY_STATE( pxTCB );                                                        \
	taskRECORD_READY_PRIORITY( ( pxTCB )->uxPriority );                                                \
	vListInsertEnd( &( pxReadyTasksLists[ ( pxTCB )->uxPriority ] ), &( ( pxTCB )->xStateListItem ) ); \
	tracePOST_MOVED_TASK_TO_READY_STATE( pxTCB )

Referenced by prvAddNewTaskToReadyList(), vTaskRemoveFromUnorderedEventList(), xTaskIncrementTick(), xTaskRemoveFromEventList(), and xTaskResumeAll().

#define prvGetTCBFromHandle ( pxHandle ) ( ( ( pxHandle ) == NULL ) ? ( TCB_t * ) pxCurrentTCB : ( TCB_t * ) ( pxHandle ) )

Referenced by pcTaskGetName().

#define taskEVENT_LIST_ITEM_VALUE_IN_USE 0x80000000UL

Referenced by vTaskPlaceOnUnorderedEventList(), and vTaskRemoveFromUnorderedEventList().

#define taskNOT_WAITING_NOTIFICATION ( ( uint8_t ) 0 )

#define taskNOTIFICATION_RECEIVED ( ( uint8_t ) 2 )

#define taskRECORD_READY_PRIORITY ( uxPriority )

Value:

{                                                                                                   \
		if( ( uxPriority ) > uxTopReadyPriority )                                                     \
        {                                                                                               \
			uxTopReadyPriority = ( uxPriority );                                                     \
        }                                                                                               \
    } /* taskRECORD_READY_PRIORITY */

#define taskRESET_READY_PRIORITY ( uxPriority )

#define taskSELECT_HIGHEST_PRIORITY_TASK ( )

Value:

{                                                                                                   \
    UBaseType_t uxTopPriority = uxTopReadyPriority;                                                     \
                                                                                                        \
        /* Find the highest priority queue that contains ready tasks. */                                \
		while( listLIST_IS_EMPTY( &( pxReadyTasksLists[ uxTopPriority ] ) ) )                         \
        {                                                                                               \
			configASSERT( uxTopPriority );                                                               \
            --uxTopPriority;                                                                            \
        }                                                                                               \
                                                                                                        \
        /* listGET_OWNER_OF_NEXT_ENTRY indexes through the list, so the tasks of                        \
        the same priority get an equal share of the processor time. */                                  \
		listGET_OWNER_OF_NEXT_ENTRY( pxCurrentTCB, &( pxReadyTasksLists[ uxTopPriority ] ) );         \
		uxTopReadyPriority = uxTopPriority;                                                               \
    } /* taskSELECT_HIGHEST_PRIORITY_TASK */

Referenced by vTaskSwitchContext().

#define taskSWITCH_DELAYED_LISTS ( )

Value:

{                                                                                                   \
	List_t *pxTemp;                                                                                    \
                                                                                                    \
    /* The delayed tasks list should be empty when the lists are switched. */                       \
	configASSERT( ( listLIST_IS_EMPTY( pxDelayedTaskList ) ) );                                        \
                                                                                                    \
    pxTemp = pxDelayedTaskList;                                                                     \
	pxDelayedTaskList = pxOverflowDelayedTaskList;                                                 \
	pxOverflowDelayedTaskList = pxTemp;                                                                \
	xNumOfOverflows++;                                                                             \
	prvResetNextTaskUnblockTime();                                                                 \
}

Referenced by xTaskIncrementTick().

#define taskWAITING_NOTIFICATION ( ( uint8_t ) 1 )

#define taskYIELD_IF_USING_PREEMPTION ( )

Referenced by prvAddNewTaskToReadyList(), and xTaskResumeAll().

#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 0

#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' )

typedef tskTCB TCB_t

typedef struct tskTaskControlBlock tskTCB

char* pcTaskGetName ( TaskHandle_t xTaskToQuery )

References configASSERT, tskTaskControlBlock::pcTaskName, and prvGetTCBFromHandle.

static portTASK_FUNCTION	(	prvIdleTask	,
		pvParameters
	)

static

THIS IS THE RTOS IDLE TASK - WHICH IS CREATED AUTOMATICALLY WHEN THE

SCHEDULER IS STARTED.

References configASSERT, configEXPECTED_IDLE_TIME_BEFORE_SLEEP, configPRE_SUPPRESS_TICKS_AND_SLEEP_PROCESSING, listCURRENT_LIST_LENGTH, mtCOVERAGE_TEST_MARKER, portSUPPRESS_TICKS_AND_SLEEP, portTASK_CALLS_SECURE_FUNCTIONS, prvCheckTasksWaitingTermination(), pxReadyTasksLists, taskYIELD, traceLOW_POWER_IDLE_BEGIN, traceLOW_POWER_IDLE_END, vApplicationIdleHook(), vTaskSuspendAll(), xNextTaskUnblockTime, xTaskResumeAll(), and xTickCount.

static void prvAddCurrentTaskToDelayedList	(	TickType_t	xTicksToWait,
		const BaseType_t	xCanBlockIndefinitely
	)

static

References listSET_LIST_ITEM_VALUE, mtCOVERAGE_TEST_MARKER, pdFALSE, portRESET_READY_PRIORITY, pxCurrentTCB, pxDelayedTaskList, pxOverflowDelayedTaskList, uxListRemove(), tskTaskControlBlock::uxPriority, uxTopReadyPriority, vListInsert(), vListInsertEnd(), xNextTaskUnblockTime, tskTaskControlBlock::xStateListItem, and xTickCount.

Referenced by vTaskPlaceOnEventList(), and vTaskPlaceOnUnorderedEventList().

static void prvAddNewTaskToReadyList ( TCB_t * pxNewTCB )

static

References mtCOVERAGE_TEST_MARKER, NULL, pdFALSE, portSETUP_TCB, prvAddTaskToReadyList, prvInitialiseTaskLists(), pxCurrentTCB, taskENTER_CRITICAL, taskEXIT_CRITICAL, taskYIELD_IF_USING_PREEMPTION, traceTASK_CREATE, uxCurrentNumberOfTasks, tskTaskControlBlock::uxPriority, uxTaskNumber, and xSchedulerRunning.

static void prvCheckTasksWaitingTermination ( void )

static

THIS FUNCTION IS CALLED FROM THE RTOS IDLE TASK

References listGET_OWNER_OF_HEAD_ENTRY, taskENTER_CRITICAL, taskEXIT_CRITICAL, uxCurrentNumberOfTasks, uxListRemove(), and tskTaskControlBlock::xStateListItem.

Referenced by portTASK_FUNCTION().

static void prvInitialiseTaskLists ( static void prvCheckTasksWaitingTermination void )

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.

static void prvInitialiseTaskLists ( void )

static

References pxDelayedTaskList, pxOverflowDelayedTaskList, pxReadyTasksLists, vListInitialise(), xDelayedTaskList1, xDelayedTaskList2, and xPendingReadyList.