标题: 51单片机做数字钟 定时器中断有误差 如何提高精度 [打印本页]
作者: LOVEqing    时间: 2020-5-18 18:59
标题: 51单片机做数字钟 定时器中断有误差 如何提高精度
    使用51单片机做一个简单的数字钟，但是用定时器中断时，进入中断服务函数时会有机器周期，会产生误差。    怎么减少这种误差？或者如果用补偿的方式增加定时器的初值，应该怎么计算需要补偿的数值？
    以下部分代码是我使用补偿修正值的方式，但是修正值不正确。

u8 fixtime; //定义修正变量

void time0_init(void)
{
        TMOD |= 0X01;  //选择为定时器0模式，工作方式1，仅用TR0打开启动。

        TH0 = 0XD8;           //给定时器赋初值，定时10ms
        TL0 = 0XF0;       
        ET0 = 1;       //打开定时器0中断允许
        EA = 1;        //打开总中断
        TR0 = 1;       //打开定时器                       
}

void Timer0() interrupt 1
{
        EA = 0;//禁止所有中断请求
        TR0 = 0;//关闭T0
        fixtime = TL0 + 0X1B;//将TL0中已计数值写入fixtime，并加上修正操作占用的27个机器周期
        TL0 = 0XF0 + fixtime;//将修正值写入TL0
        TH0 = 0XD8 + (char)CY;//修正TL0时可能产生进位，要补偿到TH0
        EA = 1;//允许所有中断请求
        TR0 = 1;//开启TR0
        msec++;
        if(msec == 100)          //1sec = 1000ms
        {
                msec = 0;
                sec++;
        }
        if(sec == 60)            //1min = 60sec
        {
                sec = 0;
                min++;
        }
        if(min == 60)            //1hour = 60min
        {
                min = 0;
                hour++;
        }
}


作者: wulin    时间: 2020-5-18 18:59
LOVEqing 发表于 2020-5-20 18:47
#include
#include "lcd.h"
#define uint unsigned int

仿真受PC时钟影响，不一定准，要用实物验证。仿真用不了STC89C52的EEPROM保存fixtime变量。给你基本补齐了。






  1. //适用STC89C52RC单片机
  2. #include <reg52.h>
  3. #include <intrins.h>
  4. #define uint unsigned int
  5. #define uchar unsigned char

  7. //定义ISP的操作命令
  8. #define RdCommand 0x01                //读命令
  9. #define PrgCommand 0x02                //写命令
  10. #define EraseCommand 0x03        //擦除命令
  11. #define Error 1
  12. #define Ok 0
  13. #define WaitTime 0x01                 //定义CPU的等待时间,写入硬件延时
  14. //STC89系列EEPROM寄存器声明
  15. sfr ISP_DATA=0xe2;                //0000,0000 EEPROM数据寄存器
  16. sfr ISP_ADDRH=0xe3;                //0000,0000 EEPROM地址高字节
  17. sfr ISP_ADDRL=0xe4;                //0000,0000 EEPROM地址第字节
  18. sfr ISP_CMD=0xe5;                //xxxx,xx00 EEPROM命令寄存器
  19. sfr ISP_TRIG=0xe6;                //0000,0000 EEPRPM命令触发寄存器
  20. sfr ISP_CONTR=0xe7;                //0000,x000 EEPROM控制寄存器

  22. sbit key0=P3^3;
  23. sbit key1=P3^4;
  24. sbit key2=P3^5;
  25. sbit rs=P2^6;         //寄存器选择信号 H:数据寄存器          L:指令寄存器
  26. sbit rw=P2^5;         //寄存器选择信号 H:数据寄存器          L:指令寄存器
  27. sbit e =P2^7;         //片选信号   下降沿触发
  28. uchar sec=0,min=0,hour=12;
  29. uchar num=0;
  30. uint  usec=0;
  31. //uint  fixtime=10000; //定义修正变量
  32. uint  fixtime;        //定义修正变量
  33. bit   sec_flag=0;    //秒标志

  35. // 打开 ISP,IAP 功能
  36. void ISP_IAP_enable(void)
  37. {
  38.         EA = 0;       /* 关中断   */
  39.         ISP_CONTR = ISP_CONTR & 0x18;       /* 0001,1000 */
  40.         ISP_CONTR = ISP_CONTR | WaitTime; /* 写入硬件延时 */
  41.         ISP_CONTR = ISP_CONTR | 0x80;       /* ISPEN=1  */
  42. }
  43. // 关闭 ISP,IAP 功能
  44. void ISP_IAP_disable(void)
  45. {
  46.         ISP_CONTR = ISP_CONTR & 0x7f; /* ISPEN = 0 */
  47.         ISP_TRIG = 0x00;
  48.         EA   =   1;   /* 开中断 */
  49. }
  50. // 公用的触发代码
  51. void ISPgoon(void)
  52. {
  53.         ISP_IAP_enable();   /* 打开 ISP,IAP 功能 */
  54.         ISP_TRIG = 0x46;  /* 触发ISP_IAP命令字节1 */
  55.         ISP_TRIG = 0xb9;  /* 触发ISP_IAP命令字节2 */
  56.         _nop_();
  57. }
  58. // 字节读
  59. unsigned char byte_read(unsigned int byte_addr)
  60. {
  61.         ISP_ADDRH = (unsigned char)(byte_addr >> 8);/* 地址赋值 */
  62.         ISP_ADDRL = (unsigned char)(byte_addr & 0x00ff);
  63.         ISP_CMD   = ISP_CMD & 0xf8;   /* 清除低3位  */
  64.         ISP_CMD   = ISP_CMD | RdCommand; /* 写入读命令 */
  65.         ISPgoon();       /* 触发执行  */
  66.         ISP_IAP_disable();    /* 关闭ISP,IAP功能 */
  67.         return (ISP_DATA);    /* 返回读到的数据 */
  68. }
  69. // 扇区擦除
  70. void SectorErase(unsigned int sector_addr)
  71. {
  72.         unsigned int iSectorAddr;
  73.         iSectorAddr = (sector_addr & 0xfe00); /* 取扇区地址 */
  74.         ISP_ADDRH = (unsigned char)(iSectorAddr >> 8);
  75.         ISP_ADDRL = 0x00;
  76.         ISP_CMD = ISP_CMD & 0xf8;   /* 清空低3位  */
  77.         ISP_CMD = ISP_CMD | EraseCommand; /* 擦除命令3  */
  78.         ISPgoon();       /* 触发执行  */
  79.         ISP_IAP_disable();    /* 关闭ISP,IAP功能 */
  80. }
  81. // 字节写
  82. void byte_write(unsigned int byte_addr, unsigned char original_data)
  83. {
  84.         ISP_ADDRH = (unsigned char)(byte_addr >> 8);  /* 取地址  */
  85.         ISP_ADDRL = (unsigned char)(byte_addr & 0x00ff);
  86.         ISP_CMD  = ISP_CMD & 0xf8;    /* 清低3位 */
  87.         ISP_CMD  = ISP_CMD | PrgCommand;  /* 写命令2 */
  88.         ISP_DATA = original_data;   /* 写入数据准备 */
  89.         ISPgoon();       /* 触发执行  */
  90.         ISP_IAP_disable();     /* 关闭IAP功能 */
  91. }
  92. /********************************************************************
  93. * 名称 : delay_uint()
  94. * 功能 : 小延时。
  95. * 输入 : 无
  96. * 输出 : 无
  97. ***********************************************************************/
  98. void delay_uint(uint i)
  99. {
  100.         while(--i);
  101. }

  103. /********************************************************************
  104. * 名称 : write_com(uchar com)
  105. * 功能 : 1602命令函数
  106. * 输入 : 输入的命令值
  107. * 输出 : 无
  108. ***********************************************************************/
  109. void write_com(uchar com)
  110. {
  111.         e=0;
  112.         rs=0;
  113.         rw=0;
  114.         P0=com;
  115.         delay_uint(25);
  116.         e=1;
  117.         delay_uint(25);
  118.         e=0;
  119. }

  121. /********************************************************************
  122. * 名称 : write_data(uchar dat)
  123. * 功能 : 1602写数据函数
  124. * 输入 : 需要写入1602的数据
  125. * 输出 : 无
  126. ***********************************************************************/
  127. void write_data(uchar dat)
  128. {
  129.         e=0;
  130.         rs=1;
  131.         rw=0;
  132.         P0=dat;
  133.         delay_uint(25);
  134.         e=1;
  135.         delay_uint(25);
  136.         e=0;       
  137. }
  138. /***********************lcd1602初始化设置************************/
  139. void init_1602()
  140. {
  141.         write_com(0x38);       
  142.         write_com(0x0c);
  143.         write_com(0x06);
  144.         write_com(0x01);
  145. }
  146. void time0_init(void)
  147. {
  148.     TMOD = 0x02;//自动重装
  149.     TH0 = 0x9C; //100us
  150.     TL0 = 0x9C;
  151.     EA = 1;
  152.     ET0 = 1;
  153.     TR0 = 1;
  154. }

  156. void LCD1602_init(void)
  157. {
  158.         uchar i;
  159.         uchar a[]=" Digital Clock  ";
  160.         write_com(0x80);
  161.         for(i=0;i<16;i++)
  162.                 write_data(a[i]);
  163. }

  165. void display(void)
  166. {
  167.         write_com(0xc0+13);
  168.         if(num==0)
  169.                 write_data(' ');
  170.         else if(num==1)
  171.                 write_data('H');
  172.         else if(num==2)
  173.                 write_data('M');
  174.         else if(num==3)
  175.                 write_data('S');
  176.         write_com(0x80+0x44);
  177.         if(num==4)
  178.         {
  179.                 write_data('F');
  180.                 write_data('=');
  181.                 write_data('=');
  182.                 write_data(fixtime/10000%10+'0');
  183.                 write_data(fixtime/1000%10+'0');
  184.                 write_data(fixtime/100%10+'0');
  185.                 write_data(fixtime/10%10+'0');
  186.                 write_data(fixtime%10+'0');
  187.                 write_data(' ');
  188.                 write_data(' ');
  189.         }
  190.         else
  191.         {
  192.                 write_data(hour/10+'0');
  193.                 write_data(hour%10+'0');
  194.                 write_data(':');
  195.                 write_data(min/10+'0');
  196.                 write_data(min%10+'0');
  197.                 write_data(':');
  198.                 write_data(sec/10+'0');
  199.                 write_data(sec%10+'0');
  200.         }
  201. }

  203. void keyscan()
  204. {
  205.         static bit key_lock=0;        //按键自锁标志
  206.         static uchar count=0;        //消抖计数变量               
  207.         uchar i=0,a,b;
  208.         if(!key0||!key1||!key2)
  209.         {
  210.                 if(++count>=10 && key_lock==0)
  211.                 {
  212.                         key_lock=1;//自锁
  213.                         if(!key0)
  214.                         {
  215.                                 num++;
  216.                                 num%=5;
  217.                         }
  218.                         if(!key1 && num>0)
  219.                         {
  220.                                 switch(num)
  221.                                 {
  222.                                         case 1: hour++;if(hour>=24)hour=0; break;
  223.                                         case 2: min++; if(min>=60) min=0;  break;
  224.                                         case 3: sec++; if(sec>=60) sec=0;  break;
  225.                                         case 4: fixtime++;
  226.                                                         a=fixtime>>8;
  227.                                                         b=fixtime;
  228.                                                         SectorErase(0x2000);//擦除扇区
  229.                                                         byte_write(0x2000,a);//重新写入数据高8位
  230.                                                         byte_write(0x2001,b);//重新写入数据低8位
  231.                                                         break;
  232.                                         default:  break;
  233.                                 }
  234.                         }
  235.                         if(!key2 && num>0)
  236.                         {
  237.                                 switch(num)
  238.                                 {
  239.                                         case 1: hour--;if(hour>=24)hour=23; break;
  240.                                         case 2: min--; if(min>=60) min=59;  break;
  241.                                         case 3: sec--; if(sec>=60) sec=59;  break;
  242.                                         case 4: fixtime--;
  243.                                                         a=fixtime>>8;
  244.                                                         b=fixtime;
  245.                                                         SectorErase(0x2000);//擦除扇区
  246.                                                         byte_write(0x2000,a);//重新写入数据高8位
  247.                                                         byte_write(0x2001,b);//重新写入数据低8位
  248.                                                         break;
  249.                                         default:  break;
  250.                                 }
  251.                         }
  252.                 }
  253.         }
  254.         else   //松手
  255.         {
  256.                 count=0;
  257.                 key_lock=0;
  258.         }
  259. }

  261. void Timing()//计时程序
  262. {
  263.         if(sec_flag)
  264.         {
  265.                 sec_flag=0;
  266.                 sec++;
  267.                 if(sec >= 60)
  268.                 {
  269.                         sec = 0;
  270.                         min++;
  271.                         if(min >= 60)
  272.                         {
  273.                                 min = 0;
  274.                                 hour++;
  275.                                 if(hour >= 24)
  276.                                         hour=0;
  277.                         }
  278.                 }
  279.         }
  280. }

  282. void main()
  283. {
  284.         init_1602();
  285.         LCD1602_init();
  286.         fixtime=byte_read(0x2000);//程序开始时读取EEPROM中数据
  287.         fixtime=fixtime<<8|byte_read(0x2001);//合并为整形数据
  288.         if(fixtime>15000||fixtime<5000) //防止首次上电时读取出错
  289.                 fixtime=10000;
  290.         time0_init();
  291.         while(1)
  292.         {
  293.                 keyscan();
  294.                 Timing();
  295.                 display();
  296.         }
  297. }

  299. void Timer0() interrupt 1
  300. {
  301.         if(++usec>=fixtime)  //1sec
  302.         {
  303.                 usec = 0;
  304.                 sec_flag=1;
  305.         }
  306. }
复制代码



STC99封装.zip

26.37 KB, 下载次数: 7
作者: man1234567    时间: 2020-5-19 11:08
如果仅用单片机内部时钟，除调整晶振频率等硬件外，软件通过调整定时器的初值，计算值加实验修正。
想获得精准时钟，直接外部时钟便宜且方便。
作者: carpcarey    时间: 2020-5-19 11:34
用方式2，自动重载模式。定时到比如100us。这样就只有相邻误差，没有累计误差。
晶振匹配不同的电容，实际的频率也是有误差的。这个补偿要累计去计算的，比如1个月后，误差多少个ms，平均每天或每小时差多少个ms（这个值小于1000），到整天或整小时的时候调整（根据实际情况去加或减。加好办，注意减的处理）。
仅提供一种思路做参考。。
作者: wulin    时间: 2020-5-19 16:35
给你一个程序框架，自己补充完整。可以做到日误差<10秒
  1. #include <reg51.h>
  2. #define uint unsigned int
  3. #define uchar unsigned char

  5. sbit key1=P3^4;
  6. sbit key2=P3^5;

  8. uchar sec,min,hour;
  9. uint  usec=0;
  10. uint  fixtime=10000; //定义修正变量
  11. bit   sec_flag=0;                //秒标志

  13. void time0_init(void)
  14. {
  15.     TMOD = 0x02;//自动重装
  16.     TH0 = 0x9C; //100us
  17.     TL0 = 0x9C;
  18.     EA = 1;
  19.     ET0 = 1;
  20.     TR0 = 1;
  21. }

  23. void keyscan()
  24. {
  25.         static bit key_lock=0;        //按键自锁标志
  26.         static uchar count=0;        //消抖计数变量               
  27.         if(!key1||!key2)
  28.         {
  29.                 if(++count>=100 && key_lock==0)
  30.                 {
  31.                         key_lock=1;//自锁
  32.                         if(!key1)
  33.                                 fixtime++;
  34.                         if(!key2)
  35.                                 fixtime--;
  36.                 }
  37.         }
  38.         else   //松手
  39.         {
  40.                 count=0;
  41.                 key_lock=0;
  42.         }
  43.         //其它调时语句
  44. }

  46. void display()//显示程序
  47. {
  48.         //显示
  49. }

  51. void Timing()//计时程序
  52. {
  53.         if(sec_flag)
  54.         {
  55.                 sec_flag=0;
  56.                 sec++;
  57.                 if(sec >= 60)
  58.                 {
  59.                         sec = 0;
  60.                         min++;
  61.                         if(min >= 60)
  62.                         {
  63.                                 min = 0;
  64.                                 hour++;
  65.                                 if(hour >= 24)
  66.                                         hour=0;
  67.                         }
  68.                 }
  69.         }
  70. }

  72. void main()
  73. {
  74.         time0_init();
  75.         while(1)
  76.         {
  77.                 keyscan();
  78.                 Timing();
  79.                 display();
  80.         }
  81. }

  83. void Timer0() interrupt 1
  84. {
  85.         if(++usec>=fixtime)  //1sec
  86.         {
  87.                 usec = 0;
  88.                 sec_flag=1;
  89.         }
  90. }
复制代码
作者: LOVEqing    时间: 2020-5-19 17:44
carpcarey 发表于 2020-5-19 11:34
用方式2，自动重载模式。定时到比如100us。这样就只有相邻误差，没有累计误差。
晶振匹配不同的电容，实际 ...

为什么我修改成方式2之后，1602显示的数值都不会变了。只修改了定时器的配置。定时时间是100us
作者: hotpet    时间: 2020-5-19 20:42
让钟运行较长一段时间，比如10-20小时，看误差万分之多少，根据误差调整fixtime的值。一次可能不行，多试几次，应该能不断减小误差。调整到每天误差几十秒应该是可以的，要进一步提高比较困难，因为使用按键时会对程序的执行时间有影响。
作者: carpcarey    时间: 2020-5-20 09:09
LOVEqing 发表于 2020-5-19 17:44
为什么我修改成方式2之后，1602显示的数值都不会变了。只修改了定时器的配置。定时时间是100us

看看代码
作者: LOVEqing    时间: 2020-5-20 16:51
carpcarey 发表于 2020-5-20 09:09
看看代码

#include "reg52.h"
#include "lcd.h"

#define u8 unsigned char
#define u16 unsigned int
       
u8 init[] = "0123456789";
u8 msec;       //毫秒
u8 sec;        //秒
u8 min;        //分
u8 hour;       //时

void LCD1602_init(void)
{
        LcdWriteCom(0x01);
        LcdWriteData(' ');
        LcdWriteData('D');
        LcdWriteData('i');
        LcdWriteData('g');
        LcdWriteData('i');
        LcdWriteData('t');
        LcdWriteData('a');
        LcdWriteData('l');
        LcdWriteData(' ');
        LcdWriteData(' ');
        LcdWriteData('C');
        LcdWriteData('l');
        LcdWriteData('o');
        LcdWriteData('c');
        LcdWriteData('k');
        LcdWriteData(' ');
}

void LCD1602_show(void)
{
        LcdWriteCom(0x80 + 0x40);
        LcdWriteData(init[hour / 10]);
        LcdWriteData(init[hour % 10]);
        LcdWriteData(':');
        LcdWriteData(init[min / 10]);
        LcdWriteData(init[min % 10]);
        LcdWriteData(':');
        LcdWriteData(init[sec / 10]);
        LcdWriteData(init[sec % 10]);
}
void time0_init(void)
{
        TMOD = 0X02;  //选择为定时器0模式，工作方式2，仅用TR0打开启动。

        TH0 = 0X9C;           //给定时器赋初值，定时0.1ms
        TL0 = 0X9C;       
        ET0 = 1;       //打开定时器0中断允许
        EA = 1;        //打开总中断
        TR0 = 1;       //打开定时器
}

void main(void)
{
                LcdInit();
                time0_init();
                LCD1602_init();
                while(1)
                {
                                LCD1602_show();
                }
}

void Timer0(void) interrupt 1
{
        msec++;
        if(msec == 10000)          //1sec = 1000ms
        {
                msec = 0;
                sec++;
        }
        if(sec == 60)            //1min = 60sec
        {
                sec = 0;
                min++;
        }
        if(min == 60)            //1hour = 60min
        {
                min = 0;
                hour++;
        }
        if(hour == 24)
                        hour = 0;
}

大概是这样
作者: xqleft    时间: 2020-5-20 17:03
wulin 发表于 2020-5-19 16:35
给你一个程序框架，自己补充完整。可以做到日误差

请问老哥.51单片机都不初始化IO口吗? 还有就是晶振频率,以及上下拉打开不打开. 还有看门狗也不初始化??
作者: 294479435    时间: 2020-5-20 17:03
中断里面处理尽可能快，所以你的很多代码可以放到中断外，中断里面就是一个简单的累加就好了。
作者: carpcarey    时间: 2020-5-20 17:21
LOVEqing 发表于 2020-5-20 16:51
#include "reg52.h"
#include "lcd.h"

u8 msc  不对 u16 msc因为后面 if (msec == 10000)          //1sec = 1000ms
如果u8 msc，始终不会等于10000的，最大只能255.
作者: LOVEqing    时间: 2020-5-20 18:47
wulin 发表于 2020-5-19 16:35
给你一个程序框架，自己补充完整。可以做到日误差

#include <reg52.h>
#include "lcd.h"
#define uint unsigned int
#define uchar unsigned char

uchar init[] = "0123456789";

sbit key1=P3^4;
sbit key2=P3^5;

uchar sec,min,hour;
uint  usec=0;
uint  fixtime=10000; //定义修正变量
bit   sec_flag=0;                //秒标志

void time0_init(void)
{
    TMOD = 0x02;//自动重装
    TH0 = 0x9C; //100us
    TL0 = 0x9C;
    EA = 1;
    ET0 = 1;
    TR0 = 1;
}

void LCD1602_init(void)
{
        LcdWriteCom(0x01);
        LcdWriteData(' ');
        LcdWriteData('D');
        LcdWriteData('i');
        LcdWriteData('g');
        LcdWriteData('i');
        LcdWriteData('t');
        LcdWriteData('a');
        LcdWriteData('l');
        LcdWriteData(' ');
        LcdWriteData(' ');
        LcdWriteData('C');
        LcdWriteData('l');
        LcdWriteData('o');
        LcdWriteData('c');
        LcdWriteData('k');
        LcdWriteData(' ');
}

void LCD1602_show(void)
{
        LcdWriteCom(0x80 + 0x40);
        LcdWriteData(init[hour / 10]);
        LcdWriteData(init[hour % 10]);
        LcdWriteData(':');
        LcdWriteData(init[min / 10]);
        LcdWriteData(init[min % 10]);
        LcdWriteData(':');
        LcdWriteData(init[sec / 10]);
        LcdWriteData(init[sec % 10]);
}

void keyscan()
{
        static bit key_lock=0;        //按键自锁标志
        static uchar count=0;        //消抖计数变量               
        if(!key1||!key2)
        {
                if(++count>=100 && key_lock==0)
                {
                        key_lock=1;//自锁
                        if(!key1)
                                fixtime++;
                        if(!key2)
                                fixtime--;
                }
        }
        else   //松手
        {
                count=0;
                key_lock=0;
        }
        //其它调时语句
}

void display()//显示程序
{
      LCD1602_show();  //显示
}

void Timing()//计时程序
{
        if(sec_flag)
        {
                sec_flag=0;
                sec++;
                if(sec >= 60)
                {
                        sec = 0;
                        min++;
                        if(min >= 60)
                        {
                                min = 0;
                                hour++;
                                if(hour >= 24)
                                        hour=0;
                        }
                }
        }
}

void main()
{
        time0_init();
        LcdInit();
        LCD1602_init();

        while(1)
        {
                keyscan();
                Timing();
                display();
        }
}

void Timer0() interrupt 1
{
        if(++usec>=fixtime)  //1sec
        {
                usec = 0;
                sec_flag=1;
        }
}

我就增加了1602显示，用protues仿真，然后误差还是蛮大的，大概1602显示25s的时候 手机秒表已经跑到28了
作者: LOVEqing    时间: 2020-5-21 10:11
carpcarey 发表于 2020-5-20 17:21
u8 msc  不对 u16 msc因为后面 if (msec == 10000)          //1sec = 1000ms
如果u8 msc，始终不会等于 ...

哦哦哦 是的呢，忘记了
作者: LOVEqing    时间: 2020-5-21 19:00
wulin 发表于 2020-5-21 12:09
仿真受PC时钟影响，不一定准，要用实物验证。仿真用不了STC89C52的EEPROM保存fixtime变量。给你基本补齐 ...

哈哈哈哈哈，有道理，主要是手头没有开发板，没法实物测试。你这都把钟基本做出来了
作者: npn    时间: 2023-3-8 14:52
高精度必须自动重载初值，定时器0中断内不能向TH0和TL0寄存器赋值，有多个中断注意优先级问题。
作者: coody_sz    时间: 2023-3-8 17:10
定时器工作于自动重装模式，本身不会造成误差。
我用一个有源恒温晶振，北斗模块校准过，作为单片机（STC8H4K64TL）的时钟，定时器工作于16位自动重装模式，1年的误差不超过0.3秒。



欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1