/*\r
- FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.\r
- All rights reserved\r
-\r
- VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.\r
-\r
- This file is part of the FreeRTOS distribution.\r
-\r
- FreeRTOS is free software; you can redistribute it and/or modify it under\r
- the terms of the GNU General Public License (version 2) as published by the\r
- Free Software Foundation >>>> AND MODIFIED BY <<<< the FreeRTOS exception.\r
-\r
- ***************************************************************************\r
- >>! NOTE: The modification to the GPL is included to allow you to !<<\r
- >>! distribute a combined work that includes FreeRTOS without being !<<\r
- >>! obliged to provide the source code for proprietary components !<<\r
- >>! outside of the FreeRTOS kernel. !<<\r
- ***************************************************************************\r
-\r
- FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY\r
- WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\r
- FOR A PARTICULAR PURPOSE. Full license text is available on the following\r
- link: http://www.freertos.org/a00114.html\r
-\r
- ***************************************************************************\r
- * *\r
- * FreeRTOS provides completely free yet professionally developed, *\r
- * robust, strictly quality controlled, supported, and cross *\r
- * platform software that is more than just the market leader, it *\r
- * is the industry's de facto standard. *\r
- * *\r
- * Help yourself get started quickly while simultaneously helping *\r
- * to support the FreeRTOS project by purchasing a FreeRTOS *\r
- * tutorial book, reference manual, or both: *\r
- * http://www.FreeRTOS.org/Documentation *\r
- * *\r
- ***************************************************************************\r
-\r
- http://www.FreeRTOS.org/FAQHelp.html - Having a problem? Start by reading\r
- the FAQ page "My application does not run, what could be wrong?". Have you\r
- defined configASSERT()?\r
-\r
- http://www.FreeRTOS.org/support - In return for receiving this top quality\r
- embedded software for free we request you assist our global community by\r
- participating in the support forum.\r
-\r
- http://www.FreeRTOS.org/training - Investing in training allows your team to\r
- be as productive as possible as early as possible. Now you can receive\r
- FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers\r
- Ltd, and the world's leading authority on the world's leading RTOS.\r
-\r
- http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,\r
- including FreeRTOS+Trace - an indispensable productivity tool, a DOS\r
- compatible FAT file system, and our tiny thread aware UDP/IP stack.\r
-\r
- http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.\r
- Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.\r
-\r
- http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High\r
- Integrity Systems ltd. to sell under the OpenRTOS brand. Low cost OpenRTOS\r
- licenses offer ticketed support, indemnification and commercial middleware.\r
-\r
- http://www.SafeRTOS.com - High Integrity Systems also provide a safety\r
- engineered and independently SIL3 certified version for use in safety and\r
- mission critical applications that require provable dependability.\r
-\r
- 1 tab == 4 spaces!\r
-*/\r
+ * FreeRTOS Kernel V10.2.1\r
+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.\r
+ *\r
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of\r
+ * this software and associated documentation files (the "Software"), to deal in\r
+ * the Software without restriction, including without limitation the rights to\r
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r
+ * the Software, and to permit persons to whom the Software is furnished to do so,\r
+ * subject to the following conditions:\r
+ *\r
+ * The above copyright notice and this permission notice shall be included in all\r
+ * copies or substantial portions of the Software.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\r
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\r
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
+ *\r
+ * http://www.FreeRTOS.org\r
+ * http://aws.amazon.com/freertos\r
+ *\r
+ * 1 tab == 4 spaces!\r
+ */\r
\r
\r
#ifndef INC_TASK_H\r
* MACROS AND DEFINITIONS\r
*----------------------------------------------------------*/\r
\r
-#define tskKERNEL_VERSION_NUMBER "V8.2.3"\r
-#define tskKERNEL_VERSION_MAJOR 8\r
+#define tskKERNEL_VERSION_NUMBER "V10.2.1"\r
+#define tskKERNEL_VERSION_MAJOR 10\r
#define tskKERNEL_VERSION_MINOR 2\r
-#define tskKERNEL_VERSION_BUILD 3\r
+#define tskKERNEL_VERSION_BUILD 1\r
+\r
+/* MPU region parameters passed in ulParameters\r
+ * of MemoryRegion_t struct. */\r
+#define tskMPU_REGION_READ_ONLY ( 1UL << 0UL )\r
+#define tskMPU_REGION_READ_WRITE ( 1UL << 1UL )\r
+#define tskMPU_REGION_EXECUTE_NEVER ( 1UL << 2UL )\r
+#define tskMPU_REGION_NORMAL_MEMORY ( 1UL << 3UL )\r
+#define tskMPU_REGION_DEVICE_MEMORY ( 1UL << 4UL )\r
\r
/**\r
* task. h\r
* \defgroup TaskHandle_t TaskHandle_t\r
* \ingroup Tasks\r
*/\r
-typedef void * TaskHandle_t;\r
+struct tskTaskControlBlock; /* The old naming convention is used to prevent breaking kernel aware debuggers. */\r
+typedef struct tskTaskControlBlock* TaskHandle_t;\r
\r
/*\r
* Defines the prototype to which the application task hook function must\r
eReady, /* The task being queried is in a read or pending ready list. */\r
eBlocked, /* The task being queried is in the Blocked state. */\r
eSuspended, /* The task being queried is in the Suspended state, or is in the Blocked state with an infinite time out. */\r
- eDeleted /* The task being queried has been deleted, but its TCB has not yet been freed. */\r
+ eDeleted, /* The task being queried has been deleted, but its TCB has not yet been freed. */\r
+ eInvalid /* Used as an 'invalid state' value. */\r
} eTaskState;\r
\r
/* Actions that can be performed when vTaskNotify() is called. */\r
{\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
+ configSTACK_DEPTH_TYPE usStackDepth;\r
void *pvParameters;\r
UBaseType_t uxPriority;\r
StackType_t *puxStackBuffer;\r
MemoryRegion_t xRegions[ portNUM_CONFIGURABLE_REGIONS ];\r
+ #if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )\r
+ StaticTask_t * const pxTaskBuffer;\r
+ #endif\r
} TaskParameters_t;\r
\r
/* Used with the uxTaskGetSystemState() function to return the state of each task\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
+ StackType_t *pxStackBase; /* Points to the lowest address of the task's stack area. */\r
+ configSTACK_DEPTH_TYPE 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
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. */\r
} eSleepModeStatus;\r
\r
-/* Value that can be assigned to the eNotifyState member of the TCB. */\r
-typedef enum\r
-{\r
- eNotWaitingNotification = 0,\r
- eWaitingNotification,\r
- eNotified\r
-} eNotifyValue;\r
-\r
/**\r
* Defines the priority used by the idle task. This must not be modified.\r
*\r
BaseType_t xTaskCreate(\r
TaskFunction_t pvTaskCode,\r
const char * const pcName,\r
- uint16_t usStackDepth,\r
+ configSTACK_DEPTH_TYPE usStackDepth,\r
void *pvParameters,\r
UBaseType_t uxPriority,\r
TaskHandle_t *pvCreatedTask\r
*\r
* Create a new task and add it to the list of tasks that are ready to run.\r
*\r
+ * Internally, within the FreeRTOS implementation, tasks use two blocks of\r
+ * memory. The first block is used to hold the task's data structures. The\r
+ * second block is used by the task as its stack. If a task is created using\r
+ * xTaskCreate() then both blocks of memory are automatically dynamically\r
+ * allocated inside the xTaskCreate() function. (see\r
+ * http://www.freertos.org/a00111.html). If a task is created using\r
+ * xTaskCreateStatic() then the application writer must provide the required\r
+ * memory. xTaskCreateStatic() therefore allows a task to be created without\r
+ * using any dynamic memory allocation.\r
+ *\r
+ * See xTaskCreateStatic() for a version that does not use any dynamic memory\r
+ * allocation.\r
+ *\r
* xTaskCreate() can only be used to create a task that has unrestricted\r
* access to the entire microcontroller memory map. Systems that include MPU\r
* support can alternatively create an MPU constrained task using\r
// an automatic stack variable it might no longer exist, or at least have been corrupted, by the time\r
// the new task attempts to access it.\r
xTaskCreate( vTaskCode, "NAME", STACK_SIZE, &ucParameterToPass, tskIDLE_PRIORITY, &xHandle );\r
- configASSERT( xHandle );\r
+ configASSERT( xHandle );\r
\r
// Use the handle to delete the task.\r
- if( xHandle != NULL )\r
- {\r
- vTaskDelete( xHandle );\r
- }\r
+ if( xHandle != NULL )\r
+ {\r
+ vTaskDelete( xHandle );\r
+ }\r
}\r
</pre>\r
* \defgroup xTaskCreate xTaskCreate\r
* \ingroup Tasks\r
*/\r
-#define xTaskCreate( pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask ) xTaskGenericCreate( ( pvTaskCode ), ( pcName ), ( usStackDepth ), ( pvParameters ), ( uxPriority ), ( pxCreatedTask ), ( NULL ), ( NULL ), ( NULL ) )\r
+#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
+ BaseType_t xTaskCreate( TaskFunction_t pxTaskCode,\r
+ const char * const pcName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
+ const configSTACK_DEPTH_TYPE usStackDepth,\r
+ void * const pvParameters,\r
+ UBaseType_t uxPriority,\r
+ TaskHandle_t * const pxCreatedTask ) PRIVILEGED_FUNCTION;\r
+#endif\r
\r
/**\r
* task. h\r
*<pre>\r
- BaseType_t xTaskCreateStatic(\r
- TaskFunction_t pvTaskCode,\r
- const char * const pcName,\r
- uint16_t usStackDepth,\r
- void *pvParameters,\r
- UBaseType_t uxPriority,\r
- TaskHandle_t *pvCreatedTask,\r
- StackType_t *pxStackBuffer,\r
- StaticTask_t *pxTCBBuffer\r
- );</pre>\r
+ TaskHandle_t xTaskCreateStatic( TaskFunction_t pvTaskCode,\r
+ const char * const pcName,\r
+ uint32_t ulStackDepth,\r
+ void *pvParameters,\r
+ UBaseType_t uxPriority,\r
+ StackType_t *pxStackBuffer,\r
+ StaticTask_t *pxTaskBuffer );</pre>\r
*\r
* Create a new task and add it to the list of tasks that are ready to run.\r
- * If a task is created using xTaskCreate() then the stack and task control\r
- * block (TCB) used by the task are allocated dynamically. If a task is created\r
- * using xTaskCreateStatic() then the application writer can optionally provide\r
- * the buffers that will hold the task stack and TCB respectively.\r
- * xTaskCreateStatic() therefore allows tasks to be created without any dynamic\r
- * memory allocation.\r
+ *\r
+ * Internally, within the FreeRTOS implementation, tasks use two blocks of\r
+ * memory. The first block is used to hold the task's data structures. The\r
+ * second block is used by the task as its stack. If a task is created using\r
+ * xTaskCreate() then both blocks of memory are automatically dynamically\r
+ * allocated inside the xTaskCreate() function. (see\r
+ * http://www.freertos.org/a00111.html). If a task is created using\r
+ * xTaskCreateStatic() then the application writer must provide the required\r
+ * memory. xTaskCreateStatic() therefore allows a task to be created without\r
+ * using any dynamic memory allocation.\r
*\r
* @param pvTaskCode Pointer to the task entry function. Tasks\r
* must be implemented to never return (i.e. continuous loop).\r
* facilitate debugging. The maximum length of the string is defined by\r
* configMAX_TASK_NAME_LEN in FreeRTOSConfig.h.\r
*\r
- * @param usStackDepth The size of the task stack specified as the number of\r
+ * @param ulStackDepth The size of the task stack specified as the number of\r
* variables the stack can hold - not the number of bytes. For example, if\r
- * the stack is 32-bits wide and usStackDepth is defined as 100 then 400 bytes\r
+ * the stack is 32-bits wide and ulStackDepth is defined as 100 then 400 bytes\r
* will be allocated for stack storage.\r
*\r
* @param pvParameters Pointer that will be used as the parameter for the task\r
*\r
* @param uxPriority The priority at which the task will run.\r
*\r
- * @param pvCreatedTask Used to pass back a handle by which the created task\r
- * can be referenced. Pass as NULL if the handle is not required.\r
+ * @param pxStackBuffer Must point to a StackType_t array that has at least\r
+ * ulStackDepth indexes - the array will then be used as the task's stack,\r
+ * removing the need for the stack to be allocated dynamically.\r
*\r
- * @param pxStackBuffer If pxStackBuffer is NULL then the stack used by the\r
- * task will be allocated dynamically, just as if the task was created using\r
- * xTaskCreate(). if pxStackBuffer is not NULL then it must point to a\r
- * StackType_t array that has at least usStackDepth indexes - the array will\r
- * then be used as the task's stack.\r
+ * @param pxTaskBuffer Must point to a variable of type StaticTask_t, which will\r
+ * then be used to hold the task's data structures, removing the need for the\r
+ * memory to be allocated dynamically.\r
*\r
- * @param pxTCBBuffer If pxTCBBuffer is NULL then the TCB (which is the\r
- * structures used internally within FreeRTOS to hold information on the task)\r
- * will be allocated dynamically, just as when xTaskCreate() is used. If\r
- * pxTCBBuffer is not NULL then it must point to a variable of type StaticTask_t,\r
- * which will then be used as the TCB of the task being created.\r
- *\r
- * @return pdPASS if the task was successfully created and added to a ready\r
- * list, otherwise an error code defined in the file projdefs.h\r
+ * @return If neither pxStackBuffer or pxTaskBuffer are NULL, then the task will\r
+ * be created and a handle to the created task is returned. If either\r
+ * pxStackBuffer or pxTaskBuffer are NULL then the task will not be created and\r
+ * NULL is returned.\r
*\r
* Example usage:\r
<pre>\r
\r
- // Dimensions the buffer that the task being created will use as its stack.\r
- // NOTE: This is the number of words the stack will hold, not the number of\r
- // bytes. For example, if each stack item is 32-bits, and this is set to 100,\r
- // then 400 bytes (100 * 32-bits) will be allocated.\r
- #define STACK_SIZE 200\r
-\r
- // Structure that will hold the TCB of the task being created.\r
- StaticTask_t xTCB;\r
-\r
- // Buffer that the task being created will use as its stack.\r
- StackType_t xStack[ STACK_SIZE ];\r
-\r
- // Task to be created.\r
- void vTaskCode( void * pvParameters )\r
- {\r
- for( ;; )\r
- {\r
- // Task code goes here.\r
- }\r
- }\r
-\r
- // Function that creates a task.\r
- void vOtherFunction( void )\r
- {\r
- static uint8_t ucParameterToPass;\r
- TaskHandle_t xHandle = NULL;\r
-\r
- // Create the task without using any dynamic memory allocation.\r
- xTaskCreate( vTaskCode, // As per xTaskCreate() parameter.\r
- "NAME", // As per xTaskCreate() parameter.\r
- STACK_SIZE, // As per xTaskCreate() parameter.\r
- &ucParameterToPass, // As per xTaskCreate() parameter.\r
- tskIDLE_PRIORITY, // As per xTaskCreate() parameter.\r
- &xHandle, // As per xTaskCreate() parameter.\r
- xStack, // Pointer to the buffer that the task being created will use as its stack.\r
- &xTCB ); // Pointer to a structure in which the TCB of the task being created will be stored.\r
- }\r
+ // Dimensions the buffer that the task being created will use as its stack.\r
+ // NOTE: This is the number of words the stack will hold, not the number of\r
+ // bytes. For example, if each stack item is 32-bits, and this is set to 100,\r
+ // then 400 bytes (100 * 32-bits) will be allocated.\r
+ #define STACK_SIZE 200\r
+\r
+ // Structure that will hold the TCB of the task being created.\r
+ StaticTask_t xTaskBuffer;\r
+\r
+ // Buffer that the task being created will use as its stack. Note this is\r
+ // an array of StackType_t variables. The size of StackType_t is dependent on\r
+ // the RTOS port.\r
+ StackType_t xStack[ STACK_SIZE ];\r
+\r
+ // Function that implements the task being created.\r
+ void vTaskCode( void * pvParameters )\r
+ {\r
+ // The parameter value is expected to be 1 as 1 is passed in the\r
+ // pvParameters value in the call to xTaskCreateStatic().\r
+ configASSERT( ( uint32_t ) pvParameters == 1UL );\r
+\r
+ for( ;; )\r
+ {\r
+ // Task code goes here.\r
+ }\r
+ }\r
+\r
+ // Function that creates a task.\r
+ void vOtherFunction( void )\r
+ {\r
+ TaskHandle_t xHandle = NULL;\r
+\r
+ // Create the task without using any dynamic memory allocation.\r
+ xHandle = xTaskCreateStatic(\r
+ vTaskCode, // Function that implements the task.\r
+ "NAME", // Text name for the task.\r
+ STACK_SIZE, // Stack size in words, not bytes.\r
+ ( void * ) 1, // Parameter passed into the task.\r
+ tskIDLE_PRIORITY,// Priority at which the task is created.\r
+ xStack, // Array to use as the task's stack.\r
+ &xTaskBuffer ); // Variable to hold the task's data structure.\r
+\r
+ // puxStackBuffer and pxTaskBuffer were not NULL, so the task will have\r
+ // been created, and xHandle will be the task's handle. Use the handle\r
+ // to suspend the task.\r
+ vTaskSuspend( xHandle );\r
+ }\r
</pre>\r
* \defgroup xTaskCreateStatic xTaskCreateStatic\r
* \ingroup Tasks\r
*/\r
#if( configSUPPORT_STATIC_ALLOCATION == 1 )\r
- #define xTaskCreateStatic( pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask, puxStackBuffer, pxDummyTCB ) xTaskGenericCreate( ( pvTaskCode ), ( pcName ), ( usStackDepth ), ( pvParameters ), ( uxPriority ), ( pxCreatedTask ), ( puxStackBuffer ), ( pxDummyTCB ), ( NULL ) )\r
+ TaskHandle_t xTaskCreateStatic( TaskFunction_t pxTaskCode,\r
+ const char * const pcName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
+ const uint32_t ulStackDepth,\r
+ void * const pvParameters,\r
+ UBaseType_t uxPriority,\r
+ StackType_t * const puxStackBuffer,\r
+ StaticTask_t * const pxTaskBuffer ) PRIVILEGED_FUNCTION;\r
#endif /* configSUPPORT_STATIC_ALLOCATION */\r
\r
/**\r
*<pre>\r
BaseType_t xTaskCreateRestricted( TaskParameters_t *pxTaskDefinition, TaskHandle_t *pxCreatedTask );</pre>\r
*\r
+ * Only available when configSUPPORT_DYNAMIC_ALLOCATION is set to 1.\r
+ *\r
* xTaskCreateRestricted() should only be used in systems that include an MPU\r
* implementation.\r
*\r
* The function parameters define the memory regions and associated access\r
* permissions allocated to the task.\r
*\r
+ * See xTaskCreateRestrictedStatic() for a version that does not use any\r
+ * dynamic memory allocation.\r
+ *\r
* @param pxTaskDefinition Pointer to a structure that contains a member\r
* for each of the normal xTaskCreate() parameters (see the xTaskCreate() API\r
* documentation) plus an optional stack buffer and the memory region\r
// for full information.\r
{\r
// Base address Length Parameters\r
- { cReadWriteArray, 32, portMPU_REGION_READ_WRITE },\r
- { cReadOnlyArray, 32, portMPU_REGION_READ_ONLY },\r
- { cPrivilegedOnlyAccessArray, 128, portMPU_REGION_PRIVILEGED_READ_WRITE }\r
+ { cReadWriteArray, 32, portMPU_REGION_READ_WRITE },\r
+ { cReadOnlyArray, 32, portMPU_REGION_READ_ONLY },\r
+ { cPrivilegedOnlyAccessArray, 128, portMPU_REGION_PRIVILEGED_READ_WRITE }\r
}\r
};\r
\r
* \defgroup xTaskCreateRestricted xTaskCreateRestricted\r
* \ingroup Tasks\r
*/\r
-#define xTaskCreateRestricted( x, pxCreatedTask ) xTaskGenericCreate( ((x)->pvTaskCode), ((x)->pcName), ((x)->usStackDepth), ((x)->pvParameters), ((x)->uxPriority), (pxCreatedTask), ((x)->puxStackBuffer), ( NULL ), ((x)->xRegions) )\r
+#if( portUSING_MPU_WRAPPERS == 1 )\r
+ BaseType_t xTaskCreateRestricted( const TaskParameters_t * const pxTaskDefinition, TaskHandle_t *pxCreatedTask ) PRIVILEGED_FUNCTION;\r
+#endif\r
+\r
+/**\r
+ * task. h\r
+ *<pre>\r
+ BaseType_t xTaskCreateRestrictedStatic( TaskParameters_t *pxTaskDefinition, TaskHandle_t *pxCreatedTask );</pre>\r
+ *\r
+ * Only available when configSUPPORT_STATIC_ALLOCATION is set to 1.\r
+ *\r
+ * xTaskCreateRestrictedStatic() should only be used in systems that include an\r
+ * MPU implementation.\r
+ *\r
+ * Internally, within the FreeRTOS implementation, tasks use two blocks of\r
+ * memory. The first block is used to hold the task's data structures. The\r
+ * second block is used by the task as its stack. If a task is created using\r
+ * xTaskCreateRestricted() then the stack is provided by the application writer,\r
+ * and the memory used to hold the task's data structure is automatically\r
+ * dynamically allocated inside the xTaskCreateRestricted() function. If a task\r
+ * is created using xTaskCreateRestrictedStatic() then the application writer\r
+ * must provide the memory used to hold the task's data structures too.\r
+ * xTaskCreateRestrictedStatic() therefore allows a memory protected task to be\r
+ * created without using any dynamic memory allocation.\r
+ *\r
+ * @param pxTaskDefinition Pointer to a structure that contains a member\r
+ * for each of the normal xTaskCreate() parameters (see the xTaskCreate() API\r
+ * documentation) plus an optional stack buffer and the memory region\r
+ * definitions. If configSUPPORT_STATIC_ALLOCATION is set to 1 the structure\r
+ * contains an additional member, which is used to point to a variable of type\r
+ * StaticTask_t - which is then used to hold the task's data structure.\r
+ *\r
+ * @param pxCreatedTask Used to pass back a handle by which the created task\r
+ * can be referenced.\r
+ *\r
+ * @return pdPASS if the task was successfully created and added to a ready\r
+ * list, otherwise an error code defined in the file projdefs.h\r
+ *\r
+ * Example usage:\r
+ <pre>\r
+// Create an TaskParameters_t structure that defines the task to be created.\r
+// The StaticTask_t variable is only included in the structure when\r
+// configSUPPORT_STATIC_ALLOCATION is set to 1. The PRIVILEGED_DATA macro can\r
+// be used to force the variable into the RTOS kernel's privileged data area.\r
+static PRIVILEGED_DATA StaticTask_t xTaskBuffer;\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
+ 100, // usStackDepth - the stack size DEFINED IN WORDS.\r
+ NULL, // pvParameters - passed into the task function as the function parameters.\r
+ ( 1UL | portPRIVILEGE_BIT ),// uxPriority - task priority, set the portPRIVILEGE_BIT if the task should run in a privileged state.\r
+ cStackBuffer,// puxStackBuffer - the buffer to be used as the task stack.\r
+\r
+ // xRegions - Allocate up to three separate memory regions for access by\r
+ // the task, with appropriate access permissions. Different processors have\r
+ // different memory alignment requirements - refer to the FreeRTOS documentation\r
+ // for full information.\r
+ {\r
+ // Base address Length Parameters\r
+ { cReadWriteArray, 32, portMPU_REGION_READ_WRITE },\r
+ { cReadOnlyArray, 32, portMPU_REGION_READ_ONLY },\r
+ { cPrivilegedOnlyAccessArray, 128, portMPU_REGION_PRIVILEGED_READ_WRITE }\r
+ }\r
+\r
+ &xTaskBuffer; // Holds the task's data structure.\r
+};\r
+\r
+int main( void )\r
+{\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
+ // demonstration purposes as its not actually used.\r
+ xTaskCreateRestricted( &xRegTest1Parameters, &xHandle );\r
+\r
+ // Start the scheduler.\r
+ vTaskStartScheduler();\r
+\r
+ // Will only get here if there was insufficient memory to create the idle\r
+ // and/or timer task.\r
+ for( ;; );\r
+}\r
+ </pre>\r
+ * \defgroup xTaskCreateRestrictedStatic xTaskCreateRestrictedStatic\r
+ * \ingroup Tasks\r
+ */\r
+#if( ( portUSING_MPU_WRAPPERS == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )\r
+ BaseType_t xTaskCreateRestrictedStatic( const TaskParameters_t * const pxTaskDefinition, TaskHandle_t *pxCreatedTask ) PRIVILEGED_FUNCTION;\r
+#endif\r
\r
/**\r
* task. h\r
\r
/**\r
* task. h\r
- * <pre>UBaseType_t uxTaskPriorityGet( TaskHandle_t xTask );</pre>\r
+ * <pre>BaseType_t xTaskAbortDelay( TaskHandle_t xTask );</pre>\r
+ *\r
+ * INCLUDE_xTaskAbortDelay must be defined as 1 in FreeRTOSConfig.h for this\r
+ * function to be available.\r
+ *\r
+ * A task will enter the Blocked state when it is waiting for an event. The\r
+ * event it is waiting for can be a temporal event (waiting for a time), such\r
+ * as when vTaskDelay() is called, or an event on an object, such as when\r
+ * xQueueReceive() or ulTaskNotifyTake() is called. If the handle of a task\r
+ * that is in the Blocked state is used in a call to xTaskAbortDelay() then the\r
+ * task will leave the Blocked state, and return from whichever function call\r
+ * placed the task into the Blocked state.\r
+ *\r
+ * There is no 'FromISR' version of this function as an interrupt would need to\r
+ * know which object a task was blocked on in order to know which actions to\r
+ * take. For example, if the task was blocked on a queue the interrupt handler\r
+ * would then need to know if the queue was locked.\r
+ *\r
+ * @param xTask The handle of the task to remove from the Blocked state.\r
+ *\r
+ * @return If the task referenced by xTask was not in the Blocked state then\r
+ * pdFAIL is returned. Otherwise pdPASS is returned.\r
+ *\r
+ * \defgroup xTaskAbortDelay xTaskAbortDelay\r
+ * \ingroup TaskCtrl\r
+ */\r
+BaseType_t xTaskAbortDelay( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;\r
+\r
+/**\r
+ * task. h\r
+ * <pre>UBaseType_t uxTaskPriorityGet( const 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
* \defgroup uxTaskPriorityGet uxTaskPriorityGet\r
* \ingroup TaskCtrl\r
*/\r
-UBaseType_t uxTaskPriorityGet( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;\r
+UBaseType_t uxTaskPriorityGet( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION;\r
\r
/**\r
* task. h\r
- * <pre>UBaseType_t uxTaskPriorityGetFromISR( TaskHandle_t xTask );</pre>\r
+ * <pre>UBaseType_t uxTaskPriorityGetFromISR( const TaskHandle_t xTask );</pre>\r
*\r
* A version of uxTaskPriorityGet() that can be used from an ISR.\r
*/\r
-UBaseType_t uxTaskPriorityGetFromISR( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;\r
+UBaseType_t uxTaskPriorityGetFromISR( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION;\r
\r
/**\r
* task. h\r
*/\r
eTaskState eTaskGetState( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;\r
\r
+/**\r
+ * task. h\r
+ * <pre>void vTaskGetInfo( TaskHandle_t xTask, TaskStatus_t *pxTaskStatus, BaseType_t xGetFreeStackSpace, eTaskState eState );</pre>\r
+ *\r
+ * configUSE_TRACE_FACILITY must be defined as 1 for this function to be\r
+ * available. See the configuration section for more information.\r
+ *\r
+ * Populates a TaskStatus_t structure with information about a task.\r
+ *\r
+ * @param xTask Handle of the task being queried. If xTask is NULL then\r
+ * information will be returned about the calling task.\r
+ *\r
+ * @param pxTaskStatus A pointer to the TaskStatus_t structure that will be\r
+ * filled with information about the task referenced by the handle passed using\r
+ * the xTask parameter.\r
+ *\r
+ * @xGetFreeStackSpace The TaskStatus_t structure contains a member to report\r
+ * the stack high water mark of the task being queried. Calculating the stack\r
+ * high water mark takes a relatively long time, and can make the system\r
+ * temporarily unresponsive - so the xGetFreeStackSpace parameter is provided to\r
+ * allow the high water mark checking to be skipped. The high watermark value\r
+ * will only be written to the TaskStatus_t structure if xGetFreeStackSpace is\r
+ * not set to pdFALSE;\r
+ *\r
+ * @param eState The TaskStatus_t structure contains a member to report the\r
+ * state of the task being queried. Obtaining the task state is not as fast as\r
+ * a simple assignment - so the eState parameter is provided to allow the state\r
+ * information to be omitted from the TaskStatus_t structure. To obtain state\r
+ * information then set eState to eInvalid - otherwise the value passed in\r
+ * eState will be reported as the task state in the TaskStatus_t structure.\r
+ *\r
+ * Example usage:\r
+ <pre>\r
+ void vAFunction( void )\r
+ {\r
+ TaskHandle_t xHandle;\r
+ TaskStatus_t xTaskDetails;\r
+\r
+ // Obtain the handle of a task from its name.\r
+ xHandle = xTaskGetHandle( "Task_Name" );\r
+\r
+ // Check the handle is not NULL.\r
+ configASSERT( xHandle );\r
+\r
+ // Use the handle to obtain further information about the task.\r
+ vTaskGetInfo( xHandle,\r
+ &xTaskDetails,\r
+ pdTRUE, // Include the high water mark in xTaskDetails.\r
+ eInvalid ); // Include the task state in xTaskDetails.\r
+ }\r
+ </pre>\r
+ * \defgroup vTaskGetInfo vTaskGetInfo\r
+ * \ingroup TaskCtrl\r
+ */\r
+void vTaskGetInfo( TaskHandle_t xTask, TaskStatus_t *pxTaskStatus, BaseType_t xGetFreeStackSpace, eTaskState eState ) PRIVILEGED_FUNCTION;\r
+\r
/**\r
* task. h\r
* <pre>void vTaskPrioritySet( TaskHandle_t xTask, UBaseType_t uxNewPriority );</pre>\r
\r
/**\r
* task. h\r
- * <PRE>char *pcTaskGetTaskName( TaskHandle_t xTaskToQuery );</PRE>\r
+ * <PRE>char *pcTaskGetName( 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
- * handle, or by setting xTaskToQuery to NULL. INCLUDE_pcTaskGetTaskName must be\r
- * set to 1 in FreeRTOSConfig.h for pcTaskGetTaskName() to be available.\r
+ * handle, or by setting xTaskToQuery to NULL.\r
+ *\r
+ * \defgroup pcTaskGetName pcTaskGetName\r
+ * \ingroup TaskUtils\r
+ */\r
+char *pcTaskGetName( 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>TaskHandle_t xTaskGetHandle( const char *pcNameToQuery );</PRE>\r
+ *\r
+ * NOTE: This function takes a relatively long time to complete and should be\r
+ * used sparingly.\r
+ *\r
+ * @return The handle of the task that has the human readable name pcNameToQuery.\r
+ * NULL is returned if no matching name is found. INCLUDE_xTaskGetHandle\r
+ * must be set to 1 in FreeRTOSConfig.h for pcTaskGetHandle() to be available.\r
*\r
- * \defgroup pcTaskGetTaskName pcTaskGetTaskName\r
+ * \defgroup pcTaskGetHandle pcTaskGetHandle\r
* \ingroup TaskUtils\r
*/\r
-char *pcTaskGetTaskName( TaskHandle_t xTaskToQuery ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
+TaskHandle_t xTaskGetHandle( const char *pcNameToQuery ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
\r
/**\r
* task.h\r
* a value of 1 means 4 bytes) since the task started. The smaller the returned\r
* number the closer the task has come to overflowing its stack.\r
*\r
+ * uxTaskGetStackHighWaterMark() and uxTaskGetStackHighWaterMark2() are the\r
+ * same except for their return type. Using configSTACK_DEPTH_TYPE allows the\r
+ * user to determine the return type. It gets around the problem of the value\r
+ * overflowing on 8-bit types without breaking backward compatibility for\r
+ * applications that expect an 8-bit return type.\r
+ *\r
* @param xTask Handle of the task associated with the stack to be checked.\r
* Set xTask to NULL to check the stack of the calling task.\r
*\r
*/\r
UBaseType_t uxTaskGetStackHighWaterMark( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;\r
\r
+/**\r
+ * task.h\r
+ * <PRE>configSTACK_DEPTH_TYPE uxTaskGetStackHighWaterMark2( TaskHandle_t xTask );</PRE>\r
+ *\r
+ * INCLUDE_uxTaskGetStackHighWaterMark2 must be set to 1 in FreeRTOSConfig.h for\r
+ * this function to be available.\r
+ *\r
+ * Returns the high water mark of the stack associated with xTask. That is,\r
+ * the minimum free stack space there has been (in words, so on a 32 bit machine\r
+ * a value of 1 means 4 bytes) since the task started. The smaller the returned\r
+ * number the closer the task has come to overflowing its stack.\r
+ *\r
+ * uxTaskGetStackHighWaterMark() and uxTaskGetStackHighWaterMark2() are the\r
+ * same except for their return type. Using configSTACK_DEPTH_TYPE allows the\r
+ * user to determine the return type. It gets around the problem of the value\r
+ * overflowing on 8-bit types without breaking backward compatibility for\r
+ * applications that expect an 8-bit return type.\r
+ *\r
+ * @param xTask Handle of the task associated with the stack to be checked.\r
+ * Set xTask to NULL to check the stack of the calling task.\r
+ *\r
+ * @return The smallest amount of free stack space there has been (in words, so\r
+ * actual spaces on the stack rather than bytes) since the task referenced by\r
+ * xTask was created.\r
+ */\r
+configSTACK_DEPTH_TYPE uxTaskGetStackHighWaterMark2( 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 TaskHookFunction_t will not yet have been defined,\r
so the following two prototypes will cause a compilation error. This can be\r
* task.h\r
* <pre>void xTaskGetApplicationTaskTag( TaskHandle_t xTask );</pre>\r
*\r
- * Returns the pxHookFunction value assigned to the task xTask.\r
+ * Returns the pxHookFunction value assigned to the task xTask. Do not\r
+ * call from an interrupt service routine - call\r
+ * xTaskGetApplicationTaskTagFromISR() instead.\r
*/\r
TaskHookFunction_t xTaskGetApplicationTaskTag( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;\r
+\r
+ /**\r
+ * task.h\r
+ * <pre>void xTaskGetApplicationTaskTagFromISR( TaskHandle_t xTask );</pre>\r
+ *\r
+ * Returns the pxHookFunction value assigned to the task xTask. Can\r
+ * be called from an interrupt service routine.\r
+ */\r
+ TaskHookFunction_t xTaskGetApplicationTaskTagFromISR( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;\r
#endif /* configUSE_APPLICATION_TASK_TAG ==1 */\r
#endif /* ifdef configUSE_APPLICATION_TASK_TAG */\r
\r
*/\r
void vTaskGetRunTimeStats( char *pcWriteBuffer ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
\r
+/**\r
+* task. h\r
+* <PRE>uint32_t ulTaskGetIdleRunTimeCounter( void );</PRE>\r
+*\r
+* configGENERATE_RUN_TIME_STATS and configUSE_STATS_FORMATTING_FUNCTIONS\r
+* must both be defined as 1 for this function to be available. The application\r
+* must also then provide definitions for\r
+* portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() and portGET_RUN_TIME_COUNTER_VALUE()\r
+* to configure a peripheral timer/counter and return the timers current count\r
+* value respectively. The counter should be at least 10 times the frequency of\r
+* the tick count.\r
+*\r
+* Setting configGENERATE_RUN_TIME_STATS to 1 will result in a total\r
+* accumulated execution time being stored for each task. The resolution\r
+* of the accumulated time value depends on the frequency of the timer\r
+* configured by the portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() macro.\r
+* While uxTaskGetSystemState() and vTaskGetRunTimeStats() writes the total\r
+* execution time of each task into a buffer, ulTaskGetIdleRunTimeCounter()\r
+* returns the total execution time of just the idle task.\r
+*\r
+* @return The total run time of the idle task. This is the amount of time the\r
+* idle task has actually been executing. The unit of time is dependent on the\r
+* frequency configured using the portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() and\r
+* portGET_RUN_TIME_COUNTER_VALUE() macros.\r
+*\r
+* \defgroup ulTaskGetIdleRunTimeCounter ulTaskGetIdleRunTimeCounter\r
+* \ingroup TaskUtils\r
+*/\r
+uint32_t ulTaskGetIdleRunTimeCounter( void ) PRIVILEGED_FUNCTION;\r
+\r
/**\r
* task. h\r
* <PRE>BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction );</PRE>\r
*/\r
BaseType_t xTaskNotifyStateClear( TaskHandle_t xTask );\r
\r
+/**\r
+* task. h\r
+* <PRE>uint32_t ulTaskNotifyValueClear( TaskHandle_t xTask, uint32_t ulBitsToClear );</pre>\r
+*\r
+* Clears the bits specified by the ulBitsToClear bit mask in the notification\r
+* value of the task referenced by xTask.\r
+*\r
+* Set ulBitsToClear to 0xffffffff (UINT_MAX on 32-bit architectures) to clear\r
+* the notification value to 0. Set ulBitsToClear to 0 to query the task's\r
+* notification value without clearing any bits.\r
+*\r
+* @return The value of the target task's notification value before the bits\r
+* specified by ulBitsToClear were cleared.\r
+* \defgroup ulTaskNotifyValueClear ulTaskNotifyValueClear\r
+* \ingroup TaskNotifications\r
+*/\r
+uint32_t ulTaskNotifyValueClear( TaskHandle_t xTask, uint32_t ulBitsToClear ) PRIVILEGED_FUNCTION;\r
+\r
+/**\r
+ * task.h\r
+ * <pre>void vTaskSetTimeOutState( TimeOut_t * const pxTimeOut )</pre>\r
+ *\r
+ * Capture the current time for future use with xTaskCheckForTimeOut().\r
+ *\r
+ * @param pxTimeOut Pointer to a timeout object into which the current time\r
+ * is to be captured. The captured time includes the tick count and the number\r
+ * of times the tick count has overflowed since the system first booted.\r
+ * \defgroup vTaskSetTimeOutState vTaskSetTimeOutState\r
+ * \ingroup TaskCtrl\r
+ */\r
+void vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) PRIVILEGED_FUNCTION;\r
+\r
+/**\r
+ * task.h\r
+ * <pre>BaseType_t xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut, TickType_t * const pxTicksToWait );</pre>\r
+ *\r
+ * Determines if pxTicksToWait ticks has passed since a time was captured\r
+ * using a call to vTaskSetTimeOutState(). The captured time includes the tick\r
+ * count and the number of times the tick count has overflowed.\r
+ *\r
+ * @param pxTimeOut The time status as captured previously using\r
+ * vTaskSetTimeOutState. If the timeout has not yet occurred, it is updated\r
+ * to reflect the current time status.\r
+ * @param pxTicksToWait The number of ticks to check for timeout i.e. if\r
+ * pxTicksToWait ticks have passed since pxTimeOut was last updated (either by\r
+ * vTaskSetTimeOutState() or xTaskCheckForTimeOut()), the timeout has occurred.\r
+ * If the timeout has not occurred, pxTIcksToWait is updated to reflect the\r
+ * number of remaining ticks.\r
+ *\r
+ * @return If timeout has occurred, pdTRUE is returned. Otherwise pdFALSE is\r
+ * returned and pxTicksToWait is updated to reflect the number of remaining\r
+ * ticks.\r
+ *\r
+ * @see https://www.freertos.org/xTaskCheckForTimeOut.html\r
+ *\r
+ * Example Usage:\r
+ * <pre>\r
+ // Driver library function used to receive uxWantedBytes from an Rx buffer\r
+ // that is filled by a UART interrupt. If there are not enough bytes in the\r
+ // Rx buffer then the task enters the Blocked state until it is notified that\r
+ // more data has been placed into the buffer. If there is still not enough\r
+ // data then the task re-enters the Blocked state, and xTaskCheckForTimeOut()\r
+ // is used to re-calculate the Block time to ensure the total amount of time\r
+ // spent in the Blocked state does not exceed MAX_TIME_TO_WAIT. This\r
+ // continues until either the buffer contains at least uxWantedBytes bytes,\r
+ // or the total amount of time spent in the Blocked state reaches\r
+ // MAX_TIME_TO_WAIT – at which point the task reads however many bytes are\r
+ // available up to a maximum of uxWantedBytes.\r
+\r
+ size_t xUART_Receive( uint8_t *pucBuffer, size_t uxWantedBytes )\r
+ {\r
+ size_t uxReceived = 0;\r
+ TickType_t xTicksToWait = MAX_TIME_TO_WAIT;\r
+ TimeOut_t xTimeOut;\r
+\r
+ // Initialize xTimeOut. This records the time at which this function\r
+ // was entered.\r
+ vTaskSetTimeOutState( &xTimeOut );\r
+\r
+ // Loop until the buffer contains the wanted number of bytes, or a\r
+ // timeout occurs.\r
+ while( UART_bytes_in_rx_buffer( pxUARTInstance ) < uxWantedBytes )\r
+ {\r
+ // The buffer didn't contain enough data so this task is going to\r
+ // enter the Blocked state. Adjusting xTicksToWait to account for\r
+ // any time that has been spent in the Blocked state within this\r
+ // function so far to ensure the total amount of time spent in the\r
+ // Blocked state does not exceed MAX_TIME_TO_WAIT.\r
+ if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) != pdFALSE )\r
+ {\r
+ //Timed out before the wanted number of bytes were available,\r
+ // exit the loop.\r
+ break;\r
+ }\r
+\r
+ // Wait for a maximum of xTicksToWait ticks to be notified that the\r
+ // receive interrupt has placed more data into the buffer.\r
+ ulTaskNotifyTake( pdTRUE, xTicksToWait );\r
+ }\r
+\r
+ // Attempt to read uxWantedBytes from the receive buffer into pucBuffer.\r
+ // The actual number of bytes read (which might be less than\r
+ // uxWantedBytes) is returned.\r
+ uxReceived = UART_read_from_receive_buffer( pxUARTInstance,\r
+ pucBuffer,\r
+ uxWantedBytes );\r
+\r
+ return uxReceived;\r
+ }\r
+ </pre>\r
+ * \defgroup xTaskCheckForTimeOut xTaskCheckForTimeOut\r
+ * \ingroup TaskCtrl\r
+ */\r
+BaseType_t xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut, TickType_t * const pxTicksToWait ) PRIVILEGED_FUNCTION;\r
+\r
/*-----------------------------------------------------------\r
* SCHEDULER INTERNALS AVAILABLE FOR PORTING PURPOSES\r
*----------------------------------------------------------*/\r
* indefinitely, whereas vTaskPlaceOnEventList() does.\r
*\r
*/\r
-void vTaskPlaceOnEventListRestricted( List_t * const pxEventList, const TickType_t xTicksToWait, const BaseType_t xWaitIndefinitely ) PRIVILEGED_FUNCTION;\r
+void vTaskPlaceOnEventListRestricted( List_t * const pxEventList, TickType_t xTicksToWait, const BaseType_t xWaitIndefinitely ) PRIVILEGED_FUNCTION;\r
\r
/*\r
* THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE. IT IS AN\r
* Removes a task from both the specified event list and the list of blocked\r
* tasks, and places it on a ready queue.\r
*\r
- * xTaskRemoveFromEventList()/xTaskRemoveFromUnorderedEventList() will be called\r
+ * xTaskRemoveFromEventList()/vTaskRemoveFromUnorderedEventList() will be called\r
* if either an event occurs to unblock a task, or the block timeout period\r
* expires.\r
*\r
* xTaskRemoveFromEventList() is used when the event list is in task priority\r
* order. It removes the list item from the head of the event list as that will\r
* have the highest priority owning task of all the tasks on the event list.\r
- * xTaskRemoveFromUnorderedEventList() is used when the event list is not\r
+ * vTaskRemoveFromUnorderedEventList() is used when the event list is not\r
* ordered and the event list items hold something other than the owning tasks\r
* priority. In this case the event list item value is updated to the value\r
* passed in the xItemValue parameter.\r
* making the call, otherwise pdFALSE.\r
*/\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
+void vTaskRemoveFromUnorderedEventList( 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
* Sets the pointer to the current TCB to the TCB of the highest priority task\r
* that is ready to run.\r
*/\r
-void vTaskSwitchContext( void ) PRIVILEGED_FUNCTION;\r
+portDONT_DISCARD void vTaskSwitchContext( void ) PRIVILEGED_FUNCTION;\r
\r
/*\r
* THESE FUNCTIONS MUST NOT BE USED FROM APPLICATION CODE. THEY ARE USED BY\r
*/\r
TaskHandle_t xTaskGetCurrentTaskHandle( void ) PRIVILEGED_FUNCTION;\r
\r
-/*\r
- * Capture the current time status for future reference.\r
- */\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
-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
* taskYIELD();\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( TaskHandle_t const pxMutexHolder ) PRIVILEGED_FUNCTION;\r
+BaseType_t xTaskPriorityInherit( 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
BaseType_t xTaskPriorityDisinherit( 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
+ * If a higher priority task attempting to obtain a mutex caused a lower\r
+ * priority task to inherit the higher priority task's priority - but the higher\r
+ * priority task then timed out without obtaining the mutex, then the lower\r
+ * priority task will disinherit the priority again - but only down as far as\r
+ * the highest priority task that is still waiting for the mutex (if there were\r
+ * more than one task waiting for the mutex).\r
*/\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, StaticTask_t * const pxTCBBuffer, const MemoryRegion_t * const xRegions ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
+void vTaskPriorityDisinheritAfterTimeout( TaskHandle_t const pxMutexHolder, UBaseType_t uxHighestPriorityWaitingTask ) PRIVILEGED_FUNCTION;\r
\r
/*\r
* Get the uxTCBNumber assigned to the task referenced by the xTask parameter.\r
*/\r
void vTaskStepTick( const TickType_t xTicksToJump ) PRIVILEGED_FUNCTION;\r
\r
+/* Correct the tick count value after the application code has held\r
+interrupts disabled for an extended period. xTicksToCatchUp is the number\r
+of tick interrupts that have been missed due to interrupts being disabled.\r
+Its value is not computed automatically, so must be computed by the\r
+application writer.\r
+\r
+This function is similar to vTaskStepTick(), however, unlike\r
+vTaskStepTick(), xTaskCatchUpTicks() may move the tick count forward past a\r
+time at which a task should be removed from the blocked state. That means\r
+tasks may have to be removed from the blocked state as the tick count is\r
+moved. */\r
+BaseType_t xTaskCatchUpTicks( TickType_t xTicksToCatchUp ) PRIVILEGED_FUNCTION;\r
+\r
/*\r
- * Only avilable when configUSE_TICKLESS_IDLE is set to 1.\r
+ * Only available when configUSE_TICKLESS_IDLE is set to 1.\r
* Provided for use within portSUPPRESS_TICKS_AND_SLEEP() to allow the port\r
* specific sleep function to determine if it is ok to proceed with the sleep,\r
* and if it is ok to proceed, if it is ok to sleep indefinitely.\r
* For internal use only. Increment the mutex held count when a mutex is\r
* taken and return the handle of the task that has taken the mutex.\r
*/\r
-void *pvTaskIncrementMutexHeldCount( void ) PRIVILEGED_FUNCTION;\r
+TaskHandle_t pvTaskIncrementMutexHeldCount( void ) PRIVILEGED_FUNCTION;\r
+\r
+/*\r
+ * For internal use only. Same as vTaskSetTimeOutState(), but without a critial\r
+ * section.\r
+ */\r
+void vTaskInternalSetTimeOutState( TimeOut_t * const pxTimeOut ) PRIVILEGED_FUNCTION;\r
+\r
\r
#ifdef __cplusplus\r
}\r
projects / freertos / blobdiff