探讨各种情况下51单片机的精确延时

2020-01-23 14:44发布

本帖最后由 hotman_x 于 2014-5-11 08:26 编辑

事实上没有什么做到精确延时的通用方法,方法有二:
一是用汇编,根据晶振频率,对照数据手册,换算出指令周期,实现精确延时;
二是用C,通过实测调整,如果不是要求非常精密,也差不多少。

我先贴一个自己做的,抛转引玉。这个方案基于方法一,用于 STC12C5A60S2,在主频 22.1184mHz 下精确到微秒。可以直接换算到常用频率 11.0592mHz,只不过变成精确到 2 微秒就是了。
另外,我用的是坛子里比较少见的 SDCC 编译器,不过,汇编没多大区别,很容易换成 keil。

分析(STC12C5A60S2,主频 22.1184mHz):
CPU为所谓的 1T 机,即不对主频进行分频(传统8051CPU会对主频进行12分频使用)。这样的话:
1. 明显的,大约 22 个指令周期为 1 μs;
2. 根据1,每 100 μs 误差约为 -0.54 μs,大约相当于12个指令周期。
3. 根据2,每8 μs补偿一个指令周期,那么:每100 μs 误差 +0.0072 μs,误差率低于 0.01%,可以接受。

微秒级延时函数,误差在1个指令周期之内。
  1. void delayUs(unsigned char us) __naked {        // 6 入口
  2.         us;        // 抑制变量未用警告
  3. __asm
  4.         ; 第一个 μs 共 22T。用于出入口(已用 10T)
  5.         ; 第一个 μs 的前半部分,7T
  6.         MOV        A, DPL                        ; 2 DPL中是函数参数
  7.         DEC        A                        ; 2 减去第 1 个 μs
  8.         JZ        0001$                        ; 3 计数为0则直接跳到 1μs 的后半部分

  9.         ; 以下是第二个 μs,共22T。用于准备主循环
  10.         ; 第二个 μs 的前半部分,11T+3T
  11.         MOV        DPL, R0                        ; 3 保存R0
  12.         MOV        R0, A                        ; 2 以下用 R0 作为 μs 计数器
  13.         MOV        A, #6                        ; 2 补偿计数,去掉已过的 2μs
  14.         DJNZ        R0, 0003$                ; 4 减去第二个 μs。计数不为 0 则进入正常周期
  15.         SJMP        0002$                        ; 3 直接跳到 2μs 的后半部分

  16.         ; 以下是 3μs (含)之后周期延时部分,每周期 22T+1T(遇 8μs 周期时)
  17.         ; 补偿
  18.         0003$:
  19.         JNZ        0041$                        ; 3 如果未到补偿的时刻(A>0),跳过补偿部分
  20.         ; 这里是补偿部分,5T,比非补偿部分多1T
  21.         MOV        A, #7                        ; 2 每 8μs 补偿一次,当前这次自行减去
  22.         SJMP        0042$                        ; 3 回避非补偿部分
  23.         ; 这里是非补偿部分 4T
  24.         0041$:
  25.         DEC        A                        ; 2 计算补偿周期
  26.         NOP                                ; 1
  27.         NOP                                ; 1

  28.         ; 计算完补偿(7T)之后剩余的部分,15T
  29.         0042$:
  30.         CJNE        A, DPL, 0043$                ; 5
  31.         0043$:
  32.         CJNE        A, DPL, 0044$                ; 5
  33.         0044$:
  34.         NOP                                ; 1
  35.         DJNZ        R0, 0003$                ; 4 μs计数

  36.         ; 补偿 2μs 前半部分最后被跳过的 SJMP 指令
  37.         SJMP        0022$                        ; 3
  38.         0022$:
  39.         ; 以下是 2μs 的后半部分,8T
  40.         0002$:
  41.         SJMP        0021$                        ; 3
  42.         0021$:
  43.         NOP                                ; 1
  44.         MOV        R0, DPL                        ; 4

  45.         ; 以下是 1μs 的后半部分,5T
  46.         0001$:
  47.         CJNE        A, DPL, 0011$                ; 5
  48.         0011$:
  49.         RET                                                ; 4
  50. __endasm;
  51. }
复制代码

毫秒级延时函数,误差依然是1个指令周期。
  1. void delayMs(unsigned char ms) __naked {                // 6
  2.         ms;        // 抑制警告
  3. __asm
  4.         ; 第一个ms,共 35T + 10T(进出) + 5T(周期补偿) + 800us + 196us
  5.         ; 本应是34T+10T,但考虑错过了一次8us补偿,所以加到35T
  6.         ; 1ms 部分,共 40T(含周期补偿,不含出入部分)
  7.         ; 1ms 前半,21T
  8.         PUSH        _R0                        ; 4
  9.         PUSH        _R1                        ; 4
  10.         MOV        R0, DPL                        ; 4 用 R0 计 ms 数
  11.         MOV        R1, #4                        ; 3 前800us的循环计数
  12.         MOV        DPL, 198                ; 3 相当于从第一次循环中减去 2 us
  13.         SJMP        0001$                        ; 3 直接跳到 1ms 后半,直接跳入周期,所以补偿5T(见开头处)

  14.         ; 主体循环部分。每周期 45T + 998us
  15.         ; 本应 44T,考虑错过一次 8us 补偿
  16.         0002$:
  17.         MOV        R1, #4                        ; 2
  18.         0021$:
  19.         MOV        DPL, #200                ; 3 x 4 = 12
  20.         0001$:
  21.         LCALL        _delayUs                ; 200us x 4 = 800us
  22.         NOP                                ; 1 x 4 = 4
  23.         NOP                                ; 1 x 4 = 4
  24.         DJNZ        R1, 0021$                ; 4 x 4 = 16
  25.         MOV        DPL, #198                ; 3
  26.         LCALL        _delayUs                ; 198us
  27.         DJNZ        R0, 0002$                ; 4

  28.         ; 1ms 的后半 19T
  29.         NOP                                ; 1
  30.         MOV        R0, #2                        ; 2
  31.         0011$:
  32.         DJNZ        R0, 0011$                ; 4 x 2 = 8
  33.         POP                _R1                ; 4
  34.         POP                _R0                ; 4
  35.         RET                                ; 4
  36. __endasm;
  37. }
复制代码

最后,秒级延时函数。有了前面的基础,不必那么讲究了,直接用C写,误差也不过是10微秒这个级别。
  1. void delayS(unsigned char sec) {
  2.         unsigned char i;
  3.         unsigned char j;
  4.         for(i = 0; i < sec; ++i) {
  5.                 for(j = 0; j < 4; ++j)
  6.                         delayMs(250);
  7.         }
  8. }
复制代码
友情提示: 此问题已得到解决,问题已经关闭,关闭后问题禁止继续编辑,回答。
20条回答
hotman_x
2020-01-25 08:57
本帖最后由 hotman_x 于 2014-5-11 13:22 编辑
gliet_su 发表于 2014-5-11 11:40
定时器最精确


大部分情况下,定时器是比较准的。特别是在高频、流水线CPU环境下,比如对于PC来说,指令延时根本没有可能,而多媒体定时器完全可以实现微秒级的精确定时。

但在特定应用环境下则不然。无论如何,这里是51区,在需要精确定时的时候,指令延时比定时器靠谱。
最简单的定时器用法大概是这样:
1、预先准备好定时器状态;
2、到达需要延时的点位时,清除C标志位;
3、启动定时器,并轮询 C 标志位;
4、用汇编完成定时器中断响应,只有两条指令:SETB C 和 RETI

这已经是可以想像的最快定时器响应了,连中断跳转都可以不要,这两条指令只有 2 字节可以直接写在中断向量表里(这意味着你需要绕过 C 编译器亲自操刀,在PC编程中通常把这叫做 thunk 技术,不知道单片机领域怎么称呼)。但对于微秒级响应,这依然麻烦:轮询与响应过程本身,就有 1 微秒(以常见的 11.0592mHz 主频计)左右的消耗了。

一周热门 更多>