begriffs open source - freertos/blob - timers.c

   1 /*\r
   2  * FreeRTOS Kernel V10.5.1\r
   3  * Copyright (C) 2021 Amazon.com, Inc. or its affiliates.  All Rights Reserved.\r
   4  *\r
   5  * SPDX-License-Identifier: MIT\r
   6  *\r
   7  * Permission is hereby granted, free of charge, to any person obtaining a copy of\r
   8  * this software and associated documentation files (the "Software"), to deal in\r
   9  * the Software without restriction, including without limitation the rights to\r
  10  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r
  11  * the Software, and to permit persons to whom the Software is furnished to do so,\r
  12  * subject to the following conditions:\r
  13  *\r
  14  * The above copyright notice and this permission notice shall be included in all\r
  15  * copies or substantial portions of the Software.\r
  16  *\r
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\r
  19  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\r
  20  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
  21  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
  22  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
  23  *\r
  24  * https://www.FreeRTOS.org\r
  25  * https://github.com/FreeRTOS\r
  26  *\r
  27  */\r
  28 \r
  29 /* Standard includes. */\r
  30 #include <stdlib.h>\r
  31 \r
  32 /* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining\r
  33  * all the API functions to use the MPU wrappers.  That should only be done when\r
  34  * task.h is included from an application file. */\r
  35 #define MPU_WRAPPERS_INCLUDED_FROM_API_FILE\r
  36 \r
  37 #include "FreeRTOS.h"\r
  38 #include "task.h"\r
  39 #include "queue.h"\r
  40 #include "timers.h"\r
  41 \r
  42 #if ( INCLUDE_xTimerPendFunctionCall == 1 ) && ( configUSE_TIMERS == 0 )\r
  43     #error configUSE_TIMERS must be set to 1 to make the xTimerPendFunctionCall() function available.\r
  44 #endif\r
  45 \r
  46 /* Lint e9021, e961 and e750 are suppressed as a MISRA exception justified\r
  47  * because the MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be defined\r
  48  * for the header files above, but not in this file, in order to generate the\r
  49  * correct privileged Vs unprivileged linkage and placement. */\r
  50 #undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE /*lint !e9021 !e961 !e750. */\r
  51 \r
  52 \r
  53 /* This entire source file will be skipped if the application is not configured\r
  54  * to include software timer functionality.  This #if is closed at the very bottom\r
  55  * of this file.  If you want to include software timer functionality then ensure\r
  56  * configUSE_TIMERS is set to 1 in FreeRTOSConfig.h. */\r
  57 #if ( configUSE_TIMERS == 1 )\r
  58 \r
  59 /* Misc definitions. */\r
  60     #define tmrNO_DELAY                    ( ( TickType_t ) 0U )\r
  61     #define tmrMAX_TIME_BEFORE_OVERFLOW    ( ( TickType_t ) -1 )\r
  62 \r
  63 /* The name assigned to the timer service task.  This can be overridden by\r
  64  * defining trmTIMER_SERVICE_TASK_NAME in FreeRTOSConfig.h. */\r
  65     #ifndef configTIMER_SERVICE_TASK_NAME\r
  66         #define configTIMER_SERVICE_TASK_NAME    "Tmr Svc"\r
  67     #endif\r
  68 \r
  69 /* Bit definitions used in the ucStatus member of a timer structure. */\r
  70     #define tmrSTATUS_IS_ACTIVE                  ( ( uint8_t ) 0x01 )\r
  71     #define tmrSTATUS_IS_STATICALLY_ALLOCATED    ( ( uint8_t ) 0x02 )\r
  72     #define tmrSTATUS_IS_AUTORELOAD              ( ( uint8_t ) 0x04 )\r
  73 \r
  74 /* The definition of the timers themselves. */\r
  75     typedef struct tmrTimerControl                  /* The old naming convention is used to prevent breaking kernel aware debuggers. */\r
  76     {\r
  77         const char * pcTimerName;                   /*<< Text name.  This is not used by the kernel, it is included simply to make debugging easier. */ /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
  78         ListItem_t xTimerListItem;                  /*<< Standard linked list item as used by all kernel features for event management. */\r
  79         TickType_t xTimerPeriodInTicks;             /*<< How quickly and often the timer expires. */\r
  80         void * pvTimerID;                           /*<< An ID to identify the timer.  This allows the timer to be identified when the same callback is used for multiple timers. */\r
  81         TimerCallbackFunction_t pxCallbackFunction; /*<< The function that will be called when the timer expires. */\r
  82         #if ( configUSE_TRACE_FACILITY == 1 )\r
  83             UBaseType_t uxTimerNumber;              /*<< An ID assigned by trace tools such as FreeRTOS+Trace */\r
  84         #endif\r
  85         uint8_t ucStatus;                           /*<< Holds bits to say if the timer was statically allocated or not, and if it is active or not. */\r
  86     } xTIMER;\r
  87 \r
  88 /* The old xTIMER name is maintained above then typedefed to the new Timer_t\r
  89  * name below to enable the use of older kernel aware debuggers. */\r
  90     typedef xTIMER Timer_t;\r
  91 \r
  92 /* The definition of messages that can be sent and received on the timer queue.\r
  93  * Two types of message can be queued - messages that manipulate a software timer,\r
  94  * and messages that request the execution of a non-timer related callback.  The\r
  95  * two message types are defined in two separate structures, xTimerParametersType\r
  96  * and xCallbackParametersType respectively. */\r
  97     typedef struct tmrTimerParameters\r
  98     {\r
  99         TickType_t xMessageValue; /*<< An optional value used by a subset of commands, for example, when changing the period of a timer. */\r
 100         Timer_t * pxTimer;        /*<< The timer to which the command will be applied. */\r
 101     } TimerParameter_t;\r
 102 \r
 103 \r
 104     typedef struct tmrCallbackParameters\r
 105     {\r
 106         PendedFunction_t pxCallbackFunction; /* << The callback function to execute. */\r
 107         void * pvParameter1;                 /* << The value that will be used as the callback functions first parameter. */\r
 108         uint32_t ulParameter2;               /* << The value that will be used as the callback functions second parameter. */\r
 109     } CallbackParameters_t;\r
 110 \r
 111 /* The structure that contains the two message types, along with an identifier\r
 112  * that is used to determine which message type is valid. */\r
 113     typedef struct tmrTimerQueueMessage\r
 114     {\r
 115         BaseType_t xMessageID; /*<< The command being sent to the timer service task. */\r
 116         union\r
 117         {\r
 118             TimerParameter_t xTimerParameters;\r
 119 \r
 120             /* Don't include xCallbackParameters if it is not going to be used as\r
 121              * it makes the structure (and therefore the timer queue) larger. */\r
 122             #if ( INCLUDE_xTimerPendFunctionCall == 1 )\r
 123                 CallbackParameters_t xCallbackParameters;\r
 124             #endif /* INCLUDE_xTimerPendFunctionCall */\r
 125         } u;\r
 126     } DaemonTaskMessage_t;\r
 127 \r
 128 /*lint -save -e956 A manual analysis and inspection has been used to determine\r
 129  * which static variables must be declared volatile. */\r
 130 \r
 131 /* The list in which active timers are stored.  Timers are referenced in expire\r
 132  * time order, with the nearest expiry time at the front of the list.  Only the\r
 133  * timer service task is allowed to access these lists.\r
 134  * xActiveTimerList1 and xActiveTimerList2 could be at function scope but that\r
 135  * breaks some kernel aware debuggers, and debuggers that reply on removing the\r
 136  * static qualifier. */\r
 137     PRIVILEGED_DATA static List_t xActiveTimerList1;\r
 138     PRIVILEGED_DATA static List_t xActiveTimerList2;\r
 139     PRIVILEGED_DATA static List_t * pxCurrentTimerList;\r
 140     PRIVILEGED_DATA static List_t * pxOverflowTimerList;\r
 141 \r
 142 /* A queue that is used to send commands to the timer service task. */\r
 143     PRIVILEGED_DATA static QueueHandle_t xTimerQueue = NULL;\r
 144     PRIVILEGED_DATA static TaskHandle_t xTimerTaskHandle = NULL;\r
 145 \r
 146 /*lint -restore */\r
 147 \r
 148 /*-----------------------------------------------------------*/\r
 149 \r
 150 /*\r
 151  * Initialise the infrastructure used by the timer service task if it has not\r
 152  * been initialised already.\r
 153  */\r
 154     static void prvCheckForValidListAndQueue( void ) PRIVILEGED_FUNCTION;\r
 155 \r
 156 /*\r
 157  * The timer service task (daemon).  Timer functionality is controlled by this\r
 158  * task.  Other tasks communicate with the timer service task using the\r
 159  * xTimerQueue queue.\r
 160  */\r
 161     static portTASK_FUNCTION_PROTO( prvTimerTask, pvParameters ) PRIVILEGED_FUNCTION;\r
 162 \r
 163 /*\r
 164  * Called by the timer service task to interpret and process a command it\r
 165  * received on the timer queue.\r
 166  */\r
 167     static void prvProcessReceivedCommands( void ) PRIVILEGED_FUNCTION;\r
 168 \r
 169 /*\r
 170  * Insert the timer into either xActiveTimerList1, or xActiveTimerList2,\r
 171  * depending on if the expire time causes a timer counter overflow.\r
 172  */\r
 173     static BaseType_t prvInsertTimerInActiveList( Timer_t * const pxTimer,\r
 174                                                   const TickType_t xNextExpiryTime,\r
 175                                                   const TickType_t xTimeNow,\r
 176                                                   const TickType_t xCommandTime ) PRIVILEGED_FUNCTION;\r
 177 \r
 178 /*\r
 179  * Reload the specified auto-reload timer.  If the reloading is backlogged,\r
 180  * clear the backlog, calling the callback for each additional reload.  When\r
 181  * this function returns, the next expiry time is after xTimeNow.\r
 182  */\r
 183     static void prvReloadTimer( Timer_t * const pxTimer,\r
 184                                 TickType_t xExpiredTime,\r
 185                                 const TickType_t xTimeNow ) PRIVILEGED_FUNCTION;\r
 186 \r
 187 /*\r
 188  * An active timer has reached its expire time.  Reload the timer if it is an\r
 189  * auto-reload timer, then call its callback.\r
 190  */\r
 191     static void prvProcessExpiredTimer( const TickType_t xNextExpireTime,\r
 192                                         const TickType_t xTimeNow ) PRIVILEGED_FUNCTION;\r
 193 \r
 194 /*\r
 195  * The tick count has overflowed.  Switch the timer lists after ensuring the\r
 196  * current timer list does not still reference some timers.\r
 197  */\r
 198     static void prvSwitchTimerLists( void ) PRIVILEGED_FUNCTION;\r
 199 \r
 200 /*\r
 201  * Obtain the current tick count, setting *pxTimerListsWereSwitched to pdTRUE\r
 202  * if a tick count overflow occurred since prvSampleTimeNow() was last called.\r
 203  */\r
 204     static TickType_t prvSampleTimeNow( BaseType_t * const pxTimerListsWereSwitched ) PRIVILEGED_FUNCTION;\r
 205 \r
 206 /*\r
 207  * If the timer list contains any active timers then return the expire time of\r
 208  * the timer that will expire first and set *pxListWasEmpty to false.  If the\r
 209  * timer list does not contain any timers then return 0 and set *pxListWasEmpty\r
 210  * to pdTRUE.\r
 211  */\r
 212     static TickType_t prvGetNextExpireTime( BaseType_t * const pxListWasEmpty ) PRIVILEGED_FUNCTION;\r
 213 \r
 214 /*\r
 215  * If a timer has expired, process it.  Otherwise, block the timer service task\r
 216  * until either a timer does expire or a command is received.\r
 217  */\r
 218     static void prvProcessTimerOrBlockTask( const TickType_t xNextExpireTime,\r
 219                                             BaseType_t xListWasEmpty ) PRIVILEGED_FUNCTION;\r
 220 \r
 221 /*\r
 222  * Called after a Timer_t structure has been allocated either statically or\r
 223  * dynamically to fill in the structure's members.\r
 224  */\r
 225     static void prvInitialiseNewTimer( const char * const pcTimerName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
 226                                        const TickType_t xTimerPeriodInTicks,\r
 227                                        const BaseType_t xAutoReload,\r
 228                                        void * const pvTimerID,\r
 229                                        TimerCallbackFunction_t pxCallbackFunction,\r
 230                                        Timer_t * pxNewTimer ) PRIVILEGED_FUNCTION;\r
 231 /*-----------------------------------------------------------*/\r
 232 \r
 233     BaseType_t xTimerCreateTimerTask( void )\r
 234     {\r
 235         BaseType_t xReturn = pdFAIL;\r
 236 \r
 237         /* This function is called when the scheduler is started if\r
 238          * configUSE_TIMERS is set to 1.  Check that the infrastructure used by the\r
 239          * timer service task has been created/initialised.  If timers have already\r
 240          * been created then the initialisation will already have been performed. */\r
 241         prvCheckForValidListAndQueue();\r
 242 \r
 243         if( xTimerQueue != NULL )\r
 244         {\r
 245             #if ( configSUPPORT_STATIC_ALLOCATION == 1 )\r
 246             {\r
 247                 StaticTask_t * pxTimerTaskTCBBuffer = NULL;\r
 248                 StackType_t * pxTimerTaskStackBuffer = NULL;\r
 249                 uint32_t ulTimerTaskStackSize;\r
 250 \r
 251                 vApplicationGetTimerTaskMemory( &pxTimerTaskTCBBuffer, &pxTimerTaskStackBuffer, &ulTimerTaskStackSize );\r
 252                 xTimerTaskHandle = xTaskCreateStatic( prvTimerTask,\r
 253                                                       configTIMER_SERVICE_TASK_NAME,\r
 254                                                       ulTimerTaskStackSize,\r
 255                                                       NULL,\r
 256                                                       ( ( UBaseType_t ) configTIMER_TASK_PRIORITY ) | portPRIVILEGE_BIT,\r
 257                                                       pxTimerTaskStackBuffer,\r
 258                                                       pxTimerTaskTCBBuffer );\r
 259 \r
 260                 if( xTimerTaskHandle != NULL )\r
 261                 {\r
 262                     xReturn = pdPASS;\r
 263                 }\r
 264             }\r
 265             #else /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */\r
 266             {\r
 267                 xReturn = xTaskCreate( prvTimerTask,\r
 268                                        configTIMER_SERVICE_TASK_NAME,\r
 269                                        configTIMER_TASK_STACK_DEPTH,\r
 270                                        NULL,\r
 271                                        ( ( UBaseType_t ) configTIMER_TASK_PRIORITY ) | portPRIVILEGE_BIT,\r
 272                                        &xTimerTaskHandle );\r
 273             }\r
 274             #endif /* configSUPPORT_STATIC_ALLOCATION */\r
 275         }\r
 276         else\r
 277         {\r
 278             mtCOVERAGE_TEST_MARKER();\r
 279         }\r
 280 \r
 281         configASSERT( xReturn );\r
 282         return xReturn;\r
 283     }\r
 284 /*-----------------------------------------------------------*/\r
 285 \r
 286     #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 287 \r
 288         TimerHandle_t xTimerCreate( const char * const pcTimerName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
 289                                     const TickType_t xTimerPeriodInTicks,\r
 290                                     const BaseType_t xAutoReload,\r
 291                                     void * const pvTimerID,\r
 292                                     TimerCallbackFunction_t pxCallbackFunction )\r
 293         {\r
 294             Timer_t * pxNewTimer;\r
 295 \r
 296             pxNewTimer = ( Timer_t * ) pvPortMalloc( sizeof( Timer_t ) ); /*lint !e9087 !e9079 All values returned by pvPortMalloc() have at least the alignment required by the MCU's stack, and the first member of Timer_t is always a pointer to the timer's mame. */\r
 297 \r
 298             if( pxNewTimer != NULL )\r
 299             {\r
 300                 /* Status is thus far zero as the timer is not created statically\r
 301                  * and has not been started.  The auto-reload bit may get set in\r
 302                  * prvInitialiseNewTimer. */\r
 303                 pxNewTimer->ucStatus = 0x00;\r
 304                 prvInitialiseNewTimer( pcTimerName, xTimerPeriodInTicks, xAutoReload, pvTimerID, pxCallbackFunction, pxNewTimer );\r
 305             }\r
 306 \r
 307             return pxNewTimer;\r
 308         }\r
 309 \r
 310     #endif /* configSUPPORT_DYNAMIC_ALLOCATION */\r
 311 /*-----------------------------------------------------------*/\r
 312 \r
 313     #if ( configSUPPORT_STATIC_ALLOCATION == 1 )\r
 314 \r
 315         TimerHandle_t xTimerCreateStatic( const char * const pcTimerName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
 316                                           const TickType_t xTimerPeriodInTicks,\r
 317                                           const BaseType_t xAutoReload,\r
 318                                           void * const pvTimerID,\r
 319                                           TimerCallbackFunction_t pxCallbackFunction,\r
 320                                           StaticTimer_t * pxTimerBuffer )\r
 321         {\r
 322             Timer_t * pxNewTimer;\r
 323 \r
 324             #if ( configASSERT_DEFINED == 1 )\r
 325             {\r
 326                 /* Sanity check that the size of the structure used to declare a\r
 327                  * variable of type StaticTimer_t equals the size of the real timer\r
 328                  * structure. */\r
 329                 volatile size_t xSize = sizeof( StaticTimer_t );\r
 330                 configASSERT( xSize == sizeof( Timer_t ) );\r
 331                 ( void ) xSize; /* Keeps lint quiet when configASSERT() is not defined. */\r
 332             }\r
 333             #endif /* configASSERT_DEFINED */\r
 334 \r
 335             /* A pointer to a StaticTimer_t structure MUST be provided, use it. */\r
 336             configASSERT( pxTimerBuffer );\r
 337             pxNewTimer = ( Timer_t * ) pxTimerBuffer; /*lint !e740 !e9087 StaticTimer_t is a pointer to a Timer_t, so guaranteed to be aligned and sized correctly (checked by an assert()), so this is safe. */\r
 338 \r
 339             if( pxNewTimer != NULL )\r
 340             {\r
 341                 /* Timers can be created statically or dynamically so note this\r
 342                  * timer was created statically in case it is later deleted.  The\r
 343                  * auto-reload bit may get set in prvInitialiseNewTimer(). */\r
 344                 pxNewTimer->ucStatus = tmrSTATUS_IS_STATICALLY_ALLOCATED;\r
 345 \r
 346                 prvInitialiseNewTimer( pcTimerName, xTimerPeriodInTicks, xAutoReload, pvTimerID, pxCallbackFunction, pxNewTimer );\r
 347             }\r
 348 \r
 349             return pxNewTimer;\r
 350         }\r
 351 \r
 352     #endif /* configSUPPORT_STATIC_ALLOCATION */\r
 353 /*-----------------------------------------------------------*/\r
 354 \r
 355     static void prvInitialiseNewTimer( const char * const pcTimerName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
 356                                        const TickType_t xTimerPeriodInTicks,\r
 357                                        const BaseType_t xAutoReload,\r
 358                                        void * const pvTimerID,\r
 359                                        TimerCallbackFunction_t pxCallbackFunction,\r
 360                                        Timer_t * pxNewTimer )\r
 361     {\r
 362         /* 0 is not a valid value for xTimerPeriodInTicks. */\r
 363         configASSERT( ( xTimerPeriodInTicks > 0 ) );\r
 364 \r
 365         /* Ensure the infrastructure used by the timer service task has been\r
 366          * created/initialised. */\r
 367         prvCheckForValidListAndQueue();\r
 368 \r
 369         /* Initialise the timer structure members using the function\r
 370          * parameters. */\r
 371         pxNewTimer->pcTimerName = pcTimerName;\r
 372         pxNewTimer->xTimerPeriodInTicks = xTimerPeriodInTicks;\r
 373         pxNewTimer->pvTimerID = pvTimerID;\r
 374         pxNewTimer->pxCallbackFunction = pxCallbackFunction;\r
 375         vListInitialiseItem( &( pxNewTimer->xTimerListItem ) );\r
 376 \r
 377         if( xAutoReload != pdFALSE )\r
 378         {\r
 379             pxNewTimer->ucStatus |= tmrSTATUS_IS_AUTORELOAD;\r
 380         }\r
 381 \r
 382         traceTIMER_CREATE( pxNewTimer );\r
 383     }\r
 384 /*-----------------------------------------------------------*/\r
 385 \r
 386     BaseType_t xTimerGenericCommand( TimerHandle_t xTimer,\r
 387                                      const BaseType_t xCommandID,\r
 388                                      const TickType_t xOptionalValue,\r
 389                                      BaseType_t * const pxHigherPriorityTaskWoken,\r
 390                                      const TickType_t xTicksToWait )\r
 391     {\r
 392         BaseType_t xReturn = pdFAIL;\r
 393         DaemonTaskMessage_t xMessage;\r
 394 \r
 395         configASSERT( xTimer );\r
 396 \r
 397         /* Send a message to the timer service task to perform a particular action\r
 398          * on a particular timer definition. */\r
 399         if( xTimerQueue != NULL )\r
 400         {\r
 401             /* Send a command to the timer service task to start the xTimer timer. */\r
 402             xMessage.xMessageID = xCommandID;\r
 403             xMessage.u.xTimerParameters.xMessageValue = xOptionalValue;\r
 404             xMessage.u.xTimerParameters.pxTimer = xTimer;\r
 405 \r
 406             if( xCommandID < tmrFIRST_FROM_ISR_COMMAND )\r
 407             {\r
 408                 if( xTaskGetSchedulerState() == taskSCHEDULER_RUNNING )\r
 409                 {\r
 410                     xReturn = xQueueSendToBack( xTimerQueue, &xMessage, xTicksToWait );\r
 411                 }\r
 412                 else\r
 413                 {\r
 414                     xReturn = xQueueSendToBack( xTimerQueue, &xMessage, tmrNO_DELAY );\r
 415                 }\r
 416             }\r
 417             else\r
 418             {\r
 419                 xReturn = xQueueSendToBackFromISR( xTimerQueue, &xMessage, pxHigherPriorityTaskWoken );\r
 420             }\r
 421 \r
 422             traceTIMER_COMMAND_SEND( xTimer, xCommandID, xOptionalValue, xReturn );\r
 423         }\r
 424         else\r
 425         {\r
 426             mtCOVERAGE_TEST_MARKER();\r
 427         }\r
 428 \r
 429         return xReturn;\r
 430     }\r
 431 /*-----------------------------------------------------------*/\r
 432 \r
 433     TaskHandle_t xTimerGetTimerDaemonTaskHandle( void )\r
 434     {\r
 435         /* If xTimerGetTimerDaemonTaskHandle() is called before the scheduler has been\r
 436          * started, then xTimerTaskHandle will be NULL. */\r
 437         configASSERT( ( xTimerTaskHandle != NULL ) );\r
 438         return xTimerTaskHandle;\r
 439     }\r
 440 /*-----------------------------------------------------------*/\r
 441 \r
 442     TickType_t xTimerGetPeriod( TimerHandle_t xTimer )\r
 443     {\r
 444         Timer_t * pxTimer = xTimer;\r
 445 \r
 446         configASSERT( xTimer );\r
 447         return pxTimer->xTimerPeriodInTicks;\r
 448     }\r
 449 /*-----------------------------------------------------------*/\r
 450 \r
 451     void vTimerSetReloadMode( TimerHandle_t xTimer,\r
 452                               const BaseType_t xAutoReload )\r
 453     {\r
 454         Timer_t * pxTimer = xTimer;\r
 455 \r
 456         configASSERT( xTimer );\r
 457         taskENTER_CRITICAL();\r
 458         {\r
 459             if( xAutoReload != pdFALSE )\r
 460             {\r
 461                 pxTimer->ucStatus |= tmrSTATUS_IS_AUTORELOAD;\r
 462             }\r
 463             else\r
 464             {\r
 465                 pxTimer->ucStatus &= ( ( uint8_t ) ~tmrSTATUS_IS_AUTORELOAD );\r
 466             }\r
 467         }\r
 468         taskEXIT_CRITICAL();\r
 469     }\r
 470 /*-----------------------------------------------------------*/\r
 471 \r
 472     BaseType_t xTimerGetReloadMode( TimerHandle_t xTimer )\r
 473     {\r
 474         Timer_t * pxTimer = xTimer;\r
 475         BaseType_t xReturn;\r
 476 \r
 477         configASSERT( xTimer );\r
 478         taskENTER_CRITICAL();\r
 479         {\r
 480             if( ( pxTimer->ucStatus & tmrSTATUS_IS_AUTORELOAD ) == 0 )\r
 481             {\r
 482                 /* Not an auto-reload timer. */\r
 483                 xReturn = pdFALSE;\r
 484             }\r
 485             else\r
 486             {\r
 487                 /* Is an auto-reload timer. */\r
 488                 xReturn = pdTRUE;\r
 489             }\r
 490         }\r
 491         taskEXIT_CRITICAL();\r
 492 \r
 493         return xReturn;\r
 494     }\r
 495 \r
 496     UBaseType_t uxTimerGetReloadMode( TimerHandle_t xTimer )\r
 497     {\r
 498         return ( UBaseType_t ) xTimerGetReloadMode( xTimer );\r
 499     }\r
 500 /*-----------------------------------------------------------*/\r
 501 \r
 502     TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer )\r
 503     {\r
 504         Timer_t * pxTimer = xTimer;\r
 505         TickType_t xReturn;\r
 506 \r
 507         configASSERT( xTimer );\r
 508         xReturn = listGET_LIST_ITEM_VALUE( &( pxTimer->xTimerListItem ) );\r
 509         return xReturn;\r
 510     }\r
 511 /*-----------------------------------------------------------*/\r
 512 \r
 513     const char * pcTimerGetName( TimerHandle_t xTimer ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */\r
 514     {\r
 515         Timer_t * pxTimer = xTimer;\r
 516 \r
 517         configASSERT( xTimer );\r
 518         return pxTimer->pcTimerName;\r
 519     }\r
 520 /*-----------------------------------------------------------*/\r
 521 \r
 522     static void prvReloadTimer( Timer_t * const pxTimer,\r
 523                                 TickType_t xExpiredTime,\r
 524                                 const TickType_t xTimeNow )\r
 525     {\r
 526         /* Insert the timer into the appropriate list for the next expiry time.\r
 527          * If the next expiry time has already passed, advance the expiry time,\r
 528          * call the callback function, and try again. */\r
 529         while( prvInsertTimerInActiveList( pxTimer, ( xExpiredTime + pxTimer->xTimerPeriodInTicks ), xTimeNow, xExpiredTime ) != pdFALSE )\r
 530         {\r
 531             /* Advance the expiry time. */\r
 532             xExpiredTime += pxTimer->xTimerPeriodInTicks;\r
 533 \r
 534             /* Call the timer callback. */\r
 535             traceTIMER_EXPIRED( pxTimer );\r
 536             pxTimer->pxCallbackFunction( ( TimerHandle_t ) pxTimer );\r
 537         }\r
 538     }\r
 539 /*-----------------------------------------------------------*/\r
 540 \r
 541     static void prvProcessExpiredTimer( const TickType_t xNextExpireTime,\r
 542                                         const TickType_t xTimeNow )\r
 543     {\r
 544         Timer_t * const pxTimer = ( Timer_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxCurrentTimerList ); /*lint !e9087 !e9079 void * is used as this macro is used with tasks and co-routines too.  Alignment is known to be fine as the type of the pointer stored and retrieved is the same. */\r
 545 \r
 546         /* Remove the timer from the list of active timers.  A check has already\r
 547          * been performed to ensure the list is not empty. */\r
 548 \r
 549         ( void ) uxListRemove( &( pxTimer->xTimerListItem ) );\r
 550 \r
 551         /* If the timer is an auto-reload timer then calculate the next\r
 552          * expiry time and re-insert the timer in the list of active timers. */\r
 553         if( ( pxTimer->ucStatus & tmrSTATUS_IS_AUTORELOAD ) != 0 )\r
 554         {\r
 555             prvReloadTimer( pxTimer, xNextExpireTime, xTimeNow );\r
 556         }\r
 557         else\r
 558         {\r
 559             pxTimer->ucStatus &= ( ( uint8_t ) ~tmrSTATUS_IS_ACTIVE );\r
 560         }\r
 561 \r
 562         /* Call the timer callback. */\r
 563         traceTIMER_EXPIRED( pxTimer );\r
 564         pxTimer->pxCallbackFunction( ( TimerHandle_t ) pxTimer );\r
 565     }\r
 566 /*-----------------------------------------------------------*/\r
 567 \r
 568     static portTASK_FUNCTION( prvTimerTask, pvParameters )\r
 569     {\r
 570         TickType_t xNextExpireTime;\r
 571         BaseType_t xListWasEmpty;\r
 572 \r
 573         /* Just to avoid compiler warnings. */\r
 574         ( void ) pvParameters;\r
 575 \r
 576         #if ( configUSE_DAEMON_TASK_STARTUP_HOOK == 1 )\r
 577         {\r
 578             extern void vApplicationDaemonTaskStartupHook( void );\r
 579 \r
 580             /* Allow the application writer to execute some code in the context of\r
 581              * this task at the point the task starts executing.  This is useful if the\r
 582              * application includes initialisation code that would benefit from\r
 583              * executing after the scheduler has been started. */\r
 584             vApplicationDaemonTaskStartupHook();\r
 585         }\r
 586         #endif /* configUSE_DAEMON_TASK_STARTUP_HOOK */\r
 587 \r
 588         for( ; ; )\r
 589         {\r
 590             /* Query the timers list to see if it contains any timers, and if so,\r
 591              * obtain the time at which the next timer will expire. */\r
 592             xNextExpireTime = prvGetNextExpireTime( &xListWasEmpty );\r
 593 \r
 594             /* If a timer has expired, process it.  Otherwise, block this task\r
 595              * until either a timer does expire, or a command is received. */\r
 596             prvProcessTimerOrBlockTask( xNextExpireTime, xListWasEmpty );\r
 597 \r
 598             /* Empty the command queue. */\r
 599             prvProcessReceivedCommands();\r
 600         }\r
 601     }\r
 602 /*-----------------------------------------------------------*/\r
 603 \r
 604     static void prvProcessTimerOrBlockTask( const TickType_t xNextExpireTime,\r
 605                                             BaseType_t xListWasEmpty )\r
 606     {\r
 607         TickType_t xTimeNow;\r
 608         BaseType_t xTimerListsWereSwitched;\r
 609 \r
 610         vTaskSuspendAll();\r
 611         {\r
 612             /* Obtain the time now to make an assessment as to whether the timer\r
 613              * has expired or not.  If obtaining the time causes the lists to switch\r
 614              * then don't process this timer as any timers that remained in the list\r
 615              * when the lists were switched will have been processed within the\r
 616              * prvSampleTimeNow() function. */\r
 617             xTimeNow = prvSampleTimeNow( &xTimerListsWereSwitched );\r
 618 \r
 619             if( xTimerListsWereSwitched == pdFALSE )\r
 620             {\r
 621                 /* The tick count has not overflowed, has the timer expired? */\r
 622                 if( ( xListWasEmpty == pdFALSE ) && ( xNextExpireTime <= xTimeNow ) )\r
 623                 {\r
 624                     ( void ) xTaskResumeAll();\r
 625                     prvProcessExpiredTimer( xNextExpireTime, xTimeNow );\r
 626                 }\r
 627                 else\r
 628                 {\r
 629                     /* The tick count has not overflowed, and the next expire\r
 630                      * time has not been reached yet.  This task should therefore\r
 631                      * block to wait for the next expire time or a command to be\r
 632                      * received - whichever comes first.  The following line cannot\r
 633                      * be reached unless xNextExpireTime > xTimeNow, except in the\r
 634                      * case when the current timer list is empty. */\r
 635                     if( xListWasEmpty != pdFALSE )\r
 636                     {\r
 637                         /* The current timer list is empty - is the overflow list\r
 638                          * also empty? */\r
 639                         xListWasEmpty = listLIST_IS_EMPTY( pxOverflowTimerList );\r
 640                     }\r
 641 \r
 642                     vQueueWaitForMessageRestricted( xTimerQueue, ( xNextExpireTime - xTimeNow ), xListWasEmpty );\r
 643 \r
 644                     if( xTaskResumeAll() == pdFALSE )\r
 645                     {\r
 646                         /* Yield to wait for either a command to arrive, or the\r
 647                          * block time to expire.  If a command arrived between the\r
 648                          * critical section being exited and this yield then the yield\r
 649                          * will not cause the task to block. */\r
 650                         portYIELD_WITHIN_API();\r
 651                     }\r
 652                     else\r
 653                     {\r
 654                         mtCOVERAGE_TEST_MARKER();\r
 655                     }\r
 656                 }\r
 657             }\r
 658             else\r
 659             {\r
 660                 ( void ) xTaskResumeAll();\r
 661             }\r
 662         }\r
 663     }\r
 664 /*-----------------------------------------------------------*/\r
 665 \r
 666     static TickType_t prvGetNextExpireTime( BaseType_t * const pxListWasEmpty )\r
 667     {\r
 668         TickType_t xNextExpireTime;\r
 669 \r
 670         /* Timers are listed in expiry time order, with the head of the list\r
 671          * referencing the task that will expire first.  Obtain the time at which\r
 672          * the timer with the nearest expiry time will expire.  If there are no\r
 673          * active timers then just set the next expire time to 0.  That will cause\r
 674          * this task to unblock when the tick count overflows, at which point the\r
 675          * timer lists will be switched and the next expiry time can be\r
 676          * re-assessed.  */\r
 677         *pxListWasEmpty = listLIST_IS_EMPTY( pxCurrentTimerList );\r
 678 \r
 679         if( *pxListWasEmpty == pdFALSE )\r
 680         {\r
 681             xNextExpireTime = listGET_ITEM_VALUE_OF_HEAD_ENTRY( pxCurrentTimerList );\r
 682         }\r
 683         else\r
 684         {\r
 685             /* Ensure the task unblocks when the tick count rolls over. */\r
 686             xNextExpireTime = ( TickType_t ) 0U;\r
 687         }\r
 688 \r
 689         return xNextExpireTime;\r
 690     }\r
 691 /*-----------------------------------------------------------*/\r
 692 \r
 693     static TickType_t prvSampleTimeNow( BaseType_t * const pxTimerListsWereSwitched )\r
 694     {\r
 695         TickType_t xTimeNow;\r
 696         PRIVILEGED_DATA static TickType_t xLastTime = ( TickType_t ) 0U; /*lint !e956 Variable is only accessible to one task. */\r
 697 \r
 698         xTimeNow = xTaskGetTickCount();\r
 699 \r
 700         if( xTimeNow < xLastTime )\r
 701         {\r
 702             prvSwitchTimerLists();\r
 703             *pxTimerListsWereSwitched = pdTRUE;\r
 704         }\r
 705         else\r
 706         {\r
 707             *pxTimerListsWereSwitched = pdFALSE;\r
 708         }\r
 709 \r
 710         xLastTime = xTimeNow;\r
 711 \r
 712         return xTimeNow;\r
 713     }\r
 714 /*-----------------------------------------------------------*/\r
 715 \r
 716     static BaseType_t prvInsertTimerInActiveList( Timer_t * const pxTimer,\r
 717                                                   const TickType_t xNextExpiryTime,\r
 718                                                   const TickType_t xTimeNow,\r
 719                                                   const TickType_t xCommandTime )\r
 720     {\r
 721         BaseType_t xProcessTimerNow = pdFALSE;\r
 722 \r
 723         listSET_LIST_ITEM_VALUE( &( pxTimer->xTimerListItem ), xNextExpiryTime );\r
 724         listSET_LIST_ITEM_OWNER( &( pxTimer->xTimerListItem ), pxTimer );\r
 725 \r
 726         if( xNextExpiryTime <= xTimeNow )\r
 727         {\r
 728             /* Has the expiry time elapsed between the command to start/reset a\r
 729              * timer was issued, and the time the command was processed? */\r
 730             if( ( ( TickType_t ) ( xTimeNow - xCommandTime ) ) >= pxTimer->xTimerPeriodInTicks ) /*lint !e961 MISRA exception as the casts are only redundant for some ports. */\r
 731             {\r
 732                 /* The time between a command being issued and the command being\r
 733                  * processed actually exceeds the timers period.  */\r
 734                 xProcessTimerNow = pdTRUE;\r
 735             }\r
 736             else\r
 737             {\r
 738                 vListInsert( pxOverflowTimerList, &( pxTimer->xTimerListItem ) );\r
 739             }\r
 740         }\r
 741         else\r
 742         {\r
 743             if( ( xTimeNow < xCommandTime ) && ( xNextExpiryTime >= xCommandTime ) )\r
 744             {\r
 745                 /* If, since the command was issued, the tick count has overflowed\r
 746                  * but the expiry time has not, then the timer must have already passed\r
 747                  * its expiry time and should be processed immediately. */\r
 748                 xProcessTimerNow = pdTRUE;\r
 749             }\r
 750             else\r
 751             {\r
 752                 vListInsert( pxCurrentTimerList, &( pxTimer->xTimerListItem ) );\r
 753             }\r
 754         }\r
 755 \r
 756         return xProcessTimerNow;\r
 757     }\r
 758 /*-----------------------------------------------------------*/\r
 759 \r
 760     static void prvProcessReceivedCommands( void )\r
 761     {\r
 762         DaemonTaskMessage_t xMessage;\r
 763         Timer_t * pxTimer;\r
 764         BaseType_t xTimerListsWereSwitched;\r
 765         TickType_t xTimeNow;\r
 766 \r
 767         while( xQueueReceive( xTimerQueue, &xMessage, tmrNO_DELAY ) != pdFAIL ) /*lint !e603 xMessage does not have to be initialised as it is passed out, not in, and it is not used unless xQueueReceive() returns pdTRUE. */\r
 768         {\r
 769             #if ( INCLUDE_xTimerPendFunctionCall == 1 )\r
 770             {\r
 771                 /* Negative commands are pended function calls rather than timer\r
 772                  * commands. */\r
 773                 if( xMessage.xMessageID < ( BaseType_t ) 0 )\r
 774                 {\r
 775                     const CallbackParameters_t * const pxCallback = &( xMessage.u.xCallbackParameters );\r
 776 \r
 777                     /* The timer uses the xCallbackParameters member to request a\r
 778                      * callback be executed.  Check the callback is not NULL. */\r
 779                     configASSERT( pxCallback );\r
 780 \r
 781                     /* Call the function. */\r
 782                     pxCallback->pxCallbackFunction( pxCallback->pvParameter1, pxCallback->ulParameter2 );\r
 783                 }\r
 784                 else\r
 785                 {\r
 786                     mtCOVERAGE_TEST_MARKER();\r
 787                 }\r
 788             }\r
 789             #endif /* INCLUDE_xTimerPendFunctionCall */\r
 790 \r
 791             /* Commands that are positive are timer commands rather than pended\r
 792              * function calls. */\r
 793             if( xMessage.xMessageID >= ( BaseType_t ) 0 )\r
 794             {\r
 795                 /* The messages uses the xTimerParameters member to work on a\r
 796                  * software timer. */\r
 797                 pxTimer = xMessage.u.xTimerParameters.pxTimer;\r
 798 \r
 799                 if( listIS_CONTAINED_WITHIN( NULL, &( pxTimer->xTimerListItem ) ) == pdFALSE ) /*lint !e961. The cast is only redundant when NULL is passed into the macro. */\r
 800                 {\r
 801                     /* The timer is in a list, remove it. */\r
 802                     ( void ) uxListRemove( &( pxTimer->xTimerListItem ) );\r
 803                 }\r
 804                 else\r
 805                 {\r
 806                     mtCOVERAGE_TEST_MARKER();\r
 807                 }\r
 808 \r
 809                 traceTIMER_COMMAND_RECEIVED( pxTimer, xMessage.xMessageID, xMessage.u.xTimerParameters.xMessageValue );\r
 810 \r
 811                 /* In this case the xTimerListsWereSwitched parameter is not used, but\r
 812                  *  it must be present in the function call.  prvSampleTimeNow() must be\r
 813                  *  called after the message is received from xTimerQueue so there is no\r
 814                  *  possibility of a higher priority task adding a message to the message\r
 815                  *  queue with a time that is ahead of the timer daemon task (because it\r
 816                  *  pre-empted the timer daemon task after the xTimeNow value was set). */\r
 817                 xTimeNow = prvSampleTimeNow( &xTimerListsWereSwitched );\r
 818 \r
 819                 switch( xMessage.xMessageID )\r
 820                 {\r
 821                     case tmrCOMMAND_START:\r
 822                     case tmrCOMMAND_START_FROM_ISR:\r
 823                     case tmrCOMMAND_RESET:\r
 824                     case tmrCOMMAND_RESET_FROM_ISR:\r
 825                         /* Start or restart a timer. */\r
 826                         pxTimer->ucStatus |= tmrSTATUS_IS_ACTIVE;\r
 827 \r
 828                         if( prvInsertTimerInActiveList( pxTimer, xMessage.u.xTimerParameters.xMessageValue + pxTimer->xTimerPeriodInTicks, xTimeNow, xMessage.u.xTimerParameters.xMessageValue ) != pdFALSE )\r
 829                         {\r
 830                             /* The timer expired before it was added to the active\r
 831                              * timer list.  Process it now. */\r
 832                             if( ( pxTimer->ucStatus & tmrSTATUS_IS_AUTORELOAD ) != 0 )\r
 833                             {\r
 834                                 prvReloadTimer( pxTimer, xMessage.u.xTimerParameters.xMessageValue + pxTimer->xTimerPeriodInTicks, xTimeNow );\r
 835                             }\r
 836                             else\r
 837                             {\r
 838                                 pxTimer->ucStatus &= ( ( uint8_t ) ~tmrSTATUS_IS_ACTIVE );\r
 839                             }\r
 840 \r
 841                             /* Call the timer callback. */\r
 842                             traceTIMER_EXPIRED( pxTimer );\r
 843                             pxTimer->pxCallbackFunction( ( TimerHandle_t ) pxTimer );\r
 844                         }\r
 845                         else\r
 846                         {\r
 847                             mtCOVERAGE_TEST_MARKER();\r
 848                         }\r
 849 \r
 850                         break;\r
 851 \r
 852                     case tmrCOMMAND_STOP:\r
 853                     case tmrCOMMAND_STOP_FROM_ISR:\r
 854                         /* The timer has already been removed from the active list. */\r
 855                         pxTimer->ucStatus &= ( ( uint8_t ) ~tmrSTATUS_IS_ACTIVE );\r
 856                         break;\r
 857 \r
 858                     case tmrCOMMAND_CHANGE_PERIOD:\r
 859                     case tmrCOMMAND_CHANGE_PERIOD_FROM_ISR:\r
 860                         pxTimer->ucStatus |= tmrSTATUS_IS_ACTIVE;\r
 861                         pxTimer->xTimerPeriodInTicks = xMessage.u.xTimerParameters.xMessageValue;\r
 862                         configASSERT( ( pxTimer->xTimerPeriodInTicks > 0 ) );\r
 863 \r
 864                         /* The new period does not really have a reference, and can\r
 865                          * be longer or shorter than the old one.  The command time is\r
 866                          * therefore set to the current time, and as the period cannot\r
 867                          * be zero the next expiry time can only be in the future,\r
 868                          * meaning (unlike for the xTimerStart() case above) there is\r
 869                          * no fail case that needs to be handled here. */\r
 870                         ( void ) prvInsertTimerInActiveList( pxTimer, ( xTimeNow + pxTimer->xTimerPeriodInTicks ), xTimeNow, xTimeNow );\r
 871                         break;\r
 872 \r
 873                     case tmrCOMMAND_DELETE:\r
 874                         #if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )\r
 875                         {\r
 876                             /* The timer has already been removed from the active list,\r
 877                              * just free up the memory if the memory was dynamically\r
 878                              * allocated. */\r
 879                             if( ( pxTimer->ucStatus & tmrSTATUS_IS_STATICALLY_ALLOCATED ) == ( uint8_t ) 0 )\r
 880                             {\r
 881                                 vPortFree( pxTimer );\r
 882                             }\r
 883                             else\r
 884                             {\r
 885                                 pxTimer->ucStatus &= ( ( uint8_t ) ~tmrSTATUS_IS_ACTIVE );\r
 886                             }\r
 887                         }\r
 888                         #else /* if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) */\r
 889                         {\r
 890                             /* If dynamic allocation is not enabled, the memory\r
 891                              * could not have been dynamically allocated. So there is\r
 892                              * no need to free the memory - just mark the timer as\r
 893                              * "not active". */\r
 894                             pxTimer->ucStatus &= ( ( uint8_t ) ~tmrSTATUS_IS_ACTIVE );\r
 895                         }\r
 896                         #endif /* configSUPPORT_DYNAMIC_ALLOCATION */\r
 897                         break;\r
 898 \r
 899                     default:\r
 900                         /* Don't expect to get here. */\r
 901                         break;\r
 902                 }\r
 903             }\r
 904         }\r
 905     }\r
 906 /*-----------------------------------------------------------*/\r
 907 \r
 908     static void prvSwitchTimerLists( void )\r
 909     {\r
 910         TickType_t xNextExpireTime;\r
 911         List_t * pxTemp;\r
 912 \r
 913         /* The tick count has overflowed.  The timer lists must be switched.\r
 914          * If there are any timers still referenced from the current timer list\r
 915          * then they must have expired and should be processed before the lists\r
 916          * are switched. */\r
 917         while( listLIST_IS_EMPTY( pxCurrentTimerList ) == pdFALSE )\r
 918         {\r
 919             xNextExpireTime = listGET_ITEM_VALUE_OF_HEAD_ENTRY( pxCurrentTimerList );\r
 920 \r
 921             /* Process the expired timer.  For auto-reload timers, be careful to\r
 922              * process only expirations that occur on the current list.  Further\r
 923              * expirations must wait until after the lists are switched. */\r
 924             prvProcessExpiredTimer( xNextExpireTime, tmrMAX_TIME_BEFORE_OVERFLOW );\r
 925         }\r
 926 \r
 927         pxTemp = pxCurrentTimerList;\r
 928         pxCurrentTimerList = pxOverflowTimerList;\r
 929         pxOverflowTimerList = pxTemp;\r
 930     }\r
 931 /*-----------------------------------------------------------*/\r
 932 \r
 933     static void prvCheckForValidListAndQueue( void )\r
 934     {\r
 935         /* Check that the list from which active timers are referenced, and the\r
 936          * queue used to communicate with the timer service, have been\r
 937          * initialised. */\r
 938         taskENTER_CRITICAL();\r
 939         {\r
 940             if( xTimerQueue == NULL )\r
 941             {\r
 942                 vListInitialise( &xActiveTimerList1 );\r
 943                 vListInitialise( &xActiveTimerList2 );\r
 944                 pxCurrentTimerList = &xActiveTimerList1;\r
 945                 pxOverflowTimerList = &xActiveTimerList2;\r
 946 \r
 947                 #if ( configSUPPORT_STATIC_ALLOCATION == 1 )\r
 948                 {\r
 949                     /* The timer queue is allocated statically in case\r
 950                      * configSUPPORT_DYNAMIC_ALLOCATION is 0. */\r
 951                     PRIVILEGED_DATA static StaticQueue_t xStaticTimerQueue;                                                                          /*lint !e956 Ok to declare in this manner to prevent additional conditional compilation guards in other locations. */\r
 952                     PRIVILEGED_DATA static uint8_t ucStaticTimerQueueStorage[ ( size_t ) configTIMER_QUEUE_LENGTH * sizeof( DaemonTaskMessage_t ) ]; /*lint !e956 Ok to declare in this manner to prevent additional conditional compilation guards in other locations. */\r
 953 \r
 954                     xTimerQueue = xQueueCreateStatic( ( UBaseType_t ) configTIMER_QUEUE_LENGTH, ( UBaseType_t ) sizeof( DaemonTaskMessage_t ), &( ucStaticTimerQueueStorage[ 0 ] ), &xStaticTimerQueue );\r
 955                 }\r
 956                 #else\r
 957                 {\r
 958                     xTimerQueue = xQueueCreate( ( UBaseType_t ) configTIMER_QUEUE_LENGTH, sizeof( DaemonTaskMessage_t ) );\r
 959                 }\r
 960                 #endif /* if ( configSUPPORT_STATIC_ALLOCATION == 1 ) */\r
 961 \r
 962                 #if ( configQUEUE_REGISTRY_SIZE > 0 )\r
 963                 {\r
 964                     if( xTimerQueue != NULL )\r
 965                     {\r
 966                         vQueueAddToRegistry( xTimerQueue, "TmrQ" );\r
 967                     }\r
 968                     else\r
 969                     {\r
 970                         mtCOVERAGE_TEST_MARKER();\r
 971                     }\r
 972                 }\r
 973                 #endif /* configQUEUE_REGISTRY_SIZE */\r
 974             }\r
 975             else\r
 976             {\r
 977                 mtCOVERAGE_TEST_MARKER();\r
 978             }\r
 979         }\r
 980         taskEXIT_CRITICAL();\r
 981     }\r
 982 /*-----------------------------------------------------------*/\r
 983 \r
 984     BaseType_t xTimerIsTimerActive( TimerHandle_t xTimer )\r
 985     {\r
 986         BaseType_t xReturn;\r
 987         Timer_t * pxTimer = xTimer;\r
 988 \r
 989         configASSERT( xTimer );\r
 990 \r
 991         /* Is the timer in the list of active timers? */\r
 992         taskENTER_CRITICAL();\r
 993         {\r
 994             if( ( pxTimer->ucStatus & tmrSTATUS_IS_ACTIVE ) == 0 )\r
 995             {\r
 996                 xReturn = pdFALSE;\r
 997             }\r
 998             else\r
 999             {\r
1000                 xReturn = pdTRUE;\r
1001             }\r
1002         }\r
1003         taskEXIT_CRITICAL();\r
1004 \r
1005         return xReturn;\r
1006     } /*lint !e818 Can't be pointer to const due to the typedef. */\r
1007 /*-----------------------------------------------------------*/\r
1008 \r
1009     void * pvTimerGetTimerID( const TimerHandle_t xTimer )\r
1010     {\r
1011         Timer_t * const pxTimer = xTimer;\r
1012         void * pvReturn;\r
1013 \r
1014         configASSERT( xTimer );\r
1015 \r
1016         taskENTER_CRITICAL();\r
1017         {\r
1018             pvReturn = pxTimer->pvTimerID;\r
1019         }\r
1020         taskEXIT_CRITICAL();\r
1021 \r
1022         return pvReturn;\r
1023     }\r
1024 /*-----------------------------------------------------------*/\r
1025 \r
1026     void vTimerSetTimerID( TimerHandle_t xTimer,\r
1027                            void * pvNewID )\r
1028     {\r
1029         Timer_t * const pxTimer = xTimer;\r
1030 \r
1031         configASSERT( xTimer );\r
1032 \r
1033         taskENTER_CRITICAL();\r
1034         {\r
1035             pxTimer->pvTimerID = pvNewID;\r
1036         }\r
1037         taskEXIT_CRITICAL();\r
1038     }\r
1039 /*-----------------------------------------------------------*/\r
1040 \r
1041     #if ( INCLUDE_xTimerPendFunctionCall == 1 )\r
1042 \r
1043         BaseType_t xTimerPendFunctionCallFromISR( PendedFunction_t xFunctionToPend,\r
1044                                                   void * pvParameter1,\r
1045                                                   uint32_t ulParameter2,\r
1046                                                   BaseType_t * pxHigherPriorityTaskWoken )\r
1047         {\r
1048             DaemonTaskMessage_t xMessage;\r
1049             BaseType_t xReturn;\r
1050 \r
1051             /* Complete the message with the function parameters and post it to the\r
1052              * daemon task. */\r
1053             xMessage.xMessageID = tmrCOMMAND_EXECUTE_CALLBACK_FROM_ISR;\r
1054             xMessage.u.xCallbackParameters.pxCallbackFunction = xFunctionToPend;\r
1055             xMessage.u.xCallbackParameters.pvParameter1 = pvParameter1;\r
1056             xMessage.u.xCallbackParameters.ulParameter2 = ulParameter2;\r
1057 \r
1058             xReturn = xQueueSendFromISR( xTimerQueue, &xMessage, pxHigherPriorityTaskWoken );\r
1059 \r
1060             tracePEND_FUNC_CALL_FROM_ISR( xFunctionToPend, pvParameter1, ulParameter2, xReturn );\r
1061 \r
1062             return xReturn;\r
1063         }\r
1064 \r
1065     #endif /* INCLUDE_xTimerPendFunctionCall */\r
1066 /*-----------------------------------------------------------*/\r
1067 \r
1068     #if ( INCLUDE_xTimerPendFunctionCall == 1 )\r
1069 \r
1070         BaseType_t xTimerPendFunctionCall( PendedFunction_t xFunctionToPend,\r
1071                                            void * pvParameter1,\r
1072                                            uint32_t ulParameter2,\r
1073                                            TickType_t xTicksToWait )\r
1074         {\r
1075             DaemonTaskMessage_t xMessage;\r
1076             BaseType_t xReturn;\r
1077 \r
1078             /* This function can only be called after a timer has been created or\r
1079              * after the scheduler has been started because, until then, the timer\r
1080              * queue does not exist. */\r
1081             configASSERT( xTimerQueue );\r
1082 \r
1083             /* Complete the message with the function parameters and post it to the\r
1084              * daemon task. */\r
1085             xMessage.xMessageID = tmrCOMMAND_EXECUTE_CALLBACK;\r
1086             xMessage.u.xCallbackParameters.pxCallbackFunction = xFunctionToPend;\r
1087             xMessage.u.xCallbackParameters.pvParameter1 = pvParameter1;\r
1088             xMessage.u.xCallbackParameters.ulParameter2 = ulParameter2;\r
1089 \r
1090             xReturn = xQueueSendToBack( xTimerQueue, &xMessage, xTicksToWait );\r
1091 \r
1092             tracePEND_FUNC_CALL( xFunctionToPend, pvParameter1, ulParameter2, xReturn );\r
1093 \r
1094             return xReturn;\r
1095         }\r
1096 \r
1097     #endif /* INCLUDE_xTimerPendFunctionCall */\r
1098 /*-----------------------------------------------------------*/\r
1099 \r
1100     #if ( configUSE_TRACE_FACILITY == 1 )\r
1101 \r
1102         UBaseType_t uxTimerGetTimerNumber( TimerHandle_t xTimer )\r
1103         {\r
1104             return ( ( Timer_t * ) xTimer )->uxTimerNumber;\r
1105         }\r
1106 \r
1107     #endif /* configUSE_TRACE_FACILITY */\r
1108 /*-----------------------------------------------------------*/\r
1109 \r
1110     #if ( configUSE_TRACE_FACILITY == 1 )\r
1111 \r
1112         void vTimerSetTimerNumber( TimerHandle_t xTimer,\r
1113                                    UBaseType_t uxTimerNumber )\r
1114         {\r
1115             ( ( Timer_t * ) xTimer )->uxTimerNumber = uxTimerNumber;\r
1116         }\r
1117 \r
1118     #endif /* configUSE_TRACE_FACILITY */\r
1119 /*-----------------------------------------------------------*/\r
1120 \r
1121 /* This entire source file will be skipped if the application is not configured\r
1122  * to include software timer functionality.  If you want to include software timer\r
1123  * functionality then ensure configUSE_TIMERS is set to 1 in FreeRTOSConfig.h. */\r
1124 #endif /* configUSE_TIMERS == 1 */\r