RT-Thread-rt-thread 驱动篇之 hwtimer 重载值算法RT-Thread问答社区

rt-thread 驱动篇之 hwtimer 重载值算法

发布于 2022-03-21 16:31:15 浏览：1774 订阅该版

[tocm]

## 硬件定时器

区别于 rt-thread 内核实现的两种定时器，这种定时器依赖芯片内置的定时器外设，依靠稳定高速的晶振实现精确定时，可以实现 rt_timer 无法达到的定时精度。硬件定时器最重要的两个参数是定时器时钟和定时器重载值。

定时器时钟越高，定时器精度越高；重载值越大，实现的定时时间越长。

在定时器时钟一定的前提下，重载值就决定了定时器定时时间的准确性。

### 两种计算重载值算法

hwtimer.c 文件 `timeout_calc` 函数实现

```
    float overflow;
    float timeout;
    rt_uint32_t counter;
    int i, index = 0;
    float tv_sec;
    float devi_min = 1;
    float devi;

/* changed to second */
    overflow = timer->maxcnt/(float)timer->freq;
    tv_sec = tv->sec + tv->usec/(float)1000000;

if (tv_sec < (1/(float)timer->freq))
    {
        /* little timeout */
        i = 0;
        timeout = 1/(float)timer->freq;
    }
    else
    {
        for (i = 1; i > 0; i ++)
        {
            timeout = tv_sec/i;

if (timeout <= overflow)
            {
                counter = timeout*timer->freq;
                devi = tv_sec - (counter/(float)timer->freq)*i;
                /* Minimum calculation error */
                if (devi > devi_min)
                {
                    i = index;
                    timeout = tv_sec/i;
                    break;
                }
                else if (devi == 0)
                {
                    break;
                }
                else if (devi < devi_min)
                {
                    devi_min = devi;
                    index = i;
                }
            }
        }
    }

timer->cycles = i;
    timer->reload = i;
    timer->period_sec = timeout;
    counter = timeout*timer->freq;

return counter;
```

第二种实现，

```
    rt_uint32_t counter, reload;
    rt_uint32_t timer_cnt;
    int i, index = 0, n0, n1;
    float tv_sec;
    rt_uint32_t dev, dev_min;

/* changed to second */
    tv_sec = tv->sec + tv->usec/(float)1000000.0;
    timer_cnt = tv_sec * timer->freq;

if (timer_cnt == 0) {
        timer_cnt = 1;
    }
    if (timer_cnt < timer->maxcnt) {
        timer->cycles = timer->reload = 1;
        timer->period_sec = tv_sec;
        counter = timer_cnt;
        return counter;
    }
    if (timer_cnt % timer->maxcnt == 0) {
        timer->cycles = timer->reload = timer_cnt / timer->maxcnt;
        timer->period_sec = tv_sec;
        counter = timer_cnt;
        return counter;
    }
    n0 = timer_cnt / timer->maxcnt + 1;
    n1 = timer_cnt / 2;
    dev_min = n0;
    for (i = n0; i < n1; i++) {
        reload = (rt_uint32_t)(timer_cnt / i);
        dev = timer_cnt - reload * i;
        if (dev == 0) {
            // end
            index = i;
            break;
        } else if (dev < dev_min) {
            dev_min = dev;
            index = i;
        }
    }
    timer->cycles = timer->reload = index;
    timer->period_sec = index / timer->freq;
    counter = timer_cnt / index;
    return counter;
```

#### 测试环境

定时器频率设定 1M。定时器最大重载值 65535。

系统：win10

IDE：Qt Creator

#### 最大定时范围

两种算法，最主要的差别在于前一种用 float 运算，因为 float 可以表达的值范围更大，定时时间可以更长。

而在 1M 定时器时钟前提下，用 32 位无符号整型 timer_cnt，最大可以处理时间仅有 4294.967295s。

#### 精度 PK

![image.png](https://oss-club.rt-thread.org/uploads/20220321/1cbeccfd9641dc4af8aaa32724c37e55.png.webp)
> 这里不支持嵌入 html 表格，只好贴图了

分别选各个量级的时间，用两种算法计算，第二种算法可以把误差降低到0，但是也暴露出一些问题，在某些时间，例如 3.230970s、12.230970s、14.230970s... 误差是很小，定时器重载值也很小，这是我们不愿意看到的。

第一种算法，在计算大于 1000 的数时，误差也随之增大。比如 1000s 误差为 3.236ms；4293.0s 误差为 64.080ms。

#### 运算速度

测试方法：抽取某几个时间值，循环 1M 次运算，计量 1M 次运算总耗时时间。

| time        | float       | uint32      |
| ----------- | ----------- | ----------- |
| 3.317s      | 98.736ms    | 3000+s      |
| 7.537s      | 178.545ms   | 21.921ms    |
| 7.000537s   | 168.549ms   | 175.530ms   |
| 999.999s    | 17407.468ms | 30866.978ms |
| 999.000999s | 17458.347ms | 337.047ms   |

从抽取的几个值测试结果看，第一种算法耗时比较稳定，第二种算法对不同值的运算时间差异很大。特别的，3.317s 这个值用第二种算法，1M 次运算总耗时时间可能达到 3000s。

从上一小节的精度比对可以看出，第二种算法对精度要求太高了。下面降低第二种算法的精度，达到和第一种一样的精度再重复一次。修改代码如下

```
        if (dev == 0) {
            // end
            index = i;
            break;
        } else if (dev > dev_min) {
            break;
        } else if (dev < dev_min) {
            dev_min = dev;
            index = i;
        }
```

再次测试结果：

| time        | float       | uint32   |
| ----------- | ----------- | -------- |
| 3.317s      | 104.720ms   | 20.945ms |
| 3.000317s   | 91.728ms    | 21.941ms |
| 7.537s      | 179.519ms   | 21.941ms |
| 7.000537s   | 168.549ms   | 20.944ms |
| 999.999s    | 17480.734ms | 27.927ms |
| 999.000999s | 17366.539ms | 20.944ms |

我们可以看出来，在相同精度条件下，第二种算法的运算速度比第一种快很多，而且耗时反而变得更集中。

其实，对结束条件再次修正，将 `dev == 0` 的严苛误差条件换成 `dev <= 1` 也不会出现上面 3000+s 慢速。

```
        if (dev <= 1) {
            // end
            index = i;
            break;
        } else if (dev > dev_min) {
            break;
        } else if (dev < dev_min) {
            dev_min = dev;
            index = i;
        }
```

#### 超过 4295s 的超长定时

需要修改 `rt_uint64_t timer_cnt` 的定义为 64 位无符号整型 `rt_uint64_t timer_cnt` 。

又因为定时时间很长很长，对误差要求可以降低一些，对第二种算法做的第二处修改:

```
        if (dev <= 500) {
            // end
            index = i;
            break;
        } else if (dev < dev_min) {
            dev_min = dev;
            index = i;
        }
```

![image.png](https://oss-club.rt-thread.org/uploads/20220321/0cd5452ccecc79f446703f27aa5b07ef.png)

超长时间，第二种算法的表现也很优秀。第三组数据第一种方法竟然出错了，没算出结果。

下面是 10k 次（没有进行 1W 次是因为有些时间太长了）运算时间统计

| time         | float      | uint32     |
| ------------ | ---------- | ---------- |
| 9999.537s    | 1741.341ms | 5.010ms    |
| 19999.999s   | 3481.173ms | 27.926ms   |
| 1999999.999s | -          | 2616.001ms |

### 返璞归真

以上是对两种算法从不同角度进行的比对测验。看似用 float 可以计算更大的定时数，但是，测试结果并不那么理想。使用 64位整型数计算，可能得到比用 float 更精确的结果。

使用 32 位无符号整型数运算虽然最大定时时间只有 4294.9s 。但是我们也看到了，第一种方法有可能出现计算误差的，当误差超过 1ms 我们用 rt_thread_mdelay 或者 rt-thread 的软/硬定时器，可能结果比硬件定时器更精确了，反而失去了精确定时器的意义。在这个前提下，使用 32 位无符号整型数已经足够了。

算法及测试源码见：https://gitee.com/thewon/rt_thread_repo/tree/master/user