David Fletcher / Mbed 2 deprecated cc3100_Test_mqtt_CM4F

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependencies:   mbed

FreeRTOS/source/include/task.h@0:1e7b5dd9edb4, 2015-09-03 (annotated)

Committer:
dflet
Date:
Thu Sep 03 14:07:01 2015 +0000
Revision:
0:1e7b5dd9edb4
First commit, it's been hanging around for a while. Updated SPI mode change 1 to 0.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
dflet 0:1e7b5dd9edb4 1 /*
dflet 0:1e7b5dd9edb4 2 FreeRTOS V8.2.1 - Copyright (C) 2015 Real Time Engineers Ltd.
dflet 0:1e7b5dd9edb4 3 All rights reserved
dflet 0:1e7b5dd9edb4 4
dflet 0:1e7b5dd9edb4 5 VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.
dflet 0:1e7b5dd9edb4 6
dflet 0:1e7b5dd9edb4 7 This file is part of the FreeRTOS distribution.
dflet 0:1e7b5dd9edb4 8
dflet 0:1e7b5dd9edb4 9 FreeRTOS is free software; you can redistribute it and/or modify it under
dflet 0:1e7b5dd9edb4 10 the terms of the GNU General Public License (version 2) as published by the
dflet 0:1e7b5dd9edb4 11 Free Software Foundation >>!AND MODIFIED BY!<< the FreeRTOS exception.
dflet 0:1e7b5dd9edb4 12
dflet 0:1e7b5dd9edb4 13 ***************************************************************************
dflet 0:1e7b5dd9edb4 14 >>! NOTE: The modification to the GPL is included to allow you to !<<
dflet 0:1e7b5dd9edb4 15 >>! distribute a combined work that includes FreeRTOS without being !<<
dflet 0:1e7b5dd9edb4 16 >>! obliged to provide the source code for proprietary components !<<
dflet 0:1e7b5dd9edb4 17 >>! outside of the FreeRTOS kernel. !<<
dflet 0:1e7b5dd9edb4 18 ***************************************************************************
dflet 0:1e7b5dd9edb4 19
dflet 0:1e7b5dd9edb4 20 FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY
dflet 0:1e7b5dd9edb4 21 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
dflet 0:1e7b5dd9edb4 22 FOR A PARTICULAR PURPOSE. Full license text is available on the following
dflet 0:1e7b5dd9edb4 23 link: http://www.freertos.org/a00114.html
dflet 0:1e7b5dd9edb4 24
dflet 0:1e7b5dd9edb4 25 ***************************************************************************
dflet 0:1e7b5dd9edb4 26 * *
dflet 0:1e7b5dd9edb4 27 * FreeRTOS provides completely free yet professionally developed, *
dflet 0:1e7b5dd9edb4 28 * robust, strictly quality controlled, supported, and cross *
dflet 0:1e7b5dd9edb4 29 * platform software that is more than just the market leader, it *
dflet 0:1e7b5dd9edb4 30 * is the industry's de facto standard. *
dflet 0:1e7b5dd9edb4 31 * *
dflet 0:1e7b5dd9edb4 32 * Help yourself get started quickly while simultaneously helping *
dflet 0:1e7b5dd9edb4 33 * to support the FreeRTOS project by purchasing a FreeRTOS *
dflet 0:1e7b5dd9edb4 34 * tutorial book, reference manual, or both: *
dflet 0:1e7b5dd9edb4 35 * http://www.FreeRTOS.org/Documentation *
dflet 0:1e7b5dd9edb4 36 * *
dflet 0:1e7b5dd9edb4 37 ***************************************************************************
dflet 0:1e7b5dd9edb4 38
dflet 0:1e7b5dd9edb4 39 http://www.FreeRTOS.org/FAQHelp.html - Having a problem? Start by reading
dflet 0:1e7b5dd9edb4 40 the FAQ page "My application does not run, what could be wrong?". Have you
dflet 0:1e7b5dd9edb4 41 defined configASSERT()?
dflet 0:1e7b5dd9edb4 42
dflet 0:1e7b5dd9edb4 43 http://www.FreeRTOS.org/support - In return for receiving this top quality
dflet 0:1e7b5dd9edb4 44 embedded software for free we request you assist our global community by
dflet 0:1e7b5dd9edb4 45 participating in the support forum.
dflet 0:1e7b5dd9edb4 46
dflet 0:1e7b5dd9edb4 47 http://www.FreeRTOS.org/training - Investing in training allows your team to
dflet 0:1e7b5dd9edb4 48 be as productive as possible as early as possible. Now you can receive
dflet 0:1e7b5dd9edb4 49 FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers
dflet 0:1e7b5dd9edb4 50 Ltd, and the world's leading authority on the world's leading RTOS.
dflet 0:1e7b5dd9edb4 51
dflet 0:1e7b5dd9edb4 52 http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,
dflet 0:1e7b5dd9edb4 53 including FreeRTOS+Trace - an indispensable productivity tool, a DOS
dflet 0:1e7b5dd9edb4 54 compatible FAT file system, and our tiny thread aware UDP/IP stack.
dflet 0:1e7b5dd9edb4 55
dflet 0:1e7b5dd9edb4 56 http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.
dflet 0:1e7b5dd9edb4 57 Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.
dflet 0:1e7b5dd9edb4 58
dflet 0:1e7b5dd9edb4 59 http://www.OpenRTOS.com - Real Time Engineers ltd. license FreeRTOS to High
dflet 0:1e7b5dd9edb4 60 Integrity Systems ltd. to sell under the OpenRTOS brand. Low cost OpenRTOS
dflet 0:1e7b5dd9edb4 61 licenses offer ticketed support, indemnification and commercial middleware.
dflet 0:1e7b5dd9edb4 62
dflet 0:1e7b5dd9edb4 63 http://www.SafeRTOS.com - High Integrity Systems also provide a safety
dflet 0:1e7b5dd9edb4 64 engineered and independently SIL3 certified version for use in safety and
dflet 0:1e7b5dd9edb4 65 mission critical applications that require provable dependability.
dflet 0:1e7b5dd9edb4 66
dflet 0:1e7b5dd9edb4 67 1 tab == 4 spaces!
dflet 0:1e7b5dd9edb4 68 */
dflet 0:1e7b5dd9edb4 69
dflet 0:1e7b5dd9edb4 70
dflet 0:1e7b5dd9edb4 71 #ifndef INC_TASK_H
dflet 0:1e7b5dd9edb4 72 #define INC_TASK_H
dflet 0:1e7b5dd9edb4 73
dflet 0:1e7b5dd9edb4 74 #ifndef INC_FREERTOS_H
dflet 0:1e7b5dd9edb4 75 #error "include FreeRTOS.h must appear in source files before include task.h"
dflet 0:1e7b5dd9edb4 76 #endif
dflet 0:1e7b5dd9edb4 77
dflet 0:1e7b5dd9edb4 78 #include "list.h"
dflet 0:1e7b5dd9edb4 79
dflet 0:1e7b5dd9edb4 80 #ifdef __cplusplus
dflet 0:1e7b5dd9edb4 81 extern "C" {
dflet 0:1e7b5dd9edb4 82 #endif
dflet 0:1e7b5dd9edb4 83
dflet 0:1e7b5dd9edb4 84 /*-----------------------------------------------------------
dflet 0:1e7b5dd9edb4 85 * MACROS AND DEFINITIONS
dflet 0:1e7b5dd9edb4 86 *----------------------------------------------------------*/
dflet 0:1e7b5dd9edb4 87
dflet 0:1e7b5dd9edb4 88 #define tskKERNEL_VERSION_NUMBER "V8.2.1"
dflet 0:1e7b5dd9edb4 89 #define tskKERNEL_VERSION_MAJOR 8
dflet 0:1e7b5dd9edb4 90 #define tskKERNEL_VERSION_MINOR 2
dflet 0:1e7b5dd9edb4 91 #define tskKERNEL_VERSION_BUILD 1
dflet 0:1e7b5dd9edb4 92
dflet 0:1e7b5dd9edb4 93 /**
dflet 0:1e7b5dd9edb4 94 * task. h
dflet 0:1e7b5dd9edb4 95 *
dflet 0:1e7b5dd9edb4 96 * Type by which tasks are referenced. For example, a call to xTaskCreate
dflet 0:1e7b5dd9edb4 97 * returns (via a pointer parameter) an TaskHandle_t variable that can then
dflet 0:1e7b5dd9edb4 98 * be used as a parameter to vTaskDelete to delete the task.
dflet 0:1e7b5dd9edb4 99 *
dflet 0:1e7b5dd9edb4 100 * \defgroup TaskHandle_t TaskHandle_t
dflet 0:1e7b5dd9edb4 101 * \ingroup Tasks
dflet 0:1e7b5dd9edb4 102 */
dflet 0:1e7b5dd9edb4 103 typedef void * TaskHandle_t;
dflet 0:1e7b5dd9edb4 104
dflet 0:1e7b5dd9edb4 105 /*
dflet 0:1e7b5dd9edb4 106 * Defines the prototype to which the application task hook function must
dflet 0:1e7b5dd9edb4 107 * conform.
dflet 0:1e7b5dd9edb4 108 */
dflet 0:1e7b5dd9edb4 109 typedef BaseType_t (*TaskHookFunction_t)( void * );
dflet 0:1e7b5dd9edb4 110
dflet 0:1e7b5dd9edb4 111 /* Task states returned by eTaskGetState. */
dflet 0:1e7b5dd9edb4 112 typedef enum
dflet 0:1e7b5dd9edb4 113 {
dflet 0:1e7b5dd9edb4 114 eRunning = 0, /* A task is querying the state of itself, so must be running. */
dflet 0:1e7b5dd9edb4 115 eReady, /* The task being queried is in a read or pending ready list. */
dflet 0:1e7b5dd9edb4 116 eBlocked, /* The task being queried is in the Blocked state. */
dflet 0:1e7b5dd9edb4 117 eSuspended, /* The task being queried is in the Suspended state, or is in the Blocked state with an infinite time out. */
dflet 0:1e7b5dd9edb4 118 eDeleted /* The task being queried has been deleted, but its TCB has not yet been freed. */
dflet 0:1e7b5dd9edb4 119 } eTaskState;
dflet 0:1e7b5dd9edb4 120
dflet 0:1e7b5dd9edb4 121 /* Actions that can be performed when vTaskNotify() is called. */
dflet 0:1e7b5dd9edb4 122 typedef enum
dflet 0:1e7b5dd9edb4 123 {
dflet 0:1e7b5dd9edb4 124 eNoAction = 0, /* Notify the task without updating its notify value. */
dflet 0:1e7b5dd9edb4 125 eSetBits, /* Set bits in the task's notification value. */
dflet 0:1e7b5dd9edb4 126 eIncrement, /* Increment the task's notification value. */
dflet 0:1e7b5dd9edb4 127 eSetValueWithOverwrite, /* Set the task's notification value to a specific value even if the previous value has not yet been read by the task. */
dflet 0:1e7b5dd9edb4 128 eSetValueWithoutOverwrite /* Set the task's notification value if the previous value has been read by the task. */
dflet 0:1e7b5dd9edb4 129 } eNotifyAction;
dflet 0:1e7b5dd9edb4 130
dflet 0:1e7b5dd9edb4 131 /*
dflet 0:1e7b5dd9edb4 132 * Used internally only.
dflet 0:1e7b5dd9edb4 133 */
dflet 0:1e7b5dd9edb4 134 typedef struct xTIME_OUT
dflet 0:1e7b5dd9edb4 135 {
dflet 0:1e7b5dd9edb4 136 BaseType_t xOverflowCount;
dflet 0:1e7b5dd9edb4 137 TickType_t xTimeOnEntering;
dflet 0:1e7b5dd9edb4 138 } TimeOut_t;
dflet 0:1e7b5dd9edb4 139
dflet 0:1e7b5dd9edb4 140 /*
dflet 0:1e7b5dd9edb4 141 * Defines the memory ranges allocated to the task when an MPU is used.
dflet 0:1e7b5dd9edb4 142 */
dflet 0:1e7b5dd9edb4 143 typedef struct xMEMORY_REGION
dflet 0:1e7b5dd9edb4 144 {
dflet 0:1e7b5dd9edb4 145 void *pvBaseAddress;
dflet 0:1e7b5dd9edb4 146 uint32_t ulLengthInBytes;
dflet 0:1e7b5dd9edb4 147 uint32_t ulParameters;
dflet 0:1e7b5dd9edb4 148 } MemoryRegion_t;
dflet 0:1e7b5dd9edb4 149
dflet 0:1e7b5dd9edb4 150 /*
dflet 0:1e7b5dd9edb4 151 * Parameters required to create an MPU protected task.
dflet 0:1e7b5dd9edb4 152 */
dflet 0:1e7b5dd9edb4 153 typedef struct xTASK_PARAMETERS
dflet 0:1e7b5dd9edb4 154 {
dflet 0:1e7b5dd9edb4 155 TaskFunction_t pvTaskCode;
dflet 0:1e7b5dd9edb4 156 const char * const pcName; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
dflet 0:1e7b5dd9edb4 157 uint16_t usStackDepth;
dflet 0:1e7b5dd9edb4 158 void *pvParameters;
dflet 0:1e7b5dd9edb4 159 UBaseType_t uxPriority;
dflet 0:1e7b5dd9edb4 160 StackType_t *puxStackBuffer;
dflet 0:1e7b5dd9edb4 161 MemoryRegion_t xRegions[ portNUM_CONFIGURABLE_REGIONS ];
dflet 0:1e7b5dd9edb4 162 } TaskParameters_t;
dflet 0:1e7b5dd9edb4 163
dflet 0:1e7b5dd9edb4 164 /* Used with the uxTaskGetSystemState() function to return the state of each task
dflet 0:1e7b5dd9edb4 165 in the system. */
dflet 0:1e7b5dd9edb4 166 typedef struct xTASK_STATUS
dflet 0:1e7b5dd9edb4 167 {
dflet 0:1e7b5dd9edb4 168 TaskHandle_t xHandle; /* The handle of the task to which the rest of the information in the structure relates. */
dflet 0:1e7b5dd9edb4 169 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. */
dflet 0:1e7b5dd9edb4 170 UBaseType_t xTaskNumber; /* A number unique to the task. */
dflet 0:1e7b5dd9edb4 171 eTaskState eCurrentState; /* The state in which the task existed when the structure was populated. */
dflet 0:1e7b5dd9edb4 172 UBaseType_t uxCurrentPriority; /* The priority at which the task was running (may be inherited) when the structure was populated. */
dflet 0:1e7b5dd9edb4 173 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. */
dflet 0:1e7b5dd9edb4 174 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. */
dflet 0:1e7b5dd9edb4 175 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. */
dflet 0:1e7b5dd9edb4 176 } TaskStatus_t;
dflet 0:1e7b5dd9edb4 177
dflet 0:1e7b5dd9edb4 178 /* Possible return values for eTaskConfirmSleepModeStatus(). */
dflet 0:1e7b5dd9edb4 179 typedef enum
dflet 0:1e7b5dd9edb4 180 {
dflet 0:1e7b5dd9edb4 181 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. */
dflet 0:1e7b5dd9edb4 182 eStandardSleep, /* Enter a sleep mode that will not last any longer than the expected idle time. */
dflet 0:1e7b5dd9edb4 183 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. */
dflet 0:1e7b5dd9edb4 184 } eSleepModeStatus;
dflet 0:1e7b5dd9edb4 185
dflet 0:1e7b5dd9edb4 186
dflet 0:1e7b5dd9edb4 187 /**
dflet 0:1e7b5dd9edb4 188 * Defines the priority used by the idle task. This must not be modified.
dflet 0:1e7b5dd9edb4 189 *
dflet 0:1e7b5dd9edb4 190 * \ingroup TaskUtils
dflet 0:1e7b5dd9edb4 191 */
dflet 0:1e7b5dd9edb4 192 #define tskIDLE_PRIORITY ( ( UBaseType_t ) 0U )
dflet 0:1e7b5dd9edb4 193
dflet 0:1e7b5dd9edb4 194 /**
dflet 0:1e7b5dd9edb4 195 * task. h
dflet 0:1e7b5dd9edb4 196 *
dflet 0:1e7b5dd9edb4 197 * Macro for forcing a context switch.
dflet 0:1e7b5dd9edb4 198 *
dflet 0:1e7b5dd9edb4 199 * \defgroup taskYIELD taskYIELD
dflet 0:1e7b5dd9edb4 200 * \ingroup SchedulerControl
dflet 0:1e7b5dd9edb4 201 */
dflet 0:1e7b5dd9edb4 202 #define taskYIELD() portYIELD()
dflet 0:1e7b5dd9edb4 203
dflet 0:1e7b5dd9edb4 204 /**
dflet 0:1e7b5dd9edb4 205 * task. h
dflet 0:1e7b5dd9edb4 206 *
dflet 0:1e7b5dd9edb4 207 * Macro to mark the start of a critical code region. Preemptive context
dflet 0:1e7b5dd9edb4 208 * switches cannot occur when in a critical region.
dflet 0:1e7b5dd9edb4 209 *
dflet 0:1e7b5dd9edb4 210 * NOTE: This may alter the stack (depending on the portable implementation)
dflet 0:1e7b5dd9edb4 211 * so must be used with care!
dflet 0:1e7b5dd9edb4 212 *
dflet 0:1e7b5dd9edb4 213 * \defgroup taskENTER_CRITICAL taskENTER_CRITICAL
dflet 0:1e7b5dd9edb4 214 * \ingroup SchedulerControl
dflet 0:1e7b5dd9edb4 215 */
dflet 0:1e7b5dd9edb4 216 #define taskENTER_CRITICAL() portENTER_CRITICAL()
dflet 0:1e7b5dd9edb4 217 #define taskENTER_CRITICAL_FROM_ISR( x ) portSET_INTERRUPT_MASK_FROM_ISR( x )
dflet 0:1e7b5dd9edb4 218
dflet 0:1e7b5dd9edb4 219 /**
dflet 0:1e7b5dd9edb4 220 * task. h
dflet 0:1e7b5dd9edb4 221 *
dflet 0:1e7b5dd9edb4 222 * Macro to mark the end of a critical code region. Preemptive context
dflet 0:1e7b5dd9edb4 223 * switches cannot occur when in a critical region.
dflet 0:1e7b5dd9edb4 224 *
dflet 0:1e7b5dd9edb4 225 * NOTE: This may alter the stack (depending on the portable implementation)
dflet 0:1e7b5dd9edb4 226 * so must be used with care!
dflet 0:1e7b5dd9edb4 227 *
dflet 0:1e7b5dd9edb4 228 * \defgroup taskEXIT_CRITICAL taskEXIT_CRITICAL
dflet 0:1e7b5dd9edb4 229 * \ingroup SchedulerControl
dflet 0:1e7b5dd9edb4 230 */
dflet 0:1e7b5dd9edb4 231 #define taskEXIT_CRITICAL() portEXIT_CRITICAL()
dflet 0:1e7b5dd9edb4 232 #define taskEXIT_CRITICAL_FROM_ISR() portCLEAR_INTERRUPT_MASK_FROM_ISR()
dflet 0:1e7b5dd9edb4 233 /**
dflet 0:1e7b5dd9edb4 234 * task. h
dflet 0:1e7b5dd9edb4 235 *
dflet 0:1e7b5dd9edb4 236 * Macro to disable all maskable interrupts.
dflet 0:1e7b5dd9edb4 237 *
dflet 0:1e7b5dd9edb4 238 * \defgroup taskDISABLE_INTERRUPTS taskDISABLE_INTERRUPTS
dflet 0:1e7b5dd9edb4 239 * \ingroup SchedulerControl
dflet 0:1e7b5dd9edb4 240 */
dflet 0:1e7b5dd9edb4 241 #define taskDISABLE_INTERRUPTS() portDISABLE_INTERRUPTS()
dflet 0:1e7b5dd9edb4 242
dflet 0:1e7b5dd9edb4 243 /**
dflet 0:1e7b5dd9edb4 244 * task. h
dflet 0:1e7b5dd9edb4 245 *
dflet 0:1e7b5dd9edb4 246 * Macro to enable microcontroller interrupts.
dflet 0:1e7b5dd9edb4 247 *
dflet 0:1e7b5dd9edb4 248 * \defgroup taskENABLE_INTERRUPTS taskENABLE_INTERRUPTS
dflet 0:1e7b5dd9edb4 249 * \ingroup SchedulerControl
dflet 0:1e7b5dd9edb4 250 */
dflet 0:1e7b5dd9edb4 251 #define taskENABLE_INTERRUPTS() portENABLE_INTERRUPTS()
dflet 0:1e7b5dd9edb4 252
dflet 0:1e7b5dd9edb4 253 /* Definitions returned by xTaskGetSchedulerState(). taskSCHEDULER_SUSPENDED is
dflet 0:1e7b5dd9edb4 254 0 to generate more optimal code when configASSERT() is defined as the constant
dflet 0:1e7b5dd9edb4 255 is used in assert() statements. */
dflet 0:1e7b5dd9edb4 256 #define taskSCHEDULER_SUSPENDED ( ( BaseType_t ) 0 )
dflet 0:1e7b5dd9edb4 257 #define taskSCHEDULER_NOT_STARTED ( ( BaseType_t ) 1 )
dflet 0:1e7b5dd9edb4 258 #define taskSCHEDULER_RUNNING ( ( BaseType_t ) 2 )
dflet 0:1e7b5dd9edb4 259
dflet 0:1e7b5dd9edb4 260
dflet 0:1e7b5dd9edb4 261 /*-----------------------------------------------------------
dflet 0:1e7b5dd9edb4 262 * TASK CREATION API
dflet 0:1e7b5dd9edb4 263 *----------------------------------------------------------*/
dflet 0:1e7b5dd9edb4 264
dflet 0:1e7b5dd9edb4 265 /**
dflet 0:1e7b5dd9edb4 266 * task. h
dflet 0:1e7b5dd9edb4 267 *<pre>
dflet 0:1e7b5dd9edb4 268 BaseType_t xTaskCreate(
dflet 0:1e7b5dd9edb4 269 TaskFunction_t pvTaskCode,
dflet 0:1e7b5dd9edb4 270 const char * const pcName,
dflet 0:1e7b5dd9edb4 271 uint16_t usStackDepth,
dflet 0:1e7b5dd9edb4 272 void *pvParameters,
dflet 0:1e7b5dd9edb4 273 UBaseType_t uxPriority,
dflet 0:1e7b5dd9edb4 274 TaskHandle_t *pvCreatedTask
dflet 0:1e7b5dd9edb4 275 );</pre>
dflet 0:1e7b5dd9edb4 276 *
dflet 0:1e7b5dd9edb4 277 * Create a new task and add it to the list of tasks that are ready to run.
dflet 0:1e7b5dd9edb4 278 *
dflet 0:1e7b5dd9edb4 279 * xTaskCreate() can only be used to create a task that has unrestricted
dflet 0:1e7b5dd9edb4 280 * access to the entire microcontroller memory map. Systems that include MPU
dflet 0:1e7b5dd9edb4 281 * support can alternatively create an MPU constrained task using
dflet 0:1e7b5dd9edb4 282 * xTaskCreateRestricted().
dflet 0:1e7b5dd9edb4 283 *
dflet 0:1e7b5dd9edb4 284 * @param pvTaskCode Pointer to the task entry function. Tasks
dflet 0:1e7b5dd9edb4 285 * must be implemented to never return (i.e. continuous loop).
dflet 0:1e7b5dd9edb4 286 *
dflet 0:1e7b5dd9edb4 287 * @param pcName A descriptive name for the task. This is mainly used to
dflet 0:1e7b5dd9edb4 288 * facilitate debugging. Max length defined by configMAX_TASK_NAME_LEN - default
dflet 0:1e7b5dd9edb4 289 * is 16.
dflet 0:1e7b5dd9edb4 290 *
dflet 0:1e7b5dd9edb4 291 * @param usStackDepth The size of the task stack specified as the number of
dflet 0:1e7b5dd9edb4 292 * variables the stack can hold - not the number of bytes. For example, if
dflet 0:1e7b5dd9edb4 293 * the stack is 16 bits wide and usStackDepth is defined as 100, 200 bytes
dflet 0:1e7b5dd9edb4 294 * will be allocated for stack storage.
dflet 0:1e7b5dd9edb4 295 *
dflet 0:1e7b5dd9edb4 296 * @param pvParameters Pointer that will be used as the parameter for the task
dflet 0:1e7b5dd9edb4 297 * being created.
dflet 0:1e7b5dd9edb4 298 *
dflet 0:1e7b5dd9edb4 299 * @param uxPriority The priority at which the task should run. Systems that
dflet 0:1e7b5dd9edb4 300 * include MPU support can optionally create tasks in a privileged (system)
dflet 0:1e7b5dd9edb4 301 * mode by setting bit portPRIVILEGE_BIT of the priority parameter. For
dflet 0:1e7b5dd9edb4 302 * example, to create a privileged task at priority 2 the uxPriority parameter
dflet 0:1e7b5dd9edb4 303 * should be set to ( 2 | portPRIVILEGE_BIT ).
dflet 0:1e7b5dd9edb4 304 *
dflet 0:1e7b5dd9edb4 305 * @param pvCreatedTask Used to pass back a handle by which the created task
dflet 0:1e7b5dd9edb4 306 * can be referenced.
dflet 0:1e7b5dd9edb4 307 *
dflet 0:1e7b5dd9edb4 308 * @return pdPASS if the task was successfully created and added to a ready
dflet 0:1e7b5dd9edb4 309 * list, otherwise an error code defined in the file projdefs.h
dflet 0:1e7b5dd9edb4 310 *
dflet 0:1e7b5dd9edb4 311 * Example usage:
dflet 0:1e7b5dd9edb4 312 <pre>
dflet 0:1e7b5dd9edb4 313 // Task to be created.
dflet 0:1e7b5dd9edb4 314 void vTaskCode( void * pvParameters )
dflet 0:1e7b5dd9edb4 315 {
dflet 0:1e7b5dd9edb4 316 for( ;; )
dflet 0:1e7b5dd9edb4 317 {
dflet 0:1e7b5dd9edb4 318 // Task code goes here.
dflet 0:1e7b5dd9edb4 319 }
dflet 0:1e7b5dd9edb4 320 }
dflet 0:1e7b5dd9edb4 321
dflet 0:1e7b5dd9edb4 322 // Function that creates a task.
dflet 0:1e7b5dd9edb4 323 void vOtherFunction( void )
dflet 0:1e7b5dd9edb4 324 {
dflet 0:1e7b5dd9edb4 325 static uint8_t ucParameterToPass;
dflet 0:1e7b5dd9edb4 326 TaskHandle_t xHandle = NULL;
dflet 0:1e7b5dd9edb4 327
dflet 0:1e7b5dd9edb4 328 // Create the task, storing the handle. Note that the passed parameter ucParameterToPass
dflet 0:1e7b5dd9edb4 329 // must exist for the lifetime of the task, so in this case is declared static. If it was just an
dflet 0:1e7b5dd9edb4 330 // an automatic stack variable it might no longer exist, or at least have been corrupted, by the time
dflet 0:1e7b5dd9edb4 331 // the new task attempts to access it.
dflet 0:1e7b5dd9edb4 332 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, &ucParameterToPass, tskIDLE_PRIORITY, &xHandle );
dflet 0:1e7b5dd9edb4 333 configASSERT( xHandle );
dflet 0:1e7b5dd9edb4 334
dflet 0:1e7b5dd9edb4 335 // Use the handle to delete the task.
dflet 0:1e7b5dd9edb4 336 if( xHandle != NULL )
dflet 0:1e7b5dd9edb4 337 {
dflet 0:1e7b5dd9edb4 338 vTaskDelete( xHandle );
dflet 0:1e7b5dd9edb4 339 }
dflet 0:1e7b5dd9edb4 340 }
dflet 0:1e7b5dd9edb4 341 </pre>
dflet 0:1e7b5dd9edb4 342 * \defgroup xTaskCreate xTaskCreate
dflet 0:1e7b5dd9edb4 343 * \ingroup Tasks
dflet 0:1e7b5dd9edb4 344 */
dflet 0:1e7b5dd9edb4 345 #define xTaskCreate( pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask ) xTaskGenericCreate( ( pvTaskCode ), ( pcName ), ( usStackDepth ), ( pvParameters ), ( uxPriority ), ( pxCreatedTask ), ( NULL ), ( NULL ) )
dflet 0:1e7b5dd9edb4 346
dflet 0:1e7b5dd9edb4 347 /**
dflet 0:1e7b5dd9edb4 348 * task. h
dflet 0:1e7b5dd9edb4 349 *<pre>
dflet 0:1e7b5dd9edb4 350 BaseType_t xTaskCreateRestricted( TaskParameters_t *pxTaskDefinition, TaskHandle_t *pxCreatedTask );</pre>
dflet 0:1e7b5dd9edb4 351 *
dflet 0:1e7b5dd9edb4 352 * xTaskCreateRestricted() should only be used in systems that include an MPU
dflet 0:1e7b5dd9edb4 353 * implementation.
dflet 0:1e7b5dd9edb4 354 *
dflet 0:1e7b5dd9edb4 355 * Create a new task and add it to the list of tasks that are ready to run.
dflet 0:1e7b5dd9edb4 356 * The function parameters define the memory regions and associated access
dflet 0:1e7b5dd9edb4 357 * permissions allocated to the task.
dflet 0:1e7b5dd9edb4 358 *
dflet 0:1e7b5dd9edb4 359 * @param pxTaskDefinition Pointer to a structure that contains a member
dflet 0:1e7b5dd9edb4 360 * for each of the normal xTaskCreate() parameters (see the xTaskCreate() API
dflet 0:1e7b5dd9edb4 361 * documentation) plus an optional stack buffer and the memory region
dflet 0:1e7b5dd9edb4 362 * definitions.
dflet 0:1e7b5dd9edb4 363 *
dflet 0:1e7b5dd9edb4 364 * @param pxCreatedTask Used to pass back a handle by which the created task
dflet 0:1e7b5dd9edb4 365 * can be referenced.
dflet 0:1e7b5dd9edb4 366 *
dflet 0:1e7b5dd9edb4 367 * @return pdPASS if the task was successfully created and added to a ready
dflet 0:1e7b5dd9edb4 368 * list, otherwise an error code defined in the file projdefs.h
dflet 0:1e7b5dd9edb4 369 *
dflet 0:1e7b5dd9edb4 370 * Example usage:
dflet 0:1e7b5dd9edb4 371 <pre>
dflet 0:1e7b5dd9edb4 372 // Create an TaskParameters_t structure that defines the task to be created.
dflet 0:1e7b5dd9edb4 373 static const TaskParameters_t xCheckTaskParameters =
dflet 0:1e7b5dd9edb4 374 {
dflet 0:1e7b5dd9edb4 375 vATask, // pvTaskCode - the function that implements the task.
dflet 0:1e7b5dd9edb4 376 "ATask", // pcName - just a text name for the task to assist debugging.
dflet 0:1e7b5dd9edb4 377 100, // usStackDepth - the stack size DEFINED IN WORDS.
dflet 0:1e7b5dd9edb4 378 NULL, // pvParameters - passed into the task function as the function parameters.
dflet 0:1e7b5dd9edb4 379 ( 1UL | portPRIVILEGE_BIT ),// uxPriority - task priority, set the portPRIVILEGE_BIT if the task should run in a privileged state.
dflet 0:1e7b5dd9edb4 380 cStackBuffer,// puxStackBuffer - the buffer to be used as the task stack.
dflet 0:1e7b5dd9edb4 381
dflet 0:1e7b5dd9edb4 382 // xRegions - Allocate up to three separate memory regions for access by
dflet 0:1e7b5dd9edb4 383 // the task, with appropriate access permissions. Different processors have
dflet 0:1e7b5dd9edb4 384 // different memory alignment requirements - refer to the FreeRTOS documentation
dflet 0:1e7b5dd9edb4 385 // for full information.
dflet 0:1e7b5dd9edb4 386 {
dflet 0:1e7b5dd9edb4 387 // Base address Length Parameters
dflet 0:1e7b5dd9edb4 388 { cReadWriteArray, 32, portMPU_REGION_READ_WRITE },
dflet 0:1e7b5dd9edb4 389 { cReadOnlyArray, 32, portMPU_REGION_READ_ONLY },
dflet 0:1e7b5dd9edb4 390 { cPrivilegedOnlyAccessArray, 128, portMPU_REGION_PRIVILEGED_READ_WRITE }
dflet 0:1e7b5dd9edb4 391 }
dflet 0:1e7b5dd9edb4 392 };
dflet 0:1e7b5dd9edb4 393
dflet 0:1e7b5dd9edb4 394 int main( void )
dflet 0:1e7b5dd9edb4 395 {
dflet 0:1e7b5dd9edb4 396 TaskHandle_t xHandle;
dflet 0:1e7b5dd9edb4 397
dflet 0:1e7b5dd9edb4 398 // Create a task from the const structure defined above. The task handle
dflet 0:1e7b5dd9edb4 399 // is requested (the second parameter is not NULL) but in this case just for
dflet 0:1e7b5dd9edb4 400 // demonstration purposes as its not actually used.
dflet 0:1e7b5dd9edb4 401 xTaskCreateRestricted( &xRegTest1Parameters, &xHandle );
dflet 0:1e7b5dd9edb4 402
dflet 0:1e7b5dd9edb4 403 // Start the scheduler.
dflet 0:1e7b5dd9edb4 404 vTaskStartScheduler();
dflet 0:1e7b5dd9edb4 405
dflet 0:1e7b5dd9edb4 406 // Will only get here if there was insufficient memory to create the idle
dflet 0:1e7b5dd9edb4 407 // and/or timer task.
dflet 0:1e7b5dd9edb4 408 for( ;; );
dflet 0:1e7b5dd9edb4 409 }
dflet 0:1e7b5dd9edb4 410 </pre>
dflet 0:1e7b5dd9edb4 411 * \defgroup xTaskCreateRestricted xTaskCreateRestricted
dflet 0:1e7b5dd9edb4 412 * \ingroup Tasks
dflet 0:1e7b5dd9edb4 413 */
dflet 0:1e7b5dd9edb4 414 #define xTaskCreateRestricted( x, pxCreatedTask ) xTaskGenericCreate( ((x)->pvTaskCode), ((x)->pcName), ((x)->usStackDepth), ((x)->pvParameters), ((x)->uxPriority), (pxCreatedTask), ((x)->puxStackBuffer), ((x)->xRegions) )
dflet 0:1e7b5dd9edb4 415
dflet 0:1e7b5dd9edb4 416 /**
dflet 0:1e7b5dd9edb4 417 * task. h
dflet 0:1e7b5dd9edb4 418 *<pre>
dflet 0:1e7b5dd9edb4 419 void vTaskAllocateMPURegions( TaskHandle_t xTask, const MemoryRegion_t * const pxRegions );</pre>
dflet 0:1e7b5dd9edb4 420 *
dflet 0:1e7b5dd9edb4 421 * Memory regions are assigned to a restricted task when the task is created by
dflet 0:1e7b5dd9edb4 422 * a call to xTaskCreateRestricted(). These regions can be redefined using
dflet 0:1e7b5dd9edb4 423 * vTaskAllocateMPURegions().
dflet 0:1e7b5dd9edb4 424 *
dflet 0:1e7b5dd9edb4 425 * @param xTask The handle of the task being updated.
dflet 0:1e7b5dd9edb4 426 *
dflet 0:1e7b5dd9edb4 427 * @param xRegions A pointer to an MemoryRegion_t structure that contains the
dflet 0:1e7b5dd9edb4 428 * new memory region definitions.
dflet 0:1e7b5dd9edb4 429 *
dflet 0:1e7b5dd9edb4 430 * Example usage:
dflet 0:1e7b5dd9edb4 431 <pre>
dflet 0:1e7b5dd9edb4 432 // Define an array of MemoryRegion_t structures that configures an MPU region
dflet 0:1e7b5dd9edb4 433 // allowing read/write access for 1024 bytes starting at the beginning of the
dflet 0:1e7b5dd9edb4 434 // ucOneKByte array. The other two of the maximum 3 definable regions are
dflet 0:1e7b5dd9edb4 435 // unused so set to zero.
dflet 0:1e7b5dd9edb4 436 static const MemoryRegion_t xAltRegions[ portNUM_CONFIGURABLE_REGIONS ] =
dflet 0:1e7b5dd9edb4 437 {
dflet 0:1e7b5dd9edb4 438 // Base address Length Parameters
dflet 0:1e7b5dd9edb4 439 { ucOneKByte, 1024, portMPU_REGION_READ_WRITE },
dflet 0:1e7b5dd9edb4 440 { 0, 0, 0 },
dflet 0:1e7b5dd9edb4 441 { 0, 0, 0 }
dflet 0:1e7b5dd9edb4 442 };
dflet 0:1e7b5dd9edb4 443
dflet 0:1e7b5dd9edb4 444 void vATask( void *pvParameters )
dflet 0:1e7b5dd9edb4 445 {
dflet 0:1e7b5dd9edb4 446 // This task was created such that it has access to certain regions of
dflet 0:1e7b5dd9edb4 447 // memory as defined by the MPU configuration. At some point it is
dflet 0:1e7b5dd9edb4 448 // desired that these MPU regions are replaced with that defined in the
dflet 0:1e7b5dd9edb4 449 // xAltRegions const struct above. Use a call to vTaskAllocateMPURegions()
dflet 0:1e7b5dd9edb4 450 // for this purpose. NULL is used as the task handle to indicate that this
dflet 0:1e7b5dd9edb4 451 // function should modify the MPU regions of the calling task.
dflet 0:1e7b5dd9edb4 452 vTaskAllocateMPURegions( NULL, xAltRegions );
dflet 0:1e7b5dd9edb4 453
dflet 0:1e7b5dd9edb4 454 // Now the task can continue its function, but from this point on can only
dflet 0:1e7b5dd9edb4 455 // access its stack and the ucOneKByte array (unless any other statically
dflet 0:1e7b5dd9edb4 456 // defined or shared regions have been declared elsewhere).
dflet 0:1e7b5dd9edb4 457 }
dflet 0:1e7b5dd9edb4 458 </pre>
dflet 0:1e7b5dd9edb4 459 * \defgroup xTaskCreateRestricted xTaskCreateRestricted
dflet 0:1e7b5dd9edb4 460 * \ingroup Tasks
dflet 0:1e7b5dd9edb4 461 */
dflet 0:1e7b5dd9edb4 462 void vTaskAllocateMPURegions( TaskHandle_t xTask, const MemoryRegion_t * const pxRegions ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 463
dflet 0:1e7b5dd9edb4 464 /**
dflet 0:1e7b5dd9edb4 465 * task. h
dflet 0:1e7b5dd9edb4 466 * <pre>void vTaskDelete( TaskHandle_t xTask );</pre>
dflet 0:1e7b5dd9edb4 467 *
dflet 0:1e7b5dd9edb4 468 * INCLUDE_vTaskDelete must be defined as 1 for this function to be available.
dflet 0:1e7b5dd9edb4 469 * See the configuration section for more information.
dflet 0:1e7b5dd9edb4 470 *
dflet 0:1e7b5dd9edb4 471 * Remove a task from the RTOS real time kernel's management. The task being
dflet 0:1e7b5dd9edb4 472 * deleted will be removed from all ready, blocked, suspended and event lists.
dflet 0:1e7b5dd9edb4 473 *
dflet 0:1e7b5dd9edb4 474 * NOTE: The idle task is responsible for freeing the kernel allocated
dflet 0:1e7b5dd9edb4 475 * memory from tasks that have been deleted. It is therefore important that
dflet 0:1e7b5dd9edb4 476 * the idle task is not starved of microcontroller processing time if your
dflet 0:1e7b5dd9edb4 477 * application makes any calls to vTaskDelete (). Memory allocated by the
dflet 0:1e7b5dd9edb4 478 * task code is not automatically freed, and should be freed before the task
dflet 0:1e7b5dd9edb4 479 * is deleted.
dflet 0:1e7b5dd9edb4 480 *
dflet 0:1e7b5dd9edb4 481 * See the demo application file death.c for sample code that utilises
dflet 0:1e7b5dd9edb4 482 * vTaskDelete ().
dflet 0:1e7b5dd9edb4 483 *
dflet 0:1e7b5dd9edb4 484 * @param xTask The handle of the task to be deleted. Passing NULL will
dflet 0:1e7b5dd9edb4 485 * cause the calling task to be deleted.
dflet 0:1e7b5dd9edb4 486 *
dflet 0:1e7b5dd9edb4 487 * Example usage:
dflet 0:1e7b5dd9edb4 488 <pre>
dflet 0:1e7b5dd9edb4 489 void vOtherFunction( void )
dflet 0:1e7b5dd9edb4 490 {
dflet 0:1e7b5dd9edb4 491 TaskHandle_t xHandle;
dflet 0:1e7b5dd9edb4 492
dflet 0:1e7b5dd9edb4 493 // Create the task, storing the handle.
dflet 0:1e7b5dd9edb4 494 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
dflet 0:1e7b5dd9edb4 495
dflet 0:1e7b5dd9edb4 496 // Use the handle to delete the task.
dflet 0:1e7b5dd9edb4 497 vTaskDelete( xHandle );
dflet 0:1e7b5dd9edb4 498 }
dflet 0:1e7b5dd9edb4 499 </pre>
dflet 0:1e7b5dd9edb4 500 * \defgroup vTaskDelete vTaskDelete
dflet 0:1e7b5dd9edb4 501 * \ingroup Tasks
dflet 0:1e7b5dd9edb4 502 */
dflet 0:1e7b5dd9edb4 503 void vTaskDelete( TaskHandle_t xTaskToDelete ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 504
dflet 0:1e7b5dd9edb4 505 /*-----------------------------------------------------------
dflet 0:1e7b5dd9edb4 506 * TASK CONTROL API
dflet 0:1e7b5dd9edb4 507 *----------------------------------------------------------*/
dflet 0:1e7b5dd9edb4 508
dflet 0:1e7b5dd9edb4 509 /**
dflet 0:1e7b5dd9edb4 510 * task. h
dflet 0:1e7b5dd9edb4 511 * <pre>void vTaskDelay( const TickType_t xTicksToDelay );</pre>
dflet 0:1e7b5dd9edb4 512 *
dflet 0:1e7b5dd9edb4 513 * Delay a task for a given number of ticks. The actual time that the
dflet 0:1e7b5dd9edb4 514 * task remains blocked depends on the tick rate. The constant
dflet 0:1e7b5dd9edb4 515 * portTICK_PERIOD_MS can be used to calculate real time from the tick
dflet 0:1e7b5dd9edb4 516 * rate - with the resolution of one tick period.
dflet 0:1e7b5dd9edb4 517 *
dflet 0:1e7b5dd9edb4 518 * INCLUDE_vTaskDelay must be defined as 1 for this function to be available.
dflet 0:1e7b5dd9edb4 519 * See the configuration section for more information.
dflet 0:1e7b5dd9edb4 520 *
dflet 0:1e7b5dd9edb4 521 *
dflet 0:1e7b5dd9edb4 522 * vTaskDelay() specifies a time at which the task wishes to unblock relative to
dflet 0:1e7b5dd9edb4 523 * the time at which vTaskDelay() is called. For example, specifying a block
dflet 0:1e7b5dd9edb4 524 * period of 100 ticks will cause the task to unblock 100 ticks after
dflet 0:1e7b5dd9edb4 525 * vTaskDelay() is called. vTaskDelay() does not therefore provide a good method
dflet 0:1e7b5dd9edb4 526 * of controlling the frequency of a periodic task as the path taken through the
dflet 0:1e7b5dd9edb4 527 * code, as well as other task and interrupt activity, will effect the frequency
dflet 0:1e7b5dd9edb4 528 * at which vTaskDelay() gets called and therefore the time at which the task
dflet 0:1e7b5dd9edb4 529 * next executes. See vTaskDelayUntil() for an alternative API function designed
dflet 0:1e7b5dd9edb4 530 * to facilitate fixed frequency execution. It does this by specifying an
dflet 0:1e7b5dd9edb4 531 * absolute time (rather than a relative time) at which the calling task should
dflet 0:1e7b5dd9edb4 532 * unblock.
dflet 0:1e7b5dd9edb4 533 *
dflet 0:1e7b5dd9edb4 534 * @param xTicksToDelay The amount of time, in tick periods, that
dflet 0:1e7b5dd9edb4 535 * the calling task should block.
dflet 0:1e7b5dd9edb4 536 *
dflet 0:1e7b5dd9edb4 537 * Example usage:
dflet 0:1e7b5dd9edb4 538
dflet 0:1e7b5dd9edb4 539 void vTaskFunction( void * pvParameters )
dflet 0:1e7b5dd9edb4 540 {
dflet 0:1e7b5dd9edb4 541 // Block for 500ms.
dflet 0:1e7b5dd9edb4 542 const TickType_t xDelay = 500 / portTICK_PERIOD_MS;
dflet 0:1e7b5dd9edb4 543
dflet 0:1e7b5dd9edb4 544 for( ;; )
dflet 0:1e7b5dd9edb4 545 {
dflet 0:1e7b5dd9edb4 546 // Simply toggle the LED every 500ms, blocking between each toggle.
dflet 0:1e7b5dd9edb4 547 vToggleLED();
dflet 0:1e7b5dd9edb4 548 vTaskDelay( xDelay );
dflet 0:1e7b5dd9edb4 549 }
dflet 0:1e7b5dd9edb4 550 }
dflet 0:1e7b5dd9edb4 551
dflet 0:1e7b5dd9edb4 552 * \defgroup vTaskDelay vTaskDelay
dflet 0:1e7b5dd9edb4 553 * \ingroup TaskCtrl
dflet 0:1e7b5dd9edb4 554 */
dflet 0:1e7b5dd9edb4 555 void vTaskDelay( const TickType_t xTicksToDelay ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 556
dflet 0:1e7b5dd9edb4 557 /**
dflet 0:1e7b5dd9edb4 558 * task. h
dflet 0:1e7b5dd9edb4 559 * <pre>void vTaskDelayUntil( TickType_t *pxPreviousWakeTime, const TickType_t xTimeIncrement );</pre>
dflet 0:1e7b5dd9edb4 560 *
dflet 0:1e7b5dd9edb4 561 * INCLUDE_vTaskDelayUntil must be defined as 1 for this function to be available.
dflet 0:1e7b5dd9edb4 562 * See the configuration section for more information.
dflet 0:1e7b5dd9edb4 563 *
dflet 0:1e7b5dd9edb4 564 * Delay a task until a specified time. This function can be used by periodic
dflet 0:1e7b5dd9edb4 565 * tasks to ensure a constant execution frequency.
dflet 0:1e7b5dd9edb4 566 *
dflet 0:1e7b5dd9edb4 567 * This function differs from vTaskDelay () in one important aspect: vTaskDelay () will
dflet 0:1e7b5dd9edb4 568 * cause a task to block for the specified number of ticks from the time vTaskDelay () is
dflet 0:1e7b5dd9edb4 569 * called. It is therefore difficult to use vTaskDelay () by itself to generate a fixed
dflet 0:1e7b5dd9edb4 570 * execution frequency as the time between a task starting to execute and that task
dflet 0:1e7b5dd9edb4 571 * calling vTaskDelay () may not be fixed [the task may take a different path though the
dflet 0:1e7b5dd9edb4 572 * code between calls, or may get interrupted or preempted a different number of times
dflet 0:1e7b5dd9edb4 573 * each time it executes].
dflet 0:1e7b5dd9edb4 574 *
dflet 0:1e7b5dd9edb4 575 * Whereas vTaskDelay () specifies a wake time relative to the time at which the function
dflet 0:1e7b5dd9edb4 576 * is called, vTaskDelayUntil () specifies the absolute (exact) time at which it wishes to
dflet 0:1e7b5dd9edb4 577 * unblock.
dflet 0:1e7b5dd9edb4 578 *
dflet 0:1e7b5dd9edb4 579 * The constant portTICK_PERIOD_MS can be used to calculate real time from the tick
dflet 0:1e7b5dd9edb4 580 * rate - with the resolution of one tick period.
dflet 0:1e7b5dd9edb4 581 *
dflet 0:1e7b5dd9edb4 582 * @param pxPreviousWakeTime Pointer to a variable that holds the time at which the
dflet 0:1e7b5dd9edb4 583 * task was last unblocked. The variable must be initialised with the current time
dflet 0:1e7b5dd9edb4 584 * prior to its first use (see the example below). Following this the variable is
dflet 0:1e7b5dd9edb4 585 * automatically updated within vTaskDelayUntil ().
dflet 0:1e7b5dd9edb4 586 *
dflet 0:1e7b5dd9edb4 587 * @param xTimeIncrement The cycle time period. The task will be unblocked at
dflet 0:1e7b5dd9edb4 588 * time *pxPreviousWakeTime + xTimeIncrement. Calling vTaskDelayUntil with the
dflet 0:1e7b5dd9edb4 589 * same xTimeIncrement parameter value will cause the task to execute with
dflet 0:1e7b5dd9edb4 590 * a fixed interface period.
dflet 0:1e7b5dd9edb4 591 *
dflet 0:1e7b5dd9edb4 592 * Example usage:
dflet 0:1e7b5dd9edb4 593 <pre>
dflet 0:1e7b5dd9edb4 594 // Perform an action every 10 ticks.
dflet 0:1e7b5dd9edb4 595 void vTaskFunction( void * pvParameters )
dflet 0:1e7b5dd9edb4 596 {
dflet 0:1e7b5dd9edb4 597 TickType_t xLastWakeTime;
dflet 0:1e7b5dd9edb4 598 const TickType_t xFrequency = 10;
dflet 0:1e7b5dd9edb4 599
dflet 0:1e7b5dd9edb4 600 // Initialise the xLastWakeTime variable with the current time.
dflet 0:1e7b5dd9edb4 601 xLastWakeTime = xTaskGetTickCount ();
dflet 0:1e7b5dd9edb4 602 for( ;; )
dflet 0:1e7b5dd9edb4 603 {
dflet 0:1e7b5dd9edb4 604 // Wait for the next cycle.
dflet 0:1e7b5dd9edb4 605 vTaskDelayUntil( &xLastWakeTime, xFrequency );
dflet 0:1e7b5dd9edb4 606
dflet 0:1e7b5dd9edb4 607 // Perform action here.
dflet 0:1e7b5dd9edb4 608 }
dflet 0:1e7b5dd9edb4 609 }
dflet 0:1e7b5dd9edb4 610 </pre>
dflet 0:1e7b5dd9edb4 611 * \defgroup vTaskDelayUntil vTaskDelayUntil
dflet 0:1e7b5dd9edb4 612 * \ingroup TaskCtrl
dflet 0:1e7b5dd9edb4 613 */
dflet 0:1e7b5dd9edb4 614 void vTaskDelayUntil( TickType_t * const pxPreviousWakeTime, const TickType_t xTimeIncrement ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 615
dflet 0:1e7b5dd9edb4 616 /**
dflet 0:1e7b5dd9edb4 617 * task. h
dflet 0:1e7b5dd9edb4 618 * <pre>UBaseType_t uxTaskPriorityGet( TaskHandle_t xTask );</pre>
dflet 0:1e7b5dd9edb4 619 *
dflet 0:1e7b5dd9edb4 620 * INCLUDE_uxTaskPriorityGet must be defined as 1 for this function to be available.
dflet 0:1e7b5dd9edb4 621 * See the configuration section for more information.
dflet 0:1e7b5dd9edb4 622 *
dflet 0:1e7b5dd9edb4 623 * Obtain the priority of any task.
dflet 0:1e7b5dd9edb4 624 *
dflet 0:1e7b5dd9edb4 625 * @param xTask Handle of the task to be queried. Passing a NULL
dflet 0:1e7b5dd9edb4 626 * handle results in the priority of the calling task being returned.
dflet 0:1e7b5dd9edb4 627 *
dflet 0:1e7b5dd9edb4 628 * @return The priority of xTask.
dflet 0:1e7b5dd9edb4 629 *
dflet 0:1e7b5dd9edb4 630 * Example usage:
dflet 0:1e7b5dd9edb4 631 <pre>
dflet 0:1e7b5dd9edb4 632 void vAFunction( void )
dflet 0:1e7b5dd9edb4 633 {
dflet 0:1e7b5dd9edb4 634 TaskHandle_t xHandle;
dflet 0:1e7b5dd9edb4 635
dflet 0:1e7b5dd9edb4 636 // Create a task, storing the handle.
dflet 0:1e7b5dd9edb4 637 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
dflet 0:1e7b5dd9edb4 638
dflet 0:1e7b5dd9edb4 639 // ...
dflet 0:1e7b5dd9edb4 640
dflet 0:1e7b5dd9edb4 641 // Use the handle to obtain the priority of the created task.
dflet 0:1e7b5dd9edb4 642 // It was created with tskIDLE_PRIORITY, but may have changed
dflet 0:1e7b5dd9edb4 643 // it itself.
dflet 0:1e7b5dd9edb4 644 if( uxTaskPriorityGet( xHandle ) != tskIDLE_PRIORITY )
dflet 0:1e7b5dd9edb4 645 {
dflet 0:1e7b5dd9edb4 646 // The task has changed it's priority.
dflet 0:1e7b5dd9edb4 647 }
dflet 0:1e7b5dd9edb4 648
dflet 0:1e7b5dd9edb4 649 // ...
dflet 0:1e7b5dd9edb4 650
dflet 0:1e7b5dd9edb4 651 // Is our priority higher than the created task?
dflet 0:1e7b5dd9edb4 652 if( uxTaskPriorityGet( xHandle ) < uxTaskPriorityGet( NULL ) )
dflet 0:1e7b5dd9edb4 653 {
dflet 0:1e7b5dd9edb4 654 // Our priority (obtained using NULL handle) is higher.
dflet 0:1e7b5dd9edb4 655 }
dflet 0:1e7b5dd9edb4 656 }
dflet 0:1e7b5dd9edb4 657 </pre>
dflet 0:1e7b5dd9edb4 658 * \defgroup uxTaskPriorityGet uxTaskPriorityGet
dflet 0:1e7b5dd9edb4 659 * \ingroup TaskCtrl
dflet 0:1e7b5dd9edb4 660 */
dflet 0:1e7b5dd9edb4 661 UBaseType_t uxTaskPriorityGet( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 662
dflet 0:1e7b5dd9edb4 663 /**
dflet 0:1e7b5dd9edb4 664 * task. h
dflet 0:1e7b5dd9edb4 665 * <pre>UBaseType_t uxTaskPriorityGetFromISR( TaskHandle_t xTask );</pre>
dflet 0:1e7b5dd9edb4 666 *
dflet 0:1e7b5dd9edb4 667 * A version of uxTaskPriorityGet() that can be used from an ISR.
dflet 0:1e7b5dd9edb4 668 */
dflet 0:1e7b5dd9edb4 669 UBaseType_t uxTaskPriorityGetFromISR( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 670
dflet 0:1e7b5dd9edb4 671 /**
dflet 0:1e7b5dd9edb4 672 * task. h
dflet 0:1e7b5dd9edb4 673 * <pre>eTaskState eTaskGetState( TaskHandle_t xTask );</pre>
dflet 0:1e7b5dd9edb4 674 *
dflet 0:1e7b5dd9edb4 675 * INCLUDE_eTaskGetState must be defined as 1 for this function to be available.
dflet 0:1e7b5dd9edb4 676 * See the configuration section for more information.
dflet 0:1e7b5dd9edb4 677 *
dflet 0:1e7b5dd9edb4 678 * Obtain the state of any task. States are encoded by the eTaskState
dflet 0:1e7b5dd9edb4 679 * enumerated type.
dflet 0:1e7b5dd9edb4 680 *
dflet 0:1e7b5dd9edb4 681 * @param xTask Handle of the task to be queried.
dflet 0:1e7b5dd9edb4 682 *
dflet 0:1e7b5dd9edb4 683 * @return The state of xTask at the time the function was called. Note the
dflet 0:1e7b5dd9edb4 684 * state of the task might change between the function being called, and the
dflet 0:1e7b5dd9edb4 685 * functions return value being tested by the calling task.
dflet 0:1e7b5dd9edb4 686 */
dflet 0:1e7b5dd9edb4 687 eTaskState eTaskGetState( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 688
dflet 0:1e7b5dd9edb4 689 /**
dflet 0:1e7b5dd9edb4 690 * task. h
dflet 0:1e7b5dd9edb4 691 * <pre>void vTaskPrioritySet( TaskHandle_t xTask, UBaseType_t uxNewPriority );</pre>
dflet 0:1e7b5dd9edb4 692 *
dflet 0:1e7b5dd9edb4 693 * INCLUDE_vTaskPrioritySet must be defined as 1 for this function to be available.
dflet 0:1e7b5dd9edb4 694 * See the configuration section for more information.
dflet 0:1e7b5dd9edb4 695 *
dflet 0:1e7b5dd9edb4 696 * Set the priority of any task.
dflet 0:1e7b5dd9edb4 697 *
dflet 0:1e7b5dd9edb4 698 * A context switch will occur before the function returns if the priority
dflet 0:1e7b5dd9edb4 699 * being set is higher than the currently executing task.
dflet 0:1e7b5dd9edb4 700 *
dflet 0:1e7b5dd9edb4 701 * @param xTask Handle to the task for which the priority is being set.
dflet 0:1e7b5dd9edb4 702 * Passing a NULL handle results in the priority of the calling task being set.
dflet 0:1e7b5dd9edb4 703 *
dflet 0:1e7b5dd9edb4 704 * @param uxNewPriority The priority to which the task will be set.
dflet 0:1e7b5dd9edb4 705 *
dflet 0:1e7b5dd9edb4 706 * Example usage:
dflet 0:1e7b5dd9edb4 707 <pre>
dflet 0:1e7b5dd9edb4 708 void vAFunction( void )
dflet 0:1e7b5dd9edb4 709 {
dflet 0:1e7b5dd9edb4 710 TaskHandle_t xHandle;
dflet 0:1e7b5dd9edb4 711
dflet 0:1e7b5dd9edb4 712 // Create a task, storing the handle.
dflet 0:1e7b5dd9edb4 713 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
dflet 0:1e7b5dd9edb4 714
dflet 0:1e7b5dd9edb4 715 // ...
dflet 0:1e7b5dd9edb4 716
dflet 0:1e7b5dd9edb4 717 // Use the handle to raise the priority of the created task.
dflet 0:1e7b5dd9edb4 718 vTaskPrioritySet( xHandle, tskIDLE_PRIORITY + 1 );
dflet 0:1e7b5dd9edb4 719
dflet 0:1e7b5dd9edb4 720 // ...
dflet 0:1e7b5dd9edb4 721
dflet 0:1e7b5dd9edb4 722 // Use a NULL handle to raise our priority to the same value.
dflet 0:1e7b5dd9edb4 723 vTaskPrioritySet( NULL, tskIDLE_PRIORITY + 1 );
dflet 0:1e7b5dd9edb4 724 }
dflet 0:1e7b5dd9edb4 725 </pre>
dflet 0:1e7b5dd9edb4 726 * \defgroup vTaskPrioritySet vTaskPrioritySet
dflet 0:1e7b5dd9edb4 727 * \ingroup TaskCtrl
dflet 0:1e7b5dd9edb4 728 */
dflet 0:1e7b5dd9edb4 729 void vTaskPrioritySet( TaskHandle_t xTask, UBaseType_t uxNewPriority ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 730
dflet 0:1e7b5dd9edb4 731 /**
dflet 0:1e7b5dd9edb4 732 * task. h
dflet 0:1e7b5dd9edb4 733 * <pre>void vTaskSuspend( TaskHandle_t xTaskToSuspend );</pre>
dflet 0:1e7b5dd9edb4 734 *
dflet 0:1e7b5dd9edb4 735 * INCLUDE_vTaskSuspend must be defined as 1 for this function to be available.
dflet 0:1e7b5dd9edb4 736 * See the configuration section for more information.
dflet 0:1e7b5dd9edb4 737 *
dflet 0:1e7b5dd9edb4 738 * Suspend any task. When suspended a task will never get any microcontroller
dflet 0:1e7b5dd9edb4 739 * processing time, no matter what its priority.
dflet 0:1e7b5dd9edb4 740 *
dflet 0:1e7b5dd9edb4 741 * Calls to vTaskSuspend are not accumulative -
dflet 0:1e7b5dd9edb4 742 * i.e. calling vTaskSuspend () twice on the same task still only requires one
dflet 0:1e7b5dd9edb4 743 * call to vTaskResume () to ready the suspended task.
dflet 0:1e7b5dd9edb4 744 *
dflet 0:1e7b5dd9edb4 745 * @param xTaskToSuspend Handle to the task being suspended. Passing a NULL
dflet 0:1e7b5dd9edb4 746 * handle will cause the calling task to be suspended.
dflet 0:1e7b5dd9edb4 747 *
dflet 0:1e7b5dd9edb4 748 * Example usage:
dflet 0:1e7b5dd9edb4 749 <pre>
dflet 0:1e7b5dd9edb4 750 void vAFunction( void )
dflet 0:1e7b5dd9edb4 751 {
dflet 0:1e7b5dd9edb4 752 TaskHandle_t xHandle;
dflet 0:1e7b5dd9edb4 753
dflet 0:1e7b5dd9edb4 754 // Create a task, storing the handle.
dflet 0:1e7b5dd9edb4 755 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
dflet 0:1e7b5dd9edb4 756
dflet 0:1e7b5dd9edb4 757 // ...
dflet 0:1e7b5dd9edb4 758
dflet 0:1e7b5dd9edb4 759 // Use the handle to suspend the created task.
dflet 0:1e7b5dd9edb4 760 vTaskSuspend( xHandle );
dflet 0:1e7b5dd9edb4 761
dflet 0:1e7b5dd9edb4 762 // ...
dflet 0:1e7b5dd9edb4 763
dflet 0:1e7b5dd9edb4 764 // The created task will not run during this period, unless
dflet 0:1e7b5dd9edb4 765 // another task calls vTaskResume( xHandle ).
dflet 0:1e7b5dd9edb4 766
dflet 0:1e7b5dd9edb4 767 //...
dflet 0:1e7b5dd9edb4 768
dflet 0:1e7b5dd9edb4 769
dflet 0:1e7b5dd9edb4 770 // Suspend ourselves.
dflet 0:1e7b5dd9edb4 771 vTaskSuspend( NULL );
dflet 0:1e7b5dd9edb4 772
dflet 0:1e7b5dd9edb4 773 // We cannot get here unless another task calls vTaskResume
dflet 0:1e7b5dd9edb4 774 // with our handle as the parameter.
dflet 0:1e7b5dd9edb4 775 }
dflet 0:1e7b5dd9edb4 776 </pre>
dflet 0:1e7b5dd9edb4 777 * \defgroup vTaskSuspend vTaskSuspend
dflet 0:1e7b5dd9edb4 778 * \ingroup TaskCtrl
dflet 0:1e7b5dd9edb4 779 */
dflet 0:1e7b5dd9edb4 780 void vTaskSuspend( TaskHandle_t xTaskToSuspend ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 781
dflet 0:1e7b5dd9edb4 782 /**
dflet 0:1e7b5dd9edb4 783 * task. h
dflet 0:1e7b5dd9edb4 784 * <pre>void vTaskResume( TaskHandle_t xTaskToResume );</pre>
dflet 0:1e7b5dd9edb4 785 *
dflet 0:1e7b5dd9edb4 786 * INCLUDE_vTaskSuspend must be defined as 1 for this function to be available.
dflet 0:1e7b5dd9edb4 787 * See the configuration section for more information.
dflet 0:1e7b5dd9edb4 788 *
dflet 0:1e7b5dd9edb4 789 * Resumes a suspended task.
dflet 0:1e7b5dd9edb4 790 *
dflet 0:1e7b5dd9edb4 791 * A task that has been suspended by one or more calls to vTaskSuspend ()
dflet 0:1e7b5dd9edb4 792 * will be made available for running again by a single call to
dflet 0:1e7b5dd9edb4 793 * vTaskResume ().
dflet 0:1e7b5dd9edb4 794 *
dflet 0:1e7b5dd9edb4 795 * @param xTaskToResume Handle to the task being readied.
dflet 0:1e7b5dd9edb4 796 *
dflet 0:1e7b5dd9edb4 797 * Example usage:
dflet 0:1e7b5dd9edb4 798 <pre>
dflet 0:1e7b5dd9edb4 799 void vAFunction( void )
dflet 0:1e7b5dd9edb4 800 {
dflet 0:1e7b5dd9edb4 801 TaskHandle_t xHandle;
dflet 0:1e7b5dd9edb4 802
dflet 0:1e7b5dd9edb4 803 // Create a task, storing the handle.
dflet 0:1e7b5dd9edb4 804 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, &xHandle );
dflet 0:1e7b5dd9edb4 805
dflet 0:1e7b5dd9edb4 806 // ...
dflet 0:1e7b5dd9edb4 807
dflet 0:1e7b5dd9edb4 808 // Use the handle to suspend the created task.
dflet 0:1e7b5dd9edb4 809 vTaskSuspend( xHandle );
dflet 0:1e7b5dd9edb4 810
dflet 0:1e7b5dd9edb4 811 // ...
dflet 0:1e7b5dd9edb4 812
dflet 0:1e7b5dd9edb4 813 // The created task will not run during this period, unless
dflet 0:1e7b5dd9edb4 814 // another task calls vTaskResume( xHandle ).
dflet 0:1e7b5dd9edb4 815
dflet 0:1e7b5dd9edb4 816 //...
dflet 0:1e7b5dd9edb4 817
dflet 0:1e7b5dd9edb4 818
dflet 0:1e7b5dd9edb4 819 // Resume the suspended task ourselves.
dflet 0:1e7b5dd9edb4 820 vTaskResume( xHandle );
dflet 0:1e7b5dd9edb4 821
dflet 0:1e7b5dd9edb4 822 // The created task will once again get microcontroller processing
dflet 0:1e7b5dd9edb4 823 // time in accordance with its priority within the system.
dflet 0:1e7b5dd9edb4 824 }
dflet 0:1e7b5dd9edb4 825 </pre>
dflet 0:1e7b5dd9edb4 826 * \defgroup vTaskResume vTaskResume
dflet 0:1e7b5dd9edb4 827 * \ingroup TaskCtrl
dflet 0:1e7b5dd9edb4 828 */
dflet 0:1e7b5dd9edb4 829 void vTaskResume( TaskHandle_t xTaskToResume ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 830
dflet 0:1e7b5dd9edb4 831 /**
dflet 0:1e7b5dd9edb4 832 * task. h
dflet 0:1e7b5dd9edb4 833 * <pre>void xTaskResumeFromISR( TaskHandle_t xTaskToResume );</pre>
dflet 0:1e7b5dd9edb4 834 *
dflet 0:1e7b5dd9edb4 835 * INCLUDE_xTaskResumeFromISR must be defined as 1 for this function to be
dflet 0:1e7b5dd9edb4 836 * available. See the configuration section for more information.
dflet 0:1e7b5dd9edb4 837 *
dflet 0:1e7b5dd9edb4 838 * An implementation of vTaskResume() that can be called from within an ISR.
dflet 0:1e7b5dd9edb4 839 *
dflet 0:1e7b5dd9edb4 840 * A task that has been suspended by one or more calls to vTaskSuspend ()
dflet 0:1e7b5dd9edb4 841 * will be made available for running again by a single call to
dflet 0:1e7b5dd9edb4 842 * xTaskResumeFromISR ().
dflet 0:1e7b5dd9edb4 843 *
dflet 0:1e7b5dd9edb4 844 * xTaskResumeFromISR() should not be used to synchronise a task with an
dflet 0:1e7b5dd9edb4 845 * interrupt if there is a chance that the interrupt could arrive prior to the
dflet 0:1e7b5dd9edb4 846 * task being suspended - as this can lead to interrupts being missed. Use of a
dflet 0:1e7b5dd9edb4 847 * semaphore as a synchronisation mechanism would avoid this eventuality.
dflet 0:1e7b5dd9edb4 848 *
dflet 0:1e7b5dd9edb4 849 * @param xTaskToResume Handle to the task being readied.
dflet 0:1e7b5dd9edb4 850 *
dflet 0:1e7b5dd9edb4 851 * @return pdTRUE if resuming the task should result in a context switch,
dflet 0:1e7b5dd9edb4 852 * otherwise pdFALSE. This is used by the ISR to determine if a context switch
dflet 0:1e7b5dd9edb4 853 * may be required following the ISR.
dflet 0:1e7b5dd9edb4 854 *
dflet 0:1e7b5dd9edb4 855 * \defgroup vTaskResumeFromISR vTaskResumeFromISR
dflet 0:1e7b5dd9edb4 856 * \ingroup TaskCtrl
dflet 0:1e7b5dd9edb4 857 */
dflet 0:1e7b5dd9edb4 858 BaseType_t xTaskResumeFromISR( TaskHandle_t xTaskToResume ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 859
dflet 0:1e7b5dd9edb4 860 /*-----------------------------------------------------------
dflet 0:1e7b5dd9edb4 861 * SCHEDULER CONTROL
dflet 0:1e7b5dd9edb4 862 *----------------------------------------------------------*/
dflet 0:1e7b5dd9edb4 863
dflet 0:1e7b5dd9edb4 864 /**
dflet 0:1e7b5dd9edb4 865 * task. h
dflet 0:1e7b5dd9edb4 866 * <pre>void vTaskStartScheduler( void );</pre>
dflet 0:1e7b5dd9edb4 867 *
dflet 0:1e7b5dd9edb4 868 * Starts the real time kernel tick processing. After calling the kernel
dflet 0:1e7b5dd9edb4 869 * has control over which tasks are executed and when.
dflet 0:1e7b5dd9edb4 870 *
dflet 0:1e7b5dd9edb4 871 * See the demo application file main.c for an example of creating
dflet 0:1e7b5dd9edb4 872 * tasks and starting the kernel.
dflet 0:1e7b5dd9edb4 873 *
dflet 0:1e7b5dd9edb4 874 * Example usage:
dflet 0:1e7b5dd9edb4 875 <pre>
dflet 0:1e7b5dd9edb4 876 void vAFunction( void )
dflet 0:1e7b5dd9edb4 877 {
dflet 0:1e7b5dd9edb4 878 // Create at least one task before starting the kernel.
dflet 0:1e7b5dd9edb4 879 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );
dflet 0:1e7b5dd9edb4 880
dflet 0:1e7b5dd9edb4 881 // Start the real time kernel with preemption.
dflet 0:1e7b5dd9edb4 882 vTaskStartScheduler ();
dflet 0:1e7b5dd9edb4 883
dflet 0:1e7b5dd9edb4 884 // Will not get here unless a task calls vTaskEndScheduler ()
dflet 0:1e7b5dd9edb4 885 }
dflet 0:1e7b5dd9edb4 886 </pre>
dflet 0:1e7b5dd9edb4 887 *
dflet 0:1e7b5dd9edb4 888 * \defgroup vTaskStartScheduler vTaskStartScheduler
dflet 0:1e7b5dd9edb4 889 * \ingroup SchedulerControl
dflet 0:1e7b5dd9edb4 890 */
dflet 0:1e7b5dd9edb4 891 void vTaskStartScheduler( void ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 892
dflet 0:1e7b5dd9edb4 893 /**
dflet 0:1e7b5dd9edb4 894 * task. h
dflet 0:1e7b5dd9edb4 895 * <pre>void vTaskEndScheduler( void );</pre>
dflet 0:1e7b5dd9edb4 896 *
dflet 0:1e7b5dd9edb4 897 * NOTE: At the time of writing only the x86 real mode port, which runs on a PC
dflet 0:1e7b5dd9edb4 898 * in place of DOS, implements this function.
dflet 0:1e7b5dd9edb4 899 *
dflet 0:1e7b5dd9edb4 900 * Stops the real time kernel tick. All created tasks will be automatically
dflet 0:1e7b5dd9edb4 901 * deleted and multitasking (either preemptive or cooperative) will
dflet 0:1e7b5dd9edb4 902 * stop. Execution then resumes from the point where vTaskStartScheduler ()
dflet 0:1e7b5dd9edb4 903 * was called, as if vTaskStartScheduler () had just returned.
dflet 0:1e7b5dd9edb4 904 *
dflet 0:1e7b5dd9edb4 905 * See the demo application file main. c in the demo/PC directory for an
dflet 0:1e7b5dd9edb4 906 * example that uses vTaskEndScheduler ().
dflet 0:1e7b5dd9edb4 907 *
dflet 0:1e7b5dd9edb4 908 * vTaskEndScheduler () requires an exit function to be defined within the
dflet 0:1e7b5dd9edb4 909 * portable layer (see vPortEndScheduler () in port. c for the PC port). This
dflet 0:1e7b5dd9edb4 910 * performs hardware specific operations such as stopping the kernel tick.
dflet 0:1e7b5dd9edb4 911 *
dflet 0:1e7b5dd9edb4 912 * vTaskEndScheduler () will cause all of the resources allocated by the
dflet 0:1e7b5dd9edb4 913 * kernel to be freed - but will not free resources allocated by application
dflet 0:1e7b5dd9edb4 914 * tasks.
dflet 0:1e7b5dd9edb4 915 *
dflet 0:1e7b5dd9edb4 916 * Example usage:
dflet 0:1e7b5dd9edb4 917 <pre>
dflet 0:1e7b5dd9edb4 918 void vTaskCode( void * pvParameters )
dflet 0:1e7b5dd9edb4 919 {
dflet 0:1e7b5dd9edb4 920 for( ;; )
dflet 0:1e7b5dd9edb4 921 {
dflet 0:1e7b5dd9edb4 922 // Task code goes here.
dflet 0:1e7b5dd9edb4 923
dflet 0:1e7b5dd9edb4 924 // At some point we want to end the real time kernel processing
dflet 0:1e7b5dd9edb4 925 // so call ...
dflet 0:1e7b5dd9edb4 926 vTaskEndScheduler ();
dflet 0:1e7b5dd9edb4 927 }
dflet 0:1e7b5dd9edb4 928 }
dflet 0:1e7b5dd9edb4 929
dflet 0:1e7b5dd9edb4 930 void vAFunction( void )
dflet 0:1e7b5dd9edb4 931 {
dflet 0:1e7b5dd9edb4 932 // Create at least one task before starting the kernel.
dflet 0:1e7b5dd9edb4 933 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );
dflet 0:1e7b5dd9edb4 934
dflet 0:1e7b5dd9edb4 935 // Start the real time kernel with preemption.
dflet 0:1e7b5dd9edb4 936 vTaskStartScheduler ();
dflet 0:1e7b5dd9edb4 937
dflet 0:1e7b5dd9edb4 938 // Will only get here when the vTaskCode () task has called
dflet 0:1e7b5dd9edb4 939 // vTaskEndScheduler (). When we get here we are back to single task
dflet 0:1e7b5dd9edb4 940 // execution.
dflet 0:1e7b5dd9edb4 941 }
dflet 0:1e7b5dd9edb4 942 </pre>
dflet 0:1e7b5dd9edb4 943 *
dflet 0:1e7b5dd9edb4 944 * \defgroup vTaskEndScheduler vTaskEndScheduler
dflet 0:1e7b5dd9edb4 945 * \ingroup SchedulerControl
dflet 0:1e7b5dd9edb4 946 */
dflet 0:1e7b5dd9edb4 947 void vTaskEndScheduler( void ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 948
dflet 0:1e7b5dd9edb4 949 /**
dflet 0:1e7b5dd9edb4 950 * task. h
dflet 0:1e7b5dd9edb4 951 * <pre>void vTaskSuspendAll( void );</pre>
dflet 0:1e7b5dd9edb4 952 *
dflet 0:1e7b5dd9edb4 953 * Suspends the scheduler without disabling interrupts. Context switches will
dflet 0:1e7b5dd9edb4 954 * not occur while the scheduler is suspended.
dflet 0:1e7b5dd9edb4 955 *
dflet 0:1e7b5dd9edb4 956 * After calling vTaskSuspendAll () the calling task will continue to execute
dflet 0:1e7b5dd9edb4 957 * without risk of being swapped out until a call to xTaskResumeAll () has been
dflet 0:1e7b5dd9edb4 958 * made.
dflet 0:1e7b5dd9edb4 959 *
dflet 0:1e7b5dd9edb4 960 * API functions that have the potential to cause a context switch (for example,
dflet 0:1e7b5dd9edb4 961 * vTaskDelayUntil(), xQueueSend(), etc.) must not be called while the scheduler
dflet 0:1e7b5dd9edb4 962 * is suspended.
dflet 0:1e7b5dd9edb4 963 *
dflet 0:1e7b5dd9edb4 964 * Example usage:
dflet 0:1e7b5dd9edb4 965 <pre>
dflet 0:1e7b5dd9edb4 966 void vTask1( void * pvParameters )
dflet 0:1e7b5dd9edb4 967 {
dflet 0:1e7b5dd9edb4 968 for( ;; )
dflet 0:1e7b5dd9edb4 969 {
dflet 0:1e7b5dd9edb4 970 // Task code goes here.
dflet 0:1e7b5dd9edb4 971
dflet 0:1e7b5dd9edb4 972 // ...
dflet 0:1e7b5dd9edb4 973
dflet 0:1e7b5dd9edb4 974 // At some point the task wants to perform a long operation during
dflet 0:1e7b5dd9edb4 975 // which it does not want to get swapped out. It cannot use
dflet 0:1e7b5dd9edb4 976 // taskENTER_CRITICAL ()/taskEXIT_CRITICAL () as the length of the
dflet 0:1e7b5dd9edb4 977 // operation may cause interrupts to be missed - including the
dflet 0:1e7b5dd9edb4 978 // ticks.
dflet 0:1e7b5dd9edb4 979
dflet 0:1e7b5dd9edb4 980 // Prevent the real time kernel swapping out the task.
dflet 0:1e7b5dd9edb4 981 vTaskSuspendAll ();
dflet 0:1e7b5dd9edb4 982
dflet 0:1e7b5dd9edb4 983 // Perform the operation here. There is no need to use critical
dflet 0:1e7b5dd9edb4 984 // sections as we have all the microcontroller processing time.
dflet 0:1e7b5dd9edb4 985 // During this time interrupts will still operate and the kernel
dflet 0:1e7b5dd9edb4 986 // tick count will be maintained.
dflet 0:1e7b5dd9edb4 987
dflet 0:1e7b5dd9edb4 988 // ...
dflet 0:1e7b5dd9edb4 989
dflet 0:1e7b5dd9edb4 990 // The operation is complete. Restart the kernel.
dflet 0:1e7b5dd9edb4 991 xTaskResumeAll ();
dflet 0:1e7b5dd9edb4 992 }
dflet 0:1e7b5dd9edb4 993 }
dflet 0:1e7b5dd9edb4 994 </pre>
dflet 0:1e7b5dd9edb4 995 * \defgroup vTaskSuspendAll vTaskSuspendAll
dflet 0:1e7b5dd9edb4 996 * \ingroup SchedulerControl
dflet 0:1e7b5dd9edb4 997 */
dflet 0:1e7b5dd9edb4 998 void vTaskSuspendAll( void ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 999
dflet 0:1e7b5dd9edb4 1000 /**
dflet 0:1e7b5dd9edb4 1001 * task. h
dflet 0:1e7b5dd9edb4 1002 * <pre>BaseType_t xTaskResumeAll( void );</pre>
dflet 0:1e7b5dd9edb4 1003 *
dflet 0:1e7b5dd9edb4 1004 * Resumes scheduler activity after it was suspended by a call to
dflet 0:1e7b5dd9edb4 1005 * vTaskSuspendAll().
dflet 0:1e7b5dd9edb4 1006 *
dflet 0:1e7b5dd9edb4 1007 * xTaskResumeAll() only resumes the scheduler. It does not unsuspend tasks
dflet 0:1e7b5dd9edb4 1008 * that were previously suspended by a call to vTaskSuspend().
dflet 0:1e7b5dd9edb4 1009 *
dflet 0:1e7b5dd9edb4 1010 * @return If resuming the scheduler caused a context switch then pdTRUE is
dflet 0:1e7b5dd9edb4 1011 * returned, otherwise pdFALSE is returned.
dflet 0:1e7b5dd9edb4 1012 *
dflet 0:1e7b5dd9edb4 1013 * Example usage:
dflet 0:1e7b5dd9edb4 1014 <pre>
dflet 0:1e7b5dd9edb4 1015 void vTask1( void * pvParameters )
dflet 0:1e7b5dd9edb4 1016 {
dflet 0:1e7b5dd9edb4 1017 for( ;; )
dflet 0:1e7b5dd9edb4 1018 {
dflet 0:1e7b5dd9edb4 1019 // Task code goes here.
dflet 0:1e7b5dd9edb4 1020
dflet 0:1e7b5dd9edb4 1021 // ...
dflet 0:1e7b5dd9edb4 1022
dflet 0:1e7b5dd9edb4 1023 // At some point the task wants to perform a long operation during
dflet 0:1e7b5dd9edb4 1024 // which it does not want to get swapped out. It cannot use
dflet 0:1e7b5dd9edb4 1025 // taskENTER_CRITICAL ()/taskEXIT_CRITICAL () as the length of the
dflet 0:1e7b5dd9edb4 1026 // operation may cause interrupts to be missed - including the
dflet 0:1e7b5dd9edb4 1027 // ticks.
dflet 0:1e7b5dd9edb4 1028
dflet 0:1e7b5dd9edb4 1029 // Prevent the real time kernel swapping out the task.
dflet 0:1e7b5dd9edb4 1030 vTaskSuspendAll ();
dflet 0:1e7b5dd9edb4 1031
dflet 0:1e7b5dd9edb4 1032 // Perform the operation here. There is no need to use critical
dflet 0:1e7b5dd9edb4 1033 // sections as we have all the microcontroller processing time.
dflet 0:1e7b5dd9edb4 1034 // During this time interrupts will still operate and the real
dflet 0:1e7b5dd9edb4 1035 // time kernel tick count will be maintained.
dflet 0:1e7b5dd9edb4 1036
dflet 0:1e7b5dd9edb4 1037 // ...
dflet 0:1e7b5dd9edb4 1038
dflet 0:1e7b5dd9edb4 1039 // The operation is complete. Restart the kernel. We want to force
dflet 0:1e7b5dd9edb4 1040 // a context switch - but there is no point if resuming the scheduler
dflet 0:1e7b5dd9edb4 1041 // caused a context switch already.
dflet 0:1e7b5dd9edb4 1042 if( !xTaskResumeAll () )
dflet 0:1e7b5dd9edb4 1043 {
dflet 0:1e7b5dd9edb4 1044 taskYIELD ();
dflet 0:1e7b5dd9edb4 1045 }
dflet 0:1e7b5dd9edb4 1046 }
dflet 0:1e7b5dd9edb4 1047 }
dflet 0:1e7b5dd9edb4 1048 </pre>
dflet 0:1e7b5dd9edb4 1049 * \defgroup xTaskResumeAll xTaskResumeAll
dflet 0:1e7b5dd9edb4 1050 * \ingroup SchedulerControl
dflet 0:1e7b5dd9edb4 1051 */
dflet 0:1e7b5dd9edb4 1052 BaseType_t xTaskResumeAll( void ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 1053
dflet 0:1e7b5dd9edb4 1054 /*-----------------------------------------------------------
dflet 0:1e7b5dd9edb4 1055 * TASK UTILITIES
dflet 0:1e7b5dd9edb4 1056 *----------------------------------------------------------*/
dflet 0:1e7b5dd9edb4 1057
dflet 0:1e7b5dd9edb4 1058 /**
dflet 0:1e7b5dd9edb4 1059 * task. h
dflet 0:1e7b5dd9edb4 1060 * <PRE>TickType_t xTaskGetTickCount( void );</PRE>
dflet 0:1e7b5dd9edb4 1061 *
dflet 0:1e7b5dd9edb4 1062 * @return The count of ticks since vTaskStartScheduler was called.
dflet 0:1e7b5dd9edb4 1063 *
dflet 0:1e7b5dd9edb4 1064 * \defgroup xTaskGetTickCount xTaskGetTickCount
dflet 0:1e7b5dd9edb4 1065 * \ingroup TaskUtils
dflet 0:1e7b5dd9edb4 1066 */
dflet 0:1e7b5dd9edb4 1067 TickType_t xTaskGetTickCount( void ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 1068
dflet 0:1e7b5dd9edb4 1069 /**
dflet 0:1e7b5dd9edb4 1070 * task. h
dflet 0:1e7b5dd9edb4 1071 * <PRE>TickType_t xTaskGetTickCountFromISR( void );</PRE>
dflet 0:1e7b5dd9edb4 1072 *
dflet 0:1e7b5dd9edb4 1073 * @return The count of ticks since vTaskStartScheduler was called.
dflet 0:1e7b5dd9edb4 1074 *
dflet 0:1e7b5dd9edb4 1075 * This is a version of xTaskGetTickCount() that is safe to be called from an
dflet 0:1e7b5dd9edb4 1076 * ISR - provided that TickType_t is the natural word size of the
dflet 0:1e7b5dd9edb4 1077 * microcontroller being used or interrupt nesting is either not supported or
dflet 0:1e7b5dd9edb4 1078 * not being used.
dflet 0:1e7b5dd9edb4 1079 *
dflet 0:1e7b5dd9edb4 1080 * \defgroup xTaskGetTickCountFromISR xTaskGetTickCountFromISR
dflet 0:1e7b5dd9edb4 1081 * \ingroup TaskUtils
dflet 0:1e7b5dd9edb4 1082 */
dflet 0:1e7b5dd9edb4 1083 TickType_t xTaskGetTickCountFromISR( void ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 1084
dflet 0:1e7b5dd9edb4 1085 /**
dflet 0:1e7b5dd9edb4 1086 * task. h
dflet 0:1e7b5dd9edb4 1087 * <PRE>uint16_t uxTaskGetNumberOfTasks( void );</PRE>
dflet 0:1e7b5dd9edb4 1088 *
dflet 0:1e7b5dd9edb4 1089 * @return The number of tasks that the real time kernel is currently managing.
dflet 0:1e7b5dd9edb4 1090 * This includes all ready, blocked and suspended tasks. A task that
dflet 0:1e7b5dd9edb4 1091 * has been deleted but not yet freed by the idle task will also be
dflet 0:1e7b5dd9edb4 1092 * included in the count.
dflet 0:1e7b5dd9edb4 1093 *
dflet 0:1e7b5dd9edb4 1094 * \defgroup uxTaskGetNumberOfTasks uxTaskGetNumberOfTasks
dflet 0:1e7b5dd9edb4 1095 * \ingroup TaskUtils
dflet 0:1e7b5dd9edb4 1096 */
dflet 0:1e7b5dd9edb4 1097 UBaseType_t uxTaskGetNumberOfTasks( void ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 1098
dflet 0:1e7b5dd9edb4 1099 /**
dflet 0:1e7b5dd9edb4 1100 * task. h
dflet 0:1e7b5dd9edb4 1101 * <PRE>char *pcTaskGetTaskName( TaskHandle_t xTaskToQuery );</PRE>
dflet 0:1e7b5dd9edb4 1102 *
dflet 0:1e7b5dd9edb4 1103 * @return The text (human readable) name of the task referenced by the handle
dflet 0:1e7b5dd9edb4 1104 * xTaskToQuery. A task can query its own name by either passing in its own
dflet 0:1e7b5dd9edb4 1105 * handle, or by setting xTaskToQuery to NULL. INCLUDE_pcTaskGetTaskName must be
dflet 0:1e7b5dd9edb4 1106 * set to 1 in FreeRTOSConfig.h for pcTaskGetTaskName() to be available.
dflet 0:1e7b5dd9edb4 1107 *
dflet 0:1e7b5dd9edb4 1108 * \defgroup pcTaskGetTaskName pcTaskGetTaskName
dflet 0:1e7b5dd9edb4 1109 * \ingroup TaskUtils
dflet 0:1e7b5dd9edb4 1110 */
dflet 0:1e7b5dd9edb4 1111 char *pcTaskGetTaskName( TaskHandle_t xTaskToQuery ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
dflet 0:1e7b5dd9edb4 1112
dflet 0:1e7b5dd9edb4 1113 /**
dflet 0:1e7b5dd9edb4 1114 * task.h
dflet 0:1e7b5dd9edb4 1115 * <PRE>UBaseType_t uxTaskGetStackHighWaterMark( TaskHandle_t xTask );</PRE>
dflet 0:1e7b5dd9edb4 1116 *
dflet 0:1e7b5dd9edb4 1117 * INCLUDE_uxTaskGetStackHighWaterMark must be set to 1 in FreeRTOSConfig.h for
dflet 0:1e7b5dd9edb4 1118 * this function to be available.
dflet 0:1e7b5dd9edb4 1119 *
dflet 0:1e7b5dd9edb4 1120 * Returns the high water mark of the stack associated with xTask. That is,
dflet 0:1e7b5dd9edb4 1121 * the minimum free stack space there has been (in words, so on a 32 bit machine
dflet 0:1e7b5dd9edb4 1122 * a value of 1 means 4 bytes) since the task started. The smaller the returned
dflet 0:1e7b5dd9edb4 1123 * number the closer the task has come to overflowing its stack.
dflet 0:1e7b5dd9edb4 1124 *
dflet 0:1e7b5dd9edb4 1125 * @param xTask Handle of the task associated with the stack to be checked.
dflet 0:1e7b5dd9edb4 1126 * Set xTask to NULL to check the stack of the calling task.
dflet 0:1e7b5dd9edb4 1127 *
dflet 0:1e7b5dd9edb4 1128 * @return The smallest amount of free stack space there has been (in words, so
dflet 0:1e7b5dd9edb4 1129 * actual spaces on the stack rather than bytes) since the task referenced by
dflet 0:1e7b5dd9edb4 1130 * xTask was created.
dflet 0:1e7b5dd9edb4 1131 */
dflet 0:1e7b5dd9edb4 1132 UBaseType_t uxTaskGetStackHighWaterMark( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 1133
dflet 0:1e7b5dd9edb4 1134 /* When using trace macros it is sometimes necessary to include task.h before
dflet 0:1e7b5dd9edb4 1135 FreeRTOS.h. When this is done TaskHookFunction_t will not yet have been defined,
dflet 0:1e7b5dd9edb4 1136 so the following two prototypes will cause a compilation error. This can be
dflet 0:1e7b5dd9edb4 1137 fixed by simply guarding against the inclusion of these two prototypes unless
dflet 0:1e7b5dd9edb4 1138 they are explicitly required by the configUSE_APPLICATION_TASK_TAG configuration
dflet 0:1e7b5dd9edb4 1139 constant. */
dflet 0:1e7b5dd9edb4 1140 #ifdef configUSE_APPLICATION_TASK_TAG
dflet 0:1e7b5dd9edb4 1141 #if configUSE_APPLICATION_TASK_TAG == 1
dflet 0:1e7b5dd9edb4 1142 /**
dflet 0:1e7b5dd9edb4 1143 * task.h
dflet 0:1e7b5dd9edb4 1144 * <pre>void vTaskSetApplicationTaskTag( TaskHandle_t xTask, TaskHookFunction_t pxHookFunction );</pre>
dflet 0:1e7b5dd9edb4 1145 *
dflet 0:1e7b5dd9edb4 1146 * Sets pxHookFunction to be the task hook function used by the task xTask.
dflet 0:1e7b5dd9edb4 1147 * Passing xTask as NULL has the effect of setting the calling tasks hook
dflet 0:1e7b5dd9edb4 1148 * function.
dflet 0:1e7b5dd9edb4 1149 */
dflet 0:1e7b5dd9edb4 1150 void vTaskSetApplicationTaskTag( TaskHandle_t xTask, TaskHookFunction_t pxHookFunction ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 1151
dflet 0:1e7b5dd9edb4 1152 /**
dflet 0:1e7b5dd9edb4 1153 * task.h
dflet 0:1e7b5dd9edb4 1154 * <pre>void xTaskGetApplicationTaskTag( TaskHandle_t xTask );</pre>
dflet 0:1e7b5dd9edb4 1155 *
dflet 0:1e7b5dd9edb4 1156 * Returns the pxHookFunction value assigned to the task xTask.
dflet 0:1e7b5dd9edb4 1157 */
dflet 0:1e7b5dd9edb4 1158 TaskHookFunction_t xTaskGetApplicationTaskTag( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 1159 #endif /* configUSE_APPLICATION_TASK_TAG ==1 */
dflet 0:1e7b5dd9edb4 1160 #endif /* ifdef configUSE_APPLICATION_TASK_TAG */
dflet 0:1e7b5dd9edb4 1161
dflet 0:1e7b5dd9edb4 1162 #if( configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 )
dflet 0:1e7b5dd9edb4 1163
dflet 0:1e7b5dd9edb4 1164 /* Each task contains an array of pointers that is dimensioned by the
dflet 0:1e7b5dd9edb4 1165 configNUM_THREAD_LOCAL_STORAGE_POINTERS setting in FreeRTOSConfig.h. The
dflet 0:1e7b5dd9edb4 1166 kernel does not use the pointers itself, so the application writer can use
dflet 0:1e7b5dd9edb4 1167 the pointers for any purpose they wish. The following two functions are
dflet 0:1e7b5dd9edb4 1168 used to set and query a pointer respectively. */
dflet 0:1e7b5dd9edb4 1169 void vTaskSetThreadLocalStoragePointer( TaskHandle_t xTaskToSet, BaseType_t xIndex, void *pvValue );
dflet 0:1e7b5dd9edb4 1170 void *pvTaskGetThreadLocalStoragePointer( TaskHandle_t xTaskToQuery, BaseType_t xIndex );
dflet 0:1e7b5dd9edb4 1171
dflet 0:1e7b5dd9edb4 1172 #endif
dflet 0:1e7b5dd9edb4 1173
dflet 0:1e7b5dd9edb4 1174 /**
dflet 0:1e7b5dd9edb4 1175 * task.h
dflet 0:1e7b5dd9edb4 1176 * <pre>BaseType_t xTaskCallApplicationTaskHook( TaskHandle_t xTask, void *pvParameter );</pre>
dflet 0:1e7b5dd9edb4 1177 *
dflet 0:1e7b5dd9edb4 1178 * Calls the hook function associated with xTask. Passing xTask as NULL has
dflet 0:1e7b5dd9edb4 1179 * the effect of calling the Running tasks (the calling task) hook function.
dflet 0:1e7b5dd9edb4 1180 *
dflet 0:1e7b5dd9edb4 1181 * pvParameter is passed to the hook function for the task to interpret as it
dflet 0:1e7b5dd9edb4 1182 * wants. The return value is the value returned by the task hook function
dflet 0:1e7b5dd9edb4 1183 * registered by the user.
dflet 0:1e7b5dd9edb4 1184 */
dflet 0:1e7b5dd9edb4 1185 BaseType_t xTaskCallApplicationTaskHook( TaskHandle_t xTask, void *pvParameter ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 1186
dflet 0:1e7b5dd9edb4 1187 /**
dflet 0:1e7b5dd9edb4 1188 * xTaskGetIdleTaskHandle() is only available if
dflet 0:1e7b5dd9edb4 1189 * INCLUDE_xTaskGetIdleTaskHandle is set to 1 in FreeRTOSConfig.h.
dflet 0:1e7b5dd9edb4 1190 *
dflet 0:1e7b5dd9edb4 1191 * Simply returns the handle of the idle task. It is not valid to call
dflet 0:1e7b5dd9edb4 1192 * xTaskGetIdleTaskHandle() before the scheduler has been started.
dflet 0:1e7b5dd9edb4 1193 */
dflet 0:1e7b5dd9edb4 1194 TaskHandle_t xTaskGetIdleTaskHandle( void );
dflet 0:1e7b5dd9edb4 1195
dflet 0:1e7b5dd9edb4 1196 /**
dflet 0:1e7b5dd9edb4 1197 * configUSE_TRACE_FACILITY must be defined as 1 in FreeRTOSConfig.h for
dflet 0:1e7b5dd9edb4 1198 * uxTaskGetSystemState() to be available.
dflet 0:1e7b5dd9edb4 1199 *
dflet 0:1e7b5dd9edb4 1200 * uxTaskGetSystemState() populates an TaskStatus_t structure for each task in
dflet 0:1e7b5dd9edb4 1201 * the system. TaskStatus_t structures contain, among other things, members
dflet 0:1e7b5dd9edb4 1202 * for the task handle, task name, task priority, task state, and total amount
dflet 0:1e7b5dd9edb4 1203 * of run time consumed by the task. See the TaskStatus_t structure
dflet 0:1e7b5dd9edb4 1204 * definition in this file for the full member list.
dflet 0:1e7b5dd9edb4 1205 *
dflet 0:1e7b5dd9edb4 1206 * NOTE: This function is intended for debugging use only as its use results in
dflet 0:1e7b5dd9edb4 1207 * the scheduler remaining suspended for an extended period.
dflet 0:1e7b5dd9edb4 1208 *
dflet 0:1e7b5dd9edb4 1209 * @param pxTaskStatusArray A pointer to an array of TaskStatus_t structures.
dflet 0:1e7b5dd9edb4 1210 * The array must contain at least one TaskStatus_t structure for each task
dflet 0:1e7b5dd9edb4 1211 * that is under the control of the RTOS. The number of tasks under the control
dflet 0:1e7b5dd9edb4 1212 * of the RTOS can be determined using the uxTaskGetNumberOfTasks() API function.
dflet 0:1e7b5dd9edb4 1213 *
dflet 0:1e7b5dd9edb4 1214 * @param uxArraySize The size of the array pointed to by the pxTaskStatusArray
dflet 0:1e7b5dd9edb4 1215 * parameter. The size is specified as the number of indexes in the array, or
dflet 0:1e7b5dd9edb4 1216 * the number of TaskStatus_t structures contained in the array, not by the
dflet 0:1e7b5dd9edb4 1217 * number of bytes in the array.
dflet 0:1e7b5dd9edb4 1218 *
dflet 0:1e7b5dd9edb4 1219 * @param pulTotalRunTime If configGENERATE_RUN_TIME_STATS is set to 1 in
dflet 0:1e7b5dd9edb4 1220 * FreeRTOSConfig.h then *pulTotalRunTime is set by uxTaskGetSystemState() to the
dflet 0:1e7b5dd9edb4 1221 * total run time (as defined by the run time stats clock, see
dflet 0:1e7b5dd9edb4 1222 * http://www.freertos.org/rtos-run-time-stats.html) since the target booted.
dflet 0:1e7b5dd9edb4 1223 * pulTotalRunTime can be set to NULL to omit the total run time information.
dflet 0:1e7b5dd9edb4 1224 *
dflet 0:1e7b5dd9edb4 1225 * @return The number of TaskStatus_t structures that were populated by
dflet 0:1e7b5dd9edb4 1226 * uxTaskGetSystemState(). This should equal the number returned by the
dflet 0:1e7b5dd9edb4 1227 * uxTaskGetNumberOfTasks() API function, but will be zero if the value passed
dflet 0:1e7b5dd9edb4 1228 * in the uxArraySize parameter was too small.
dflet 0:1e7b5dd9edb4 1229 *
dflet 0:1e7b5dd9edb4 1230 * Example usage:
dflet 0:1e7b5dd9edb4 1231 <pre>
dflet 0:1e7b5dd9edb4 1232 // This example demonstrates how a human readable table of run time stats
dflet 0:1e7b5dd9edb4 1233 // information is generated from raw data provided by uxTaskGetSystemState().
dflet 0:1e7b5dd9edb4 1234 // The human readable table is written to pcWriteBuffer
dflet 0:1e7b5dd9edb4 1235 void vTaskGetRunTimeStats( char *pcWriteBuffer )
dflet 0:1e7b5dd9edb4 1236 {
dflet 0:1e7b5dd9edb4 1237 TaskStatus_t *pxTaskStatusArray;
dflet 0:1e7b5dd9edb4 1238 volatile UBaseType_t uxArraySize, x;
dflet 0:1e7b5dd9edb4 1239 uint32_t ulTotalRunTime, ulStatsAsPercentage;
dflet 0:1e7b5dd9edb4 1240
dflet 0:1e7b5dd9edb4 1241 // Make sure the write buffer does not contain a string.
dflet 0:1e7b5dd9edb4 1242 *pcWriteBuffer = 0x00;
dflet 0:1e7b5dd9edb4 1243
dflet 0:1e7b5dd9edb4 1244 // Take a snapshot of the number of tasks in case it changes while this
dflet 0:1e7b5dd9edb4 1245 // function is executing.
dflet 0:1e7b5dd9edb4 1246 uxArraySize = uxTaskGetNumberOfTasks();
dflet 0:1e7b5dd9edb4 1247
dflet 0:1e7b5dd9edb4 1248 // Allocate a TaskStatus_t structure for each task. An array could be
dflet 0:1e7b5dd9edb4 1249 // allocated statically at compile time.
dflet 0:1e7b5dd9edb4 1250 pxTaskStatusArray = pvPortMalloc( uxArraySize * sizeof( TaskStatus_t ) );
dflet 0:1e7b5dd9edb4 1251
dflet 0:1e7b5dd9edb4 1252 if( pxTaskStatusArray != NULL )
dflet 0:1e7b5dd9edb4 1253 {
dflet 0:1e7b5dd9edb4 1254 // Generate raw status information about each task.
dflet 0:1e7b5dd9edb4 1255 uxArraySize = uxTaskGetSystemState( pxTaskStatusArray, uxArraySize, &ulTotalRunTime );
dflet 0:1e7b5dd9edb4 1256
dflet 0:1e7b5dd9edb4 1257 // For percentage calculations.
dflet 0:1e7b5dd9edb4 1258 ulTotalRunTime /= 100UL;
dflet 0:1e7b5dd9edb4 1259
dflet 0:1e7b5dd9edb4 1260 // Avoid divide by zero errors.
dflet 0:1e7b5dd9edb4 1261 if( ulTotalRunTime > 0 )
dflet 0:1e7b5dd9edb4 1262 {
dflet 0:1e7b5dd9edb4 1263 // For each populated position in the pxTaskStatusArray array,
dflet 0:1e7b5dd9edb4 1264 // format the raw data as human readable ASCII data
dflet 0:1e7b5dd9edb4 1265 for( x = 0; x < uxArraySize; x++ )
dflet 0:1e7b5dd9edb4 1266 {
dflet 0:1e7b5dd9edb4 1267 // What percentage of the total run time has the task used?
dflet 0:1e7b5dd9edb4 1268 // This will always be rounded down to the nearest integer.
dflet 0:1e7b5dd9edb4 1269 // ulTotalRunTimeDiv100 has already been divided by 100.
dflet 0:1e7b5dd9edb4 1270 ulStatsAsPercentage = pxTaskStatusArray[ x ].ulRunTimeCounter / ulTotalRunTime;
dflet 0:1e7b5dd9edb4 1271
dflet 0:1e7b5dd9edb4 1272 if( ulStatsAsPercentage > 0UL )
dflet 0:1e7b5dd9edb4 1273 {
dflet 0:1e7b5dd9edb4 1274 sprintf( pcWriteBuffer, "%s\t\t%lu\t\t%lu%%\r\n", pxTaskStatusArray[ x ].pcTaskName, pxTaskStatusArray[ x ].ulRunTimeCounter, ulStatsAsPercentage );
dflet 0:1e7b5dd9edb4 1275 }
dflet 0:1e7b5dd9edb4 1276 else
dflet 0:1e7b5dd9edb4 1277 {
dflet 0:1e7b5dd9edb4 1278 // If the percentage is zero here then the task has
dflet 0:1e7b5dd9edb4 1279 // consumed less than 1% of the total run time.
dflet 0:1e7b5dd9edb4 1280 sprintf( pcWriteBuffer, "%s\t\t%lu\t\t<1%%\r\n", pxTaskStatusArray[ x ].pcTaskName, pxTaskStatusArray[ x ].ulRunTimeCounter );
dflet 0:1e7b5dd9edb4 1281 }
dflet 0:1e7b5dd9edb4 1282
dflet 0:1e7b5dd9edb4 1283 pcWriteBuffer += strlen( ( char * ) pcWriteBuffer );
dflet 0:1e7b5dd9edb4 1284 }
dflet 0:1e7b5dd9edb4 1285 }
dflet 0:1e7b5dd9edb4 1286
dflet 0:1e7b5dd9edb4 1287 // The array is no longer needed, free the memory it consumes.
dflet 0:1e7b5dd9edb4 1288 vPortFree( pxTaskStatusArray );
dflet 0:1e7b5dd9edb4 1289 }
dflet 0:1e7b5dd9edb4 1290 }
dflet 0:1e7b5dd9edb4 1291 </pre>
dflet 0:1e7b5dd9edb4 1292 */
dflet 0:1e7b5dd9edb4 1293 UBaseType_t uxTaskGetSystemState( TaskStatus_t * const pxTaskStatusArray, const UBaseType_t uxArraySize, uint32_t * const pulTotalRunTime );
dflet 0:1e7b5dd9edb4 1294
dflet 0:1e7b5dd9edb4 1295 /**
dflet 0:1e7b5dd9edb4 1296 * task. h
dflet 0:1e7b5dd9edb4 1297 * <PRE>void vTaskList( char *pcWriteBuffer );</PRE>
dflet 0:1e7b5dd9edb4 1298 *
dflet 0:1e7b5dd9edb4 1299 * configUSE_TRACE_FACILITY and configUSE_STATS_FORMATTING_FUNCTIONS must
dflet 0:1e7b5dd9edb4 1300 * both be defined as 1 for this function to be available. See the
dflet 0:1e7b5dd9edb4 1301 * configuration section of the FreeRTOS.org website for more information.
dflet 0:1e7b5dd9edb4 1302 *
dflet 0:1e7b5dd9edb4 1303 * NOTE 1: This function will disable interrupts for its duration. It is
dflet 0:1e7b5dd9edb4 1304 * not intended for normal application runtime use but as a debug aid.
dflet 0:1e7b5dd9edb4 1305 *
dflet 0:1e7b5dd9edb4 1306 * Lists all the current tasks, along with their current state and stack
dflet 0:1e7b5dd9edb4 1307 * usage high water mark.
dflet 0:1e7b5dd9edb4 1308 *
dflet 0:1e7b5dd9edb4 1309 * Tasks are reported as blocked ('B'), ready ('R'), deleted ('D') or
dflet 0:1e7b5dd9edb4 1310 * suspended ('S').
dflet 0:1e7b5dd9edb4 1311 *
dflet 0:1e7b5dd9edb4 1312 * PLEASE NOTE:
dflet 0:1e7b5dd9edb4 1313 *
dflet 0:1e7b5dd9edb4 1314 * This function is provided for convenience only, and is used by many of the
dflet 0:1e7b5dd9edb4 1315 * demo applications. Do not consider it to be part of the scheduler.
dflet 0:1e7b5dd9edb4 1316 *
dflet 0:1e7b5dd9edb4 1317 * vTaskList() calls uxTaskGetSystemState(), then formats part of the
dflet 0:1e7b5dd9edb4 1318 * uxTaskGetSystemState() output into a human readable table that displays task
dflet 0:1e7b5dd9edb4 1319 * names, states and stack usage.
dflet 0:1e7b5dd9edb4 1320 *
dflet 0:1e7b5dd9edb4 1321 * vTaskList() has a dependency on the sprintf() C library function that might
dflet 0:1e7b5dd9edb4 1322 * bloat the code size, use a lot of stack, and provide different results on
dflet 0:1e7b5dd9edb4 1323 * different platforms. An alternative, tiny, third party, and limited
dflet 0:1e7b5dd9edb4 1324 * functionality implementation of sprintf() is provided in many of the
dflet 0:1e7b5dd9edb4 1325 * FreeRTOS/Demo sub-directories in a file called printf-stdarg.c (note
dflet 0:1e7b5dd9edb4 1326 * printf-stdarg.c does not provide a full snprintf() implementation!).
dflet 0:1e7b5dd9edb4 1327 *
dflet 0:1e7b5dd9edb4 1328 * It is recommended that production systems call uxTaskGetSystemState()
dflet 0:1e7b5dd9edb4 1329 * directly to get access to raw stats data, rather than indirectly through a
dflet 0:1e7b5dd9edb4 1330 * call to vTaskList().
dflet 0:1e7b5dd9edb4 1331 *
dflet 0:1e7b5dd9edb4 1332 * @param pcWriteBuffer A buffer into which the above mentioned details
dflet 0:1e7b5dd9edb4 1333 * will be written, in ASCII form. This buffer is assumed to be large
dflet 0:1e7b5dd9edb4 1334 * enough to contain the generated report. Approximately 40 bytes per
dflet 0:1e7b5dd9edb4 1335 * task should be sufficient.
dflet 0:1e7b5dd9edb4 1336 *
dflet 0:1e7b5dd9edb4 1337 * \defgroup vTaskList vTaskList
dflet 0:1e7b5dd9edb4 1338 * \ingroup TaskUtils
dflet 0:1e7b5dd9edb4 1339 */
dflet 0:1e7b5dd9edb4 1340 void vTaskList( char * pcWriteBuffer ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
dflet 0:1e7b5dd9edb4 1341
dflet 0:1e7b5dd9edb4 1342 /**
dflet 0:1e7b5dd9edb4 1343 * task. h
dflet 0:1e7b5dd9edb4 1344 * <PRE>void vTaskGetRunTimeStats( char *pcWriteBuffer );</PRE>
dflet 0:1e7b5dd9edb4 1345 *
dflet 0:1e7b5dd9edb4 1346 * configGENERATE_RUN_TIME_STATS and configUSE_STATS_FORMATTING_FUNCTIONS
dflet 0:1e7b5dd9edb4 1347 * must both be defined as 1 for this function to be available. The application
dflet 0:1e7b5dd9edb4 1348 * must also then provide definitions for
dflet 0:1e7b5dd9edb4 1349 * portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() and portGET_RUN_TIME_COUNTER_VALUE()
dflet 0:1e7b5dd9edb4 1350 * to configure a peripheral timer/counter and return the timers current count
dflet 0:1e7b5dd9edb4 1351 * value respectively. The counter should be at least 10 times the frequency of
dflet 0:1e7b5dd9edb4 1352 * the tick count.
dflet 0:1e7b5dd9edb4 1353 *
dflet 0:1e7b5dd9edb4 1354 * NOTE 1: This function will disable interrupts for its duration. It is
dflet 0:1e7b5dd9edb4 1355 * not intended for normal application runtime use but as a debug aid.
dflet 0:1e7b5dd9edb4 1356 *
dflet 0:1e7b5dd9edb4 1357 * Setting configGENERATE_RUN_TIME_STATS to 1 will result in a total
dflet 0:1e7b5dd9edb4 1358 * accumulated execution time being stored for each task. The resolution
dflet 0:1e7b5dd9edb4 1359 * of the accumulated time value depends on the frequency of the timer
dflet 0:1e7b5dd9edb4 1360 * configured by the portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() macro.
dflet 0:1e7b5dd9edb4 1361 * Calling vTaskGetRunTimeStats() writes the total execution time of each
dflet 0:1e7b5dd9edb4 1362 * task into a buffer, both as an absolute count value and as a percentage
dflet 0:1e7b5dd9edb4 1363 * of the total system execution time.
dflet 0:1e7b5dd9edb4 1364 *
dflet 0:1e7b5dd9edb4 1365 * NOTE 2:
dflet 0:1e7b5dd9edb4 1366 *
dflet 0:1e7b5dd9edb4 1367 * This function is provided for convenience only, and is used by many of the
dflet 0:1e7b5dd9edb4 1368 * demo applications. Do not consider it to be part of the scheduler.
dflet 0:1e7b5dd9edb4 1369 *
dflet 0:1e7b5dd9edb4 1370 * vTaskGetRunTimeStats() calls uxTaskGetSystemState(), then formats part of the
dflet 0:1e7b5dd9edb4 1371 * uxTaskGetSystemState() output into a human readable table that displays the
dflet 0:1e7b5dd9edb4 1372 * amount of time each task has spent in the Running state in both absolute and
dflet 0:1e7b5dd9edb4 1373 * percentage terms.
dflet 0:1e7b5dd9edb4 1374 *
dflet 0:1e7b5dd9edb4 1375 * vTaskGetRunTimeStats() has a dependency on the sprintf() C library function
dflet 0:1e7b5dd9edb4 1376 * that might bloat the code size, use a lot of stack, and provide different
dflet 0:1e7b5dd9edb4 1377 * results on different platforms. An alternative, tiny, third party, and
dflet 0:1e7b5dd9edb4 1378 * limited functionality implementation of sprintf() is provided in many of the
dflet 0:1e7b5dd9edb4 1379 * FreeRTOS/Demo sub-directories in a file called printf-stdarg.c (note
dflet 0:1e7b5dd9edb4 1380 * printf-stdarg.c does not provide a full snprintf() implementation!).
dflet 0:1e7b5dd9edb4 1381 *
dflet 0:1e7b5dd9edb4 1382 * It is recommended that production systems call uxTaskGetSystemState() directly
dflet 0:1e7b5dd9edb4 1383 * to get access to raw stats data, rather than indirectly through a call to
dflet 0:1e7b5dd9edb4 1384 * vTaskGetRunTimeStats().
dflet 0:1e7b5dd9edb4 1385 *
dflet 0:1e7b5dd9edb4 1386 * @param pcWriteBuffer A buffer into which the execution times will be
dflet 0:1e7b5dd9edb4 1387 * written, in ASCII form. This buffer is assumed to be large enough to
dflet 0:1e7b5dd9edb4 1388 * contain the generated report. Approximately 40 bytes per task should
dflet 0:1e7b5dd9edb4 1389 * be sufficient.
dflet 0:1e7b5dd9edb4 1390 *
dflet 0:1e7b5dd9edb4 1391 * \defgroup vTaskGetRunTimeStats vTaskGetRunTimeStats
dflet 0:1e7b5dd9edb4 1392 * \ingroup TaskUtils
dflet 0:1e7b5dd9edb4 1393 */
dflet 0:1e7b5dd9edb4 1394 void vTaskGetRunTimeStats( char *pcWriteBuffer ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
dflet 0:1e7b5dd9edb4 1395
dflet 0:1e7b5dd9edb4 1396 /**
dflet 0:1e7b5dd9edb4 1397 * task. h
dflet 0:1e7b5dd9edb4 1398 * <PRE>BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction );</PRE>
dflet 0:1e7b5dd9edb4 1399 *
dflet 0:1e7b5dd9edb4 1400 * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this
dflet 0:1e7b5dd9edb4 1401 * function to be available.
dflet 0:1e7b5dd9edb4 1402 *
dflet 0:1e7b5dd9edb4 1403 * When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private
dflet 0:1e7b5dd9edb4 1404 * "notification value", which is a 32-bit unsigned integer (uint32_t).
dflet 0:1e7b5dd9edb4 1405 *
dflet 0:1e7b5dd9edb4 1406 * Events can be sent to a task using an intermediary object. Examples of such
dflet 0:1e7b5dd9edb4 1407 * objects are queues, semaphores, mutexes and event groups. Task notifications
dflet 0:1e7b5dd9edb4 1408 * are a method of sending an event directly to a task without the need for such
dflet 0:1e7b5dd9edb4 1409 * an intermediary object.
dflet 0:1e7b5dd9edb4 1410 *
dflet 0:1e7b5dd9edb4 1411 * A notification sent to a task can optionally perform an action, such as
dflet 0:1e7b5dd9edb4 1412 * update, overwrite or increment the task's notification value. In that way
dflet 0:1e7b5dd9edb4 1413 * task notifications can be used to send data to a task, or be used as light
dflet 0:1e7b5dd9edb4 1414 * weight and fast binary or counting semaphores.
dflet 0:1e7b5dd9edb4 1415 *
dflet 0:1e7b5dd9edb4 1416 * A notification sent to a task will remain pending until it is cleared by the
dflet 0:1e7b5dd9edb4 1417 * task calling xTaskNotifyWait() or ulTaskNotifyTake(). If the task was
dflet 0:1e7b5dd9edb4 1418 * already in the Blocked state to wait for a notification when the notification
dflet 0:1e7b5dd9edb4 1419 * arrives then the task will automatically be removed from the Blocked state
dflet 0:1e7b5dd9edb4 1420 * (unblocked) and the notification cleared.
dflet 0:1e7b5dd9edb4 1421 *
dflet 0:1e7b5dd9edb4 1422 * A task can use xTaskNotifyWait() to [optionally] block to wait for a
dflet 0:1e7b5dd9edb4 1423 * notification to be pending, or ulTaskNotifyTake() to [optionally] block
dflet 0:1e7b5dd9edb4 1424 * to wait for its notification value to have a non-zero value. The task does
dflet 0:1e7b5dd9edb4 1425 * not consume any CPU time while it is in the Blocked state.
dflet 0:1e7b5dd9edb4 1426 *
dflet 0:1e7b5dd9edb4 1427 * See http://www.FreeRTOS.org/RTOS-task-notifications.html for details.
dflet 0:1e7b5dd9edb4 1428 *
dflet 0:1e7b5dd9edb4 1429 * @param xTaskToNotify The handle of the task being notified. The handle to a
dflet 0:1e7b5dd9edb4 1430 * task can be returned from the xTaskCreate() API function used to create the
dflet 0:1e7b5dd9edb4 1431 * task, and the handle of the currently running task can be obtained by calling
dflet 0:1e7b5dd9edb4 1432 * xTaskGetCurrentTaskHandle().
dflet 0:1e7b5dd9edb4 1433 *
dflet 0:1e7b5dd9edb4 1434 * @param ulValue Data that can be sent with the notification. How the data is
dflet 0:1e7b5dd9edb4 1435 * used depends on the value of the eAction parameter.
dflet 0:1e7b5dd9edb4 1436 *
dflet 0:1e7b5dd9edb4 1437 * @param eAction Specifies how the notification updates the task's notification
dflet 0:1e7b5dd9edb4 1438 * value, if at all. Valid values for eAction are as follows:
dflet 0:1e7b5dd9edb4 1439 *
dflet 0:1e7b5dd9edb4 1440 * eSetBits -
dflet 0:1e7b5dd9edb4 1441 * The task's notification value is bitwise ORed with ulValue. xTaskNofify()
dflet 0:1e7b5dd9edb4 1442 * always returns pdPASS in this case.
dflet 0:1e7b5dd9edb4 1443 *
dflet 0:1e7b5dd9edb4 1444 * eIncrement -
dflet 0:1e7b5dd9edb4 1445 * The task's notification value is incremented. ulValue is not used and
dflet 0:1e7b5dd9edb4 1446 * xTaskNotify() always returns pdPASS in this case.
dflet 0:1e7b5dd9edb4 1447 *
dflet 0:1e7b5dd9edb4 1448 * eSetValueWithOverwrite -
dflet 0:1e7b5dd9edb4 1449 * The task's notification value is set to the value of ulValue, even if the
dflet 0:1e7b5dd9edb4 1450 * task being notified had not yet processed the previous notification (the
dflet 0:1e7b5dd9edb4 1451 * task already had a notification pending). xTaskNotify() always returns
dflet 0:1e7b5dd9edb4 1452 * pdPASS in this case.
dflet 0:1e7b5dd9edb4 1453 *
dflet 0:1e7b5dd9edb4 1454 * eSetValueWithoutOverwrite -
dflet 0:1e7b5dd9edb4 1455 * If the task being notified did not already have a notification pending then
dflet 0:1e7b5dd9edb4 1456 * the task's notification value is set to ulValue and xTaskNotify() will
dflet 0:1e7b5dd9edb4 1457 * return pdPASS. If the task being notified already had a notification
dflet 0:1e7b5dd9edb4 1458 * pending then no action is performed and pdFAIL is returned.
dflet 0:1e7b5dd9edb4 1459 *
dflet 0:1e7b5dd9edb4 1460 * eNoAction -
dflet 0:1e7b5dd9edb4 1461 * The task receives a notification without its notification value being
dflet 0:1e7b5dd9edb4 1462 * updated. ulValue is not used and xTaskNotify() always returns pdPASS in
dflet 0:1e7b5dd9edb4 1463 * this case.
dflet 0:1e7b5dd9edb4 1464 *
dflet 0:1e7b5dd9edb4 1465 * pulPreviousNotificationValue -
dflet 0:1e7b5dd9edb4 1466 * Can be used to pass out the subject task's notification value before any
dflet 0:1e7b5dd9edb4 1467 * bits are modified by the notify function.
dflet 0:1e7b5dd9edb4 1468 *
dflet 0:1e7b5dd9edb4 1469 * @return Dependent on the value of eAction. See the description of the
dflet 0:1e7b5dd9edb4 1470 * eAction parameter.
dflet 0:1e7b5dd9edb4 1471 *
dflet 0:1e7b5dd9edb4 1472 * \defgroup xTaskNotify xTaskNotify
dflet 0:1e7b5dd9edb4 1473 * \ingroup TaskNotifications
dflet 0:1e7b5dd9edb4 1474 */
dflet 0:1e7b5dd9edb4 1475 BaseType_t xTaskGenericNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue );
dflet 0:1e7b5dd9edb4 1476 #define xTaskNotify( xTaskToNotify, ulValue, eAction ) xTaskGenericNotify( ( xTaskToNotify ), ( ulValue ), ( eAction ), NULL )
dflet 0:1e7b5dd9edb4 1477 #define xTaskNotifyAndQuery( xTaskToNotify, ulValue, eAction, pulPreviousNotifyValue ) xTaskGenericNotify( ( xTaskToNotify ), ( ulValue ), ( eAction ), ( pulPreviousNotifyValue ) )
dflet 0:1e7b5dd9edb4 1478
dflet 0:1e7b5dd9edb4 1479 /**
dflet 0:1e7b5dd9edb4 1480 * task. h
dflet 0:1e7b5dd9edb4 1481 * <PRE>BaseType_t xTaskNotifyFromISR( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, BaseType_t *pxHigherPriorityTaskWoken );</PRE>
dflet 0:1e7b5dd9edb4 1482 *
dflet 0:1e7b5dd9edb4 1483 * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this
dflet 0:1e7b5dd9edb4 1484 * function to be available.
dflet 0:1e7b5dd9edb4 1485 *
dflet 0:1e7b5dd9edb4 1486 * When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private
dflet 0:1e7b5dd9edb4 1487 * "notification value", which is a 32-bit unsigned integer (uint32_t).
dflet 0:1e7b5dd9edb4 1488 *
dflet 0:1e7b5dd9edb4 1489 * A version of xTaskNotify() that can be used from an interrupt service routine
dflet 0:1e7b5dd9edb4 1490 * (ISR).
dflet 0:1e7b5dd9edb4 1491 *
dflet 0:1e7b5dd9edb4 1492 * Events can be sent to a task using an intermediary object. Examples of such
dflet 0:1e7b5dd9edb4 1493 * objects are queues, semaphores, mutexes and event groups. Task notifications
dflet 0:1e7b5dd9edb4 1494 * are a method of sending an event directly to a task without the need for such
dflet 0:1e7b5dd9edb4 1495 * an intermediary object.
dflet 0:1e7b5dd9edb4 1496 *
dflet 0:1e7b5dd9edb4 1497 * A notification sent to a task can optionally perform an action, such as
dflet 0:1e7b5dd9edb4 1498 * update, overwrite or increment the task's notification value. In that way
dflet 0:1e7b5dd9edb4 1499 * task notifications can be used to send data to a task, or be used as light
dflet 0:1e7b5dd9edb4 1500 * weight and fast binary or counting semaphores.
dflet 0:1e7b5dd9edb4 1501 *
dflet 0:1e7b5dd9edb4 1502 * A notification sent to a task will remain pending until it is cleared by the
dflet 0:1e7b5dd9edb4 1503 * task calling xTaskNotifyWait() or ulTaskNotifyTake(). If the task was
dflet 0:1e7b5dd9edb4 1504 * already in the Blocked state to wait for a notification when the notification
dflet 0:1e7b5dd9edb4 1505 * arrives then the task will automatically be removed from the Blocked state
dflet 0:1e7b5dd9edb4 1506 * (unblocked) and the notification cleared.
dflet 0:1e7b5dd9edb4 1507 *
dflet 0:1e7b5dd9edb4 1508 * A task can use xTaskNotifyWait() to [optionally] block to wait for a
dflet 0:1e7b5dd9edb4 1509 * notification to be pending, or ulTaskNotifyTake() to [optionally] block
dflet 0:1e7b5dd9edb4 1510 * to wait for its notification value to have a non-zero value. The task does
dflet 0:1e7b5dd9edb4 1511 * not consume any CPU time while it is in the Blocked state.
dflet 0:1e7b5dd9edb4 1512 *
dflet 0:1e7b5dd9edb4 1513 * See http://www.FreeRTOS.org/RTOS-task-notifications.html for details.
dflet 0:1e7b5dd9edb4 1514 *
dflet 0:1e7b5dd9edb4 1515 * @param xTaskToNotify The handle of the task being notified. The handle to a
dflet 0:1e7b5dd9edb4 1516 * task can be returned from the xTaskCreate() API function used to create the
dflet 0:1e7b5dd9edb4 1517 * task, and the handle of the currently running task can be obtained by calling
dflet 0:1e7b5dd9edb4 1518 * xTaskGetCurrentTaskHandle().
dflet 0:1e7b5dd9edb4 1519 *
dflet 0:1e7b5dd9edb4 1520 * @param ulValue Data that can be sent with the notification. How the data is
dflet 0:1e7b5dd9edb4 1521 * used depends on the value of the eAction parameter.
dflet 0:1e7b5dd9edb4 1522 *
dflet 0:1e7b5dd9edb4 1523 * @param eAction Specifies how the notification updates the task's notification
dflet 0:1e7b5dd9edb4 1524 * value, if at all. Valid values for eAction are as follows:
dflet 0:1e7b5dd9edb4 1525 *
dflet 0:1e7b5dd9edb4 1526 * eSetBits -
dflet 0:1e7b5dd9edb4 1527 * The task's notification value is bitwise ORed with ulValue. xTaskNofify()
dflet 0:1e7b5dd9edb4 1528 * always returns pdPASS in this case.
dflet 0:1e7b5dd9edb4 1529 *
dflet 0:1e7b5dd9edb4 1530 * eIncrement -
dflet 0:1e7b5dd9edb4 1531 * The task's notification value is incremented. ulValue is not used and
dflet 0:1e7b5dd9edb4 1532 * xTaskNotify() always returns pdPASS in this case.
dflet 0:1e7b5dd9edb4 1533 *
dflet 0:1e7b5dd9edb4 1534 * eSetValueWithOverwrite -
dflet 0:1e7b5dd9edb4 1535 * The task's notification value is set to the value of ulValue, even if the
dflet 0:1e7b5dd9edb4 1536 * task being notified had not yet processed the previous notification (the
dflet 0:1e7b5dd9edb4 1537 * task already had a notification pending). xTaskNotify() always returns
dflet 0:1e7b5dd9edb4 1538 * pdPASS in this case.
dflet 0:1e7b5dd9edb4 1539 *
dflet 0:1e7b5dd9edb4 1540 * eSetValueWithoutOverwrite -
dflet 0:1e7b5dd9edb4 1541 * If the task being notified did not already have a notification pending then
dflet 0:1e7b5dd9edb4 1542 * the task's notification value is set to ulValue and xTaskNotify() will
dflet 0:1e7b5dd9edb4 1543 * return pdPASS. If the task being notified already had a notification
dflet 0:1e7b5dd9edb4 1544 * pending then no action is performed and pdFAIL is returned.
dflet 0:1e7b5dd9edb4 1545 *
dflet 0:1e7b5dd9edb4 1546 * eNoAction -
dflet 0:1e7b5dd9edb4 1547 * The task receives a notification without its notification value being
dflet 0:1e7b5dd9edb4 1548 * updated. ulValue is not used and xTaskNotify() always returns pdPASS in
dflet 0:1e7b5dd9edb4 1549 * this case.
dflet 0:1e7b5dd9edb4 1550 *
dflet 0:1e7b5dd9edb4 1551 * @param pxHigherPriorityTaskWoken xTaskNotifyFromISR() will set
dflet 0:1e7b5dd9edb4 1552 * *pxHigherPriorityTaskWoken to pdTRUE if sending the notification caused the
dflet 0:1e7b5dd9edb4 1553 * task to which the notification was sent to leave the Blocked state, and the
dflet 0:1e7b5dd9edb4 1554 * unblocked task has a priority higher than the currently running task. If
dflet 0:1e7b5dd9edb4 1555 * xTaskNotifyFromISR() sets this value to pdTRUE then a context switch should
dflet 0:1e7b5dd9edb4 1556 * be requested before the interrupt is exited. How a context switch is
dflet 0:1e7b5dd9edb4 1557 * requested from an ISR is dependent on the port - see the documentation page
dflet 0:1e7b5dd9edb4 1558 * for the port in use.
dflet 0:1e7b5dd9edb4 1559 *
dflet 0:1e7b5dd9edb4 1560 * @return Dependent on the value of eAction. See the description of the
dflet 0:1e7b5dd9edb4 1561 * eAction parameter.
dflet 0:1e7b5dd9edb4 1562 *
dflet 0:1e7b5dd9edb4 1563 * \defgroup xTaskNotify xTaskNotify
dflet 0:1e7b5dd9edb4 1564 * \ingroup TaskNotifications
dflet 0:1e7b5dd9edb4 1565 */
dflet 0:1e7b5dd9edb4 1566 BaseType_t xTaskNotifyFromISR( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, BaseType_t *pxHigherPriorityTaskWoken );
dflet 0:1e7b5dd9edb4 1567
dflet 0:1e7b5dd9edb4 1568 /**
dflet 0:1e7b5dd9edb4 1569 * task. h
dflet 0:1e7b5dd9edb4 1570 * <PRE>BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait );</pre>
dflet 0:1e7b5dd9edb4 1571 *
dflet 0:1e7b5dd9edb4 1572 * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this
dflet 0:1e7b5dd9edb4 1573 * function to be available.
dflet 0:1e7b5dd9edb4 1574 *
dflet 0:1e7b5dd9edb4 1575 * When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private
dflet 0:1e7b5dd9edb4 1576 * "notification value", which is a 32-bit unsigned integer (uint32_t).
dflet 0:1e7b5dd9edb4 1577 *
dflet 0:1e7b5dd9edb4 1578 * Events can be sent to a task using an intermediary object. Examples of such
dflet 0:1e7b5dd9edb4 1579 * objects are queues, semaphores, mutexes and event groups. Task notifications
dflet 0:1e7b5dd9edb4 1580 * are a method of sending an event directly to a task without the need for such
dflet 0:1e7b5dd9edb4 1581 * an intermediary object.
dflet 0:1e7b5dd9edb4 1582 *
dflet 0:1e7b5dd9edb4 1583 * A notification sent to a task can optionally perform an action, such as
dflet 0:1e7b5dd9edb4 1584 * update, overwrite or increment the task's notification value. In that way
dflet 0:1e7b5dd9edb4 1585 * task notifications can be used to send data to a task, or be used as light
dflet 0:1e7b5dd9edb4 1586 * weight and fast binary or counting semaphores.
dflet 0:1e7b5dd9edb4 1587 *
dflet 0:1e7b5dd9edb4 1588 * A notification sent to a task will remain pending until it is cleared by the
dflet 0:1e7b5dd9edb4 1589 * task calling xTaskNotifyWait() or ulTaskNotifyTake(). If the task was
dflet 0:1e7b5dd9edb4 1590 * already in the Blocked state to wait for a notification when the notification
dflet 0:1e7b5dd9edb4 1591 * arrives then the task will automatically be removed from the Blocked state
dflet 0:1e7b5dd9edb4 1592 * (unblocked) and the notification cleared.
dflet 0:1e7b5dd9edb4 1593 *
dflet 0:1e7b5dd9edb4 1594 * A task can use xTaskNotifyWait() to [optionally] block to wait for a
dflet 0:1e7b5dd9edb4 1595 * notification to be pending, or ulTaskNotifyTake() to [optionally] block
dflet 0:1e7b5dd9edb4 1596 * to wait for its notification value to have a non-zero value. The task does
dflet 0:1e7b5dd9edb4 1597 * not consume any CPU time while it is in the Blocked state.
dflet 0:1e7b5dd9edb4 1598 *
dflet 0:1e7b5dd9edb4 1599 * See http://www.FreeRTOS.org/RTOS-task-notifications.html for details.
dflet 0:1e7b5dd9edb4 1600 *
dflet 0:1e7b5dd9edb4 1601 * @param ulBitsToClearOnEntry Bits that are set in ulBitsToClearOnEntry value
dflet 0:1e7b5dd9edb4 1602 * will be cleared in the calling task's notification value before the task
dflet 0:1e7b5dd9edb4 1603 * checks to see if any notifications are pending, and optionally blocks if no
dflet 0:1e7b5dd9edb4 1604 * notifications are pending. Setting ulBitsToClearOnEntry to ULONG_MAX (if
dflet 0:1e7b5dd9edb4 1605 * limits.h is included) or 0xffffffffUL (if limits.h is not included) will have
dflet 0:1e7b5dd9edb4 1606 * the effect of resetting the task's notification value to 0. Setting
dflet 0:1e7b5dd9edb4 1607 * ulBitsToClearOnEntry to 0 will leave the task's notification value unchanged.
dflet 0:1e7b5dd9edb4 1608 *
dflet 0:1e7b5dd9edb4 1609 * @param ulBitsToClearOnExit If a notification is pending or received before
dflet 0:1e7b5dd9edb4 1610 * the calling task exits the xTaskNotifyWait() function then the task's
dflet 0:1e7b5dd9edb4 1611 * notification value (see the xTaskNotify() API function) is passed out using
dflet 0:1e7b5dd9edb4 1612 * the pulNotificationValue parameter. Then any bits that are set in
dflet 0:1e7b5dd9edb4 1613 * ulBitsToClearOnExit will be cleared in the task's notification value (note
dflet 0:1e7b5dd9edb4 1614 * *pulNotificationValue is set before any bits are cleared). Setting
dflet 0:1e7b5dd9edb4 1615 * ulBitsToClearOnExit to ULONG_MAX (if limits.h is included) or 0xffffffffUL
dflet 0:1e7b5dd9edb4 1616 * (if limits.h is not included) will have the effect of resetting the task's
dflet 0:1e7b5dd9edb4 1617 * notification value to 0 before the function exits. Setting
dflet 0:1e7b5dd9edb4 1618 * ulBitsToClearOnExit to 0 will leave the task's notification value unchanged
dflet 0:1e7b5dd9edb4 1619 * when the function exits (in which case the value passed out in
dflet 0:1e7b5dd9edb4 1620 * pulNotificationValue will match the task's notification value).
dflet 0:1e7b5dd9edb4 1621 *
dflet 0:1e7b5dd9edb4 1622 * @param pulNotificationValue Used to pass the task's notification value out
dflet 0:1e7b5dd9edb4 1623 * of the function. Note the value passed out will not be effected by the
dflet 0:1e7b5dd9edb4 1624 * clearing of any bits caused by ulBitsToClearOnExit being non-zero.
dflet 0:1e7b5dd9edb4 1625 *
dflet 0:1e7b5dd9edb4 1626 * @param xTicksToWait The maximum amount of time that the task should wait in
dflet 0:1e7b5dd9edb4 1627 * the Blocked state for a notification to be received, should a notification
dflet 0:1e7b5dd9edb4 1628 * not already be pending when xTaskNotifyWait() was called. The task
dflet 0:1e7b5dd9edb4 1629 * will not consume any processing time while it is in the Blocked state. This
dflet 0:1e7b5dd9edb4 1630 * is specified in kernel ticks, the macro pdMS_TO_TICSK( value_in_ms ) can be
dflet 0:1e7b5dd9edb4 1631 * used to convert a time specified in milliseconds to a time specified in
dflet 0:1e7b5dd9edb4 1632 * ticks.
dflet 0:1e7b5dd9edb4 1633 *
dflet 0:1e7b5dd9edb4 1634 * @return If a notification was received (including notifications that were
dflet 0:1e7b5dd9edb4 1635 * already pending when xTaskNotifyWait was called) then pdPASS is
dflet 0:1e7b5dd9edb4 1636 * returned. Otherwise pdFAIL is returned.
dflet 0:1e7b5dd9edb4 1637 *
dflet 0:1e7b5dd9edb4 1638 * \defgroup xTaskNotifyWait xTaskNotifyWait
dflet 0:1e7b5dd9edb4 1639 * \ingroup TaskNotifications
dflet 0:1e7b5dd9edb4 1640 */
dflet 0:1e7b5dd9edb4 1641 BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait );
dflet 0:1e7b5dd9edb4 1642
dflet 0:1e7b5dd9edb4 1643 /**
dflet 0:1e7b5dd9edb4 1644 * task. h
dflet 0:1e7b5dd9edb4 1645 * <PRE>BaseType_t xTaskNotifyGive( TaskHandle_t xTaskToNotify );</PRE>
dflet 0:1e7b5dd9edb4 1646 *
dflet 0:1e7b5dd9edb4 1647 * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this macro
dflet 0:1e7b5dd9edb4 1648 * to be available.
dflet 0:1e7b5dd9edb4 1649 *
dflet 0:1e7b5dd9edb4 1650 * When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private
dflet 0:1e7b5dd9edb4 1651 * "notification value", which is a 32-bit unsigned integer (uint32_t).
dflet 0:1e7b5dd9edb4 1652 *
dflet 0:1e7b5dd9edb4 1653 * Events can be sent to a task using an intermediary object. Examples of such
dflet 0:1e7b5dd9edb4 1654 * objects are queues, semaphores, mutexes and event groups. Task notifications
dflet 0:1e7b5dd9edb4 1655 * are a method of sending an event directly to a task without the need for such
dflet 0:1e7b5dd9edb4 1656 * an intermediary object.
dflet 0:1e7b5dd9edb4 1657 *
dflet 0:1e7b5dd9edb4 1658 * A notification sent to a task can optionally perform an action, such as
dflet 0:1e7b5dd9edb4 1659 * update, overwrite or increment the task's notification value. In that way
dflet 0:1e7b5dd9edb4 1660 * task notifications can be used to send data to a task, or be used as light
dflet 0:1e7b5dd9edb4 1661 * weight and fast binary or counting semaphores.
dflet 0:1e7b5dd9edb4 1662 *
dflet 0:1e7b5dd9edb4 1663 * xTaskNotifyGive() is a helper macro intended for use when task notifications
dflet 0:1e7b5dd9edb4 1664 * are used as light weight and faster binary or counting semaphore equivalents.
dflet 0:1e7b5dd9edb4 1665 * Actual FreeRTOS semaphores are given using the xSemaphoreGive() API function,
dflet 0:1e7b5dd9edb4 1666 * the equivalent action that instead uses a task notification is
dflet 0:1e7b5dd9edb4 1667 * xTaskNotifyGive().
dflet 0:1e7b5dd9edb4 1668 *
dflet 0:1e7b5dd9edb4 1669 * When task notifications are being used as a binary or counting semaphore
dflet 0:1e7b5dd9edb4 1670 * equivalent then the task being notified should wait for the notification
dflet 0:1e7b5dd9edb4 1671 * using the ulTaskNotificationTake() API function rather than the
dflet 0:1e7b5dd9edb4 1672 * xTaskNotifyWait() API function.
dflet 0:1e7b5dd9edb4 1673 *
dflet 0:1e7b5dd9edb4 1674 * See http://www.FreeRTOS.org/RTOS-task-notifications.html for more details.
dflet 0:1e7b5dd9edb4 1675 *
dflet 0:1e7b5dd9edb4 1676 * @param xTaskToNotify The handle of the task being notified. The handle to a
dflet 0:1e7b5dd9edb4 1677 * task can be returned from the xTaskCreate() API function used to create the
dflet 0:1e7b5dd9edb4 1678 * task, and the handle of the currently running task can be obtained by calling
dflet 0:1e7b5dd9edb4 1679 * xTaskGetCurrentTaskHandle().
dflet 0:1e7b5dd9edb4 1680 *
dflet 0:1e7b5dd9edb4 1681 * @return xTaskNotifyGive() is a macro that calls xTaskNotify() with the
dflet 0:1e7b5dd9edb4 1682 * eAction parameter set to eIncrement - so pdPASS is always returned.
dflet 0:1e7b5dd9edb4 1683 *
dflet 0:1e7b5dd9edb4 1684 * \defgroup xTaskNotifyGive xTaskNotifyGive
dflet 0:1e7b5dd9edb4 1685 * \ingroup TaskNotifications
dflet 0:1e7b5dd9edb4 1686 */
dflet 0:1e7b5dd9edb4 1687 #define xTaskNotifyGive( xTaskToNotify ) xTaskNotify( ( xTaskToNotify ), 0, eIncrement );
dflet 0:1e7b5dd9edb4 1688
dflet 0:1e7b5dd9edb4 1689 /**
dflet 0:1e7b5dd9edb4 1690 * task. h
dflet 0:1e7b5dd9edb4 1691 * <PRE>void vTaskNotifyGiveFromISR( TaskHandle_t xTaskHandle, BaseType_t *pxHigherPriorityTaskWoken );
dflet 0:1e7b5dd9edb4 1692 *
dflet 0:1e7b5dd9edb4 1693 * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this macro
dflet 0:1e7b5dd9edb4 1694 * to be available.
dflet 0:1e7b5dd9edb4 1695 *
dflet 0:1e7b5dd9edb4 1696 * When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private
dflet 0:1e7b5dd9edb4 1697 * "notification value", which is a 32-bit unsigned integer (uint32_t).
dflet 0:1e7b5dd9edb4 1698 *
dflet 0:1e7b5dd9edb4 1699 * A version of xTaskNotifyGive() that can be called from an interrupt service
dflet 0:1e7b5dd9edb4 1700 * routine (ISR).
dflet 0:1e7b5dd9edb4 1701 *
dflet 0:1e7b5dd9edb4 1702 * Events can be sent to a task using an intermediary object. Examples of such
dflet 0:1e7b5dd9edb4 1703 * objects are queues, semaphores, mutexes and event groups. Task notifications
dflet 0:1e7b5dd9edb4 1704 * are a method of sending an event directly to a task without the need for such
dflet 0:1e7b5dd9edb4 1705 * an intermediary object.
dflet 0:1e7b5dd9edb4 1706 *
dflet 0:1e7b5dd9edb4 1707 * A notification sent to a task can optionally perform an action, such as
dflet 0:1e7b5dd9edb4 1708 * update, overwrite or increment the task's notification value. In that way
dflet 0:1e7b5dd9edb4 1709 * task notifications can be used to send data to a task, or be used as light
dflet 0:1e7b5dd9edb4 1710 * weight and fast binary or counting semaphores.
dflet 0:1e7b5dd9edb4 1711 *
dflet 0:1e7b5dd9edb4 1712 * vTaskNotifyGiveFromISR() is intended for use when task notifications are
dflet 0:1e7b5dd9edb4 1713 * used as light weight and faster binary or counting semaphore equivalents.
dflet 0:1e7b5dd9edb4 1714 * Actual FreeRTOS semaphores are given from an ISR using the
dflet 0:1e7b5dd9edb4 1715 * xSemaphoreGiveFromISR() API function, the equivalent action that instead uses
dflet 0:1e7b5dd9edb4 1716 * a task notification is vTaskNotifyGiveFromISR().
dflet 0:1e7b5dd9edb4 1717 *
dflet 0:1e7b5dd9edb4 1718 * When task notifications are being used as a binary or counting semaphore
dflet 0:1e7b5dd9edb4 1719 * equivalent then the task being notified should wait for the notification
dflet 0:1e7b5dd9edb4 1720 * using the ulTaskNotificationTake() API function rather than the
dflet 0:1e7b5dd9edb4 1721 * xTaskNotifyWait() API function.
dflet 0:1e7b5dd9edb4 1722 *
dflet 0:1e7b5dd9edb4 1723 * See http://www.FreeRTOS.org/RTOS-task-notifications.html for more details.
dflet 0:1e7b5dd9edb4 1724 *
dflet 0:1e7b5dd9edb4 1725 * @param xTaskToNotify The handle of the task being notified. The handle to a
dflet 0:1e7b5dd9edb4 1726 * task can be returned from the xTaskCreate() API function used to create the
dflet 0:1e7b5dd9edb4 1727 * task, and the handle of the currently running task can be obtained by calling
dflet 0:1e7b5dd9edb4 1728 * xTaskGetCurrentTaskHandle().
dflet 0:1e7b5dd9edb4 1729 *
dflet 0:1e7b5dd9edb4 1730 * @param pxHigherPriorityTaskWoken vTaskNotifyGiveFromISR() will set
dflet 0:1e7b5dd9edb4 1731 * *pxHigherPriorityTaskWoken to pdTRUE if sending the notification caused the
dflet 0:1e7b5dd9edb4 1732 * task to which the notification was sent to leave the Blocked state, and the
dflet 0:1e7b5dd9edb4 1733 * unblocked task has a priority higher than the currently running task. If
dflet 0:1e7b5dd9edb4 1734 * vTaskNotifyGiveFromISR() sets this value to pdTRUE then a context switch
dflet 0:1e7b5dd9edb4 1735 * should be requested before the interrupt is exited. How a context switch is
dflet 0:1e7b5dd9edb4 1736 * requested from an ISR is dependent on the port - see the documentation page
dflet 0:1e7b5dd9edb4 1737 * for the port in use.
dflet 0:1e7b5dd9edb4 1738 *
dflet 0:1e7b5dd9edb4 1739 * \defgroup xTaskNotifyWait xTaskNotifyWait
dflet 0:1e7b5dd9edb4 1740 * \ingroup TaskNotifications
dflet 0:1e7b5dd9edb4 1741 */
dflet 0:1e7b5dd9edb4 1742 void vTaskNotifyGiveFromISR( TaskHandle_t xTaskToNotify, BaseType_t *pxHigherPriorityTaskWoken );
dflet 0:1e7b5dd9edb4 1743
dflet 0:1e7b5dd9edb4 1744 /**
dflet 0:1e7b5dd9edb4 1745 * task. h
dflet 0:1e7b5dd9edb4 1746 * <PRE>uint32_t ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait );</pre>
dflet 0:1e7b5dd9edb4 1747 *
dflet 0:1e7b5dd9edb4 1748 * configUSE_TASK_NOTIFICATIONS must be undefined or defined as 1 for this
dflet 0:1e7b5dd9edb4 1749 * function to be available.
dflet 0:1e7b5dd9edb4 1750 *
dflet 0:1e7b5dd9edb4 1751 * When configUSE_TASK_NOTIFICATIONS is set to one each task has its own private
dflet 0:1e7b5dd9edb4 1752 * "notification value", which is a 32-bit unsigned integer (uint32_t).
dflet 0:1e7b5dd9edb4 1753 *
dflet 0:1e7b5dd9edb4 1754 * Events can be sent to a task using an intermediary object. Examples of such
dflet 0:1e7b5dd9edb4 1755 * objects are queues, semaphores, mutexes and event groups. Task notifications
dflet 0:1e7b5dd9edb4 1756 * are a method of sending an event directly to a task without the need for such
dflet 0:1e7b5dd9edb4 1757 * an intermediary object.
dflet 0:1e7b5dd9edb4 1758 *
dflet 0:1e7b5dd9edb4 1759 * A notification sent to a task can optionally perform an action, such as
dflet 0:1e7b5dd9edb4 1760 * update, overwrite or increment the task's notification value. In that way
dflet 0:1e7b5dd9edb4 1761 * task notifications can be used to send data to a task, or be used as light
dflet 0:1e7b5dd9edb4 1762 * weight and fast binary or counting semaphores.
dflet 0:1e7b5dd9edb4 1763 *
dflet 0:1e7b5dd9edb4 1764 * ulTaskNotifyTake() is intended for use when a task notification is used as a
dflet 0:1e7b5dd9edb4 1765 * faster and lighter weight binary or counting semaphore alternative. Actual
dflet 0:1e7b5dd9edb4 1766 * FreeRTOS semaphores are taken using the xSemaphoreTake() API function, the
dflet 0:1e7b5dd9edb4 1767 * equivalent action that instead uses a task notification is
dflet 0:1e7b5dd9edb4 1768 * ulTaskNotifyTake().
dflet 0:1e7b5dd9edb4 1769 *
dflet 0:1e7b5dd9edb4 1770 * When a task is using its notification value as a binary or counting semaphore
dflet 0:1e7b5dd9edb4 1771 * other tasks should send notifications to it using the xTaskNotifyGive()
dflet 0:1e7b5dd9edb4 1772 * macro, or xTaskNotify() function with the eAction parameter set to
dflet 0:1e7b5dd9edb4 1773 * eIncrement.
dflet 0:1e7b5dd9edb4 1774 *
dflet 0:1e7b5dd9edb4 1775 * ulTaskNotifyTake() can either clear the task's notification value to
dflet 0:1e7b5dd9edb4 1776 * zero on exit, in which case the notification value acts like a binary
dflet 0:1e7b5dd9edb4 1777 * semaphore, or decrement the task's notification value on exit, in which case
dflet 0:1e7b5dd9edb4 1778 * the notification value acts like a counting semaphore.
dflet 0:1e7b5dd9edb4 1779 *
dflet 0:1e7b5dd9edb4 1780 * A task can use ulTaskNotifyTake() to [optionally] block to wait for a
dflet 0:1e7b5dd9edb4 1781 * the task's notification value to be non-zero. The task does not consume any
dflet 0:1e7b5dd9edb4 1782 * CPU time while it is in the Blocked state.
dflet 0:1e7b5dd9edb4 1783 *
dflet 0:1e7b5dd9edb4 1784 * Where as xTaskNotifyWait() will return when a notification is pending,
dflet 0:1e7b5dd9edb4 1785 * ulTaskNotifyTake() will return when the task's notification value is
dflet 0:1e7b5dd9edb4 1786 * not zero.
dflet 0:1e7b5dd9edb4 1787 *
dflet 0:1e7b5dd9edb4 1788 * See http://www.FreeRTOS.org/RTOS-task-notifications.html for details.
dflet 0:1e7b5dd9edb4 1789 *
dflet 0:1e7b5dd9edb4 1790 * @param xClearCountOnExit if xClearCountOnExit is pdFALSE then the task's
dflet 0:1e7b5dd9edb4 1791 * notification value is decremented when the function exits. In this way the
dflet 0:1e7b5dd9edb4 1792 * notification value acts like a counting semaphore. If xClearCountOnExit is
dflet 0:1e7b5dd9edb4 1793 * not pdFALSE then the task's notification value is cleared to zero when the
dflet 0:1e7b5dd9edb4 1794 * function exits. In this way the notification value acts like a binary
dflet 0:1e7b5dd9edb4 1795 * semaphore.
dflet 0:1e7b5dd9edb4 1796 *
dflet 0:1e7b5dd9edb4 1797 * @param xTicksToWait The maximum amount of time that the task should wait in
dflet 0:1e7b5dd9edb4 1798 * the Blocked state for the task's notification value to be greater than zero,
dflet 0:1e7b5dd9edb4 1799 * should the count not already be greater than zero when
dflet 0:1e7b5dd9edb4 1800 * ulTaskNotifyTake() was called. The task will not consume any processing
dflet 0:1e7b5dd9edb4 1801 * time while it is in the Blocked state. This is specified in kernel ticks,
dflet 0:1e7b5dd9edb4 1802 * the macro pdMS_TO_TICSK( value_in_ms ) can be used to convert a time
dflet 0:1e7b5dd9edb4 1803 * specified in milliseconds to a time specified in ticks.
dflet 0:1e7b5dd9edb4 1804 *
dflet 0:1e7b5dd9edb4 1805 * @return The task's notification count before it is either cleared to zero or
dflet 0:1e7b5dd9edb4 1806 * decremented (see the xClearCountOnExit parameter).
dflet 0:1e7b5dd9edb4 1807 *
dflet 0:1e7b5dd9edb4 1808 * \defgroup ulTaskNotifyTake ulTaskNotifyTake
dflet 0:1e7b5dd9edb4 1809 * \ingroup TaskNotifications
dflet 0:1e7b5dd9edb4 1810 */
dflet 0:1e7b5dd9edb4 1811 uint32_t ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait );
dflet 0:1e7b5dd9edb4 1812
dflet 0:1e7b5dd9edb4 1813 /*-----------------------------------------------------------
dflet 0:1e7b5dd9edb4 1814 * SCHEDULER INTERNALS AVAILABLE FOR PORTING PURPOSES
dflet 0:1e7b5dd9edb4 1815 *----------------------------------------------------------*/
dflet 0:1e7b5dd9edb4 1816
dflet 0:1e7b5dd9edb4 1817 /*
dflet 0:1e7b5dd9edb4 1818 * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE. IT IS ONLY
dflet 0:1e7b5dd9edb4 1819 * INTENDED FOR USE WHEN IMPLEMENTING A PORT OF THE SCHEDULER AND IS
dflet 0:1e7b5dd9edb4 1820 * AN INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.
dflet 0:1e7b5dd9edb4 1821 *
dflet 0:1e7b5dd9edb4 1822 * Called from the real time kernel tick (either preemptive or cooperative),
dflet 0:1e7b5dd9edb4 1823 * this increments the tick count and checks if any tasks that are blocked
dflet 0:1e7b5dd9edb4 1824 * for a finite period required removing from a blocked list and placing on
dflet 0:1e7b5dd9edb4 1825 * a ready list. If a non-zero value is returned then a context switch is
dflet 0:1e7b5dd9edb4 1826 * required because either:
dflet 0:1e7b5dd9edb4 1827 * + A task was removed from a blocked list because its timeout had expired,
dflet 0:1e7b5dd9edb4 1828 * or
dflet 0:1e7b5dd9edb4 1829 * + Time slicing is in use and there is a task of equal priority to the
dflet 0:1e7b5dd9edb4 1830 * currently running task.
dflet 0:1e7b5dd9edb4 1831 */
dflet 0:1e7b5dd9edb4 1832 BaseType_t xTaskIncrementTick( void ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 1833
dflet 0:1e7b5dd9edb4 1834 /*
dflet 0:1e7b5dd9edb4 1835 * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE. IT IS AN
dflet 0:1e7b5dd9edb4 1836 * INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.
dflet 0:1e7b5dd9edb4 1837 *
dflet 0:1e7b5dd9edb4 1838 * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED.
dflet 0:1e7b5dd9edb4 1839 *
dflet 0:1e7b5dd9edb4 1840 * Removes the calling task from the ready list and places it both
dflet 0:1e7b5dd9edb4 1841 * on the list of tasks waiting for a particular event, and the
dflet 0:1e7b5dd9edb4 1842 * list of delayed tasks. The task will be removed from both lists
dflet 0:1e7b5dd9edb4 1843 * and replaced on the ready list should either the event occur (and
dflet 0:1e7b5dd9edb4 1844 * there be no higher priority tasks waiting on the same event) or
dflet 0:1e7b5dd9edb4 1845 * the delay period expires.
dflet 0:1e7b5dd9edb4 1846 *
dflet 0:1e7b5dd9edb4 1847 * The 'unordered' version replaces the event list item value with the
dflet 0:1e7b5dd9edb4 1848 * xItemValue value, and inserts the list item at the end of the list.
dflet 0:1e7b5dd9edb4 1849 *
dflet 0:1e7b5dd9edb4 1850 * The 'ordered' version uses the existing event list item value (which is the
dflet 0:1e7b5dd9edb4 1851 * owning tasks priority) to insert the list item into the event list is task
dflet 0:1e7b5dd9edb4 1852 * priority order.
dflet 0:1e7b5dd9edb4 1853 *
dflet 0:1e7b5dd9edb4 1854 * @param pxEventList The list containing tasks that are blocked waiting
dflet 0:1e7b5dd9edb4 1855 * for the event to occur.
dflet 0:1e7b5dd9edb4 1856 *
dflet 0:1e7b5dd9edb4 1857 * @param xItemValue The item value to use for the event list item when the
dflet 0:1e7b5dd9edb4 1858 * event list is not ordered by task priority.
dflet 0:1e7b5dd9edb4 1859 *
dflet 0:1e7b5dd9edb4 1860 * @param xTicksToWait The maximum amount of time that the task should wait
dflet 0:1e7b5dd9edb4 1861 * for the event to occur. This is specified in kernel ticks,the constant
dflet 0:1e7b5dd9edb4 1862 * portTICK_PERIOD_MS can be used to convert kernel ticks into a real time
dflet 0:1e7b5dd9edb4 1863 * period.
dflet 0:1e7b5dd9edb4 1864 */
dflet 0:1e7b5dd9edb4 1865 void vTaskPlaceOnEventList( List_t * const pxEventList, const TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 1866 void vTaskPlaceOnUnorderedEventList( List_t * pxEventList, const TickType_t xItemValue, const TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 1867
dflet 0:1e7b5dd9edb4 1868 /*
dflet 0:1e7b5dd9edb4 1869 * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE. IT IS AN
dflet 0:1e7b5dd9edb4 1870 * INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.
dflet 0:1e7b5dd9edb4 1871 *
dflet 0:1e7b5dd9edb4 1872 * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED.
dflet 0:1e7b5dd9edb4 1873 *
dflet 0:1e7b5dd9edb4 1874 * This function performs nearly the same function as vTaskPlaceOnEventList().
dflet 0:1e7b5dd9edb4 1875 * The difference being that this function does not permit tasks to block
dflet 0:1e7b5dd9edb4 1876 * indefinitely, whereas vTaskPlaceOnEventList() does.
dflet 0:1e7b5dd9edb4 1877 *
dflet 0:1e7b5dd9edb4 1878 */
dflet 0:1e7b5dd9edb4 1879 void vTaskPlaceOnEventListRestricted( List_t * const pxEventList, const TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 1880
dflet 0:1e7b5dd9edb4 1881 /*
dflet 0:1e7b5dd9edb4 1882 * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE. IT IS AN
dflet 0:1e7b5dd9edb4 1883 * INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.
dflet 0:1e7b5dd9edb4 1884 *
dflet 0:1e7b5dd9edb4 1885 * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED.
dflet 0:1e7b5dd9edb4 1886 *
dflet 0:1e7b5dd9edb4 1887 * Removes a task from both the specified event list and the list of blocked
dflet 0:1e7b5dd9edb4 1888 * tasks, and places it on a ready queue.
dflet 0:1e7b5dd9edb4 1889 *
dflet 0:1e7b5dd9edb4 1890 * xTaskRemoveFromEventList()/xTaskRemoveFromUnorderedEventList() will be called
dflet 0:1e7b5dd9edb4 1891 * if either an event occurs to unblock a task, or the block timeout period
dflet 0:1e7b5dd9edb4 1892 * expires.
dflet 0:1e7b5dd9edb4 1893 *
dflet 0:1e7b5dd9edb4 1894 * xTaskRemoveFromEventList() is used when the event list is in task priority
dflet 0:1e7b5dd9edb4 1895 * order. It removes the list item from the head of the event list as that will
dflet 0:1e7b5dd9edb4 1896 * have the highest priority owning task of all the tasks on the event list.
dflet 0:1e7b5dd9edb4 1897 * xTaskRemoveFromUnorderedEventList() is used when the event list is not
dflet 0:1e7b5dd9edb4 1898 * ordered and the event list items hold something other than the owning tasks
dflet 0:1e7b5dd9edb4 1899 * priority. In this case the event list item value is updated to the value
dflet 0:1e7b5dd9edb4 1900 * passed in the xItemValue parameter.
dflet 0:1e7b5dd9edb4 1901 *
dflet 0:1e7b5dd9edb4 1902 * @return pdTRUE if the task being removed has a higher priority than the task
dflet 0:1e7b5dd9edb4 1903 * making the call, otherwise pdFALSE.
dflet 0:1e7b5dd9edb4 1904 */
dflet 0:1e7b5dd9edb4 1905 BaseType_t xTaskRemoveFromEventList( const List_t * const pxEventList ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 1906 BaseType_t xTaskRemoveFromUnorderedEventList( ListItem_t * pxEventListItem, const TickType_t xItemValue ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 1907
dflet 0:1e7b5dd9edb4 1908 /*
dflet 0:1e7b5dd9edb4 1909 * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE. IT IS ONLY
dflet 0:1e7b5dd9edb4 1910 * INTENDED FOR USE WHEN IMPLEMENTING A PORT OF THE SCHEDULER AND IS
dflet 0:1e7b5dd9edb4 1911 * AN INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.
dflet 0:1e7b5dd9edb4 1912 *
dflet 0:1e7b5dd9edb4 1913 * Sets the pointer to the current TCB to the TCB of the highest priority task
dflet 0:1e7b5dd9edb4 1914 * that is ready to run.
dflet 0:1e7b5dd9edb4 1915 */
dflet 0:1e7b5dd9edb4 1916 void vTaskSwitchContext( void ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 1917
dflet 0:1e7b5dd9edb4 1918 /*
dflet 0:1e7b5dd9edb4 1919 * THESE FUNCTIONS MUST NOT BE USED FROM APPLICATION CODE. THEY ARE USED BY
dflet 0:1e7b5dd9edb4 1920 * THE EVENT BITS MODULE.
dflet 0:1e7b5dd9edb4 1921 */
dflet 0:1e7b5dd9edb4 1922 TickType_t uxTaskResetEventItemValue( void ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 1923
dflet 0:1e7b5dd9edb4 1924 /*
dflet 0:1e7b5dd9edb4 1925 * Return the handle of the calling task.
dflet 0:1e7b5dd9edb4 1926 */
dflet 0:1e7b5dd9edb4 1927 TaskHandle_t xTaskGetCurrentTaskHandle( void ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 1928
dflet 0:1e7b5dd9edb4 1929 /*
dflet 0:1e7b5dd9edb4 1930 * Capture the current time status for future reference.
dflet 0:1e7b5dd9edb4 1931 */
dflet 0:1e7b5dd9edb4 1932 void vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 1933
dflet 0:1e7b5dd9edb4 1934 /*
dflet 0:1e7b5dd9edb4 1935 * Compare the time status now with that previously captured to see if the
dflet 0:1e7b5dd9edb4 1936 * timeout has expired.
dflet 0:1e7b5dd9edb4 1937 */
dflet 0:1e7b5dd9edb4 1938 BaseType_t xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut, TickType_t * const pxTicksToWait ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 1939
dflet 0:1e7b5dd9edb4 1940 /*
dflet 0:1e7b5dd9edb4 1941 * Shortcut used by the queue implementation to prevent unnecessary call to
dflet 0:1e7b5dd9edb4 1942 * taskYIELD();
dflet 0:1e7b5dd9edb4 1943 */
dflet 0:1e7b5dd9edb4 1944 void vTaskMissedYield( void ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 1945
dflet 0:1e7b5dd9edb4 1946 /*
dflet 0:1e7b5dd9edb4 1947 * Returns the scheduler state as taskSCHEDULER_RUNNING,
dflet 0:1e7b5dd9edb4 1948 * taskSCHEDULER_NOT_STARTED or taskSCHEDULER_SUSPENDED.
dflet 0:1e7b5dd9edb4 1949 */
dflet 0:1e7b5dd9edb4 1950 BaseType_t xTaskGetSchedulerState( void ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 1951
dflet 0:1e7b5dd9edb4 1952 /*
dflet 0:1e7b5dd9edb4 1953 * Raises the priority of the mutex holder to that of the calling task should
dflet 0:1e7b5dd9edb4 1954 * the mutex holder have a priority less than the calling task.
dflet 0:1e7b5dd9edb4 1955 */
dflet 0:1e7b5dd9edb4 1956 void vTaskPriorityInherit( TaskHandle_t const pxMutexHolder ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 1957
dflet 0:1e7b5dd9edb4 1958 /*
dflet 0:1e7b5dd9edb4 1959 * Set the priority of a task back to its proper priority in the case that it
dflet 0:1e7b5dd9edb4 1960 * inherited a higher priority while it was holding a semaphore.
dflet 0:1e7b5dd9edb4 1961 */
dflet 0:1e7b5dd9edb4 1962 BaseType_t xTaskPriorityDisinherit( TaskHandle_t const pxMutexHolder ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 1963
dflet 0:1e7b5dd9edb4 1964 /*
dflet 0:1e7b5dd9edb4 1965 * Generic version of the task creation function which is in turn called by the
dflet 0:1e7b5dd9edb4 1966 * xTaskCreate() and xTaskCreateRestricted() macros.
dflet 0:1e7b5dd9edb4 1967 */
dflet 0:1e7b5dd9edb4 1968 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. */
dflet 0:1e7b5dd9edb4 1969
dflet 0:1e7b5dd9edb4 1970 /*
dflet 0:1e7b5dd9edb4 1971 * Get the uxTCBNumber assigned to the task referenced by the xTask parameter.
dflet 0:1e7b5dd9edb4 1972 */
dflet 0:1e7b5dd9edb4 1973 UBaseType_t uxTaskGetTaskNumber( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 1974
dflet 0:1e7b5dd9edb4 1975 /*
dflet 0:1e7b5dd9edb4 1976 * Set the uxTaskNumber of the task referenced by the xTask parameter to
dflet 0:1e7b5dd9edb4 1977 * uxHandle.
dflet 0:1e7b5dd9edb4 1978 */
dflet 0:1e7b5dd9edb4 1979 void vTaskSetTaskNumber( TaskHandle_t xTask, const UBaseType_t uxHandle ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 1980
dflet 0:1e7b5dd9edb4 1981 /*
dflet 0:1e7b5dd9edb4 1982 * Only available when configUSE_TICKLESS_IDLE is set to 1.
dflet 0:1e7b5dd9edb4 1983 * If tickless mode is being used, or a low power mode is implemented, then
dflet 0:1e7b5dd9edb4 1984 * the tick interrupt will not execute during idle periods. When this is the
dflet 0:1e7b5dd9edb4 1985 * case, the tick count value maintained by the scheduler needs to be kept up
dflet 0:1e7b5dd9edb4 1986 * to date with the actual execution time by being skipped forward by a time
dflet 0:1e7b5dd9edb4 1987 * equal to the idle period.
dflet 0:1e7b5dd9edb4 1988 */
dflet 0:1e7b5dd9edb4 1989 void vTaskStepTick( const TickType_t xTicksToJump ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 1990
dflet 0:1e7b5dd9edb4 1991 /*
dflet 0:1e7b5dd9edb4 1992 * Only avilable when configUSE_TICKLESS_IDLE is set to 1.
dflet 0:1e7b5dd9edb4 1993 * Provided for use within portSUPPRESS_TICKS_AND_SLEEP() to allow the port
dflet 0:1e7b5dd9edb4 1994 * specific sleep function to determine if it is ok to proceed with the sleep,
dflet 0:1e7b5dd9edb4 1995 * and if it is ok to proceed, if it is ok to sleep indefinitely.
dflet 0:1e7b5dd9edb4 1996 *
dflet 0:1e7b5dd9edb4 1997 * This function is necessary because portSUPPRESS_TICKS_AND_SLEEP() is only
dflet 0:1e7b5dd9edb4 1998 * called with the scheduler suspended, not from within a critical section. It
dflet 0:1e7b5dd9edb4 1999 * is therefore possible for an interrupt to request a context switch between
dflet 0:1e7b5dd9edb4 2000 * portSUPPRESS_TICKS_AND_SLEEP() and the low power mode actually being
dflet 0:1e7b5dd9edb4 2001 * entered. eTaskConfirmSleepModeStatus() should be called from a short
dflet 0:1e7b5dd9edb4 2002 * critical section between the timer being stopped and the sleep mode being
dflet 0:1e7b5dd9edb4 2003 * entered to ensure it is ok to proceed into the sleep mode.
dflet 0:1e7b5dd9edb4 2004 */
dflet 0:1e7b5dd9edb4 2005 eSleepModeStatus eTaskConfirmSleepModeStatus( void ) PRIVILEGED_FUNCTION;
dflet 0:1e7b5dd9edb4 2006
dflet 0:1e7b5dd9edb4 2007 /*
dflet 0:1e7b5dd9edb4 2008 * For internal use only. Increment the mutex held count when a mutex is
dflet 0:1e7b5dd9edb4 2009 * taken and return the handle of the task that has taken the mutex.
dflet 0:1e7b5dd9edb4 2010 */
dflet 0:1e7b5dd9edb4 2011 void *pvTaskIncrementMutexHeldCount( void );
dflet 0:1e7b5dd9edb4 2012
dflet 0:1e7b5dd9edb4 2013 #ifdef __cplusplus
dflet 0:1e7b5dd9edb4 2014 }
dflet 0:1e7b5dd9edb4 2015 #endif
dflet 0:1e7b5dd9edb4 2016 #endif /* INC_TASK_H */
dflet 0:1e7b5dd9edb4 2017
dflet 0:1e7b5dd9edb4 2018
dflet 0:1e7b5dd9edb4 2019
dflet 0:1e7b5dd9edb4 2020