21.5 软件定时器控制块

xTimerCreate()/xTimerCreateStatic()函数创建一个软件定时器

  1. #if ( configUSE_TIMERS == 1 )
  2. #define tmrNO_DELAY        ( TickType_t ) 0U
  4. typedef struct tmrTimerControl
  5. {
  6.     //软件定时器名字,一般用于调试的,RTOS 使用定时器是通过其句柄，并不是使用其名字
  7.     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. */
  8.     //软件定时器列表项，用于插入定时器列表
  9.     ListItem_t                xTimerListItem;        /*<< Standard linked list item as used by all kernel features for event management. */
  10.     // 软件定时器的周期， 单位为系统节拍周期,
  11.     // pdMS_TO_TICKS()可以把时间单位从 ms 转换为系统节拍周期
  12.     TickType_t                xTimerPeriodInTicks;/*<< How quickly and often the timer expires. */
  13.     //软件定时器是否自动重置， 如果该值为 pdFalse，那么创建的软件
  14.     //定时器工作模式是单次模式，否则为周期模式
  15.     UBaseType_t                uxAutoReload;        /*<< Set to pdTRUE if the timer should be automatically restarted once expired.  Set to pdFALSE if the timer is, in effect, a one-shot timer. */
  16.     //软件定时器 ID， 数字形式。在回调函数里面根据 ID 号来处理不同的软件定时器
  17.     void                     *pvTimerID;            /*<< An ID to identify the timer.  This allows the timer to be identified when the same callback is used for multiple timers. */
  18.     //软件定时器的回调函数， 当定时时间到达的时候就会调用这个函数
  19.     TimerCallbackFunction_t    pxCallbackFunction;    /*<< The function that will be called when the timer expires. */
  20.     #if( configUSE_TRACE_FACILITY == 1 )
  21.         UBaseType_t            uxTimerNumber;        /*<< An ID assigned by trace tools such as FreeRTOS+Trace */
  22.     #endif
  23.     //软件定时器的回调函数， 当定时时间到达的时候就会调用这个函数
  24.     #if( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
  25.         uint8_t             ucStaticallyAllocated; /*<< Set to pdTRUE if the timer was created statically so no attempt is made to free the memory again if the timer is later deleted. */
  26.     #endif
  27. } xTIMER;

21.6 软件定时器函数接口

软件定时器的功能是在定时器任务（或者叫定时器守护任务） 中实现的。 软件定时器的很多 API 函数通过一个名字叫“定时器命令队列” 的队列来给定时器守护任务发送命令。该定时器命令队列由 RTOS 内核提供，且应用程序不能够直接访问，其消息队列的长度由宏 configTIMER_QUEUE_LENGTH 定义。

21.6.1 软件定时器创建函数xTimerCreate(）

一种是动态创建软件定时器 xTimerCreate()， 另一种是静态创建方式 xTimerCreateStatic()，
xTimerCreate()用于创建一个软件定时器，并返回一个句柄。
软件定时器在创建成功后是处于休眠状态的， 可以使用以下的API来操作定时器。

  • xTimerStart()
  • xTimerReset()
  • xTimerStartFromISR()
  • xTimerResetFromISR()
  • xTimerChangePeriod()
  • xTimerChangePeriodFromISR()

参数：

  • const char * const pcTimerName：软件定时器名字

  • const TickType_t xTimerPeriodInTicks：软件定时器的周期，单位为系统节拍周期 pdMS_TO_TICKS()可以把时间单位从 ms 转换为系统节拍周期 

    1. #ifndef pdMS_TO_TICKS
    2.   #define pdMS_TO_TICKS( xTimeInMs ) ( ( TickType_t ) ( ( ( TickType_t ) ( xTimeInMs ) * ( TickType_t ) configTICK_RATE_HZ ) / ( TickType_t ) 1000 ) )
    3. #endif

  • const UBaseType_t uxAutoReload：如果 uxAutoReload 设置为 pdTRUE， 那么软件定时器的工作模式就是周期模式

  • void * const pvTimerID：在回调函数里面根据 ID 号来处理不同的软件定时器

  • TimerCallbackFunction_t pxCallbackFunction：软件定时器的回调函数 ```c TimerHandle_t xTimerCreate( const char * const pcTimerName,

    1.                           const TickType_t xTimerPeriodInTicks,
    2.                           const UBaseType_t uxAutoReload,
    3.                           void * const pvTimerID,
    4.                           TimerCallbackFunction_t pxCallbackFunction ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

    {

    1.   Timer_t *pxNewTimer;
    2.   /* 为这个软件定时器申请一块内存 */
    3.   pxNewTimer = ( Timer_t * ) pvPortMalloc( sizeof( Timer_t ) );
    5.   if( pxNewTimer != NULL )
    6.   {    /* 内存申请成功，进行初始化软件定时器 */
    7.       prvInitialiseNewTimer( pcTimerName, 
    8.                             xTimerPeriodInTicks,
    9.                             uxAutoReload, 
    10.                             pvTimerID, 
    11.                             pxCallbackFunction,
    12.                             pxNewTimer );
    14.       #if( configSUPPORT_STATIC_ALLOCATION == 1 )
    15.       {
    16.           pxNewTimer->ucStaticallyAllocated = pdFALSE;
    17.       }
    18.       #endif /* configSUPPORT_STATIC_ALLOCATION */
    19.   }
    21.   return pxNewTimer;

    }

endif / configSUPPORT_STATIC_ALLOCATION /

/—————————————————————————————-/

  1. prvInitialiseNewTimer() 
  2. ```c
  3. static void prvInitialiseNewTimer(    const char * const pcTimerName,
  4.                                     const TickType_t xTimerPeriodInTicks,
  5.                                     const UBaseType_t uxAutoReload,
  6.                                     void * const pvTimerID,
  7.                                     TimerCallbackFunction_t pxCallbackFunction,
  8.                                     Timer_t *pxNewTimer ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */
  9. {
  10.     /* 断言，判断定时器的周期是否大于 0 */
  11.     configASSERT( ( xTimerPeriodInTicks > 0 ) );
  13.     if( pxNewTimer != NULL )
  14.     {
  15.         /* 初始化软件定时器列表与创建软件定时器消息队列  下面有详情*/ 
  16.         prvCheckForValidListAndQueue();
  18.         /* 初始化软件定时信息，这些信息保存在软件定时器控制块中 */ 
  19.         pxNewTimer->pcTimerName = pcTimerName;
  20.         pxNewTimer->xTimerPeriodInTicks = xTimerPeriodInTicks;
  21.         pxNewTimer->uxAutoReload = uxAutoReload;
  22.         pxNewTimer->pvTimerID = pvTimerID;
  23.         pxNewTimer->pxCallbackFunction = pxCallbackFunction;
  24.         /* 初始化定时器列表项 */ 
  25.         vListInitialiseItem( &( pxNewTimer->xTimerListItem ) );
  26.         traceTIMER_CREATE( pxNewTimer );
  27.     }
  28. }
  29. /*-----------------------------------------------------------*/
  1. 在 prvCheckForValidListAndQueue()函数中系统将初始化软件定时器列表与创建软件定时器消息队列，也叫“定时器命令队列” ，因为在使用软件定时器的时候，用户是无法直接控制软件定时器的，必须通过“定时器命令队列”向软件定时器发送一个命令，软件定时器任务被唤醒就去执行对应的命令操作。

prvCheckForValidListAndQueue()

  1. static void prvCheckForValidListAndQueue( void )
  2. {
  3.     /* Check that the list from which active timers are referenced, and the
  4.     queue used to communicate with the timer service, have been
  5.     initialised. */
  6.     /* 检查引用活动计时器的列表，队列是用来和时间服务来进行通讯的 */
  7.     taskENTER_CRITICAL();
  8.     {
  9.         /* 没有创建定时器命令队列 */
  10.         if( xTimerQueue == NULL )
  11.         {
  12.             /* 初始化两个队列 */
  13.             vListInitialise( &xActiveTimerList1 );
  14.             vListInitialise( &xActiveTimerList2 );
  15.             pxCurrentTimerList = &xActiveTimerList1;
  16.             pxOverflowTimerList = &xActiveTimerList2;
  18.             #if( configSUPPORT_STATIC_ALLOCATION == 1 )
  19.             {
  20.                 /* The timer queue is allocated statically in case
  21.                 configSUPPORT_DYNAMIC_ALLOCATION is 0. */
  22.                 static StaticQueue_t xStaticTimerQueue;
  23.                 static uint8_t ucStaticTimerQueueStorage[ configTIMER_QUEUE_LENGTH * sizeof( DaemonTaskMessage_t ) ];
  25.                 xTimerQueue = xQueueCreateStatic( ( UBaseType_t ) configTIMER_QUEUE_LENGTH, sizeof( DaemonTaskMessage_t ), &( ucStaticTimerQueueStorage[ 0 ] ), &xStaticTimerQueue );
  26.             }
  27.             #else
  28.             {
  29.                 // 用这个动态创建
  30.                 xTimerQueue = xQueueCreate( ( UBaseType_t ) configTIMER_QUEUE_LENGTH, sizeof( DaemonTaskMessage_t ) );
  31.             }
  32.             #endif
  34.             #if ( configQUEUE_REGISTRY_SIZE > 0 )
  35.             {
  36.                 if( xTimerQueue != NULL )
  37.                 {
  38.                     // 注册到队列（注意消息队列是没有注册到队列的）
  39.                     vQueueAddToRegistry( xTimerQueue, "TmrQ" );
  40.                 }
  41.                 else
  42.                 {
  43.                     mtCOVERAGE_TEST_MARKER();
  44.                 }
  45.             }
  46.             #endif /* configQUEUE_REGISTRY_SIZE */
  47.         }
  48.         else
  49.         {
  50.             mtCOVERAGE_TEST_MARKER();
  51.         }
  52.     }
  53.     taskEXIT_CRITICAL();
  54. }
  55. /*-----------------------------------------------------------*/

使用示例：

  1. static TimerHandle_t Swtmr1_Handle =NULL; /* 软件定时器句柄 */
  2. static TimerHandle_t Swtmr2_Handle =NULL; /* 软件定时器句柄 */
  4. /* 周期模式的软件定时器 1,定时器周期 1000(tick)*/
  5. Swtmr1_Handle=xTimerCreate((const char*)"AutoReloadTimer",
  6.                             (TickType_t)1000,/* 定时器周期 1000(tick) */
  7.                             (UBaseType_t)pdTRUE,/* 周期模式 */
  8.                             (void* )1,/* 为每个计时器分配一个索引的唯一 ID */
  9.                             (TimerCallbackFunction_t)Swtmr1_Callback); /* 回调函数 */
  11. if (Swtmr1_Handle != NULL)
  12. {
  13.     /********************************************************************
  14. * xTicksToWait:如果在调用 xTimerStart()时队列已满，则以 tick 为单位指定调用任务应保持
  15.  * 在 Blocked(阻塞)状态以等待 start 命令成功发送到 timer 命令队列的时间。
  16. * 如果在启动调度程序之前调用 xTimerStart()，则忽略 xTicksToWait。在这里设置等待时间为 0.
  17.  **********************************************************************/
  18.     xTimerStart(Swtmr1_Handle,0); //开启周期定时器
  20. }
  23. /* 单次模式的软件定时器 2,定时器周期 5000(tick)*/
  24. Swtmr2_Handle=xTimerCreate((const char* )"OneShotTimer",
  25.                             (TickType_t)5000,/* 定时器周期 5000(tick) */
  26.                             (UBaseType_t )pdFALSE,/* 单次模式 */
  27.                             (void*)2,/* 为每个计时器分配一个索引的唯一 ID */
  28.                             (TimerCallbackFunction_t)Swtmr2_Callback);
  29. if (Swtmr2_Handle != NULL)
  30. {
  31.     xTimerStart(Swtmr2_Handle,0); //开启单次定时器
  32. }
  34. static void Swtmr1_Callback(void* parameter)
  35. {
  36.     // 回调函数
  37. }
  39. static void Swtmr2_Callback(void* parameter)
  40. {
  41.     // 回调函数
  42. }

21.6.2 软件定时器启动函数

1. xTimerStart()

软件定时器在创建完成的时候是处于休眠状态的，需要用 FreeRTOS 的相关函数将软件定时器活动起来，而 xTimerStart()函数就是可以让处于休眠的定时器开始工作
在系统开始运行的时候，系统会帮我们自动创建一个软件定时器任务（prvTimerTask），在这个任务中，如果暂时没有运行中的定时器，任务会进入阻塞态等待命令， 而我们的启动函数就是通过“定时器命令队列” 向定时器任务发送一个启动命令，定时器任务获得命令就解除阻塞，然后执行启动软件定时器命令。 

  1. #define xTimerStart( xTimer, xTicksToWait )     \
  2. xTimerGenericCommand( ( xTimer ),                 \
  3.                      tmrCOMMAND_START,     \
  4.                      ( xTaskGetTickCount() ),    \
  5.                      NULL,             \
  6.                      ( xTicksToWait ) )

xTimerStart()函数就是一个宏定义，真正起作用的是 xTimerGenericCommand()函数。
tmrCOMMAND_START 是软件定时器启动命令，因为现在是要将软件定时器启动，该命令在 timers.h 中有定义。 xCommandID 参数可以指定多个命令，软件定时器操作支持的命令

xTaskGetTickCount() )：获取系统时间
xTicksToWait：用户指定超时阻塞时间， 单位为系统节拍周期(即 tick)。调用xTimerStart()的任务将被锁定在阻塞态， 在软件定时器把启动的命令成功发送到定时器命令队列之前。如果在 FreeRTOS 调度器开启之前调用 xTimerStart()，形参将不起作用。

支持的命令

  1. #define tmrCOMMAND_EXECUTE_CALLBACK_FROM_ISR     ( ( BaseType_t ) -2 )
  2. #define tmrCOMMAND_EXECUTE_CALLBACK                ( ( BaseType_t ) -1 )
  3. #define tmrCOMMAND_START_DONT_TRACE                ( ( BaseType_t ) 0 )
  4. #define tmrCOMMAND_START                        ( ( BaseType_t ) 1 )
  5. #define tmrCOMMAND_RESET                        ( ( BaseType_t ) 2 )
  6. #define tmrCOMMAND_STOP                            ( ( BaseType_t ) 3 )
  7. #define tmrCOMMAND_CHANGE_PERIOD                ( ( BaseType_t ) 4 )
  8. #define tmrCOMMAND_DELETE                        ( ( BaseType_t ) 5 )
  10. #define tmrFIRST_FROM_ISR_COMMAND                ( ( BaseType_t ) 6 )
  11. #define tmrCOMMAND_START_FROM_ISR                ( ( BaseType_t ) 6 )
  12. #define tmrCOMMAND_RESET_FROM_ISR                ( ( BaseType_t ) 7 )
  13. #define tmrCOMMAND_STOP_FROM_ISR                ( ( BaseType_t ) 8 )
  14. #define tmrCOMMAND_CHANGE_PERIOD_FROM_ISR        ( ( BaseType_t ) 9 )

xTimerGenericCommand()源码

  1. BaseType_t xTimerGenericCommand( TimerHandle_t xTimer, 
  2.                                 const BaseType_t xCommandID, 
  3.                                 const TickType_t xOptionalValue, 
  4.                                 BaseType_t * const pxHigherPriorityTaskWoken, 
  5.                                 const TickType_t xTicksToWait )
  6. {
  7.     BaseType_t xReturn = pdFAIL;
  8.     DaemonTaskMessage_t xMessage;
  10.     configASSERT( xTimer );
  11.     /* 发送命令给定时器任务 */
  12.     if( xTimerQueue != NULL )
  13.     {
  14.         /* 要发送的命令信息，包含命令
  15.         命令的数值（比如可以表示当前系统时间、要修改的定时器周期等）
  16.         以及要处理的软件定时器句柄 */
  17.         xMessage.xMessageID = xCommandID;        // 命令
  18.         xMessage.u.xTimerParameters.xMessageValue = xOptionalValue;    // 系统时间
  19.         xMessage.u.xTimerParameters.pxTimer = ( Timer_t * ) xTimer;    // 句柄
  20.         /* 命令是在任务中发出的,不是在中断 */
  21.         if( xCommandID < tmrFIRST_FROM_ISR_COMMAND )
  22.         {
  23.             /* 如果调度器已经运行了，就根据用户指定超时时间发送 */
  24.             if( xTaskGetSchedulerState() == taskSCHEDULER_RUNNING )
  25.             {
  26.                 // 将任务推送到定时器的队列
  27.                 xReturn = xQueueSendToBack( xTimerQueue, 
  28.                                            &xMessage, 
  29.                                            xTicksToWait );
  30.             }
  31.             else
  32.             {
  33.                 /* 如果调度器还未运行，发送就行了，不需要阻塞 */
  34.                 xReturn = xQueueSendToBack( xTimerQueue,
  35.                                            &xMessage, 
  36.                                            tmrNO_DELAY );
  37.             }
  38.         }
  39.         else    /* 命令是在中断中发出的 */
  40.         {
  41.             /* 调用从中断向消息队列发送消息的函数 */
  42.             xReturn = xQueueSendToBackFromISR( xTimerQueue, 
  43.                                               &xMessage, 
  44.                                               pxHigherPriorityTaskWoken );
  45.         }
  47.         traceTIMER_COMMAND_SEND( xTimer, xCommandID, xOptionalValue, xReturn );
  48.     }
  49.     else
  50.     {
  51.         mtCOVERAGE_TEST_MARKER();
  52.     }
  54.     return xReturn;
  55. }

2. xTimerStartFromISR()

xTimerStartFromISR()是函数 xTimerStart()的中断版本， 用于启动一个先前由函数 xTimerCreate() / xTimerCreateStatic()创建的软件定时器。
image.png

使用示例：

  1. /*  这个方案假定软件定时器 xBacklightTimer 已经创建，
  2.     定时周期为 5s，执行次数为一次，即定时时间到了之后
  3.     就进入休眠态。
  5.     程序说明：当按键按下，打开液晶背光，启动软件定时器，5s 时间到，关掉液晶背光
  6. */
  8. /* 软件定时器回调函数 */
  9. void vBacklightTimerCallback( TimerHandle_t pxTimer )
  10. {
  11.     /* 关掉液晶背光 */
  12.     vSetBacklightState( BACKLIGHT_OFF );
  13. }
  15. /* 按键中断服务程序 */
  16. void vKeyPressEventInterruptHandler( void )
  17. {
  18.     BaseType_t xHigherPriorityTaskWoken = pdFALSE;
  20.     /* 确保液晶背光已经打开 */
  21.     vSetBacklightState( BACKLIGHT_ON );
  23.     /* 启动软件定时器 */
  24.     if ( xTimerStartFromISR( xBacklightTimer,
  25.                             &xHigherPriorityTaskWoken ) != pdPASS ) {
  26.         /* 软件定时器开启命令没有成功执行 */
  27.     }
  29.     /* ...执行其他的按键相关的功能代码 */
  31.     if ( xHigherPriorityTaskWoken != pdFALSE ) {
  32.         /* 执行上下文切换 */
  33.     }
  34. }

21.6.3 软件定时器停止函数

1. xTimerStop()

xTimerStop() 用于停止一个已经启动的软件定时器， 该函数的实现也是通过“定时器命令队列”发送一个停止命令给软件定时器任务，从而唤醒软件定时器任务去将定时器停止。
image.png
使用示例：

  1. static TimerHandle_t Swtmr1_Handle =NULL; /* 软件定时器句柄 */
  3. /* 周期模式的软件定时器 1,定时器周期 1000(tick)*/
  4. Swtmr1_Handle=xTimerCreate((const char* )"AutoReloadTimer",
  5.                            (TickType_t )1000,/* 定时器周期 1000(tick) */
  6.                            (UBaseType_t )pdTRUE,/* 周期模式 */
  7.                            (void*)1,/* 为每个计时器分配一个索引的唯一 ID */
  8.                            (TimerCallbackFunction_t)Swtmr1_Callback); /* 回调函数 */
  9. if (Swtmr1_Handle != NULL)
  10. {
  11.  /********************************************************************
  12.  * xTicksToWait:如果在调用 xTimerStart()时队列已满，则以 tick 为单位指定调用任务应保持
  13.  * 在 Blocked(阻塞)状态以等待 start 命令成功发送到 timer 命令队列的时间。
  14.  * 如果在启动调度程序之前调用 xTimerStart()，则忽略 xTicksToWait。在这里设置等待时间为 0.
  15.  *******************************************************************/
  16.     xTimerStart(Swtmr1_Handle,0); //开启周期定时器
  17. }
  19. static void test_task(void* parameter)
  20. {
  21.     while (1) {
  22.         /* 用户自己实现任务代码 */
  23.         xTimerStop(Swtmr1_Handle,0); //停止定时器
  24.     }
  25. }

2.xTimerStopFromISR()

中断版本：
image.png
示例：

  1. /* 这个方案假定软件定时器 xTimer 已经创建且启动
  2. 当中断发生时，停止软件定时器 */
  4. /* 停止软件定时器的中断服务函数*/
  5. void vAnExampleInterruptServiceRoutine( void )
  6. {
  7.     BaseType_t xHigherPriorityTaskWoken = pdFALSE;
  9.     if (xTimerStopFromISR(xTimer,&xHigherPriorityTaskWoken)!=pdPASS ) {
  10.         /* 软件定时器停止命令没有成功执行 */
  11.     }
  13.     if ( xHigherPriorityTaskWoken != pdFALSE ) {
  14.         /* 执行上下文切换 */
  15.     }
  16. }

21.6.4 软件定时器任务

软件定时器回调函数运行的上下文环境是任务，那么软件定时器任务是在干什么的呢？如何创建的呢？下面跟我一步步来分析软件定时器的工作过程。
软件定时器任务是在系统开始调度（vTaskStartScheduler()函数） 的时候就被创建的，前提 是将宏定 义 configUSE_TIMERS 开启。

  1.     #if ( configUSE_TIMERS == 1 )
  2.     {
  3.         if( xReturn == pdPASS )
  4.         {
  5.             xReturn = xTimerCreateTimerTask();
  6.         }
  7.         else
  8.         {
  9.             mtCOVERAGE_TEST_MARKER();
  10.         }
  11.     }
  12.     #endif /* configUSE_TIMERS */

xTimerCreateTimerTask()函数：

  1. BaseType_t xTimerCreateTimerTask( void )
  2. {
  3.     BaseType_t xReturn = pdFAIL;
  5.     prvCheckForValidListAndQueue();
  7.     if( xTimerQueue != NULL )    /* 静态创建任务 */
  8.     {
  9.         #if( configSUPPORT_STATIC_ALLOCATION == 1 )
  10.         {
  11.             StaticTask_t *pxTimerTaskTCBBuffer = NULL;
  12.             StackType_t *pxTimerTaskStackBuffer = NULL;
  13.             uint32_t ulTimerTaskStackSize;
  15.             vApplicationGetTimerTaskMemory( &pxTimerTaskTCBBuffer, &pxTimerTaskStackBuffer, &ulTimerTaskStackSize );
  16.             xTimerTaskHandle = xTaskCreateStatic(    prvTimerTask,
  17.                                                     "Tmr Svc",
  18.                                                     ulTimerTaskStackSize,
  19.                                                     NULL,
  20.                                                     ( ( UBaseType_t ) configTIMER_TASK_PRIORITY ) | portPRIVILEGE_BIT,
  21.                                                     pxTimerTaskStackBuffer,
  22.                                                     pxTimerTaskTCBBuffer );
  24.             if( xTimerTaskHandle != NULL )
  25.             {
  26.                 xReturn = pdPASS;
  27.             }
  28.         }
  29.         #else    /* 动态创建任务 */
  30.         {
  31.             xReturn = xTaskCreate(    prvTimerTask,
  32.                                     "Tmr Svc",
  33.                                     configTIMER_TASK_STACK_DEPTH,
  34.                                     NULL,
  35.                                     ( ( UBaseType_t ) configTIMER_TASK_PRIORITY ) | portPRIVILEGE_BIT,
  36.                                     &xTimerTaskHandle );
  37.         }
  38.         #endif /* configSUPPORT_STATIC_ALLOCATION */
  39.     }
  40.     else
  41.     {
  42.         mtCOVERAGE_TEST_MARKER();
  43.     }
  45.     configASSERT( xReturn );
  46.     return xReturn;
  47. }

系统调用 xTaskCreate()函数创建了一个软件定时器任务，任务的入口函数是 prvTimerTask， 任务的优先级是 configTIMER_TASK_PRIORITY。任务是 prvTimerTask() ，主要是在这个任务里面干活。

prvTimerTask() 主要的任务

  1. static void prvTimerTask( void *pvParameters )
  2. {
  3.     TickType_t xNextExpireTime;
  4.     BaseType_t xListWasEmpty;
  6.     /* Just to avoid compiler warnings. */
  7.     ( void ) pvParameters;
  9.     for( ;; )
  10.     {
  11.         /* 获取下一个要到期的软件定时器的时间 */
  12.         // 这个函数猜测：选取第一个要到期的任务
  13.         xNextExpireTime = prvGetNextExpireTime( &xListWasEmpty );    //(1)
  15.         /* 处理定时器或者将任务阻塞到下一个到期的软件定时器时间 */
  16.         prvProcessTimerOrBlockTask( xNextExpireTime, xListWasEmpty );    //(2)
  18.         /* 读取“定时器命令队列”，处理相应命令 */
  19.         prvProcessReceivedCommands();    //3
  20.     }
  21. }
  22. /*-----------------------------------------------------------*/
  1. 在这个函数中：
  2.     xNextExpireTime = prvGetNextExpireTime( &xListWasEmpty );    //(1)
  3.     这个函数用来判断是否有任务到期了。
  5.     prvProcessTimerOrBlockTask
  6.     这个函数判断了是否溢出，如果溢出就切换列表。然后进入延时等待唤醒
  8.     prvProcessReceivedCommands
  9.     这个函数主要是用来接收队列里面的消息，然后执行对应的命令

软件定时器任务的处理很简单，如果当前有软件定时器在运行，那么它大部分的时间都在等待定时器到期时间的到来，或者在等待对软件定时器操作的命令，而如果没有软件定时器在运行，那定时器任务的绝大部分时间都在阻塞中等待定时器的操作命令。

  1. 获取下一个要到期的软件定时器的时间，因为软件定时器是由定时器列表维护的，并且按照到期的时间进行升序排列，只需获取软件定时器列表中的第一个定时器到期时间就是下一个要到期的时间。
  2. 处理定时器或者将任务阻塞到下一个到期的软件定时器时间，因为系统时间节拍随着系统的运行可能会溢出，那么就需要处理溢出的情况，如果没有溢出，那么就等待下一个定时器到期时间的到来。该函数每次调用都会记录节拍值， 下一次调用，通过比较相邻两次调用的值判断节拍计数器是否溢出过。当节拍计数器溢出，需要处理掉当前定时器列表上的定时器（因为这条定时器列表上的定时器都已经溢出了），然后切换定时器列表。

软件定时器是一个任务，在下一个定时器到了之前的这段时间，系统要把任务状态转移为阻塞态，让其他的任务能正常运行，这样子就使得系统的资源能充分利用。

prvTimerTask
prvProcessTimerOrBlockTask() xListWasEmpty

  1. static void prvProcessTimerOrBlockTask( const TickType_t xNextExpireTime, 
  2.                                        BaseType_t xListWasEmpty )
  3. {
  4.     TickType_t xTimeNow;
  5.     BaseType_t xTimerListsWereSwitched;
  7.     vTaskSuspendAll();
  8.     {
  9.         // 获取当前系统时间节拍并判断系统节拍计数是否溢出
  10.         // 如果是， 那么就处理当前列表上的定时器，并切换定时器列表
  11.         xTimeNow = prvSampleTimeNow( &xTimerListsWereSwitched );
  12.         // 系统节拍计数器没有溢出
  13.         if( xTimerListsWereSwitched == pdFALSE )
  14.         {
  15.             // 判断是否有定时器是否到期
  16.             // 定时器列表非空并且定时器的时间已比当前时间小，说明定时器到期了
  17.             if( ( xListWasEmpty == pdFALSE ) && ( xNextExpireTime <= xTimeNow ) )
  18.             {
  19.                 // 恢复调度器
  20.                 ( void ) xTaskResumeAll();
  21.                 //执行相应定时器的回调函数
  22.                 // 对于需要自动重载的定时器， 更新下一次溢出时间， 插回列表
  23.                 prvProcessExpiredTimer( xNextExpireTime, xTimeNow );
  24.             }
  25.             else
  26.             {
  27.                 // 当前定时器列表中没有定时器
  28.                 if( xListWasEmpty != pdFALSE )
  29.                 {
  30.                     //发生这种情况的可能是系统节拍计数器溢出了，
  31.                     //定时器被添加到溢出列表中，所以判断定时器溢出列表上是否有定时
  32.                     xListWasEmpty = listLIST_IS_EMPTY( pxOverflowTimerList );
  33.                 }
  34.                 // 定时器定时时间还没到，将当前任务挂起，
  35.                 // 直到定时器到期才唤醒或者收到命令的时候唤醒     
  36.                 vQueueWaitForMessageRestricted( xTimerQueue, 
  37.                                                ( xNextExpireTime - xTimeNow ), 
  38.                                                xListWasEmpty );
  40.                 // 恢复调度器，看看是否有任务需要切换，如果有则进行任务切换
  41.                 // 疑问：这里判是false不就是不需要任务切换，但是下面又进行了切换
  42.                 if( xTaskResumeAll() == pdFALSE )
  43.                 {
  44.                     // 进行任务切换
  45.                     portYIELD_WITHIN_API();
  46.                 }
  47.                 else
  48.                 {
  49.                     mtCOVERAGE_TEST_MARKER();
  50.                 }
  51.             }
  52.         }
  53.         else
  54.         {
  55.             ( void ) xTaskResumeAll();
  56.         }
  57.     }
  58. }
  59. /*-----------------------------------------------------------*/

prvProcessTimerOrBlockTask
prvSampleTimeNow() 

  1. static TickType_t prvSampleTimeNow( BaseType_t * const pxTimerListsWereSwitched )
  2. {
  3.     TickType_t xTimeNow;
  4.     // 定义一个静态变量 记录上一次调用时系统时间节拍值
  5.     PRIVILEGED_DATA static TickType_t xLastTime = ( TickType_t ) 0U; /*lint !e956 Variable is only accessible to one task. */
  7.     //获取当前系统时间节拍
  8.     xTimeNow = xTaskGetTickCount();
  10.     //判断是否溢出了
  11.     //当前系统时间节拍比上一次调用时间节拍的值小，这种情况是溢出的情况
  12.     if( xTimeNow < xLastTime )
  13.     {
  14.         // 发生溢出， 处理当前定时器列表上所有定时器并切换定时器列表
  15.         prvSwitchTimerLists();
  16.         *pxTimerListsWereSwitched = pdTRUE;
  17.     }
  18.     else
  19.     {
  20.         *pxTimerListsWereSwitched = pdFALSE;
  21.     }
  22.     // 更新本次系统时间节拍
  23.     xLastTime = xTimeNow;
  25.     return xTimeNow;
  26. }
  27. /*-----------------------------------------------------------*/


prvTimerTask
读取“定时器命令队列”，处理相应命令，
prvProcessReceivedCommands 有删减 删除了配置中断中要设置的一些任务（譬如事件，在中断中不进行判断，而是设置任务到TIMER进程去处理事件）

  1. static void    prvProcessReceivedCommands( void )
  2. {
  3.     DaemonTaskMessage_t xMessage;
  4.     Timer_t *pxTimer;
  5.     BaseType_t xTimerListsWereSwitched, xResult;
  6.     TickType_t xTimeNow;
  8.     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. */
  9.     {
  10.         /* 判断定时器命令是否有效 */
  11.         if( xMessage.xMessageID >= ( BaseType_t ) 0 )
  12.         {
  13.             /* 获取定时器消息，获取命令指定处理的定时器， */
  14.             pxTimer = xMessage.u.xTimerParameters.pxTimer;
  15.             /* 如果定时器在列表中，将定时器移除 */
  16.             if( listIS_CONTAINED_WITHIN( NULL, &( pxTimer->xTimerListItem ) ) == pdFALSE )
  17.             {
  18.                 ( void ) uxListRemove( &( pxTimer->xTimerListItem ) );
  19.             }
  20.             else
  21.             {
  22.                 mtCOVERAGE_TEST_MARKER();
  23.             }
  25.             traceTIMER_COMMAND_RECEIVED( pxTimer, xMessage.xMessageID, xMessage.u.xTimerParameters.xMessageValue );
  26.             // 判断节拍计数器是否溢出过，如果有就处理并切换定时器列表
  27.             // 因为下面的操作可能有新定时器项插入确保定时器列表对应
  28.             xTimeNow = prvSampleTimeNow( &xTimerListsWereSwitched );
  30.             switch( xMessage.xMessageID )
  31.             {
  32.                 case tmrCOMMAND_START :
  33.                 case tmrCOMMAND_START_FROM_ISR :
  34.                 case tmrCOMMAND_RESET :
  35.                 case tmrCOMMAND_RESET_FROM_ISR :
  36.                 case tmrCOMMAND_START_DONT_TRACE :
  37.                     // 以上的命令都是让定时器启动
  38.                     // 求出定时器到期时间并插入到定时器列表中
  39.                     if( prvInsertTimerInActiveList( pxTimer,  
  41.                                                    xMessage.u.xTimerParameters.xMessageValue 
  42.                                                    + pxTimer->xTimerPeriodInTicks, 
  44.                                                    xTimeNow, 
  45.                                                    xMessage.u.xTimerParameters.xMessageValue ) != pdFALSE )
  46.                     {
  47.                         // 该定时器已经溢出赶紧执行其回调函数
  48.                         pxTimer->pxCallbackFunction( ( TimerHandle_t ) pxTimer );
  49.                         traceTIMER_EXPIRED( pxTimer );
  51.                         // 如果定时器是重载定时器，就重新启动
  52.                         if( pxTimer->uxAutoReload == ( UBaseType_t ) pdTRUE )
  53.                         {
  54.                             xResult = xTimerGenericCommand( pxTimer, tmrCOMMAND_START_DONT_TRACE, xMessage.u.xTimerParameters.xMessageValue + pxTimer->xTimerPeriodInTicks, NULL, tmrNO_DELAY );
  55.                             configASSERT( xResult );
  56.                             ( void ) xResult;
  57.                         }
  58.                         else
  59.                         {
  60.                             mtCOVERAGE_TEST_MARKER();
  61.                         }
  62.                     }
  63.                     else
  64.                     {
  65.                         mtCOVERAGE_TEST_MARKER();
  66.                     }
  67.                     break;
  69.                 case tmrCOMMAND_STOP :
  70.                 case tmrCOMMAND_STOP_FROM_ISR :
  71.                     break;
  72.                     // 如果命令是停止定时器，那就将定时器移除，
  73.                     // 在开始的时候已经从定时器列表移除，
  74.                     // 此处就不需要做其他操作
  77.                 case tmrCOMMAND_CHANGE_PERIOD :
  78.                 case tmrCOMMAND_CHANGE_PERIOD_FROM_ISR :
  79.                     // 更新定时器配置
  80.                     // 插入到定时器列表，也重新启动了定时器
  81.                     pxTimer->xTimerPeriodInTicks = xMessage.u.xTimerParameters.xMessageValue;
  82.                     configASSERT( ( pxTimer->xTimerPeriodInTicks > 0 ) );
  83.                     ( void ) prvInsertTimerInActiveList( pxTimer, ( xTimeNow + pxTimer->xTimerPeriodInTicks ), xTimeNow, xTimeNow );
  84.                     break;
  86.                 case tmrCOMMAND_DELETE :
  87.                     // 删除定时器
  88.                     #if( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 0 ) )
  89.                     {
  90.                         vPortFree( pxTimer );
  91.                     }
  92.                     break;
  94.                 default    :
  95.                     break;
  96.             }
  97.         }
  98.     }
  99. }
  100. /*-----------------------------------------------------------*/

21.6.5 软件定时器删除函数 xTimerDelete()

TimerDelete()用于删除一个已经被创建成功的软件定时器， 删除之后就无法使用该定时器， 并且定时器相应的资源也会被系统回收释放。
image.png
从软件定时器删除函数 xTimerDelete()的原型可以看出， 删除一个软件定时器也是在软件定时器任务中删除， 调用 xTimerDelete()将删除软件定时器的命令发送给软件定时器任务，软件定时器任务在接收到删除的命令之后就进行删除操作， 该函数的使用方法很简单。

  1. static TimerHandle_t Swtmr1_Handle =NULL; /* 软件定时器句柄 */
  3. /* 周期模式的软件定时器 1,定时器周期 1000(tick)*/
  4. Swtmr1_Handle=xTimerCreate((const char* )"AutoReloadTimer",
  5.                            (TickType_t )1000,/* 定时器周期 1000(tick) */
  6.                            (UBaseType_t)pdTRUE,/* 周期模式 */
  7.                            (void* )1,/* 为每个计时器分配一个索引的唯一 ID */
  8.                            (TimerCallbackFunction_t)Swtmr1_Callback); /* 回调函数 */
  9. if (Swtmr1_Handle != NULL)
  10. {
  11.     xTimerStart(Swtmr1_Handle,0);
  12. }
  14. static void test_task(void* parameter)
  15. {
  16.     while (1) {
  17.         /* 用户自己实现任务代码 */
  18.         xTimerDelete(Swtmr1_Handle,0); //删除软件定时器
  19.     }
  20. }