FreeRTOS源码探析之——软件定时器

xxpcb

发布于 2020-12-02 14:36:05

1.2K0

发布于 2020-12-02 14:36:05

文章被收录于专栏：码农爱学习的专栏码农爱学习的专栏

软件定时器是FreeRTOS中的一个重要模块，使用软件定时器可以方便的实现一些与超时或周期性相关的功能，本篇从FreeRTOS的源码入手，来分析FreeRTOS软件定时器的运行机理。

基础知识

1.1 软件定时器与硬件定时器的区别

硬件定时器

每次在定时时间到达之后就会自动触发一个中断，用户在中断服务函数中处理信息
硬件定时器的精度一般很高，可以达到纳秒级别
硬件定时器是芯片本身提供的定时功能

软件定时器

指定时间到达后要调用回调函数（也称超时函数），用户在回调函数中处理信息
硬件定时器的定时精度与系统时钟的周期有关，一般系统利用SysTick作为软件定时器的基础时钟，系统节拍配置为FreeRTOSConfig.h中的configTICK_RATE_HZ，默认是1000，那么系统的时钟节拍周期就为1ms
软件定时器是由操作系统提供的一类系统接口

注意：软件定时器回调函数的上下文是任务，回调函数要快进快出，且回调函数中不能有任何阻塞任务运行的情况，如vTaskDelay()以及其它能阻塞任务运行的函数。

1.2 软件定时器的两种工作模式

FreeRTOS提供的软件定时器支持单次模式和周期模式

单次模式：当用户创建了定时器并启动了定时器后，定时时间到了，只执行一次回调函数之后就将该定时器删除，不再重新执行。
周期模式：这个定时器会按照设置的定时时间循环执行回调函数，直到用户将定时器删除

软件定时器工作原理

通过查看FreeRTOS的源码，可以发现，软件定时器的运行原理实际是FreeRTOS 通过一个 prvTimerTask任务（也叫守护任务Daemon）管理软定时器，它是在启动调度器时自动创建的。另外，软件定时器在FreeRTOS中是可选功能，如果需要使用软件定时器，需要设置 FreeRTOSConfig.h 中的宏定义configUSE_TIMERS为1 。

先用一个图来表示整个创建过程：

下面来看一下启动调度器时是怎么创建Daemon任务的。

2.1 任务调度器函数创建Daemon任务

main函数的最后会启动FreeRTOS的任务调度函数，在该函数中会创建软件定时器任务（即Daemon守护任务），并且可以看到是通过宏定义的方式选择编译：

/* 启动调度器 */ 
void vTaskStartScheduler( void )
{
    ...略去部分代码
    #if ( configUSE_TIMERS == 1 )
    {
        if( xReturn == pdPASS )
        {
            /* 创建软件定时器任务（守护任务） */
            xReturn = xTimerCreateTimerTask();
        }
        else
        {
            mtCOVERAGE_TEST_MARKER();
        }
    }
    #endif /* configUSE_TIMERS */
    ...略去部分代码
 }

xTimerCreateTimerTask()只是一个函数名，它内部的函数内容如下。

2.2 创建Daemon任务

软件定时器任务（Daemon任务）的创建是通过xTaskCreate方法来创建，在创建守护任务之前，还要先通过prvCheckForValidListAndQueue函数创建两个列表和一个消息队列：

BaseType_t xTimerCreateTimerTask( void )
{
    BaseType_t xReturn = pdFAIL;

    /* 创建列表与消息队列 */
    prvCheckForValidListAndQueue();

    if( xTimerQueue != NULL )
{
        #if( configSUPPORT_STATIC_ALLOCATION == 1 )
        ...略去部分代码
        #else
        {
            /* 创建软件定时器任务（守护任务） */
            xReturn = xTaskCreate(  prvTimerTask,
                                    "Tmr Svc",
                                    configTIMER_TASK_STACK_DEPTH,
                                    NULL,
                                    ( ( UBaseType_t ) configTIMER_TASK_PRIORITY ) | portPRIVILEGE_BIT,
                                    &xTimerTaskHandle );
        }
        #endif /* configSUPPORT_STATIC_ALLOCATION */
}
    else
{
        mtCOVERAGE_TEST_MARKER();
}

    configASSERT( xReturn );
    return xReturn;
}

创建列表与消息队列的具体函数内容如下：

2.3 创建列表与消息队列

由于系统节拍采用32位变量进行计数，总有一天会溢出，所以软件定时器使用了两个列表：

当前定时器列表pxCurrentTimerList ：系统新创建并激活的定时器都会以超时时间升序的方式插入到pxCurrentTimerList列表中。系统在定时器任务中扫描pxCurrentTimerList中的第一个定时器，看是否已超时，若已经超时了则调用软件定时器回调函数，否则将定时器任务挂起。
溢出定时器列表pxOverflowTimerList：在软件定时器溢出的时候使用，作用与pxCurrentTimerList一致。

定时器列表会按照唤醒时间从早到晚挂接在当前定时器列表中，唤醒时间如果溢出了就挂接在溢出定时器列表中。当系统节拍溢出之后，两个列表的功能会进行交换，即当前列表变为溢出列表，溢出列表变为当前列表。

此外，FreeRTOS的软件定时器还使用了一个消息队列xTimerQueue，利用“定时器命令队列”向软件定时器任务发送一些命令，任务在接收到命令就会去处理命令对应的程序，比如启动定时器，停止定时器，复位、删除、改变周期等。

假如定时器任务处于阻塞状态，我们又需要马上再添加一个软件定时器的话，就是采用这种消息队列命令的方式进行添加，才能唤醒处于等待状态的定时器任务，并且在任务中将新添加的软件定时器添加到软件定时器列表中

（注：事件标志组在中断中设置事件标志，实际也是通过队列发送消息给软件定时器任务来执行）

/* 检查是否有可用的列表和队列 */
static void prvCheckForValidListAndQueue( void )
{
    /* 进入临界区 */
    taskENTER_CRITICAL();
{
        /* 还没有创建队列 */
        if( xTimerQueue == NULL )
        {           
            /* 初始化定时器列表1 */
            vListInitialise( &xActiveTimerList1 );
            /* 初始化定时器列表2 */
            vListInitialise( &xActiveTimerList2 );
            /* 当前定时器列表 */
            pxCurrentTimerList = &xActiveTimerList1;
            /* 溢出定时器列表 */
            pxOverflowTimerList = &xActiveTimerList2;

            #if( configSUPPORT_STATIC_ALLOCATION == 1 )
            ...略去部分代码
            #else
            {
                /* 创建定时器消息队列 */
                xTimerQueue = xQueueCreate( ( UBaseType_t ) configTIMER_QUEUE_LENGTH, sizeof( DaemonTaskMessage_t ) );
            }
            #endif

            #if ( configQUEUE_REGISTRY_SIZE > 0 )
            {
                if( xTimerQueue != NULL )
                {
                    vQueueAddToRegistry( xTimerQueue, "TmrQ" );
                }
                else
                {
                    mtCOVERAGE_TEST_MARKER();
                }
            }
            #endif /* configQUEUE_REGISTRY_SIZE */
        }
        else
        {
            mtCOVERAGE_TEST_MARKER();
        }
}
    taskEXIT_CRITICAL();
}

既然消息队列是用来处理软件定时器的一些操作指令的，那这些在哪里呢？其实就是软件定时器的一些API函数，如下。

2.4 软件定时器API函数实际原理

软件定时器的多种API函数，如启动、停止、删除、复位、改变周期等，实际是通过宏定义的方式提供：

/*启动定时器*/
#define xTimerStart(xTimer, xTicksToWait) xTimerGenericCommand((xTimer), tmrCOMMAND_START, (xTaskGetTickCount()), NULL, (xTicksToWait))

/*停止定时器*/
#define xTimerStop(xTimer, xTicksToWait) xTimerGenericCommand((xTimer), tmrCOMMAND_STOP, 0U, NULL, (xTicksToWait))

/*改变定时器周期*/
#define xTimerChangePeriod(xTimer, xNewPeriod, xTicksToWait) xTimerGenericCommand((xTimer), tmrCOMMAND_CHANGE_PERIOD, (xNewPeriod), NULL, (xTicksToWait))

/*删除定时器*/
#define xTimerDelete(xTimer, xTicksToWait) xTimerGenericCommand((xTimer), tmrCOMMAND_DELETE, 0U, NULL, (xTicksToWait))

/*复位定时器*/
#define xTimerReset(xTimer, xTicksToWait) xTimerGenericCommand((xTimer), tmrCOMMAND_RESET, (xTaskGetTickCount()), NULL, (xTicksToWait))

/*从中断中启动定时器*/
#define xTimerStartFromISR(xTimer, pxHigherPriorityTaskWoken) xTimerGenericCommand((xTimer), tmrCOMMAND_START_FROM_ISR, (xTaskGetTickCountFromISR()), (pxHigherPriorityTaskWoken), 0U)

/*从中断中停止定时器*/
#define xTimerStopFromISR(xTimer, pxHigherPriorityTaskWoken) xTimerGenericCommand((xTimer), tmrCOMMAND_STOP_FROM_ISR, 0, (pxHigherPriorityTaskWoken), 0U)

/*从中断中改变定时器周期*/
#define xTimerChangePeriodFromISR(xTimer, xNewPeriod, pxHigherPriorityTaskWoken) xTimerGenericCommand((xTimer), tmrCOMMAND_CHANGE_PERIOD_FROM_ISR, (xNewPeriod), (pxHigherPriorityTaskWoken), 0U)

/*从中断中复位定时器*/
#define xTimerResetFromISR(xTimer, pxHigherPriorityTaskWoken) xTimerGenericCommand((xTimer), tmrCOMMAND_RESET_FROM_ISR, (xTaskGetTickCountFromISR()), (pxHigherPriorityTaskWoken), 0U)

这些API函数对应的宏定义，本质上又都是调用了xTimerGenericCommand函数来实现对消息的打包和发送。

2.5 软件定时器打包命令与发送

该函数将命令打包成队列项发送给xTimerQueue消息队列，由软件定时器任务（守护任务来）接收并进行处理。

/* 软件定时器打包命令与发送 */
BaseType_t xTimerGenericCommand( TimerHandle_t xTimer, const BaseType_t xCommandID, const TickType_t xOptionalValue, BaseType_t * const pxHigherPriorityTaskWoken, const TickType_t xTicksToWait )
{
    BaseType_t xReturn = pdFAIL;
    DaemonTaskMessage_t xMessage;

    configASSERT( xTimer );

    if( xTimerQueue != NULL )
{
        /* 命令码 */
        xMessage.xMessageID = xCommandID;
        /* 命令有效值 */
        xMessage.u.xTimerParameters.xMessageValue = xOptionalValue;
        /* 定时器句柄 */
        xMessage.u.xTimerParameters.pxTimer = xTimer;
 
        /* 不带中断命令 */
        if(xCommandID < tmrFIRST_FROM_ISR_COMMAND)
        {
            /* 调度器正在运行 */
            if(xTaskGetSchedulerState() == taskSCHEDULER_RUNNING)
            {
                /* 将命令消息发送到队列，可以阻塞一定时间 */
                xReturn = xQueueSendToBack(xTimerQueue, &xMessage, xTicksToWait);
            }
            /* 调度器不在运行 */
            else
            {
                /* 将命令消息发送到队列 ，不带阻塞时间*/
                xReturn = xQueueSendToBack(xTimerQueue, &xMessage, tmrNO_DELAY);
            }
        }
        /* 带中断命令 */
        else
        {
            /* 将命令消息发送到队列 */
            xReturn = xQueueSendToBackFromISR(xTimerQueue, &xMessage, pxHigherPriorityTaskWoken);
        }

        traceTIMER_COMMAND_SEND( xTimer, xCommandID, xOptionalValue, xReturn );
}
    else
{
        mtCOVERAGE_TEST_MARKER();
}

    return xReturn;
}

上面分析的差不多了，现在回到重点，回顾2.2的xTimerCreateTimerTask()函数，在创建列表与消息队列后，会使用xTaskCreate方法来创建软件定时器任务prvTimerTask()，该任务实体的具体内容如下：

2.6 软件定时器任务基本功能（三部分）

软件定时器任务的具体内容可分为三部分：

获取最近一次定时器超时时间
处理超时的定时器或者让队列阻塞
处理队列接收到的命令

三部分不断循环处理实现Daemon任务。

static void prvTimerTask( void *pvParameters )
{
TickType_t xNextExpireTime;
BaseType_t xListWasEmpty;

    /* Just to avoid compiler warnings. */
    ( void ) pvParameters;

    #if( configUSE_DAEMON_TASK_STARTUP_HOOK == 1 )
    ...略去部分代码
    #endif /* configUSE_DAEMON_TASK_STARTUP_HOOK */

    for( ;; )
{
        /* 获取最近一次定时器超时时间 */
        xNextExpireTime = prvGetNextExpireTime(&xListWasEmpty);
 
        /* 处理超时的定时器或者让队列阻塞 */
        prvProcessTimerOrBlockTask(xNextExpireTime, xListWasEmpty);
 
        /* 处理队列接收到的命令 */
        prvProcessReceivedCommands();
}
}

以上介绍了从启动调度器到实现Daemon任务的具体过程，下面来详细分析Daemon任务中的三部分功能的细节。

软件定时器任务功能分析

先来一张整体结构图：

首先是从定时器列表中获取下一次的溢出时间，因为各定时器的溢出时间是按照升序排列的，因此只需获取下一次的溢出时间。

3.1 获取下一个定时超时时间

/* 获取下一次的定时器超时时间 */
static TickType_t prvGetNextExpireTime( BaseType_t * const pxListWasEmpty )
{
TickType_t xNextExpireTime;

    /* 判断当前定时器列表是否为空 */
    *pxListWasEmpty = listLIST_IS_EMPTY( pxCurrentTimerList );
    
    /* 当前列表非空 */
    if( *pxListWasEmpty == pdFALSE )
{
        /* 获取最近超时时间 */
        xNextExpireTime = listGET_ITEM_VALUE_OF_HEAD_ENTRY( pxCurrentTimerList );
}
    else /* 当前列表为空 */
{
        /*超时时间设为0，使任务非阻塞 */
        xNextExpireTime = ( TickType_t ) 0U;
}

    return xNextExpireTime;
}

3.2 处理或阻塞软件定时器任务

那系统如何处理软件定时器列表？系统在不断运行，而xTimeNow（xTickCount）随着SysTick的触发一直在增长，在软件定时器任务运行的时候会获取下一个要唤醒的定时器:

比较当前系统时间xTimeNow是否大于或等于下一个定时器唤醒时间xTicksToWait
若大于则表示已经超时，定时器任务将会调用对应定时器的回调函数
否则将软件定时器任务挂起，直至下一个要唤醒的软件定时器时间到来或者接收到命令消息

/* 处理或阻塞软件定时器任务 */
static void prvProcessTimerOrBlockTask( const TickType_t xNextExpireTime, BaseType_t xListWasEmpty )
{
    TickType_t xTimeNow;
    BaseType_t xTimerListsWereSwitched;

    /* 挂起调度器 */
    vTaskSuspendAll();
    {
        /* 获取当前时间，并判断是否需要切换定时器列表，如果需要则切换 */
        xTimeNow = prvSampleTimeNow( &xTimerListsWereSwitched );
        
        /* 定时器列表没有切换 */
        if( xTimerListsWereSwitched == pdFALSE )
        {
            /* 当前列表中有定时器，且下次唤醒时间小于当前时间，即超时了 */
            if( ( xListWasEmpty == pdFALSE ) && ( xNextExpireTime <= xTimeNow ) )
            {
                /* 解除调度器挂起 */
                ( void )xTaskResumeAll();
                /* 处理超时的定时器 */
                prvProcessExpiredTimer( xNextExpireTime, xTimeNow );
            }
            else/* 定时器列表为空，或者没有超时 */
            {
                /* 定时器列表为空 */
                if( xListWasEmpty != pdFALSE )
                {
                    /* 判断溢出列表是否为空，如果两个列表都为空，则无限期阻塞 */
                    xListWasEmpty = listLIST_IS_EMPTY( pxOverflowTimerList );
                }

                /* 定时器定时时间还没到，将当前任务挂起，让队列按照给定的时间进行阻塞 */
                vQueueWaitForMessageRestricted( xTimerQueue, ( xNextExpireTime - xTimeNow ), xListWasEmpty );
                /* 解除调度器挂起 */
                if( xTaskResumeAll() == pdFALSE )
                {
                    /* 申请切换任务 */
                    portYIELD_WITHIN_API();
                }
                else
                {
                    mtCOVERAGE_TEST_MARKER();
                }
            }
        }
        else
        {
            /* 解除调度器挂起 */
            ( void ) xTaskResumeAll();
        }
    }
}

3.2.1 获取当前时间并决定是否切换列表

static TickType_t prvSampleTimeNow( BaseType_t * const pxTimerListsWereSwitched )
{
    TickType_t xTimeNow;
    /*静态变量 记录上一次调用时系统节拍值*/
    PRIVILEGED_DATA static TickType_t xLastTime = ( TickType_t ) 0U; 
    /*获取本次调用节拍结束器值*/
    xTimeNow = xTaskGetTickCount();

    /*判断节拍计数器是否溢出过*/
    if( xTimeNow < xLastTime )
    {
        /*发生溢出，处理当前链表上所有定时器并切换管理链表*/
        prvSwitchTimerLists();
        *pxTimerListsWereSwitched = pdTRUE;
    }
    else
    {
        *pxTimerListsWereSwitched = pdFALSE;
    }
    /*更新时间记录*/
    xLastTime = xTimeNow;

    return xTimeNow;
}

可以看到，该函数每次调用都会记录当前系统节拍时间（TickCount），下一次调用，通过比较相邻两次调用的值判断节拍计数器是否溢出。当系统节拍计数器溢出，必须切换计时器列表。如果当前计时器列表中仍然引用任何计时器，那么它们一定已经过期，应该在切换列表之前进行处理。

切换列表的具体内容如下：

static void prvSwitchTimerLists( void )
{
    TickType_t xNextExpireTime, xReloadTime;
    List_t *pxTemp;
    Timer_t *pxTimer;
    BaseType_t xResult;

    /* 列表非空，循环处理，直至将该列表处理完 */
    while( listLIST_IS_EMPTY( pxCurrentTimerList ) == pdFALSE )
    {
        xNextExpireTime = listGET_ITEM_VALUE_OF_HEAD_ENTRY( pxCurrentTimerList );

        /* 从列表中移除软件定时器 */
        pxTimer = ( Timer_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxCurrentTimerList );
        ( void ) uxListRemove( &( pxTimer->xTimerListItem ) );
        traceTIMER_EXPIRED( pxTimer );

        /*执行回调函数*/
        pxTimer->pxCallbackFunction( ( TimerHandle_t ) pxTimer );

        /*对于周期定时器*/
        if( pxTimer->uxAutoReload == ( UBaseType_t ) pdTRUE )
        {
            /*计算重新加载值：下个溢出时间 + 定时周期*/
            xReloadTime = ( xNextExpireTime + pxTimer->xTimerPeriodInTicks );
            /*如果重新加载值>下个溢出时间，应该将计时器重新插入当前列表，以便在此循环中再次处理它*/
            if( xReloadTime > xNextExpireTime )
            {
                listSET_LIST_ITEM_VALUE( &( pxTimer->xTimerListItem ), xReloadTime );
                listSET_LIST_ITEM_OWNER( &( pxTimer->xTimerListItem ), pxTimer );
                vListInsert( pxCurrentTimerList, &( pxTimer->xTimerListItem ) );
            }
            else/*否则，应该发送一个命令来重新启动计时器，以确保它只插入到列表之后列表已被交换*/
            {
                xResult = xTimerGenericCommand( pxTimer, tmrCOMMAND_START_DONT_TRACE, xNextExpireTime, NULL, tmrNO_DELAY );
                configASSERT( xResult );
                ( void ) xResult;
            }
        }
        else
        {
            mtCOVERAGE_TEST_MARKER();
        }
    }

    pxTemp = pxCurrentTimerList;
    pxCurrentTimerList = pxOverflowTimerList;
    pxOverflowTimerList = pxTemp;
}

(切换列表这里还没完全弄明白)

下面来看一下如何处理到时（或超时）的定时器：

3.2.2 处理超时的定时器

/* 处理超时的定时器 */
static void prvProcessExpiredTimer( const TickType_t xNextExpireTime, const TickType_t xTimeNow )
{
    BaseType_t xResult;
    /* 获取最近的超时定时器 */
    Timer_t *const pxTimer = ( Timer_t * )listGET_OWNER_OF_HEAD_ENTRY( pxCurrentTimerList );
 
    /* 将最近的超时定时器从活跃列表中移除 */
    (void)uxListRemove( &( pxTimer->xTimerListItem ) );
    traceTIMER_EXPIRED(pxTimer);
 
    /* 周期定时 */
    if( pxTimer->uxAutoReload == ( UBaseType_t )pdTRUE )
    {
        /* 重新计算超时时间并加入活跃列表，如果下一次超时时间都已经过了 */
        if( prvInsertTimerInActiveList( pxTimer, ( xNextExpireTime + pxTimer->xTimerPeriodInTicks ), xTimeNow, xNextExpireTime ) != pdFALSE )
        {
            /* 通知守护任务来处理（将定时器插入活跃列表） */
            xResult = xTimerGenericCommand( pxTimer, tmrCOMMAND_START_DONT_TRACE, xNextExpireTime, NULL, tmrNO_DELAY );
            configASSERT( xResult );
            ( void )xResult;
        }
        else
        {
            mtCOVERAGE_TEST_MARKER();
        }
    }
    else
    {
        mtCOVERAGE_TEST_MARKER();
    }
 
    /* 调用回调函数 */
    pxTimer->pxCallbackFunction( ( TimerHandle_t )pxTimer );
}

3.2.3 让队列按照给定的时间进行阻塞

回顾prvProcessTimerOrBlockTask()函数，定时器定时时间还没到，将当前任务挂起，直到定时器到期才唤醒或者收到命令的时候唤醒：

/* 让队列按照给定的时间进行阻塞 */
void vQueueWaitForMessageRestricted( QueueHandle_t xQueue, TickType_t xTicksToWait, const BaseType_t xWaitIndefinitely )
{
    Queue_t *const pxQueue = xQueue;
 
    /* 锁定队列 */
    prvLockQueue( pxQueue );

    /* 队列为空 */
    if( pxQueue->uxMessagesWaiting == ( UBaseType_t )0U )
    {
        /* 将任务插入等待接收队列项而阻塞的事件列表，并加入延时列表进行阻塞延时 */
        vTaskPlaceOnEventListRestricted( &( pxQueue->xTasksWaitingToReceive ), xTicksToWait, xWaitIndefinitely );
    }
    /* 队列不为空 */
    else
    {
        mtCOVERAGE_TEST_MARKER();
    }
    /* 解锁队列 */
    prvUnlockQueue(pxQueue);
}

3.3 处理命令队列中接收的消息

用户将需要处理的定时器命令发送到定时器的消息队列， Daemon 任务每次执行期间回去读取并执行，下面看看该函数的具体内容：

/*处理命令队列中接收的消息*/
static void prvProcessReceivedCommands( void )
{
    DaemonTaskMessage_t xMessage;
    Timer_t *pxTimer;
    BaseType_t xTimerListsWereSwitched, xResult;
    TickType_t xTimeNow;

    /*消息队列接收*/
    while( xQueueReceive( xTimerQueue, &xMessage, tmrNO_DELAY ) != pdFAIL )
    {
        #if ( INCLUDE_xTimerPendFunctionCall == 1 )
        {
            /* 命令码小于等于0 (事件标志组中断中置位的命令)*/
            if( xMessage.xMessageID < ( BaseType_t ) 0 )
            {
                const CallbackParameters_t * const pxCallback = &( xMessage.u.xCallbackParameters );
                
                configASSERT( pxCallback );

                /* 执行回调函数 */
                pxCallback->pxCallbackFunction( pxCallback->pvParameter1, pxCallback->ulParameter2 );
            }
            else
            {
                mtCOVERAGE_TEST_MARKER();
            }
        }
        #endif /* INCLUDE_xTimerPendFunctionCall */

        /* 命令码大于等于0 (软件定时器命令)*/
        if( xMessage.xMessageID >= ( BaseType_t ) 0 )
        {
            /* 定时器句柄 */
            pxTimer = xMessage.u.xTimerParameters.pxTimer;

            /* 定时器队列项包含该定时器 */
            if( listIS_CONTAINED_WITHIN( NULL, &( pxTimer->xTimerListItem ) ) == pdFALSE )
            {
                /* 移除该定时器 */
                ( void ) uxListRemove( &( pxTimer->xTimerListItem ) );
            }
            else
            {
                mtCOVERAGE_TEST_MARKER();
            }

            traceTIMER_COMMAND_RECEIVED( pxTimer, xMessage.xMessageID, xMessage.u.xTimerParameters.xMessageValue );

            /* 获取当前时间，并判断是否需要切换定时器列表，如果需要则切换 */
            xTimeNow = prvSampleTimeNow( &xTimerListsWereSwitched );

            /* 消息类型 */
            switch( xMessage.xMessageID )
            {
                /* 定时器启动或者复位 */
                case tmrCOMMAND_START :
                case tmrCOMMAND_START_FROM_ISR :
                case tmrCOMMAND_RESET :
                case tmrCOMMAND_RESET_FROM_ISR :
                case tmrCOMMAND_START_DONT_TRACE :
                    /* 计算超时时间，超时时间没过加入活跃列表，超时时间已过返回pdTrue */
                    if( prvInsertTimerInActiveList( pxTimer,  xMessage.u.xTimerParameters.xMessageValue + pxTimer->xTimerPeriodInTicks, xTimeNow, xMessage.u.xTimerParameters.xMessageValue ) != pdFALSE )
                    {
                        /* 在加入列表前已经超时，执行对应的回调函数 */
                        pxTimer->pxCallbackFunction( ( TimerHandle_t ) pxTimer );
                        traceTIMER_EXPIRED( pxTimer );

                        /*如果是周期定时器*/
                        if( pxTimer->uxAutoReload == ( UBaseType_t ) pdTRUE )
                        {
                            /* 发送消息，通知守护任务将定时器插入当前列表 */
                            xResult = xTimerGenericCommand( pxTimer, tmrCOMMAND_START_DONT_TRACE, xMessage.u.xTimerParameters.xMessageValue + pxTimer->xTimerPeriodInTicks, NULL, tmrNO_DELAY );
                            configASSERT( xResult );
                            ( void ) xResult;
                        }
                        else
                        {
                            mtCOVERAGE_TEST_MARKER();
                        }
                    }
                    else
                    {
                        mtCOVERAGE_TEST_MARKER();
                    }
                    break;

                /* 停止定时器 */
                case tmrCOMMAND_STOP :
                case tmrCOMMAND_STOP_FROM_ISR :
                    /* 定时器已经从活跃列表中移除，所以什么都不做 */
                    break;

                /* 改变定时器周期 */
                case tmrCOMMAND_CHANGE_PERIOD :
                case tmrCOMMAND_CHANGE_PERIOD_FROM_ISR :
                    /* 取出新的频率 */
                    pxTimer->xTimerPeriodInTicks = xMessage.u.xTimerParameters.xMessageValue;
                    configASSERT( ( pxTimer->xTimerPeriodInTicks > 0 ) );

                    /* 计算超时时间，超时时间没过则加入活跃列表 */
                    ( void ) prvInsertTimerInActiveList( pxTimer, ( xTimeNow + pxTimer->xTimerPeriodInTicks ), xTimeNow, xTimeNow );
                    break;

                /* 删除定时器 */
                case tmrCOMMAND_DELETE :
                    #if( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 0 ) )
                    {
                        /* 释放软件定时器内存 */
                        vPortFree( pxTimer );
                    }
                    #elif( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )
                    {
                        if( pxTimer->ucStaticallyAllocated == ( uint8_t ) pdFALSE )
                        {
                            /* 释放软件定时器内存 */
                            vPortFree( pxTimer );
                        }
                        else
                        {
                            mtCOVERAGE_TEST_MARKER();
                        }
                    }
                    #endif /* configSUPPORT_DYNAMIC_ALLOCATION */
                    break;

                default :
                    /* Don't expect to get here. */
                    break;
            }
        }
    }
}

4软件定时器的使用

4.1 软件定时器控制块（结构体）

/* 软件定时器结构体 */
typedef struct tmrTimerControl
{
    const char *pcTimerName;            /* 定时器名字 */
    ListItem_t xTimerListItem;          /* 定时器列表项 */
    TickType_t xTimerPeriodInTicks;     /* 定时器定时时间 */
    UBaseType_t uxAutoReload;           /* 定时器周期模式 */
    void *pvTimerID;                    /* 定时器ID */
    TimerCallbackFunction_t pxCallbackFunction; /* 定时器回调函数 */
 
    #if (configUSE_TRACE_FACILITY == 1)
        UBaseType_t uxTimerNumber;
    #endif
 
    #if ((configSUPPORT_STATIC_ALLOCATION == 1) && (configSUPPORT_DYNAMIC_ALLOCATION == 1))
        uint8_t ucStaticallyAllocated; /*标记定时器使用的内存， 删除时判断是否需要释放内存*/
    #endif
}xTIMER;
typedef xTIMER Timer_t;

4.2 创建一个软件定时器

#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )
TimerHandle_t xTimerCreate( const char * const pcTimerName,        /* 定时器名字 */
                           const TickType_t xTimerPeriodInTicks,   /* 定时器定时时间 */
                           const UBaseType_t uxAutoReload,         /* 定时器周期模式 */
                           void * const pvTimerID,                 /* 定时器ID */
                           TimerCallbackFunction_t pxCallbackFunction ) /* 定时器回调函数 */
{
    Timer_t *pxNewTimer;

    /*为软件定时器申请内存*/
    pxNewTimer = ( Timer_t * ) pvPortMalloc( sizeof( Timer_t ) );

    if( pxNewTimer != NULL )
    {
        prvInitialiseNewTimer( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction, pxNewTimer );

        #if( configSUPPORT_STATIC_ALLOCATION == 1 )
        {
            /* 定时器可以静态创建，也可以动态创建，注意这个计时器是动态创建的，以防稍后删除计时器 */
            pxNewTimer->ucStaticallyAllocated = pdFALSE;
        }
        #endif /* configSUPPORT_STATIC_ALLOCATION */
    }

    return pxNewTimer;
}
#endif /* configSUPPORT_STATIC_ALLOCATION */

成功申请定时器后，定时器并没有开始工作，需要调用启动或复位等API函数将该定时器中的 xTimerListItem 插入到定时器管理链表中， Daemon 任务才能在该定时器设定的溢出时刻调用其回调函数。

4.3 启动定时器

当用户创建并启动一个软件定时器时， FreeRTOS会根据当前系统时间及用户设置的定时确定该定时器唤醒时间，并将该定时器控制块挂入软件定时器列表

下面来看一下当启动多个软件定时器时，软件定时器列表是如何来管理这些定时器的：

例如：系统当前时间xTimeNow值为0，注意：xTimeNow其实是一个局部变量，是根据xTaskGetTickCount()函数获取的，实际它的值就是全局变量xTickCount的值，表示当前系统时间。

4.3.1 例子1

在当前系统中已经创建并启动了1个定时时间为200定时器Timer1
当系统时间xTimeNow为20的时候，用户创建并且启动一个定时时间为100的定时器Timer2，此时Timer2的溢出时间xTicksToWait就为定时时间+系统当前时间（100+20=120），然后将Timer2按xTicksToWait升序插入软件定时器列表中
当系统时间xTimeNow为40的时候，用户创建并且启动了一个定时时间为50的定时器Timer3，那么此时Timer3的溢出时间xTicksToWait就为40+50=90，同样安装xTicksToWait的数值升序插入软件定时器列表中

4.3.2 例子2

创建并且启动在已有的两个定时器中间的定时器也是一样的:

创建定Timer1并且启动后，假如系统经过了50个tick， xTimeNow从0增长到50，与Timer1的xTicksToWait值相等，这时会触发与Timer1对应的回调函数，从而转到回调函数中执行用户代码，同时将Timer1从软件定时器列表删除，如果软件定时器是周期性的，那么系统会根据Timer1下一次唤醒时间重新将Timer1添加到软件定时器列表中，按照xTicksToWait的升序进行排列。
同理，在xTimeNow=40的时候创建的Timer3，在经过130个tick后（此时系统时间xTimeNow是40，130个tick就是系统时间xTimeNow为170的时候），与Timer3定时器对应的回调函数会被触发，接着将Timer3从软件定时器列表中删除，如果是周期性的定时器，还会按照xTicksToWait升序重新添加到软件定时器列表中。

总结与注意事项

编译定时器相关代码，如需要使用定时器，需要先在 FreeRTOSConfig.h 中正确配置宏 configUSE_TIMERS为 1
软件定时器使用了系统的一个队列和一个任务资源，软件定时器任务的优先级默认为configTIMER_TASK_PRIORITY，如果优先级太低，可能导致定时器无法及时执行，所以为了更好响应，该优先级应设置为所有任务中最高的优先级。
定时器任务的消息队列深度为configTIMER_QUEUE_LENGTH，设置定时器都是通过发送消息到该队列实现的
定时器任务的堆栈大小默认为configTIMER_TASK_STACK_DEPTH个字节。
软件定时器的回调函数中应快进快出，绝对不允许使用任何可能引软件定时器起任务挂起或者阻塞的API接口，在回调函数中也绝对不允许出现死循环。
创建单次软件定时器，该定时器超时执行完回调函数后，系统会自动删除该软件定时器，并回收资源。