毫秒，微妙级别软件定时器

Posted 2020-10-02 llkkyy

　　单片机开发中，软件定时器是常用的工具。定时执行特定任务和延时功能，都可以用软件定时器实现。

　　常见的延时函数的实现做法有：

　　1. 使用空指令进行延时，通过控制空指令的执行次数，进行延时。优点：不需要占用系统外设。缺点：系统运行指定个空指令的时间不稳定，中途出现的中断处理会严重影响计时的精确性。

　　2.使用单片机的定时器外设，设定特定的时间产生中断，进行计时。优点：计时准确，不受其他中断影响计时。缺点：浪费单片机外设资源，并且延时处理不能嵌套调用，灵活性不够。

　　这里要介绍的是利用单片机内部的sysTicket 定时器实现的软件定时器。sysTicket timer每毫秒产生一次中断，单片机内有一个无符号类型的32位全局变量msTicket对中断次数进行计数，我们可以认为msTicket

为当前“系统时间”。

　　先介绍相对简单的ms定时器，ms定时器的结构定义如下：

typedef struct
{
    uint16_t start;
    uint32_t value;
}MsSoftTimer;

　　start字段用来表示定时器的开关状态，考虑到字节对齐的问题，用了十六位的类型。如果单片机存储资源紧张，可以不用这个字段。value字段用来保存开始计时时刻系统的时间，也就是msTicket的值。

ms定时器的接口函数如下：

 1 #define        def_ms_tm(tm)    MsSoftTimer tm;
 2 #define        declare_ms_tm(tm)    extern MsSoftTimer tm;
 3 #define        get_ms_tm_val(tm)         _get_ms_tm_val(tm.value)
 4 
 5 #define  start_ms_tm(tm)     do   6 {                          7     tm.start = 1;          8     tm.value = get_msTicks();      9 }while(0)
10 
11 #define  init_ms_tm(tm)     do  12 {                         13     tm.start = 0;         14     tm.value = 0;        15 }while(0)
16 
17 #define  is_ms_tm_on(tm)     ( tm.start)
18 #define  stop_ms_tm(tm)     tm.start = 0

定义定时器，本质是就是定义一个定时器类型的变量。可以嵌套调用，如果要在中断处理函数中使用软件定时器，要先将msTicket 中断的优先级设置为最高级别的，并且可以抢占。获取当前的计时时间，就是将当前的“系统时间”，减去定时器开始计时时刻的时间。具体实现如下：

 1 uint32_t _get_ms_tm_val(uint32_t pre_timer_val)
 2 {
 3     uint32_t curr_timer_val = msTicks;
 4     uint32_t ret_timer_val = 0;
 5     
 6     if ( curr_timer_val >= pre_timer_val)
 7     {
 8         ret_timer_val  = curr_timer_val - pre_timer_val;
 9     }
10     else
11     {
12         ret_timer_val = 0xFFFFFFFF - pre_timer_val + curr_timer_val;
13     }
14 
15     return ret_timer_val;
16 }

第12行代码中，对msTicket 变量溢出做了判断和处理。

利于ms软件定时器实现的ms延时函数如下：

void delay_ms(uint32_t ms)
{
    if ( ms == 0) return ;
    def_ms_tm(tm_ms_count);
    start_ms_tm(tm_ms_count);
    while ( get_ms_tm_val(tm_ms_count) < ms)
    ;
    stop_ms_tm(tm_ms_count);
}

us 定时器实现原理跟ms定时器类似，但会稍微复杂一些。us定时利用系统sysTicket 定时器内部的计数值（SysTick Current Value）进行计时。如果系统时钟为20M,每隔1us，SysTick Current Value减少20。

如果系统时钟为48M，每隔1us，SysTick Current Value 减少48。系统sysTicket 定时器结构如下：

1 typedef struct
2 {
3   __IO uint32_t CTRL;                    /*!< Offset: 0x000 (R/W)  SysTick Control and Status Register */
4   __IO uint32_t LOAD;                    /*!< Offset: 0x004 (R/W)  SysTick Reload Value Register       */
5   __IO uint32_t VAL;                     /*!< Offset: 0x008 (R/W)  SysTick Current Value Register      */
6   __I  uint32_t CALIB;                   /*!< Offset: 0x00C (R/ )  SysTick Calibration Register        */
7 } SysTick_Type;

us 定时器的结构体如下：

1 typedef struct 
2 {
3     uint16_t start;
4     uint32_t init_ticket_val;
5     uint32_t init_ms_val;
6 }UsSoftTimer;

init_ticket_val 记录的是开始计时时刻SysTick Current Value的值。init_ms_val 记录的是开始计时时刻msTicket 的值。

us 定时器接口函数实现如下：

 1 void _start_us_sw(USSoftTimer* pTM)
 2 {
 3     pTM->init_ms_val =  msTicks;
 4     pTM->init_ticket_val = SysTick->VAL;
 5     pTM->start = 1;
 6 }
 7 
 8 #pragma O0
 9 uint32_t _get_us_tm_val(USSoftTimer* pTM)
10 {
11     volatile uint32_t curr_ms = msTicks;    
12     volatile uint32_t curr_ticket_val = SysTick->VAL;
13     volatile uint32_t ms_interval = 0;
14     volatile uint32_t sys_clock = SysTick -> LOAD / 1000;
15     volatile uint32_t us_interval = 0;
16     
17     
18     if ( curr_ticket_val > pTM->init_ticket_val)
19     us_interval = ( SysTick->LOAD  - (curr_ticket_val - pTM->init_ticket_val)) / sys_clock;
20     else
21     us_interval = (pTM->init_ticket_val - curr_ticket_val) / sys_clock;
22     
23     if ( curr_ms != pTM->init_ms_val)
24     {
25 
26     if ( curr_ms >= pTM->init_ms_val)
27         ms_interval = curr_ms - pTM->init_ms_val;
28     else
29         ms_interval = 0xFFFFFFFF - pTM->init_ms_val+ curr_ms;
30     
31     if ( curr_ticket_val > pTM->init_ticket_val)
32         ms_interval -= 1;
33 
34     us_interval += ms_interval * 1000;
35 
36     }
37 
38     return us_interval;
39 }
40 
41 #define       def_us_tm(tm)       UsSoftTimer tm 
42 #define       declare_us_tm(tm)   extern    UsSoftTimer tm        
43 #define       get_us_tm_val(tm)    _get_us_tm_val(&tm)
44 #define is_us_tm_on(tm)    (1== tm.start)
45 #define stop_us_tm(tm)    tm.start = 0
46 #define start_us_tm(tm)    _start_us_sw(&tm)

us延时函数的实现如下：

1 void delay_us(uint32_t us)
2 {
3     if ( us <= 1) return ;
4     def_us_tm(tm_us_count);
5     start_us_tm(tm_us_count);
6     while ( get_us_tm_val(tm_us_count) < us)
7     ;
8     stop_us_tm(tm_us_count);
9 }