/*\r
- FreeRTOS V7.4.0 - Copyright (C) 2013 Real Time Engineers Ltd.\r
+ FreeRTOS V7.6.0 - Copyright (C) 2013 Real Time Engineers Ltd.\r
+ All rights reserved\r
\r
- FEATURES AND PORTS ARE ADDED TO FREERTOS ALL THE TIME. PLEASE VISIT\r
- http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.\r
+ VISIT http://www.FreeRTOS.org TO ENSURE YOU ARE USING THE LATEST VERSION.\r
\r
***************************************************************************\r
* *\r
- * FreeRTOS tutorial books are available in pdf and paperback. *\r
- * Complete, revised, and edited pdf reference manuals are also *\r
- * available. *\r
+ * FreeRTOS provides completely free yet professionally developed, *\r
+ * robust, strictly quality controlled, supported, and cross *\r
+ * platform software that has become a de facto standard. *\r
* *\r
- * Purchasing FreeRTOS documentation will not only help you, by *\r
- * ensuring you get running as quickly as possible and with an *\r
- * in-depth knowledge of how to use FreeRTOS, it will also help *\r
- * the FreeRTOS project to continue with its mission of providing *\r
- * professional grade, cross platform, de facto standard solutions *\r
- * for microcontrollers - completely free of charge! *\r
+ * Help yourself get started quickly and support the FreeRTOS *\r
+ * project by purchasing a FreeRTOS tutorial book, reference *\r
+ * manual, or both from: http://www.FreeRTOS.org/Documentation *\r
* *\r
- * >>> See http://www.FreeRTOS.org/Documentation for details. <<< *\r
- * *\r
- * Thank you for using FreeRTOS, and thank you for your support! *\r
+ * Thank you! *\r
* *\r
***************************************************************************\r
\r
-\r
This file is part of the FreeRTOS distribution.\r
\r
FreeRTOS is free software; you can redistribute it and/or modify it under\r
the terms of the GNU General Public License (version 2) as published by the\r
- Free Software Foundation AND MODIFIED BY the FreeRTOS exception.\r
+ Free Software Foundation >>!AND MODIFIED BY!<< the FreeRTOS exception.\r
\r
- >>>>>>NOTE<<<<<< The modification to the GPL is included to allow you to\r
- distribute a combined work that includes FreeRTOS without being obliged to\r
- provide the source code for proprietary components outside of the FreeRTOS\r
- kernel.\r
+ >>! NOTE: The modification to the GPL is included to allow you to distribute\r
+ >>! a combined work that includes FreeRTOS without being obliged to provide\r
+ >>! the source code for proprietary components outside of the FreeRTOS\r
+ >>! kernel.\r
\r
FreeRTOS is distributed in the hope that it will be useful, but WITHOUT ANY\r
WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS\r
- FOR A PARTICULAR PURPOSE. See the GNU General Public License for more\r
- details. You should have received a copy of the GNU General Public License\r
- and the FreeRTOS license exception along with FreeRTOS; if not itcan be\r
- viewed here: http://www.freertos.org/a00114.html and also obtained by\r
- writing to Real Time Engineers Ltd., contact details for whom are available\r
- on the FreeRTOS WEB site.\r
+ FOR A PARTICULAR PURPOSE. Full license text is available from the following\r
+ link: http://www.freertos.org/a00114.html\r
\r
1 tab == 4 spaces!\r
\r
* *\r
***************************************************************************\r
\r
-\r
- http://www.FreeRTOS.org - Documentation, books, training, latest versions, \r
+ http://www.FreeRTOS.org - Documentation, books, training, latest versions,\r
license and Real Time Engineers Ltd. contact details.\r
\r
http://www.FreeRTOS.org/plus - A selection of FreeRTOS ecosystem products,\r
- including FreeRTOS+Trace - an indispensable productivity tool, and our new\r
- fully thread aware and reentrant UDP/IP stack.\r
-\r
- http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High \r
- Integrity Systems, who sell the code with commercial support, \r
- indemnification and middleware, under the OpenRTOS brand.\r
- \r
- http://www.SafeRTOS.com - High Integrity Systems also provide a safety \r
- engineered and independently SIL3 certified version for use in safety and \r
+ including FreeRTOS+Trace - an indispensable productivity tool, a DOS\r
+ compatible FAT file system, and our tiny thread aware UDP/IP stack.\r
+\r
+ http://www.OpenRTOS.com - Real Time Engineers ltd license FreeRTOS to High\r
+ Integrity Systems to sell under the OpenRTOS brand. Low cost OpenRTOS\r
+ licenses offer ticketed support, indemnification and middleware.\r
+\r
+ http://www.SafeRTOS.com - High Integrity Systems also provide a safety\r
+ engineered and independently SIL3 certified version for use in safety and\r
mission critical applications that require provable dependability.\r
+\r
+ 1 tab == 4 spaces!\r
*/\r
\r
\r
#error "include FreeRTOS.h must appear in source files before include timers.h"\r
#endif\r
\r
-#include "portable.h"\r
-#include "list.h"\r
+/*lint -e537 This headers are only multiply included if the application code\r
+happens to also be including task.h. */\r
#include "task.h"\r
+/*lint +e956 */\r
\r
#ifdef __cplusplus\r
extern "C" {\r
#endif\r
\r
-/* IDs for commands that can be sent/received on the timer queue. These are to\r
-be used solely through the macros that make up the public software timer API,\r
-as defined below. */\r
-#define tmrCOMMAND_START 0\r
-#define tmrCOMMAND_STOP 1\r
-#define tmrCOMMAND_CHANGE_PERIOD 2\r
-#define tmrCOMMAND_DELETE 3\r
-\r
/*-----------------------------------------------------------\r
* MACROS AND DEFINITIONS\r
*----------------------------------------------------------*/\r
\r
- /**\r
+/* IDs for commands that can be sent/received on the timer queue. These are to\r
+be used solely through the macros that make up the public software timer API,\r
+as defined below. */\r
+#define tmrCOMMAND_EXECUTE_CALLBACK ( ( BaseType_t ) -1 )\r
+#define tmrCOMMAND_START ( ( BaseType_t ) 0 )\r
+#define tmrCOMMAND_STOP ( ( BaseType_t ) 1 )\r
+#define tmrCOMMAND_CHANGE_PERIOD ( ( BaseType_t ) 2 )\r
+#define tmrCOMMAND_DELETE ( ( BaseType_t ) 3 )\r
+\r
+/**\r
* Type by which software timers are referenced. For example, a call to\r
- * xTimerCreate() returns an xTimerHandle variable that can then be used to\r
+ * xTimerCreate() returns an TimerHandle_t variable that can then be used to\r
* reference the subject timer in calls to other software timer API functions\r
* (for example, xTimerStart(), xTimerReset(), etc.).\r
*/\r
-typedef void * xTimerHandle;\r
+typedef void * TimerHandle_t;\r
\r
/* Define the prototype to which timer callback functions must conform. */\r
-typedef void (*tmrTIMER_CALLBACK)( xTimerHandle xTimer );\r
+typedef void (*tmrTIMER_CALLBACK)( TimerHandle_t xTimer );\r
\r
/**\r
- * xTimerHandle xTimerCreate( const signed char *pcTimerName,\r
- * portTickType xTimerPeriodInTicks,\r
- * unsigned portBASE_TYPE uxAutoReload,\r
+ * TimerHandle_t xTimerCreate( const char * const pcTimerName,\r
+ * TickType_t xTimerPeriodInTicks,\r
+ * UBaseType_t uxAutoReload,\r
* void * pvTimerID,\r
* tmrTIMER_CALLBACK pxCallbackFunction );\r
*\r
*\r
* Timers are created in the dormant state. The xTimerStart(), xTimerReset(),\r
* xTimerStartFromISR(), xTimerResetFromISR(), xTimerChangePeriod() and\r
- * xTimerChangePeriodFromISR() API functions can all be used to transition a timer into the\r
- * active state.\r
+ * xTimerChangePeriodFromISR() API functions can all be used to transition a\r
+ * timer into the active state.\r
*\r
* @param pcTimerName A text name that is assigned to the timer. This is done\r
- * purely to assist debugging. The kernel itself only ever references a timer by\r
- * its handle, and never by its name.\r
+ * purely to assist debugging. The kernel itself only ever references a timer\r
+ * by its handle, and never by its name.\r
*\r
- * @param xTimerPeriodInTicks The timer period. The time is defined in tick periods so\r
- * the constant portTICK_RATE_MS can be used to convert a time that has been\r
- * specified in milliseconds. For example, if the timer must expire after 100\r
- * ticks, then xTimerPeriodInTicks should be set to 100. Alternatively, if the timer\r
- * must expire after 500ms, then xPeriod can be set to ( 500 / portTICK_RATE_MS )\r
- * provided configTICK_RATE_HZ is less than or equal to 1000.\r
+ * @param xTimerPeriodInTicks The timer period. The time is defined in tick\r
+ * periods so the constant portTICK_RATE_MS can be used to convert a time that\r
+ * has been specified in milliseconds. For example, if the timer must expire\r
+ * after 100 ticks, then xTimerPeriodInTicks should be set to 100.\r
+ * Alternatively, if the timer must expire after 500ms, then xPeriod can be set\r
+ * to ( 500 / portTICK_RATE_MS ) provided configTICK_RATE_HZ is less than or\r
+ * equal to 1000.\r
*\r
* @param uxAutoReload If uxAutoReload is set to pdTRUE then the timer will\r
- * expire repeatedly with a frequency set by the xTimerPeriodInTicks parameter. If\r
- * uxAutoReload is set to pdFALSE then the timer will be a one-shot timer and\r
+ * expire repeatedly with a frequency set by the xTimerPeriodInTicks parameter.\r
+ * If uxAutoReload is set to pdFALSE then the timer will be a one-shot timer and\r
* enter the dormant state after it expires.\r
*\r
* @param pvTimerID An identifier that is assigned to the timer being created.\r
*\r
* @param pxCallbackFunction The function to call when the timer expires.\r
* Callback functions must have the prototype defined by tmrTIMER_CALLBACK,\r
- * which is "void vCallbackFunction( xTimerHandle xTimer );".\r
+ * which is "void vCallbackFunction( TimerHandle_t xTimer );".\r
*\r
- * @return If the timer is successfully create then a handle to the newly\r
+ * @return If the timer is successfully created then a handle to the newly\r
* created timer is returned. If the timer cannot be created (because either\r
* there is insufficient FreeRTOS heap remaining to allocate the timer\r
- * structures, or the timer period was set to 0) then 0 is returned.\r
+ * structures, or the timer period was set to 0) then NULL is returned.\r
*\r
* Example usage:\r
- *\r
+ * @verbatim\r
* #define NUM_TIMERS 5\r
*\r
* // An array to hold handles to the created timers.\r
- * xTimerHandle xTimers[ NUM_TIMERS ];\r
+ * TimerHandle_t xTimers[ NUM_TIMERS ];\r
*\r
* // An array to hold a count of the number of times each timer expires.\r
- * long lExpireCounters[ NUM_TIMERS ] = { 0 };\r
+ * int32_t lExpireCounters[ NUM_TIMERS ] = { 0 };\r
*\r
* // Define a callback function that will be used by multiple timer instances.\r
* // The callback function does nothing but count the number of times the\r
* // associated timer expires, and stop the timer once the timer has expired\r
* // 10 times.\r
- * void vTimerCallback( xTimerHandle pxTimer )\r
+ * void vTimerCallback( TimerHandle_t pxTimer )\r
* {\r
- * long lArrayIndex;\r
- * const long xMaxExpiryCountBeforeStopping = 10;\r
+ * int32_t lArrayIndex;\r
+ * const int32_t xMaxExpiryCountBeforeStopping = 10;\r
*\r
* // Optionally do something if the pxTimer parameter is NULL.\r
* configASSERT( pxTimer );\r
- * \r
+ *\r
* // Which timer expired?\r
- * lArrayIndex = ( long ) pvTimerGetTimerID( pxTimer );\r
+ * lArrayIndex = ( int32_t ) pvTimerGetTimerID( pxTimer );\r
*\r
* // Increment the number of times that pxTimer has expired.\r
* lExpireCounters[ lArrayIndex ] += 1;\r
*\r
* void main( void )\r
* {\r
- * long x;\r
+ * int32_t x;\r
*\r
* // Create then start some timers. Starting the timers before the scheduler\r
* // has been started means the timers will start running immediately that\r
* // the scheduler starts.\r
* for( x = 0; x < NUM_TIMERS; x++ )\r
* {\r
- * xTimers[ x ] = xTimerCreate( "Timer", // Just a text name, not used by the kernel.\r
- * ( 100 * x ), // The timer period in ticks.\r
- * pdTRUE, // The timers will auto-reload themselves when they expire.\r
- * ( void * ) x, // Assign each timer a unique id equal to its array index.\r
- * vTimerCallback // Each timer calls the same callback when it expires.\r
+ * xTimers[ x ] = xTimerCreate( "Timer", // Just a text name, not used by the kernel.\r
+ * ( 100 * x ), // The timer period in ticks.\r
+ * pdTRUE, // The timers will auto-reload themselves when they expire.\r
+ * ( void * ) x, // Assign each timer a unique id equal to its array index.\r
+ * vTimerCallback // Each timer calls the same callback when it expires.\r
* );\r
*\r
* if( xTimers[ x ] == NULL )\r
* // Should not reach here.\r
* for( ;; );\r
* }\r
+ * @endverbatim\r
*/\r
-xTimerHandle xTimerCreate( const signed char * const pcTimerName, portTickType xTimerPeriodInTicks, unsigned portBASE_TYPE uxAutoReload, void * pvTimerID, tmrTIMER_CALLBACK pxCallbackFunction ) PRIVILEGED_FUNCTION;\r
+TimerHandle_t xTimerCreate( const char * const pcTimerName, const TickType_t xTimerPeriodInTicks, const UBaseType_t uxAutoReload, void * const pvTimerID, tmrTIMER_CALLBACK pxCallbackFunction ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
\r
/**\r
- * void *pvTimerGetTimerID( xTimerHandle xTimer );\r
+ * void *pvTimerGetTimerID( TimerHandle_t xTimer );\r
*\r
* Returns the ID assigned to the timer.\r
*\r
*\r
* See the xTimerCreate() API function example usage scenario.\r
*/\r
-void *pvTimerGetTimerID( xTimerHandle xTimer ) PRIVILEGED_FUNCTION;\r
+void *pvTimerGetTimerID( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;\r
\r
/**\r
- * portBASE_TYPE xTimerIsTimerActive( xTimerHandle xTimer );\r
+ * BaseType_t xTimerIsTimerActive( TimerHandle_t xTimer );\r
*\r
* Queries a timer to see if it is active or dormant.\r
*\r
* A timer will be dormant if:\r
* 1) It has been created but not started, or\r
- * 2) It is an expired on-shot timer that has not been restarted.\r
+ * 2) It is an expired one-shot timer that has not been restarted.\r
*\r
* Timers are created in the dormant state. The xTimerStart(), xTimerReset(),\r
* xTimerStartFromISR(), xTimerResetFromISR(), xTimerChangePeriod() and\r
* pdFALSE will be returned if the timer is active.\r
*\r
* Example usage:\r
- *\r
+ * @verbatim\r
* // This function assumes xTimer has already been created.\r
- * void vAFunction( xTimerHandle xTimer )\r
+ * void vAFunction( TimerHandle_t xTimer )\r
* {\r
* if( xTimerIsTimerActive( xTimer ) != pdFALSE ) // or more simply and equivalently "if( xTimerIsTimerActive( xTimer ) )"\r
* {\r
* // xTimer is not active, do something else.\r
* }\r
* }\r
+ * @endverbatim\r
*/\r
-portBASE_TYPE xTimerIsTimerActive( xTimerHandle xTimer ) PRIVILEGED_FUNCTION;\r
+BaseType_t xTimerIsTimerActive( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;\r
\r
/**\r
- * xTimerGetTimerDaemonTaskHandle() is only available if \r
+ * TaskHandle_t xTimerGetTimerDaemonTaskHandle( void );\r
+ *\r
+ * xTimerGetTimerDaemonTaskHandle() is only available if\r
* INCLUDE_xTimerGetTimerDaemonTaskHandle is set to 1 in FreeRTOSConfig.h.\r
*\r
* Simply returns the handle of the timer service/daemon task. It it not valid\r
* to call xTimerGetTimerDaemonTaskHandle() before the scheduler has been started.\r
*/\r
-xTaskHandle xTimerGetTimerDaemonTaskHandle( void );\r
+TaskHandle_t xTimerGetTimerDaemonTaskHandle( void );\r
\r
/**\r
- * portBASE_TYPE xTimerStart( xTimerHandle xTimer, portTickType xBlockTime );\r
+ * BaseType_t xTimerStart( TimerHandle_t xTimer, TickType_t xBlockTime );\r
*\r
* Timer functionality is provided by a timer service/daemon task. Many of the\r
* public FreeRTOS timer API functions send commands to the timer service task\r
- * though a queue called the timer command queue. The timer command queue is\r
+ * through a queue called the timer command queue. The timer command queue is\r
* private to the kernel itself and is not directly accessible to application\r
* code. The length of the timer command queue is set by the\r
* configTIMER_QUEUE_LENGTH configuration constant.\r
#define xTimerStart( xTimer, xBlockTime ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_START, ( xTaskGetTickCount() ), NULL, ( xBlockTime ) )\r
\r
/**\r
- * portBASE_TYPE xTimerStop( xTimerHandle xTimer, portTickType xBlockTime );\r
+ * BaseType_t xTimerStop( TimerHandle_t xTimer, TickType_t xBlockTime );\r
*\r
* Timer functionality is provided by a timer service/daemon task. Many of the\r
* public FreeRTOS timer API functions send commands to the timer service task\r
- * though a queue called the timer command queue. The timer command queue is\r
+ * through a queue called the timer command queue. The timer command queue is\r
* private to the kernel itself and is not directly accessible to application\r
* code. The length of the timer command queue is set by the\r
* configTIMER_QUEUE_LENGTH configuration constant.\r
#define xTimerStop( xTimer, xBlockTime ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_STOP, 0U, NULL, ( xBlockTime ) )\r
\r
/**\r
- * portBASE_TYPE xTimerChangePeriod( xTimerHandle xTimer,\r
- * portTickType xNewPeriod,\r
- * portTickType xBlockTime );\r
+ * BaseType_t xTimerChangePeriod( TimerHandle_t xTimer,\r
+ * TickType_t xNewPeriod,\r
+ * TickType_t xBlockTime );\r
*\r
* Timer functionality is provided by a timer service/daemon task. Many of the\r
* public FreeRTOS timer API functions send commands to the timer service task\r
- * though a queue called the timer command queue. The timer command queue is\r
+ * through a queue called the timer command queue. The timer command queue is\r
* private to the kernel itself and is not directly accessible to application\r
* code. The length of the timer command queue is set by the\r
* configTIMER_QUEUE_LENGTH configuration constant.\r
* configTIMER_TASK_PRIORITY configuration constant.\r
*\r
* Example usage:\r
- *\r
+ * @verbatim\r
* // This function assumes xTimer has already been created. If the timer\r
* // referenced by xTimer is already active when it is called, then the timer\r
* // is deleted. If the timer referenced by xTimer is not active when it is\r
* // called, then the period of the timer is set to 500ms and the timer is\r
* // started.\r
- * void vAFunction( xTimerHandle xTimer )\r
+ * void vAFunction( TimerHandle_t xTimer )\r
* {\r
* if( xTimerIsTimerActive( xTimer ) != pdFALSE ) // or more simply and equivalently "if( xTimerIsTimerActive( xTimer ) )"\r
* {\r
* }\r
* }\r
* }\r
+ * @endverbatim\r
*/\r
#define xTimerChangePeriod( xTimer, xNewPeriod, xBlockTime ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_CHANGE_PERIOD, ( xNewPeriod ), NULL, ( xBlockTime ) )\r
\r
/**\r
- * portBASE_TYPE xTimerDelete( xTimerHandle xTimer, portTickType xBlockTime );\r
+ * BaseType_t xTimerDelete( TimerHandle_t xTimer, TickType_t xBlockTime );\r
*\r
* Timer functionality is provided by a timer service/daemon task. Many of the\r
* public FreeRTOS timer API functions send commands to the timer service task\r
- * though a queue called the timer command queue. The timer command queue is\r
+ * through a queue called the timer command queue. The timer command queue is\r
* private to the kernel itself and is not directly accessible to application\r
* code. The length of the timer command queue is set by the\r
* configTIMER_QUEUE_LENGTH configuration constant.\r
#define xTimerDelete( xTimer, xBlockTime ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_DELETE, 0U, NULL, ( xBlockTime ) )\r
\r
/**\r
- * portBASE_TYPE xTimerReset( xTimerHandle xTimer, portTickType xBlockTime );\r
+ * BaseType_t xTimerReset( TimerHandle_t xTimer, TickType_t xBlockTime );\r
*\r
* Timer functionality is provided by a timer service/daemon task. Many of the\r
* public FreeRTOS timer API functions send commands to the timer service task\r
- * though a queue called the timer command queue. The timer command queue is\r
+ * through a queue called the timer command queue. The timer command queue is\r
* private to the kernel itself and is not directly accessible to application\r
* code. The length of the timer command queue is set by the\r
* configTIMER_QUEUE_LENGTH configuration constant.\r
* configuration constant.\r
*\r
* Example usage:\r
- *\r
+ * @verbatim\r
* // When a key is pressed, an LCD back-light is switched on. If 5 seconds pass\r
* // without a key being pressed, then the LCD back-light is switched off. In\r
* // this case, the timer is a one-shot timer.\r
*\r
- * xTimerHandle xBacklightTimer = NULL;\r
+ * TimerHandle_t xBacklightTimer = NULL;\r
*\r
* // The callback function assigned to the one-shot timer. In this case the\r
* // parameter is not used.\r
- * void vBacklightTimerCallback( xTimerHandle pxTimer )\r
+ * void vBacklightTimerCallback( TimerHandle_t pxTimer )\r
* {\r
* // The timer expired, therefore 5 seconds must have passed since a key\r
* // was pressed. Switch off the LCD back-light.\r
*\r
* void main( void )\r
* {\r
- * long x;\r
+ * int32_t x;\r
*\r
* // Create then start the one-shot timer that is responsible for turning\r
* // the back-light off if no keys are pressed within a 5 second period.\r
* // Should not reach here.\r
* for( ;; );\r
* }\r
+ * @endverbatim\r
*/\r
#define xTimerReset( xTimer, xBlockTime ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_START, ( xTaskGetTickCount() ), NULL, ( xBlockTime ) )\r
\r
/**\r
- * portBASE_TYPE xTimerStartFromISR( xTimerHandle xTimer,\r
- * portBASE_TYPE *pxHigherPriorityTaskWoken );\r
+ * BaseType_t xTimerStartFromISR( TimerHandle_t xTimer,\r
+ * BaseType_t *pxHigherPriorityTaskWoken );\r
*\r
* A version of xTimerStart() that can be called from an interrupt service\r
* routine.\r
* successfully sent to the timer command queue. When the command is actually\r
* processed will depend on the priority of the timer service/daemon task\r
* relative to other tasks in the system, although the timers expiry time is\r
- * relative to when xTimerStartFromISR() is actually called. The timer service/daemon\r
- * task priority is set by the configTIMER_TASK_PRIORITY configuration constant.\r
+ * relative to when xTimerStartFromISR() is actually called. The timer\r
+ * service/daemon task priority is set by the configTIMER_TASK_PRIORITY\r
+ * configuration constant.\r
*\r
* Example usage:\r
- *\r
+ * @verbatim\r
* // This scenario assumes xBacklightTimer has already been created. When a\r
* // key is pressed, an LCD back-light is switched on. If 5 seconds pass\r
* // without a key being pressed, then the LCD back-light is switched off. In\r
*\r
* // The callback function assigned to the one-shot timer. In this case the\r
* // parameter is not used.\r
- * void vBacklightTimerCallback( xTimerHandle pxTimer )\r
+ * void vBacklightTimerCallback( TimerHandle_t pxTimer )\r
* {\r
* // The timer expired, therefore 5 seconds must have passed since a key\r
* // was pressed. Switch off the LCD back-light.\r
* // The key press interrupt service routine.\r
* void vKeyPressEventInterruptHandler( void )\r
* {\r
- * portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
+ * BaseType_t xHigherPriorityTaskWoken = pdFALSE;\r
*\r
* // Ensure the LCD back-light is on, then restart the timer that is\r
* // responsible for turning the back-light off after 5 seconds of\r
* if( xHigherPriorityTaskWoken != pdFALSE )\r
* {\r
* // Call the interrupt safe yield function here (actual function\r
- * // depends on the FreeRTOS port being used.\r
+ * // depends on the FreeRTOS port being used).\r
* }\r
* }\r
+ * @endverbatim\r
*/\r
#define xTimerStartFromISR( xTimer, pxHigherPriorityTaskWoken ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_START, ( xTaskGetTickCountFromISR() ), ( pxHigherPriorityTaskWoken ), 0U )\r
\r
/**\r
- * portBASE_TYPE xTimerStopFromISR( xTimerHandle xTimer,\r
- * portBASE_TYPE *pxHigherPriorityTaskWoken );\r
+ * BaseType_t xTimerStopFromISR( TimerHandle_t xTimer,\r
+ * BaseType_t *pxHigherPriorityTaskWoken );\r
*\r
* A version of xTimerStop() that can be called from an interrupt service\r
* routine.\r
* priority is set by the configTIMER_TASK_PRIORITY configuration constant.\r
*\r
* Example usage:\r
- *\r
+ * @verbatim\r
* // This scenario assumes xTimer has already been created and started. When\r
* // an interrupt occurs, the timer should be simply stopped.\r
*\r
* // The interrupt service routine that stops the timer.\r
* void vAnExampleInterruptServiceRoutine( void )\r
* {\r
- * portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
+ * BaseType_t xHigherPriorityTaskWoken = pdFALSE;\r
*\r
* // The interrupt has occurred - simply stop the timer.\r
* // xHigherPriorityTaskWoken was set to pdFALSE where it was defined\r
* if( xHigherPriorityTaskWoken != pdFALSE )\r
* {\r
* // Call the interrupt safe yield function here (actual function\r
- * // depends on the FreeRTOS port being used.\r
+ * // depends on the FreeRTOS port being used).\r
* }\r
* }\r
+ * @endverbatim\r
*/\r
#define xTimerStopFromISR( xTimer, pxHigherPriorityTaskWoken ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_STOP, 0, ( pxHigherPriorityTaskWoken ), 0U )\r
\r
/**\r
- * portBASE_TYPE xTimerChangePeriodFromISR( xTimerHandle xTimer,\r
- * portTickType xNewPeriod,\r
- * portBASE_TYPE *pxHigherPriorityTaskWoken );\r
+ * BaseType_t xTimerChangePeriodFromISR( TimerHandle_t xTimer,\r
+ * TickType_t xNewPeriod,\r
+ * BaseType_t *pxHigherPriorityTaskWoken );\r
*\r
* A version of xTimerChangePeriod() that can be called from an interrupt\r
* service routine.\r
* priority is set by the configTIMER_TASK_PRIORITY configuration constant.\r
*\r
* Example usage:\r
- *\r
+ * @verbatim\r
* // This scenario assumes xTimer has already been created and started. When\r
* // an interrupt occurs, the period of xTimer should be changed to 500ms.\r
*\r
* // The interrupt service routine that changes the period of xTimer.\r
* void vAnExampleInterruptServiceRoutine( void )\r
* {\r
- * portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
+ * BaseType_t xHigherPriorityTaskWoken = pdFALSE;\r
*\r
* // The interrupt has occurred - change the period of xTimer to 500ms.\r
* // xHigherPriorityTaskWoken was set to pdFALSE where it was defined\r
* if( xHigherPriorityTaskWoken != pdFALSE )\r
* {\r
* // Call the interrupt safe yield function here (actual function\r
- * // depends on the FreeRTOS port being used.\r
+ * // depends on the FreeRTOS port being used).\r
* }\r
* }\r
+ * @endverbatim\r
*/\r
#define xTimerChangePeriodFromISR( xTimer, xNewPeriod, pxHigherPriorityTaskWoken ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_CHANGE_PERIOD, ( xNewPeriod ), ( pxHigherPriorityTaskWoken ), 0U )\r
\r
/**\r
- * portBASE_TYPE xTimerResetFromISR( xTimerHandle xTimer,\r
- * portBASE_TYPE *pxHigherPriorityTaskWoken );\r
+ * BaseType_t xTimerResetFromISR( TimerHandle_t xTimer,\r
+ * BaseType_t *pxHigherPriorityTaskWoken );\r
*\r
* A version of xTimerReset() that can be called from an interrupt service\r
* routine.\r
* task priority is set by the configTIMER_TASK_PRIORITY configuration constant.\r
*\r
* Example usage:\r
- *\r
+ * @verbatim\r
* // This scenario assumes xBacklightTimer has already been created. When a\r
* // key is pressed, an LCD back-light is switched on. If 5 seconds pass\r
* // without a key being pressed, then the LCD back-light is switched off. In\r
*\r
* // The callback function assigned to the one-shot timer. In this case the\r
* // parameter is not used.\r
- * void vBacklightTimerCallback( xTimerHandle pxTimer )\r
+ * void vBacklightTimerCallback( TimerHandle_t pxTimer )\r
* {\r
* // The timer expired, therefore 5 seconds must have passed since a key\r
* // was pressed. Switch off the LCD back-light.\r
* // The key press interrupt service routine.\r
* void vKeyPressEventInterruptHandler( void )\r
* {\r
- * portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;\r
+ * BaseType_t xHigherPriorityTaskWoken = pdFALSE;\r
*\r
* // Ensure the LCD back-light is on, then reset the timer that is\r
* // responsible for turning the back-light off after 5 seconds of\r
* if( xHigherPriorityTaskWoken != pdFALSE )\r
* {\r
* // Call the interrupt safe yield function here (actual function\r
- * // depends on the FreeRTOS port being used.\r
+ * // depends on the FreeRTOS port being used).\r
* }\r
* }\r
+ * @endverbatim\r
*/\r
#define xTimerResetFromISR( xTimer, pxHigherPriorityTaskWoken ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_START, ( xTaskGetTickCountFromISR() ), ( pxHigherPriorityTaskWoken ), 0U )\r
\r
+\r
+/**\r
+ * BaseType_t xTimerPendCallbackFromISR( pdAPPLICATION_CALLBACK_CODE pvCallbackFunction,\r
+ * void *pvParameter1,\r
+ * uint32_t ulParameter2,\r
+ * BaseType_t *pxHigherPriorityTaskWoken );\r
+ *\r
+ *\r
+ * Can be used by interrupt service routines to request that a function (the\r
+ * callback function) is executed from a task context.\r
+ *\r
+ * Ideally an interrupt service routine (ISR) is kept as short as possible, but\r
+ * sometimes an ISR either has a lot of processing to do, or needs to perform\r
+ * processing that is not deterministic. In these cases the processing can be\r
+ * deferred to be performed in a task - allowing the ISR to exit. The timer\r
+ * daemon service/daemon task is already responsible for executing software\r
+ * timer callback functions, so is also used to executed callback functions that\r
+ * are pended from interrupts.\r
+ *\r
+ * A mechanism is provided that allows the interrupt to return directly to the\r
+ * task that will subsequently execute the pended callback function. This\r
+ * allows the callback function to execute contiguously in time with the\r
+ * interrupt - just as if the callback had executed in the interrupt itself.\r
+ *\r
+ * @param pvCallbackFunction The function to execute from the timer service/\r
+ * daemon task. The function must conform to the pdAPPLICATION_CALLBACK_CODE\r
+ * prototype.\r
+ *\r
+ * @param pvParameter1 The value of the callback function's first parameter.\r
+ * The parameter has a void * type to allow it to be used to pass any type.\r
+ * For example, unsigned longs can be cast to a void *, or the void * can be\r
+ * used to point to a structure.\r
+ *\r
+ * @param ulParameter2 The value of the callback function's second parameter.\r
+ *\r
+ * @param pxHigherPriorityTaskWoken As mentioned above, calling this function\r
+ * will result in a message being sent to the timer daemon task. If the\r
+ * priority of the timer daemon task (which is set using\r
+ * configTIMER_TASK_PRIORITY in FreeRTOSConfig.h) is higher than the priority of\r
+ * the currently running task (the task the interrupt interrupted) then\r
+ * *pxHigherPriorityTaskWoken will be set to pdTRUE within\r
+ * xTimerPendCallbackFromISR(), indicating that a context switch should be\r
+ * requested before the interrupt exits. For that reason\r
+ * *pxHigherPriorityTaskWoken must be initialised to pdFALSE. See the\r
+ * example code below.\r
+ *\r
+ * @return pdPASS is returned if the message was successfully sent to the\r
+ * timer daemon task, otherwise pdFALSE is returned.\r
+ *\r
+ * Example usage:\r
+ * @verbatim\r
+ *\r
+ * // The callback function that will execute in the context of the daemon task.\r
+ * // Note callback functions must all use this same prototype.\r
+ * void vProcessInterface( void *pvParameter1, uint32_t ulParameter2 )\r
+ * {\r
+ * BaseType_t xInterfaceToService;\r
+ *\r
+ * // The interface that requires servicing is passed in the second\r
+ * // parameter. The first parameter is not used in this case.\r
+ * xInterfaceToService = ( BaseType_t ) ulParameter2;\r
+ *\r
+ * // ...Perform the processing here...\r
+ * }\r
+ *\r
+ * // An ISR that receives data packets from multiple interfaces\r
+ * void vAnISR( void )\r
+ * {\r
+ * BaseType_t xInterfaceToService, xHigherPriorityTaskWoken;\r
+ *\r
+ * // Query the hardware to determine which interface needs processing.\r
+ * xInterfaceToService = prvCheckInterfaces();\r
+ *\r
+ * // The actual processing is to be deferred to a task. Request the\r
+ * // vProcessInterface() callback function is executed, passing in the\r
+ * // number of the interface that needs processing. The interface to\r
+ * // service is passed in the second parameter. The first parameter is\r
+ * // not used in this case.\r
+ * xHigherPriorityTaskWoken = pdFALSE;\r
+ * xTimerPendCallbackFromISR( vProcessInterface, NULL, ( uint32_t ) xInterfaceToService, &xHigherPriorityTaskWoken );\r
+ *\r
+ * // If xHigherPriorityTaskWoken is now set to pdTRUE then a context\r
+ * // switch should be requested. The macro used is port specific and will\r
+ * // be either portYIELD_FROM_ISR() or portEND_SWITCHING_ISR() - refer to\r
+ * // the documentation page for the port being used.\r
+ * portYIELD_FROM_ISR( xHigherPriorityTaskWoken );\r
+ *\r
+ * }\r
+ * @endverbatim\r
+ */\r
+BaseType_t xTimerPendCallbackFromISR( pdAPPLICATION_CALLBACK_CODE pvCallbackFunction, void *pvParameter1, uint32_t ulParameter2, BaseType_t *pxHigherPriorityTaskWoken );\r
+\r
/*\r
* Functions beyond this part are not part of the public API and are intended\r
* for use by the kernel only.\r
*/\r
-portBASE_TYPE xTimerCreateTimerTask( void ) PRIVILEGED_FUNCTION;\r
-portBASE_TYPE xTimerGenericCommand( xTimerHandle xTimer, portBASE_TYPE xCommandID, portTickType xOptionalValue, signed portBASE_TYPE *pxHigherPriorityTaskWoken, portTickType xBlockTime ) PRIVILEGED_FUNCTION;\r
+BaseType_t xTimerCreateTimerTask( void ) PRIVILEGED_FUNCTION;\r
+BaseType_t xTimerGenericCommand( TimerHandle_t xTimer, const BaseType_t xCommandID, const TickType_t xOptionalValue, BaseType_t * const pxHigherPriorityTaskWoken, const TickType_t xBlockTime ) PRIVILEGED_FUNCTION;\r
\r
#ifdef __cplusplus\r
}\r
projects / freertos / blobdiff