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++;
        }
}

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
   
6. 
   
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控制寄存器
    
21. 
    
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;    //秒标志
    
34. 
    
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. }
     
102. 
     
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. }
     
120. 
     
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. }
     
155. 
     
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. }
     
164. 
     
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. }
     
202. 
     
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. }
     
260. 
     
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. }
     
281. 
     
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. }
     
298. 
     
299. void Timer0() interrupt 1
     
300. {
     
301.         if(++usec>=fixtime)  //1sec
     
302.         {
     
303.                 usec = 0;
     
304.                 sec_flag=1;
     
305.         }
     
306. }

复制代码

如果仅用单片机内部时钟，除调整晶振频率等硬件外，软件通过调整定时器的初值，计算值加实验修正。
想获得精准时钟，直接外部时钟便宜且方便。

用方式2，自动重载模式。定时到比如100us。这样就只有相邻误差，没有累计误差。
晶振匹配不同的电容，实际的频率也是有误差的。这个补偿要累计去计算的，比如1个月后，误差多少个ms，平均每天或每小时差多少个ms（这个值小于1000），到整天或整小时的时候调整（根据实际情况去加或减。加好办，注意减的处理）。
仅提供一种思路做参考。。

给你一个程序框架，自己补充完整。可以做到日误差<10秒

1. #include <reg51.h>
   
2. #define uint unsigned int
   
3. #define uchar unsigned char
   
4. 
   
5. sbit key1=P3^4;
   
6. sbit key2=P3^5;
   
7. 
   
8. uchar sec,min,hour;
   
9. uint  usec=0;
   
10. uint  fixtime=10000; //定义修正变量
    
11. bit   sec_flag=0;                //秒标志
    
12. 
    
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. }
    
22. 
    
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. }
    
45. 
    
46. void display()//显示程序
    
47. {
    
48.         //显示
    
49. }
    
50. 
    
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. }
    
71. 
    
72. void main()
    
73. {
    
74.         time0_init();
    
75.         while(1)
    
76.         {
    
77.                 keyscan();
    
78.                 Timing();
    
79.                 display();
    
80.         }
    
81. }
    
82. 
    
83. void Timer0() interrupt 1
    
84. {
    
85.         if(++usec>=fixtime)  //1sec
    
86.         {
    
87.                 usec = 0;
    
88.                 sec_flag=1;
    
89.         }
    
90. }

复制代码

carpcarey 发表于 2020-5-19 11:34
用方式2，自动重载模式。定时到比如100us。这样就只有相邻误差，没有累计误差。
晶振匹配不同的电容，实际 ...

为什么我修改成方式2之后，1602显示的数值都不会变了。只修改了定时器的配置。定时时间是100us

让钟运行较长一段时间，比如10-20小时，看误差万分之多少，根据误差调整fixtime的值。一次可能不行，多试几次，应该能不断减小误差。调整到每天误差几十秒应该是可以的，要进一步提高比较困难，因为使用按键时会对程序的执行时间有影响。

LOVEqing 发表于 2020-5-19 17:44
为什么我修改成方式2之后，1602显示的数值都不会变了。只修改了定时器的配置。定时时间是100us

看看代码

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;
}

大概是这样

wulin 发表于 2020-5-19 16:35
给你一个程序框架，自己补充完整。可以做到日误差

请问老哥.51单片机都不初始化IO口吗? 还有就是晶振频率,以及上下拉打开不打开. 还有看门狗也不初始化??

中断里面处理尽可能快，所以你的很多代码可以放到中断外，中断里面就是一个简单的累加就好了。

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.

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了

carpcarey 发表于 2020-5-20 17:21
u8 msc  不对 u16 msc因为后面 if (msec == 10000)          //1sec = 1000ms
如果u8 msc，始终不会等于 ...

哦哦哦 是的呢，忘记了

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

哈哈哈哈哈，有道理，主要是手头没有开发板，没法实物测试。你这都把钟基本做出来了

高精度必须自动重载初值，定时器0中断内不能向TH0和TL0寄存器赋值，有多个中断注意优先级问题。

定时器工作于自动重装模式，本身不会造成误差。
我用一个有源恒温晶振，北斗模块校准过，作为单片机（STC8H4K64TL）的时钟，定时器工作于16位自动重装模式，1年的误差不超过0.3秒。