| /* |
| * FreeRTOS Kernel V10.5.1 |
| * Copyright (C) 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved. |
| * |
| * SPDX-License-Identifier: MIT |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy of |
| * this software and associated documentation files (the "Software"), to deal in |
| * the Software without restriction, including without limitation the rights to |
| * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of |
| * the Software, and to permit persons to whom the Software is furnished to do so, |
| * subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in all |
| * copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS |
| * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR |
| * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER |
| * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
| * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| * |
| * https://www.FreeRTOS.org |
| * https://github.com/FreeRTOS |
| * |
| */ |
| |
| |
| #ifndef TIMERS_H |
| #define TIMERS_H |
| |
| #ifndef INC_FREERTOS_H |
| #error "include FreeRTOS.h must appear in source files before include timers.h" |
| #endif |
| |
| /*lint -save -e537 This headers are only multiply included if the application code |
| * happens to also be including task.h. */ |
| #include "task.h" |
| /*lint -restore */ |
| |
| /* *INDENT-OFF* */ |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| /* *INDENT-ON* */ |
| |
| /*----------------------------------------------------------- |
| * MACROS AND DEFINITIONS |
| *----------------------------------------------------------*/ |
| |
| /* IDs for commands that can be sent/received on the timer queue. These are to |
| * be used solely through the macros that make up the public software timer API, |
| * as defined below. The commands that are sent from interrupts must use the |
| * highest numbers as tmrFIRST_FROM_ISR_COMMAND is used to determine if the task |
| * or interrupt version of the queue send function should be used. */ |
| #define tmrCOMMAND_EXECUTE_CALLBACK_FROM_ISR ( ( BaseType_t ) -2 ) |
| #define tmrCOMMAND_EXECUTE_CALLBACK ( ( BaseType_t ) -1 ) |
| #define tmrCOMMAND_START_DONT_TRACE ( ( BaseType_t ) 0 ) |
| #define tmrCOMMAND_START ( ( BaseType_t ) 1 ) |
| #define tmrCOMMAND_RESET ( ( BaseType_t ) 2 ) |
| #define tmrCOMMAND_STOP ( ( BaseType_t ) 3 ) |
| #define tmrCOMMAND_CHANGE_PERIOD ( ( BaseType_t ) 4 ) |
| #define tmrCOMMAND_DELETE ( ( BaseType_t ) 5 ) |
| |
| #define tmrFIRST_FROM_ISR_COMMAND ( ( BaseType_t ) 6 ) |
| #define tmrCOMMAND_START_FROM_ISR ( ( BaseType_t ) 6 ) |
| #define tmrCOMMAND_RESET_FROM_ISR ( ( BaseType_t ) 7 ) |
| #define tmrCOMMAND_STOP_FROM_ISR ( ( BaseType_t ) 8 ) |
| #define tmrCOMMAND_CHANGE_PERIOD_FROM_ISR ( ( BaseType_t ) 9 ) |
| |
| |
| /** |
| * Type by which software timers are referenced. For example, a call to |
| * xTimerCreate() returns an TimerHandle_t variable that can then be used to |
| * reference the subject timer in calls to other software timer API functions |
| * (for example, xTimerStart(), xTimerReset(), etc.). |
| */ |
| struct tmrTimerControl; /* The old naming convention is used to prevent breaking kernel aware debuggers. */ |
| typedef struct tmrTimerControl * TimerHandle_t; |
| |
| /* |
| * Defines the prototype to which timer callback functions must conform. |
| */ |
| typedef void (* TimerCallbackFunction_t)( TimerHandle_t xTimer ); |
| |
| /* |
| * Defines the prototype to which functions used with the |
| * xTimerPendFunctionCallFromISR() function must conform. |
| */ |
| typedef void (* PendedFunction_t)( void *, |
| uint32_t ); |
| |
| /** |
| * TimerHandle_t xTimerCreate( const char * const pcTimerName, |
| * TickType_t xTimerPeriodInTicks, |
| * BaseType_t xAutoReload, |
| * void * pvTimerID, |
| * TimerCallbackFunction_t pxCallbackFunction ); |
| * |
| * Creates a new software timer instance, and returns a handle by which the |
| * created software timer can be referenced. |
| * |
| * Internally, within the FreeRTOS implementation, software timers use a block |
| * of memory, in which the timer data structure is stored. If a software timer |
| * is created using xTimerCreate() then the required memory is automatically |
| * dynamically allocated inside the xTimerCreate() function. (see |
| * https://www.FreeRTOS.org/a00111.html). If a software timer is created using |
| * xTimerCreateStatic() then the application writer must provide the memory that |
| * will get used by the software timer. xTimerCreateStatic() therefore allows a |
| * software timer to be created without using any dynamic memory allocation. |
| * |
| * Timers are created in the dormant state. The xTimerStart(), xTimerReset(), |
| * xTimerStartFromISR(), xTimerResetFromISR(), xTimerChangePeriod() and |
| * xTimerChangePeriodFromISR() API functions can all be used to transition a |
| * timer into the active state. |
| * |
| * @param pcTimerName A text name that is assigned to the timer. This is done |
| * purely to assist debugging. The kernel itself only ever references a timer |
| * by its handle, and never by its name. |
| * |
| * @param xTimerPeriodInTicks The timer period. The time is defined in tick |
| * periods so the constant portTICK_PERIOD_MS can be used to convert a time that |
| * has been specified in milliseconds. For example, if the timer must expire |
| * after 100 ticks, then xTimerPeriodInTicks should be set to 100. |
| * Alternatively, if the timer must expire after 500ms, then xPeriod can be set |
| * to ( 500 / portTICK_PERIOD_MS ) provided configTICK_RATE_HZ is less than or |
| * equal to 1000. Time timer period must be greater than 0. |
| * |
| * @param xAutoReload If xAutoReload is set to pdTRUE then the timer will |
| * expire repeatedly with a frequency set by the xTimerPeriodInTicks parameter. |
| * If xAutoReload is set to pdFALSE then the timer will be a one-shot timer and |
| * enter the dormant state after it expires. |
| * |
| * @param pvTimerID An identifier that is assigned to the timer being created. |
| * Typically this would be used in the timer callback function to identify which |
| * timer expired when the same callback function is assigned to more than one |
| * timer. |
| * |
| * @param pxCallbackFunction The function to call when the timer expires. |
| * Callback functions must have the prototype defined by TimerCallbackFunction_t, |
| * which is "void vCallbackFunction( TimerHandle_t xTimer );". |
| * |
| * @return If the timer is successfully created then a handle to the newly |
| * created timer is returned. If the timer cannot be created because there is |
| * insufficient FreeRTOS heap remaining to allocate the timer |
| * structures then NULL is returned. |
| * |
| * Example usage: |
| * @verbatim |
| * #define NUM_TIMERS 5 |
| * |
| * // An array to hold handles to the created timers. |
| * TimerHandle_t xTimers[ NUM_TIMERS ]; |
| * |
| * // An array to hold a count of the number of times each timer expires. |
| * int32_t lExpireCounters[ NUM_TIMERS ] = { 0 }; |
| * |
| * // Define a callback function that will be used by multiple timer instances. |
| * // The callback function does nothing but count the number of times the |
| * // associated timer expires, and stop the timer once the timer has expired |
| * // 10 times. |
| * void vTimerCallback( TimerHandle_t pxTimer ) |
| * { |
| * int32_t lArrayIndex; |
| * const int32_t xMaxExpiryCountBeforeStopping = 10; |
| * |
| * // Optionally do something if the pxTimer parameter is NULL. |
| * configASSERT( pxTimer ); |
| * |
| * // Which timer expired? |
| * lArrayIndex = ( int32_t ) pvTimerGetTimerID( pxTimer ); |
| * |
| * // Increment the number of times that pxTimer has expired. |
| * lExpireCounters[ lArrayIndex ] += 1; |
| * |
| * // If the timer has expired 10 times then stop it from running. |
| * if( lExpireCounters[ lArrayIndex ] == xMaxExpiryCountBeforeStopping ) |
| * { |
| * // Do not use a block time if calling a timer API function from a |
| * // timer callback function, as doing so could cause a deadlock! |
| * xTimerStop( pxTimer, 0 ); |
| * } |
| * } |
| * |
| * void main( void ) |
| * { |
| * int32_t x; |
| * |
| * // Create then start some timers. Starting the timers before the scheduler |
| * // has been started means the timers will start running immediately that |
| * // the scheduler starts. |
| * for( x = 0; x < NUM_TIMERS; x++ ) |
| * { |
| * xTimers[ x ] = xTimerCreate( "Timer", // Just a text name, not used by the kernel. |
| * ( 100 * ( x + 1 ) ), // The timer period in ticks. |
| * pdTRUE, // The timers will auto-reload themselves when they expire. |
| * ( void * ) x, // Assign each timer a unique id equal to its array index. |
| * vTimerCallback // Each timer calls the same callback when it expires. |
| * ); |
| * |
| * if( xTimers[ x ] == NULL ) |
| * { |
| * // The timer was not created. |
| * } |
| * else |
| * { |
| * // Start the timer. No block time is specified, and even if one was |
| * // it would be ignored because the scheduler has not yet been |
| * // started. |
| * if( xTimerStart( xTimers[ x ], 0 ) != pdPASS ) |
| * { |
| * // The timer could not be set into the Active state. |
| * } |
| * } |
| * } |
| * |
| * // ... |
| * // Create tasks here. |
| * // ... |
| * |
| * // Starting the scheduler will start the timers running as they have already |
| * // been set into the active state. |
| * vTaskStartScheduler(); |
| * |
| * // Should not reach here. |
| * for( ;; ); |
| * } |
| * @endverbatim |
| */ |
| #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) |
| TimerHandle_t xTimerCreate( const char * const pcTimerName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */ |
| const TickType_t xTimerPeriodInTicks, |
| const BaseType_t xAutoReload, |
| void * const pvTimerID, |
| TimerCallbackFunction_t pxCallbackFunction ) PRIVILEGED_FUNCTION; |
| #endif |
| |
| /** |
| * TimerHandle_t xTimerCreateStatic(const char * const pcTimerName, |
| * TickType_t xTimerPeriodInTicks, |
| * BaseType_t xAutoReload, |
| * void * pvTimerID, |
| * TimerCallbackFunction_t pxCallbackFunction, |
| * StaticTimer_t *pxTimerBuffer ); |
| * |
| * Creates a new software timer instance, and returns a handle by which the |
| * created software timer can be referenced. |
| * |
| * Internally, within the FreeRTOS implementation, software timers use a block |
| * of memory, in which the timer data structure is stored. If a software timer |
| * is created using xTimerCreate() then the required memory is automatically |
| * dynamically allocated inside the xTimerCreate() function. (see |
| * https://www.FreeRTOS.org/a00111.html). If a software timer is created using |
| * xTimerCreateStatic() then the application writer must provide the memory that |
| * will get used by the software timer. xTimerCreateStatic() therefore allows a |
| * software timer to be created without using any dynamic memory allocation. |
| * |
| * Timers are created in the dormant state. The xTimerStart(), xTimerReset(), |
| * xTimerStartFromISR(), xTimerResetFromISR(), xTimerChangePeriod() and |
| * xTimerChangePeriodFromISR() API functions can all be used to transition a |
| * timer into the active state. |
| * |
| * @param pcTimerName A text name that is assigned to the timer. This is done |
| * purely to assist debugging. The kernel itself only ever references a timer |
| * by its handle, and never by its name. |
| * |
| * @param xTimerPeriodInTicks The timer period. The time is defined in tick |
| * periods so the constant portTICK_PERIOD_MS can be used to convert a time that |
| * has been specified in milliseconds. For example, if the timer must expire |
| * after 100 ticks, then xTimerPeriodInTicks should be set to 100. |
| * Alternatively, if the timer must expire after 500ms, then xPeriod can be set |
| * to ( 500 / portTICK_PERIOD_MS ) provided configTICK_RATE_HZ is less than or |
| * equal to 1000. The timer period must be greater than 0. |
| * |
| * @param xAutoReload If xAutoReload is set to pdTRUE then the timer will |
| * expire repeatedly with a frequency set by the xTimerPeriodInTicks parameter. |
| * If xAutoReload is set to pdFALSE then the timer will be a one-shot timer and |
| * enter the dormant state after it expires. |
| * |
| * @param pvTimerID An identifier that is assigned to the timer being created. |
| * Typically this would be used in the timer callback function to identify which |
| * timer expired when the same callback function is assigned to more than one |
| * timer. |
| * |
| * @param pxCallbackFunction The function to call when the timer expires. |
| * Callback functions must have the prototype defined by TimerCallbackFunction_t, |
| * which is "void vCallbackFunction( TimerHandle_t xTimer );". |
| * |
| * @param pxTimerBuffer Must point to a variable of type StaticTimer_t, which |
| * will be then be used to hold the software timer's data structures, removing |
| * the need for the memory to be allocated dynamically. |
| * |
| * @return If the timer is created then a handle to the created timer is |
| * returned. If pxTimerBuffer was NULL then NULL is returned. |
| * |
| * Example usage: |
| * @verbatim |
| * |
| * // The buffer used to hold the software timer's data structure. |
| * static StaticTimer_t xTimerBuffer; |
| * |
| * // A variable that will be incremented by the software timer's callback |
| * // function. |
| * UBaseType_t uxVariableToIncrement = 0; |
| * |
| * // A software timer callback function that increments a variable passed to |
| * // it when the software timer was created. After the 5th increment the |
| * // callback function stops the software timer. |
| * static void prvTimerCallback( TimerHandle_t xExpiredTimer ) |
| * { |
| * UBaseType_t *puxVariableToIncrement; |
| * BaseType_t xReturned; |
| * |
| * // Obtain the address of the variable to increment from the timer ID. |
| * puxVariableToIncrement = ( UBaseType_t * ) pvTimerGetTimerID( xExpiredTimer ); |
| * |
| * // Increment the variable to show the timer callback has executed. |
| * ( *puxVariableToIncrement )++; |
| * |
| * // If this callback has executed the required number of times, stop the |
| * // timer. |
| * if( *puxVariableToIncrement == 5 ) |
| * { |
| * // This is called from a timer callback so must not block. |
| * xTimerStop( xExpiredTimer, staticDONT_BLOCK ); |
| * } |
| * } |
| * |
| * |
| * void main( void ) |
| * { |
| * // Create the software time. xTimerCreateStatic() has an extra parameter |
| * // than the normal xTimerCreate() API function. The parameter is a pointer |
| * // to the StaticTimer_t structure that will hold the software timer |
| * // structure. If the parameter is passed as NULL then the structure will be |
| * // allocated dynamically, just as if xTimerCreate() had been called. |
| * xTimer = xTimerCreateStatic( "T1", // Text name for the task. Helps debugging only. Not used by FreeRTOS. |
| * xTimerPeriod, // The period of the timer in ticks. |
| * pdTRUE, // This is an auto-reload timer. |
| * ( void * ) &uxVariableToIncrement, // A variable incremented by the software timer's callback function |
| * prvTimerCallback, // The function to execute when the timer expires. |
| * &xTimerBuffer ); // The buffer that will hold the software timer structure. |
| * |
| * // The scheduler has not started yet so a block time is not used. |
| * xReturned = xTimerStart( xTimer, 0 ); |
| * |
| * // ... |
| * // Create tasks here. |
| * // ... |
| * |
| * // Starting the scheduler will start the timers running as they have already |
| * // been set into the active state. |
| * vTaskStartScheduler(); |
| * |
| * // Should not reach here. |
| * for( ;; ); |
| * } |
| * @endverbatim |
| */ |
| #if ( configSUPPORT_STATIC_ALLOCATION == 1 ) |
| TimerHandle_t xTimerCreateStatic( const char * const pcTimerName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */ |
| const TickType_t xTimerPeriodInTicks, |
| const BaseType_t xAutoReload, |
| void * const pvTimerID, |
| TimerCallbackFunction_t pxCallbackFunction, |
| StaticTimer_t * pxTimerBuffer ) PRIVILEGED_FUNCTION; |
| #endif /* configSUPPORT_STATIC_ALLOCATION */ |
| |
| /** |
| * void *pvTimerGetTimerID( TimerHandle_t xTimer ); |
| * |
| * Returns the ID assigned to the timer. |
| * |
| * IDs are assigned to timers using the pvTimerID parameter of the call to |
| * xTimerCreated() that was used to create the timer, and by calling the |
| * vTimerSetTimerID() API function. |
| * |
| * If the same callback function is assigned to multiple timers then the timer |
| * ID can be used as time specific (timer local) storage. |
| * |
| * @param xTimer The timer being queried. |
| * |
| * @return The ID assigned to the timer being queried. |
| * |
| * Example usage: |
| * |
| * See the xTimerCreate() API function example usage scenario. |
| */ |
| void * pvTimerGetTimerID( const TimerHandle_t xTimer ) PRIVILEGED_FUNCTION; |
| |
| /** |
| * void vTimerSetTimerID( TimerHandle_t xTimer, void *pvNewID ); |
| * |
| * Sets the ID assigned to the timer. |
| * |
| * IDs are assigned to timers using the pvTimerID parameter of the call to |
| * xTimerCreated() that was used to create the timer. |
| * |
| * If the same callback function is assigned to multiple timers then the timer |
| * ID can be used as time specific (timer local) storage. |
| * |
| * @param xTimer The timer being updated. |
| * |
| * @param pvNewID The ID to assign to the timer. |
| * |
| * Example usage: |
| * |
| * See the xTimerCreate() API function example usage scenario. |
| */ |
| void vTimerSetTimerID( TimerHandle_t xTimer, |
| void * pvNewID ) PRIVILEGED_FUNCTION; |
| |
| /** |
| * BaseType_t xTimerIsTimerActive( TimerHandle_t xTimer ); |
| * |
| * Queries a timer to see if it is active or dormant. |
| * |
| * A timer will be dormant if: |
| * 1) It has been created but not started, or |
| * 2) It is an expired one-shot timer that has not been restarted. |
| * |
| * Timers are created in the dormant state. The xTimerStart(), xTimerReset(), |
| * xTimerStartFromISR(), xTimerResetFromISR(), xTimerChangePeriod() and |
| * xTimerChangePeriodFromISR() API functions can all be used to transition a timer into the |
| * active state. |
| * |
| * @param xTimer The timer being queried. |
| * |
| * @return pdFALSE will be returned if the timer is dormant. A value other than |
| * pdFALSE will be returned if the timer is active. |
| * |
| * Example usage: |
| * @verbatim |
| * // This function assumes xTimer has already been created. |
| * void vAFunction( TimerHandle_t xTimer ) |
| * { |
| * if( xTimerIsTimerActive( xTimer ) != pdFALSE ) // or more simply and equivalently "if( xTimerIsTimerActive( xTimer ) )" |
| * { |
| * // xTimer is active, do something. |
| * } |
| * else |
| * { |
| * // xTimer is not active, do something else. |
| * } |
| * } |
| * @endverbatim |
| */ |
| BaseType_t xTimerIsTimerActive( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION; |
| |
| /** |
| * TaskHandle_t xTimerGetTimerDaemonTaskHandle( void ); |
| * |
| * Simply returns the handle of the timer service/daemon task. It it not valid |
| * to call xTimerGetTimerDaemonTaskHandle() before the scheduler has been started. |
| */ |
| TaskHandle_t xTimerGetTimerDaemonTaskHandle( void ) PRIVILEGED_FUNCTION; |
| |
| /** |
| * BaseType_t xTimerStart( TimerHandle_t xTimer, TickType_t xTicksToWait ); |
| * |
| * Timer functionality is provided by a timer service/daemon task. Many of the |
| * public FreeRTOS timer API functions send commands to the timer service task |
| * through a queue called the timer command queue. The timer command queue is |
| * private to the kernel itself and is not directly accessible to application |
| * code. The length of the timer command queue is set by the |
| * configTIMER_QUEUE_LENGTH configuration constant. |
| * |
| * xTimerStart() starts a timer that was previously created using the |
| * xTimerCreate() API function. If the timer had already been started and was |
| * already in the active state, then xTimerStart() has equivalent functionality |
| * to the xTimerReset() API function. |
| * |
| * Starting a timer ensures the timer is in the active state. If the timer |
| * is not stopped, deleted, or reset in the mean time, the callback function |
| * associated with the timer will get called 'n' ticks after xTimerStart() was |
| * called, where 'n' is the timers defined period. |
| * |
| * It is valid to call xTimerStart() before the scheduler has been started, but |
| * when this is done the timer will not actually start until the scheduler is |
| * started, and the timers expiry time will be relative to when the scheduler is |
| * started, not relative to when xTimerStart() was called. |
| * |
| * The configUSE_TIMERS configuration constant must be set to 1 for xTimerStart() |
| * to be available. |
| * |
| * @param xTimer The handle of the timer being started/restarted. |
| * |
| * @param xTicksToWait Specifies the time, in ticks, that the calling task should |
| * be held in the Blocked state to wait for the start command to be successfully |
| * sent to the timer command queue, should the queue already be full when |
| * xTimerStart() was called. xTicksToWait is ignored if xTimerStart() is called |
| * before the scheduler is started. |
| * |
| * @return pdFAIL will be returned if the start command could not be sent to |
| * the timer command queue even after xTicksToWait ticks had passed. pdPASS will |
| * be returned if the command was successfully sent to the timer command queue. |
| * When the command is actually processed will depend on the priority of the |
| * timer service/daemon task relative to other tasks in the system, although the |
| * timers expiry time is relative to when xTimerStart() is actually called. The |
| * timer service/daemon task priority is set by the configTIMER_TASK_PRIORITY |
| * configuration constant. |
| * |
| * Example usage: |
| * |
| * See the xTimerCreate() API function example usage scenario. |
| * |
| */ |
| #define xTimerStart( xTimer, xTicksToWait ) \ |
| xTimerGenericCommand( ( xTimer ), tmrCOMMAND_START, ( xTaskGetTickCount() ), NULL, ( xTicksToWait ) ) |
| |
| /** |
| * BaseType_t xTimerStop( TimerHandle_t xTimer, TickType_t xTicksToWait ); |
| * |
| * Timer functionality is provided by a timer service/daemon task. Many of the |
| * public FreeRTOS timer API functions send commands to the timer service task |
| * through a queue called the timer command queue. The timer command queue is |
| * private to the kernel itself and is not directly accessible to application |
| * code. The length of the timer command queue is set by the |
| * configTIMER_QUEUE_LENGTH configuration constant. |
| * |
| * xTimerStop() stops a timer that was previously started using either of the |
| * The xTimerStart(), xTimerReset(), xTimerStartFromISR(), xTimerResetFromISR(), |
| * xTimerChangePeriod() or xTimerChangePeriodFromISR() API functions. |
| * |
| * Stopping a timer ensures the timer is not in the active state. |
| * |
| * The configUSE_TIMERS configuration constant must be set to 1 for xTimerStop() |
| * to be available. |
| * |
| * @param xTimer The handle of the timer being stopped. |
| * |
| * @param xTicksToWait Specifies the time, in ticks, that the calling task should |
| * be held in the Blocked state to wait for the stop command to be successfully |
| * sent to the timer command queue, should the queue already be full when |
| * xTimerStop() was called. xTicksToWait is ignored if xTimerStop() is called |
| * before the scheduler is started. |
| * |
| * @return pdFAIL will be returned if the stop command could not be sent to |
| * the timer command queue even after xTicksToWait ticks had passed. pdPASS will |
| * be returned if the command was successfully sent to the timer command queue. |
| * When the command is actually processed will depend on the priority of the |
| * timer service/daemon task relative to other tasks in the system. The timer |
| * service/daemon task priority is set by the configTIMER_TASK_PRIORITY |
| * configuration constant. |
| * |
| * Example usage: |
| * |
| * See the xTimerCreate() API function example usage scenario. |
| * |
| */ |
| #define xTimerStop( xTimer, xTicksToWait ) \ |
| xTimerGenericCommand( ( xTimer ), tmrCOMMAND_STOP, 0U, NULL, ( xTicksToWait ) ) |
| |
| /** |
| * BaseType_t xTimerChangePeriod( TimerHandle_t xTimer, |
| * TickType_t xNewPeriod, |
| * TickType_t xTicksToWait ); |
| * |
| * Timer functionality is provided by a timer service/daemon task. Many of the |
| * public FreeRTOS timer API functions send commands to the timer service task |
| * through a queue called the timer command queue. The timer command queue is |
| * private to the kernel itself and is not directly accessible to application |
| * code. The length of the timer command queue is set by the |
| * configTIMER_QUEUE_LENGTH configuration constant. |
| * |
| * xTimerChangePeriod() changes the period of a timer that was previously |
| * created using the xTimerCreate() API function. |
| * |
| * xTimerChangePeriod() can be called to change the period of an active or |
| * dormant state timer. |
| * |
| * The configUSE_TIMERS configuration constant must be set to 1 for |
| * xTimerChangePeriod() to be available. |
| * |
| * @param xTimer The handle of the timer that is having its period changed. |
| * |
| * @param xNewPeriod The new period for xTimer. Timer periods are specified in |
| * tick periods, so the constant portTICK_PERIOD_MS can be used to convert a time |
| * that has been specified in milliseconds. For example, if the timer must |
| * expire after 100 ticks, then xNewPeriod should be set to 100. Alternatively, |
| * if the timer must expire after 500ms, then xNewPeriod can be set to |
| * ( 500 / portTICK_PERIOD_MS ) provided configTICK_RATE_HZ is less than |
| * or equal to 1000. |
| * |
| * @param xTicksToWait Specifies the time, in ticks, that the calling task should |
| * be held in the Blocked state to wait for the change period command to be |
| * successfully sent to the timer command queue, should the queue already be |
| * full when xTimerChangePeriod() was called. xTicksToWait is ignored if |
| * xTimerChangePeriod() is called before the scheduler is started. |
| * |
| * @return pdFAIL will be returned if the change period command could not be |
| * sent to the timer command queue even after xTicksToWait ticks had passed. |
| * pdPASS will be returned if the command was successfully sent to the timer |
| * command queue. When the command is actually processed will depend on the |
| * priority of the timer service/daemon task relative to other tasks in the |
| * system. The timer service/daemon task priority is set by the |
| * configTIMER_TASK_PRIORITY configuration constant. |
| * |
| * Example usage: |
| * @verbatim |
| * // This function assumes xTimer has already been created. If the timer |
| * // referenced by xTimer is already active when it is called, then the timer |
| * // is deleted. If the timer referenced by xTimer is not active when it is |
| * // called, then the period of the timer is set to 500ms and the timer is |
| * // started. |
| * void vAFunction( TimerHandle_t xTimer ) |
| * { |
| * if( xTimerIsTimerActive( xTimer ) != pdFALSE ) // or more simply and equivalently "if( xTimerIsTimerActive( xTimer ) )" |
| * { |
| * // xTimer is already active - delete it. |
| * xTimerDelete( xTimer ); |
| * } |
| * else |
| * { |
| * // xTimer is not active, change its period to 500ms. This will also |
| * // cause the timer to start. Block for a maximum of 100 ticks if the |
| * // change period command cannot immediately be sent to the timer |
| * // command queue. |
| * if( xTimerChangePeriod( xTimer, 500 / portTICK_PERIOD_MS, 100 ) == pdPASS ) |
| * { |
| * // The command was successfully sent. |
| * } |
| * else |
| * { |
| * // The command could not be sent, even after waiting for 100 ticks |
| * // to pass. Take appropriate action here. |
| * } |
| * } |
| * } |
| * @endverbatim |
| */ |
| #define xTimerChangePeriod( xTimer, xNewPeriod, xTicksToWait ) \ |
| xTimerGenericCommand( ( xTimer ), tmrCOMMAND_CHANGE_PERIOD, ( xNewPeriod ), NULL, ( xTicksToWait ) ) |
| |
| /** |
| * BaseType_t xTimerDelete( TimerHandle_t xTimer, TickType_t xTicksToWait ); |
| * |
| * Timer functionality is provided by a timer service/daemon task. Many of the |
| * public FreeRTOS timer API functions send commands to the timer service task |
| * through a queue called the timer command queue. The timer command queue is |
| * private to the kernel itself and is not directly accessible to application |
| * code. The length of the timer command queue is set by the |
| * configTIMER_QUEUE_LENGTH configuration constant. |
| * |
| * xTimerDelete() deletes a timer that was previously created using the |
| * xTimerCreate() API function. |
| * |
| * The configUSE_TIMERS configuration constant must be set to 1 for |
| * xTimerDelete() to be available. |
| * |
| * @param xTimer The handle of the timer being deleted. |
| * |
| * @param xTicksToWait Specifies the time, in ticks, that the calling task should |
| * be held in the Blocked state to wait for the delete command to be |
| * successfully sent to the timer command queue, should the queue already be |
| * full when xTimerDelete() was called. xTicksToWait is ignored if xTimerDelete() |
| * is called before the scheduler is started. |
| * |
| * @return pdFAIL will be returned if the delete command could not be sent to |
| * the timer command queue even after xTicksToWait ticks had passed. pdPASS will |
| * be returned if the command was successfully sent to the timer command queue. |
| * When the command is actually processed will depend on the priority of the |
| * timer service/daemon task relative to other tasks in the system. The timer |
| * service/daemon task priority is set by the configTIMER_TASK_PRIORITY |
| * configuration constant. |
| * |
| * Example usage: |
| * |
| * See the xTimerChangePeriod() API function example usage scenario. |
| */ |
| #define xTimerDelete( xTimer, xTicksToWait ) \ |
| xTimerGenericCommand( ( xTimer ), tmrCOMMAND_DELETE, 0U, NULL, ( xTicksToWait ) ) |
| |
| /** |
| * BaseType_t xTimerReset( TimerHandle_t xTimer, TickType_t xTicksToWait ); |
| * |
| * Timer functionality is provided by a timer service/daemon task. Many of the |
| * public FreeRTOS timer API functions send commands to the timer service task |
| * through a queue called the timer command queue. The timer command queue is |
| * private to the kernel itself and is not directly accessible to application |
| * code. The length of the timer command queue is set by the |
| * configTIMER_QUEUE_LENGTH configuration constant. |
| * |
| * xTimerReset() re-starts a timer that was previously created using the |
| * xTimerCreate() API function. If the timer had already been started and was |
| * already in the active state, then xTimerReset() will cause the timer to |
| * re-evaluate its expiry time so that it is relative to when xTimerReset() was |
| * called. If the timer was in the dormant state then xTimerReset() has |
| * equivalent functionality to the xTimerStart() API function. |
| * |
| * Resetting a timer ensures the timer is in the active state. If the timer |
| * is not stopped, deleted, or reset in the mean time, the callback function |
| * associated with the timer will get called 'n' ticks after xTimerReset() was |
| * called, where 'n' is the timers defined period. |
| * |
| * It is valid to call xTimerReset() before the scheduler has been started, but |
| * when this is done the timer will not actually start until the scheduler is |
| * started, and the timers expiry time will be relative to when the scheduler is |
| * started, not relative to when xTimerReset() was called. |
| * |
| * The configUSE_TIMERS configuration constant must be set to 1 for xTimerReset() |
| * to be available. |
| * |
| * @param xTimer The handle of the timer being reset/started/restarted. |
| * |
| * @param xTicksToWait Specifies the time, in ticks, that the calling task should |
| * be held in the Blocked state to wait for the reset command to be successfully |
| * sent to the timer command queue, should the queue already be full when |
| * xTimerReset() was called. xTicksToWait is ignored if xTimerReset() is called |
| * before the scheduler is started. |
| * |
| * @return pdFAIL will be returned if the reset command could not be sent to |
| * the timer command queue even after xTicksToWait ticks had passed. pdPASS will |
| * be returned if the command was successfully sent to the timer command queue. |
| * When the command is actually processed will depend on the priority of the |
| * timer service/daemon task relative to other tasks in the system, although the |
| * timers expiry time is relative to when xTimerStart() is actually called. The |
| * timer service/daemon task priority is set by the configTIMER_TASK_PRIORITY |
| * configuration constant. |
| * |
| * Example usage: |
| * @verbatim |
| * // When a key is pressed, an LCD back-light is switched on. If 5 seconds pass |
| * // without a key being pressed, then the LCD back-light is switched off. In |
| * // this case, the timer is a one-shot timer. |
| * |
| * TimerHandle_t xBacklightTimer = NULL; |
| * |
| * // The callback function assigned to the one-shot timer. In this case the |
| * // parameter is not used. |
| * void vBacklightTimerCallback( TimerHandle_t pxTimer ) |
| * { |
| * // The timer expired, therefore 5 seconds must have passed since a key |
| * // was pressed. Switch off the LCD back-light. |
| * vSetBacklightState( BACKLIGHT_OFF ); |
| * } |
| * |
| * // The key press event handler. |
| * void vKeyPressEventHandler( char cKey ) |
| * { |
| * // Ensure the LCD back-light is on, then reset the timer that is |
| * // responsible for turning the back-light off after 5 seconds of |
| * // key inactivity. Wait 10 ticks for the command to be successfully sent |
| * // if it cannot be sent immediately. |
| * vSetBacklightState( BACKLIGHT_ON ); |
| * if( xTimerReset( xBacklightTimer, 100 ) != pdPASS ) |
| * { |
| * // The reset command was not executed successfully. Take appropriate |
| * // action here. |
| * } |
| * |
| * // Perform the rest of the key processing here. |
| * } |
| * |
| * void main( void ) |
| * { |
| * int32_t x; |
| * |
| * // Create then start the one-shot timer that is responsible for turning |
| * // the back-light off if no keys are pressed within a 5 second period. |
| * xBacklightTimer = xTimerCreate( "BacklightTimer", // Just a text name, not used by the kernel. |
| * ( 5000 / portTICK_PERIOD_MS), // The timer period in ticks. |
| * pdFALSE, // The timer is a one-shot timer. |
| * 0, // The id is not used by the callback so can take any value. |
| * vBacklightTimerCallback // The callback function that switches the LCD back-light off. |
| * ); |
| * |
| * if( xBacklightTimer == NULL ) |
| * { |
| * // The timer was not created. |
| * } |
| * else |
| * { |
| * // Start the timer. No block time is specified, and even if one was |
| * // it would be ignored because the scheduler has not yet been |
| * // started. |
| * if( xTimerStart( xBacklightTimer, 0 ) != pdPASS ) |
| * { |
| * // The timer could not be set into the Active state. |
| * } |
| * } |
| * |
| * // ... |
| * // Create tasks here. |
| * // ... |
| * |
| * // Starting the scheduler will start the timer running as it has already |
| * // been set into the active state. |
| * vTaskStartScheduler(); |
| * |
| * // Should not reach here. |
| * for( ;; ); |
| * } |
| * @endverbatim |
| */ |
| #define xTimerReset( xTimer, xTicksToWait ) \ |
| xTimerGenericCommand( ( xTimer ), tmrCOMMAND_RESET, ( xTaskGetTickCount() ), NULL, ( xTicksToWait ) ) |
| |
| /** |
| * BaseType_t xTimerStartFromISR( TimerHandle_t xTimer, |
| * BaseType_t *pxHigherPriorityTaskWoken ); |
| * |
| * A version of xTimerStart() that can be called from an interrupt service |
| * routine. |
| * |
| * @param xTimer The handle of the timer being started/restarted. |
| * |
| * @param pxHigherPriorityTaskWoken The timer service/daemon task spends most |
| * of its time in the Blocked state, waiting for messages to arrive on the timer |
| * command queue. Calling xTimerStartFromISR() writes a message to the timer |
| * command queue, so has the potential to transition the timer service/daemon |
| * task out of the Blocked state. If calling xTimerStartFromISR() causes the |
| * timer service/daemon task to leave the Blocked state, and the timer service/ |
| * daemon task has a priority equal to or greater than the currently executing |
| * task (the task that was interrupted), then *pxHigherPriorityTaskWoken will |
| * get set to pdTRUE internally within the xTimerStartFromISR() function. If |
| * xTimerStartFromISR() sets this value to pdTRUE then a context switch should |
| * be performed before the interrupt exits. |
| * |
| * @return pdFAIL will be returned if the start command could not be sent to |
| * the timer command queue. pdPASS will be returned if the command was |
| * successfully sent to the timer command queue. When the command is actually |
| * processed will depend on the priority of the timer service/daemon task |
| * relative to other tasks in the system, although the timers expiry time is |
| * relative to when xTimerStartFromISR() is actually called. The timer |
| * service/daemon task priority is set by the configTIMER_TASK_PRIORITY |
| * configuration constant. |
| * |
| * Example usage: |
| * @verbatim |
| * // This scenario assumes xBacklightTimer has already been created. When a |
| * // key is pressed, an LCD back-light is switched on. If 5 seconds pass |
| * // without a key being pressed, then the LCD back-light is switched off. In |
| * // this case, the timer is a one-shot timer, and unlike the example given for |
| * // the xTimerReset() function, the key press event handler is an interrupt |
| * // service routine. |
| * |
| * // The callback function assigned to the one-shot timer. In this case the |
| * // parameter is not used. |
| * void vBacklightTimerCallback( TimerHandle_t pxTimer ) |
| * { |
| * // The timer expired, therefore 5 seconds must have passed since a key |
| * // was pressed. Switch off the LCD back-light. |
| * vSetBacklightState( BACKLIGHT_OFF ); |
| * } |
| * |
| * // The key press interrupt service routine. |
| * void vKeyPressEventInterruptHandler( void ) |
| * { |
| * BaseType_t xHigherPriorityTaskWoken = pdFALSE; |
| * |
| * // Ensure the LCD back-light is on, then restart the timer that is |
| * // responsible for turning the back-light off after 5 seconds of |
| * // key inactivity. This is an interrupt service routine so can only |
| * // call FreeRTOS API functions that end in "FromISR". |
| * vSetBacklightState( BACKLIGHT_ON ); |
| * |
| * // xTimerStartFromISR() or xTimerResetFromISR() could be called here |
| * // as both cause the timer to re-calculate its expiry time. |
| * // xHigherPriorityTaskWoken was initialised to pdFALSE when it was |
| * // declared (in this function). |
| * if( xTimerStartFromISR( xBacklightTimer, &xHigherPriorityTaskWoken ) != pdPASS ) |
| * { |
| * // The start command was not executed successfully. Take appropriate |
| * // action here. |
| * } |
| * |
| * // Perform the rest of the key processing here. |
| * |
| * // If xHigherPriorityTaskWoken equals pdTRUE, then a context switch |
| * // should be performed. The syntax required to perform a context switch |
| * // from inside an ISR varies from port to port, and from compiler to |
| * // compiler. Inspect the demos for the port you are using to find the |
| * // actual syntax required. |
| * if( xHigherPriorityTaskWoken != pdFALSE ) |
| * { |
| * // Call the interrupt safe yield function here (actual function |
| * // depends on the FreeRTOS port being used). |
| * } |
| * } |
| * @endverbatim |
| */ |
| #define xTimerStartFromISR( xTimer, pxHigherPriorityTaskWoken ) \ |
| xTimerGenericCommand( ( xTimer ), tmrCOMMAND_START_FROM_ISR, ( xTaskGetTickCountFromISR() ), ( pxHigherPriorityTaskWoken ), 0U ) |
| |
| /** |
| * BaseType_t xTimerStopFromISR( TimerHandle_t xTimer, |
| * BaseType_t *pxHigherPriorityTaskWoken ); |
| * |
| * A version of xTimerStop() that can be called from an interrupt service |
| * routine. |
| * |
| * @param xTimer The handle of the timer being stopped. |
| * |
| * @param pxHigherPriorityTaskWoken The timer service/daemon task spends most |
| * of its time in the Blocked state, waiting for messages to arrive on the timer |
| * command queue. Calling xTimerStopFromISR() writes a message to the timer |
| * command queue, so has the potential to transition the timer service/daemon |
| * task out of the Blocked state. If calling xTimerStopFromISR() causes the |
| * timer service/daemon task to leave the Blocked state, and the timer service/ |
| * daemon task has a priority equal to or greater than the currently executing |
| * task (the task that was interrupted), then *pxHigherPriorityTaskWoken will |
| * get set to pdTRUE internally within the xTimerStopFromISR() function. If |
| * xTimerStopFromISR() sets this value to pdTRUE then a context switch should |
| * be performed before the interrupt exits. |
| * |
| * @return pdFAIL will be returned if the stop command could not be sent to |
| * the timer command queue. pdPASS will be returned if the command was |
| * successfully sent to the timer command queue. When the command is actually |
| * processed will depend on the priority of the timer service/daemon task |
| * relative to other tasks in the system. The timer service/daemon task |
| * priority is set by the configTIMER_TASK_PRIORITY configuration constant. |
| * |
| * Example usage: |
| * @verbatim |
| * // This scenario assumes xTimer has already been created and started. When |
| * // an interrupt occurs, the timer should be simply stopped. |
| * |
| * // The interrupt service routine that stops the timer. |
| * void vAnExampleInterruptServiceRoutine( void ) |
| * { |
| * BaseType_t xHigherPriorityTaskWoken = pdFALSE; |
| * |
| * // The interrupt has occurred - simply stop the timer. |
| * // xHigherPriorityTaskWoken was set to pdFALSE where it was defined |
| * // (within this function). As this is an interrupt service routine, only |
| * // FreeRTOS API functions that end in "FromISR" can be used. |
| * if( xTimerStopFromISR( xTimer, &xHigherPriorityTaskWoken ) != pdPASS ) |
| * { |
| * // The stop command was not executed successfully. Take appropriate |
| * // action here. |
| * } |
| * |
| * // If xHigherPriorityTaskWoken equals pdTRUE, then a context switch |
| * // should be performed. The syntax required to perform a context switch |
| * // from inside an ISR varies from port to port, and from compiler to |
| * // compiler. Inspect the demos for the port you are using to find the |
| * // actual syntax required. |
| * if( xHigherPriorityTaskWoken != pdFALSE ) |
| * { |
| * // Call the interrupt safe yield function here (actual function |
| * // depends on the FreeRTOS port being used). |
| * } |
| * } |
| * @endverbatim |
| */ |
| #define xTimerStopFromISR( xTimer, pxHigherPriorityTaskWoken ) \ |
| xTimerGenericCommand( ( xTimer ), tmrCOMMAND_STOP_FROM_ISR, 0, ( pxHigherPriorityTaskWoken ), 0U ) |
| |
| /** |
| * BaseType_t xTimerChangePeriodFromISR( TimerHandle_t xTimer, |
| * TickType_t xNewPeriod, |
| * BaseType_t *pxHigherPriorityTaskWoken ); |
| * |
| * A version of xTimerChangePeriod() that can be called from an interrupt |
| * service routine. |
| * |
| * @param xTimer The handle of the timer that is having its period changed. |
| * |
| * @param xNewPeriod The new period for xTimer. Timer periods are specified in |
| * tick periods, so the constant portTICK_PERIOD_MS can be used to convert a time |
| * that has been specified in milliseconds. For example, if the timer must |
| * expire after 100 ticks, then xNewPeriod should be set to 100. Alternatively, |
| * if the timer must expire after 500ms, then xNewPeriod can be set to |
| * ( 500 / portTICK_PERIOD_MS ) provided configTICK_RATE_HZ is less than |
| * or equal to 1000. |
| * |
| * @param pxHigherPriorityTaskWoken The timer service/daemon task spends most |
| * of its time in the Blocked state, waiting for messages to arrive on the timer |
| * command queue. Calling xTimerChangePeriodFromISR() writes a message to the |
| * timer command queue, so has the potential to transition the timer service/ |
| * daemon task out of the Blocked state. If calling xTimerChangePeriodFromISR() |
| * causes the timer service/daemon task to leave the Blocked state, and the |
| * timer service/daemon task has a priority equal to or greater than the |
| * currently executing task (the task that was interrupted), then |
| * *pxHigherPriorityTaskWoken will get set to pdTRUE internally within the |
| * xTimerChangePeriodFromISR() function. If xTimerChangePeriodFromISR() sets |
| * this value to pdTRUE then a context switch should be performed before the |
| * interrupt exits. |
| * |
| * @return pdFAIL will be returned if the command to change the timers period |
| * could not be sent to the timer command queue. pdPASS will be returned if the |
| * command was successfully sent to the timer command queue. When the command |
| * is actually processed will depend on the priority of the timer service/daemon |
| * task relative to other tasks in the system. The timer service/daemon task |
| * priority is set by the configTIMER_TASK_PRIORITY configuration constant. |
| * |
| * Example usage: |
| * @verbatim |
| * // This scenario assumes xTimer has already been created and started. When |
| * // an interrupt occurs, the period of xTimer should be changed to 500ms. |
| * |
| * // The interrupt service routine that changes the period of xTimer. |
| * void vAnExampleInterruptServiceRoutine( void ) |
| * { |
| * BaseType_t xHigherPriorityTaskWoken = pdFALSE; |
| * |
| * // The interrupt has occurred - change the period of xTimer to 500ms. |
| * // xHigherPriorityTaskWoken was set to pdFALSE where it was defined |
| * // (within this function). As this is an interrupt service routine, only |
| * // FreeRTOS API functions that end in "FromISR" can be used. |
| * if( xTimerChangePeriodFromISR( xTimer, &xHigherPriorityTaskWoken ) != pdPASS ) |
| * { |
| * // The command to change the timers period was not executed |
| * // successfully. Take appropriate action here. |
| * } |
| * |
| * // If xHigherPriorityTaskWoken equals pdTRUE, then a context switch |
| * // should be performed. The syntax required to perform a context switch |
| * // from inside an ISR varies from port to port, and from compiler to |
| * // compiler. Inspect the demos for the port you are using to find the |
| * // actual syntax required. |
| * if( xHigherPriorityTaskWoken != pdFALSE ) |
| * { |
| * // Call the interrupt safe yield function here (actual function |
| * // depends on the FreeRTOS port being used). |
| * } |
| * } |
| * @endverbatim |
| */ |
| #define xTimerChangePeriodFromISR( xTimer, xNewPeriod, pxHigherPriorityTaskWoken ) \ |
| xTimerGenericCommand( ( xTimer ), tmrCOMMAND_CHANGE_PERIOD_FROM_ISR, ( xNewPeriod ), ( pxHigherPriorityTaskWoken ), 0U ) |
| |
| /** |
| * BaseType_t xTimerResetFromISR( TimerHandle_t xTimer, |
| * BaseType_t *pxHigherPriorityTaskWoken ); |
| * |
| * A version of xTimerReset() that can be called from an interrupt service |
| * routine. |
| * |
| * @param xTimer The handle of the timer that is to be started, reset, or |
| * restarted. |
| * |
| * @param pxHigherPriorityTaskWoken The timer service/daemon task spends most |
| * of its time in the Blocked state, waiting for messages to arrive on the timer |
| * command queue. Calling xTimerResetFromISR() writes a message to the timer |
| * command queue, so has the potential to transition the timer service/daemon |
| * task out of the Blocked state. If calling xTimerResetFromISR() causes the |
| * timer service/daemon task to leave the Blocked state, and the timer service/ |
| * daemon task has a priority equal to or greater than the currently executing |
| * task (the task that was interrupted), then *pxHigherPriorityTaskWoken will |
| * get set to pdTRUE internally within the xTimerResetFromISR() function. If |
| * xTimerResetFromISR() sets this value to pdTRUE then a context switch should |
| * be performed before the interrupt exits. |
| * |
| * @return pdFAIL will be returned if the reset command could not be sent to |
| * the timer command queue. pdPASS will be returned if the command was |
| * successfully sent to the timer command queue. When the command is actually |
| * processed will depend on the priority of the timer service/daemon task |
| * relative to other tasks in the system, although the timers expiry time is |
| * relative to when xTimerResetFromISR() is actually called. The timer service/daemon |
| * task priority is set by the configTIMER_TASK_PRIORITY configuration constant. |
| * |
| * Example usage: |
| * @verbatim |
| * // This scenario assumes xBacklightTimer has already been created. When a |
| * // key is pressed, an LCD back-light is switched on. If 5 seconds pass |
| * // without a key being pressed, then the LCD back-light is switched off. In |
| * // this case, the timer is a one-shot timer, and unlike the example given for |
| * // the xTimerReset() function, the key press event handler is an interrupt |
| * // service routine. |
| * |
| * // The callback function assigned to the one-shot timer. In this case the |
| * // parameter is not used. |
| * void vBacklightTimerCallback( TimerHandle_t pxTimer ) |
| * { |
| * // The timer expired, therefore 5 seconds must have passed since a key |
| * // was pressed. Switch off the LCD back-light. |
| * vSetBacklightState( BACKLIGHT_OFF ); |
| * } |
| * |
| * // The key press interrupt service routine. |
| * void vKeyPressEventInterruptHandler( void ) |
| * { |
| * BaseType_t xHigherPriorityTaskWoken = pdFALSE; |
| * |
| * // Ensure the LCD back-light is on, then reset the timer that is |
| * // responsible for turning the back-light off after 5 seconds of |
| * // key inactivity. This is an interrupt service routine so can only |
| * // call FreeRTOS API functions that end in "FromISR". |
| * vSetBacklightState( BACKLIGHT_ON ); |
| * |
| * // xTimerStartFromISR() or xTimerResetFromISR() could be called here |
| * // as both cause the timer to re-calculate its expiry time. |
| * // xHigherPriorityTaskWoken was initialised to pdFALSE when it was |
| * // declared (in this function). |
| * if( xTimerResetFromISR( xBacklightTimer, &xHigherPriorityTaskWoken ) != pdPASS ) |
| * { |
| * // The reset command was not executed successfully. Take appropriate |
| * // action here. |
| * } |
| * |
| * // Perform the rest of the key processing here. |
| * |
| * // If xHigherPriorityTaskWoken equals pdTRUE, then a context switch |
| * // should be performed. The syntax required to perform a context switch |
| * // from inside an ISR varies from port to port, and from compiler to |
| * // compiler. Inspect the demos for the port you are using to find the |
| * // actual syntax required. |
| * if( xHigherPriorityTaskWoken != pdFALSE ) |
| * { |
| * // Call the interrupt safe yield function here (actual function |
| * // depends on the FreeRTOS port being used). |
| * } |
| * } |
| * @endverbatim |
| */ |
| #define xTimerResetFromISR( xTimer, pxHigherPriorityTaskWoken ) \ |
| xTimerGenericCommand( ( xTimer ), tmrCOMMAND_RESET_FROM_ISR, ( xTaskGetTickCountFromISR() ), ( pxHigherPriorityTaskWoken ), 0U ) |
| |
| |
| /** |
| * BaseType_t xTimerPendFunctionCallFromISR( PendedFunction_t xFunctionToPend, |
| * void *pvParameter1, |
| * uint32_t ulParameter2, |
| * BaseType_t *pxHigherPriorityTaskWoken ); |
| * |
| * |
| * Used from application interrupt service routines to defer the execution of a |
| * function to the RTOS daemon task (the timer service task, hence this function |
| * is implemented in timers.c and is prefixed with 'Timer'). |
| * |
| * Ideally an interrupt service routine (ISR) is kept as short as possible, but |
| * sometimes an ISR either has a lot of processing to do, or needs to perform |
| * processing that is not deterministic. In these cases |
| * xTimerPendFunctionCallFromISR() can be used to defer processing of a function |
| * to the RTOS daemon task. |
| * |
| * A mechanism is provided that allows the interrupt to return directly to the |
| * task that will subsequently execute the pended callback function. This |
| * allows the callback function to execute contiguously in time with the |
| * interrupt - just as if the callback had executed in the interrupt itself. |
| * |
| * @param xFunctionToPend The function to execute from the timer service/ |
| * daemon task. The function must conform to the PendedFunction_t |
| * prototype. |
| * |
| * @param pvParameter1 The value of the callback function's first parameter. |
| * The parameter has a void * type to allow it to be used to pass any type. |
| * For example, unsigned longs can be cast to a void *, or the void * can be |
| * used to point to a structure. |
| * |
| * @param ulParameter2 The value of the callback function's second parameter. |
| * |
| * @param pxHigherPriorityTaskWoken As mentioned above, calling this function |
| * will result in a message being sent to the timer daemon task. If the |
| * priority of the timer daemon task (which is set using |
| * configTIMER_TASK_PRIORITY in FreeRTOSConfig.h) is higher than the priority of |
| * the currently running task (the task the interrupt interrupted) then |
| * *pxHigherPriorityTaskWoken will be set to pdTRUE within |
| * xTimerPendFunctionCallFromISR(), indicating that a context switch should be |
| * requested before the interrupt exits. For that reason |
| * *pxHigherPriorityTaskWoken must be initialised to pdFALSE. See the |
| * example code below. |
| * |
| * @return pdPASS is returned if the message was successfully sent to the |
| * timer daemon task, otherwise pdFALSE is returned. |
| * |
| * Example usage: |
| * @verbatim |
| * |
| * // The callback function that will execute in the context of the daemon task. |
| * // Note callback functions must all use this same prototype. |
| * void vProcessInterface( void *pvParameter1, uint32_t ulParameter2 ) |
| * { |
| * BaseType_t xInterfaceToService; |
| * |
| * // The interface that requires servicing is passed in the second |
| * // parameter. The first parameter is not used in this case. |
| * xInterfaceToService = ( BaseType_t ) ulParameter2; |
| * |
| * // ...Perform the processing here... |
| * } |
| * |
| * // An ISR that receives data packets from multiple interfaces |
| * void vAnISR( void ) |
| * { |
| * BaseType_t xInterfaceToService, xHigherPriorityTaskWoken; |
| * |
| * // Query the hardware to determine which interface needs processing. |
| * xInterfaceToService = prvCheckInterfaces(); |
| * |
| * // The actual processing is to be deferred to a task. Request the |
| * // vProcessInterface() callback function is executed, passing in the |
| * // number of the interface that needs processing. The interface to |
| * // service is passed in the second parameter. The first parameter is |
| * // not used in this case. |
| * xHigherPriorityTaskWoken = pdFALSE; |
| * xTimerPendFunctionCallFromISR( vProcessInterface, NULL, ( uint32_t ) xInterfaceToService, &xHigherPriorityTaskWoken ); |
| * |
| * // If xHigherPriorityTaskWoken is now set to pdTRUE then a context |
| * // switch should be requested. The macro used is port specific and will |
| * // be either portYIELD_FROM_ISR() or portEND_SWITCHING_ISR() - refer to |
| * // the documentation page for the port being used. |
| * portYIELD_FROM_ISR( xHigherPriorityTaskWoken ); |
| * |
| * } |
| * @endverbatim |
| */ |
| BaseType_t xTimerPendFunctionCallFromISR( PendedFunction_t xFunctionToPend, |
| void * pvParameter1, |
| uint32_t ulParameter2, |
| BaseType_t * pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION; |
| |
| /** |
| * BaseType_t xTimerPendFunctionCall( PendedFunction_t xFunctionToPend, |
| * void *pvParameter1, |
| * uint32_t ulParameter2, |
| * TickType_t xTicksToWait ); |
| * |
| * |
| * Used to defer the execution of a function to the RTOS daemon task (the timer |
| * service task, hence this function is implemented in timers.c and is prefixed |
| * with 'Timer'). |
| * |
| * @param xFunctionToPend The function to execute from the timer service/ |
| * daemon task. The function must conform to the PendedFunction_t |
| * prototype. |
| * |
| * @param pvParameter1 The value of the callback function's first parameter. |
| * The parameter has a void * type to allow it to be used to pass any type. |
| * For example, unsigned longs can be cast to a void *, or the void * can be |
| * used to point to a structure. |
| * |
| * @param ulParameter2 The value of the callback function's second parameter. |
| * |
| * @param xTicksToWait Calling this function will result in a message being |
| * sent to the timer daemon task on a queue. xTicksToWait is the amount of |
| * time the calling task should remain in the Blocked state (so not using any |
| * processing time) for space to become available on the timer queue if the |
| * queue is found to be full. |
| * |
| * @return pdPASS is returned if the message was successfully sent to the |
| * timer daemon task, otherwise pdFALSE is returned. |
| * |
| */ |
| BaseType_t xTimerPendFunctionCall( PendedFunction_t xFunctionToPend, |
| void * pvParameter1, |
| uint32_t ulParameter2, |
| TickType_t xTicksToWait ) PRIVILEGED_FUNCTION; |
| |
| /** |
| * const char * const pcTimerGetName( TimerHandle_t xTimer ); |
| * |
| * Returns the name that was assigned to a timer when the timer was created. |
| * |
| * @param xTimer The handle of the timer being queried. |
| * |
| * @return The name assigned to the timer specified by the xTimer parameter. |
| */ |
| const char * pcTimerGetName( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */ |
| |
| /** |
| * void vTimerSetReloadMode( TimerHandle_t xTimer, const BaseType_t xAutoReload ); |
| * |
| * Updates a timer to be either an auto-reload timer, in which case the timer |
| * automatically resets itself each time it expires, or a one-shot timer, in |
| * which case the timer will only expire once unless it is manually restarted. |
| * |
| * @param xTimer The handle of the timer being updated. |
| * |
| * @param xAutoReload If xAutoReload is set to pdTRUE then the timer will |
| * expire repeatedly with a frequency set by the timer's period (see the |
| * xTimerPeriodInTicks parameter of the xTimerCreate() API function). If |
| * xAutoReload is set to pdFALSE then the timer will be a one-shot timer and |
| * enter the dormant state after it expires. |
| */ |
| void vTimerSetReloadMode( TimerHandle_t xTimer, |
| const BaseType_t xAutoReload ) PRIVILEGED_FUNCTION; |
| |
| /** |
| * BaseType_t xTimerGetReloadMode( TimerHandle_t xTimer ); |
| * |
| * Queries a timer to determine if it is an auto-reload timer, in which case the timer |
| * automatically resets itself each time it expires, or a one-shot timer, in |
| * which case the timer will only expire once unless it is manually restarted. |
| * |
| * @param xTimer The handle of the timer being queried. |
| * |
| * @return If the timer is an auto-reload timer then pdTRUE is returned, otherwise |
| * pdFALSE is returned. |
| */ |
| BaseType_t xTimerGetReloadMode( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION; |
| |
| /** |
| * UBaseType_t uxTimerGetReloadMode( TimerHandle_t xTimer ); |
| * |
| * Queries a timer to determine if it is an auto-reload timer, in which case the timer |
| * automatically resets itself each time it expires, or a one-shot timer, in |
| * which case the timer will only expire once unless it is manually restarted. |
| * |
| * @param xTimer The handle of the timer being queried. |
| * |
| * @return If the timer is an auto-reload timer then pdTRUE is returned, otherwise |
| * pdFALSE is returned. |
| */ |
| UBaseType_t uxTimerGetReloadMode( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION; |
| |
| /** |
| * TickType_t xTimerGetPeriod( TimerHandle_t xTimer ); |
| * |
| * Returns the period of a timer. |
| * |
| * @param xTimer The handle of the timer being queried. |
| * |
| * @return The period of the timer in ticks. |
| */ |
| TickType_t xTimerGetPeriod( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION; |
| |
| /** |
| * TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer ); |
| * |
| * Returns the time in ticks at which the timer will expire. If this is less |
| * than the current tick count then the expiry time has overflowed from the |
| * current time. |
| * |
| * @param xTimer The handle of the timer being queried. |
| * |
| * @return If the timer is running then the time in ticks at which the timer |
| * will next expire is returned. If the timer is not running then the return |
| * value is undefined. |
| */ |
| TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION; |
| |
| /* |
| * Functions beyond this part are not part of the public API and are intended |
| * for use by the kernel only. |
| */ |
| BaseType_t xTimerCreateTimerTask( void ) PRIVILEGED_FUNCTION; |
| BaseType_t xTimerGenericCommand( TimerHandle_t xTimer, |
| const BaseType_t xCommandID, |
| const TickType_t xOptionalValue, |
| BaseType_t * const pxHigherPriorityTaskWoken, |
| const TickType_t xTicksToWait ) PRIVILEGED_FUNCTION; |
| |
| #if ( configUSE_TRACE_FACILITY == 1 ) |
| void vTimerSetTimerNumber( TimerHandle_t xTimer, |
| UBaseType_t uxTimerNumber ) PRIVILEGED_FUNCTION; |
| UBaseType_t uxTimerGetTimerNumber( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION; |
| #endif |
| |
| #if ( configSUPPORT_STATIC_ALLOCATION == 1 ) |
| |
| /** |
| * task.h |
| * @code{c} |
| * void vApplicationGetTimerTaskMemory( StaticTask_t ** ppxTimerTaskTCBBuffer, StackType_t ** ppxTimerTaskStackBuffer, uint32_t *pulTimerTaskStackSize ) |
| * @endcode |
| * |
| * This function is used to provide a statically allocated block of memory to FreeRTOS to hold the Timer Task TCB. This function is required when |
| * configSUPPORT_STATIC_ALLOCATION is set. For more information see this URI: https://www.FreeRTOS.org/a00110.html#configSUPPORT_STATIC_ALLOCATION |
| * |
| * @param ppxTimerTaskTCBBuffer A handle to a statically allocated TCB buffer |
| * @param ppxTimerTaskStackBuffer A handle to a statically allocated Stack buffer for the idle task |
| * @param pulTimerTaskStackSize A pointer to the number of elements that will fit in the allocated stack buffer |
| */ |
| void vApplicationGetTimerTaskMemory( StaticTask_t ** ppxTimerTaskTCBBuffer, |
| StackType_t ** ppxTimerTaskStackBuffer, |
| uint32_t * pulTimerTaskStackSize ); |
| |
| #endif |
| |
| /* *INDENT-OFF* */ |
| #ifdef __cplusplus |
| } |
| #endif |
| /* *INDENT-ON* */ |
| #endif /* TIMERS_H */ |
