Lines Matching full:the
8 * this software and associated documentation files (the "Software"), to deal in
9 * the Software without restriction, including without limitation the rights to
11 * the Software, and to permit persons to whom the Software is furnished to do so,
12 * subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included in all
15 * copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
19 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
22 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
50 * If tskKERNEL_VERSION_NUMBER ends with + it represents the version in development
51 * after the numbered release.
53 * The tskKERNEL_VERSION_MAJOR, tskKERNEL_VERSION_MINOR, tskKERNEL_VERSION_BUILD
54 * values will reflect the last released version number.
74 /* The direct to task notification feature used to have only a single notification
76 * configTASK_NOTIFICATION_ARRAY_ENTRIES. For backward compatibility, any use of the
77 * original direct to task notification defaults to using the first index in the
86 * be used as a parameter to vTaskDelete to delete the task.
91 struct tskTaskControlBlock; /* The old naming convention is used to prevent breaking kernel aware d…
95 * Defines the prototype to which the application task hook function must
103 eRunning = 0, /* A task is querying the state of itself, so must be running. */
104 eReady, /* The task being queried is in a ready or pending ready list. */
105 eBlocked, /* The task being queried is in the Blocked state. */
106 …eSuspended, /* The task being queried is in the Suspended state, or is in the Blocked state with…
107 eDeleted, /* The task being queried has been deleted, but its TCB has not yet been freed. */
114 eNoAction = 0, /* Notify the task without updating its notify value. */
115 eSetBits, /* Set bits in the task's notification value. */
116 eIncrement, /* Increment the task's notification value. */
117 …WithOverwrite, /* Set the task's notification value to a specific value even if the previous val…
118 …eSetValueWithoutOverwrite /* Set the task's notification value if the previous value has been read…
131 * Defines the memory ranges allocated to the task when an MPU is used.
157 /* Used with the uxTaskGetSystemState() function to return the state of each task
158 * in the system. */
161 …ndle_t xHandle; /* The handle of the task to which the rest of the informa…
162 … /* A pointer to the task's name. This value will be invalid if the task was …
163 UBaseType_t xTaskNumber; /* A number unique to the task. */
164 …eTaskState eCurrentState; /* The state in which the task existed when the stru…
165 …e_t uxCurrentPriority; /* The priority at which the task was running (may be inheri…
166 …UBaseType_t uxBasePriority; /* The priority to which the task will return if the…
167 …RUN_TIME_COUNTER_TYPE ulRunTimeCounter; /* The total run time allocated to the task so far, as def…
168 …StackType_t * pxStackBase; /* Points to the lowest address of the task's stack …
170 …StackType_t * pxTopOfStack; /* Points to the top address of the task's stack area. */
171 …StackType_t * pxEndOfStack; /* Points to the end address of the task's stack area. */
173 …; /* The minimum amount of stack space that has remained for the task since the task was created.…
180 …eStandardSleep, /* Enter a sleep mode that will not last any longer than the expected i…
187 * Defines the priority used by the idle task. This must not be modified.
206 * Macro to mark the start of a critical code region. Preemptive context
209 * NOTE: This may alter the stack (depending on the portable implementation)
221 * Macro to mark the end of a critical code region. Preemptive context
224 * NOTE: This may alter the stack (depending on the portable implementation)
254 * 0 to generate more optimal code when configASSERT() is defined as the constant
278 * Create a new task and add it to the list of tasks that are ready to run.
280 * Internally, within the FreeRTOS implementation, tasks use two blocks of
281 * memory. The first block is used to hold the task's data structures. The
282 * second block is used by the task as its stack. If a task is created using
284 * allocated inside the xTaskCreate() function. (see
286 * xTaskCreateStatic() then the application writer must provide the required
294 * access to the entire microcontroller memory map. Systems that include MPU
298 * @param pxTaskCode Pointer to the task entry function. Tasks
301 * @param pcName A descriptive name for the task. This is mainly used to
305 * @param usStackDepth The size of the task stack specified as the number of
306 * variables the stack can hold - not the number of bytes. For example, if
307 * the stack is 16 bits wide and usStackDepth is defined as 100, 200 bytes
310 * @param pvParameters Pointer that will be used as the parameter for the task
313 * @param uxPriority The priority at which the task should run. Systems that
315 * mode by setting bit portPRIVILEGE_BIT of the priority parameter. For
316 * example, to create a privileged task at priority 2 the uxPriority parameter
319 * @param pxCreatedTask Used to pass back a handle by which the created task
322 * @return pdPASS if the task was successfully created and added to a ready
323 * list, otherwise an error code defined in the file projdefs.h
342 * // Create the task, storing the handle. Note that the passed parameter ucParameterToPass
343 …* // must exist for the lifetime of the task, so in this case is declared static. If it was jus…
344 … an automatic stack variable it might no longer exist, or at least have been corrupted, by the time
345 * // the new task attempts to access it.
349 * // Use the handle to delete the task.
380 * Create a new task and add it to the list of tasks that are ready to run.
382 * Internally, within the FreeRTOS implementation, tasks use two blocks of
383 * memory. The first block is used to hold the task's data structures. The
384 * second block is used by the task as its stack. If a task is created using
386 * allocated inside the xTaskCreate() function. (see
388 * xTaskCreateStatic() then the application writer must provide the required
392 * @param pxTaskCode Pointer to the task entry function. Tasks
395 * @param pcName A descriptive name for the task. This is mainly used to
396 * facilitate debugging. The maximum length of the string is defined by
399 * @param ulStackDepth The size of the task stack specified as the number of
400 * variables the stack can hold - not the number of bytes. For example, if
401 * the stack is 32-bits wide and ulStackDepth is defined as 100 then 400 bytes
404 * @param pvParameters Pointer that will be used as the parameter for the task
407 * @param uxPriority The priority at which the task will run.
410 * ulStackDepth indexes - the array will then be used as the task's stack,
411 * removing the need for the stack to be allocated dynamically.
414 * then be used to hold the task's data structures, removing the need for the
417 * @return If neither puxStackBuffer nor pxTaskBuffer are NULL, then the task
418 * will be created and a handle to the created task is returned. If either
419 * puxStackBuffer or pxTaskBuffer are NULL then the task will not be created and
425 * // Dimensions of the buffer that the task being created will use as its stack.
426 * // NOTE: This is the number of words the stack will hold, not the number of
431 * // Structure that will hold the TCB of the task being created.
434 * // Buffer that the task being created will use as its stack. Note this is
435 * // an array of StackType_t variables. The size of StackType_t is dependent on
436 * // the RTOS port.
439 * // Function that implements the task being created.
442 * // The parameter value is expected to be 1 as 1 is passed in the
443 * // pvParameters value in the call to xTaskCreateStatic().
457 * // Create the task without using any dynamic memory allocation.
459 * vTaskCode, // Function that implements the task.
460 * "NAME", // Text name for the task.
462 * ( void * ) 1, // Parameter passed into the task.
463 * tskIDLE_PRIORITY,// Priority at which the task is created.
464 * xStack, // Array to use as the task's stack.
465 * &xTaskBuffer ); // Variable to hold the task's data structure.
467 * // puxStackBuffer and pxTaskBuffer were not NULL, so the task will have
468 * // been created, and xHandle will be the task's handle. Use the handle
469 * // to suspend the task.
497 * Create a new task and add it to the list of tasks that are ready to run.
498 * The function parameters define the memory regions and associated access
499 * permissions allocated to the task.
505 * for each of the normal xTaskCreate() parameters (see the xTaskCreate() API
506 * documentation) plus an optional stack buffer and the memory region
509 * @param pxCreatedTask Used to pass back a handle by which the created task
512 * @return pdPASS if the task was successfully created and added to a ready
513 * list, otherwise an error code defined in the file projdefs.h
517 * // Create an TaskParameters_t structure that defines the task to be created.
520 * vATask, // pvTaskCode - the function that implements the task.
521 * "ATask", // pcName - just a text name for the task to assist debugging.
522 * 100, // usStackDepth - the stack size DEFINED IN WORDS.
523 * NULL, // pvParameters - passed into the task function as the function parameters.
524 …* ( 1UL | portPRIVILEGE_BIT ),// uxPriority - task priority, set the portPRIVILEGE_BIT if the tas…
525 * cStackBuffer,// puxStackBuffer - the buffer to be used as the task stack.
528 * // the task, with appropriate access permissions. Different processors have
529 * // different memory alignment requirements - refer to the FreeRTOS documentation
543 * // Create a task from the const structure defined above. The task handle
544 * // is requested (the second parameter is not NULL) but in this case just for
548 * // Start the scheduler.
551 * // Will only get here if there was insufficient memory to create the idle
575 * Internally, within the FreeRTOS implementation, tasks use two blocks of
576 * memory. The first block is used to hold the task's data structures. The
577 * second block is used by the task as its stack. If a task is created using
578 * xTaskCreateRestricted() then the stack is provided by the application writer,
579 * and the memory used to hold the task's data structure is automatically
580 * dynamically allocated inside the xTaskCreateRestricted() function. If a task
581 * is created using xTaskCreateRestrictedStatic() then the application writer
582 * must provide the memory used to hold the task's data structures too.
587 * for each of the normal xTaskCreate() parameters (see the xTaskCreate() API
588 * documentation) plus an optional stack buffer and the memory region
589 * definitions. If configSUPPORT_STATIC_ALLOCATION is set to 1 the structure
591 * StaticTask_t - which is then used to hold the task's data structure.
593 * @param pxCreatedTask Used to pass back a handle by which the created task
596 * @return pdPASS if the task was successfully created and added to a ready
597 * list, otherwise an error code defined in the file projdefs.h
601 * // Create an TaskParameters_t structure that defines the task to be created.
602 * // The StaticTask_t variable is only included in the structure when
603 * // configSUPPORT_STATIC_ALLOCATION is set to 1. The PRIVILEGED_DATA macro can
604 * // be used to force the variable into the RTOS kernel's privileged data area.
608 * vATask, // pvTaskCode - the function that implements the task.
609 * "ATask", // pcName - just a text name for the task to assist debugging.
610 * 100, // usStackDepth - the stack size DEFINED IN WORDS.
611 * NULL, // pvParameters - passed into the task function as the function parameters.
612 …* ( 1UL | portPRIVILEGE_BIT ),// uxPriority - task priority, set the portPRIVILEGE_BIT if the tas…
613 * cStackBuffer,// puxStackBuffer - the buffer to be used as the task stack.
616 * // the task, with appropriate access permissions. Different processors have
617 * // different memory alignment requirements - refer to the FreeRTOS documentation
626 * &xTaskBuffer; // Holds the task's data structure.
633 * // Create a task from the const structure defined above. The task handle
634 * // is requested (the second parameter is not NULL) but in this case just for
638 * // Start the scheduler.
641 * // Will only get here if there was insufficient memory to create the idle
660 * Memory regions are assigned to a restricted task when the task is created by
664 * @param xTask The handle of the task being updated.
666 * @param[in] pxRegions A pointer to a MemoryRegion_t structure that contains the
672 * // allowing read/write access for 1024 bytes starting at the beginning of the
673 * // ucOneKByte array. The other two of the maximum 3 definable regions are
686 * // memory as defined by the MPU configuration. At some point it is
687 * // desired that these MPU regions are replaced with that defined in the
689 * // for this purpose. NULL is used as the task handle to indicate that this
690 * // function should modify the MPU regions of the calling task.
693 * // Now the task can continue its function, but from this point on can only
694 * // access its stack and the ucOneKByte array (unless any other statically
711 * See the configuration section for more information.
713 * Remove a task from the RTOS real time kernel's management. The task being
716 * NOTE: The idle task is responsible for freeing the kernel allocated
718 * the idle task is not starved of microcontroller processing time if your
719 * application makes any calls to vTaskDelete (). Memory allocated by the
720 * task code is not automatically freed, and should be freed before the task
723 * See the demo application file death.c for sample code that utilises
726 * @param xTaskToDelete The handle of the task to be deleted. Passing NULL will
727 * cause the calling task to be deleted.
735 * // Create the task, storing the handle.
738 * // Use the handle to delete the task.
757 * Delay a task for a given number of ticks. The actual time that the
758 * task remains blocked depends on the tick rate. The constant
759 * portTICK_PERIOD_MS can be used to calculate real time from the tick
760 * rate - with the resolution of one tick period.
763 * See the configuration section for more information.
766 * vTaskDelay() specifies a time at which the task wishes to unblock relative to
767 * the time at which vTaskDelay() is called. For example, specifying a block
768 * period of 100 ticks will cause the task to unblock 100 ticks after
770 * of controlling the frequency of a periodic task as the path taken through the
771 * code, as well as other task and interrupt activity, will affect the frequency
772 * at which vTaskDelay() gets called and therefore the time at which the task
775 * absolute time (rather than a relative time) at which the calling task should
778 * @param xTicksToDelay The amount of time, in tick periods, that
779 * the calling task should block.
790 * // Simply toggle the LED every 500ms, blocking between each toggle.
808 * See the configuration section for more information.
814 * cause a task to block for the specified number of ticks from the time vTaskDelay () is
816 * execution frequency as the time between a task starting to execute and that task
817 * calling vTaskDelay () may not be fixed [the task may take a different path though the
821 * Whereas vTaskDelay () specifies a wake time relative to the time at which the function
822 * is called, xTaskDelayUntil () specifies the absolute (exact) time at which it wishes to
825 * The macro pdMS_TO_TICKS() can be used to calculate the number of ticks from a
828 * @param pxPreviousWakeTime Pointer to a variable that holds the time at which the
829 * task was last unblocked. The variable must be initialised with the current time
830 * prior to its first use (see the example below). Following this the variable is
833 * @param xTimeIncrement The cycle time period. The task will be unblocked at
834 * time *pxPreviousWakeTime + xTimeIncrement. Calling xTaskDelayUntil with the
835 * same xTimeIncrement parameter value will cause the task to execute with
838 * @return Value which can be used to check whether the task was actually delayed.
839 * Will be pdTRUE if the task way delayed and pdFALSE otherwise. A task will not
840 * be delayed if the next expected wake time is in the past.
851 * // Initialise the xLastWakeTime variable with the current time.
855 * // Wait for the next cycle.
859 * // whether a deadline was missed if the code here took too long.
870 * vTaskDelayUntil() is the older version of xTaskDelayUntil() and does not
888 * A task will enter the Blocked state when it is waiting for an event. The
891 * xQueueReceive() or ulTaskNotifyTake() is called. If the handle of a task
892 * that is in the Blocked state is used in a call to xTaskAbortDelay() then the
893 * task will leave the Blocked state, and return from whichever function call
894 * placed the task into the Blocked state.
898 * take. For example, if the task was blocked on a queue the interrupt handler
899 * would then need to know if the queue was locked.
901 * @param xTask The handle of the task to remove from the Blocked state.
903 * @return If the task referenced by xTask was not in the Blocked state then
918 * See the configuration section for more information.
920 * Obtain the priority of any task.
922 * @param xTask Handle of the task to be queried. Passing a NULL
923 * handle results in the priority of the calling task being returned.
925 * @return The priority of xTask.
933 * // Create a task, storing the handle.
938 * // Use the handle to obtain the priority of the created task.
943 * // The task has changed it's priority.
948 * // Is our priority higher than the created task?
977 * See the configuration section for more information.
979 * Obtain the state of any task. States are encoded by the eTaskState
982 * @param xTask Handle of the task to be queried.
984 * @return The state of xTask at the time the function was called. Note the
985 * state of the task might change between the function being called, and the
986 * functions return value being tested by the calling task.
997 * available. See the configuration section for more information.
1001 * @param xTask Handle of the task being queried. If xTask is NULL then
1002 * information will be returned about the calling task.
1004 * @param pxTaskStatus A pointer to the TaskStatus_t structure that will be
1005 * filled with information about the task referenced by the handle passed using
1006 * the xTask parameter.
1008 * @param xGetFreeStackSpace The TaskStatus_t structure contains a member to report
1009 * the stack high water mark of the task being queried. Calculating the stack
1010 * high water mark takes a relatively long time, and can make the system
1011 * temporarily unresponsive - so the xGetFreeStackSpace parameter is provided to
1012 * allow the high water mark checking to be skipped. The high watermark value
1013 * will only be written to the TaskStatus_t structure if xGetFreeStackSpace is
1016 * @param eState The TaskStatus_t structure contains a member to report the
1017 * state of the task being queried. Obtaining the task state is not as fast as
1018 * a simple assignment - so the eState parameter is provided to allow the state
1019 * information to be omitted from the TaskStatus_t structure. To obtain state
1020 * information then set eState to eInvalid - otherwise the value passed in
1021 * eState will be reported as the task state in the TaskStatus_t structure.
1030 * // Obtain the handle of a task from its name.
1033 * // Check the handle is not NULL.
1036 * // Use the handle to obtain further information about the task.
1039 * pdTRUE, // Include the high water mark in xTaskDetails.
1040 * eInvalid ); // Include the task state in xTaskDetails.
1058 * See the configuration section for more information.
1060 * Set the priority of any task.
1062 * A context switch will occur before the function returns if the priority
1063 * being set is higher than the currently executing task.
1065 * @param xTask Handle to the task for which the priority is being set.
1066 * Passing a NULL handle results in the priority of the calling task being set.
1068 * @param uxNewPriority The priority to which the task will be set.
1076 * // Create a task, storing the handle.
1081 * // Use the handle to raise the priority of the created task.
1086 * // Use a NULL handle to raise our priority to the same value.
1103 * See the configuration section for more information.
1109 * i.e. calling vTaskSuspend () twice on the same task still only requires one
1110 * call to vTaskResume () to ready the suspended task.
1112 * @param xTaskToSuspend Handle to the task being suspended. Passing a NULL
1113 * handle will cause the calling task to be suspended.
1121 * // Create a task, storing the handle.
1126 * // Use the handle to suspend the created task.
1131 * // The created task will not run during this period, unless
1141 * // with our handle as the parameter.
1156 * See the configuration section for more information.
1164 * @param xTaskToResume Handle to the task being readied.
1172 * // Create a task, storing the handle.
1177 * // Use the handle to suspend the created task.
1182 * // The created task will not run during this period, unless
1188 * // Resume the suspended task ourselves.
1191 * // The created task will once again get microcontroller processing
1192 * // time in accordance with its priority within the system.
1207 * available. See the configuration section for more information.
1216 * interrupt if there is a chance that the interrupt could arrive prior to the
1220 * @param xTaskToResume Handle to the task being readied.
1222 * @return pdTRUE if resuming the task should result in a context switch,
1223 * otherwise pdFALSE. This is used by the ISR to determine if a context switch
1224 * may be required following the ISR.
1241 * Starts the real time kernel tick processing. After calling the kernel
1244 * See the demo application file main.c for an example of creating
1245 * tasks and starting the kernel.
1251 * // Create at least one task before starting the kernel.
1254 * // Start the real time kernel with preemption.
1272 * NOTE: At the time of writing only the x86 real mode port, which runs on a PC
1275 * Stops the real time kernel tick. All created tasks will be automatically
1277 * stop. Execution then resumes from the point where vTaskStartScheduler ()
1280 * See the demo application file main. c in the demo/PC directory for an
1283 * vTaskEndScheduler () requires an exit function to be defined within the
1284 * portable layer (see vPortEndScheduler () in port. c for the PC port). This
1285 * performs hardware specific operations such as stopping the kernel tick.
1287 * vTaskEndScheduler () will cause all of the resources allocated by the
1299 * // At some point we want to end the real time kernel processing
1307 * // Create at least one task before starting the kernel.
1310 * // Start the real time kernel with preemption.
1313 * // Will only get here when the vTaskCode () task has called
1330 * Suspends the scheduler without disabling interrupts. Context switches will
1331 * not occur while the scheduler is suspended.
1333 * After calling vTaskSuspendAll () the calling task will continue to execute
1337 * API functions that have the potential to cause a context switch (for example,
1338 * xTaskDelayUntil(), xQueueSend(), etc.) must not be called while the scheduler
1351 * // At some point the task wants to perform a long operation during
1353 * // taskENTER_CRITICAL ()/taskEXIT_CRITICAL () as the length of the
1354 * // operation may cause interrupts to be missed - including the
1357 * // Prevent the real time kernel swapping out the task.
1360 * // Perform the operation here. There is no need to use critical
1361 * // sections as we have all the microcontroller processing time.
1362 * // During this time interrupts will still operate and the kernel
1367 * // The operation is complete. Restart the kernel.
1386 * xTaskResumeAll() only resumes the scheduler. It does not unsuspend tasks
1389 * @return If resuming the scheduler caused a context switch then pdTRUE is
1402 * // At some point the task wants to perform a long operation during
1404 * // taskENTER_CRITICAL ()/taskEXIT_CRITICAL () as the length of the
1405 * // operation may cause interrupts to be missed - including the
1408 * // Prevent the real time kernel swapping out the task.
1411 * // Perform the operation here. There is no need to use critical
1412 * // sections as we have all the microcontroller processing time.
1413 * // During this time interrupts will still operate and the real
1418 * // The operation is complete. Restart the kernel. We want to force
1419 * // a context switch - but there is no point if resuming the scheduler
1443 * @return The count of ticks since vTaskStartScheduler was called.
1456 * @return The count of ticks since vTaskStartScheduler was called.
1459 * ISR - provided that TickType_t is the natural word size of the
1474 * @return The number of tasks that the real time kernel is currently managing.
1476 * has been deleted but not yet freed by the idle task will also be
1477 * included in the count.
1490 * @return The text (human readable) name of the task referenced by the handle
1508 * @return The handle of the task that has the human readable name pcNameToQuery.
1526 * buffer and stack buffer. These are the same buffers that are supplied
1527 * at the time of creation.
1529 * @param xTask The task for which to retrieve the buffers.
1531 * @param ppuxStackBuffer Used to return a pointer to the task's stack buffer.
1533 * @param ppxTaskBuffer Used to return a pointer to the task's data structure
1556 * Returns the high water mark of the stack associated with xTask. That is,
1557 * the minimum free stack space there has been (in words, so on a 32 bit machine
1558 * a value of 1 means 4 bytes) since the task started. The smaller the returned
1559 * number the closer the task has come to overflowing its stack.
1561 * uxTaskGetStackHighWaterMark() and uxTaskGetStackHighWaterMark2() are the
1562 * same except for their return type. Using configSTACK_DEPTH_TYPE allows the
1563 * user to determine the return type. It gets around the problem of the value
1567 * @param xTask Handle of the task associated with the stack to be checked.
1568 * Set xTask to NULL to check the stack of the calling task.
1570 * @return The smallest amount of free stack space there has been (in words, so
1571 * actual spaces on the stack rather than bytes) since the task referenced by
1585 * Returns the high water mark of the stack associated with xTask. That is,
1586 * the minimum free stack space there has been (in words, so on a 32 bit machine
1587 * a value of 1 means 4 bytes) since the task started. The smaller the returned
1588 * number the closer the task has come to overflowing its stack.
1590 * uxTaskGetStackHighWaterMark() and uxTaskGetStackHighWaterMark2() are the
1591 * same except for their return type. Using configSTACK_DEPTH_TYPE allows the
1592 * user to determine the return type. It gets around the problem of the value
1596 * @param xTask Handle of the task associated with the stack to be checked.
1597 * Set xTask to NULL to check the stack of the calling task.
1599 * @return The smallest amount of free stack space there has been (in words, so
1600 * actual spaces on the stack rather than bytes) since the task referenced by
1607 * so the following two prototypes will cause a compilation error. This can be
1608 * fixed by simply guarding against the inclusion of these two prototypes unless
1609 * they are explicitly required by the configUSE_APPLICATION_TASK_TAG configuration
1620 * Sets pxHookFunction to be the task hook function used by the task xTask.
1621 * Passing xTask as NULL has the effect of setting the calling tasks hook
1633 * Returns the pxHookFunction value assigned to the task xTask. Do not
1645 * Returns the pxHookFunction value assigned to the task xTask. Can
1654 /* Each task contains an array of pointers that is dimensioned by the
1655 * configNUM_THREAD_LOCAL_STORAGE_POINTERS setting in FreeRTOSConfig.h. The
1656 * kernel does not use the pointers itself, so the application writer can use
1657 * the pointers for any purpose they wish. The following two functions are
1675 * The application stack overflow hook is called when a stack overflow is detected for a task.
1679 * @param xTask the task that just exceeded its stack boundaries.
1680 * @param pcTaskName A character string containing the name of the offending task.
1695 * The application idle hook is called by the idle task.
1696 * This allows the application designer to add background functionality without
1697 * the overhead of a separate task.
1713 * This hook function is called in the system tick handler after any OS work is completed.
1727 …* This function is used to provide a statically allocated block of memory to FreeRTOS to hold the …
1731 * @param ppxIdleTaskStackBuffer A handle to a statically allocated Stack buffer for the idle task
1732 …* @param pulIdleTaskStackSize A pointer to the number of elements that will fit in the allocated s…
1745 * Calls the hook function associated with xTask. Passing xTask as NULL has
1746 * the effect of calling the Running tasks (the calling task) hook function.
1748 * pvParameter is passed to the hook function for the task to interpret as it
1749 * wants. The return value is the value returned by the task hook function
1750 * registered by the user.
1759 * Simply returns the handle of the idle task. It is not valid to call
1760 * xTaskGetIdleTaskHandle() before the scheduler has been started.
1769 * the system. TaskStatus_t structures contain, among other things, members
1770 * for the task handle, task name, task priority, task state, and total amount
1771 * of run time consumed by the task. See the TaskStatus_t structure
1772 * definition in this file for the full member list.
1775 * the scheduler remaining suspended for an extended period.
1778 * The array must contain at least one TaskStatus_t structure for each task
1779 * that is under the control of the RTOS. The number of tasks under the control
1780 * of the RTOS can be determined using the uxTaskGetNumberOfTasks() API function.
1782 * @param uxArraySize The size of the array pointed to by the pxTaskStatusArray
1783 * parameter. The size is specified as the number of indexes in the array, or
1784 * the number of TaskStatus_t structures contained in the array, not by the
1785 * number of bytes in the array.
1788 * FreeRTOSConfig.h then *pulTotalRunTime is set by uxTaskGetSystemState() to the
1789 * total run time (as defined by the run time stats clock, see
1790 * https://www.FreeRTOS.org/rtos-run-time-stats.html) since the target booted.
1791 * pulTotalRunTime can be set to NULL to omit the total run time information.
1793 * @return The number of TaskStatus_t structures that were populated by
1794 * uxTaskGetSystemState(). This should equal the number returned by the
1795 * uxTaskGetNumberOfTasks() API function, but will be zero if the value passed
1796 * in the uxArraySize parameter was too small.
1802 * // The human readable table is written to pcWriteBuffer
1809 * // Make sure the write buffer does not contain a string.
1812 * // Take a snapshot of the number of tasks in case it changes while this
1831 * // For each populated position in the pxTaskStatusArray array,
1832 * // format the raw data as human readable ASCII data
1835 * // What percentage of the total run time has the task used?
1836 * // This will always be rounded down to the nearest integer.
1846 * // If the percentage is zero here then the task has
1847 * // consumed less than 1% of the total run time.
1855 * // The array is no longer needed, free the memory it consumes.
1872 * both be defined as 1 for this function to be available. See the
1873 * configuration section of the FreeRTOS.org website for more information.
1878 * Lists all the current tasks, along with their current state and stack
1886 * This function is provided for convenience only, and is used by many of the
1887 * demo applications. Do not consider it to be part of the scheduler.
1889 * vTaskList() calls uxTaskGetSystemState(), then formats part of the
1892 * Stack usage specified as the number of unused StackType_t words stack can hold
1893 * on top of stack - not the number of bytes.
1895 * vTaskList() has a dependency on the sprintf() C library function that might
1896 * bloat the code size, use a lot of stack, and provide different results on
1898 * functionality implementation of sprintf() is provided in many of the
1906 * @param pcWriteBuffer A buffer into which the above mentioned details
1908 * enough to contain the generated report. Approximately 40 bytes per
1923 * must both be defined as 1 for this function to be available. The application
1926 * to configure a peripheral timer/counter and return the timers current count
1927 * value respectively. The counter should be at least 10 times the frequency of
1928 * the tick count.
1934 * accumulated execution time being stored for each task. The resolution
1935 * of the accumulated time value depends on the frequency of the timer
1936 * configured by the portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() macro.
1937 * Calling vTaskGetRunTimeStats() writes the total execution time of each
1939 * of the total system execution time.
1943 * This function is provided for convenience only, and is used by many of the
1944 * demo applications. Do not consider it to be part of the scheduler.
1946 * vTaskGetRunTimeStats() calls uxTaskGetSystemState(), then formats part of the
1947 * uxTaskGetSystemState() output into a human readable table that displays the
1948 * amount of time each task has spent in the Running state in both absolute and
1951 * vTaskGetRunTimeStats() has a dependency on the sprintf() C library function
1952 * that might bloat the code size, use a lot of stack, and provide different
1954 * limited functionality implementation of sprintf() is provided in many of the
1962 * @param pcWriteBuffer A buffer into which the execution times will be
1964 * contain the generated report. Approximately 40 bytes per task should
1980 * available. The application must also then provide definitions for
1983 * return the timers current count value respectively. The counter should be
1984 * at least 10 times the frequency of the tick count.
1987 * accumulated execution time being stored for each task. The resolution
1988 * of the accumulated time value depends on the frequency of the timer
1989 * configured by the portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() macro.
1990 * While uxTaskGetSystemState() and vTaskGetRunTimeStats() writes the total
1992 * returns the total execution time of just one task and
1993 * ulTaskGetRunTimePercent() returns the percentage of the CPU time used by
1996 * @return The total run time of the given task or the percentage of the total
1997 * run time consumed by the given task. This is the amount of time the task
1998 * has actually been executing. The unit of time is dependent on the frequency
1999 * configured using the portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() and
2016 * available. The application must also then provide definitions for
2019 * return the timers current count value respectively. The counter should be
2020 * at least 10 times the frequency of the tick count.
2023 * accumulated execution time being stored for each task. The resolution
2024 * of the accumulated time value depends on the frequency of the timer
2025 * configured by the portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() macro.
2026 * While uxTaskGetSystemState() and vTaskGetRunTimeStats() writes the total
2028 * returns the total execution time of just the idle task and
2029 * ulTaskGetIdleRunTimePercent() returns the percentage of the CPU time used by
2030 * just the idle task.
2032 * Note the amount of idle time is only a good measure of the slack time in a
2033 * system if there are no other tasks executing at the idle priority, tickless
2036 * @return The total run time of the idle task or the percentage of the total
2037 * run time consumed by the idle task. This is the amount of time the
2038 * idle task has actually been executing. The unit of time is dependent on the
2039 * frequency configured using the portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() and
2064 * each of which is a 32-bit unsigned integer (uint32_t). The constant
2065 * configTASK_NOTIFICATION_ARRAY_ENTRIES sets the number of indexes in the
2071 * are a method of sending an event directly to a task without the need for such
2075 * update, overwrite or increment one of the task's notification values. In
2080 * [optionally] block to wait for a notification to be pending. The task does
2081 * not consume any CPU time while it is in the Blocked state.
2083 * A notification sent to a task will remain pending until it is cleared by the
2085 * un-indexed equivalents). If the task was already in the Blocked state to
2086 * wait for a notification when the notification arrives then the task will
2087 * automatically be removed from the Blocked state (unblocked) and the
2090 * **NOTE** Each notification within the array operates independently - a task
2091 * can only block on one notification within the array at a time and will not be
2096 * all task notification API functions operated on that value. Replacing the
2098 * new set of API functions that could address specific notifications within the
2099 * array. xTaskNotify() is the original API function, and remains backward
2100 * compatible by always operating on the notification value at index 0 in the
2102 * with the uxIndexToNotify parameter set to 0.
2104 * @param xTaskToNotify The handle of the task being notified. The handle to a
2105 * task can be returned from the xTaskCreate() API function used to create the
2106 * task, and the handle of the currently running task can be obtained by calling
2109 * @param uxIndexToNotify The index within the target task's array of
2110 * notification values to which the notification is to be sent. uxIndexToNotify
2114 * @param ulValue Data that can be sent with the notification. How the data is
2115 * used depends on the value of the eAction parameter.
2117 * @param eAction Specifies how the notification updates the task's notification
2121 * The target notification value is bitwise ORed with ulValue.
2125 * The target notification value is incremented. ulValue is not used and
2129 * The target notification value is set to the value of ulValue, even if the
2130 * task being notified had not yet processed the previous notification at the
2131 * same array index (the task already had a notification pending at that index).
2135 * If the task being notified did not already have a notification pending at the
2136 * same array index then the target notification value is set to ulValue and
2137 * xTaskNotifyIndexed() will return pdPASS. If the task being notified already
2138 * had a notification pending at the same array index then no action is
2142 * The task receives a notification at the specified array index without the
2147 * Can be used to pass out the subject task's notification value before any
2148 * bits are modified by the notify function.
2150 * @return Dependent on the value of eAction. See the description of the
2175 * xTaskNotifyAndQueryIndexed() performs the same operation as
2176 * xTaskNotifyIndexed() with the addition that it also returns the subject
2177 * task's prior notification value (the notification value at the time the
2178 * function is called rather than when the function returns) in the additional
2181 * xTaskNotifyAndQuery() performs the same operation as xTaskNotify() with the
2182 * addition that it also returns the subject task's prior notification value
2183 * (the notification value as it was at the time the function is called, rather
2184 * than when the function returns) in the additional pulPreviousNotifyValue
2211 * each of which is a 32-bit unsigned integer (uint32_t). The constant
2212 * configTASK_NOTIFICATION_ARRAY_ENTRIES sets the number of indexes in the
2218 * are a method of sending an event directly to a task without the need for such
2222 * update, overwrite or increment one of the task's notification values. In
2228 * to wait for a notification value to have a non-zero value. The task does
2229 * not consume any CPU time while it is in the Blocked state.
2231 * A notification sent to a task will remain pending until it is cleared by the
2233 * un-indexed equivalents). If the task was already in the Blocked state to
2234 * wait for a notification when the notification arrives then the task will
2235 * automatically be removed from the Blocked state (unblocked) and the
2238 * **NOTE** Each notification within the array operates independently - a task
2239 * can only block on one notification within the array at a time and will not be
2244 * all task notification API functions operated on that value. Replacing the
2246 * new set of API functions that could address specific notifications within the
2247 * array. xTaskNotifyFromISR() is the original API function, and remains
2248 * backward compatible by always operating on the notification value at index 0
2249 * within the array. Calling xTaskNotifyFromISR() is equivalent to calling
2250 * xTaskNotifyIndexedFromISR() with the uxIndexToNotify parameter set to 0.
2252 * @param uxIndexToNotify The index within the target task's array of
2253 * notification values to which the notification is to be sent. uxIndexToNotify
2257 * @param xTaskToNotify The handle of the task being notified. The handle to a
2258 * task can be returned from the xTaskCreate() API function used to create the
2259 * task, and the handle of the currently running task can be obtained by calling
2262 * @param ulValue Data that can be sent with the notification. How the data is
2263 * used depends on the value of the eAction parameter.
2265 * @param eAction Specifies how the notification updates the task's notification
2269 * The task's notification value is bitwise ORed with ulValue. xTaskNotify()
2273 * The task's notification value is incremented. ulValue is not used and
2277 * The task's notification value is set to the value of ulValue, even if the
2278 * task being notified had not yet processed the previous notification (the
2283 * If the task being notified did not already have a notification pending then
2284 * the task's notification value is set to ulValue and xTaskNotify() will
2285 * return pdPASS. If the task being notified already had a notification
2289 * The task receives a notification without its notification value being
2294 * *pxHigherPriorityTaskWoken to pdTRUE if sending the notification caused the
2295 * task to which the notification was sent to leave the Blocked state, and the
2296 * unblocked task has a priority higher than the currently running task. If
2298 * be requested before the interrupt is exited. How a context switch is
2299 * requested from an ISR is dependent on the port - see the documentation page
2300 * for the port in use.
2302 * @return Dependent on the value of eAction. See the description of the
2328 * xTaskNotifyAndQueryIndexedFromISR() performs the same operation as
2329 * xTaskNotifyIndexedFromISR() with the addition that it also returns the
2330 * subject task's prior notification value (the notification value at the time
2331 * the function is called rather than at the time the function returns) in the
2334 * xTaskNotifyAndQueryFromISR() performs the same operation as
2335 * xTaskNotifyFromISR() with the addition that it also returns the subject
2336 * task's prior notification value (the notification value at the time the
2337 * function is called rather than at the time the function returns) in the
2365 * each of which is a 32-bit unsigned integer (uint32_t). The constant
2366 * configTASK_NOTIFICATION_ARRAY_ENTRIES sets the number of indexes in the
2372 * are a method of sending an event directly to a task without the need for such
2376 * update, overwrite or increment one of the task's notification values. In
2380 * A notification sent to a task will remain pending until it is cleared by the
2382 * un-indexed equivalents). If the task was already in the Blocked state to
2383 * wait for a notification when the notification arrives then the task will
2384 * automatically be removed from the Blocked state (unblocked) and the
2389 * to wait for a notification value to have a non-zero value. The task does
2390 * not consume any CPU time while it is in the Blocked state.
2392 * **NOTE** Each notification within the array operates independently - a task
2393 * can only block on one notification within the array at a time and will not be
2398 * all task notification API functions operated on that value. Replacing the
2400 * new set of API functions that could address specific notifications within the
2401 * array. xTaskNotifyWait() is the original API function, and remains backward
2402 * compatible by always operating on the notification value at index 0 in the
2404 * xTaskNotifyWaitIndexed() with the uxIndexToWaitOn parameter set to 0.
2406 * @param uxIndexToWaitOn The index within the calling task's array of
2407 * notification values on which the calling task will wait for a notification to
2413 * will be cleared in the calling task's notification value before the task
2417 * the effect of resetting the task's notification value to 0. Setting
2418 * ulBitsToClearOnEntry to 0 will leave the task's notification value unchanged.
2421 * the calling task exits the xTaskNotifyWait() function then the task's
2422 * notification value (see the xTaskNotify() API function) is passed out using
2423 * the pulNotificationValue parameter. Then any bits that are set in
2424 * ulBitsToClearOnExit will be cleared in the task's notification value (note
2427 * (if limits.h is not included) will have the effect of resetting the task's
2428 * notification value to 0 before the function exits. Setting
2429 * ulBitsToClearOnExit to 0 will leave the task's notification value unchanged
2430 * when the function exits (in which case the value passed out in
2431 * pulNotificationValue will match the task's notification value).
2433 * @param pulNotificationValue Used to pass the task's notification value out
2434 * of the function. Note the value passed out will not be effected by the
2437 * @param xTicksToWait The maximum amount of time that the task should wait in
2438 * the Blocked state for a notification to be received, should a notification
2439 * not already be pending when xTaskNotifyWait() was called. The task
2440 * will not consume any processing time while it is in the Blocked state. This
2441 * is specified in kernel ticks, the macro pdMS_TO_TICKS( value_in_ms ) can be
2469 * Sends a direct to task notification to a particular index in the target
2478 * each of which is a 32-bit unsigned integer (uint32_t). The constant
2479 * configTASK_NOTIFICATION_ARRAY_ENTRIES sets the number of indexes in the
2485 * are a method of sending an event directly to a task without the need for such
2489 * update, overwrite or increment one of the task's notification values. In
2495 * semaphore equivalents. Actual FreeRTOS semaphores are given using the
2496 * xSemaphoreGive() API function, the equivalent action that instead uses a task
2500 * equivalent then the task being notified should wait for the notification
2501 * using the ulTaskNotifyTakeIndexed() API function rather than the
2504 * **NOTE** Each notification within the array operates independently - a task
2505 * can only block on one notification within the array at a time and will not be
2510 * all task notification API functions operated on that value. Replacing the
2512 * new set of API functions that could address specific notifications within the
2513 * array. xTaskNotifyGive() is the original API function, and remains backward
2514 * compatible by always operating on the notification value at index 0 in the
2516 * xTaskNotifyGiveIndexed() with the uxIndexToNotify parameter set to 0.
2518 * @param xTaskToNotify The handle of the task being notified. The handle to a
2519 * task can be returned from the xTaskCreate() API function used to create the
2520 * task, and the handle of the currently running task can be obtained by calling
2523 * @param uxIndexToNotify The index within the target task's array of
2524 * notification values to which the notification is to be sent. uxIndexToNotify
2528 * @return xTaskNotifyGive() is a macro that calls xTaskNotify() with the
2555 * each of which is a 32-bit unsigned integer (uint32_t). The constant
2556 * configTASK_NOTIFICATION_ARRAY_ENTRIES sets the number of indexes in the
2562 * are a method of sending an event directly to a task without the need for such
2566 * update, overwrite or increment one of the task's notification values. In
2572 * Actual FreeRTOS semaphores are given from an ISR using the
2573 * xSemaphoreGiveFromISR() API function, the equivalent action that instead uses
2577 * equivalent then the task being notified should wait for the notification
2578 * using the ulTaskNotifyTakeIndexed() API function rather than the
2581 * **NOTE** Each notification within the array operates independently - a task
2582 * can only block on one notification within the array at a time and will not be
2587 * all task notification API functions operated on that value. Replacing the
2589 * new set of API functions that could address specific notifications within the
2590 * array. xTaskNotifyFromISR() is the original API function, and remains
2591 * backward compatible by always operating on the notification value at index 0
2592 * within the array. Calling xTaskNotifyGiveFromISR() is equivalent to calling
2593 * xTaskNotifyGiveIndexedFromISR() with the uxIndexToNotify parameter set to 0.
2595 * @param xTaskToNotify The handle of the task being notified. The handle to a
2596 * task can be returned from the xTaskCreate() API function used to create the
2597 * task, and the handle of the currently running task can be obtained by calling
2600 * @param uxIndexToNotify The index within the target task's array of
2601 * notification values to which the notification is to be sent. uxIndexToNotify
2607 * *pxHigherPriorityTaskWoken to pdTRUE if sending the notification caused the
2608 * task to which the notification was sent to leave the Blocked state, and the
2609 * unblocked task has a priority higher than the currently running task. If
2611 * should be requested before the interrupt is exited. How a context switch is
2612 * requested from an ISR is dependent on the port - see the documentation page
2613 * for the port in use.
2634 * Waits for a direct to task notification on a particular index in the calling
2643 * each of which is a 32-bit unsigned integer (uint32_t). The constant
2644 * configTASK_NOTIFICATION_ARRAY_ENTRIES sets the number of indexes in the
2650 * are a method of sending an event directly to a task without the need for such
2654 * update, overwrite or increment one of the task's notification values. In
2660 * Actual FreeRTOS semaphores are taken using the xSemaphoreTake() API function,
2661 * the equivalent action that instead uses a task notification is
2665 * other tasks should send notifications to it using the xTaskNotifyGiveIndexed()
2666 * macro, or xTaskNotifyIndex() function with the eAction parameter set to
2669 * ulTaskNotifyTakeIndexed() can either clear the task's notification value at
2670 * the array index specified by the uxIndexToWaitOn parameter to zero on exit,
2671 * in which case the notification value acts like a binary semaphore, or
2672 * decrement the notification value on exit, in which case the notification
2676 * a notification. The task does not consume any CPU time while it is in the
2680 * ulTaskNotifyTakeIndexed() will return when the task's notification value is
2683 * **NOTE** Each notification within the array operates independently - a task
2684 * can only block on one notification within the array at a time and will not be
2689 * all task notification API functions operated on that value. Replacing the
2691 * new set of API functions that could address specific notifications within the
2692 * array. ulTaskNotifyTake() is the original API function, and remains backward
2693 * compatible by always operating on the notification value at index 0 in the
2695 * ulTaskNotifyTakeIndexed() with the uxIndexToWaitOn parameter set to 0.
2697 * @param uxIndexToWaitOn The index within the calling task's array of
2698 * notification values on which the calling task will wait for a notification to
2703 * @param xClearCountOnExit if xClearCountOnExit is pdFALSE then the task's
2704 * notification value is decremented when the function exits. In this way the
2706 * not pdFALSE then the task's notification value is cleared to zero when the
2707 * function exits. In this way the notification value acts like a binary
2710 * @param xTicksToWait The maximum amount of time that the task should wait in
2711 * the Blocked state for the task's notification value to be greater than zero,
2712 * should the count not already be greater than zero when
2713 * ulTaskNotifyTake() was called. The task will not consume any processing
2714 * time while it is in the Blocked state. This is specified in kernel ticks,
2715 * the macro pdMS_TO_TICKS( value_in_ms ) can be used to convert a time
2718 * @return The task's notification count before it is either cleared to zero or
2719 * decremented (see the xClearCountOnExit parameter).
2746 * each of which is a 32-bit unsigned integer (uint32_t). The constant
2747 * configTASK_NOTIFICATION_ARRAY_ENTRIES sets the number of indexes in the
2751 * If a notification is sent to an index within the array of notifications then
2752 * the notification at that index is said to be 'pending' until it is read or
2753 * explicitly cleared by the receiving task. xTaskNotifyStateClearIndexed()
2754 * is the function that clears a pending notification without reading the
2755 * notification value. The notification value at the same array index is not
2756 * altered. Set xTask to NULL to clear the notification state of the calling
2761 * all task notification API functions operated on that value. Replacing the
2763 * new set of API functions that could address specific notifications within the
2764 * array. xTaskNotifyStateClear() is the original API function, and remains
2765 * backward compatible by always operating on the notification value at index 0
2766 * within the array. Calling xTaskNotifyStateClear() is equivalent to calling
2767 * xTaskNotifyStateClearIndexed() with the uxIndexToNotify parameter set to 0.
2769 * @param xTask The handle of the RTOS task that will have a notification state
2770 * cleared. Set xTask to NULL to clear a notification state in the calling
2771 * task. To obtain a task's handle create the task using xTaskCreate() and
2772 * make use of the pxCreatedTask parameter, or create the task using
2773 * xTaskCreateStatic() and store the returned value, or use the task's name in
2776 * @param uxIndexToClear The index within the target task's array of
2778 * will clear the state of the notification at index 1 within the array.
2780 * ulTaskNotifyStateClear() does not have this parameter and always acts on the
2783 * @return pdTRUE if the task's notification state was set to
2810 * each of which is a 32-bit unsigned integer (uint32_t). The constant
2811 * configTASK_NOTIFICATION_ARRAY_ENTRIES sets the number of indexes in the
2815 * ulTaskNotifyValueClearIndexed() clears the bits specified by the
2816 * ulBitsToClear bit mask in the notification value at array index uxIndexToClear
2817 * of the task referenced by xTask.
2821 * all task notification API functions operated on that value. Replacing the
2823 * new set of API functions that could address specific notifications within the
2824 * array. ulTaskNotifyValueClear() is the original API function, and remains
2825 * backward compatible by always operating on the notification value at index 0
2826 * within the array. Calling ulTaskNotifyValueClear() is equivalent to calling
2827 * ulTaskNotifyValueClearIndexed() with the uxIndexToClear parameter set to 0.
2829 * @param xTask The handle of the RTOS task that will have bits in one of its
2831 * notification value of the calling task. To obtain a task's handle create the
2832 * task using xTaskCreate() and make use of the pxCreatedTask parameter, or
2833 * create the task using xTaskCreateStatic() and store the returned value, or
2834 * use the task's name in a call to xTaskGetHandle().
2836 * @param uxIndexToClear The index within the target task's array of
2837 * notification values in which to clear the bits. uxIndexToClear
2840 * in the notification value at index 0.
2842 * @param ulBitsToClear Bit mask of the bits to clear in the notification value of
2843 * xTask. Set a bit to 1 to clear the corresponding bits in the task's notification
2845 * the notification value to 0. Set ulBitsToClear to 0 to query the task's
2849 * @return The value of the target task's notification value before the bits
2868 * Capture the current time for future use with xTaskCheckForTimeOut().
2870 * @param pxTimeOut Pointer to a timeout object into which the current time
2871 * is to be captured. The captured time includes the tick count and the number
2872 * of times the tick count has overflowed since the system first booted.
2885 * using a call to vTaskSetTimeOutState(). The captured time includes the tick
2886 * count and the number of times the tick count has overflowed.
2888 * @param pxTimeOut The time status as captured previously using
2889 * vTaskSetTimeOutState. If the timeout has not yet occurred, it is updated
2890 * to reflect the current time status.
2891 * @param pxTicksToWait The number of ticks to check for timeout i.e. if
2893 * vTaskSetTimeOutState() or xTaskCheckForTimeOut()), the timeout has occurred.
2894 * If the timeout has not occurred, pxTicksToWait is updated to reflect the
2898 * returned and pxTicksToWait is updated to reflect the number of remaining
2906 * // that is filled by a UART interrupt. If there are not enough bytes in the
2907 * // Rx buffer then the task enters the Blocked state until it is notified that
2908 * // more data has been placed into the buffer. If there is still not enough
2909 * // data then the task re-enters the Blocked state, and xTaskCheckForTimeOut()
2910 * // is used to re-calculate the Block time to ensure the total amount of time
2911 * // spent in the Blocked state does not exceed MAX_TIME_TO_WAIT. This
2912 * // continues until either the buffer contains at least uxWantedBytes bytes,
2913 * // or the total amount of time spent in the Blocked state reaches
2914 * // MAX_TIME_TO_WAIT - at which point the task reads however many bytes are
2923 * // Initialize xTimeOut. This records the time at which this function
2927 * // Loop until the buffer contains the wanted number of bytes, or a
2931 * // The buffer didn't contain enough data so this task is going to
2932 * // enter the Blocked state. Adjusting xTicksToWait to account for
2933 * // any time that has been spent in the Blocked state within this
2934 * // function so far to ensure the total amount of time spent in the
2938 * //Timed out before the wanted number of bytes were available,
2939 * // exit the loop.
2943 * // Wait for a maximum of xTicksToWait ticks to be notified that the
2944 * // receive interrupt has placed more data into the buffer.
2948 * // Attempt to read uxWantedBytes from the receive buffer into pucBuffer.
2949 * // The actual number of bytes read (which might be less than
2970 * This function corrects the tick count value after the application code has held
2975 * vTaskStepTick(), xTaskCatchUpTicks() may move the tick count forward past a
2976 * time at which a task should be removed from the blocked state. That means
2977 * tasks may have to be removed from the blocked state as the tick count is
2980 * @param xTicksToCatchUp The number of tick interrupts that have been missed due to
2982 * computed by the application writer.
2984 * @return pdTRUE if moving the tick count forward resulted in a task leaving the
2999 * INTENDED FOR USE WHEN IMPLEMENTING A PORT OF THE SCHEDULER AND IS
3000 * AN INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.
3002 * Called from the real time kernel tick (either preemptive or cooperative),
3003 * this increments the tick count and checks if any tasks that are blocked
3009 * + Time slicing is in use and there is a task of equal priority to the
3016 * INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.
3020 * Removes the calling task from the ready list and places it both
3021 * on the list of tasks waiting for a particular event, and the
3022 * list of delayed tasks. The task will be removed from both lists
3023 * and replaced on the ready list should either the event occur (and
3024 * there be no higher priority tasks waiting on the same event) or
3025 * the delay period expires.
3027 * The 'unordered' version replaces the event list item value with the
3028 * xItemValue value, and inserts the list item at the end of the list.
3030 * The 'ordered' version uses the existing event list item value (which is the
3031 * owning task's priority) to insert the list item into the event list in task
3034 * @param pxEventList The list containing tasks that are blocked waiting
3035 * for the event to occur.
3037 * @param xItemValue The item value to use for the event list item when the
3040 * @param xTicksToWait The maximum amount of time that the task should wait
3041 * for the event to occur. This is specified in kernel ticks, the constant
3053 * INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.
3057 * This function performs nearly the same function as vTaskPlaceOnEventList().
3058 * The difference being that this function does not permit tasks to block
3068 * INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.
3072 * Removes a task from both the specified event list and the list of blocked
3076 * if either an event occurs to unblock a task, or the block timeout period
3079 * xTaskRemoveFromEventList() is used when the event list is in task priority
3080 * order. It removes the list item from the head of the event list as that will
3081 * have the highest priority owning task of all the tasks on the event list.
3082 * vTaskRemoveFromUnorderedEventList() is used when the event list is not
3083 * ordered and the event list items hold something other than the owning tasks
3084 * priority. In this case the event list item value is updated to the value
3085 * passed in the xItemValue parameter.
3087 * @return pdTRUE if the task being removed has a higher priority than the task
3088 * making the call, otherwise pdFALSE.
3096 * INTENDED FOR USE WHEN IMPLEMENTING A PORT OF THE SCHEDULER AND IS
3097 * AN INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.
3099 * Sets the pointer to the current TCB to the TCB of the highest priority task
3106 * THE EVENT BITS MODULE.
3111 * Return the handle of the calling task.
3116 * Shortcut used by the queue implementation to prevent unnecessary call to
3122 * Returns the scheduler state as taskSCHEDULER_RUNNING,
3128 * Raises the priority of the mutex holder to that of the calling task should
3129 * the mutex holder have a priority less than the calling task.
3134 * Set the priority of a task back to its proper priority in the case that it
3141 * priority task to inherit the higher priority task's priority - but the higher
3142 * priority task then timed out without obtaining the mutex, then the lower
3143 * priority task will disinherit the priority again - but only down as far as
3144 * the highest priority task that is still waiting for the mutex (if there were
3145 * more than one task waiting for the mutex).
3151 * Get the uxTaskNumber assigned to the task referenced by the xTask parameter.
3156 * Set the uxTaskNumber of the task referenced by the xTask parameter to
3165 * the tick interrupt will not execute during idle periods. When this is the
3166 * case, the tick count value maintained by the scheduler needs to be kept up
3167 * to date with the actual execution time by being skipped forward by a time
3168 * equal to the idle period.
3174 * Provided for use within portSUPPRESS_TICKS_AND_SLEEP() to allow the port
3175 * specific sleep function to determine if it is ok to proceed with the sleep,
3179 * called with the scheduler suspended, not from within a critical section. It
3181 * portSUPPRESS_TICKS_AND_SLEEP() and the low power mode actually being
3183 * critical section between the timer being stopped and the sleep mode being
3184 * entered to ensure it is ok to proceed into the sleep mode.
3189 * For internal use only. Increment the mutex held count when a mutex is
3190 * taken and return the handle of the task that has taken the mutex.