实时操作系统-10-[FreeRTOS]软件定时器
软件定时器基本概念
定时器，是指从指定的时刻开始，经过一个指定时间，然后触发一个超时事件，用户可以自定义定时器的周期与频率。相当于一个闹钟，到点干什么。
定时器有硬件定时器和软件定时器之分：
硬件定时器：
是芯片本身提供的定时功能；
一般是由外部晶振提供给芯片输入时钟，芯片向软件模块提供一组配置寄存器，接受控制输入，到达设定时间值后芯片中断控制器产生时钟中断；
硬件定时器的精度一般很高，可以达到纳秒级别，并且是中断触发方式；
使用硬件定时器时，每次在定时时间到达之后就会自动触发一个中断，用户在中断中处理信息；
软件定时器：
是由操作系统 提供的一类系统接口。
它构建在硬件定时器基础之上，使系统能够提供不受硬件定时器资源限制的定时器服务，它实现的功能与硬件定时器也是类 似的。
需要我们在创建软件定时器时指定时间到达后要调用的函数（也称超时函数/回调函数，为了统一，下文均用回调函数描述），在回调函数中处理信息。
软件定时器在被创建之后，当经过设定的时钟计数值后会触发用户定义的回调函数。定时精度与系统时钟的周期有关。一般系统利用 SysTick 作为软件定时器的基础时钟，软件定时器的回调函数类似硬件的中断服务函数，所以，回调函数也要快进快出，而且回调函数中不能有任何阻塞任务运行的情况（软件定时器回调函数的上下文环境是任务），比如 vTaskDelay()以及 其它能阻塞任务运行的函数 ，两次触发回调函数的时间间隔xTimerPeriodInTicks 叫定时器的定时周期。
FreeRTOS操作系统提供软件定时器功能，软件定时器的使用相当于扩展了定时器的数量，允许创建更多的定时业务。
FreeRTOS软件定时器功能上支持：
- 裁剪：能通过宏关闭软件定时器功能。
- 软件定时器创建。
- 软件定时器启动。
- 软件定时器停止。
- 软件定时器复位。
- 软件定时器删除。
FreeRTOS 提供的软件定时器支持单次模式和周期模式：
- 单次模式：当用户创建了定时器并启动了定时器后，定时时间到了，只执行一次回调函数之后就将该定时器进入休眠状态，不再重新执行。
- 周期模式：这个定时器会按照设置的定时时间循环执行回调函数，直到用户将定时器删除。
FreeRTOS 通过一个 prvTimerTask 任务（也叫守护任务 Daemon）管理软定时器，它是在启动调度器时自动创建的，为了满足用户定时需求。prvTimerTask 任务会在其执行期间检查用户启动的时间周期溢出的定时器，并调用其回调函数。只有设置 FreeRTOSConfig.h 中的宏定义 configUSE_TIMERS 设置为 1 ，将相关代码编译进来，才能正常使用软件定时器相关功能。
软件定时器的精度
在操作系统中，通常软件定时器以系统节拍周期为计时单位。系统节拍是系统的心跳节拍，表示系统时钟的频率，就类似人的心跳，1s 能跳动多少下，系统节拍配置为 configTICK_RATE_HZ，该宏在 FreeRTOSConfig.h 中有定义，默认是 1000。
那么系统的时钟节拍周期就为 1ms（1s跳动 1000 下，每一下就为 1ms）。软件定时器的所定时数值必须是这个节拍周期的整数倍，例如节拍周期是 10ms，那么上层软件定时器定时数值只能是 10ms，20ms，100ms 等，而不能取值为 15ms。
由于节拍定义了系统中定时器能够分辨的精确度，系统可以根据实际系统 CPU 的处理能力和实时性需求设置合适的数值，系统节拍周期的值越小，精度越高，但是系统开销也将越大，因为这代表在 1 秒中系统进入时钟中断的次数也就越多。
软件定时器的应用
我们知道硬件定时器收到硬件限制，数量上不足以满足用户的实际需求，无法提供更多的定时器，那么我们就可以采用软件定时器来完成。
软件定时器更适用于对于时间精度要求不高的任务。
软件定时器的运作机制
软件定时器是可选的系统资源，在创建定时器的时候会分配一块内存空间。当用户创建并启动一个软件定时器时， 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，在当前系统中已经创建并启动了 1 个定时器 Timer1：
注意：xTimeNow 其实是一个局部变量，是根据 xTaskGetTickCount()函数获取的，实际它的值就是全局变量 xTickCount 的值，下文都采用它表示当前系统时间。
系统继续运行，当系统的时间 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，若大于则表示已经超时，定时器任务将会调用对应定时器的回调函数，否则将软件定时器任务挂起，直至下一个要唤醒的软件定时器时间到来或者接收到命令消息。
使用软件定时器时候要注意以下几点：
(1）软件定时器的回调函数中应快进快出，绝对不允许使用任何可能引软件定时器起任务挂起或者阻塞的API接口，在回调函数中也绝对不允许出现死循环。
（2）软件定时器使用了系统的一个队列和一个任务资源，软件定时器任务的优先级默认为configTIMER_TASK_PRIORITY，为了更好响应，该优先级应设置为所有任务中最高的优先级。
（3）创建单次软件定时器，该定时器超时执行完回调函数后，系统会自动删除该软件定时器，并回收资源。
（4）定时器任务的堆栈大小默认为 configTIMER_TASK_STACK_DEPTH 个字节。
软件定时器控制块
软件定时器虽然不属于内核资源，但是也是 FreeRTOS 核心组成部分，是一个可以裁剪的功能模块，同样在系统中由一个控制块管理其相关信息，软件定时器的控制块中包含没用过创建的软件定时器基本信息，在使用定时器前我们需要通过 xTimerCreate()/xTimerCreateStatic() 函数创建一个软件定时器，在函数中，FreeRTOS 将向系统管理的内存申请一块软件定时器控制块大小的内存用于保存定时器的信息：
typedef struct tmrTimerControl {
const char *pcTimerName; /* (1) 定时器名称字符串 */
ListItem_t xTimerListItem; /* (2) 定时器链表项 */
TickType_t xTimerPeriodInTicks; /* (3) 定时周期(ticks) */
UBaseType_t uxAutoReload; /* (4) 自动重载标志 */
void *pvTimerID; /* (5) 定时器ID */
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; /* 定时器类型别名 */
软件定时器接口函数
软件定时器创建函数 xTimerCreate()
软件定时器与 FreeRTOS 内核其他资源一样，需要创建才允许使用的，FreeRTOS 为我们提供了两种创建方式，一种是动态创建软件定时器 xTimerCreate()，另一种是静态创建方式 xTimerCreateStatic()，因为创建过程基本差不多，所以在这里我们只讲解动态创建方式。
每一个软件定时器只需要 很少的 RAM 空间来保存其的状态。如果使用函 数xTimeCreate()来创建一个软件定时器，那么需要的 RAM 是动态分配的。如果使用函数xTimeCreateStatic()来创建一个事件组，那么需要的 RAM 是静态分配的。
注意在使用中将宏定义打开：
/*****************************************************************
FreeRTOS与内存申请有关配置选项
*****************************************************************/
//支持动态内存申请
#define configSUPPORT_DYNAMIC_ALLOCATION 1
//支持静态内存
#define configSUPPORT_STATIC_ALLOCATION 0
软件定时器在创建成功后是处于休眠状态的，可以使用 xTimerStart()、xTimerReset()、xTimerStartFromISR() 、 xTimerResetFromISR() 、 xTimerChangePeriod() 和xTimerChangePeriodFromISR()这些函数将其状态转换为活跃态。
#if (configSUPPORT_DYNAMIC_ALLOCATION == 1)
TimerHandle_t xTimerCreate(const char * const pcTimerName, /* (1) 定时器名称 */
const TickType_t xTimerPeriodInTicks, /* (2) 定时周期(ticks) */
const UBaseType_t uxAutoReload, /* (3) 自动重载标志 */
void * const pvTimerID, /* (4) 定时器ID */
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;
}
#endif
对于初始化软件定时器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;
/* 初始化定时器链表项 */ /* (4) 链表项初始化 */
vListInitialiseItem(&(pxNewTimer->xTimerListItem));
traceTIMER_CREATE(pxNewTimer); /* 调试跟踪 */
}
}
举个例子看一下，我们知道软件定时器有两种模式分别为周期模式和单次模式，我们两个都来验证一下。
首先，我们要想使用软件定时器需要先将它的头文件包含进来：
#include "event_groups.h"
然后找到FreeRTOSConfig.h文件，找到软件定时器相关宏定义，启用软件定时器：
/***********************************************************************
FreeRTOS与软件定时器有关的配置选项
**********************************************************************/
//启用软件定时器
#define configUSE_TIMERS 1
//软件定时器优先级
#define configTIMER_TASK_PRIORITY (configMAX_PRIORITIES-1)
//软件定时器队列长度
#define configTIMER_QUEUE_LENGTH 10
//软件定时器任务堆栈大小
#define configTIMER_TASK_STACK_DEPTH (configMINIMAL_STACK_SIZE*2)
然后为两个模式声明两个句柄：
static TimerHandle_t Swtmr1_Handle =NULL; /* 软件定时器句柄 */
static TimerHandle_t Swtmr2_Handle =NULL; /* 软件定时器句柄 */
然后我们知道当软件定时器达到所定的值后会进行回调函数，下面来创建两个回调函数，不过这里先创建两个空的，具体里面的内容，下面讲到相关API在进行填充：
static void Swtmr1_Callback(void* parameter)
{
}
static void Swtmr2_Callback(void* parameter)
{
}
既然东西都准备好了，那就开始在AppTaskCreate()函数中进行调用软件定时器创建函数xTimerCreate()开始创建，根据上面介绍对内容进行填充：
//任务创建函数
static void AppTaskCreate(void)
{
BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为pdPASS */
taskENTER_CRITICAL(); //进入临界区
//周期模式
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)
{
printf("周期模式定时器创建成功!\r\n");
}
//单次模式
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)
{
printf("单次模式定时器创建成功!\r\n");
}
vTaskDelete(AppTaskCreate_Handle); //删除AppTaskCreate任务
taskEXIT_CRITICAL(); //退出临界区
}
至此创建完毕，完整main函数代码：
#include "stm32f10x.h" // Device header
#include "Delay.h"
#include "LED.h"
#include "Usart.h"
#include "Key.h"
/* FreeRTOS头文件 */
#include "FreeRTOS.h"
#include "task.h"
#include "event_groups.h"
/*
* 任务句柄是一个指针，用于指向一个任务，当任务创建好之后，它就具有了一个任务句柄
* 以后我们要想操作这个任务都需要通过这个任务句柄，如果是自身的任务操作自己，那么
* 这个句柄可以为NULL。
*/
static TaskHandle_t AppTaskCreate_Handle = NULL; /* 创建任务句柄 */
/********************************** 内核对象句柄 *********************************/
/*
* 信号量，消息队列，事件标志组，软件定时器这些都属于内核的对象，要想使用这些内核
* 对象，必须先创建，创建成功之后会返回一个相应的句柄。实际上就是一个指针，后续我
* 们就可以通过这个句柄操作这些内核对象。
*
* 内核对象说白了就是一种全局的数据结构，通过这些数据结构我们可以实现任务间的通信，
* 任务间的事件同步等各种功能。至于这些功能的实现我们是通过调用这些内核对象的函数
* 来完成的
*
*/
static TimerHandle_t Swtmr1_Handle =NULL; /* 软件定时器句柄 */
static TimerHandle_t Swtmr2_Handle =NULL; /* 软件定时器句柄 */
/******************************* 宏定义 ************************************/
/*
* 当我们在写应用程序的时候，可能需要用到一些宏定义。
*/
//一些函数声明
static void AppTaskCreate(void);/* 用于创建任务 */
static void Swtmr1_Callback(void* parameter);
static void Swtmr2_Callback(void* parameter);
static void All_Function_Init(void);/* 用于初始化板载相关资源 */
int main(void)
{
BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为pdPASS */
All_Function_Init();//硬件初始化
while (1)
{
/* 创建AppTaskCreate任务 */
xReturn = xTaskCreate((TaskFunction_t )AppTaskCreate, /* 任务入口函数 */
(const char* )"AppTaskCreate",/* 任务名字 */
(uint16_t )512, /* 任务栈大小 */
(void* )NULL,/* 任务入口函数参数 */
(UBaseType_t )1, /* 任务的优先级 */
(TaskHandle_t* )&AppTaskCreate_Handle);/* 任务控制块指针 */
/* 启动任务调度 */
if(pdPASS == xReturn)
vTaskStartScheduler(); /* 启动任务，开启调度 */
else
return -1;
}
}
//任务创建函数
static void AppTaskCreate(void)
{
BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为pdPASS */
taskENTER_CRITICAL(); //进入临界区
//周期模式
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)
{
printf("周期模式定时器创建成功!\r\n");
}
//单次模式
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)
{
printf("单次模式定时器创建成功!\r\n");
}
vTaskDelete(AppTaskCreate_Handle); //删除AppTaskCreate任务
taskEXIT_CRITICAL(); //退出临界区
}
/***********************************************************************
* @ 函数名 ： Swtmr1_Callback
* @ 功能说明： 软件定时器1 回调函数，打印回调函数信息&当前系统时间
* 软件定时器请不要调用阻塞函数，也不要进行死循环，应快进快出
* @ 参数 ： 无
* @ 返回值 ： 无
**********************************************************************/
static void Swtmr1_Callback(void* parameter)
{
}
/***********************************************************************
* @ 函数名 ： Swtmr2_Callback
* @ 功能说明： 软件定时器2 回调函数，打印回调函数信息&当前系统时间
* 软件定时器请不要调用阻塞函数，也不要进行死循环，应快进快出
* @ 参数 ： 无
* @ 返回值 ： 无
**********************************************************************/
static void Swtmr2_Callback(void* parameter)
{
}
//初始化声明
static void All_Function_Init(void)
{
/*
* STM32中断优先级分组为4，即4bit都用来表示抢占优先级，范围为：0~15
* 优先级分组只需要分组一次即可，以后如果有其他的任务需要用到中断，
* 都统一用这个优先级分组，千万不要再分组，切忌。
*/
NVIC_PriorityGroupConfig( NVIC_PriorityGroup_4 );
/* LED 初始化 */
LED_GPIO_Config();
/* 串口初始化 */
USART_Config();
//按键初始化
Key_GPIO_Config();
}
运行结果：
软件定时器启动函数
xTimerStart()
我们知道软件定时器在创建完成的时候是处于休眠状态的，需要用 FreeRTOS 的相关函数将软件定时器活动起来，而 xTimerStart()函数就是可以让处于休眠的定时器开始工作。
我们知道，在系统开始运行的时候，系统会帮我们自动创建一个软件定时器任务（prvTimerTask），在这个任务中，如果暂时没有运行中的定时器，任务会进入阻塞态等待命令，而我们的启动函数就是通过“定时器命令队列”向定时器任务发送一个启动命令，定时器任务获得命令就解除阻塞，然后执行启动软件定时器命令，xTimerStart()函数原型：
#define xTimerStart( xTimer, xTicksToWait )
xTimerGenericCommand( ( xTimer ), //（1）要启动的定时器句柄
tmrCOMMAND_START, //（2）表示启动定时器的命令
( xTaskGetTickCount() ), //（3）该函数返回当前系统的 tick 值，即系统自启动以来的时钟节拍数。
NULL, //（4）pxHigherPriorityTaskWoken 为 NULL，该参数在中断中发送命令才起作用。
( xTicksToWait ) )//（5）这个参数指定从现在开始，等待多少个系统 ticks 后启动定时器。
（2）：tmrCOMMAND_START 是软件定时器启动命令，因为现在是要将软件定时器启动，该命令在 timers.h 中有定义：
/* 定时器命令宏定义 */
#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) /* ISR命令起始值 */
#define tmrCOMMAND_START_FROM_ISR ((BaseType_t)6) /* ISR中启动 */
#define tmrCOMMAND_RESET_FROM_ISR ((BaseType_t)7) /* ISR中重置 */
#define tmrCOMMAND_STOP_FROM_ISR ((BaseType_t)8) /* ISR中停止 */
#define tmrCOMMAND_CHANGE_PERIOD_FROM_ISR ((BaseType_t)9) /* ISR中改周期 */
（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) 设置命令ID */
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, /* (6) ISR队列发送 */
&xMessage,
pxHigherPriorityTaskWoken);
}
/* 跟踪调试 */
traceTIMER_COMMAND_SEND(xTimer, xCommandID, xOptionalValue, xReturn);
}
else {
mtCOVERAGE_TEST_MARKER(); /* 覆盖率测试标记 */
}
return xReturn;
}
软件定时器的开启其实就一句函数就可以：
xTimerStart(Swtmr1_Handle,0); //开启周期定时器
xTimerStart(Swtmr2_Handle,0); //开启周期定时器
//任务创建函数
static void AppTaskCreate(void)
{
BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为pdPASS */
taskENTER_CRITICAL(); //进入临界区
//周期模式
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)
{
printf("周期模式定时器创建成功!\r\n");
xTimerStart(Swtmr1_Handle,0); //开启周期定时器
}
//单次模式
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)
{
printf("单次模式定时器创建成功!\r\n");
xTimerStart(Swtmr2_Handle,0); //开启周期定时器
}
vTaskDelete(AppTaskCreate_Handle); //删除AppTaskCreate任务
taskEXIT_CRITICAL(); //退出临界区
}
不过这样运行的实验结果我们看不见：
解释两个函数：
检查定时器是否处于活跃状态（正在运行/尚未到期）：
/*
pdTRUE：定时器正在运行
pdFALSE：定时器未运行（可能是停止状态或已到期）
*/
xTimerIsTimerActive(TimerHandle_t xTimer)
例如：
if(xTimerIsTimerActive(Swtmr1_Handle) == pdTRUE)
{
printf("周期定时器正在运行!\r\n");
}
else
{
printf("周期定时器未运行!\r\n");
}
获取定时器下一次触发的绝对时间点（以系统 tick 为单位），需要与 xTaskGetTickCount() 配合计算剩余时间：
TickType_t remaining = xTimerGetExpiryTime(xTimer) - xTaskGetTickCount();
我们可以在刚刚创建的空白的回调函数对其进行更改：
static void Swtmr1_Callback(void* parameter)
{
// 检查定时器是否处于活跃状态
if(xTimerIsTimerActive(Swtmr1_Handle) == pdTRUE)
{
printf("周期定时器正在运行!\r\n");
// 获取剩余时间
TickType_t remaining = xTimerGetExpiryTime(Swtmr1_Handle) - xTaskGetTickCount();
printf("下次触发剩余时间: %d ticks\r\n", remaining);
}
else
{
printf("周期定时器未运行!\r\n");
}
}
完整main函数：
#include "stm32f10x.h" // Device header
#include "Delay.h"
#include "LED.h"
#include "Usart.h"
#include "Key.h"
/* FreeRTOS头文件 */
#include "FreeRTOS.h"
#include "task.h"
#include "event_groups.h"
/*
* 任务句柄是一个指针，用于指向一个任务，当任务创建好之后，它就具有了一个任务句柄
* 以后我们要想操作这个任务都需要通过这个任务句柄，如果是自身的任务操作自己，那么
* 这个句柄可以为NULL。
*/
static TaskHandle_t AppTaskCreate_Handle = NULL; /* 创建任务句柄 */
/********************************** 内核对象句柄 *********************************/
/*
* 信号量，消息队列，事件标志组，软件定时器这些都属于内核的对象，要想使用这些内核
* 对象，必须先创建，创建成功之后会返回一个相应的句柄。实际上就是一个指针，后续我
* 们就可以通过这个句柄操作这些内核对象。
*
* 内核对象说白了就是一种全局的数据结构，通过这些数据结构我们可以实现任务间的通信，
* 任务间的事件同步等各种功能。至于这些功能的实现我们是通过调用这些内核对象的函数
* 来完成的
*
*/
static TimerHandle_t Swtmr1_Handle =NULL; /* 软件定时器句柄 */
static TimerHandle_t Swtmr2_Handle =NULL; /* 软件定时器句柄 */
/******************************* 宏定义 ************************************/
/*
* 当我们在写应用程序的时候，可能需要用到一些宏定义。
*/
//一些函数声明
static void AppTaskCreate(void);/* 用于创建任务 */
static void Swtmr1_Callback(void* parameter);
static void Swtmr2_Callback(void* parameter);
static void All_Function_Init(void);/* 用于初始化板载相关资源 */
int main(void)
{
BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为pdPASS */
All_Function_Init();//硬件初始化
while (1)
{
/* 创建AppTaskCreate任务 */
xReturn = xTaskCreate((TaskFunction_t )AppTaskCreate, /* 任务入口函数 */
(const char* )"AppTaskCreate",/* 任务名字 */
(uint16_t )512, /* 任务栈大小 */
(void* )NULL,/* 任务入口函数参数 */
(UBaseType_t )1, /* 任务的优先级 */
(TaskHandle_t* )&AppTaskCreate_Handle);/* 任务控制块指针 */
/* 启动任务调度 */
if(pdPASS == xReturn)
vTaskStartScheduler(); /* 启动任务，开启调度 */
else
return -1;
}
}
//任务创建函数
static void AppTaskCreate(void)
{
BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为pdPASS */
taskENTER_CRITICAL(); //进入临界区
//周期模式
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)
{
printf("周期模式定时器创建成功!\r\n");
xTimerStart(Swtmr1_Handle,0); //开启周期定时器
}
//单次模式
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)
{
printf("单次模式定时器创建成功!\r\n");
xTimerStart(Swtmr2_Handle,0); //开启周期定时器
}
vTaskDelete(AppTaskCreate_Handle); //删除AppTaskCreate任务
taskEXIT_CRITICAL(); //退出临界区
}
/***********************************************************************
* @ 函数名 ： Swtmr1_Callback
* @ 功能说明： 软件定时器1 回调函数，打印回调函数信息&当前系统时间
* 软件定时器请不要调用阻塞函数，也不要进行死循环，应快进快出
* @ 参数 ： 无
* @ 返回值 ： 无
**********************************************************************/
static void Swtmr1_Callback(void* parameter)
{
// 检查定时器是否处于活跃状态
if(xTimerIsTimerActive(Swtmr1_Handle) == pdTRUE)
{
printf("周期定时器正在运行!\r\n");
// 获取剩余时间
TickType_t remaining = xTimerGetExpiryTime(Swtmr1_Handle) - xTaskGetTickCount();
printf("下次触发剩余时间: %d ticks\r\n", remaining);
}
else
{
printf("周期定时器未运行!\r\n");
}
}
/***********************************************************************
* @ 函数名 ： Swtmr2_Callback
* @ 功能说明： 软件定时器2 回调函数，打印回调函数信息&当前系统时间
* 软件定时器请不要调用阻塞函数，也不要进行死循环，应快进快出
* @ 参数 ： 无
* @ 返回值 ： 无
**********************************************************************/
static void Swtmr2_Callback(void* parameter)
{
}
//初始化声明
static void All_Function_Init(void)
{
/*
* STM32中断优先级分组为4，即4bit都用来表示抢占优先级，范围为：0~15
* 优先级分组只需要分组一次即可，以后如果有其他的任务需要用到中断，
* 都统一用这个优先级分组，千万不要再分组，切忌。
*/
NVIC_PriorityGroupConfig( NVIC_PriorityGroup_4 );
/* LED 初始化 */
LED_GPIO_Config();
/* 串口初始化 */
USART_Config();
//按键初始化
Key_GPIO_Config();
}
运行结果：
这里也可以看出软件定时器受到系统的影响，不是非常的准确。
不过上面这种方法只适合于周期模式的检测，因为对于单次模式的定时器（uxAutoReload = pdFALSE）触发回调函数时，定时器已自动进入非活跃状态（这是单次模式的特性）回调函数执行时，定时器生命周期已结束（xTimerIsTimerActive() 必然返回 pdFALSE），所以如果我们继续按照上面的方法检测单次定时器：
static void Swtmr2_Callback(void* parameter)
{
// 检查定时器是否处于活跃状态
if(xTimerIsTimerActive(Swtmr2_Handle) == pdTRUE)
{
printf("单次定时器正在运行!\r\n");
// 获取剩余时间
TickType_t remaining = xTimerGetExpiryTime(Swtmr2_Handle) - xTaskGetTickCount();
printf("下次触发剩余时间: %d ticks\r\n", remaining);
}
else
{
printf("单次定时器未运行!\r\n");
}
}
只会显示未运行的结果：
那么如何进行单次定时器是否启动的检测呢？首先我们可以先创建一个函数，用以记录软件定时器2回调函数执行次数：
static uint32_t TmrCb_Count2 = 0; /* 记录软件定时器2回调函数执行次数 */
然后在单次回调函数进行++操作，每次调用加1，同时获取当前计数器的数值：
static void Swtmr2_Callback(void* parameter)
{
TickType_t tick_num2;
TmrCb_Count2++; /* 每回调一次加一 */
tick_num2 = xTaskGetTickCount(); /* 获取滴答定时器的计数值 */
printf("Swtmr2_Callback函数执行 %d 次!\r\n", TmrCb_Count2);
printf("滴答定时器数值=%d\r\n", tick_num2);
}
此时完整main函数的代码：
#include "stm32f10x.h" // Device header
#include "Delay.h"
#include "LED.h"
#include "Usart.h"
#include "Key.h"
/* FreeRTOS头文件 */
#include "FreeRTOS.h"
#include "task.h"
#include "event_groups.h"
/*
* 任务句柄是一个指针，用于指向一个任务，当任务创建好之后，它就具有了一个任务句柄
* 以后我们要想操作这个任务都需要通过这个任务句柄，如果是自身的任务操作自己，那么
* 这个句柄可以为NULL。
*/
static TaskHandle_t AppTaskCreate_Handle = NULL; /* 创建任务句柄 */
/********************************** 内核对象句柄 *********************************/
/*
* 信号量，消息队列，事件标志组，软件定时器这些都属于内核的对象，要想使用这些内核
* 对象，必须先创建，创建成功之后会返回一个相应的句柄。实际上就是一个指针，后续我
* 们就可以通过这个句柄操作这些内核对象。
*
* 内核对象说白了就是一种全局的数据结构，通过这些数据结构我们可以实现任务间的通信，
* 任务间的事件同步等各种功能。至于这些功能的实现我们是通过调用这些内核对象的函数
* 来完成的
*
*/
static TimerHandle_t Swtmr1_Handle =NULL; /* 软件定时器句柄 */
static TimerHandle_t Swtmr2_Handle =NULL; /* 软件定时器句柄 */
/******************************* 宏定义 ************************************/
/*
* 当我们在写应用程序的时候，可能需要用到一些宏定义。
*/
static uint32_t TmrCb_Count2 = 0; /* 记录软件定时器2回调函数执行次数 */
//一些函数声明
static void AppTaskCreate(void);/* 用于创建任务 */
static void Swtmr1_Callback(void* parameter);
static void Swtmr2_Callback(void* parameter);
static void All_Function_Init(void);/* 用于初始化板载相关资源 */
int main(void)
{
BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为pdPASS */
All_Function_Init();//硬件初始化
while (1)
{
/* 创建AppTaskCreate任务 */
xReturn = xTaskCreate((TaskFunction_t )AppTaskCreate, /* 任务入口函数 */
(const char* )"AppTaskCreate",/* 任务名字 */
(uint16_t )512, /* 任务栈大小 */
(void* )NULL,/* 任务入口函数参数 */
(UBaseType_t )1, /* 任务的优先级 */
(TaskHandle_t* )&AppTaskCreate_Handle);/* 任务控制块指针 */
/* 启动任务调度 */
if(pdPASS == xReturn)
vTaskStartScheduler(); /* 启动任务，开启调度 */
else
return -1;
}
}
//任务创建函数
static void AppTaskCreate(void)
{
BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为pdPASS */
taskENTER_CRITICAL(); //进入临界区
//周期模式
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)
{
printf("周期模式定时器创建成功!\r\n");
xTimerStart(Swtmr1_Handle,0); //开启周期定时器
}
//单次模式
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)
{
printf("单次模式定时器创建成功!\r\n");
xTimerStart(Swtmr2_Handle,0); //开启周期定时器
}
vTaskDelete(AppTaskCreate_Handle); //删除AppTaskCreate任务
taskEXIT_CRITICAL(); //退出临界区
}
/***********************************************************************
* @ 函数名 ： Swtmr1_Callback
* @ 功能说明： 软件定时器1 回调函数，打印回调函数信息&当前系统时间
* 软件定时器请不要调用阻塞函数，也不要进行死循环，应快进快出
* @ 参数 ： 无
* @ 返回值 ： 无
**********************************************************************/
static void Swtmr1_Callback(void* parameter)
{
// // 检查定时器是否处于活跃状态
// if(xTimerIsTimerActive(Swtmr1_Handle) == pdTRUE)
// {
// printf("周期定时器正在运行!\r\n");
//
// // 获取剩余时间
// TickType_t remaining = xTimerGetExpiryTime(Swtmr1_Handle) - xTaskGetTickCount();
// printf("下次触发剩余时间: %d ticks\r\n", remaining);
// }
// else
// {
// printf("周期定时器未运行!\r\n");
// }
}
/***********************************************************************
* @ 函数名 ： Swtmr2_Callback
* @ 功能说明： 软件定时器2 回调函数，打印回调函数信息&当前系统时间
* 软件定时器请不要调用阻塞函数，也不要进行死循环，应快进快出
* @ 参数 ： 无
* @ 返回值 ： 无
**********************************************************************/
static void Swtmr2_Callback(void* parameter)
{
TickType_t tick_num2;
TmrCb_Count2++; /* 每回调一次加一 */
tick_num2 = xTaskGetTickCount(); /* 获取滴答定时器的计数值 */
printf("Swtmr2_Callback函数执行 %d 次!\r\n", TmrCb_Count2);
printf("滴答定时器数值=%d\r\n", tick_num2);
}
//初始化声明
static void All_Function_Init(void)
{
/*
* STM32中断优先级分组为4，即4bit都用来表示抢占优先级，范围为：0~15
* 优先级分组只需要分组一次即可，以后如果有其他的任务需要用到中断，
* 都统一用这个优先级分组，千万不要再分组，切忌。
*/
NVIC_PriorityGroupConfig( NVIC_PriorityGroup_4 );
/* LED 初始化 */
LED_GPIO_Config();
/* 串口初始化 */
USART_Config();
//按键初始化
Key_GPIO_Config();
}
运行结果：
同样的我们也可以对周期回调函数进行一样的修改：
static uint32_t TmrCb_Count1 = 0; /* 记录软件定时器1回调函数执行次数 */
static void Swtmr1_Callback(void* parameter)
{
TickType_t tick_num1;
TmrCb_Count1++; /* 每回调一次加一 */
tick_num1 = xTaskGetTickCount(); /* 获取滴答定时器的计数值 */
Toggle_LED_R();
printf("Swtmr1_Callback函数执行 %d 次!\r\n", TmrCb_Count1);
printf("滴答定时器数值=%d\r\n", tick_num1);
}
此时完整main函数代码：
#include "stm32f10x.h" // Device header
#include "Delay.h"
#include "LED.h"
#include "Usart.h"
#include "Key.h"
/* FreeRTOS头文件 */
#include "FreeRTOS.h"
#include "task.h"
#include "event_groups.h"
/*
* 任务句柄是一个指针，用于指向一个任务，当任务创建好之后，它就具有了一个任务句柄
* 以后我们要想操作这个任务都需要通过这个任务句柄，如果是自身的任务操作自己，那么
* 这个句柄可以为NULL。
*/
static TaskHandle_t AppTaskCreate_Handle = NULL; /* 创建任务句柄 */
/********************************** 内核对象句柄 *********************************/
/*
* 信号量，消息队列，事件标志组，软件定时器这些都属于内核的对象，要想使用这些内核
* 对象，必须先创建，创建成功之后会返回一个相应的句柄。实际上就是一个指针，后续我
* 们就可以通过这个句柄操作这些内核对象。
*
* 内核对象说白了就是一种全局的数据结构，通过这些数据结构我们可以实现任务间的通信，
* 任务间的事件同步等各种功能。至于这些功能的实现我们是通过调用这些内核对象的函数
* 来完成的
*
*/
static TimerHandle_t Swtmr1_Handle =NULL; /* 软件定时器句柄 */
static TimerHandle_t Swtmr2_Handle =NULL; /* 软件定时器句柄 */
/******************************* 宏定义 ************************************/
/*
* 当我们在写应用程序的时候，可能需要用到一些宏定义。
*/
static uint32_t TmrCb_Count1 = 0; /* 记录软件定时器1回调函数执行次数 */
static uint32_t TmrCb_Count2 = 0; /* 记录软件定时器2回调函数执行次数 */
//一些函数声明
static void AppTaskCreate(void);/* 用于创建任务 */
static void Swtmr1_Callback(void* parameter);
static void Swtmr2_Callback(void* parameter);
static void All_Function_Init(void);/* 用于初始化板载相关资源 */
int main(void)
{
BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为pdPASS */
All_Function_Init();//硬件初始化
while (1)
{
/* 创建AppTaskCreate任务 */
xReturn = xTaskCreate((TaskFunction_t )AppTaskCreate, /* 任务入口函数 */
(const char* )"AppTaskCreate",/* 任务名字 */
(uint16_t )512, /* 任务栈大小 */
(void* )NULL,/* 任务入口函数参数 */
(UBaseType_t )1, /* 任务的优先级 */
(TaskHandle_t* )&AppTaskCreate_Handle);/* 任务控制块指针 */
/* 启动任务调度 */
if(pdPASS == xReturn)
vTaskStartScheduler(); /* 启动任务，开启调度 */
else
return -1;
}
}
//任务创建函数
static void AppTaskCreate(void)
{
BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为pdPASS */
taskENTER_CRITICAL(); //进入临界区
//周期模式
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)
{
printf("周期模式定时器创建成功!\r\n");
xTimerStart(Swtmr1_Handle,0); //开启周期定时器
}
//单次模式
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)
{
printf("单次模式定时器创建成功!\r\n");
xTimerStart(Swtmr2_Handle,0); //开启周期定时器
}
vTaskDelete(AppTaskCreate_Handle); //删除AppTaskCreate任务
taskEXIT_CRITICAL(); //退出临界区
}
/***********************************************************************
* @ 函数名 ： Swtmr1_Callback
* @ 功能说明： 软件定时器1 回调函数，打印回调函数信息&当前系统时间
* 软件定时器请不要调用阻塞函数，也不要进行死循环，应快进快出
* @ 参数 ： 无
* @ 返回值 ： 无
**********************************************************************/
static void Swtmr1_Callback(void* parameter)
{
TickType_t tick_num1;
TmrCb_Count1++; /* 每回调一次加一 */
tick_num1 = xTaskGetTickCount(); /* 获取滴答定时器的计数值 */
Toggle_LED_R();
printf("Swtmr1_Callback函数执行 %d 次!\r\n", TmrCb_Count1);
printf("滴答定时器数值=%d\r\n", tick_num1);
}
/***********************************************************************
* @ 函数名 ： Swtmr2_Callback
* @ 功能说明： 软件定时器2 回调函数，打印回调函数信息&当前系统时间
* 软件定时器请不要调用阻塞函数，也不要进行死循环，应快进快出
* @ 参数 ： 无
* @ 返回值 ： 无
**********************************************************************/
static void Swtmr2_Callback(void* parameter)
{
TickType_t tick_num2;
TmrCb_Count2++; /* 每回调一次加一 */
tick_num2 = xTaskGetTickCount(); /* 获取滴答定时器的计数值 */
printf("Swtmr2_Callback函数执行 %d 次!\r\n", TmrCb_Count2);
printf("滴答定时器数值=%d\r\n", tick_num2);
}
//初始化声明
static void All_Function_Init(void)
{
/*
* STM32中断优先级分组为4，即4bit都用来表示抢占优先级，范围为：0~15
* 优先级分组只需要分组一次即可，以后如果有其他的任务需要用到中断，
* 都统一用这个优先级分组，千万不要再分组，切忌。
*/
NVIC_PriorityGroupConfig( NVIC_PriorityGroup_4 );
/* LED 初始化 */
LED_GPIO_Config();
/* 串口初始化 */
USART_Config();
//按键初始化
Key_GPIO_Config();
}
运行结果：
xTimerStartFromISR()
当然除在任务启动软件定时器之外，还有在中断中启动软件定时器的函数 xTimerStartFromISR()。xTimerStartFromISR()是函数 xTimerStart()的中断版本，用于启动一个先前由函数 xTimerCreate() / xTimerCreateStatic()创建的软件定时器：
软件定时器停止函数
xTimerStop()
xTimerStop() 用于停止一个已经启动的软件定时器，该函数的实现也是通过“定时器命令队列”发送一个停止命令给软件定时器任务，从而唤醒软件定时器任务去将定时器停止。
停止函数也非常简单就一句：
xTimerStop(Swtmr1_Handle,0);
我们可以自己加个判断条件实现其停止，在前面启动函数的代码上进行修改，这里只对周期回调函数进行修改，当第七次回调时给禁用：
static void Swtmr1_Callback(void* parameter)
{
TickType_t tick_num1;
TmrCb_Count1++; /* 每回调一次加一 */
tick_num1 = xTaskGetTickCount(); /* 获取滴答定时器的计数值 */
Toggle_LED_R();
printf("Swtmr1_Callback函数执行 %d 次!\r\n", TmrCb_Count1);
printf("滴答定时器数值=%d\r\n", tick_num1);
if(TmrCb_Count1 == 7)
{
xTimerStop(Swtmr1_Handle,0);
printf("\r\nSwtmr1_Callback已被停止!\r\n");
}
}
main完整代码：
#include "stm32f10x.h" // Device header
#include "Delay.h"
#include "LED.h"
#include "Usart.h"
#include "Key.h"
/* FreeRTOS头文件 */
#include "FreeRTOS.h"
#include "task.h"
#include "event_groups.h"
/*
* 任务句柄是一个指针，用于指向一个任务，当任务创建好之后，它就具有了一个任务句柄
* 以后我们要想操作这个任务都需要通过这个任务句柄，如果是自身的任务操作自己，那么
* 这个句柄可以为NULL。
*/
static TaskHandle_t AppTaskCreate_Handle = NULL; /* 创建任务句柄 */
/********************************** 内核对象句柄 *********************************/
/*
* 信号量，消息队列，事件标志组，软件定时器这些都属于内核的对象，要想使用这些内核
* 对象，必须先创建，创建成功之后会返回一个相应的句柄。实际上就是一个指针，后续我
* 们就可以通过这个句柄操作这些内核对象。
*
* 内核对象说白了就是一种全局的数据结构，通过这些数据结构我们可以实现任务间的通信，
* 任务间的事件同步等各种功能。至于这些功能的实现我们是通过调用这些内核对象的函数
* 来完成的
*
*/
static TimerHandle_t Swtmr1_Handle =NULL; /* 软件定时器句柄 */
static TimerHandle_t Swtmr2_Handle =NULL; /* 软件定时器句柄 */
/******************************* 宏定义 ************************************/
/*
* 当我们在写应用程序的时候，可能需要用到一些宏定义。
*/
static uint32_t TmrCb_Count1 = 0; /* 记录软件定时器1回调函数执行次数 */
static uint32_t TmrCb_Count2 = 0; /* 记录软件定时器2回调函数执行次数 */
//一些函数声明
static void AppTaskCreate(void);/* 用于创建任务 */
static void Swtmr1_Callback(void* parameter);
static void Swtmr2_Callback(void* parameter);
static void All_Function_Init(void);/* 用于初始化板载相关资源 */
int main(void)
{
BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为pdPASS */
All_Function_Init();//硬件初始化
while (1)
{
/* 创建AppTaskCreate任务 */
xReturn = xTaskCreate((TaskFunction_t )AppTaskCreate, /* 任务入口函数 */
(const char* )"AppTaskCreate",/* 任务名字 */
(uint16_t )512, /* 任务栈大小 */
(void* )NULL,/* 任务入口函数参数 */
(UBaseType_t )1, /* 任务的优先级 */
(TaskHandle_t* )&AppTaskCreate_Handle);/* 任务控制块指针 */
/* 启动任务调度 */
if(pdPASS == xReturn)
vTaskStartScheduler(); /* 启动任务，开启调度 */
else
return -1;
}
}
//任务创建函数
static void AppTaskCreate(void)
{
BaseType_t xReturn = pdPASS;/* 定义一个创建信息返回值，默认为pdPASS */
taskENTER_CRITICAL(); //进入临界区
//周期模式
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)
{
printf("周期模式定时器创建成功!\r\n");
xTimerStart(Swtmr1_Handle,0); //开启周期定时器
}
//单次模式
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)
{
printf("单次模式定时器创建成功!\r\n");
xTimerStart(Swtmr2_Handle,0); //开启周期定时器
}
vTaskDelete(AppTaskCreate_Handle); //删除AppTaskCreate任务
taskEXIT_CRITICAL(); //退出临界区
}
/***********************************************************************
* @ 函数名 ： Swtmr1_Callback
* @ 功能说明： 软件定时器1 回调函数，打印回调函数信息&当前系统时间
* 软件定时器请不要调用阻塞函数，也不要进行死循环，应快进快出
* @ 参数 ： 无
* @ 返回值 ： 无
**********************************************************************/
static void Swtmr1_Callback(void* parameter)
{
TickType_t tick_num1;
TmrCb_Count1++; /* 每回调一次加一 */
tick_num1 = xTaskGetTickCount(); /* 获取滴答定时器的计数值 */
Toggle_LED_R();
printf("Swtmr1_Callback函数执行 %d 次!\r\n", TmrCb_Count1);
printf("滴答定时器数值=%d\r\n", tick_num1);
if(TmrCb_Count1 == 7)
{
xTimerStop(Swtmr1_Handle,0);
printf("\r\nSwtmr1_Callback已被停止!\r\n");
}
}
/***********************************************************************
* @ 函数名 ： Swtmr2_Callback
* @ 功能说明： 软件定时器2 回调函数，打印回调函数信息&当前系统时间
* 软件定时器请不要调用阻塞函数，也不要进行死循环，应快进快出
* @ 参数 ： 无
* @ 返回值 ： 无
**********************************************************************/
static void Swtmr2_Callback(void* parameter)
{
TickType_t tick_num2;
TmrCb_Count2++; /* 每回调一次加一 */
tick_num2 = xTaskGetTickCount(); /* 获取滴答定时器的计数值 */
printf("Swtmr2_Callback函数执行 %d 次!\r\n", TmrCb_Count2);
printf("滴答定时器数值=%d\r\n", tick_num2);
}
//初始化声明
static void All_Function_Init(void)
{
/*
* STM32中断优先级分组为4，即4bit都用来表示抢占优先级，范围为：0~15
* 优先级分组只需要分组一次即可，以后如果有其他的任务需要用到中断，
* 都统一用这个优先级分组，千万不要再分组，切忌。
*/
NVIC_PriorityGroupConfig( NVIC_PriorityGroup_4 );
/* LED 初始化 */
LED_GPIO_Config();
/* 串口初始化 */
USART_Config();
//按键初始化
Key_GPIO_Config();
}
运行结果：
xTimerStopFromISR()
xTimerStopFromISR()是函数 xTimerStop()的中断版本，用于停止一个正在运行的软件定时器，让其进入休眠态，实现过程也是通过“定时器命令队列”向软件定时器任务发送停止命令。
软件定时器删除函数 xTimerDelete()
xTimerDelete()用于删除一个已经被创建成功的软件定时器，删除之后就无法使用该定时器，并且定时器相应的资源也会被系统回收释放。
从软件定时器删除函数 xTimerDelete()的原型可以看出，删除一个软件定时器也是在软件定时器任务中删除，调用 xTimerDelete()将删除软件定时器的命令发送给软件定时器任务，软件定时器任务在接收到删除的命令之后就进行删除操作，该函数的使用方法很简单，也是一句话：
xTimerDelete(Swtmr1_Handle,0); //删除软件定时器
我们继续在停止函数的代码基础上进行修改，首先把停止函数的代码注释掉，然后对周期计时器代码进行修改：
static void Swtmr1_Callback(void* parameter)
{
TickType_t tick_num1;
TmrCb_Count1++; /* 每回调一次加一 */
tick_num1 = xTaskGetTickCount(); /* 获取滴答定时器的计数值 */
Toggle_LED_R();
printf("Swtmr1_Callback函数执行 %d 次!\r\n", TmrCb_Count1);
printf("滴答定时器数值=%d\r\n", tick_num1);
if(TmrCb_Count1 == 7)
{
xTimerDelete(Swtmr1_Handle,0); //删除软件定时器
Swtmr1_Handle = NULL;//删除后立即置空句柄
if(Swtmr1_Handle == NULL)
{
printf("\r\n定时器已被删除!\r\n");
}
else
{
printf("\r\n定时器仍存在，删除操作失败!\r\n");
}
}
}
运行结果：
浙公网安备 33010602011771号