SAM4S-EK_FreeRTOS+FAT-SL  1.0
An example project to test the functionality of FreeRTOS+FAT-SL using SD card as data storage medium
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Macros Modules
task.h
Go to the documentation of this file.
1 /*
2  FreeRTOS V8.0.1 - Copyright (C) 2014 Real Time Engineers Ltd.
3  All rights reserved
4 
5  VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
6 
7  ***************************************************************************
8  * *
9  * FreeRTOS provides completely free yet professionally developed, *
10  * robust, strictly quality controlled, supported, and cross *
11  * platform software that has become a de facto standard. *
12  * *
13  * Help yourself get started quickly and support the FreeRTOS *
14  * project by purchasing a FreeRTOS tutorial book, reference *
15  * manual, or both from: http://www.FreeRTOS.org/Documentation *
16  * *
17  * Thank you! *
18  * *
19  ***************************************************************************
20 
21  This file is part of the FreeRTOS distribution.
22 
23  FreeRTOS is free software; you can redistribute it and/or modify it under
24  the terms of the GNU General Public License (version 2) as published by the
25  Free Software Foundation >>!AND MODIFIED BY!<< the FreeRTOS exception.
26 
27  >>! NOTE: The modification to the GPL is included to allow you to !<<
28  >>! distribute a combined work that includes FreeRTOS without being !<<
29  >>! obliged to provide the source code for proprietary components !<<
30  >>! outside of the FreeRTOS kernel. !<<
31 
32  FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY
33  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
34  FOR A PARTICULAR PURPOSE. Full license text is available from the following
35  link: http://www.freertos.org/a00114.html
36 
37  1 tab == 4 spaces!
38 
39  ***************************************************************************
40  * *
41  * Having a problem? Start by reading the FAQ "My application does *
42  * not run, what could be wrong?" *
43  * *
44  * http://www.FreeRTOS.org/FAQHelp.html *
45  * *
46  ***************************************************************************
47 
48  http://www.FreeRTOS.org - Documentation, books, training, latest versions,
49  license and Real Time Engineers Ltd. contact details.
50 
51  http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
52  including FreeRTOS+Trace - an indispensable productivity tool, a DOS
53  compatible FAT file system, and our tiny thread aware UDP/IP stack.
54 
55  http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High
56  Integrity Systems to sell under the OpenRTOS brand. Low cost OpenRTOS
57  licenses offer ticketed support, indemnification and middleware.
58 
59  http://www.SafeRTOS.com - High Integrity Systems also provide a safety
60  engineered and independently SIL3 certified version for use in safety and
61  mission critical applications that require provable dependability.
62 
63  1 tab == 4 spaces!
64 */
65 
66 
67 #ifndef INC_TASK_H
68 #define INC_TASK_H
69 
70 #ifndef INC_FREERTOS_H
71  #error "include FreeRTOS.h must appear in source files before include task.h"
72 #endif
73 
74 #include "list.h"
75 
76 #ifdef __cplusplus
77 extern "C" {
78 #endif
79 
80 /*-----------------------------------------------------------
81  * MACROS AND DEFINITIONS
82  *----------------------------------------------------------*/
83 
84 #define tskKERNEL_VERSION_NUMBER "V8.0.1"
85 #define tskKERNEL_VERSION_MAJOR 8
86 #define tskKERNEL_VERSION_MINOR 0
87 #define tskKERNEL_VERSION_BUILD 1
88 
99 typedef void * TaskHandle_t;
100 
101 /*
102  * Defines the prototype to which the application task hook function must
103  * conform.
104  */
105 typedef BaseType_t (*TaskHookFunction_t)( void * );
106 
107 /* Task states returned by eTaskGetState. */
108 typedef enum
109 {
110  eRunning = 0, /* A task is querying the state of itself, so must be running. */
111  eReady, /* The task being queried is in a read or pending ready list. */
112  eBlocked, /* The task being queried is in the Blocked state. */
113  eSuspended, /* The task being queried is in the Suspended state, or is in the Blocked state with an infinite time out. */
114  eDeleted /* The task being queried has been deleted, but its TCB has not yet been freed. */
115 } eTaskState;
116 
117 /*
118  * Used internally only.
119  */
120 typedef struct xTIME_OUT
121 {
124 } TimeOut_t;
125 
126 /*
127  * Defines the memory ranges allocated to the task when an MPU is used.
128  */
129 typedef struct xMEMORY_REGION
130 {
132  uint32_t ulLengthInBytes;
133  uint32_t ulParameters;
135 
136 /*
137  * Parameters required to create an MPU protected task.
138  */
139 typedef struct xTASK_PARAMETERS
140 {
142  const char * const pcName; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
143  uint16_t usStackDepth;
149 
150 /* Used with the uxTaskGetSystemState() function to return the state of each task
151 in the system. */
152 typedef struct xTASK_STATUS
153 {
154  TaskHandle_t xHandle; /* The handle of the task to which the rest of the information in the structure relates. */
155  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. */
156  UBaseType_t xTaskNumber; /* A number unique to the task. */
157  eTaskState eCurrentState; /* The state in which the task existed when the structure was populated. */
158  UBaseType_t uxCurrentPriority; /* The priority at which the task was running (may be inherited) when the structure was populated. */
159  UBaseType_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. */
160  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. */
161  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. */
162 } TaskStatus_t;
163 
164 /* Possible return values for eTaskConfirmSleepModeStatus(). */
165 typedef enum
166 {
167  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. */
168  eStandardSleep, /* Enter a sleep mode that will not last any longer than the expected idle time. */
169  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. */
171 
172 
178 #define tskIDLE_PRIORITY ( ( UBaseType_t ) 0U )
179 
188 #define taskYIELD() portYIELD()
189 
202 #define taskENTER_CRITICAL() portENTER_CRITICAL()
203 
216 #define taskEXIT_CRITICAL() portEXIT_CRITICAL()
217 
226 #define taskDISABLE_INTERRUPTS() portDISABLE_INTERRUPTS()
227 
236 #define taskENABLE_INTERRUPTS() portENABLE_INTERRUPTS()
237 
238 /* Definitions returned by xTaskGetSchedulerState(). taskSCHEDULER_SUSPENDED is
239 0 to generate more optimal code when configASSERT() is defined as the constant
240 is used in assert() statements. */
241 #define taskSCHEDULER_SUSPENDED ( ( BaseType_t ) 0 )
242 #define taskSCHEDULER_NOT_STARTED ( ( BaseType_t ) 1 )
243 #define taskSCHEDULER_RUNNING ( ( BaseType_t ) 2 )
244 
245 
246 /*-----------------------------------------------------------
247  * TASK CREATION API
248  *----------------------------------------------------------*/
249 
330 #define xTaskCreate( pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask ) xTaskGenericCreate( ( pvTaskCode ), ( pcName ), ( usStackDepth ), ( pvParameters ), ( uxPriority ), ( pxCreatedTask ), ( NULL ), ( NULL ) )
331 
399 #define xTaskCreateRestricted( x, pxCreatedTask ) xTaskGenericCreate( ((x)->pvTaskCode), ((x)->pcName), ((x)->usStackDepth), ((x)->pvParameters), ((x)->uxPriority), (pxCreatedTask), ((x)->puxStackBuffer), ((x)->xRegions) )
400 
447 void vTaskAllocateMPURegions( TaskHandle_t xTask, const MemoryRegion_t * const pxRegions ) PRIVILEGED_FUNCTION;
448 
488 void vTaskDelete( TaskHandle_t xTaskToDelete ) PRIVILEGED_FUNCTION;
489 
490 /*-----------------------------------------------------------
491  * TASK CONTROL API
492  *----------------------------------------------------------*/
493 
540 void vTaskDelay( const TickType_t xTicksToDelay ) PRIVILEGED_FUNCTION;
541 
599 void vTaskDelayUntil( TickType_t * const pxPreviousWakeTime, const TickType_t xTimeIncrement ) PRIVILEGED_FUNCTION;
600 
647 
664 eTaskState eTaskGetState( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
665 
706 void vTaskPrioritySet( TaskHandle_t xTask, UBaseType_t uxNewPriority ) PRIVILEGED_FUNCTION;
707 
757 void vTaskSuspend( TaskHandle_t xTaskToSuspend ) PRIVILEGED_FUNCTION;
758 
806 void vTaskResume( TaskHandle_t xTaskToResume ) PRIVILEGED_FUNCTION;
807 
835 BaseType_t xTaskResumeFromISR( TaskHandle_t xTaskToResume ) PRIVILEGED_FUNCTION;
836 
837 /*-----------------------------------------------------------
838  * SCHEDULER CONTROL
839  *----------------------------------------------------------*/
840 
868 void vTaskStartScheduler( void ) PRIVILEGED_FUNCTION;
869 
924 void vTaskEndScheduler( void ) PRIVILEGED_FUNCTION;
925 
975 void vTaskSuspendAll( void ) PRIVILEGED_FUNCTION;
976 
1029 BaseType_t xTaskResumeAll( void ) PRIVILEGED_FUNCTION;
1030 
1031 /*-----------------------------------------------------------
1032  * TASK UTILITIES
1033  *----------------------------------------------------------*/
1034 
1044 TickType_t xTaskGetTickCount( void ) PRIVILEGED_FUNCTION;
1045 
1060 TickType_t xTaskGetTickCountFromISR( void ) PRIVILEGED_FUNCTION;
1061 
1074 UBaseType_t uxTaskGetNumberOfTasks( void ) PRIVILEGED_FUNCTION;
1075 
1088 char *pcTaskGetTaskName( TaskHandle_t xTaskToQuery ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
1089 
1109 UBaseType_t uxTaskGetStackHighWaterMark( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
1110 
1111 /* When using trace macros it is sometimes necessary to include task.h before
1112 FreeRTOS.h. When this is done TaskHookFunction_t will not yet have been defined,
1113 so the following two prototypes will cause a compilation error. This can be
1114 fixed by simply guarding against the inclusion of these two prototypes unless
1115 they are explicitly required by the configUSE_APPLICATION_TASK_TAG configuration
1116 constant. */
1117 #ifdef configUSE_APPLICATION_TASK_TAG
1118  #if configUSE_APPLICATION_TASK_TAG == 1
1119 
1127  void vTaskSetApplicationTaskTag( TaskHandle_t xTask, TaskHookFunction_t pxHookFunction ) PRIVILEGED_FUNCTION;
1128 
1135  TaskHookFunction_t xTaskGetApplicationTaskTag( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
1136  #endif /* configUSE_APPLICATION_TASK_TAG ==1 */
1137 #endif /* ifdef configUSE_APPLICATION_TASK_TAG */
1138 
1150 BaseType_t xTaskCallApplicationTaskHook( TaskHandle_t xTask, void *pvParameter ) PRIVILEGED_FUNCTION;
1151 
1159 TaskHandle_t xTaskGetIdleTaskHandle( void );
1160 
1258 UBaseType_t uxTaskGetSystemState( TaskStatus_t * const pxTaskStatusArray, const UBaseType_t uxArraySize, uint32_t * const pulTotalRunTime );
1259 
1305 void vTaskList( char * pcWriteBuffer ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
1306 
1359 void vTaskGetRunTimeStats( char *pcWriteBuffer ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
1360 
1361 /*-----------------------------------------------------------
1362  * SCHEDULER INTERNALS AVAILABLE FOR PORTING PURPOSES
1363  *----------------------------------------------------------*/
1364 
1365 /*
1366  * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE. IT IS ONLY
1367  * INTENDED FOR USE WHEN IMPLEMENTING A PORT OF THE SCHEDULER AND IS
1368  * AN INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.
1369  *
1370  * Called from the real time kernel tick (either preemptive or cooperative),
1371  * this increments the tick count and checks if any tasks that are blocked
1372  * for a finite period required removing from a blocked list and placing on
1373  * a ready list. If a non-zero value is returned then a context switch is
1374  * required because either:
1375  * + A task was removed from a blocked list because its timeout had expired,
1376  * or
1377  * + Time slicing is in use and there is a task of equal priority to the
1378  * currently running task.
1379  */
1380 BaseType_t xTaskIncrementTick( void ) PRIVILEGED_FUNCTION;
1381 
1382 /*
1383  * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE. IT IS AN
1384  * INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.
1385  *
1386  * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED.
1387  *
1388  * Removes the calling task from the ready list and places it both
1389  * on the list of tasks waiting for a particular event, and the
1390  * list of delayed tasks. The task will be removed from both lists
1391  * and replaced on the ready list should either the event occur (and
1392  * there be no higher priority tasks waiting on the same event) or
1393  * the delay period expires.
1394  *
1395  * The 'unordered' version replaces the event list item value with the
1396  * xItemValue value, and inserts the list item at the end of the list.
1397  *
1398  * The 'ordered' version uses the existing event list item value (which is the
1399  * owning tasks priority) to insert the list item into the event list is task
1400  * priority order.
1401  *
1402  * @param pxEventList The list containing tasks that are blocked waiting
1403  * for the event to occur.
1404  *
1405  * @param xItemValue The item value to use for the event list item when the
1406  * event list is not ordered by task priority.
1407  *
1408  * @param xTicksToWait The maximum amount of time that the task should wait
1409  * for the event to occur. This is specified in kernel ticks,the constant
1410  * portTICK_PERIOD_MS can be used to convert kernel ticks into a real time
1411  * period.
1412  */
1413 void vTaskPlaceOnEventList( List_t * const pxEventList, const TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
1414 void vTaskPlaceOnUnorderedEventList( List_t * pxEventList, const TickType_t xItemValue, const TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
1415 
1416 /*
1417  * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE. IT IS AN
1418  * INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.
1419  *
1420  * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED.
1421  *
1422  * This function performs nearly the same function as vTaskPlaceOnEventList().
1423  * The difference being that this function does not permit tasks to block
1424  * indefinitely, whereas vTaskPlaceOnEventList() does.
1425  *
1426  */
1427 void vTaskPlaceOnEventListRestricted( List_t * const pxEventList, const TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
1428 
1429 /*
1430  * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE. IT IS AN
1431  * INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.
1432  *
1433  * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED.
1434  *
1435  * Removes a task from both the specified event list and the list of blocked
1436  * tasks, and places it on a ready queue.
1437  *
1438  * xTaskRemoveFromEventList()/xTaskRemoveFromUnorderedEventList() will be called
1439  * if either an event occurs to unblock a task, or the block timeout period
1440  * expires.
1441  *
1442  * xTaskRemoveFromEventList() is used when the event list is in task priority
1443  * order. It removes the list item from the head of the event list as that will
1444  * have the highest priority owning task of all the tasks on the event list.
1445  * xTaskRemoveFromUnorderedEventList() is used when the event list is not
1446  * ordered and the event list items hold something other than the owning tasks
1447  * priority. In this case the event list item value is updated to the value
1448  * passed in the xItemValue parameter.
1449  *
1450  * @return pdTRUE if the task being removed has a higher priority than the task
1451  * making the call, otherwise pdFALSE.
1452  */
1453 BaseType_t xTaskRemoveFromEventList( const List_t * const pxEventList ) PRIVILEGED_FUNCTION;
1454 BaseType_t xTaskRemoveFromUnorderedEventList( ListItem_t * pxEventListItem, const TickType_t xItemValue ) PRIVILEGED_FUNCTION;
1455 
1456 /*
1457  * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE. IT IS ONLY
1458  * INTENDED FOR USE WHEN IMPLEMENTING A PORT OF THE SCHEDULER AND IS
1459  * AN INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.
1460  *
1461  * Sets the pointer to the current TCB to the TCB of the highest priority task
1462  * that is ready to run.
1463  */
1464 void vTaskSwitchContext( void ) PRIVILEGED_FUNCTION;
1465 
1466 /*
1467  * THESE FUNCTIONS MUST NOT BE USED FROM APPLICATION CODE. THEY ARE USED BY
1468  * THE EVENT BITS MODULE.
1469  */
1470 TickType_t uxTaskResetEventItemValue( void ) PRIVILEGED_FUNCTION;
1471 
1472 /*
1473  * Return the handle of the calling task.
1474  */
1475 TaskHandle_t xTaskGetCurrentTaskHandle( void ) PRIVILEGED_FUNCTION;
1476 
1477 /*
1478  * Capture the current time status for future reference.
1479  */
1480 void vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) PRIVILEGED_FUNCTION;
1481 
1482 /*
1483  * Compare the time status now with that previously captured to see if the
1484  * timeout has expired.
1485  */
1486 BaseType_t xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut, TickType_t * const pxTicksToWait ) PRIVILEGED_FUNCTION;
1487 
1488 /*
1489  * Shortcut used by the queue implementation to prevent unnecessary call to
1490  * taskYIELD();
1491  */
1492 void vTaskMissedYield( void ) PRIVILEGED_FUNCTION;
1493 
1494 /*
1495  * Returns the scheduler state as taskSCHEDULER_RUNNING,
1496  * taskSCHEDULER_NOT_STARTED or taskSCHEDULER_SUSPENDED.
1497  */
1498 BaseType_t xTaskGetSchedulerState( void ) PRIVILEGED_FUNCTION;
1499 
1500 /*
1501  * Raises the priority of the mutex holder to that of the calling task should
1502  * the mutex holder have a priority less than the calling task.
1503  */
1504 void vTaskPriorityInherit( TaskHandle_t const pxMutexHolder ) PRIVILEGED_FUNCTION;
1505 
1506 /*
1507  * Set the priority of a task back to its proper priority in the case that it
1508  * inherited a higher priority while it was holding a semaphore.
1509  */
1510 void vTaskPriorityDisinherit( TaskHandle_t const pxMutexHolder ) PRIVILEGED_FUNCTION;
1511 
1512 /*
1513  * Generic version of the task creation function which is in turn called by the
1514  * xTaskCreate() and xTaskCreateRestricted() macros.
1515  */
1516 BaseType_t xTaskGenericCreate( TaskFunction_t pxTaskCode, const char * const pcName, const uint16_t usStackDepth, void * const pvParameters, UBaseType_t uxPriority, TaskHandle_t * const pxCreatedTask, StackType_t * const puxStackBuffer, const MemoryRegion_t * const xRegions ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
1517 
1518 /*
1519  * Get the uxTCBNumber assigned to the task referenced by the xTask parameter.
1520  */
1521 UBaseType_t uxTaskGetTaskNumber( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
1522 
1523 /*
1524  * Set the uxTaskNumber of the task referenced by the xTask parameter to
1525  * uxHandle.
1526  */
1527 void vTaskSetTaskNumber( TaskHandle_t xTask, const UBaseType_t uxHandle ) PRIVILEGED_FUNCTION;
1528 
1529 /*
1530  * Only available when configUSE_TICKLESS_IDLE is set to 1.
1531  * If tickless mode is being used, or a low power mode is implemented, then
1532  * the tick interrupt will not execute during idle periods. When this is the
1533  * case, the tick count value maintained by the scheduler needs to be kept up
1534  * to date with the actual execution time by being skipped forward by a time
1535  * equal to the idle period.
1536  */
1537 void vTaskStepTick( const TickType_t xTicksToJump ) PRIVILEGED_FUNCTION;
1538 
1539 /*
1540  * Only avilable when configUSE_TICKLESS_IDLE is set to 1.
1541  * Provided for use within portSUPPRESS_TICKS_AND_SLEEP() to allow the port
1542  * specific sleep function to determine if it is ok to proceed with the sleep,
1543  * and if it is ok to proceed, if it is ok to sleep indefinitely.
1544  *
1545  * This function is necessary because portSUPPRESS_TICKS_AND_SLEEP() is only
1546  * called with the scheduler suspended, not from within a critical section. It
1547  * is therefore possible for an interrupt to request a context switch between
1548  * portSUPPRESS_TICKS_AND_SLEEP() and the low power mode actually being
1549  * entered. eTaskConfirmSleepModeStatus() should be called from a short
1550  * critical section between the timer being stopped and the sleep mode being
1551  * entered to ensure it is ok to proceed into the sleep mode.
1552  */
1553 eSleepModeStatus eTaskConfirmSleepModeStatus( void ) PRIVILEGED_FUNCTION;
1554 
1555 #ifdef __cplusplus
1556 }
1557 #endif
1558 #endif /* INC_TASK_H */
1559 
1560 
1561 
#define pxMutexHolder
Definition: queue.c:104
BaseType_t(* TaskHookFunction_t)(void *)
Definition: task.h:105
void vTaskSwitchContext(void) PRIVILEGED_FUNCTION
Definition: tasks.c:2113
UBaseType_t uxBasePriority
Definition: task.h:159
void vTaskSetTaskNumber(TaskHandle_t xTask, const UBaseType_t uxHandle) PRIVILEGED_FUNCTION
void vTaskGetRunTimeStats(char *pcWriteBuffer) PRIVILEGED_FUNCTION
TaskHandle_t xTaskGetCurrentTaskHandle(void) PRIVILEGED_FUNCTION
void vTaskPrioritySet(TaskHandle_t xTask, UBaseType_t uxNewPriority) PRIVILEGED_FUNCTION
uint32_t ulRunTimeCounter
Definition: task.h:160
void vTaskSuspendAll(void) PRIVILEGED_FUNCTION
Definition: tasks.c:1543
MemoryRegion_t xRegions[portNUM_CONFIGURABLE_REGIONS]
Definition: task.h:147
Definition: task.h:110
void vTaskPlaceOnEventListRestricted(List_t *const pxEventList, const TickType_t xTicksToWait) PRIVILEGED_FUNCTION
Definition: task.h:114
struct xTIME_OUT TimeOut_t
BaseType_t xTaskResumeFromISR(TaskHandle_t xTaskToResume) PRIVILEGED_FUNCTION
BaseType_t xTaskCallApplicationTaskHook(TaskHandle_t xTask, void *pvParameter) PRIVILEGED_FUNCTION
UBaseType_t xTaskNumber
Definition: task.h:156
void vTaskList(char *pcWriteBuffer) PRIVILEGED_FUNCTION
Definition: task.h:111
TickType_t xTimeOnEntering
Definition: task.h:123
void vTaskPlaceOnUnorderedEventList(List_t *pxEventList, const TickType_t xItemValue, const TickType_t xTicksToWait) PRIVILEGED_FUNCTION
Definition: tasks.c:2230
uint32_t ulParameters
Definition: task.h:133
void * pvBaseAddress
Definition: task.h:131
unsigned long UBaseType_t
Definition: portmacro.h:95
uint32_t TickType_t
Definition: portmacro.h:101
void vTaskStepTick(const TickType_t xTicksToJump) PRIVILEGED_FUNCTION
UBaseType_t uxPriority
Definition: task.h:145
void * pvParameters
Definition: task.h:144
eTaskState
Definition: task.h:108
void vTaskStartScheduler(void) PRIVILEGED_FUNCTION
Definition: tasks.c:1454
struct xMEMORY_REGION MemoryRegion_t
BaseType_t xTaskRemoveFromUnorderedEventList(ListItem_t *pxEventListItem, const TickType_t xItemValue) PRIVILEGED_FUNCTION
Definition: tasks.c:2395
TaskFunction_t pvTaskCode
Definition: task.h:141
UBaseType_t uxTaskPriorityGet(TaskHandle_t xTask) PRIVILEGED_FUNCTION
TickType_t xTaskGetTickCountFromISR(void) PRIVILEGED_FUNCTION
Definition: tasks.c:1689
void vTaskEndScheduler(void) PRIVILEGED_FUNCTION
Definition: tasks.c:1532
void vTaskPriorityDisinherit(TaskHandle_t const pxMutexHolder) PRIVILEGED_FUNCTION
TickType_t xTaskGetTickCount(void) PRIVILEGED_FUNCTION
Definition: tasks.c:1674
char * pcTaskGetTaskName(TaskHandle_t xTaskToQuery) PRIVILEGED_FUNCTION
void vTaskDelete(TaskHandle_t xTaskToDelete) PRIVILEGED_FUNCTION
const char * pcTaskName
Definition: task.h:155
UBaseType_t uxTaskGetTaskNumber(TaskHandle_t xTask) PRIVILEGED_FUNCTION
void vTaskMissedYield(void) PRIVILEGED_FUNCTION
Definition: tasks.c:2497
UBaseType_t uxTaskGetStackHighWaterMark(TaskHandle_t xTask) PRIVILEGED_FUNCTION
void vTaskDelayUntil(TickType_t *const pxPreviousWakeTime, const TickType_t xTimeIncrement) PRIVILEGED_FUNCTION
long BaseType_t
Definition: portmacro.h:94
void vTaskSuspend(TaskHandle_t xTaskToSuspend) PRIVILEGED_FUNCTION
#define portNUM_CONFIGURABLE_REGIONS
Definition: portable.h:345
uint16_t usStackDepth
Definition: task.h:143
UBaseType_t uxTaskGetSystemState(TaskStatus_t *const pxTaskStatusArray, const UBaseType_t uxArraySize, uint32_t *const pulTotalRunTime)
void * TaskHandle_t
Definition: task.h:99
void vTaskPriorityInherit(TaskHandle_t const pxMutexHolder) PRIVILEGED_FUNCTION
UBaseType_t uxTaskGetNumberOfTasks(void) PRIVILEGED_FUNCTION
Definition: tasks.c:1720
TickType_t uxTaskResetEventItemValue(void) PRIVILEGED_FUNCTION
Definition: tasks.c:3546
struct xTASK_STATUS TaskStatus_t
eSleepModeStatus
Definition: task.h:165
void vTaskResume(TaskHandle_t xTaskToResume) PRIVILEGED_FUNCTION
void vTaskAllocateMPURegions(TaskHandle_t xTask, const MemoryRegion_t *const pxRegions) PRIVILEGED_FUNCTION
eTaskState eCurrentState
Definition: task.h:157
BaseType_t xTaskIncrementTick(void) PRIVILEGED_FUNCTION
Definition: tasks.c:1849
BaseType_t xTaskResumeAll(void) PRIVILEGED_FUNCTION
Definition: tasks.c:1581
void(* TaskFunction_t)(void *)
Definition: projdefs.h:73
BaseType_t xTaskGetSchedulerState(void) PRIVILEGED_FUNCTION
struct xTASK_PARAMETERS TaskParameters_t
void vTaskSetTimeOutState(TimeOut_t *const pxTimeOut) PRIVILEGED_FUNCTION
Definition: tasks.c:2440
eSleepModeStatus eTaskConfirmSleepModeStatus(void) PRIVILEGED_FUNCTION
const char *const pcName
Definition: task.h:142
BaseType_t xTaskGenericCreate(TaskFunction_t pxTaskCode, const char *const pcName, const uint16_t usStackDepth, void *const pvParameters, UBaseType_t uxPriority, TaskHandle_t *const pxCreatedTask, StackType_t *const puxStackBuffer, const MemoryRegion_t *const xRegions) PRIVILEGED_FUNCTION
#define PRIVILEGED_FUNCTION
Definition: mpu_wrappers.h:145
void vTaskDelay(const TickType_t xTicksToDelay) PRIVILEGED_FUNCTION
BaseType_t xOverflowCount
Definition: task.h:122
Definition: task.h:112
BaseType_t xTaskCheckForTimeOut(TimeOut_t *const pxTimeOut, TickType_t *const pxTicksToWait) PRIVILEGED_FUNCTION
Definition: tasks.c:2448
TaskHandle_t xTaskGetIdleTaskHandle(void)
Definition: list.h:157
StackType_t * puxStackBuffer
Definition: task.h:146
uint16_t usStackHighWaterMark
Definition: task.h:161
BaseType_t xTaskRemoveFromEventList(const List_t *const pxEventList) PRIVILEGED_FUNCTION
Definition: tasks.c:2341
void vTaskPlaceOnEventList(List_t *const pxEventList, const TickType_t xTicksToWait) PRIVILEGED_FUNCTION
Definition: tasks.c:2171
uint32_t ulLengthInBytes
Definition: task.h:132
TaskHandle_t xHandle
Definition: task.h:154
eTaskState eTaskGetState(TaskHandle_t xTask) PRIVILEGED_FUNCTION
portSTACK_TYPE StackType_t
Definition: portmacro.h:93
UBaseType_t uxCurrentPriority
Definition: task.h:158