代码:

1. #include <reg52.h>
   
2. #include <intrins.h>
   
3. #define uint unsigned int
   
4. #define uchar unsigned char
   
5. uchar code table[]="MONTUEWEDTHUFRISATSUNMAX TEMPMIN TEMPALARM!      ";
   
6. int i;//存放温度的值的变量
   
7. char settempmax,settempmin,n;
   
8. uchar temp,sumup,count,hundredms,L,M,C_qian,C_bai,C_shi,C_ge,tempmax;
   
9. uchar shi=3,fen=3,miao=3,nian=3,yue=3,week=3,ri=3,s1num=0,s2num,s3num,s4num,num,fiftyms;
   
10. float f_temp;
    
11. uint Int_temp;
    
12. sbit du=P2^6;
    
13. sbit we=P2^7;
    
14. sbit di=P2^3;
    
15. sbit lcdrs=P3^5;
    
16. sbit lcdwr=P3^6;
    
17. sbit lcden=P3^4;
    
18. sbit s1=P3^0;
    
19. sbit s2=P3^1;
    
20. sbit s3=P3^2;
    
21. sbit s4=P3^3;
    
22. sbit rd=P3^7;
    
23. sbit TSCLK=P1^0;
    
24. sbit TIO=P1^1;
    
25. sbit TRST=P1^2;
    
26. sbit ds=P2^2;
    
27. 
    
28. void delay(uint xms)
    
29. {
    
30.         uint i,j;
    
31.         for(i=xms;i>0;i--)
    
32.                 for(j=110;j>0;j--);
    
33. }
    
34. 
    
35. void delay_us(uchar us)
    
36. {
    
37.         while(us--);
    
38. }
    
39. void write_com(uchar com)
    
40. {
    
41.         lcdrs=0;
    
42.         lcden=0;
    
43.         P0=com;
    
44.         delay(5);
    
45.         lcden=1;
    
46.         delay(5);
    
47.         lcden=0;
    
48. }
    
49. void write_date(uchar date)
    
50. {
    
51.         lcdrs=1;
    
52.         lcden=0;                                                                                                                  
    
53.         P0=date;
    
54.         delay(5);
    
55.         lcden=1;
    
56.         delay(5);
    
57.         lcden=0;
    
58. }  
    
59. 
    
60. void lcdinit()
    
61. {
    
62.         du=0;
    
63.         we=0;
    
64.         lcdwr=0;
    
65.         lcden=0;
    
66.         write_com(0x38);
    
67.         write_com(0x0c);
    
68.         write_com(0x06);
    
69.         write_com(0x01);
    
70. }
    
71. 
    
72. 
    
73. void write_sfm(uchar add,uchar date)
    
74. {
    
75.         uchar shi,ge;
    
76.         shi=date/10;
    
77.         ge=date%10;
    
78.         write_com(0x80+0x40+add);
    
79.         write_date(0x30+shi);
    
80.         write_date(0x30+ge);
    
81. }
    
82. void write_nyr(uchar add,uchar date)
    
83. {
    
84.         uchar shi,ge;
    
85.         shi=date/10;
    
86.         ge=date%10;
    
87.         write_com(0x80+add);
    
88.         write_date(0x30+shi);
    
89.         write_date(0x30+ge);
    
90. }
    
91. void write_miaobiao(uchar add,uchar date)
    
92. {
    
93.         uchar shi,ge;
    
94.         shi=date/10;
    
95.         ge=date%10;
    
96.         write_com(0x80+0x40+add);
    
97.         write_date(0x30+shi);
    
98.         write_date(0x30+ge);
    
99. }
    
100. 
     
101. void write_wendu(uchar add,uchar date)
     
102. {
     
103.         write_com(0x80+add);
     
104.         write_date(0x30+date);
     
105. }
     
106. 
     
107. void wendufuhaoinit()
     
108. {
     
109.         write_com(0x80+0x40+7);//写一个字母T
     
110.         write_date(0x54);
     
111.         write_com(0x80+0x40+8);//写一个等号=
     
112.         write_date(0x3d);
     
113.         write_com(0x80+0x40+11);//写小数点
     
114.         write_date(0x2e);
     
115.         write_com(0x80+0x40+14);//设置摄氏度符号
     
116.         write_date(0xdf);
     
117.         write_com(0x80+0x40+15);
     
118.         write_date(0x43);
     
119. }
     
120. 
     
121. void wendufuhao2init()
     
122. {
     
123.         write_com(0x80+7);//写一个字母T
     
124.         write_date(0x54);
     
125.         write_com(0x80+8);//写一个等号=
     
126.         write_date(0x3d);
     
127.         write_com(0x80+11);//写小数点
     
128.         write_date(0x2e);
     
129.         write_com(0x80+14);//设置摄氏度符号
     
130.         write_date(0xdf);
     
131.         write_com(0x80+15);
     
132.         write_date(0x43);
     
133. }
     
134. void write_ds1302(uchar cmd,uchar dat)
     
135. {
     
136.         uchar i;
     
137.         TRST=0;
     
138.         TSCLK=0;
     
139.         TRST=1;
     
140.         for(i=0;i<8;i++)
     
141.         {
     
142.                 TSCLK=0;
     
143.                 TIO=cmd&0x01;
     
144.                 TSCLK=1;
     
145.                 cmd>>=1;
     
146.         }
     
147.         for(i=0;i<8;i++)
     
148.         {
     
149.                 TSCLK=0;
     
150.                 TIO=dat&0x01;
     
151.                 TSCLK=1;
     
152.                 dat>>=1;
     
153.         }
     
154.         TRST=0;
     
155. }
     
156. 
     
157. uchar read_ds1302(uchar cmd)
     
158. {
     
159.         uchar i,dat;
     
160.         TRST=0;
     
161.         TSCLK=0;
     
162.         TRST=1;
     
163.         for(i=0;i<8;i++)
     
164.         {
     
165.                 TSCLK=0;
     
166.                 TIO=cmd&0x01;
     
167.                 TSCLK=1;
     
168.                 cmd>>=1;
     
169.         }
     
170.         for(i=0;i<8;i++)
     
171.         {
     
172.                 TSCLK=0;
     
173.                 dat>>=1;
     
174.                 if(TIO)
     
175.                 dat=dat|0x80;        
     
176.                 TSCLK=1;
     
177.         }
     
178.         TRST=0;
     
179.         return dat;
     
180. }
     
181. 
     
182. //数据转BCD码
     
183. uchar dat_chg_bcd(uchar dat)
     
184. {
     
185.         uchar dat1,dat2;
     
186.         dat1=dat/10;
     
187.         dat2=dat%10;
     
188.         dat2=dat2+dat1*16;
     
189.         return dat2;
     
190. }
     
191. //bcd码转数据
     
192. uchar bcd_chg_dat(uchar dat)
     
193. {
     
194.         uchar dat1,dat2;
     
195.         dat1=dat/16;
     
196.         dat2=dat%16;
     
197.         dat2=dat2+dat1*10;
     
198.         return dat2;
     
199. }
     
200. 
     
201. void ds1302_init()
     
202. {
     
203.         write_ds1302(0x8e,0);
     
204.         write_ds1302(0x80,dat_chg_bcd(miao));
     
205.         write_ds1302(0x82,dat_chg_bcd(fen));
     
206.         write_ds1302(0x84,dat_chg_bcd(shi));
     
207.         write_ds1302(0x86,dat_chg_bcd(ri));
     
208.         write_ds1302(0x88,dat_chg_bcd(yue));
     
209.         write_ds1302(0x8a,dat_chg_bcd(week));
     
210.         write_ds1302(0x8c,dat_chg_bcd(nian));
     
211.         write_ds1302(0x8e,0x80);
     
212. }
     
213. 
     
214. bit ds18b20_init()
     
215. {
     
216.         bit i;
     
217.         ds=1;
     
218.         _nop_();
     
219.         ds=0;
     
220.         delay_us(75);
     
221.         ds=1;
     
222.         delay_us(4);
     
223.         i=ds;
     
224.         delay_us(20);
     
225.         ds=1;
     
226.         _nop_();
     
227.         return (i);
     
228. }
     
229. 
     
230. void write_ds(uchar dat)
     
231. {
     
232.         uchar i;
     
233.         for(i=0;i<8;i++)
     
234.         {
     
235.                 ds=0;
     
236.                 _nop_();
     
237.                 ds=dat&0x01;
     
238.                 delay_us(10);
     
239.                 ds=1;
     
240.                 _nop_();
     
241.                 dat>>=1;
     
242.         }
     
243. }
     
244. 
     
245. uchar read_ds()
     
246. {
     
247.         uchar i,j,dat;
     
248.         for(i=0;i<8;i++)
     
249.         {
     
250.                 ds=0;
     
251.                 _nop_();
     
252.                 ds=1;
     
253.                 _nop_();
     
254.                 j=ds;
     
255.                 delay_us(10);
     
256.                 ds=1;
     
257.                 _nop_();
     
258.                 dat=(j<<=7)|dat>>1;        
     
259.         }        
     
260.         return (dat);
     
261. }
     
262. 
     
263. void keyscan()
     
264. {
     
265.         rd=0;
     
266.         if(s1==0)
     
267.         {
     
268.                 delay(5);
     
269.                 if(s1==0)
     
270.                 {        
     
271.                         while(!s1);
     
272.                         s1num++;
     
273.                         di=0;        
     
274.                         delay(800);        
     
275.                         di=1;
     
276.                         while(s1num==1)
     
277.                         {        
     
278.                                 if(s1==0)
     
279.                                 {
     
280.                                         delay(5);
     
281.                                         if(s1==0)
     
282.                                         {
     
283.                                                 s1num++;
     
284.                                         }
     
285.                                 }        
     
286.                                 if(s2==0)
     
287.                                 {
     
288.                                         delay(5);
     
289.                                         if(s2==0)
     
290.                                         {
     
291.                                                 di=0;
     
292.                                                 while(!s2);
     
293.                                                 di=1;
     
294.                                                 s2num++;
     
295.                                                 if(s2num==1)
     
296.                                                 {
     
297.                                                         write_com(0x80+0x40+10);//把指针定到秒的位置
     
298.                                                         write_com(0x0f);//开光标闪烁（开一次就行了）
     
299.                                                 }
     
300.                                                 if(s2num==2)
     
301.                                                 {
     
302.                                                         write_com(0x80+0x40+7);
     
303.                                                 }
     
304.                                                 if(s2num==3)
     
305.                                                 {
     
306.                                                         write_com(0x80+0x40+4);
     
307.                                                 }
     
308.                                                 if(s2num==4)
     
309.                                                 {
     
310.                                                         write_com(0x80+13);
     
311.                                                 }
     
312.                                                 if(s2num==5)
     
313.                                                 {
     
314.                                                         write_com(0x80+11);
     
315.                                                 }
     
316.                                                 if(s2num==6)
     
317.                                                 {
     
318.                                                         write_com(0x80+8);
     
319.                                                 }
     
320.                                                 if(s2num==7)
     
321.                                                 {
     
322.                                                         write_com(0x80+5);
     
323.                                                 }
     
324.                                                 if(s2num==8)
     
325.                                                 {
     
326.                                                         write_com(0x80+0x40+10);
     
327.                                                         s2num=0;
     
328.                                                 }
     
329.                                         }
     
330.                                 }
     
331.                                 if(s3==0)
     
332.                                 {
     
333.                                         delay(5);
     
334.                                         if(s3==0)
     
335.                                         {
     
336.                                                 di=0;
     
337.                                                 while(!s3);
     
338.                                                 di=1;
     
339.                                                 if(s2num==1)
     
340.                                                 {
     
341.                                                         miao++;
     
342.                                                         if(miao==60)
     
343.                                                         miao=0;
     
344.                                                         write_sfm(9,miao);
     
345.                                                 }
     
346.                                                 if(s2num==2)        
     
347.                                                 {
     
348.                                                         fen++;
     
349.                                                         if(fen==60)
     
350.                                                         fen=0;
     
351.                                                         write_sfm(6,fen);
     
352.                                                 }
     
353.                                                 if(s2num==3)
     
354.                                                 {
     
355.                                                         shi++;
     
356.                                                         if(shi==24)
     
357.                                                         shi=0;
     
358.                                                         write_sfm(3,shi);
     
359.                                                 }
     
360.                                                 if(s2num==4)
     
361.                                                 {
     
362.                                                         week++;
     
363.                                                         if(week==8)
     
364.                                                         week=1;
     
365.                                                         write_nyr(13,week);
     
366.                                                 }
     
367.                                                 if(s2num==5)
     
368.                                                 {
     
369.                                                         ri++;
     
370.                                                         if(ri==32)
     
371.                                                         ri=1;
     
372.                                                         write_nyr(10,ri);
     
373.                                                 }
     
374.                                                 if(s2num==6)        
     
375.                                                 {
     
376.                                                         yue++;
     
377.                                                         if(yue==13)
     
378.                                                         yue=1;
     
379.                                                         write_nyr(7,yue);
     
380.                                                 }
     
381.                                                 if(s2num==7)
     
382.                                                 {
     
383.                                                         nian++;
     
384.                                                         if(nian==99)
     
385.                                                         nian=0;
     
386.                                                         write_nyr(4,nian);
     
387.                                                 }
     
388.                                         }
     
389.                                 }
     
390.                                 if(s4==0)
     
391.                                 {                     
     
392.                                         delay(5);
     
393.                                         if(s4==0)
     
394.                                         {
     
395.                                                 di=0;
     
396.                                                 while(!s4);
     
397.                                                 di=1;
     
398.                                                 if(s2num==1)
     
399.                                                 {
     
400.                                                         miao--;
     
401.                                                         if(miao==0)
     
402.                                                         miao=59;
     
403.                                                         write_sfm(9,miao);
     
404.                                                 }
     
405.                                                 if(s2num==2)        
     
406.                                                 {
     
407.                                                         fen--;
     
408.                                                         if(fen==0)
     
409.                                                         fen=59;
     
410.                                                         write_sfm(6,fen);
     
411.                                                 }
     
412.                                                 if(s2num==3)
     
413.                                                 {
     
414.                                                         shi--;
     
415.                                                         if(shi==0)
     
416.                                                                 shi=23;
     
417.                                                         write_sfm(3,shi);
     
418.                                                 }
     
419.                                                 if(s2num==4)
     
420.                                                 {
     
421.                                                         week--;
     
422.                                                         if(week==0)
     
423.                                                                 week=7;
     
424.                                                         write_nyr(13,week);
     
425.                                                 }
     
426.                                                 if(s2num==5)
     
427.                                                 {
     
428.                                                         ri--;
     
429.                                                         if(ri==1)
     
430.                                                         ri=31;
     
431.                                                         write_nyr(10,ri);
     
432.                                                 }
     
433.                                                 if(s2num==6)        
     
434.                                                 {
     
435.                                                         yue--;
     
436.                                                         if(yue==1)
     
437.                                                         yue=12;
     
438.                                                         write_nyr(7,yue);
     
439.                                                 }
     
440.                                                 if(s2num==7)
     
441.                                                 {
     
442.                                                         nian--;
     
443.                                                         if(nian==0)
     
444.                                                         nian=99;
     
445.                                                         write_nyr(4,nian);
     
446.                                                 }
     
447.                                         }
     
448.                                  }               
     
449.                         }
     
450.                         write_ds1302(0x8e,0);
     
451.                         write_ds1302(0x80,dat_chg_bcd(miao));
     
452.                         write_ds1302(0x82,dat_chg_bcd(fen));
     
453.                         write_ds1302(0x84,dat_chg_bcd(shi));
     
454.                         write_ds1302(0x8a,dat_chg_bcd(week));
     
455.                         write_ds1302(0x86,dat_chg_bcd(ri));
     
456.                         write_ds1302(0x88,dat_chg_bcd(yue));
     
457.                         write_ds1302(0x8c,dat_chg_bcd(nian));
     
458.                         write_ds1302(0x8e,0x80);
     
459.                         s1num=0;
     
460.                         s2num=0;
     
461.                         write_com(0x0c);//清除光标闪烁
     
462.                 }
     
463.         }
     
464.         if(s4==0)
     
465.         {
     
466.                 delay(5);
     
467.                 if(s4==0)
     
468.                 {
     
469.                         while(!s4);
     
470.                         s4num++;
     
471.                         write_com(0x01);
     
472.                         write_com(0x80);//写字母MAXTEMP
     
473.                         for(i=21;i<29;i++)
     
474.                                 write_date(table[i]);
     
475.                         write_com(0x80+8);//写等号
     
476.                         write_date(0x3d);
     
477.                         write_nyr(9,settempmax);//写温度的初始状态
     
478.                         write_com(0x80+11);//写摄氏度符号
     
479.                         write_date(0xdf);
     
480.                         write_com(0x80+12);
     
481.                         write_date(0x43);
     
482. 
     
483. 
     
484.                         write_com(0x80+0x40);//写字母MINTEMP
     
485.                         for(i=29;i<37;i++)
     
486.                                 write_date(table[i]);
     
487.                         write_com(0x80+0x40+8);//写等号
     
488.                         write_date(0x3d);
     
489.                         write_sfm(9,settempmin);
     
490.                         write_com(0x80+0x40+12);//写摄氏度符号
     
491.                         write_date(0xdf);
     
492.                         write_com(0x80+0x40+13);
     
493.                         write_date(0x43);
     
494.                         while(s4num==1)
     
495.                         {
     
496.                                 if(s4==0)
     
497.                                 {
     
498.                                         delay(5);
     
499.                                         if(s4==0)
     
500.                                         {
     
501.                                                 while(!s4);
     
502.                                                 s4num++;
     
503.                                         }
     
504.                                 }
     
505.                                 if(s1==0)
     
506.                                 {
     
507.                                         delay(5);
     
508.                                         if(s1==0)
     
509.                                         {
     
510.                                                 while(!s1);
     
511.                                                 settempmax++;
     
512.                                                 if(settempmax==38)
     
513.                                                 settempmax=25;                                                
     
514.                                                 write_nyr(9,settempmax);        
     
515.                                         }
     
516.                                 }
     
517.                                 if(s2==0)
     
518.                                 {
     
519.                                         delay(5);
     
520.                                         if(s2==0)
     
521.                                         {
     
522.                                                 while(!s2);
     
523.                                                 settempmin--;
     
524.                                                 if(settempmin==-1)
     
525.                                                 settempmin=25;
     
526.                                                 write_sfm(9,settempmin);        
     
527.                                         }
     
528.                                 }               
     
529.                         }
     
530.                         write_com(0x01);
     
531.                         s4num=0;        
     
532.                 }
     
533.         }
     
534.         else
     
535.         {
     
536.                 if(s2==0)
     
537.                 {
     
538.                         delay(5);
     
539.                         if(s2==0)
     
540.                         {        
     
541.                                 while(!s2);
     
542.                                 s2num++;
     
543.                                 write_com(0x01);
     
544.                                 di=0;
     
545.                                 delay(100);
     
546.                                 di=1;
     
547.                                 delay(100);
     
548.                                 di=0;
     
549.                                 delay(100);
     
550.                                 di=1;               
     
551.                                 TR0=1;
     
552.                                 while(s2num==1)
     
553.                                 {
     
554.                                         if(num==20)
     
555.                                         {
     
556.                                                 num=0;
     
557.                                                 fiftyms++;
     
558.                                                 if(fiftyms==20)
     
559.                                                 {
     
560.                                                         fiftyms=0;
     
561.                                                         miao++;
     
562.                                                         if(miao==60)
     
563.                                                         {
     
564.                                                                 miao=0;
     
565.                                                                 fen++;
     
566.                                                                 write_miaobiao(5,fen);
     
567.                                                         }
     
568.                                                         write_miaobiao(11,miao);
     
569.                                                 }
     
570.                                                 write_miaobiao(14,fiftyms);
     
571.                                         }
     
572.                                         if(s2==0)
     
573.                                         {
     
574.                                                 delay(5);
     
575.                                                 if(s2==0)
     
576.                                                 {
     
577.                                                         while(!s2);
     
578.                                                         s2num++;
     
579.                                                 }
     
580.                                         }
     
581.                                         if(s3==0)
     
582.                                         {
     
583.                                                 delay(5);
     
584.                                                 if(s3==0)
     
585.                                                 {
     
586.                                                         di=0;
     
587.                                                         while(!s3);
     
588.                                                         di=1;
     
589.                                                         s3num++;
     
590.                                                         if(s3num==1)
     
591.                                                         {
     
592.                                                                 write_nyr(0,miao);
     
593.                                                                 write_nyr(3,fiftyms);        
     
594.                                                         }
     
595.                                                         if(s3num==2)
     
596.                                                         {
     
597.                                                                 write_nyr(11,miao);
     
598.                                                                 write_nyr(14,fiftyms);
     
599.                                                         }
     
600.                                                         if(s3num==3)
     
601.                                                         {
     
602.                                                                 write_sfm(0,miao);
     
603.                                                                 write_sfm(3,fiftyms);
     
604.                                                                 s3num=0;
     
605.                                                         }
     
606.                                                 }
     
607.                                         }        
     
608.                                 }
     
609.                                 s2num=0;
     
610.                                 TR0=0;              
     
611.                                 write_com(0x01);
     
612.                                 num=0;
     
613.                                 fiftyms=0;
     
614.                                 miao=0;
     
615.                                 fen=0;               
     
616.                         }               
     
617.                 }
     
618.                 if(s3==0)
     
619.                 {
     
620.                         delay(5);
     
621.                         if(s3==0)
     
622.                         {
     
623.                                 while(!s3);
     
624.                                 s3num++;
     
625.                                 write_com(0x01);
     
626.                                 wendufuhaoinit();
     
627.                                 while(s3num==1)
     
628.                                 {
     
629.                                         ds18b20_init();
     
630.                                         write_ds(0xcc);
     
631.                                         write_ds(0x44);
     
632.                                         ds18b20_init();
     
633.                                         write_ds(0xcc);
     
634.                                         write_ds(0xbe);
     
635.                                         L=read_ds();
     
636.                                         M=read_ds();
     
637.                                         i=0;
     
638.                                         i=M;
     
639.                                         i<<=8;
     
640.                                         i|=L;
     
641.                                         f_temp=i*0.0625;
     
642.                                         if(f_temp>settempmax)  //如果超过报警温度，则蜂鸣器闹响，
     
643.                                         {                                           //而且闪烁alarm提醒词
     
644.                                                 di=0;
     
645.                                                 write_com(0x80+0x40); //写入警报提醒单词，又能有延时效果
     
646.                                                 for(n=37;n<43;n++)
     
647.                                                 {
     
648.                                                         write_date(table[n]);
     
649.                                                 }
     
650.                                         }
     
651.                                         di=1;
     
652.                                         if(f_temp<settempmin)
     
653.                                         {
     
654.                                                 di=0;
     
655.                                                 write_com(0x80+0x40);
     
656.                                                 for(n=37;n<43;n++)
     
657.                                                 {
     
658.                                                         write_date(table[n]);
     
659.                                                 }
     
660.                                         }
     
661.                                         di=1;
     
662.                                         delay(100);
     
663.                                         write_com(0x80+0x40);//写空格清除提醒词达到闪烁效果
     
664.                                         for(n=43;n<49;n++)
     
665.                                         {
     
666.                                                 write_date(table[n]);
     
667.                                         }
     
668.                                         Int_temp=i*0.0625*100+0.5;
     
669.                                         C_qian=Int_temp/1000;
     
670.                                         C_bai=Int_temp%1000/100;
     
671.                                         C_shi=Int_temp%100/10;
     
672.                                         C_ge =Int_temp%10;
     
673.                                         write_wendu(0x40+9,C_qian);
     
674.                                         write_wendu(0x40+10,C_bai);
     
675.                                         write_wendu(0x40+12,C_shi);
     
676.                                         write_wendu(0x40+13,C_ge);
     
677.                                         if(s3==0)
     
678.                                         {
     
679.                                                 delay(5);
     
680.                                                 if(s3==0)
     
681.                                                 {
     
682.                                                         while(!s3);
     
683.                                                         s3num++;
     
684.                                                 }
     
685.                                         }
     
686.                                         if(s4==0)
     
687.                                         {
     
688.                                                 delay(5);
     
689.                                                 if(s4==0)
     
690.                                                 {
     
691.                                                         di=0;
     
692.                                                         while(!s4);
     
693.                                                         di=1;
     
694.                                                         s4num++;
     
695.                                                         if(s4num==1)
     
696.                                                         {
     
697.                                                                 miao=bcd_chg_dat(read_ds1302(0x81));
     
698.                                                                 fen=bcd_chg_dat(read_ds1302(0x83));
     
699.                                                                 write_nyr(3,miao);
     
700.                                                                 write_nyr(0,fen);
     
701.                                                                 wendufuhao2init();
     
702.                                                                 write_wendu(9,C_qian);
     
703.                                                                 write_wendu(10,C_bai);
     
704.                                                                 write_wendu(12,C_shi);
     
705.                                                                 write_wendu(13,C_ge);
     
706.                                                                 s4num=0;        
     
707.                                                         }
     
708.                                                 }
     
709.                                         }
     
710.                                 }
     
711.                                 s3num=0;
     
712.                                 write_com(0x01);
     
713.                         }
     
714.                 }
     
715. 
     
716.         }               
     
717. }
     
718. 
     
719. void t0_init()
     
720. {
     
721.         TMOD=0x02;
     
722.         TH0=6;
     
723.         TL0=6;
     
724.         EA=1;
     
725.         ET0=1;
     
726. }
     
727. 
     
728. void main()
     
729. {
     
730.         uchar miao,fen,shi,nian,yue,ri,week;
     
731.         settempmax=37;
     
732.         settempmin=0;
     
733.         lcdinit();
     
734.         ds1302_init();
     
735.         t0_init();
     
736.         while(1)
     
737.         {
     
738.                 keyscan();
     
739.                 write_ds1302(0x8e,0);//关闭写保护
     
740.                 miao=bcd_chg_dat(read_ds1302(0x81));
     
741.                 fen=bcd_chg_dat(read_ds1302(0x83));
     
742.                 shi=bcd_chg_dat(read_ds1302(0x85));
     
743.                 ri=bcd_chg_dat(read_ds1302(0x87));
     
744.                 yue=bcd_chg_dat(read_ds1302(0x89));
     
745.                 week=bcd_chg_dat(read_ds1302(0x8b));
     
746.                 nian=bcd_chg_dat(read_ds1302(0x8d));
     
747.                 write_ds1302(0x8e,0x80); //打开写保护
     
748.                 if(week==1)
     
749.                 {
     
750.                         write_com(0x80+13);
     
751.                         for(num=0;num<3;num++)        
     
752.                                 write_date(table[num]);
     
753.                 }
     
754.                 if(week==2)
     
755.                 {
     
756.                         write_com(0x80+13);
     
757.                         for(num=3;num<6;num++)
     
758.                                 write_date(table[num]);
     
759.                 }
     
760.                 if(week==3)
     
761.                 {
     
762.                         write_com(0x80+13);
     
763.                         for(num=6;num<9;num++)
     
764.                                 write_date(table[num]);
     
765.                 }
     
766.                 if(week==4)
     
767.                 {
     
768.                         write_com(0x80+13);
     
769.                         for(num=9;num<12;num++)
     
770.                                 write_date(table[num]);
     
771.                 }
     
772.                 if(week==5)
     
773.                 {
     
774.                         write_com(0x80+13);
     
775.                         for(num=12;num<15;num++)
     
776.                                 write_date(table[num]);
     
777.                 }
     
778.                 if(week==6)
     
779.                 {
     
780.                         write_com(0x80+13);
     
781.                         for(num=15;num<18;num++)
     
782.                                 write_date(table[num]);
     
783.                 }
     
784.                 if(week==7)
     
785.                 {
     
786.                         write_com(0x80+13);
     
787.                         for(num=18;num<21;num++)
     
788.                                 write_date(table[num]);
     
789.                 }
     
790.                
     
791.                 write_sfm(9,miao);
     
792.                 write_sfm(6,fen);
     
793.                 write_sfm(3,shi);
     
794.                 write_nyr(10,ri);
     
795.                 write_nyr(7,yue);
     
796.                 write_nyr(4,nian);
     
797.                 write_nyr(2,20);
     
798.         }            
     
799. }
     
800. 
     
801. void t0_time() interrupt 1
     
802. {
     
803.         num++;
     
804. }