单片机高精度计时器电路原理图 PCB与源代码

（原创）51单片机高精度计时器电路原理图。采用AT89S52加DP8573，实现两个功能：带掉电保持功能的日历时钟、由外部开关信号触发的高精度计时，pcb文件与原理图配套，完全对应，可直接加工制作.
以上所有文件打包下载： 源码pcb等资料.rar (206.35 KB, 下载次数: 11)

2016-4-7 02:00 上传

点击文件名下载附件
下载积分: 黑币 -5

1. //********************************************************************
   
2. // Author        : Bing Wang
   
3. // Date          : Mar. 2017
   
4. // File          : msTIMER.c
   
5. // Hardware      : 89S51/89S52
   
6. //********************************************************************
   
7. 
   
8. #include <AT89X52.h>                // SFR definition file.
   
9. #include <stdio.h>
   
10. #include <absacc.h>                        //
    
11. #include <ctype.h>                        //
    
12. #include <stdlib.h>                        //
    
13. #include <math.h>
    
14. 
    
15. // Interface address definition
    
16. // DP8573AN RTC
    
17. xdata char DP8573SEC         _at_ 0x0600;
    
18. xdata char DP8573MIN         _at_ 0x0700;
    
19. xdata char DP8573HOUR         _at_ 0x0800;
    
20. xdata char DP8573WEEK         _at_ 0x0E00;
    
21. xdata char DP8573DAY         _at_ 0x0900;
    
22. xdata char DP8573MONTH        _at_ 0x0A00;
    
23. xdata char DP8573YEAR         _at_ 0x0B00;
    
24. 
    
25. xdata char DP8573SECs        _at_ 0x1900;        // Second Save
    
26. xdata char DP8573MINs         _at_ 0x1A00;        // Minute Save
    
27. xdata char DP8573HOURs        _at_ 0x1B00;        // Hour Save
    
28. xdata char DP8573DAYs        _at_ 0x1C00;        // Day Save
    
29. xdata char DP8573MONs        _at_ 0x1D00;        // Month Save
    
30. 
    
31. xdata char DP8573MSR         _at_ 0x0000;        // Main Status Register
    
32. xdata char DP8573PFR         _at_ 0x0400;        // Periodic Flag Register
    
33. xdata char DP8573TSCR         _at_ 0x0400;        // Time Save Control Register
    
34. xdata char DP8573RTMR         _at_ 0x0100;        // Real Time Mode Register
    
35. xdata char DP8573OMR         _at_ 0x0200;        // Output Mode Register
    
36. xdata char DP8573ICR0         _at_ 0x0300;        // Interrupt Control Register 0
    
37. xdata char DP8573ICR1         _at_ 0x0400;        // Interrupt Control Register 1
    
38. 
    
39. unsigned char msCNT, Tsecond;
    
40. unsigned char SecRTC, MinRTC, HourRTC, WeekRTC, DayRTC, MonthRTC, YearRTC;
    
41. unsigned char CmdOld, KeyCmd;
    
42. unsigned char second, secondOld, minute, minuteOld, hour, hourOld;
    
43. unsigned char day, dayOld, month, monthOld, year, yearOld, timeH, timeL;
    
44. 
    
45. void UART_Init(void)
    
46. {
    
47.         SCON = 0x50;        // Setup serial port ctrl reg
    
48.                                         // Mode 1: 8-bit uart var. baud rate
    
49.                                         // REN: enable receiver
    
50.         PCON &= 0x7F;        // Clear SMOD bit in power ctrl reg
    
51.                                         // This bit doubles the baud rate
    
52.         TMOD &= 0xCF;        // Clear M1 and M0 for timer 1
    
53.         TMOD |= 0x20;        // Set M1 for 8-bit autoreload timer
    
54.                                         // TMOD: Timer 1 Mode 2: 8-bit auto-reload timer
    
55.         TH1 = 213;                // 1200 baud with 20MHz xtal
    
56.         TR1 = 1;                // Start timer 1
    
57.         TI = 1;                        // Set TI to indicate ready to xmit
    
58. }
    
59. 
    
60. void DP8573A_Init(void)
    
61. {
    
62.         DP8573MSR = 0x40;        // RS=1
    
63.         DP8573ICR0 = 0x04;        // Interrupt every 1sec
    
64.         DP8573RTMR = 0x00;         // 24 hour mode + stop timer
    
65.         DP8573MSR = 0x00;        // RS=0
    
66.         DP8573PFR = 0x00;        // Clear INT flags + battery backup
    
67.         DP8573TSCR = 0x80;        // Time save enable
    
68.         DP8573SECs = 0x00;        // Clear saved second
    
69.         DP8573MINs = 0x00;        // Clear saved minute
    
70.         DP8573HOURs = 0x00;        // Clear saved hour
    
71.         DP8573DAYs = 0x00;        // Clear saved day
    
72.         DP8573MONs = 0x00;        // Clear saved month
    
73.         DP8573MSR = 0x44;        // RS=1, clear INT flag
    
74.         DP8573RTMR = 0x08;        // Clock start
    
75. }
    
76. 
    
77. void delay1s(void)
    
78. {
    
79.         unsigned int k;
    
80.         for (k=0;k<40000;k++);
    
81. }
    
82. 
    
83. void delay100ms(void)
    
84. {
    
85.         unsigned int k;
    
86.         for (k=0;k<2000;k++);
    
87. }
    
88. 
    
89. unsigned char KeyScan(void)
    
90. {
    
91.         unsigned char keypad;
    
92. 
    
93.         keypad = P1;
    
94.         keypad &= 0x1D;
    
95. 
    
96.         switch (keypad)
    
97.         {
    
98.                 case 0x1C:
    
99.                         keypad = 1;
    
100.                         break;
     
101.                 case 0x19:
     
102.                         keypad = 2;
     
103.                         break;
     
104.                 case 0x15:
     
105.                         keypad = 3;
     
106.                         break;
     
107.                 case 0x0D:
     
108.                         keypad = 4;
     
109.                         break;
     
110.                 default:
     
111.                         keypad = 0;
     
112.                         break;
     
113.         }
     
114.         return keypad;
     
115. }
     
116. 
     
117. void AdjustRTC(void)
     
118. {
     
119.         unsigned char EndCMD, Para, ParaOld, ParaValue;
     
120. 
     
121.         SecRTC = DP8573SEC;
     
122.         SecRTC = (SecRTC>>4)*10 + (SecRTC%16);
     
123.         MinRTC = DP8573MIN;
     
124.         MinRTC = (MinRTC>>4)*10 + (MinRTC%16);
     
125.         HourRTC = DP8573HOUR;
     
126.         HourRTC = (HourRTC>>4)*10 + (HourRTC%16);
     
127.         DayRTC = DP8573DAY;
     
128.         DayRTC = (DayRTC>>4)*10 + (DayRTC%16);
     
129.         MonthRTC = DP8573MONTH;
     
130.         MonthRTC = (MonthRTC>>4)*10 + (MonthRTC%16);
     
131.         YearRTC = DP8573YEAR;
     
132.         YearRTC = (YearRTC>>4)*10 + (YearRTC%16);
     
133.         EndCMD = 0;
     
134.         Para = ParaOld = 0;
     
135.         CmdOld = 0;
     
136. 
     
137.         while (!EndCMD) {
     
138.                 if (KeyCmd != CmdOld) {
     
139.                         switch (KeyCmd) {
     
140.                                 case 1:                                        // Setting
     
141.                                         Para += 1;
     
142.                                         if (Para >= 7) { Para = 0; EndCMD = 1; }
     
143.                                         break;
     
144.                                 case 2:                                        // +
     
145.                                         switch(Para) {
     
146.                                                 case 1:                        // Year
     
147.                                                         if (YearRTC >= 99) YearRTC = 0;
     
148.                                                         else YearRTC++;
     
149.                                                         putchar(16);        // Set cursor to the last 2 chars
     
150.                                                         putchar(14);
     
151.                                                         putchar((YearRTC/10)+48);
     
152.                                                         putchar((YearRTC%10)+48);
     
153.                                                         break;
     
154.                                                 case 2:                        // Month
     
155.                                                         if (MonthRTC >= 12) MonthRTC = 1;
     
156.                                                         else MonthRTC++;
     
157.                                                         putchar(16);        // Set cursor to the last 2 chars
     
158.                                                         putchar(14);
     
159.                                                         putchar((MonthRTC/10)+48);
     
160.                                                         putchar((MonthRTC%10)+48);
     
161.                                                         break;
     
162.                                                 case 3:                        // Day
     
163.                                                         if (DayRTC >= 31) DayRTC = 1;
     
164.                                                         else DayRTC++;
     
165.                                                         putchar(16);        // Set cursor to the last 2 chars
     
166.                                                         putchar(14);
     
167.                                                         putchar((DayRTC/10)+48);
     
168.                                                         putchar((DayRTC%10)+48);
     
169.                                                         break;
     
170.                                                 case 4:                        // Hour
     
171.                                                         if (HourRTC >= 24) HourRTC = 0;
     
172.                                                         else HourRTC++;
     
173.                                                         putchar(16);        // Set cursor to the last 2 chars
     
174.                                                         putchar(14);
     
175.                                                         putchar((HourRTC/10)+48);
     
176.                                                         putchar((HourRTC%10)+48);
     
177.                                                         break;
     
178.                                                 case 5:                        // Minute
     
179.                                                         if (MinRTC >= 59) MinRTC = 0;
     
180.                                                         else MinRTC++;
     
181.                                                         putchar(16);        // Set cursor to the last 2 chars
     
182.                                                         putchar(14);
     
183.                                                         putchar((MinRTC/10)+48);
     
184.                                                         putchar((MinRTC%10)+48);
     
185.                                                         break;
     
186.                                                 case 6:                        // Second
     
187.                                                         if (SecRTC >= 59) SecRTC = 0;
     
188.                                                         else SecRTC++;
     
189.                                                         putchar(16);        // Set cursor to the last 2 chars
     
190.                                                         putchar(14);
     
191.                                                         putchar((SecRTC/10)+48);
     
192.                                                         putchar((SecRTC%10)+48);
     
193.                                                         break;
     
194.                                                 default:
     
195.                                                         break;
     
196.                                         }
     
197.                                         break;
     
198.                                 case 3:                                        // -
     
199.                                         switch(Para) {
     
200.                                                 case 1:                        // Year
     
201.                                                         if (YearRTC == 0) YearRTC = 99;
     
202.                                                         else YearRTC--;
     
203.                                                         putchar(16);        // Set cursor to the last 2 chars
     
204.                                                         putchar(14);
     
205.                                                         putchar((YearRTC/10)+48);
     
206.                                                         putchar((YearRTC%10)+48);
     
207.                                                         break;
     
208.                                                 case 2:                        // Month
     
209.                                                         if (MonthRTC == 1) MonthRTC = 12;
     
210.                                                         else MonthRTC--;
     
211.                                                         putchar(16);        // Set cursor to the last 2 chars
     
212.                                                         putchar(14);
     
213.                                                         putchar((MonthRTC/10)+48);
     
214.                                                         putchar((MonthRTC%10)+48);
     
215.                                                         break;
     
216.                                                 case 3:                        // Day
     
217.                                                         if (DayRTC == 1) DayRTC = 31;
     
218.                                                         else DayRTC--;
     
219.                                                         putchar(16);        // Set cursor to the last 2 chars
     
220.                                                         putchar(14);
     
221.                                                         putchar((DayRTC/10)+48);
     
222.                                                         putchar((DayRTC%10)+48);
     
223.                                                         break;
     
224.                                                 case 4:                        // Hour
     
225.                                                         if (HourRTC == 0) HourRTC = 24;
     
226.                                                         else HourRTC--;
     
227.                                                         putchar(16);        // Set cursor to the last 2 chars
     
228.                                                         putchar(14);
     
229.                                                         putchar((HourRTC/10)+48);
     
230.                                                         putchar((HourRTC%10)+48);
     
231.                                                         break;
     
232.                                                 case 5:                        // Minute
     
233.                                                         if (MinRTC == 0) MinRTC = 59;
     
234.                                                         else MinRTC--;
     
235.                                                         putchar(16);        // Set cursor to the last 2 chars
     
236.                                                         putchar(14);
     
237.                                                         putchar((MinRTC/10)+48);
     
238.                                                         putchar((MinRTC%10)+48);
     
239.                                                         break;
     
240.                                                 case 6:                        // Second
     
241.                                                         if (SecRTC == 0) SecRTC = 59;
     
242.                                                         else SecRTC--;
     
243.                                                         putchar(16);        // Set cursor to the last 2 chars
     
244.                                                         putchar(14);
     
245.                                                         putchar((SecRTC/10)+48);
     
246.                                                         putchar((SecRTC%10)+48);
     
247.                                                         break;
     
248.                                                 default:
     
249.                                                         break;
     
250.                                         }
     
251.                                         break;
     
252.                                 case 4:                                        // Enter
     
253.                                         ParaValue = ((SecRTC/10)*16) + (SecRTC%10);
     
254.                                         SecRTC = ParaValue;
     
255.                                         ParaValue = ((MinRTC/10)*16) + (MinRTC%10);
     
256.                                         MinRTC = ParaValue;
     
257.                                         ParaValue = ((HourRTC/10)*16) + (HourRTC%10);
     
258.                                         HourRTC = ParaValue;
     
259.                                         ParaValue = ((DayRTC/10)*16) + (DayRTC%10);
     
260.                                         DayRTC = ParaValue;
     
261.                                         ParaValue = ((MonthRTC/10)*16) + (MonthRTC%10);
     
262.                                         MonthRTC = ParaValue;
     
263.                                         ParaValue = ((YearRTC/10)*16) + (YearRTC%10);
     
264.                                         YearRTC = ParaValue;
     
265.        
     
266.                                         DP8573MSR = 0x40;        // RS=1
     
267.                                         DP8573RTMR = 0x00;         // 24 hour mode + stop timer
     
268.                                         DP8573SEC = SecRTC;
     
269.                                         DP8573MIN = MinRTC;
     
270.                                         DP8573HOUR = HourRTC;
     
271.                                         DP8573DAY = DayRTC;
     
272.                                         DP8573MONTH = MonthRTC;
     
273.                                         DP8573YEAR = YearRTC;
     
274.                                         DP8573MSR = 0x40;        // RS=1
     
275.                                         DP8573RTMR = 0x08;         // 24 hour mode + run timer
     
276.                                         EndCMD = 1;
     
277.                                         Para = 0;
     
278.                                         break;
     
279.                                 default:
     
280.                                         break;
     
281.                         }
     
282.                         // Display setting
     
283.                         if (ParaOld != Para) {
     
284.                                 putchar(13);
     
285.                                 ParaOld = Para;
     
286.                                 switch(Para) {
     
287.                                         case 1:                        // Year
     
288.                                                 printf("Year:");
     
289.                                                 putchar(16);        // Set cursor to the last 2 chars
     
290.                                                 putchar(14);
     
291.                                                 putchar((YearRTC/10)+48);
     
292.                                                 putchar((YearRTC%10)+48);
     
293.                                                 break;
     
294.                                         case 2:                        // Month
     
295.                                                 printf("Month:");
     
296.                                                 putchar(16);        // Set cursor to the last 2 chars
     
297.                                                 putchar(14);
     
298.                                                 putchar((MonthRTC/10)+48);
     
299.                                                 putchar((MonthRTC%10)+48);
     
300.                                                 break;
     
301.                                         case 3:                        // Day
     
302.                                                 printf("Day:");
     
303.                                                 putchar(16);        // Set cursor to the last 2 chars
     
304.                                                 putchar(14);
     
305.                                                 putchar((DayRTC/10)+48);
     
306.                                                 putchar((DayRTC%10)+48);
     
307.                                                 break;
     
308.                                         case 4:                        // Hour
     
309.                                                 printf("Hour:");
     
310.                                                 putchar(16);        // Set cursor to the last 2 chars
     
311.                                                 putchar(14);
     
312.                                                 putchar((HourRTC/10)+48);
     
313.                                                 putchar((HourRTC%10)+48);
     
314.                                                 break;
     
315.                                         case 5:                        // Minute
     
316.                                                 printf("Minute:");
     
317.                                                 putchar(16);        // Set cursor to the last 2 chars
     
318.                                                 putchar(14);
     
319.                                                 putchar((MinRTC/10)+48);
     
320.                                                 putchar((MinRTC%10)+48);
     
321.                                                 break;
     
322.                                         case 6:                        // Second
     
323.                                                 printf("Second:");
     
324.                                                 putchar(16);        // Set cursor to the last 2 chars
     
325.                                                 putchar(14);
     
326.                                                 putchar((SecRTC/10)+48);
     
327.                                                 putchar((SecRTC%10)+48);
     
328.                                                 break;
     
329.                                         default:
     
330.                                                 break;
     
331.                                 }        // End SWITCH
     
332.                         }                // End if(ParaOld != Para)
     
333.                 }                        // End if(KeyCmd != CmdOld)
     
334.                 CmdOld = KeyCmd;
     
335.                 KeyCmd = KeyScan();
     
336.         }                                 // End while(!EndCMD)
     
337. //        CmdOld = KeyCmd;
     
338. //        putchar(7);                        // Cursor back 1 char
     
339. //        putchar(23);                // Cursor blinking
     
340. }
     
341. 
     
342. void DisplayRTC(void)
     
343. {
     
344.         putchar(13);
     
345.         hour = DP8573HOUR;                // Hour
     
346.         timeH = hour >> 4;
     
347.         putchar(timeH+48);
     
348.         timeL = hour % 16;
     
349.         putchar(timeL+48);
     
350.         putchar(':');
     
351.        
     
352.         minute = DP8573MIN;                // Minute
     
353.         timeH = minute >> 4;
     
354.         putchar(timeH+48);
     
355.         timeL = minute % 16;
     
356.         putchar(timeL+48);
     
357.         putchar(':');
     
358. 
     
359.         second = DP8573SEC;                // Second
     
360.         timeH = second >> 4;
     
361.         putchar(timeH+48);
     
362.         timeL = second % 16;
     
363.         putchar(timeL+48);
     
364. 
     
365.         putchar(' ');
     
366.         putchar(' ');
     
367.         year = DP8573YEAR;                // Year
     
368.         timeH = year >> 4;
     
369.         putchar(timeH+48);
     
370.         putchar(25);                        // .
     
371.         putchar(3);
     
372.         timeL = year % 16;
     
373.         putchar(timeL+48);
     
374. 
     
375.         month = DP8573MONTH;        // Month
     
376.         timeH = month >> 4;
     
377.         putchar(timeH+48);
     
378.         putchar(25);                        // .
     
379.         putchar(3);
     
380.         timeL = month % 16;
     
381.         putchar(timeL+48);
     
382. 
     
383.         day = DP8573DAY;                // Day
     
384.         timeH = day >> 4;
     
385.         putchar(timeH+48);
     
386.         timeL = day % 16;
     
387.         putchar(timeL+48);
     
388. 
     
389.         secondOld = second;
     
390.         minuteOld = minute;
     
391.         hourOld =  hour;
     
392.         yearOld = year;
     
393.         monthOld = month;
     
394.         dayOld = day;
     
395. }
     
396. 
     
397. void msTimer(void) interrupt 0 using 0  {
     
398.   if (++msCNT == 1)  {        /* 1s */
     
399.     Tsecond++;                        /* second counter    */
     
400.     msCNT = 0;                        /* clear int counter */
     
401.   }
     
402. }
     
403. 
     
404. main()
     
405. {
     
406.         UART_Init();
     
407.         delay1s();
     
408.         delay100ms();
     
409.         putchar(15);        // Set VFD brightness
     
410.         delay100ms();
     
411.         putchar(0x20);        // Lowest brightness to reduce power consumption
     
412. 
     
413.         // user-defined char #1: \05 \01; show with \01
     
414.         putchar(5); putchar(1);
     
415.         // SHI: 02 39 17 EE 45 A2 B1 C8 04 06 00
     
416.         putchar(0x02);
     
417.         putchar(0x39);
     
418.         putchar(0x17);
     
419.         putchar(0xEE);
     
420.         putchar(0x45);
     
421.         putchar(0xA2);
     
422.         putchar(0xB1);
     
423.         putchar(0xC8);
     
424.         putchar(0x04);
     
425.         putchar(0x06);
     
426.         putchar(0x00);
     
427.         // user-defined char #2: \05 \02; show with \02
     
428.         putchar(5); putchar(2);
     
429.         // JIAN: 40 17 90 4B A5 52 E9 54 BA 43 00
     
430.         putchar(0x40);
     
431.         putchar(0x17);
     
432.         putchar(0x90);
     
433.         putchar(0x4B);
     
434.         putchar(0xA5);
     
435.         putchar(0x52);
     
436.         putchar(0xE9);
     
437.         putchar(0x54);
     
438.         putchar(0xBA);
     
439.         putchar(0x43);
     
440.         putchar(0x00);
     
441.         // user-defined char #3: \05 \03; show with \03
     
442.         putchar(5); putchar(3);
     
443.         // RI: 00 1F 08 84 43 E1 10 88 7C 00 00
     
444.         putchar(0x00);
     
445.         putchar(0x1F);
     
446.         putchar(0x08);
     
447.         putchar(0x84);
     
448.         putchar(0x43);
     
449.         putchar(0xE1);
     
450.         putchar(0x10);
     
451.         putchar(0x88);
     
452.         putchar(0x7C);
     
453.         putchar(0x00);
     
454.         putchar(0x00);
     
455.         // user-defined char #4: \05 \04; show with \04
     
456.         putchar(5); putchar(4);
     
457.         // QI: 50 7F 95 4E E7 52 BB F4 AA 55 01 =or= 50 7D D4 AE 77 2A 9F EA A5 95 80
     
458.         putchar(0x50);
     
459.         putchar(0x7F);
     
460.         putchar(0x95);
     
461.         putchar(0x4E);
     
462.         putchar(0xE7);
     
463.         putchar(0x52);
     
464.         putchar(0xBB);
     
465.         putchar(0xF4);
     
466.         putchar(0xAA);
     
467.         putchar(0x55);
     
468.         putchar(0x01);
     
469. 
     
470.         putchar(22);        // Hide cursor
     
471.         putchar(13);        // Reset display
     
472.         putchar(1);
     
473.         putchar(2);
     
474.         putchar(':');
     
475.         putchar(16);        // Set cursor position
     
476.         putchar(11);
     
477.         putchar(3);
     
478.         putchar(4);
     
479.         putchar('-');
     
480. 
     
481.         delay1s();
     
482.         DP8573A_Init();
     
483.         P1 = 0x7F;                // P1: 1DO + 7DI
     
484.         delay1s();
     
485. 
     
486.         // Used to set RTC
     
487. /*        DP8573MSR = 0x40;
     
488.         DP8573RTMR = 0x00;
     
489.         DP8573MIN = 54;
     
490.         DP8573HOUR = 24;
     
491.         DP8573DAY = 24;
     
492.         DP8573MONTH = 3;
     
493.         DP8573YEAR = 7;
     
494.         DP8573MSR = 0x40;
     
495.         DP8573RTMR = 0x08;
     
496. */
     
497.         DisplayRTC();
     
498.         delay1s();
     
499.         delay1s();
     
500.         CmdOld = KeyScan();
     
501. 
     
502.         while(1)
     
503.         {
     
504.                 hour = DP8573HOUR;                // Hour
     
505.                 if (hour != hourOld) {
     
506.                         putchar(16);                // Set cursor position
     
507.                         putchar(0);
     
508.                         timeH = hour >> 4;
     
509.                         putchar(timeH+48);
     
510.                         timeL = hour % 16;
     
511.                         putchar(timeL+48);
     
512.                         putchar(':');
     
513.                         hourOld = hour;
     
514.                 }
     
515.                 minute = DP8573MIN;                // Minute
     
516.                 if (minute != minuteOld) {
     
517.                         putchar(16);                // Set cursor position
     
518.                         putchar(3);
     
519.                         timeH = minute >> 4;
     
520.                         putchar(timeH+48);
     
521.                         timeL = minute % 16;
     
522.                         putchar(timeL+48);
     
523.                         putchar(':');
     
524.                         minuteOld = minute;
     
525.                 }
     
526.                 second = DP8573SEC;                // Second
     
527.                 if (second != secondOld) {
     
528.                         putchar(16);                // Set cursor position
     
529.                         putchar(6);
     
530.                         timeH = second >> 4;
     
531.                         putchar(timeH+48);
     
532.                         timeL = second % 16;
     
533.                         putchar(timeL+48);
     
534.                         secondOld = second;
     
535.                 }
     
536.                 year = DP8573YEAR;
     
537.                 if (year != yearOld) {
     
538.                         putchar(16);                // Set cursor position
     
539.                         putchar(10);
     
540.                         timeH = year >> 4;
     
541.                         putchar(timeH+48);
     
542.                         timeL = year % 16;
     
543.                         putchar(timeL+48);
     
544.                         yearOld = year;
     
545.                 }
     
546.                 month = DP8573MONTH;
     
547.                 if (month != monthOld) {
     
548.                         putchar(16);                // Set cursor position
     
549.                         putchar(12);
     
550.                         timeH = month >> 4;
     
551.                         putchar(timeH+48);
     
552.                         timeL = month % 16;
     
553.                         putchar(timeL+48);
     
554.                         yearOld = year;
     
555.                 }
     
556.                 day = DP8573DAY;
     
557.                 if (day != dayOld) {
     
558.                         putchar(16);                // Set cursor position
     
559.                         putchar(14);
     
560.                         timeH = day >> 4;
     
561.                         putchar(timeH+48);
     
562.                         timeL = day % 16;
     
563.                         putchar(timeL+48);
     
564.                         dayOld = day;
     
565.                 }
     
566. 
     
567.                 KeyCmd = KeyScan();
     
568.                 if (KeyCmd == 1) {                // RTC adjustment
     
569.                         AdjustRTC();
     
570.                         DisplayRTC();
     
571.                 }
     
572.         }
     
573. }

复制代码

谢谢楼主，最近正好想做这个计时器用于CNC计算稼动率。