* task. h\r
*\r
* Type by which tasks are referenced. For example, a call to xTaskCreate\r
- * returns (via a pointer parameter) an xTaskHandle variable that can then\r
+ * returns (via a pointer parameter) an TaskHandle_t variable that can then\r
* be used as a parameter to vTaskDelete to delete the task.\r
*\r
- * \defgroup xTaskHandle xTaskHandle\r
+ * \defgroup TaskHandle_t TaskHandle_t\r
* \ingroup Tasks\r
*/\r
-typedef void * xTaskHandle;\r
+typedef void * TaskHandle_t;\r
+\r
+/* \r
+ * Defines the prototype to which the application task hook function must\r
+ * conform. \r
+ */\r
+typedef BaseType_t (*TaskHookFunction_t)( void * );\r
\r
/* Task states returned by eTaskGetState. */\r
typedef enum\r
*/\r
typedef struct xTIME_OUT\r
{\r
- portBASE_TYPE xOverflowCount;\r
- portTickType xTimeOnEntering;\r
-} xTimeOutType;\r
+ BaseType_t xOverflowCount;\r
+ TickType_t xTimeOnEntering;\r
+} TimeOut_t;\r
\r
/*\r
* Defines the memory ranges allocated to the task when an MPU is used.\r
typedef struct xMEMORY_REGION\r
{\r
void *pvBaseAddress;\r
- unsigned long ulLengthInBytes;\r
- unsigned long ulParameters;\r
-} xMemoryRegion;\r
+ uint32_t ulLengthInBytes;\r
+ uint32_t ulParameters;\r
+} MemoryRegion_t;\r
\r
/*\r
* Parameters required to create an MPU protected task.\r
*/\r
typedef struct xTASK_PARAMETERS\r
{\r
- pdTASK_CODE pvTaskCode;\r
- const signed char * const pcName;\r
- unsigned short usStackDepth;\r
+ TaskFunction_t pvTaskCode;\r
+ const char * const pcName; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
+ uint16_t usStackDepth;\r
void *pvParameters;\r
- unsigned portBASE_TYPE uxPriority;\r
- portSTACK_TYPE *puxStackBuffer;\r
- xMemoryRegion xRegions[ portNUM_CONFIGURABLE_REGIONS ];\r
-} xTaskParameters;\r
+ UBaseType_t uxPriority;\r
+ StackType_t *puxStackBuffer;\r
+ MemoryRegion_t xRegions[ portNUM_CONFIGURABLE_REGIONS ];\r
+} TaskParameters_t;\r
\r
/* Used with the uxTaskGetSystemState() function to return the state of each task\r
in the system. */\r
typedef struct xTASK_STATUS\r
{\r
- xTaskHandle xHandle; /* The handle of the task to which the rest of the information in the structure relates. */\r
- const signed char *pcTaskName; /* A pointer to the task's name. This value will be invalid if the task was deleted since the structure was populated! */\r
- unsigned portBASE_TYPE xTaskNumber; /* A number unique to the task. */\r
- eTaskState eCurrentState; /* The state in which the task existed when the structure was populated. */\r
- unsigned portBASE_TYPE uxCurrentPriority; /* The priority at which the task was running (may be inherited) when the structure was populated. */\r
- unsigned portBASE_TYPE 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. */\r
- unsigned long 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. */\r
- unsigned short 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. */\r
-} xTaskStatusType;\r
+ TaskHandle_t xHandle; /* The handle of the task to which the rest of the information in the structure relates. */\r
+ 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. */\r
+ UBaseType_t xTaskNumber; /* A number unique to the task. */\r
+ eTaskState eCurrentState; /* The state in which the task existed when the structure was populated. */\r
+ UBaseType_t uxCurrentPriority; /* The priority at which the task was running (may be inherited) when the structure was populated. */\r
+ 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. */\r
+ 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. */\r
+ 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. */\r
+} TaskStatus_t;\r
\r
/* Possible return values for eTaskConfirmSleepModeStatus(). */\r
typedef enum\r
*\r
* \ingroup TaskUtils\r
*/\r
-#define tskIDLE_PRIORITY ( ( unsigned portBASE_TYPE ) 0U )\r
+#define tskIDLE_PRIORITY ( ( UBaseType_t ) 0U )\r
\r
/**\r
* task. h\r
/* Definitions returned by xTaskGetSchedulerState(). taskSCHEDULER_SUSPENDED is\r
0 to generate more optimal code when configASSERT() is defined as the constant\r
is used in assert() statements. */\r
-#define taskSCHEDULER_SUSPENDED ( ( portBASE_TYPE ) 0 )\r
-#define taskSCHEDULER_NOT_STARTED ( ( portBASE_TYPE ) 1 )\r
-#define taskSCHEDULER_RUNNING ( ( portBASE_TYPE ) 2 )\r
+#define taskSCHEDULER_SUSPENDED ( ( BaseType_t ) 0 )\r
+#define taskSCHEDULER_NOT_STARTED ( ( BaseType_t ) 1 )\r
+#define taskSCHEDULER_RUNNING ( ( BaseType_t ) 2 )\r
\r
\r
/*-----------------------------------------------------------\r
/**\r
* task. h\r
*<pre>\r
- portBASE_TYPE xTaskCreate(\r
- pdTASK_CODE pvTaskCode,\r
- const signed char * const pcName,\r
- unsigned short usStackDepth,\r
+ BaseType_t xTaskCreate(\r
+ TaskFunction_t pvTaskCode,\r
+ const char * const pcName,\r
+ uint16_t usStackDepth,\r
void *pvParameters,\r
- unsigned portBASE_TYPE uxPriority,\r
- xTaskHandle *pvCreatedTask\r
+ UBaseType_t uxPriority,\r
+ TaskHandle_t *pvCreatedTask\r
);</pre>\r
*\r
* Create a new task and add it to the list of tasks that are ready to run.\r
// Function that creates a task.\r
void vOtherFunction( void )\r
{\r
- static unsigned char ucParameterToPass;\r
- xTaskHandle xHandle = NULL;\r
+ static uint8_t ucParameterToPass;\r
+ TaskHandle_t xHandle = NULL;\r
\r
// Create the task, storing the handle. Note that the passed parameter ucParameterToPass\r
// must exist for the lifetime of the task, so in this case is declared static. If it was just an\r
/**\r
* task. h\r
*<pre>\r
- portBASE_TYPE xTaskCreateRestricted( xTaskParameters *pxTaskDefinition, xTaskHandle *pxCreatedTask );</pre>\r
+ BaseType_t xTaskCreateRestricted( TaskParameters_t *pxTaskDefinition, TaskHandle_t *pxCreatedTask );</pre>\r
*\r
* xTaskCreateRestricted() should only be used in systems that include an MPU\r
* implementation.\r
*\r
* Example usage:\r
<pre>\r
-// Create an xTaskParameters structure that defines the task to be created.\r
-static const xTaskParameters xCheckTaskParameters =\r
+// Create an TaskParameters_t structure that defines the task to be created.\r
+static const TaskParameters_t xCheckTaskParameters =\r
{\r
vATask, // pvTaskCode - the function that implements the task.\r
"ATask", // pcName - just a text name for the task to assist debugging.\r
\r
int main( void )\r
{\r
-xTaskHandle xHandle;\r
+TaskHandle_t xHandle;\r
\r
// Create a task from the const structure defined above. The task handle\r
// is requested (the second parameter is not NULL) but in this case just for\r
/**\r
* task. h\r
*<pre>\r
- void vTaskAllocateMPURegions( xTaskHandle xTask, const xMemoryRegion * const pxRegions );</pre>\r
+ void vTaskAllocateMPURegions( TaskHandle_t xTask, const MemoryRegion_t * const pxRegions );</pre>\r
*\r
* Memory regions are assigned to a restricted task when the task is created by\r
* a call to xTaskCreateRestricted(). These regions can be redefined using\r
*\r
* @param xTask The handle of the task being updated.\r
*\r
- * @param xRegions A pointer to an xMemoryRegion structure that contains the\r
+ * @param xRegions A pointer to an MemoryRegion_t structure that contains the\r
* new memory region definitions.\r
*\r
* Example usage:\r
<pre>\r
-// Define an array of xMemoryRegion structures that configures an MPU region\r
+// Define an array of MemoryRegion_t structures that configures an MPU region\r
// allowing read/write access for 1024 bytes starting at the beginning of the\r
// ucOneKByte array. The other two of the maximum 3 definable regions are\r
// unused so set to zero.\r
-static const xMemoryRegion xAltRegions[ portNUM_CONFIGURABLE_REGIONS ] =\r
+static const MemoryRegion_t xAltRegions[ portNUM_CONFIGURABLE_REGIONS ] =\r
{\r
// Base address Length Parameters\r
{ ucOneKByte, 1024, portMPU_REGION_READ_WRITE },\r
* \defgroup xTaskCreateRestricted xTaskCreateRestricted\r
* \ingroup Tasks\r
*/\r
-void vTaskAllocateMPURegions( xTaskHandle xTask, const xMemoryRegion * const pxRegions ) PRIVILEGED_FUNCTION;\r
+void vTaskAllocateMPURegions( TaskHandle_t xTask, const MemoryRegion_t * const pxRegions ) PRIVILEGED_FUNCTION;\r
\r
/**\r
* task. h\r
- * <pre>void vTaskDelete( xTaskHandle xTask );</pre>\r
+ * <pre>void vTaskDelete( TaskHandle_t xTask );</pre>\r
*\r
* INCLUDE_vTaskDelete must be defined as 1 for this function to be available.\r
* See the configuration section for more information.\r
<pre>\r
void vOtherFunction( void )\r
{\r
- xTaskHandle xHandle;\r
+ TaskHandle_t xHandle;\r
\r
// Create the task, storing the handle.\r
xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );\r
* \defgroup vTaskDelete vTaskDelete\r
* \ingroup Tasks\r
*/\r
-void vTaskDelete( xTaskHandle xTaskToDelete ) PRIVILEGED_FUNCTION;\r
+void vTaskDelete( TaskHandle_t xTaskToDelete ) PRIVILEGED_FUNCTION;\r
\r
/*-----------------------------------------------------------\r
* TASK CONTROL API\r
\r
/**\r
* task. h\r
- * <pre>void vTaskDelay( const portTickType xTicksToDelay );</pre>\r
+ * <pre>void vTaskDelay( const TickType_t xTicksToDelay );</pre>\r
*\r
* Delay a task for a given number of ticks. The actual time that the\r
* task remains blocked depends on the tick rate. The constant\r
void vTaskFunction( void * pvParameters )\r
{\r
// Block for 500ms.\r
- const portTickType xDelay = 500 / portTICK_RATE_MS;\r
+ const TickType_t xDelay = 500 / portTICK_RATE_MS;\r
\r
for( ;; )\r
{\r
* \defgroup vTaskDelay vTaskDelay\r
* \ingroup TaskCtrl\r
*/\r
-void vTaskDelay( const portTickType xTicksToDelay ) PRIVILEGED_FUNCTION;\r
+void vTaskDelay( const TickType_t xTicksToDelay ) PRIVILEGED_FUNCTION;\r
\r
/**\r
* task. h\r
- * <pre>void vTaskDelayUntil( portTickType *pxPreviousWakeTime, const portTickType xTimeIncrement );</pre>\r
+ * <pre>void vTaskDelayUntil( TickType_t *pxPreviousWakeTime, const TickType_t xTimeIncrement );</pre>\r
*\r
* INCLUDE_vTaskDelayUntil must be defined as 1 for this function to be available.\r
* See the configuration section for more information.\r
// Perform an action every 10 ticks.\r
void vTaskFunction( void * pvParameters )\r
{\r
- portTickType xLastWakeTime;\r
- const portTickType xFrequency = 10;\r
+ TickType_t xLastWakeTime;\r
+ const TickType_t xFrequency = 10;\r
\r
// Initialise the xLastWakeTime variable with the current time.\r
xLastWakeTime = xTaskGetTickCount ();\r
* \defgroup vTaskDelayUntil vTaskDelayUntil\r
* \ingroup TaskCtrl\r
*/\r
-void vTaskDelayUntil( portTickType * const pxPreviousWakeTime, const portTickType xTimeIncrement ) PRIVILEGED_FUNCTION;\r
+void vTaskDelayUntil( TickType_t * const pxPreviousWakeTime, const TickType_t xTimeIncrement ) PRIVILEGED_FUNCTION;\r
\r
/**\r
* task. h\r
- * <pre>unsigned portBASE_TYPE uxTaskPriorityGet( xTaskHandle xTask );</pre>\r
+ * <pre>UBaseType_t uxTaskPriorityGet( TaskHandle_t xTask );</pre>\r
*\r
* INCLUDE_uxTaskPriorityGet must be defined as 1 for this function to be available.\r
* See the configuration section for more information.\r
<pre>\r
void vAFunction( void )\r
{\r
- xTaskHandle xHandle;\r
+ TaskHandle_t xHandle;\r
\r
// Create a task, storing the handle.\r
xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );\r
* \defgroup uxTaskPriorityGet uxTaskPriorityGet\r
* \ingroup TaskCtrl\r
*/\r
-unsigned portBASE_TYPE uxTaskPriorityGet( xTaskHandle xTask ) PRIVILEGED_FUNCTION;\r
+UBaseType_t uxTaskPriorityGet( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;\r
\r
/**\r
* task. h\r
- * <pre>eTaskState eTaskGetState( xTaskHandle xTask );</pre>\r
+ * <pre>eTaskState eTaskGetState( TaskHandle_t xTask );</pre>\r
*\r
* INCLUDE_eTaskGetState must be defined as 1 for this function to be available.\r
* See the configuration section for more information.\r
* state of the task might change between the function being called, and the\r
* functions return value being tested by the calling task.\r
*/\r
-eTaskState eTaskGetState( xTaskHandle xTask ) PRIVILEGED_FUNCTION;\r
+eTaskState eTaskGetState( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;\r
\r
/**\r
* task. h\r
- * <pre>void vTaskPrioritySet( xTaskHandle xTask, unsigned portBASE_TYPE uxNewPriority );</pre>\r
+ * <pre>void vTaskPrioritySet( TaskHandle_t xTask, UBaseType_t uxNewPriority );</pre>\r
*\r
* INCLUDE_vTaskPrioritySet must be defined as 1 for this function to be available.\r
* See the configuration section for more information.\r
<pre>\r
void vAFunction( void )\r
{\r
- xTaskHandle xHandle;\r
+ TaskHandle_t xHandle;\r
\r
// Create a task, storing the handle.\r
xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );\r
* \defgroup vTaskPrioritySet vTaskPrioritySet\r
* \ingroup TaskCtrl\r
*/\r
-void vTaskPrioritySet( xTaskHandle xTask, unsigned portBASE_TYPE uxNewPriority ) PRIVILEGED_FUNCTION;\r
+void vTaskPrioritySet( TaskHandle_t xTask, UBaseType_t uxNewPriority ) PRIVILEGED_FUNCTION;\r
\r
/**\r
* task. h\r
- * <pre>void vTaskSuspend( xTaskHandle xTaskToSuspend );</pre>\r
+ * <pre>void vTaskSuspend( TaskHandle_t xTaskToSuspend );</pre>\r
*\r
* INCLUDE_vTaskSuspend must be defined as 1 for this function to be available.\r
* See the configuration section for more information.\r
<pre>\r
void vAFunction( void )\r
{\r
- xTaskHandle xHandle;\r
+ TaskHandle_t xHandle;\r
\r
// Create a task, storing the handle.\r
xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );\r
* \defgroup vTaskSuspend vTaskSuspend\r
* \ingroup TaskCtrl\r
*/\r
-void vTaskSuspend( xTaskHandle xTaskToSuspend ) PRIVILEGED_FUNCTION;\r
+void vTaskSuspend( TaskHandle_t xTaskToSuspend ) PRIVILEGED_FUNCTION;\r
\r
/**\r
* task. h\r
- * <pre>void vTaskResume( xTaskHandle xTaskToResume );</pre>\r
+ * <pre>void vTaskResume( TaskHandle_t xTaskToResume );</pre>\r
*\r
* INCLUDE_vTaskSuspend must be defined as 1 for this function to be available.\r
* See the configuration section for more information.\r
<pre>\r
void vAFunction( void )\r
{\r
- xTaskHandle xHandle;\r
+ TaskHandle_t xHandle;\r
\r
// Create a task, storing the handle.\r
xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );\r
* \defgroup vTaskResume vTaskResume\r
* \ingroup TaskCtrl\r
*/\r
-void vTaskResume( xTaskHandle xTaskToResume ) PRIVILEGED_FUNCTION;\r
+void vTaskResume( TaskHandle_t xTaskToResume ) PRIVILEGED_FUNCTION;\r
\r
/**\r
* task. h\r
- * <pre>void xTaskResumeFromISR( xTaskHandle xTaskToResume );</pre>\r
+ * <pre>void xTaskResumeFromISR( TaskHandle_t xTaskToResume );</pre>\r
*\r
* INCLUDE_xTaskResumeFromISR must be defined as 1 for this function to be\r
* available. See the configuration section for more information.\r
* \defgroup vTaskResumeFromISR vTaskResumeFromISR\r
* \ingroup TaskCtrl\r
*/\r
-portBASE_TYPE xTaskResumeFromISR( xTaskHandle xTaskToResume ) PRIVILEGED_FUNCTION;\r
+BaseType_t xTaskResumeFromISR( TaskHandle_t xTaskToResume ) PRIVILEGED_FUNCTION;\r
\r
/*-----------------------------------------------------------\r
* SCHEDULER CONTROL\r
\r
/**\r
* task. h\r
- * <pre>char xTaskResumeAll( void );</pre>\r
+ * <pre>BaseType_t xTaskResumeAll( void );</pre>\r
*\r
* Resumes scheduler activity after it was suspended by a call to\r
* vTaskSuspendAll().\r
* \defgroup xTaskResumeAll xTaskResumeAll\r
* \ingroup SchedulerControl\r
*/\r
-signed portBASE_TYPE xTaskResumeAll( void ) PRIVILEGED_FUNCTION;\r
+BaseType_t xTaskResumeAll( void ) PRIVILEGED_FUNCTION;\r
\r
/**\r
* task. h\r
- * <pre>signed portBASE_TYPE xTaskIsTaskSuspended( const xTaskHandle xTask );</pre>\r
+ * <pre>BaseType_t xTaskIsTaskSuspended( const TaskHandle_t xTask );</pre>\r
*\r
* Utility task that simply returns pdTRUE if the task referenced by xTask is\r
* currently in the Suspended state, or pdFALSE if the task referenced by xTask\r
* is in any other state.\r
*\r
*/\r
-signed portBASE_TYPE xTaskIsTaskSuspended( const xTaskHandle xTask ) PRIVILEGED_FUNCTION;\r
+BaseType_t xTaskIsTaskSuspended( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION;\r
\r
/*-----------------------------------------------------------\r
* TASK UTILITIES\r
\r
/**\r
* task. h\r
- * <PRE>portTickType xTaskGetTickCount( void );</PRE>\r
+ * <PRE>TickType_t xTaskGetTickCount( void );</PRE>\r
*\r
* @return The count of ticks since vTaskStartScheduler was called.\r
*\r
* \defgroup xTaskGetTickCount xTaskGetTickCount\r
* \ingroup TaskUtils\r
*/\r
-portTickType xTaskGetTickCount( void ) PRIVILEGED_FUNCTION;\r
+TickType_t xTaskGetTickCount( void ) PRIVILEGED_FUNCTION;\r
\r
/**\r
* task. h\r
- * <PRE>portTickType xTaskGetTickCountFromISR( void );</PRE>\r
+ * <PRE>TickType_t xTaskGetTickCountFromISR( void );</PRE>\r
*\r
* @return The count of ticks since vTaskStartScheduler was called.\r
*\r
* This is a version of xTaskGetTickCount() that is safe to be called from an\r
- * ISR - provided that portTickType is the natural word size of the\r
+ * ISR - provided that TickType_t is the natural word size of the\r
* microcontroller being used or interrupt nesting is either not supported or\r
* not being used.\r
*\r
* \defgroup xTaskGetTickCountFromISR xTaskGetTickCountFromISR\r
* \ingroup TaskUtils\r
*/\r
-portTickType xTaskGetTickCountFromISR( void ) PRIVILEGED_FUNCTION;\r
+TickType_t xTaskGetTickCountFromISR( void ) PRIVILEGED_FUNCTION;\r
\r
/**\r
* task. h\r
- * <PRE>unsigned short uxTaskGetNumberOfTasks( void );</PRE>\r
+ * <PRE>uint16_t uxTaskGetNumberOfTasks( void );</PRE>\r
*\r
* @return The number of tasks that the real time kernel is currently managing.\r
* This includes all ready, blocked and suspended tasks. A task that\r
* \defgroup uxTaskGetNumberOfTasks uxTaskGetNumberOfTasks\r
* \ingroup TaskUtils\r
*/\r
-unsigned portBASE_TYPE uxTaskGetNumberOfTasks( void ) PRIVILEGED_FUNCTION;\r
+UBaseType_t uxTaskGetNumberOfTasks( void ) PRIVILEGED_FUNCTION;\r
\r
/**\r
* task. h\r
- * <PRE>signed char *pcTaskGetTaskName( xTaskHandle xTaskToQuery );</PRE>\r
+ * <PRE>char *pcTaskGetTaskName( TaskHandle_t xTaskToQuery );</PRE>\r
*\r
* @return The text (human readable) name of the task referenced by the handle\r
* xTaskToQuery. A task can query its own name by either passing in its own\r
* \defgroup pcTaskGetTaskName pcTaskGetTaskName\r
* \ingroup TaskUtils\r
*/\r
-signed char *pcTaskGetTaskName( xTaskHandle xTaskToQuery );\r
+char *pcTaskGetTaskName( TaskHandle_t xTaskToQuery ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
\r
/**\r
* task.h\r
- * <PRE>unsigned portBASE_TYPE uxTaskGetStackHighWaterMark( xTaskHandle xTask );</PRE>\r
+ * <PRE>UBaseType_t uxTaskGetStackHighWaterMark( TaskHandle_t xTask );</PRE>\r
*\r
* INCLUDE_uxTaskGetStackHighWaterMark must be set to 1 in FreeRTOSConfig.h for\r
* this function to be available.\r
* actual spaces on the stack rather than bytes) since the task referenced by\r
* xTask was created.\r
*/\r
-unsigned portBASE_TYPE uxTaskGetStackHighWaterMark( xTaskHandle xTask ) PRIVILEGED_FUNCTION;\r
+UBaseType_t uxTaskGetStackHighWaterMark( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;\r
\r
/* When using trace macros it is sometimes necessary to include task.h before\r
-FreeRTOS.h. When this is done pdTASK_HOOK_CODE will not yet have been defined,\r
+FreeRTOS.h. When this is done TaskHookFunction_t will not yet have been defined,\r
so the following two prototypes will cause a compilation error. This can be\r
fixed by simply guarding against the inclusion of these two prototypes unless\r
they are explicitly required by the configUSE_APPLICATION_TASK_TAG configuration\r
#if configUSE_APPLICATION_TASK_TAG == 1\r
/**\r
* task.h\r
- * <pre>void vTaskSetApplicationTaskTag( xTaskHandle xTask, pdTASK_HOOK_CODE pxHookFunction );</pre>\r
+ * <pre>void vTaskSetApplicationTaskTag( TaskHandle_t xTask, TaskHookFunction_t pxHookFunction );</pre>\r
*\r
* Sets pxHookFunction to be the task hook function used by the task xTask.\r
* Passing xTask as NULL has the effect of setting the calling tasks hook\r
* function.\r
*/\r
- void vTaskSetApplicationTaskTag( xTaskHandle xTask, pdTASK_HOOK_CODE pxHookFunction ) PRIVILEGED_FUNCTION;\r
+ void vTaskSetApplicationTaskTag( TaskHandle_t xTask, TaskHookFunction_t pxHookFunction ) PRIVILEGED_FUNCTION;\r
\r
/**\r
* task.h\r
- * <pre>void xTaskGetApplicationTaskTag( xTaskHandle xTask );</pre>\r
+ * <pre>void xTaskGetApplicationTaskTag( TaskHandle_t xTask );</pre>\r
*\r
* Returns the pxHookFunction value assigned to the task xTask.\r
*/\r
- pdTASK_HOOK_CODE xTaskGetApplicationTaskTag( xTaskHandle xTask ) PRIVILEGED_FUNCTION;\r
+ TaskHookFunction_t xTaskGetApplicationTaskTag( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;\r
#endif /* configUSE_APPLICATION_TASK_TAG ==1 */\r
#endif /* ifdef configUSE_APPLICATION_TASK_TAG */\r
\r
/**\r
* task.h\r
- * <pre>portBASE_TYPE xTaskCallApplicationTaskHook( xTaskHandle xTask, void *pvParameter );</pre>\r
+ * <pre>BaseType_t xTaskCallApplicationTaskHook( TaskHandle_t xTask, void *pvParameter );</pre>\r
*\r
* Calls the hook function associated with xTask. Passing xTask as NULL has\r
* the effect of calling the Running tasks (the calling task) hook function.\r
* wants. The return value is the value returned by the task hook function\r
* registered by the user.\r
*/\r
-portBASE_TYPE xTaskCallApplicationTaskHook( xTaskHandle xTask, void *pvParameter ) PRIVILEGED_FUNCTION;\r
+BaseType_t xTaskCallApplicationTaskHook( TaskHandle_t xTask, void *pvParameter ) PRIVILEGED_FUNCTION;\r
\r
/**\r
* xTaskGetIdleTaskHandle() is only available if\r
* Simply returns the handle of the idle task. It is not valid to call\r
* xTaskGetIdleTaskHandle() before the scheduler has been started.\r
*/\r
-xTaskHandle xTaskGetIdleTaskHandle( void );\r
+TaskHandle_t xTaskGetIdleTaskHandle( void );\r
\r
/**\r
* configUSE_TRACE_FACILITY must be defined as 1 in FreeRTOSConfig.h for\r
* uxTaskGetSystemState() to be available.\r
*\r
- * uxTaskGetSystemState() populates an xTaskStatusType structure for each task in\r
- * the system. xTaskStatusType structures contain, among other things, members\r
+ * uxTaskGetSystemState() populates an TaskStatus_t structure for each task in\r
+ * the system. TaskStatus_t structures contain, among other things, members\r
* for the task handle, task name, task priority, task state, and total amount\r
- * of run time consumed by the task. See the xTaskStatusType structure\r
+ * of run time consumed by the task. See the TaskStatus_t structure\r
* definition in this file for the full member list.\r
*\r
* NOTE: This function is intended for debugging use only as its use results in\r
* the scheduler remaining suspended for an extended period.\r
*\r
- * @param pxTaskStatusArray A pointer to an array of xTaskStatusType structures.\r
- * The array must contain at least one xTaskStatusType structure for each task\r
+ * @param pxTaskStatusArray A pointer to an array of TaskStatus_t structures.\r
+ * The array must contain at least one TaskStatus_t structure for each task\r
* that is under the control of the RTOS. The number of tasks under the control\r
* of the RTOS can be determined using the uxTaskGetNumberOfTasks() API function.\r
*\r
* @param uxArraySize The size of the array pointed to by the pxTaskStatusArray\r
* parameter. The size is specified as the number of indexes in the array, or\r
- * the number of xTaskStatusType structures contained in the array, not by the\r
+ * the number of TaskStatus_t structures contained in the array, not by the\r
* number of bytes in the array.\r
*\r
* @param pulTotalRunTime If configGENERATE_RUN_TIME_STATS is set to 1 in\r
* http://www.freertos.org/rtos-run-time-stats.html) since the target booted.\r
* pulTotalRunTime can be set to NULL to omit the total run time information.\r
*\r
- * @return The number of xTaskStatusType structures that were populated by\r
+ * @return The number of TaskStatus_t structures that were populated by\r
* uxTaskGetSystemState(). This should equal the number returned by the\r
* uxTaskGetNumberOfTasks() API function, but will be zero if the value passed\r
* in the uxArraySize parameter was too small.\r
// This example demonstrates how a human readable table of run time stats\r
// information is generated from raw data provided by uxTaskGetSystemState().\r
// The human readable table is written to pcWriteBuffer\r
- void vTaskGetRunTimeStats( signed char *pcWriteBuffer )\r
+ void vTaskGetRunTimeStats( char *pcWriteBuffer )\r
{\r
- xTaskStatusType *pxTaskStatusArray;\r
- volatile unsigned portBASE_TYPE uxArraySize, x;\r
- unsigned long ulTotalRunTime, ulStatsAsPercentage;\r
+ TaskStatus_t *pxTaskStatusArray;\r
+ volatile UBaseType_t uxArraySize, x;\r
+ uint32_t ulTotalRunTime, ulStatsAsPercentage;\r
\r
// Make sure the write buffer does not contain a string.\r
*pcWriteBuffer = 0x00;\r
// function is executing.\r
uxArraySize = uxTaskGetNumberOfTasks();\r
\r
- // Allocate a xTaskStatusType structure for each task. An array could be\r
+ // Allocate a TaskStatus_t structure for each task. An array could be\r
// allocated statically at compile time.\r
- pxTaskStatusArray = pvPortMalloc( uxArraySize * sizeof( xTaskStatusType ) );\r
+ pxTaskStatusArray = pvPortMalloc( uxArraySize * sizeof( TaskStatus_t ) );\r
\r
if( pxTaskStatusArray != NULL )\r
{\r
\r
if( ulStatsAsPercentage > 0UL )\r
{\r
- sprintf( ( char * ) pcWriteBuffer, ( char * ) "%s\t\t%lu\t\t%lu%%\r\n", pxTaskStatusArray[ x ].pcTaskName, pxTaskStatusArray[ x ].ulRunTimeCounter, ulStatsAsPercentage );\r
+ sprintf( pcWriteBuffer, "%s\t\t%lu\t\t%lu%%\r\n", pxTaskStatusArray[ x ].pcTaskName, pxTaskStatusArray[ x ].ulRunTimeCounter, ulStatsAsPercentage );\r
}\r
else\r
{\r
// If the percentage is zero here then the task has\r
// consumed less than 1% of the total run time.\r
- sprintf( ( char * ) pcWriteBuffer, ( char * ) "%s\t\t%lu\t\t<1%%\r\n", pxTaskStatusArray[ x ].pcTaskName, pxTaskStatusArray[ x ].ulRunTimeCounter );\r
+ sprintf( pcWriteBuffer, "%s\t\t%lu\t\t<1%%\r\n", pxTaskStatusArray[ x ].pcTaskName, pxTaskStatusArray[ x ].ulRunTimeCounter );\r
}\r
\r
pcWriteBuffer += strlen( ( char * ) pcWriteBuffer );\r
}\r
</pre>\r
*/\r
-unsigned portBASE_TYPE uxTaskGetSystemState( xTaskStatusType *pxTaskStatusArray, unsigned portBASE_TYPE uxArraySize, unsigned long *pulTotalRunTime );\r
+UBaseType_t uxTaskGetSystemState( TaskStatus_t * const pxTaskStatusArray, const UBaseType_t uxArraySize, uint32_t * const pulTotalRunTime );\r
\r
/**\r
* task. h\r
* \defgroup vTaskList vTaskList\r
* \ingroup TaskUtils\r
*/\r
-void vTaskList( signed char *pcWriteBuffer ) PRIVILEGED_FUNCTION;\r
+void vTaskList( char * pcWriteBuffer ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
\r
/**\r
* task. h\r
* \defgroup vTaskGetRunTimeStats vTaskGetRunTimeStats\r
* \ingroup TaskUtils\r
*/\r
-void vTaskGetRunTimeStats( signed char *pcWriteBuffer ) PRIVILEGED_FUNCTION;\r
+void vTaskGetRunTimeStats( char *pcWriteBuffer ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
\r
/*-----------------------------------------------------------\r
* SCHEDULER INTERNALS AVAILABLE FOR PORTING PURPOSES\r
* + Time slicing is in use and there is a task of equal priority to the\r
* currently running task.\r
*/\r
-portBASE_TYPE xTaskIncrementTick( void ) PRIVILEGED_FUNCTION;\r
+BaseType_t xTaskIncrementTick( void ) PRIVILEGED_FUNCTION;\r
\r
/*\r
* THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE. IT IS AN\r
* portTICK_RATE_MS can be used to convert kernel ticks into a real time\r
* period.\r
*/\r
-void vTaskPlaceOnEventList( xList * const pxEventList, const portTickType xTicksToWait ) PRIVILEGED_FUNCTION;\r
-void vTaskPlaceOnUnorderedEventList( xList * pxEventList, portTickType xItemValue, const portTickType xTicksToWait ) PRIVILEGED_FUNCTION;\r
+void vTaskPlaceOnEventList( List_t * const pxEventList, const TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;\r
+void vTaskPlaceOnUnorderedEventList( List_t * pxEventList, const TickType_t xItemValue, const TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;\r
\r
/*\r
* THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE. IT IS AN\r
* indefinitely, whereas vTaskPlaceOnEventList() does.\r
*\r
*/\r
-void vTaskPlaceOnEventListRestricted( xList * const pxEventList, portTickType xTicksToWait ) PRIVILEGED_FUNCTION;\r
+void vTaskPlaceOnEventListRestricted( List_t * const pxEventList, const TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;\r
\r
/*\r
* THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE. IT IS AN\r
* @return pdTRUE if the task being removed has a higher priority than the task\r
* making the call, otherwise pdFALSE.\r
*/\r
-signed portBASE_TYPE xTaskRemoveFromEventList( const xList * const pxEventList ) PRIVILEGED_FUNCTION;\r
-signed portBASE_TYPE xTaskRemoveFromUnorderedEventList( xListItem * pxEventListItem, portTickType xItemValue ) PRIVILEGED_FUNCTION;\r
+BaseType_t xTaskRemoveFromEventList( const List_t * const pxEventList ) PRIVILEGED_FUNCTION;\r
+BaseType_t xTaskRemoveFromUnorderedEventList( ListItem_t * pxEventListItem, const TickType_t xItemValue ) PRIVILEGED_FUNCTION;\r
\r
/*\r
* THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE. IT IS ONLY\r
* THESE FUNCTIONS MUST NOT BE USED FROM APPLICATION CODE. THEY ARE USED BY\r
* THE EVENT BITS MODULE.\r
*/\r
-portTickType uxTaskResetEventItemValue( void ) PRIVILEGED_FUNCTION;\r
+TickType_t uxTaskResetEventItemValue( void ) PRIVILEGED_FUNCTION;\r
\r
/*\r
* Return the handle of the calling task.\r
*/\r
-xTaskHandle xTaskGetCurrentTaskHandle( void ) PRIVILEGED_FUNCTION;\r
+TaskHandle_t xTaskGetCurrentTaskHandle( void ) PRIVILEGED_FUNCTION;\r
\r
/*\r
* Capture the current time status for future reference.\r
*/\r
-void vTaskSetTimeOutState( xTimeOutType * const pxTimeOut ) PRIVILEGED_FUNCTION;\r
+void vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) PRIVILEGED_FUNCTION;\r
\r
/*\r
* Compare the time status now with that previously captured to see if the\r
* timeout has expired.\r
*/\r
-portBASE_TYPE xTaskCheckForTimeOut( xTimeOutType * const pxTimeOut, portTickType * const pxTicksToWait ) PRIVILEGED_FUNCTION;\r
+BaseType_t xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut, TickType_t * const pxTicksToWait ) PRIVILEGED_FUNCTION;\r
\r
/*\r
* Shortcut used by the queue implementation to prevent unnecessary call to\r
* Returns the scheduler state as taskSCHEDULER_RUNNING,\r
* taskSCHEDULER_NOT_STARTED or taskSCHEDULER_SUSPENDED.\r
*/\r
-portBASE_TYPE xTaskGetSchedulerState( void ) PRIVILEGED_FUNCTION;\r
+BaseType_t xTaskGetSchedulerState( void ) PRIVILEGED_FUNCTION;\r
\r
/*\r
* Raises the priority of the mutex holder to that of the calling task should\r
* the mutex holder have a priority less than the calling task.\r
*/\r
-void vTaskPriorityInherit( xTaskHandle const pxMutexHolder ) PRIVILEGED_FUNCTION;\r
+void vTaskPriorityInherit( TaskHandle_t const pxMutexHolder ) PRIVILEGED_FUNCTION;\r
\r
/*\r
* Set the priority of a task back to its proper priority in the case that it\r
* inherited a higher priority while it was holding a semaphore.\r
*/\r
-void vTaskPriorityDisinherit( xTaskHandle const pxMutexHolder ) PRIVILEGED_FUNCTION;\r
+void vTaskPriorityDisinherit( TaskHandle_t const pxMutexHolder ) PRIVILEGED_FUNCTION;\r
\r
/*\r
* Generic version of the task creation function which is in turn called by the\r
* xTaskCreate() and xTaskCreateRestricted() macros.\r
*/\r
-signed portBASE_TYPE xTaskGenericCreate( pdTASK_CODE pxTaskCode, const signed char * const pcName, unsigned short usStackDepth, void *pvParameters, unsigned portBASE_TYPE uxPriority, xTaskHandle *pxCreatedTask, portSTACK_TYPE *puxStackBuffer, const xMemoryRegion * const xRegions ) PRIVILEGED_FUNCTION;\r
+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. */\r
\r
/*\r
* Get the uxTCBNumber assigned to the task referenced by the xTask parameter.\r
*/\r
-unsigned portBASE_TYPE uxTaskGetTaskNumber( xTaskHandle xTask ) PRIVILEGED_FUNCTION;\r
+UBaseType_t uxTaskGetTaskNumber( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;\r
\r
/*\r
* Set the uxTaskNumber of the task referenced by the xTask parameter to\r
* uxHandle.\r
*/\r
-void vTaskSetTaskNumber( xTaskHandle xTask, unsigned portBASE_TYPE uxHandle ) PRIVILEGED_FUNCTION;\r
+void vTaskSetTaskNumber( TaskHandle_t xTask, const UBaseType_t uxHandle ) PRIVILEGED_FUNCTION;\r
\r
/*\r
* Only available when configUSE_TICKLESS_IDLE is set to 1.\r
* to date with the actual execution time by being skipped forward by a time\r
* equal to the idle period.\r
*/\r
-void vTaskStepTick( portTickType xTicksToJump ) PRIVILEGED_FUNCTION;\r
+void vTaskStepTick( const TickType_t xTicksToJump ) PRIVILEGED_FUNCTION;\r
\r
/*\r
* Only avilable when configUSE_TICKLESS_IDLE is set to 1.\r
projects / freertos / blobdiff