task.h

/*
 * FreeRTOS Kernel V10.0.1
 * Copyright (C) 2017 Amazon.com, Inc. or its affiliates.  All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * http://www.FreeRTOS.org
 * http://aws.amazon.com/freertos
 *
 * 1 tab == 4 spaces!
 */
 
#include "FreeRTOS.h"
 
#ifndef INC_TASK_H
#define INC_TASK_H
 
#ifndef INC_FREERTOS_H
    #error "include FreeRTOS.h must appear in source files before include task.h"
#endif
 
#include "list.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
/*-----------------------------------------------------------
 * MACROS AND DEFINITIONS
 *----------------------------------------------------------*/
 
#define tskKERNEL_VERSION_NUMBER "V10.0.1"
#define tskKERNEL_VERSION_MAJOR 10
#define tskKERNEL_VERSION_MINOR 0
#define tskKERNEL_VERSION_BUILD 1

typedef void * task_t;
 
/*
 * Defines the prototype to which the application task hook function must
 * conform.
 */
typedef int32_t (*TaskHookFunction_t)( void * );
 
/* Task states returned by task_get_state. */
typedef enum
{
    E_TASK_STATE_RUNNING = 0,   /* A task is querying the state of itself, so must be running. */
    E_TASK_STATE_READY,           /* The task being queried is in a read or pending ready list. */
    E_TASK_STATE_BLOCKED,       /* The task being queried is in the Blocked state. */
    E_TASK_STATE_SUSPENDED,       /* The task being queried is in the Suspended state, or is in the Blocked state with an infinite time out. */
    E_TASK_STATE_DELETED,       /* The task being queried has been deleted, but its TCB has not yet been freed. */
    E_TASK_STATE_INVALID            /* Used as an 'invalid state' value. */
} task_state_e_t;
 
/* Actions that can be performed when vTaskNotify() is called. */
typedef enum
{
    E_NOTIFY_ACTION_NONE = 0,               /* Notify the task without updating its notify value. */
    E_NOTIFY_ACTION_BITS,                   /* Set bits in the task's notification value. */
    E_NOTIFY_ACTION_INCR,                   /* Increment the task's notification value. */
    E_NOTIFY_ACTION_OWRITE,       /* Set the task's notification value to a specific value even if the previous value has not yet been read by the task. */
    E_NOTIFY_ACTION_NO_OWRITE  /* Set the task's notification value if the previous value has been read by the task. */
} notify_action_e_t;
 
/*
 * Used internally only.
 */
typedef struct xTIME_OUT
{
    int32_t xOverflowCount;
    uint32_t xTimeOnEntering;
} TimeOut_t;
 
 
/*
 * Parameters required to create an MPU protected task.
 */
typedef struct xTASK_PARAMETERS
{
    task_fn_t pvTaskCode;
    const char * const pcName;  /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
    uint16_t usStackDepth;
    void *pvParameters;
    uint32_t uxPriority;
    task_stack_t *puxStackBuffer;
} TaskParameters_t;
 
/* Used with the uxTaskGetSystemState() function to return the state of each task
in the system. */
typedef struct xTASK_STATUS
{
    task_t xHandle;         /* The handle of the task to which the rest of the information in the structure relates. */
    const char *pcTaskName;         /* A pointer to the task's name.  This value will be invalid if the task was deleted since the structure was populated! */ /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
    uint32_t xTaskNumber;       /* A number unique to the task. */
    task_state_e_t eCurrentState;       /* The state in which the task existed when the structure was populated. */
    uint32_t uxCurrentPriority; /* The priority at which the task was running (may be inherited) when the structure was populated. */
    uint32_t uxBasePriority;        /* The priority to which the task will return if the task's current priority has been inherited to avoid unbounded priority inversion when obtaining a mutex.  Only valid if configUSE_MUTEXES is defined as 1 in FreeRTOSConfig.h. */
    uint32_t ulRunTimeCounter;      /* The total run time allocated to the task so far, as defined by the run time stats clock.  See http://www.freertos.org/rtos-run-time-stats.html.  Only valid when configGENERATE_RUN_TIME_STATS is defined as 1 in FreeRTOSConfig.h. */
    task_stack_t *pxStackBase;      /* Points to the lowest address of the task's stack area. */
    uint16_t usStackHighWaterMark;  /* The minimum amount of stack space that has remained for the task since the task was created.  The closer this value is to zero the closer the task has come to overflowing its stack. */
} TaskStatus_t;
 
/* Possible return values for eTaskConfirmSleepModeStatus(). */
typedef enum
{
    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;

#define tskIDLE_PRIORITY            ( ( uint32_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()
 
/* Definitions returned by xTaskGetSchedulerState().  taskSCHEDULER_SUSPENDED is
0 to generate more optimal code when configASSERT() is defined as the constant
is used in assert() statements. */
#define taskSCHEDULER_SUSPENDED     ( ( int32_t ) 0 )
#define taskSCHEDULER_NOT_STARTED   ( ( int32_t ) 1 )
#define taskSCHEDULER_RUNNING       ( ( int32_t ) 2 )
 
 
/*-----------------------------------------------------------
 * TASK CREATION API
 *----------------------------------------------------------*/

#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
    task_t task_create(task_fn_t function, void* const parameters,
                       uint32_t prio, const uint16_t stack_depth,
                       const char* const name);
#endif

#if( configSUPPORT_STATIC_ALLOCATION == 1 )
    task_t task_create_static(  task_fn_t task_code, void* const param,
                                uint32_t priority, const size_t stack_size,
                                const char* const name,
                                task_stack_t * const stack_buffer,
                                static_task_s_t * const task_buffer ) ;
#endif /* configSUPPORT_STATIC_ALLOCATION */

void task_delete( task_t xTaskToDelete ) ;
 
/*-----------------------------------------------------------
 * TASK CONTROL API
 *----------------------------------------------------------*/

void task_delay( const uint32_t xTicksToDelay ) ;

void task_delay_until( uint32_t * const pxPreviousWakeTime, const uint32_t xTimeIncrement ) ;

int32_t task_abort_delay( task_t xTask ) ;

uint32_t task_get_priority( task_t xTask ) ;

uint32_t uxTaskPriorityGetFromISR( task_t xTask ) ;

task_state_e_t task_get_state( task_t xTask ) ;

void vTaskGetInfo( task_t xTask, TaskStatus_t *pxTaskStatus, int32_t xGetFreeStackSpace, task_state_e_t eState ) ;

void task_set_priority( task_t xTask, uint32_t uxNewPriority ) ;

void task_suspend( task_t xTaskToSuspend ) ;

void task_resume( task_t xTaskToResume ) ;

int32_t xTaskResumeFromISR( task_t xTaskToResume ) ;
 
/*-----------------------------------------------------------
 * SCHEDULER CONTROL
 *----------------------------------------------------------*/

void rtos_sched_start( void ) ;

void rtos_sched_stop( void ) ;

void rtos_suspend_all( void ) ;

int32_t rtos_resume_all( void ) ;
 
/*-----------------------------------------------------------
 * TASK UTILITIES
 *----------------------------------------------------------*/

uint32_t millis( void ) ;

uint32_t xTaskGetTickCountFromISR( void ) ;

uint32_t task_get_count( void ) ;

char *task_get_name( task_t xTaskToQuery ) ; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

task_t task_get_by_name( const char *pcNameToQuery ) ; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

uint32_t uxTaskGetStackHighWaterMark( task_t xTask ) ;
 
/* When using trace macros it is sometimes necessary to include task.h before
FreeRTOS.h.  When this is done TaskHookFunction_t will not yet have been defined,
so the following two prototypes will cause a compilation error.  This can be
fixed by simply guarding against the inclusion of these two prototypes unless
they are explicitly required by the configUSE_APPLICATION_TASK_TAG configuration
constant. */
#ifdef configUSE_APPLICATION_TASK_TAG
    #if configUSE_APPLICATION_TASK_TAG == 1
        void vTaskSetApplicationTaskTag( task_t xTask, TaskHookFunction_t pxHookFunction ) ;

        TaskHookFunction_t xTaskGetApplicationTaskTag( task_t xTask ) ;
    #endif /* configUSE_APPLICATION_TASK_TAG ==1 */
#endif /* ifdef configUSE_APPLICATION_TASK_TAG */
 
#if( configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 )
 
    /* Each task contains an array of pointers that is dimensioned by the
    configNUM_THREAD_LOCAL_STORAGE_POINTERS setting in FreeRTOSConfig.h.  The
    kernel does not use the pointers itself, so the application writer can use
    the pointers for any purpose they wish.  The following two functions are
    used to set and query a pointer respectively. */
    void vTaskSetThreadLocalStoragePointer( task_t xTaskToSet, int32_t xIndex, void *pvValue ) ;
    void *pvTaskGetThreadLocalStoragePointer( task_t xTaskToQuery, int32_t xIndex ) ;
 
#endif

int32_t xTaskCallApplicationTaskHook( task_t xTask, void *pvParameter ) ;

task_t xTaskGetIdleTaskHandle( void ) ;

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

void vTaskList( char * pcWriteBuffer ) ; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

void vTaskGetRunTimeStats( char *pcWriteBuffer ) ; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

int32_t task_notify_ext( task_t xTaskToNotify, uint32_t ulValue, notify_action_e_t eAction, uint32_t *pulPreviousNotificationValue ) ;
#define xTaskNotify( xTaskToNotify, ulValue, eAction ) task_notify_ext( ( xTaskToNotify ), ( ulValue ), ( eAction ), NULL )
#define xTaskNotifyAndQuery( xTaskToNotify, ulValue, eAction, pulPreviousNotifyValue ) task_notify_ext( ( xTaskToNotify ), ( ulValue ), ( eAction ), ( pulPreviousNotifyValue ) )

int32_t xTaskGenericNotifyFromISR( task_t xTaskToNotify, uint32_t ulValue, notify_action_e_t eAction, uint32_t *pulPreviousNotificationValue, int32_t *pxHigherPriorityTaskWoken ) ;
#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 ) )

int32_t task_notify_wait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, uint32_t xTicksToWait ) ;

int32_t task_notify(task_t xTaskToNotify);

void vTaskNotifyGiveFromISR( task_t xTaskToNotify, int32_t *pxHigherPriorityTaskWoken ) ;

uint32_t task_notify_take( bool xClearCountOnExit, uint32_t xTicksToWait ) ;

int32_t task_notify_clear( task_t xTask );
 
/*-----------------------------------------------------------
 * SCHEDULER INTERNALS AVAILABLE FOR PORTING PURPOSES
 *----------------------------------------------------------*/
 
/*
 * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE.  IT IS ONLY
 * INTENDED FOR USE WHEN IMPLEMENTING A PORT OF THE SCHEDULER AND IS
 * AN INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.
 *
 * Called from the real time kernel tick (either preemptive or cooperative),
 * this increments the tick count and checks if any tasks that are blocked
 * for a finite period required removing from a blocked list and placing on
 * a ready list.  If a non-zero value is returned then a context switch is
 * required because either:
 *   + A task was removed from a blocked list because its timeout had expired,
 *     or
 *   + Time slicing is in use and there is a task of equal priority to the
 *     currently running task.
 */
int32_t xTaskIncrementTick( void ) ;
 
/*
 * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE.  IT IS AN
 * INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.
 *
 * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED.
 *
 * Removes the calling task from the ready list and places it both
 * on the list of tasks waiting for a particular event, and the
 * list of delayed tasks.  The task will be removed from both lists
 * and replaced on the ready list should either the event occur (and
 * there be no higher priority tasks waiting on the same event) or
 * the delay period expires.
 *
 * The 'unordered' version replaces the event list item value with the
 * xItemValue value, and inserts the list item at the end of the list.
 *
 * The 'ordered' version uses the existing event list item value (which is the
 * owning tasks priority) to insert the list item into the event list is task
 * priority order.
 *
 * @param pxEventList The list containing tasks that are blocked waiting
 * for the event to occur.
 *
 * @param xItemValue The item value to use for the event list item when the
 * event list is not ordered by task priority.
 *
 * @param xTicksToWait The maximum amount of time that the task should wait
 * for the event to occur.  This is specified in kernel ticks,the constant
 * portTICK_PERIOD_MS can be used to convert kernel ticks into a real time
 * period.
 */
void vTaskPlaceOnEventList( List_t * const pxEventList, const uint32_t xTicksToWait ) ;
void vTaskPlaceOnUnorderedEventList( List_t * pxEventList, const uint32_t xItemValue, const uint32_t xTicksToWait ) ;
 
/*
 * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE.  IT IS AN
 * INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.
 *
 * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED.
 *
 * This function performs nearly the same function as vTaskPlaceOnEventList().
 * The difference being that this function does not permit tasks to block
 * indefinitely, whereas vTaskPlaceOnEventList() does.
 *
 */
void vTaskPlaceOnEventListRestricted( List_t * const pxEventList, uint32_t xTicksToWait, const int32_t xWaitIndefinitely ) ;
 
/*
 * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE.  IT IS AN
 * INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.
 *
 * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED.
 *
 * Removes a task from both the specified event list and the list of blocked
 * tasks, and places it on a ready queue.
 *
 * xTaskRemoveFromEventList()/vTaskRemoveFromUnorderedEventList() will be called
 * if either an event occurs to unblock a task, or the block timeout period
 * expires.
 *
 * xTaskRemoveFromEventList() is used when the event list is in task priority
 * order.  It removes the list item from the head of the event list as that will
 * have the highest priority owning task of all the tasks on the event list.
 * vTaskRemoveFromUnorderedEventList() is used when the event list is not
 * ordered and the event list items hold something other than the owning tasks
 * priority.  In this case the event list item value is updated to the value
 * passed in the xItemValue parameter.
 *
 * @return pdTRUE if the task being removed has a higher priority than the task
 * making the call, otherwise pdFALSE.
 */
int32_t xTaskRemoveFromEventList( const List_t * const pxEventList ) ;
void vTaskRemoveFromUnorderedEventList( list_item_t * pxEventListItem, const uint32_t xItemValue ) ;
 
/*
 * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE.  IT IS ONLY
 * INTENDED FOR USE WHEN IMPLEMENTING A PORT OF THE SCHEDULER AND IS
 * AN INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.
 *
 * Sets the pointer to the current TCB to the TCB of the highest priority task
 * that is ready to run.
 */
void vTaskSwitchContext( void ) ;
 
/*
 * THESE FUNCTIONS MUST NOT BE USED FROM APPLICATION CODE.  THEY ARE USED BY
 * THE EVENT BITS MODULE.
 */
uint32_t uxTaskResetEventItemValue( void ) ;
 
/*
 * Return the handle of the calling task.
 */
task_t task_get_current( void ) ;
 
/*
 * Capture the current time status for future reference.
 */
void vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) ;
 
/*
 * Compare the time status now with that previously captured to see if the
 * timeout has expired.
 */
int32_t xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut, uint32_t * const pxTicksToWait ) ;
 
/*
 * Shortcut used by the queue implementation to prevent unnecessary call to
 * taskYIELD();
 */
void vTaskMissedYield( void ) ;
 
/*
 * Returns the scheduler state as taskSCHEDULER_RUNNING,
 * taskSCHEDULER_NOT_STARTED or taskSCHEDULER_SUSPENDED.
 */
int32_t xTaskGetSchedulerState( void ) ;
 
/*
 * Raises the priority of the mutex holder to that of the calling task should
 * the mutex holder have a priority less than the calling task.
 */
int32_t xTaskPriorityInherit( task_t const pxMutexHolder ) ;
 
/*
 * Set the priority of a task back to its proper priority in the case that it
 * inherited a higher priority while it was holding a semaphore.
 */
int32_t xTaskPriorityDisinherit( task_t const pxMutexHolder ) ;
 
/*
 * If a higher priority task attempting to obtain a mutex caused a lower
 * priority task to inherit the higher priority task's priority - but the higher
 * priority task then timed out without obtaining the mutex, then the lower
 * priority task will disinherit the priority again - but only down as far as
 * the highest priority task that is still waiting for the mutex (if there were
 * more than one task waiting for the mutex).
 */
void vTaskPriorityDisinheritAfterTimeout( task_t const pxMutexHolder, uint32_t uxHighestPriorityWaitingTask ) ;
 
/*
 * Get the uxTCBNumber assigned to the task referenced by the xTask parameter.
 */
uint32_t uxTaskGetTaskNumber( task_t xTask ) ;
 
/*
 * Set the uxTaskNumber of the task referenced by the xTask parameter to
 * uxHandle.
 */
void vTaskSetTaskNumber( task_t xTask, const uint32_t uxHandle ) ;
 
/*
 * Only available when configUSE_TICKLESS_IDLE is set to 1.
 * If tickless mode is being used, or a low power mode is implemented, then
 * the tick interrupt will not execute during idle periods.  When this is the
 * case, the tick count value maintained by the scheduler needs to be kept up
 * to date with the actual execution time by being skipped forward by a time
 * equal to the idle period.
 */
void vTaskStepTick( const uint32_t xTicksToJump ) ;
 
/*
 * Only avilable when configUSE_TICKLESS_IDLE is set to 1.
 * Provided for use within portSUPPRESS_TICKS_AND_SLEEP() to allow the port
 * specific sleep function to determine if it is ok to proceed with the sleep,
 * and if it is ok to proceed, if it is ok to sleep indefinitely.
 *
 * This function is necessary because portSUPPRESS_TICKS_AND_SLEEP() is only
 * called with the scheduler suspended, not from within a critical section.  It
 * is therefore possible for an interrupt to request a context switch between
 * portSUPPRESS_TICKS_AND_SLEEP() and the low power mode actually being
 * entered.  eTaskConfirmSleepModeStatus() should be called from a short
 * critical section between the timer being stopped and the sleep mode being
 * entered to ensure it is ok to proceed into the sleep mode.
 */
eSleepModeStatus eTaskConfirmSleepModeStatus( void ) ;
 
/*
 * For internal use only.  Increment the mutex held count when a mutex is
 * taken and return the handle of the task that has taken the mutex.
 */
void *pvTaskIncrementMutexHeldCount( void ) ;
 
/*
 * For internal use only.  Same as vTaskSetTimeOutState(), but without a critial
 * section.
 */
void vTaskInternalSetTimeOutState( TimeOut_t * const pxTimeOut ) ;
 
 
#ifdef __cplusplus
}
#endif
#endif /* INC_TASK_H */