51单片机，用郭天祥的板子做了一个电子表，发现时间很不准，求教问题在哪里

1. //本程序是基于6位数码管做的电子钟
   
2. //前两位显示小时，中间两位显示==，后面两位显示分钟
   
3. //按键1按一次进入调整小时，按两次调整分钟，按三次恢复正常
   
4. //调整小时时，小时数每秒闪一次，分钟数同理。
   
5. #include <mydec.h>
   
6. #include <tianxiang.h>
   
7. uchar hour,min,sec;
   
8. uchar count1,count2,count3,count4,count5,count6;
   
9. uchar cnt1,cnt2,cnt3,key,cnt4,status;
   
10. bit flag1,flag2,flag3;
    
11. void main()
    
12. {
    
13.         flag1=0;
    
14.         flag2=0;flag3=0;
    
15. 
    
16.         //        中断控制
    
17.         TMOD=0x01;
    
18.         TH0=(65536-10000)/256;
    
19.         TL0=(65536-10000)%256;
    
20.        
    
21.        
    
22.         EA=1;
    
23.         ET0=1;
    
24.         TR0=1;
    
25.         hour=19;
    
26.         min=57;       
    
27. 
    
28. 
    
29.         while(1)
    
30.         {
    
31.                 count1=hour/10;
    
32.                 count2=hour%10;
    
33.                 count5=min/10;
    
34.                 count6=min%10;
    
35. 
    
36.                 if(flag3)
    
37.                 {
    
38.                         count2=16;
    
39.                         count1=16;
    
40.                 }
    
41.             if(flag2)
    
42.           {
    
43.                   count5=16;
    
44.                 count6=16;
    
45.           }
    
46.                                 //6
    
47.                            weixuan=1;
    
48.                         P0=0x5f;
    
49.                         weixuan=0;
    
50.                        
    
51.        
    
52.                         duanxuan=1;
    
53.                         P0=num[count6];
    
54.                         duanxuan=0;               
    
55.                         delay(2);
    
56.                 //5
    
57.                            weixuan=1;
    
58.                         P0=0x6f;
    
59.                         weixuan=0;
    
60.                        
    
61.        
    
62.                         duanxuan=1;
    
63.                         P0=num[count5];
    
64.                         duanxuan=0;               
    
65.                         delay(2);
    
66.                
    
67.                
    
68.                 //4
    
69.                    weixuan=1;
    
70.                 P0=0x77;
    
71.                 weixuan=0;
    
72.        
    
73. 
    
74.                 duanxuan=1;
    
75.                 P0=count4;
    
76.                 duanxuan=0;               
    
77.                 delay(2);               
    
78.                             //3
    
79.                    weixuan=1;
    
80.                 P0=0x7b;
    
81.                 weixuan=0;
    
82.        
    
83. 
    
84.                
    
85.                         duanxuan=1;
    
86.                         P0=count3;
    
87.                         duanxuan=0;               
    
88.                         delay(2);
    
89. 
    
90. 
    
91.                                         //2
    
92.                            weixuan=1;
    
93.                         P0=0x7d;
    
94.                         weixuan=0;
    
95.                
    
96.        
    
97.                         duanxuan=1;
    
98.                         P0=num[count2];
    
99.                         duanxuan=0;               
    
100.                         delay(2);
     
101.        
     
102.                                         //1
     
103.                            weixuan=1;
     
104.                         P0=0x7e;
     
105.                         weixuan=0;
     
106.                
     
107.        
     
108.                         duanxuan=1;
     
109.                         P0=num[count1];
     
110.                        
     
111.                         duanxuan=0;               
     
112.                         delay(2);
     
113.                
     
114.        
     
115. //检测按键
     
116.                 if(P3！=0XFF)
     
117.                 {
     
118.                         delay(1);
     
119.                         if(P3！=0XFF)
     
120.                         {       
     
121.                                 key=P3;
     
122.                                 //若没松键，则不操作
     
123.                                 if(flag1==0)
     
124.                                 {
     
125.                                         flag1=1;
     
126.                                         //change mode
     
127.                                         if(key==0xef)                               
     
128.                                                 status++;
     
129.                                                 if(status>=3)
     
130.                                                 status=0;
     
131.                                                 //change value
     
132.                                         else if(key==0xdf)
     
133.                                         {
     
134.                                                 if(status==1)
     
135.                                                 {
     
136.                                                         hour++;
     
137.                                                         hour=hour%24;
     
138.                                                  }
     
139.                                                  else if(status==2)
     
140.                                                  {
     
141.                                                          min++;
     
142.                                                         min=min%60;
     
143.                                                  }
     
144.                                                  
     
145.                                        
     
146.                                         }               
     
147. 
     
148.                                        
     
149. 
     
150.                                   }
     
151.                                                  
     
152.                         }
     
153.                         //无按键则按下标志清0
     
154.                         else flag1=0;       
     
155.                 }
     
156.                 else flag1=0;
     
157.        
     
158.        
     
159.         }  //end while
     
160. 
     
161. 
     
162. 
     
163. 
     
164. }
     
165. 
     
166. 
     
167. void time0() interrupt 1
     
168. {
     
169.         //10MS中断
     
170.         TH0=(65536-10000)/256;
     
171.         TL0=(65536-10000)%256;
     
172.         cnt1++;
     
173.         cnt2++;
     
174.         cnt4++;
     
175.         if(cnt2==50)
     
176.         {
     
177.                 cnt2=0;
     
178.                 count3=count3^9;
     
179.                 count4=count4^9;
     
180.                
     
181.                         if(status==1)
     
182.                         {       
     
183.                                 if(！count3)
     
184.                                 flag3=1;
     
185.                                 else flag3=0;
     
186.                                 flag2=0;
     
187.                         }
     
188.                         else if(status==2)
     
189.                         {
     
190.                                 if(！count3)
     
191.                                         flag2=1;
     
192.                                 else flag2=0;
     
193.                                 flag3=0;
     
194.                          }
     
195.                         else {flag2=0;flag3=0;}
     
196.                                
     
197.         }
     
198.         //1秒
     
199.         if(cnt1==100)
     
200.         {
     
201.                 cnt1=0;
     
202.                 sec++;
     
203.                 if(sec==60)
     
204.                 {
     
205.                         sec=0;
     
206.                         min++;
     
207.                 }
     
208.                 if(min>=60)
     
209.                 {
     
210.                         min=0;
     
211.                         hour++;
     
212.                 }
     
213.                 if(hour>=24)
     
214.                 {
     
215.                         hour=0;
     
216.                 }
     
217.                        
     
218. 
     
219. 
     
220.                
     
221.         }
     
222. 
     
223. 
     
224. 
     
225.                
     
226. }

把中断装入初值改下，用定时器也不会蛮准，因为中断函数也会有误差，慢慢调。我感觉就是到后面误差会越来越大，如果真要做还是用时钟芯片好

1小时差5分钟的原因在于你的工作方式选择不正确，方式1在每次中断后需要重新给定时器赋初值。修改如下：
标准51的时钟频率只能使用6MHz、12MHz或24MHz；假设时钟频率为12MHz，则每秒钟有1M个机器周期。
在main()的前面定义一个16位无符号整型变量，用来讲录中断次数，例如：
unsigned int temp=0;        //用来计1秒钟的中断次数
定时器初始化语句：
TMOD=0x02;        //自动重载初值的8位计数器
TH0=6;
TL0=6;                //中断一次共250个机器周期
按上面的设置，每秒钟中断4000次，T0的参考中断服务函数如下：
void timer0() interrupt 1
{
        temp++;
        if(temp==4000)
        {
                temp=0;
                sec++;
                if(sec==60)
                {
                        sec=0;
                        min++;
                        if(min==60)
                        {
                                min=0;       
                                hour++;
                                if(hour==24)
                                hour=0;
                        }
                }
        }
}
中断服务函数需要标志位的修改请自己完成。

单片机的主频累计的误差大，不可能做电子表。

晶振频率是11.0592Mhz的吧

时间的处理不要在中断中做，不然很可能会有孔径误差。在中断中设个标志，在外面做秒钟加1