source: trunk/firmware/App/CubeMX/Middlewares/Third_Party/FreeRTOS/Source/timers.c

Last change on this file was 29, checked in by Zed, 3 weeks ago

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