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

Data Structures
struct	tskTaskControlBlock

Macros
#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	taskRECORD_READY_PRIORITY(uxPriority)

#define	taskRESET_READY_PRIORITY(uxPriority)

#define	taskSELECT_HIGHEST_PRIORITY_TASK()

#define	taskSWITCH_DELAYED_LISTS()

#define	taskYIELD_IF_USING_PREEMPTION()

#define	tskBLOCKED_CHAR ( 'B' )

#define	tskDELETED_CHAR ( 'D' )

#define	tskIDLE_STACK_SIZE configMINIMAL_STACK_SIZE

#define	tskREADY_CHAR ( 'R' )

#define	tskSTACK_FILL_BYTE ( 0xa5U )

#define	tskSUSPENDED_CHAR ( 'S' )

Typedefs
typedef tskTCB	TCB_t

typedef struct tskTaskControlBlock	tskTCB

Enumerations
enum	eNotifyValue { eNotWaitingNotification = 0, eWaitingNotification, eNotified }

Functions
static	portTASK_FUNCTION (prvIdleTask, pvParameters)

static void	prvAddCurrentTaskToDelayedList (const TickType_t xTimeToWake)

static TCB_t *	prvAllocateTCBAndStack (const uint16_t usStackDepth, StackType_t *const puxStackBuffer)

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	prvInitialiseTCBVariables (TCB_t const pxTCB, const char const pcName, UBaseType_t uxPriority, const MemoryRegion_t *const xRegions, const uint16_t usStackDepth) PRIVILEGED_FUNCTION

static void	prvResetNextTaskUnblockTime (void)

UBaseType_t	uxTaskGetNumberOfTasks (void)

TickType_t	uxTaskResetEventItemValue (void)

void	vTaskEndScheduler (void)

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	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	xTaskRemoveFromUnorderedEventList (ListItem_t *pxEventListItem, const TickType_t xItemValue)

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 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 ) 0U

static PRIVILEGED_DATA volatile BaseType_t	xYieldPending = pdFALSE

#define MPU_WRAPPERS_INCLUDED_FROM_API_FILE

#define portRESET_READY_PRIORITY	(	uxPriority,
		uxTopReadyPriority
	)

Referenced by vTaskPlaceOnEventList(), and vTaskPlaceOnUnorderedEventList().

#define prvAddTaskToReadyList ( pxTCB )

Value:

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

Referenced by xTaskIncrementTick(), xTaskRemoveFromEventList(), xTaskRemoveFromUnorderedEventList(), and xTaskResumeAll().

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

#define taskEVENT_LIST_ITEM_VALUE_IN_USE 0x80000000UL

Referenced by vTaskPlaceOnUnorderedEventList(), and xTaskRemoveFromUnorderedEventList().

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

{                                                                                                   \
        /* Find the highest priority queue that contains ready tasks. */                                \
        while( listLIST_IS_EMPTY( &( pxReadyTasksLists[ uxTopReadyPriority ] ) ) )                      \
        {                                                                                               \
			configASSERT( uxTopReadyPriority );                                                          \
            --uxTopReadyPriority;                                                                       \
        }                                                                                               \
                                                                                                        \
        /* 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[ uxTopReadyPriority ] ) );        \
    } /* 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 taskYIELD_IF_USING_PREEMPTION ( )

Referenced by xTaskResumeAll().

#define tskBLOCKED_CHAR ( 'B' )

#define tskDELETED_CHAR ( 'D' )

#define tskIDLE_STACK_SIZE configMINIMAL_STACK_SIZE

Referenced by vTaskStartScheduler().

#define tskREADY_CHAR ( 'R' )

#define tskSTACK_FILL_BYTE ( 0xa5U )

Referenced by prvAllocateTCBAndStack().

#define tskSUSPENDED_CHAR ( 'S' )

typedef tskTCB TCB_t

typedef struct tskTaskControlBlock tskTCB

enum eNotifyValue

Enumerator
eNotWaitingNotification
eWaitingNotification
eNotified

static portTASK_FUNCTION	(	prvIdleTask	,
		pvParameters
	)

static

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

static void prvAddCurrentTaskToDelayedList ( const TickType_t xTimeToWake )

static

References listSET_LIST_ITEM_VALUE, mtCOVERAGE_TEST_MARKER, pxCurrentTCB, pxDelayedTaskList, pxOverflowDelayedTaskList, vListInsert(), tskTaskControlBlock::xGenericListItem, xNextTaskUnblockTime, and xTickCount.

Referenced by vTaskPlaceOnEventList(), and vTaskPlaceOnUnorderedEventList().

static TCB_t* prvAllocateTCBAndStack	(	const uint16_t	usStackDepth,
		StackType_t *const	puxStackBuffer
	)

static

References NULL, pvPortMalloc(), pvPortMallocAligned, tskTaskControlBlock::pxStack, tskSTACK_FILL_BYTE, and vPortFree().

static void prvCheckTasksWaitingTermination ( void )

static

References listGET_OWNER_OF_HEAD_ENTRY, listLIST_IS_EMPTY, mtCOVERAGE_TEST_MARKER, taskENTER_CRITICAL, taskEXIT_CRITICAL, uxCurrentNumberOfTasks, uxListRemove(), vTaskSuspendAll(), tskTaskControlBlock::xGenericListItem, and xTaskResumeAll().

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.

static void prvInitialiseTCBVariables	(	TCB_t *const	pxTCB,
		const char *const	pcName,
		UBaseType_t	uxPriority,
		const MemoryRegion_t *const	xRegions,
		const uint16_t	usStackDepth
	)