51单片机

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

2020-01-23 14:44发布

站内问答 / 51单片机
1788 20 20
本帖最后由 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 的后半部分

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

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

  31.         ; 计算完补偿（7T）之后剩余的部分，15T
  32.         0042$:
  33.         CJNE        A, DPL, 0043$                ; 5
  34.         0043$:
  35.         CJNE        A, DPL, 0044$                ; 5
  36.         0044$:
  37.         NOP                                ; 1
  38.         DJNZ        R0, 0003$                ; 4 μs计数

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

  50.         ; 以下是 1μs 的后半部分，5T
  51.         0001$:
  52.         CJNE        A, DPL, 0011$                ; 5
  53.         0011$:
  54.         RET                                                ; 4
  55. __endasm;
  56. }
复制代码

毫秒级延时函数，误差依然是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（见开头处）

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

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

最后，秒级延时函数。有了前面的基础，不必那么讲究了，直接用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 主频计）左右的消耗了。

一周热门 更多>