13、软件定时器

1、软件定时器的基本概念

　　定时器，是指从指定的时刻开始，经过一个指定时间，然后触发一个超时事件，用户可以自定义定时器的周期与频率。

　　定时器有硬件定时器和软件定时器之分：

　　硬件定时器是芯片本身提供的定时功能。一般是由外部晶振提供给芯片输入时钟，芯片向软件模块提供一组配置寄存器，接受控制输入，到达设定时间值后芯片中断控制器产生时钟中断。硬件定时器的精度一般很高，可以达到纳秒级别，并且是中断触发方式。

　　软件定时器，软件定时器是由操作系统提供的一类系统接口，它构建在硬件定时器基础之上，使系统能够提供不受硬件定时器资源限制的定时器服务，它实现的功能与硬件定时器也是类似的。

　　使用硬件定时器时，每次在定时时间到达之后就会自动触发一个中断，用户在中断中处理信息；而使用软件定时器时，需要我们在创建软件定时器的时候指定时间到达后要去调用的函数（也称超时函数/回调函数，为了统一，下文均用回调函数描述），在回调函数中处理信息。

　　注意：软件定时器回调函数的上下文是任务， 下文所说的定时器均为软件定时器。

　　软件定时器在被创建之后，当经过设定的时钟计数值后会触发用户定义的回调函数。

　　定时精度与系统时钟的周期有关。一般系统利用 SysTick 作为软件定时器的基础时钟， 软件定时器的回调函数类似硬件的中断服务函数，所以， 回调函数也要快进快出，而且回调函数中不能有任何阻塞任务运行的情况（软件定时器回调函数的上下文环境是任务） ，比如 vTaskDelay()以及其它能阻塞任务运行的函数 ，两次触发回调函数的时间间隔xTimerPeriodInTicks 叫定时器的定时周期。

　　FreeRTOS 操作系统提供软件定时器功能，软件定时器的使用相当于扩展了定时器的数量，允许创建更多的定时业务。 FreeRTOS 软件定时器功能上支持：

• 裁剪：能通过宏关闭软件定时器功能。
• 软件定时器创建。
• 软件定时器启动。
• 软件定时器停止。
• 软件定时器复位。
• 软件定时器删除。

　　FreeRTOS 提供的软件定时器支持单次模式和周期模式， 单次模式和周期模式的定时时间到之后都会调用软件定时器的回调函数，用户可以在回调函数中加入要执行的工程代码。

　　单次模式：当用户创建了定时器并启动了定时器后，定时时间到了，只执行一次回调函数之后就将该定时器删除，不再重新执行。

　　周期模式：这个定时器会按照设置的定时时间循环执行回调函数，直到用户将定时器删除，具体见下图：

　　FreeRTOS 通过一个 prvTimerTask 任务（也叫守护任务 Daemon）管理软定时器，它是在启动调度器时自动创建的， 为了满足用户定时需求。 prvTimerTask 任务会在其执行期间检查用户启动的时间周期溢出的定时器，并调用其回调函数。只有设置 FreeRTOSConfig.h中的宏定义 configUSE_TIMERS 设置为 1 ，将相关代码编译进来，才能正常使用软件定时器相关功能。

2、 软件定时器应用场景

　　在很多应用中，我们需要一些定时器任务，硬件定时器受硬件的限制，数量上不足以满足用户的实际需求，无法提供更多的定时器，那么可以采用软件定时器来完成，由软件定时器代替硬件定时器任务。

　　但需要注意的是软件定时器的精度是无法和硬件定时器相比的，因为在软件定时器的定时过程中是极有可能被其它中断所打断，因为软件定时器的执行上下文环境是任务。所以，软件定时器更适用于对时间精度要求不高的任务，一些辅助型的任务。

3、 软件定时器的精度

　　在操作系统中，通常软件定时器以系统节拍周期为计时单位。系统节拍是系统的心跳节拍，表示系统时钟的频率，就类似人的心跳， 1s 能跳动多少下，系统节拍配置为configTICK_RATE_HZ，该宏在 FreeRTOSConfig.h 中有定义，默认是 1000。那么系统的时钟节拍周期就为 1ms（1s 跳动 1000 下，每一下就为 1ms）。软件定时器的所定时数值必须是这个节拍周期的整数倍，例如节拍周期是 10ms，那么上层软件定时器定时数值只能是10ms， 20ms， 100ms 等，而不能取值为 15ms。由于节拍定义了系统中定时器能够分辨的精确度，系统可以根据实际系统 CPU 的处理能力和实时性需求设置合适的数值，系统节拍周期的值越小，精度越高，但是系统开销也将越大，因为这代表在 1 秒中系统进入时钟中断的次数也就越多。

4、 软件定时器的运作机制

　　软件定时器是可选的系统资源，在创建定时器的时候会分配一块内存空间。当用户创建并启动一个软件定时器时， FreeRTOS 会根据当前系统时间及用户设置的定时确定该定时器唤醒时间，并将该定时器控制块挂入软件定时器列表， FreeRTOS 中采用两个定时器列表维护软件定时器， pxCurrentTimerList 与 pxOverflowTimerList 是列表指针， 在初始化的时候分别指向 xActiveTimerList1 与 xActiveTimerList2，具体见下面代码清单。

//软件定时器用到的列表 
PRIVILEGED_DATA static List_t xActiveTimerList1;
PRIVILEGED_DATA static List_t xActiveTimerList2;
PRIVILEGED_DATA static List_t *pxCurrentTimerList;
PRIVILEGED_DATA static List_t *pxOverflowTimerList;

　　pxCurrentTimerList： 系统新创建并激活的定时器都会以超时时间升序的方式插入到pxCurrentTimerList 列表中。系统在定时器任务中扫描 pxCurrentTimerList 中的第一个定时器，看是否已超时，若已经超时了则调用软件定时器回调函数。否则将定时器任务挂起，因为定时时间是升序插入软件定时器列表的，列表中第一个定时器的定时时间都还没到的话，那后面的定时器定时时间自然没到。

　　pxOverflowTimerList 列表是在软件定时器溢出的时候使用， 作用与 pxCurrentTimerList一致。

　　同时， FreeRTOS 的软件定时器还有采用消息队列进行通信， 利用“定时器命令队列”向软件定时器任务发送一些命令，任务在接收到命令就会去处理命令对应的程序，比如启动定时器，停止定时器等。假如定时器任务处于阻塞状态，我们又需要马上再添加一个软件定时器的话，就是采用这种消息队列命令的方式进行添加，才能唤醒处于等待状态的定时器任务，并且在任务中将新添加的软件定时器添加到软件定时器列表中，所以，在定时器启动函数中， FreeRTOS 是采用队列的方式发送一个消息给软件定时器任务，任务被唤醒从而执行接收到的命令。

　　例如：系统当前时间 xTimeNow 值为 0，注意： xTimeNow 其实是一个局部变量， 是根据 xTaskGetTickCount()函数获取的，实际它的值就是全局变量 xTickCount 的值，下文都采用它表示当前系统时间。 在当前系统中已经创建并启动了 1 个定时器 Timer1；系统继续运行，当系统的时间 xTimeNow 为 20 的时候，用户创建并且启动一个定时时间为 100 的定时器 Timer2 ， 此时 Timer2 的溢出时 间 xTicksToWait 就为定 时时间 +系统当前时间（100+20=120），然后将 Timer2 按 xTicksToWait 升序插入软件定时器列表中；假设当前系统时间 xTimeNow 为 40 的时候，用户创建并且启动了一个定时时间为 50 的定时器Timer3 ，那么此时Timer3 的 溢 出 时 间 xTicksToWait 就 为 40+50=90 ， 同 样 安 装xTicksToWait 的数值升序插入软件定时器列表中，在定时器链表中插入过程具体见下图。同理创建并且启动在已有的两个定时器中间的定时器也是一样的，具体见下图：

 

　　那么系统如何处理软件定时器列表？系统在不断运行，而 xTimeNow（ xTickCount）随着 SysTick 的触发一直在增长（每一次硬件定时器中断来临， xTimeNow 变量会加 1），在软件定时器任务运行的时候会获取下一个要唤醒的定时器，比较当前系统时间xTimeNow 是否大于或等于下一个定时器唤醒时间 xTicksToWait，若大于则表示已经超时，定时器任务将会调用对应定时器的回调函数，否则将软件定时器任务挂起，直至下一个要唤醒的软件定时器时间到来或者接收到命令消息。以上图为例，讲解软件定时器调用回调函数的过程，在创建定 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 升序重新添加到软件定时器列表中。

　　使用软件定时器时候要注意以下几点：

• 软件定时器的回调函数中应快进快出，绝对不允许使用任何可能引软件定时器起任务挂起或者阻塞的 API 接口，在回调函数中也绝对不允许出现死循环。
• 软件定时器使用了系统的一个队列和一个任务资源，软件定时器任务的优先级默认为 configTIMER_TASK_PRIORITY，为了更好响应，该优先级应设置为所有任务中最高的优先级。
• 创建单次软件定时器，该定时器超时执行完回调函数后，系统会自动删除该软件定时器，并回收资源。
• 定时器任务的堆栈大小默认为 configTIMER_TASK_STACK_DEPTH 个字节。

5、 软件定时器控制块

　　软件定时器虽然不属于内核资源，但是也是 FreeRTOS 核心组成部分，是一个可以裁剪的功能模块，同样在系统中由一个控制块管理其相关信息，具体见下面代码清单。

//软件定时器控制块
typedef struct tmrTimerControl 
{
　　const char *pcTimerName; (1)
　　ListItem_t xTimerListItem; (2)
　　TickType_t xTimerPeriodInTicks; (3)
　　UBaseType_t uxAutoReload; (4)
　　void *pvTimerID; (5)
　　TimerCallbackFunction_t pxCallbackFunction; (6)

　　#if( configUSE_TRACE_FACILITY == 1 )
　　    UBaseType_t uxTimerNumber;
　　#endif

　　#if( ( configSUPPORT_STATIC_ALLOCATION == 1 )&& ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
　　　　uint8_t ucStaticallyAllocated; (7) 
　　#endif 
} xTIMER;

typedef xTIMER Timer_t; 

代码清单 21-2(1)：软件定时器名字，这个名字一般用于调试的， RTOS 使用定时器是通过其句柄，并不是使用其名字。
代码清单 21-2(2)：软件定时器列表项，用于插入定时器列表。
代码清单 21-2(3)： 软件定时器的周期， 单位为系统节拍周期 （即 tick） ，pdMS_TO_TICKS()可以把时间单位从 ms 转换为系统节拍周期。
代码清单 21-2(4)： 软件定时器是否自动重置， 如果该值为 pdFalse，那么创建的软件定时器工作模式是单次模式，否则为周期模式。
代码清单 21-2(5)： 软件定时器 ID， 数字形式。 该 ID 典型的用法是当一个回调函数分配给一个或者多个软件定时器时，在回调函数里面根据 ID 号来处理不同的软件定时器。
代码清单 21-2(6)： 软件定时器的回调函数， 当定时时间到达的时候就会调用这个函数。
代码清单 21-2(7)： 标记定时器使用的内存，删除时判断是否需要释放内存。

6、 软件定时器函数接口讲解

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

　　6.1 软件定时器创建函数 xTimerCreate()

　　软件定时器与 FreeRTOS 内核其他资源一样，需要创建才允许使用的， FreeRTOS 为我们提供了两种创建方式，一种是动态创建软件定时器 xTimerCreate()， 另一种是静态创建方式 xTimerCreateStatic()，因为创建过程基本差不多，所以在这里我们只讲解动态创建方式。

　　xTimerCreate()用于创建一个软件定时器，并返回一个句柄。 要想使用该函数函数必须在 头 文 件 FreeRTOSConfig.h 中 把 宏 configUSE_TIMERS 和configSUPPORT_DYNAMIC_ALLOCATION 均 定 义 为 1（configSUPPORT_DYNAMIC_ALLOCATION 在 FreeRTOS.h 中默认定义为 1）， 并且需要把 FreeRTOS/source/times.c 这个 C 文件添加到工程中。

　　每一个软件定时器只需要很少的 RAM 空间来保存其的状态。如果使用函数xTimeCreate()来创建一个软件定时器，那么需要的 RAM 是动态分配的。 如果使用函数xTimeCreateStatic()来创建一个事件组，那么需要的 RAM 是静态分配的软件定时器在创建成功后是处于休眠状态的， 可以使用 xTimerStart()、 xTimerReset()、xTimerStartFromISR() 、 xTimerResetFromISR() 、 xTimerChangePeriod() 和xTimerChangePeriodFromISR()这些函数将其状态转换为活跃态。

//xTimerCreate()源码

#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )

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 ) (5)
{
    Timer_t *pxNewTimer;

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

    if ( pxNewTimer != NULL ) 
    {
        /* 内存申请成功，进行初始化软件定时器 */
        prvInitialiseNewTimer( pcTimerName,
        xTimerPeriodInTicks,
        uxAutoReload,
        pvTimerID,
        pxCallbackFunction,
        pxNewTimer ); (7)

        #if( configSUPPORT_STATIC_ALLOCATION == 1 )
        {
            pxNewTimer->ucStaticallyAllocated = pdFALSE;
        }
        #endif
    }

    return pxNewTimer;
}

代码清单 21-3(1)：软件定时器名字， 文本形式，纯粹是为了调试， FreeRTOS 使用定时器是通过其句柄， 而不是使用其名字。
代码清单 21-3(2)：软件定时器的周期，单位为系统节拍周期（即 tick）。 使用pdMS_TO_TICKS()可以把时间单位从 ms 转换为系统节拍周期。 如果软件定时器的周期为100 个 tick， 那么只需要简单的设置 xTimerPeriod 的值为 100 即可。如果软件定时器的周期为 500ms， 那么 xTimerPeriod 应设置为 pdMS_TO_TICKS(500)。 宏 pdMS_TO_TICKS()只有当 configTICK_RATE_HZ 配置成小于或者等于 1000HZ 时才可以使用。
代码清单 21-3(3)： 如果 uxAutoReload 设置为 pdTRUE， 那么软件定时器的工作模式就 是 周 期 模 式 ， 一 直 会 以 用 户 指 定 的 xTimerPeriod 周 期 去 执 行 回 调 函 数 。 如 果uxAutoReload 设置为 pdFALSE， 那么软件定时器就在用户指定的 xTimerPeriod 周期下运行一次后就进入休眠态。
代码清单 21-3(4)： 软件定时器 ID， 数字形式。 该 ID 典型的用法是当一个回调函数分配给一个或者多个软件定时器时，在回调函数里面根据 ID 号来处理不同的软件定时器。
代码清单 21-3(5)： 软件定时器的回调函数， 当定时时间到达的时候就会调用这个函数， 该函数需要用户自己实现。
代码清单 21-3(6)： 为这个软件定时器申请一块内存，大小为软件定时器控制块大小，用于保存该定时器的基本信息。
代码清单 21-3(7)： 调用 prvInitialiseNewTimer()函数初始化一个新的软件定时器，该函数的源码具体见代码清单 21-4(3)： 。

//prvInitialiseNewTimer()源码
static void prvInitialiseNewTimer(const char * const pcTimerName,
const TickType_t xTimerPeriodInTicks,
const UBaseType_t uxAutoReload,
void * const pvTimerID,
TimerCallbackFunction_t pxCallbackFunction,
Timer_t *pxNewTimer )
{
    /* 断言，判断定时器的周期是否大于 0 */
    configASSERT( ( xTimerPeriodInTicks > 0 ) ); (1)

    if ( pxNewTimer != NULL ) 
    {
        /* 初始化软件定时器列表与创建软件定时器消息队列 */
        prvCheckForValidListAndQueue(); (2)

        /* 初始化软件定时信息，这些信息保存在软件定时器控制块中 */ (3)
        pxNewTimer->pcTimerName = pcTimerName;
        pxNewTimer->xTimerPeriodInTicks = xTimerPeriodInTicks;
        pxNewTimer->uxAutoReload = uxAutoReload;
        pxNewTimer->pvTimerID = pvTimerID;
        pxNewTimer->pxCallbackFunction = pxCallbackFunction;
        vListInitialiseItem( &( pxNewTimer->xTimerListItem ) ); (4)
        traceTIMER_CREATE( pxNewTimer );
    }
}

代码清单 21-4(1)： 断言，判断软件定时器的周期是否大于 0，否则的话其他任务是没办法执行的，因为系统会一直执行软件定时器回调函数。
代码清单 21-4(2)：在 prvCheckForValidListAndQueue()函数中系统将初始化软件定时器列表与创建软件定时器消息队列，也叫“定时器命令队列” ，因为在使用软件定时器的时候，用户是无法直接控制软件定时器的，必须通过“ 定时器命令队列”向软件定时器发送一个命令，软件定时器任务被唤醒就去执行对应的命令操作。
代码清单 21-4(3)： 初始化软件定时基本信息，如定时器名称、回调周期、 定时器 ID与定时器回调函数等，这些信息保存在软件定时器控制块中， 在操作软件定时器的时候，就需要用到这些信息。
代码清单 21-4(4)： 初始化定时器列表项。
软件定时器的创建很简单，需要用户根据自己需求指定相关信息即可，下面来看看xTimerCreate()函数使用实例，具体见代码清单 21-5 加粗部分。

//xTimerCreate()使用实例
static TimerHandle_t Swtmr1_Handle = NULL; /* 软件定时器句柄 */
static TimerHandle_t Swtmr2_Handle = NULL; /* 软件定时器句柄 */

//周期模式的软件定时器 1,定时器周期 1000(tick)
Swtmr1_Handle = xTimerCreate((const char*)"AutoReloadTimer",
(TickType_t)1000,/* 定时器周期 1000(tick) */
(UBaseType_t)pdTRUE,/* 周期模式 */
(void* )1,/* 为每个计时器分配一个索引的唯一 ID */
(TimerCallbackFunction_t)Swtmr1_Callback); /* 回调函数 */

if (Swtmr1_Handle != NULL)
{
　　/********************************************************************
　　* xTicksToWait:如果在调用 xTimerStart()时队列已满，则以 tick 为单位指定调用任务应保持
　　* 在 Blocked(阻塞)状态以等待 start 命令成功发送到 timer 命令队列的时间。
　　* 如果在启动调度程序之前调用 xTimerStart()，则忽略 xTicksToWait。在这里设置等待时间为 0.
　　**********************************************************************/
　　xTimerStart(Swtmr1_Handle,0); //开启周期定时器
}

//单次模式的软件定时器 2,定时器周期 5000(tick)
Swtmr2_Handle = xTimerCreate( (const char* )"OneShotTimer",
(TickType_t)5000,/* 定时器周期 5000(tick) */
(UBaseType_t )pdFALSE,/* 单次模式 */
(void*)2,/* 为每个计时器分配一个索引的唯一 ID */
(TimerCallbackFunction_t)Swtmr2_Callback);

if (Swtmr2_Handle != NULL)
{
　　xTimerStart(Swtmr2_Handle,0); //开启单次定时器
}

static void Swtmr1_Callback(void* parameter)
{
　　/* 软件定时器的回调函数，用户自己实现 */
}

static void Swtmr2_Callback(void* parameter)
{
　　/* 软件定时器的回调函数，用户自己实现 */
}

　　6.2 、软件定时器启动函数

　　（1）、xTimerStart()

　　软件定时器在创建完成的时候是处于休眠状态的，需要用 FreeRTOS 的相关函数将软件定时器活动起来，而 xTimerStart()函数就是可以让处于休眠的定时器开始工作。

　　我们知道，在系统开始运行的时候，系统会帮我们自动创建一个软件定时器任务（ prvTimerTask），在这个任务中，如果暂时没有运行中的定时器，任务会进入阻塞态等待命令， 而我们的启动函数就是通过“定时器命令队列” 向定时器任务发送一个启动命令，定时器任务获得命令就解除阻塞，然后执行启动软件定时器命令。 下面来看看 xTimerStart()是怎么让定时器工作的吧。

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

代码清单 21-6(1)：要操作的软件定时器句柄。xTimerStart()函数就是一个宏定义，真正起作用的是 xTimerGenericCommand()函数。
代码清单 21-6(2)： tmrCOMMAND_START 是软件定时器启动命令，因为现在是要将软件定时器启动，该命令在 timers.h 中有定义。 xCommandID 参数可以指定多个命令，软件定时器操作支持的命令具体见代码清单 21-7。
//软件定时器支持的命令
#define tmrCOMMAND_EXECUTE_CALLBACK_FROM_ISR ( ( BaseType_t ) -2 )
#define tmrCOMMAND_EXECUTE_CALLBACK ( ( BaseType_t ) -1 )
#define tmrCOMMAND_START_DONT_TRACE ( ( BaseType_t ) 0 )
#define tmrCOMMAND_START ( ( BaseType_t ) 1 )
#define tmrCOMMAND_RESET ( ( BaseType_t ) 2 )
#define tmrCOMMAND_STOP ( ( BaseType_t ) 3 )
#define tmrCOMMAND_CHANGE_PERIOD ( ( BaseType_t ) 4 )
#define tmrCOMMAND_DELETE ( ( BaseType_t ) 5 )

#define tmrFIRST_FROM_ISR_COMMAND ( ( BaseType_t ) 6 )
#define tmrCOMMAND_START_FROM_ISR ( ( BaseType_t ) 6 )
#define tmrCOMMAND_RESET_FROM_ISR ( ( BaseType_t ) 7 )
#define tmrCOMMAND_STOP_FROM_ISR ( ( BaseType_t ) 8 )
#define tmrCOMMAND_CHANGE_PERIOD_FROM_ISR ( ( BaseType_t ) 9 )

代码清单 21-6(3)： 获取当前系统时间。
代码清单 21-6(4)： pxHigherPriorityTaskWoken 为 NULL，该参数在中断中发送命令才起作用。
代码清单 21-6(5)： 用户指定超时阻塞时间， 单位为系统节拍周期(即 tick)。调用xTimerStart()的任务将被锁定在阻塞态， 在软件定时器把启动的命令成功发送到定时器命令队列之前。如果在 FreeRTOS 调度器开启之前调用 xTimerStart()，形参将不起作用。

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 ) (1)
　　{
　　　　/* 要发送的命令信息，包含命令、命令的数值（比如可以表示当前系统时间、要修改的定时器周期等）以及要处理的软件定时器句柄 */
　　　　xMessage.xMessageID = xCommandID; (2)
　　　　xMessage.u.xTimerParameters.xMessageValue = xOptionalValue;
　　　　xMessage.u.xTimerParameters.pxTimer = ( Timer_t * ) xTimer;

　　　　/* 命令是在任务中发出的 */
　　　　if ( xCommandID < tmrFIRST_FROM_ISR_COMMAND )  (3)
        {

            /* 如果调度器已经运行了，就根据用户指定超时时间发送 */
            if ( xTaskGetSchedulerState() == taskSCHEDULER_RUNNING ) 
            {
                xReturn = xQueueSendToBack( xTimerQueue,&xMessage,xTicksToWait ); (4)
            } 
            else 
            {
                /* 如果调度器还未运行，发送就行了，不需要阻塞 */
                xReturn = xQueueSendToBack( xTimerQueue,xMessage,tmrNO_DELAY ); (5)
            }
        }
        /* 命令是在中断中发出的 */
        else 
        {
            /* 调用从中断向消息队列发送消息的函数 */
            xReturn = xQueueSendToBackFromISR( xTimerQueue, &xMessage,pxHigherPriorityTaskWoken );(6)
        }

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

    return xReturn;
}

代码清单 21-8(1)：系统打算通过“定时器命令队列” 发送命令给定时器任务， 需要先判断一下“定时器命令队列”是否存在，只有存在队列才允许发送命令。
代码清单 21-8(2)： 要发送的命令基本信息，包括命令、命令的数值（比如可以表示当前系统时间、要修改的定时器周期等）以及要处理的软件定时器句柄等。
代码清单 21-8(3)： 根据用户指定的 xCommandID 参数，判断命令是在哪个上下文环境发出的，如果是在任务中发出的，则执行(4) 、 (5) 代码，否则就执行(6)。
代码清单 21-8(4)： 如果系统调度器已经运行了，就根据用户指定超时时间向“定时器命令队列” 发送命令。
代码清单 21-8(5)： 如果调度器还未运行，用户指定的超时时间是无效的，发送就行了，不需要阻塞， tmrNO_DELAY 的值为 0。
代码清单 21-8(6)： 命令是在中断中发出的， 调用从中断向消息队列发送消息的函数xQueueSendToBackFromISR()就行了。
软件定时器启动函数的使用很简单， 在创建一个软件定时器完成后， 就可以调用该函数启动定时器了。

　　（2）、xTimerStartFromISR()

　　当 然 除 在 任 务 启 动 软 件 定 时 器 之 外 ， 还 有 在 中 断 中 启 动 软 件 定 时 器 的 函 数xTimerStartFromISR()。 xTimerStartFromISR()是函数 xTimerStart()的中断版本， 用于启动一个先前由函数 xTimerCreate() / xTimerCreateStatic()创建的软件定时器。该函数的具体说明见表格 21-1， 使用实例具体见代码清单 21-9。

/*******************************************************************************************************
  *@ 函数功能：在中断中启动一个软件定时器。
  *@ 函数参数：xTimer：软件定时器句柄  
               pxHigherPriorityTaskWoken：定时器守护任务的大部分时间都在阻塞态等待定时器命令队列的命令。 调用函数 xTimerStartFromISR()将会往定时器的命令队列发送一个启动命令，这很有可能会将定时 器 任 务 从 阻 塞 态 移 除 。 如 果 调 用 函 数xTimerStartFromISR()让定时器任务脱离阻塞态， 且定时器守护任务的优先级大于或者等于当前被中断的任务的优先级，那么 pxHigherPriorityTaskWoken 的值会在函数xTimerStartFromISR()内部设置为 pdTRUE， 然后在中断退出之前执行一次上下文切换。
               pxHigherPriorityTaskWoken：pxHigherPriorityTaskWoken 在使用之前必须初始化成pdFALSE。调用 xEventGroupSetBitsFromISR()会给守护任务发送一个消息， 如果守护任务的优先级高于当前被中断的任务的优先级的话（一般情况下都需要将守护任务 的 优 先 级 设 置 为 所 有 任 务 中 最 高 优 先 级 ） ，pxHigherPriorityTaskWoken 会被置为 pdTRUE， 然后在中断退出前执行一次上下文切换。
  *@ 返回值：如果启动命令无法成功地发送到定时器命令队列则返回 pdFAILE， 成功发送则返回pdPASS。 软件定时器成功发送的命令是否真正的被执行也还要看定时器守护任务的优先级，其优先级由宏 configTIMER_TASK_PRIORITY 定义。
*******************************************************************************************************/
#define xTimerStartFromISR( xTimer, pxHigherPriorityTaskWoken )    xTimerGenericCommand( ( xTimer ), tmrCOMMAND_START_FROM_ISR,( xTaskGetTickCountFromISR() ),( pxHigherPriorityTaskWoken ), 0U )

/* 这个方案假定软件定时器 xBacklightTimer 已经创建，定时周期为 5s，执行次数为一次，即定时时间到了之后就进入休眠态。
程序说明：当按键按下，打开液晶背光，启动软件定时器，5s 时间到，关掉液晶背光*/

/* 软件定时器回调函数 */
void vBacklightTimerCallback( TimerHandle_t pxTimer )
{
　　/* 关掉液晶背光 */
　　vSetBacklightState( BACKLIGHT_OFF );
}

/* 按键中断服务程序 */
void vKeyPressEventInterruptHandler( void )
{
　　BaseType_t xHigherPriorityTaskWoken = pdFALSE;

　　/* 确保液晶背光已经打开 */
　　vSetBacklightState( BACKLIGHT_ON );

　　/* 启动软件定时器 */
　　if ( xTimerStartFromISR( xBacklightTimer,&xHigherPriorityTaskWoken ) != pdPASS ) 
　　{
　　　　/* 软件定时器开启命令没有成功执行 */
　　}

　　　　/* ...执行其他的按键相关的功能代码 */

　　if ( xHigherPriorityTaskWoken != pdFALSE )
　　{
　　　　/* 执行上下文切换 */
　　}
}

　　6.3、软件定时器停止函数

　　（1）、xTimerStop()

　　xTimerStop() 用于停止一个已经启动的软件定时器， 该函数的实现也是通过“定时器命令队列”发送一个停止命令给软件定时器任务，从而唤醒软件定时器任务去将定时器停止。 要想使函数 xTimerStop()必须在头文件 FreeRTOSConfig.h 中把宏 configUSE_TIMERS定义为 1。 

/*******************************************************************************************************
  *@ 函数功能：停止一个软件定时器， 让其进入休眠态。
  *@ 函数参数：xTimer：软件定时器句柄
               xBlockTime：用户指定超时时间， 单位为系统节拍周期(即 tick)。 如果在 FreeRTOS 调度器开启之前调用 xTimerStart()，形参将不起作用。
  *@ 返回值：如果启动命令在超时时间之前无法成功地发送到定时器命令队列则返回 pdFAILE， 成功发送则返回 pdPASS。 软件定时器成功发送的命令是否真正的被执行也还要看定时器守护任务的优先级，其优先级由宏 configTIMER_TASK_PRIORITY 定义。
*******************************************************************************************************/
BaseType_t xTimerStop( TimerHandle_t xTimer, TickType_t xBlockTime );

　　（2）、xTimerStopFromISR()

　　xTimerStopFromISR()是函数 xTimerStop()的中断版本， 用于停止一个正在运行的软件定时器， 让其进入休眠态， 实现过程也是通过“定时器命令队列”向软件定时器任务发送停止命令。

/*******************************************************************************************************
  *@ 函数功能：在中断中停止一个软件定时器， 让其进入休眠态。
  *@ 函数参数：xTimer：软件定时器句柄
               pxHigherPriorityTaskWoken：定时器守护任务的大部分时间都在阻塞态等待定时器命令队列的命令。调用函数 xTimerStopFromISR()将会往定时器的命令队列发送一个
                                          停止命令，这很有可能会将定时 器 任 务 从 阻 塞 态 移 除 。 如 果 调 用 函 数xTimerStopFromISR()让定时器任务脱离阻塞态，且
                                          定时器守护任务的优先级大于或者等于当前被中断的任务的优先级，那么 pxHigherPriorityTaskWoken 的值会在函数xTimerStopFromISR()
                                          内部设置为 pdTRUE， 然后在中断退出之前执行一次上下文切换。
  *@ 返回值：如果停止命令在超时时间之前无法成功地发送到定时器命令队列则返回 pdFAILE， 成功发送则返回 pdPASS。 软件定时器成功发送的命令是否真正的被执行也还要看定时
             器守护任务的优先级，其优先级由宏 configTIMER_TASK_PRIORITY 定义。
*******************************************************************************************************/
BaseType_t xTimerStopFromISR(TimerHandle_t xTimer,BaseType_t *pxHigherPriorityTaskWoken);

　　6.4、软件定时器任务

　　我们知道，软件定时器回调函数运行的上下文环境是任务，那么软件定时器任务是在干什么的呢？如何创建的呢？下面跟我一步步来分析软件定时器的工作过程。软件定时器任务是在系统开始调度（ vTaskStartScheduler()函数） 的时候就被创建的，前提是将宏定义 configUSE_TIMERS 开启，具体见代码清单 21-12 加粗部分， 在xTimerCreateTimerTask()函数里面就是创建了一个软件定时器任务，就跟我们创建任务一样，支持动态与静态创建，我们暂时看动态创建的即可，具体见代码清单 21-13 加粗部分。

void vTaskStartScheduler( void )
{
    #if ( configUSE_TIMERS == 1 )
    {
        if ( xReturn == pdPASS )
        {
            xReturn = xTimerCreateTimerTask();
        } 
        else
        {
            mtCOVERAGE_TEST_MARKER();
        }
    }
    #endif /* configUSE_TIMERS */
}

BaseType_t xTimerCreateTimerTask( void )
{
　　BaseType_t xReturn = pdFAIL;

　　prvCheckForValidListAndQueue();

　　if ( xTimerQueue != NULL )
　　{
　　　　#if( configSUPPORT_STATIC_ALLOCATION == 1 ) /* 静态创建任务 */
　　　　{
　　　　　　StaticTask_t *pxTimerTaskTCBBuffer = NULL;
　　　　　　StackType_t *pxTimerTaskStackBuffer = NULL;
　　　　　　uint32_t ulTimerTaskStackSize;

　　　　　　vApplicationGetTimerTaskMemory( &pxTimerTaskTCBBuffer,&pxTimerTaskStackBuffer,&ulTimerTaskStackSize );
　　　　　　xTimerTaskHandle = xTaskCreateStatic(prvTimerTask,"Tmr Svc",ulTimerTaskStackSize,NULL,( ( UBaseType_t ) configTIMER_TASK_PRIORITY ) | portPRIVILEGE_BIT,pxTimerTaskStackBuffer,pxTimerTaskTCBBuffer );

　　　　　　if ( xTimerTaskHandle != NULL )
　　　　　　{
　　　　　　　　xReturn = pdPASS;
　　　　　　}
　　　　}
　　　　#else /* 动态创建任务 */
　　　　{
　　　　　　xReturn = xTaskCreate(prvTimerTask, "Tmr Svc",configTIMER_TASK_STACK_DEPTH,NULL,( ( UBaseType_t ) configTIMER_TASK_PRIORITY ) | portPRIVILEGE_BIT,&xTimerTaskHandle ); (1)
　　　　}
　　　　#endif
　　} 
　　else
　　{
　　　　mtCOVERAGE_TEST_MARKER();
　　}

　　configASSERT( xReturn );
　　return xReturn;
}

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

　　xTimerDelete()用于删除一个已经被创建成功的软件定时器， 删除之后就无法使用该定时器， 并且定时器相应的资源也会被系统回收释放。 要想使函数 xTimerStop()必须在头文件 FreeRTOSConfig.h 中把宏 configUSE_TIMERS 定义为 1， 该函数的具体说明见下。

/*******************************************************************************************************
  *@ 函数功能：删除一个已经被创建成功的软件定时器
  *@ 函数参数：xTimer：软件定时器句柄
              xBlockTime：用户指定的超时时间， 单位为系统节拍周期(即 tick)， 如果在 FreeRTOS调度器开启之前调用 xTimerStart()， 该形参将不起作用。
  *@ 返回值：如果删除命令在超时时间之前无法成功地发送到定时器命令队列则返回 pdFAILE， 成功发送则返回 pdPASS。
*******************************************************************************************************/
#define xTimerDelete( xTimer, xTicksToWait )    xTimerGenericCommand( ( xTimer ),tmrCOMMAND_DELETE,0U, NULL, ( xTicksToWait ) )

　　从软件定时器删除函数 xTimerDelete()的原型可以看出， 删除一个软件定时器也是在软件定时器任务中删除， 调用 xTimerDelete()将删除软件定时器的命令发送给软件定时器任务，软件定时器任务在接收到删除的命令之后就进行删除操作。