FreeRTOS：软件定时器

前言

什么是硬件定时器

CPU内部自带的定时器模块，通过初始化、配置可以实现定时，定时时间到以后就会执行相应的定时器中断处理函数。硬件定时器一般都带有其它功能，比如PWM输出、输入捕获等等功能。但是缺点是硬件定时器数量少！！

什么是软件定时器

软件定时器允许设置一段时间，当设置的时间到达之后就执行指定的功能函数，被定时器调用的这个功能函数叫做定时器的回调函数。回调函数的两次执行间隔叫做定时器的定时周期，简而言之，当定时器的定时周期到了以后就会执行回调函数。

一、回调函数

软件定时器的回调函数是在定时器服务任务中执行的，所以一定不能在回调函数中调用任何会阻塞任务的 API 函数！

FreeRTOS 提供了很多定时器有关的 API 函数，这些 API 函数大多都使用 FreeRTOS的队列发送命令给定时器服务任务。这个队列叫做定时器命令队列。定时器命令队列是提供给FreeRTOS 的软件定时器使用的，用户不能直接访问！

二、定时器的配置

2.1软件定时器分类

软件定时器分两种：单次定时器和周期定时器。
单次定时器的话定时器回调函数就执行一次，比如定时 1s，当定时时间到了以后就会执行一次回调函数，然后定时器就会停止运行。对于单次定时器我们可以再次手动重新启动(调用相应的 API 函数即可)，但是单次定时器不能自动重启。

相反的，周期定时器一旦启动以后就会在执行完回调函数以后自动的重新启动，这样回调函数就会周期性的执行。

2.2定时器相关API函数

2.2.1创建软件定时器

函数 xTiemrCreate()
此函数用于创建一个软件定时器，所需要的内存通过动态内存管理方法分配。新创建的软件定时器处于休眠状态，也就是未运行的 。函数 xTimerStart() 、 xTimerReset() 、xTimerStartFromISR() 、 xTimerResetFromISR() 、 xTimerChangePeriod() 和xTimerChangePeriodFromISR()可以使新创建的定时器进入活动状态

TimerHandle_t xTimerCreate( const char * const pcTimerName,
 TickType_t xTimerPeriodInTicks,
 UBaseType_t uxAutoReload,
 void * pvTimerID,
 TimerCallbackFunction_t pxCallbackFunction )

参数：
pcTimerName： 软件定时器名字，名字是一串字符串，用于调试使用。

xTimerPeriodInTicks ： 软件定时器的定时器周期， 单位是时钟节拍数。可以借助portTICK_PERIOD_MS 将 ms 单位转换为时钟节拍数。举个例子，定时器的周期为 100 个时钟节拍的话，那么 xTimerPeriodInTicks 就为100，当定时器周期为 500ms 的时候 xTimerPeriodInTicks 就可以设置为(500/ portTICK_PERIOD_MS)。

uxAutoReload： 设置定时器模式，单次定时器还是周期定时器？当此参数为 pdTRUE的时候表示创建的是周期定时器。如果为 pdFALSE 的话表示创建的是单次定时器。

pvTimerID： 定时器 ID 号，一般情况下每个定时器都有一个回调函数，当定时器定时周期到了以后就会执行这个回调函数。但是FreeRTOS 也支持多个定时器共用同一个回调函数，在回调函数中根据定时器的 ID 号来处理不同的定时器。

pxCallbackFunction： 定时器回调函数，当定时器定时周期到了以后就会调用这个函数。

返回值：
NULL: 软件定时器创建失败。
其他值: 创建成功的软件定时器句柄。

2.2.2开启软件定时器

上面说过，最开始设置的软件定时器是处于休眠状态的，所有需要开启软件定时器。

1、函数 xTimerStart()
启动软件定时器。如果软件定时器没有运行的话调用函数 xTimerStart()就会计算定时器到期时间，如果软件定时器正在运行的话调用函数 xTimerStart()的结果和 xTimerReset()一样。

BaseType_t xTimerStart( TimerHandle_t xTimer, 
TickType_t xTicksToWait )

参数：
xTimer： 要开启的软件定时器的句柄。
xTicksToWait： 设置阻塞时间（涉及到入队的问题），调用函数 xTimerStart()开启软件定时器其实就是向定时器命令队列发送一条 tmrCOMMAND_START 命令，既然是向队列发送消息，那肯定会涉及到入队阻塞时间的设置。

返回值：
pdPASS: 软件定时器开启成功，其实就是命令发送成功。
pdFAIL: 软件定时器开启失败，命令发送失败。

2、函数 xTimerStartFromISR()
此函数是函数 xTimerStart()的中断版本，用在中断服务函数中。

BaseType_t xTimerStartFromISR( TimerHandle_t xTimer,
BaseType_t * pxHigherPriorityTaskWoken );

参数：
xTimer： 要开启的软件定时器的句柄。
pxHigherPriorityTaskWoken： 标记退出此函数以后是否进行任务切换，这个变量的值函数会自动设置的，用户不用进行设置，用户只需要提供一个变量来保存这个值就行了。当此值为 pdTRUE 的时候在退出中断服务函数之前一定要进行一次任务切换。

返回值：
pdPASS: 软件定时器开启成功，其实就是命令发送成功。
pdFAIL: 软件定时器开启失败，命令发送失败。

2.2.3停止软件定时器

1、函数 xTimerStop()
此函数用于停止一个软件定时器，此函数用于任务中，不能用在中断服务函数中！

BaseType_t xTimerStop ( TimerHandle_t xTimer, 
TickType_t xTicksToWait )

参数：
xTimer： 要停止的软件定时器的句柄。
xTicksToWait： 设置阻塞时间，调用函数 xTimerStop()停止软件定时器其实就是向定时器命令队列发送一条 tmrCOMMAND_STOP 命令，既然是向队列发送消息，那肯定会涉及到入队阻塞时间的设置。

返回值：
pdPASS: 软件定时器停止成功，其实就是命令发送成功。
pdFAIL: 软件定时器停止失败，命令发送失败。

2、函数 xTimerStopFromISR()
此函数是 xTimerStop()的中断版本，此函数用于中断服务函数中！

BaseType_t xTimerStopFromISR( TimerHandle_t xTimer,
BaseType_t * pxHigherPriorityTaskWoken );

参数：
xTimer： 要停止的软件定时器句柄。
pxHigherPriorityTaskWoken： 标记退出此函数以后是否进行任务切换，这个变量的值函数会
自动设置的，用户不用进行设置，用户只需要提供一个变量来保存这个值就行了。当此值为 pdTRUE 的时候在退出中断服务函数之前一定要进行一次任务切换。

返回值：
pdPASS: 软件定时器停止成功，其实就是命令发送成功。
pdFAIL: 软件定时器停止失败，命令发送失败。

2.2.4复位软件定时器

复位很简单，就是重新运行，持续5秒。

1、函数 xTimerReset()
复位一个软件定时器，此函数只能用在任务中，不能用于中断服务函数！

BaseType_t xTimerReset( TimerHandle_t xTimer, 
TickType_t xTicksToWait )

参数：
xTimer： 要复位的软件定时器的句柄。
xTicksToWait： 设置阻塞时间，调用函数 xTimerReset ()开启软件定时器其实就是向定时器命令队列发送一条 tmrCOMMAND_RESET 命令，既然是向队列发送消息，那肯定会涉及到入队阻塞时间的设置。

返回值：
pdPASS: 软件定时器复位成功，其实就是命令发送成功。
pdFAIL: 软件定时器复位失败，命令发送失败。

2、函数 xTimerResetFromISR()
此函数是 xTimerReset()的中断版本，此函数用于中断服务函数中！

BaseType_t xTimerResetFromISR( TimerHandle_t xTimer,
BaseType_t * pxHigherPriorityTaskWoken );

参数：
xTimer： 要复位的软件定时器的句柄。
pxHigherPriorityTaskWoken： 记退出此函数以后是否进行任务切换，这个变量的值函数会自动设置的，用户不用进行设置，用户只需要提供一个变量来保存这个值就行了。当此值为 pdTRUE 的时候在退出中断服务函数之前一定要进行一次任务切换。

返回值：
pdPASS: 软件定时器复位成功，其实就是命令发送成功。
pdFAIL: 软件定时器复位失败，命令发送失败

三、软件定时器实验

3.1实验要求

创建2个任务，start_task、timercontrol_task。

start_stask：创建timercontrol_task任务；创建周期定时器AutoReloadTimer 和单次定时器OneShotTimer；创建二值信号量BinarySemaphore。

BinarySemaphore：接收串口命名，在中断中释放信号，在timercontrol_task中等待信号量，解析命名，通过不同的命令控制周期定时器AutoReloadTimer和单次定时器OneShotTimer的开启和关闭。

AutoReloadTimer 的回调函数会输出运行的次数

OneShotTimer的回调函数会输出运行的次数

3.2实验代码

任务分配：

//任务优先级
#define START_TASK_PRIO        1
//任务堆栈大小    
#define START_STK_SIZE         128  
//任务句柄
TaskHandle_t StartTask_Handler;
//任务函数
void start_task(void *pvParameters);

//任务优先级
#define TIMERCONTROL_TASK_PRIO        2
//任务堆栈大小    
#define TIMERCONTROL_STK_SIZE         50  
//任务句柄
TaskHandle_t TimerControlTask_Handler;
//任务函数
void timercontrol_task(void *pvParameters);

SemaphoreHandle_t BinarySemaphore_Handle;    // 二值信号量句柄

TimerHandle_t AutoReloadTimer_Handle ;    // 周期定时器句柄
TimerHandle_t OneShotTimer_Handle;        // 单次定时器句柄


void AutoReloadTimerCallback(void);        // 周期定时器回调函数
void OneShotTimerCallback(void);        // 周期定时器回调函数

main() 函数：

int main(void)
{
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);//设置系统中断优先级分组4     
    delay_init();                        //延时函数初始化      
    uart_init(115200);                    //初始化串口
    LED_Init();                              //初始化LED
     
    //创建开始任务
    xTaskCreate((TaskFunction_t )start_task,            //任务函数
                (const char*    )"start_task",          //任务名称
                (uint16_t       )START_STK_SIZE,        //任务堆栈大小
                (void*          )NULL,                  //传递给任务函数的参数
                (UBaseType_t    )START_TASK_PRIO,       //任务优先级
                (TaskHandle_t*  )&StartTask_Handler);   //任务句柄              
    vTaskStartScheduler();          //开启任务调度
}

命令解析相关函数：

// 将字符串中的小写字母转换为大写
// str：要转换的字符串
// len：字符串长度
void LowerToCap(u8 *str,u8 len)
{
    u8 i;
    
    for(i=0;i<len;i++)
    {
        if((96<str[i])&&(str[i]<123))    // 小写字母
            str[i] = str[i]-32;            // 转换为大写
    }
}

// 命令处理函数，将字符串命令转换成命令值
// str：命令
// 返回值：0xFF-命令错误 其他值-命令值
u8 CommandProcess(u8 *str)
{
    u8 CommandValue = 0xFF;
    
    if(strcmp((char*)str,"KEY1")==0) CommandValue = 1;
    else if(strcmp((char*)str,"KEY2")==0) CommandValue = 2;
    else if(strcmp((char*)str,"KEY3")==0) CommandValue = 3;
    else if(strcmp((char*)str,"KEY4")==0) CommandValue = 4;
    
    return CommandValue;
}

任务函数：

//开始任务任务函数
void start_task(void *pvParameters)
{
    taskENTER_CRITICAL();           //进入临界区
    
    // 创建二值信号量
    BinarySemaphore_Handle =  xSemaphoreCreateBinary();    // 创建二值信号量
    if(BinarySemaphore_Handle ==NULL)
    {
        printf("BinarySemaphore Create Failed!\r\n");
    }else{
        xSemaphoreGive(BinarySemaphore_Handle);            // 释放信号量
    }
    
    
    // 创建周期定时器
    AutoReloadTimer_Handle =  xTimerCreate(    (const char *)"AutoReloadTimer",
                                (TickType_t) 1000,
                                (UBaseType_t) pdTRUE,
                                (void *) 1,
                                (TimerCallbackFunction_t)AutoReloadTimerCallback );
    if(AutoReloadTimer_Handle == NULL)
    {
        printf("AutoReloadTimer Created Failed \r\n");
    }else{
        printf("AutoReloadTimer Created Success \r\n");
    }
    
    // 创建单次定时器                            
    OneShotTimer_Handle =  xTimerCreate(    (const char *)"OneShotTimer",
                                (TickType_t) 2000,
                                (UBaseType_t) pdFALSE,
                                (void *) 2,
                                (TimerCallbackFunction_t)OneShotTimerCallback );
    if(OneShotTimer_Handle == NULL)
    {
        printf("OneShotTimer Created Failed \r\n");
    }else{
        printf("OneShotTimer Created Success \r\n");
    }
    
    //创建TIMECONTRFOL任务
    xTaskCreate((TaskFunction_t )timercontrol_task,         
                (const char*    )"timercontrol_task",       
                (uint16_t       )TIMERCONTROL_STK_SIZE, 
                (void*          )NULL,                
                (UBaseType_t    )TIMERCONTROL_TASK_PRIO,    
                (TaskHandle_t*  )&TimerControlTask_Handler);   
      
    vTaskDelete(StartTask_Handler); //删除开始任务
    taskEXIT_CRITICAL();            //退出临界区
}



//TIMERCONTROL任务函数
void timercontrol_task(void *pvParameters)
{
    u8 len = 0;
    u8 CommandValue = 0xFF;
    u8 CommandStr[USART_REC_LEN];
    BaseType_t err;
    
    while(1)
    {
        xSemaphoreTake( BinarySemaphore_Handle, portMAX_DELAY );    // 死等
        len = USART_RX_STA&0x3fff;                                // 得到此次接收到的数据长度
        
        sprintf((char *)CommandStr,"%s",USART_RX_BUF);            // 装载数据
        CommandStr[len] = '\0';                                    // 加上字符串结尾符号
        LowerToCap(CommandStr,len);                                // 将字符串转换为大写
        CommandValue = CommandProcess(CommandStr);                // 命令解析
        
        if(CommandValue != 0xFF)                                // 接收到正确的命令
        {
            switch(CommandValue)
            {
                case 1:        // 开启周期定时器
                    err =  xTimerStart( AutoReloadTimer_Handle, 0 );
                    if(err == pdFAIL)
                    {
                        printf("AutoReloadTimer Start Failed! \r\n");
                    }else{
                        printf("AutoReloadTimer Start Succeed! \r\n");
                    }
                    break;
                case 2:        // 关闭周期定时器
                    err =  xTimerStop( AutoReloadTimer_Handle, 0 );
                    if(err == pdFAIL)
                    {
                        printf("AutoReloadTimer Stop Failed! \r\n");
                    }else{
                        printf("AutoReloadTimer Stop Succeed! \r\n");
                    }
                    break;
                case 3:        // 开启单次定时器
                    err =  xTimerStart( OneShotTimer_Handle, 0 );
                    if(err == pdFAIL)
                    {
                        printf("OneShotTimer Start Failed! \r\n");
                    }else{
                        printf("OneShotTimer Start Succeed! \r\n");
                    }
                    break;
                case 4:        // 关闭周期定时器
                    err =  xTimerStop( OneShotTimer_Handle, 0 );
                    if(err == pdFAIL)
                    {
                        printf("OneShotTimer Stop Failed! \r\n");
                    }else{
                        printf("OneShotTimer Stop Succeed! \r\n");
                    }
                    break;
            }
        }else{
            printf("Cmd error!\r\n");
        }
        USART_RX_STA = 0;
    }
}

定时器回调函数：

// 周期定时器回调函数
void AutoReloadTimerCallback(void)
{
    static u8 count = 0;
    
    count ++;
    printf("AutoReloadTimerCallback running %d timers\r\n",count);
}

// 周期定时器回调函数
void OneShotTimerCallback(void)
{
    static u8 count = 0;
    
    count ++;
    printf("OneShotTimerCallback running %d timers\r\n",count);
}

串口中断初始化和中断处理函数：

u8 USART_RX_BUF[USART_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
//接收状态
//bit15，    接收完成标志
//bit14，    接收到0x0d
//bit13~0，    接收到的有效字节数目
u16 USART_RX_STA=0;       //接收状态标记      
  
void uart_init(u32 bound){
    //GPIO端口设置
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
    NVIC_InitTypeDef NVIC_InitStructure;
     
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);    //使能USART1，GPIOA时钟
  
    //USART1_TX   GPIOA.9
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;    //复用推挽输出
    GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.9
   
    //USART1_RX      GPIOA.10初始化
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//PA10
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入
    GPIO_Init(GPIOA, &GPIO_InitStructure);//初始化GPIOA.10  

    //Usart1 NVIC 配置
    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=8 ;//抢占优先级3
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;        //子优先级3
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;            //IRQ通道使能
    NVIC_Init(&NVIC_InitStructure);    //根据指定的参数初始化VIC寄存器
  
    //USART 初始化设置

    USART_InitStructure.USART_BaudRate = bound;//串口波特率
    USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式
    USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位
    USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制
    USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;    //收发模式

    USART_Init(USART1, &USART_InitStructure); //初始化串口1
    USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启串口接受中断
    USART_Cmd(USART1, ENABLE);                    //使能串口1 
}

extern SemaphoreHandle_t BinarySemaphore_Handle;    // 二值信号量句柄
void USART1_IRQHandler(void)                    //串口1中断服务程序
{
    u8 Res;
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;

    if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)  //接收中断(接收到的数据必须是0x0d 0x0a结尾)
    {
        Res =USART_ReceiveData(USART1);    //读取接收到的数据
        
        if((USART_RX_STA&0x8000)==0)//接收未完成
            {
            if(USART_RX_STA&0x4000)//接收到了0x0d
                {
                if(Res!=0x0a)USART_RX_STA=0;//接收错误,重新开始
                else USART_RX_STA|=0x8000;    //接收完成了 
                }
            else //还没收到0X0D
                {    
                if(Res==0x0d)USART_RX_STA|=0x4000;
                else
                    {
                    USART_RX_BUF[USART_RX_STA&0X3FFF]=Res ;
                    USART_RX_STA++;
                    if(USART_RX_STA>(USART_REC_LEN-1))USART_RX_STA=0;//接收数据错误,重新开始接收      
                    }         
                }
            }            
     } 
    
     if((BinarySemaphore_Handle != NULL) && (USART_RX_STA&0x8000))
     {
         xSemaphoreGiveFromISR( BinarySemaphore_Handle, &xHigherPriorityTaskWoken );    // 释放互斥信号量
         portYIELD_FROM_ISR(xHigherPriorityTaskWoken);    // 如果需要进行一次任务切换
     }
     
}

#define USART_REC_LEN              20      //定义最大接收字节数 200
#define EN_USART1_RX             1        //使能（1）/禁止（0）串口1接收
          
extern u8  USART_RX_BUF[USART_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符 

注意：串口中断的优先级在FreeRTOS的优先级管理范围内。
参考视频：正点原子