标题: 单片机1602可调万年历,带DS18B20负温度显示 [打印本页]

---

作者: 870770329    时间: 2021-1-4 16:21
标题: 单片机1602可调万年历,带DS18B20负温度显示
前不久学会使用学习单片机的师兄们可以来看看
这是我找到的一个中等难度的程序
仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）


单片机源程序如下:

1. #include<reg52.h>
   
2. #include<intrins.h>
   
3. #define uchar unsigned char
   
4. #define uint unsigned int
   
5. #define     LCDIO      P0
   
6. sbit rs=P2^0;  
   
7. sbit rd=P2^1;
   
8. sbit lcden=P2^2;
   
9. sbit acc0=ACC^0;
   
10. sbit acc7=ACC^7;  
    
11. sbit ct=P2^3;
    
12. sbit speaker=P3^5;
    
13. sbit DQ=P2^5;
    
14. int djs11=0,js,dsmin=0,dshour=0;
    
15. 
    
16. uchar second,minute,hour,day,month,year,week,count=0;   
    
17. uchar ReadValue,num,time;   
    
18. uint tvalue;
    
19. uchar tflag;
    
20. uchar code        table[]={" 2000-00-00 FRI"};
    
21. uchar code table1[]={" 00:00:00       "};
    
22. uchar code table2[]= "THUFRISATSUNMONTUEWES";
    
23. char szdata[8];
    
24. char szdata1[8];
    
25. uchar data disdata[5];
    
26. sbit DATA=P3^3;
    
27. sbit RST=P3^4;   
    
28. sbit SCLK=P3^2;   
    
29. sbit menu=P2^7;      
    
30. sbit add=P2^6;        
    
31. sbit dec=P2^4;
    
32. sbit set=P2^3 ;      
    
33. sbit djs=P3^6;
    
34. void miaobiao();
    
35. void yx();
    
36. void delayms(int x)
    
37. {
    
38. char i;
    
39. while(x--)
    
40. {
    
41.   for(i=150;i>0;i--);
    
42. }
    
43. }
    
44. void delay(uint z)
    
45. {
    
46.         uint x,y;
    
47.         for(x=z;x>0;x--)
    
48.                 for(y=110;y>0;y--);
    
49. }
    
50. void delay1(uint z)
    
51. {
    
52.         for(;z>0;z--);
    
53. }
    
54. void write_com(uchar com)
    
55. {
    
56.         rs=0;
    
57.         rd=0;
    
58.         lcden=0;
    
59.         LCDIO=com;
    
60.         delay(5);
    
61.         lcden=1;
    
62.         delay(5);
    
63.         lcden=0;        
    
64. }
    
65. 
    
66. void write_date(uchar date)
    
67. {
    
68.         rs=1;
    
69.         rd=0;
    
70.         lcden=0;
    
71.         LCDIO=date;
    
72.         delay(5);
    
73.         lcden=1;
    
74.         delay(5);
    
75.         lcden=0;        
    
76. }
    
77. 
    
78. void init()
    
79. {
    
80.         uchar num;
    
81.         lcden=0;
    
82. 
    
83.         write_com(0x38);
    
84.         write_com(0x0c);
    
85.         write_com(0x06);
    
86.         write_com(0x01);
    
87.         write_com(0x80);
    
88.         delay(5);
    
89.         write_com(0x80);
    
90.         for(num=0;num<15;num++)
    
91.                 {
    
92.                         write_date(table[num]);
    
93.                         delay(5);
    
94.                 }
    
95.         write_com(0x80+0x40);
    
96.         for(num=0;num<15;num++)
    
97.                 {
    
98.                         write_date(table1[num]);
    
99.                         delay(5);
    
100.                 }      
     
101.         
     
102. 
     
103. }
     
104. 
     
105. void Write1302(uchar dat)
     
106. {
     
107.   uchar i;
     
108.   SCLK=0;        
     
109.   delay1(2);
     
110.   for(i=0;i<8;i++)
     
111.     {
     
112.      DATA=dat&0x01;   
     
113.   delay(2);  
     
114.    SCLK=1;  
     
115.    delay1(2);
     
116.    SCLK=0;  
     
117.    dat>>=1;  
     
118.    }
     
119. }
     
120. 
     
121. void WriteSet1302(uchar Cmd,uchar dat)
     
122. {
     
123.    RST=0;           //禁止数据传递
     
124.    SCLK=0;          //确保写数居前SCLK被拉低
     
125.    RST=1;           //启动数据传输
     
126.    delay1(2);     //稍微等待，使硬件做好准备
     
127.    Write1302(Cmd);  //写入命令字
     
128.    Write1302(dat);  //写数据
     
129.    SCLK=1;          //将时钟电平置于已知状态
     
130.    RST=0;           //禁止数据传递
     
131. }
     
132. 
     
133. uchar Read1302(void)
     
134. {
     
135.    uchar i,dat;
     
136.    delay(2);       //稍微等待，使硬件做好准备
     
137.    for(i=0;i<8;i++)   //连续读8个二进制位数据
     
138.    {
     
139.     dat>>=1;       //将dat的各数据位右移1位，因为先读出的是字节的最低位
     
140.     if(DATA==1)    //如果读出的数据是1
     
141.     dat|=0x80;    //将1取出，写在dat的最高位
     
142.     SCLK=1;       //将SCLK置于高电平，为下降沿读出
     
143.     delay1(2);  //稍微等待
     
144.     SCLK=0;       //拉低SCLK，形成脉冲下降沿
     
145.     delay1(2);  //稍微等待
     
146.     }  
     
147.   return dat;        //将读出的数据返回
     
148.   }
     
149. 
     
150. uchar  ReadSet1302(uchar Cmd)
     
151. {
     
152.   uchar dat;
     
153.   RST=0;                 //拉低RST
     
154.   SCLK=0;                //确保写数居前SCLK被拉低
     
155.   RST=1;                 //启动数据传输
     
156.   Write1302(Cmd);       //写入命令字
     
157.   dat=Read1302();       //读出数据
     
158.   SCLK=1;              //将时钟电平置于已知状态
     
159.   RST=0;               //禁止数据传递
     
160.   return dat;          //将读出的数据返回
     
161. }
     
162. void Init_DS1302(void)
     
163. {
     
164. WriteSet1302(0x8E,0x00);                 //根据写状态寄存器命令字，写入不保护指令
     
165. WriteSet1302(0x80,((0/10)<<4|(0%10)));   //根据写秒寄存器命令字，写入秒的初始值
     
166. WriteSet1302(0x82,((12/10)<<4|(12%10)));   //根据写分寄存器命令字，写入分的初始值
     
167. WriteSet1302(0x84,((11/10)<<4|(11%10))); //根据写小时寄存器命令字，写入小时的初始值
     
168. WriteSet1302(0x86,((25/10)<<4|(25%10))); //根据写日寄存器命令字，写入日的初始值
     
169. WriteSet1302(0x88,((1/10)<<4|(1%10))); //根据写月寄存器命令字，写入月的初始值
     
170. WriteSet1302(0x8c,((13/10)<<4|(13%10)));   //nian
     
171. WriteSet1302(0x8a,((1/10)<<4|(1%10)));
     
172. }
     
173. 
     
174. void DisplaySecond(uchar x)
     
175. {
     
176. uchar i,j;   
     
177. i=x/10;
     
178. j=x%10;
     
179. write_com(0xc7);   
     
180. write_date(0x30+i);   
     
181. write_date(0x30+j);      
     
182. }
     
183. void DisplayMinute(uchar x)
     
184. {
     
185. uchar i,j;   
     
186. i=x/10;
     
187. j=x%10;
     
188. write_com(0xc4);   
     
189. write_date(0x30+i);  
     
190. write_date(0x30+j);        
     
191. }
     
192. void DisplayHour(uchar x)
     
193. {
     
194. uchar i,j;   
     
195. i=x/10;
     
196. j=x%10;
     
197. write_com(0xc1);   
     
198. write_date(0x30+i);  
     
199. write_date(0x30+j);        
     
200. }
     
201. 
     
202. void DisplayDay(uchar x)
     
203. {
     
204. uchar i,j;   
     
205. i=x/10;
     
206. j=x%10;   
     
207. write_com(0x89);   
     
208. write_date(0x30+i);  
     
209. write_date(0x30+j);      
     
210. }
     
211. 
     
212. void DisplayMonth(uchar x)
     
213. {
     
214. uchar i,j;     
     
215. i=x/10;
     
216. j=x%10;  
     
217. write_com(0x86);   
     
218. write_date(0x30+i);  
     
219. write_date(0x30+j);  
     
220. }
     
221. 
     
222. void DisplayYear(uchar x)
     
223. {
     
224. uchar i,j;  
     
225.   i=x/10;
     
226. j=x%10;
     
227. write_com(0x83);   
     
228. write_date(0x30+i);
     
229. write_date(0x30+j);  
     
230. }   
     
231. void DisplayWeek(uchar x)
     
232. { uchar i;
     
233.    x=x*3;
     
234. write_com(0x8c);   
     
235. for(i=0;i<3;i++)
     
236.    {
     
237.            write_date(table2[x]);
     
238.         x++;  
     
239.    }
     
240. }   
     
241. 
     
242. void  read_date(void)
     
243. {
     
244.      ReadValue = ReadSet1302(0x81);   
     
245.      second=((ReadValue&0x70)>>4)*10 + (ReadValue&0x0F);
     
246.      ReadValue = ReadSet1302(0x83);  
     
247.      minute=((ReadValue&0x70)>>4)*10 + (ReadValue&0x0F);
     
248.      ReadValue = ReadSet1302(0x85);  
     
249.      hour=((ReadValue&0x70)>>4)*10 + (ReadValue&0x0F);
     
250.      ReadValue = ReadSet1302(0x87);  
     
251.      day=((ReadValue&0x70)>>4)*10 + (ReadValue&0x0F);
     
252.      ReadValue = ReadSet1302(0x89);  
     
253.      month=((ReadValue&0x70)>>4)*10 + (ReadValue&0x0F);
     
254.      ReadValue = ReadSet1302(0x8d);  
     
255.      year=((ReadValue&0x70)>>4)*10 + (ReadValue&0x0F);
     
256.          ReadValue=ReadSet1302(0x8b);                     //读星期
     
257.      week=ReadValue&0x07;
     
258.          if((year==szdata[1])&&(month==szdata[2])&&(day==szdata[3])&&(week==szdata[4])&&(hour==szdata[5])&&(minute==szdata[6])&&(second==szdata[7]))             speaker=0;
     
259.          DisplaySecond(second);           
     
260.      DisplayMinute(minute);        
     
261.      DisplayHour(hour);            
     
262.      DisplayDay(day);               
     
263.      DisplayMonth(month);            
     
264.      DisplayYear(year);         
     
265.          DisplayWeek(week);  
     
266. }
     
267. 
     
268. void turn_val(char newval,uchar flag,uchar  newaddr,uchar s1num)
     
269.     {
     
270.                    newval=ReadSet1302(newaddr);                     //读取当前时间
     
271.                    newval=((newval&0x70)>>4)*10+(newval&0x0f);    //将bcd码转换成十进制
     
272.                    if(flag)                  //判断是加一还是减一
     
273.                    {
     
274.                                      newval++;
     
275.                      switch(s1num)
     
276.                        { case 1: if(newval>99) newval=0;
     
277.                                                       DisplayYear(newval);      
     
278.                                                                   break;
     
279.                                              case 2: if(newval>12) newval=1;
     
280.                                                                    DisplayMonth(newval);
     
281.                                                                   break;
     
282.                                              case 3: if(newval>31) newval=1;
     
283.                                                           DisplayDay(newval);  
     
284.                                                                   break;
     
285.                                              case 4: if(newval>6) newval=0;
     
286.                                                           DisplayWeek(newval);
     
287.                                                                   break;
     
288.                          case 5: if(newval>23) newval=0;
     
289.                                                           DisplayHour(newval);
     
290.                                                                   break;
     
291.                          case 6: if(newval>59) newval=0;
     
292.                                                           DisplayMinute(newval);
     
293.                                                                   break;
     
294.                          case 7: if(newval>59) newval=0;
     
295.                                                           DisplaySecond(newval);
     
296.                                                                   break;
     
297.                          default:break;
     
298.                        }
     
299.                                          }   
     
300.                                 else
     
301.                    {
     
302.                                     newval--;
     
303.                                         switch(s1num)
     
304.                        { case 1: if(newval<0) newval=99;
     
305.                                                       DisplayYear(newval);
     
306.                                                                   break;
     
307.                                              case 2: if(newval<0) newval=12;
     
308.                                                                    DisplayMonth(newval);
     
309.                                                           break;
     
310.                                              case 3: if(newval<0) newval=31;
     
311.                                                                    DisplayDay(newval);
     
312.                                                           break;
     
313.                                              case 4: if(newval<0) newval=6;
     
314.                                                           DisplayWeek(newval);
     
315.                                                                   break;
     
316.                          case 5: if(newval<0) newval=23;
     
317.                                                           DisplayHour(newval);
     
318.                                                                   break;
     
319.                          case 6: if(newval<0) newval=59;
     
320.                                                           DisplayMinute(newval);
     
321.                                                                   break;
     
322.                          case 7: if(newval<0) newval=59;
     
323.                                                           DisplaySecond(newval);
     
324.                                                                   break;
     
325.                                                  default:break;
     
326.                                        }
     
327.                                          }
     
328.                 WriteSet1302((newaddr-1),((newval/10)<<4)|(newval%10));  //将新数据写入寄存器
     
329.            
     
330.         }   
     
331. 
     
332. 
     
333. void turn_val11(char newval,uchar flag,uchar  newaddr,uchar s1num)
     
334.     {
     
335.                    newval=szdata[s1num];                     //读取当前时间
     
336.                    //newval=((newval&0x70)>>4)*10+(newval&0x0f);    //将bcd码转换成十进制
     
337.                    if(flag)                  //判断是加一还是减一
     
338.                    {
     
339.                                      newval++;
     
340.                      switch(s1num)
     
341.                        { case 1: if(newval>99) newval=0;
     
342.                                                       DisplayYear(newval);      
     
343.                                                                   break;
     
344.                                              case 2: if(newval>12) newval=1;
     
345.                                                                    DisplayMonth(newval);
     
346.                                                                   break;
     
347.                                              case 3: if(newval>31) newval=1;
     
348.                                                           DisplayDay(newval);  
     
349.                                                                   break;
     
350.                                              case 4: if(newval>6) newval=0;
     
351.                                                           DisplayWeek(newval);
     
352.                                                                   break;
     
353.                          case 5: if(newval>23) newval=0;
     
354.                                                           DisplayHour(newval);
     
355.                                                                   break;
     
356.                          case 6: if(newval>59) newval=0;
     
357.                                                           DisplayMinute(newval);
     
358.                                                                   break;
     
359.                          case 7: if(newval>59) newval=0;
     
360.                                                           DisplaySecond(newval);
     
361.                                                                   break;
     
362.                          default:break;
     
363.                        }
     
364.                                          }   
     
365.                                 else
     
366.                    {
     
367.                                     newval--;
     
368.                                         switch(s1num)
     
369.                        { case 1: if(newval<0) newval=99;
     
370.                                                       DisplayYear(newval);
     
371.                                                                   break;
     
372.                                              case 2: if(newval<0) newval=12;
     
373.                                                                    DisplayMonth(newval);
     
374.                                                           break;
     
375.                                              case 3: if(newval<0) newval=31;
     
376.                                                                    DisplayDay(newval);
     
377.                                                           break;
     
378.                                              case 4: if(newval<0) newval=6;
     
379.                                                           DisplayWeek(newval);
     
380.                                                                   break;
     
381.                          case 5: if(newval<0) newval=23;
     
382.                                                           DisplayHour(newval);
     
383.                                                                   break;
     
384.                          case 6: if(newval<0) newval=59;
     
385.                                                           DisplayMinute(newval);
     
386.                                                                   break;
     
387.                          case 7: if(newval<0) newval=59;
     
388.                                                           DisplaySecond(newval);
     
389.                                                                   break;
     
390.                                                  default:break;
     
391.                                        }
     
392.                                          }
     
393.                  szdata[s1num]= newval;
     
394.                                  szdata1[s1num]=newval;
     
395.                                 //WriteSet1302((newaddr-1),((newval/10)<<4)|(newval%10));  //将新数据写入寄存器
     
396.            
     
397.         }   
     
398. 
     
399. //键盘扫描程序
     
400. //*******************************************
     
401. void key_scan(void)
     
402. {        uchar miao,s1num=0;        
     
403. 
     
404.         if(menu==0)
     
405.      {
     
406.        delay(5);
     
407.            if(menu==0)
     
408.            {
     
409.              while(!menu);         
     
410.                   s1num++;
     
411.                                                  write_com(0xc9);
     
412.            write_date(' ');//显示符号位
     
413.            write_com(0xca);
     
414.            write_date(' ');//显示百位
     
415.            write_com(0xcb);
     
416.            write_date('T');//显示十位         
     
417.            write_com(0xcc);
     
418.            write_date('-');//显示个位         
     
419.            write_com(0xcd);
     
420.            write_date('S');//显示小数点         
     
421.            write_com(0xce);
     
422.            write_date('E');//显示小数位
     
423.            write_com(0xcf);
     
424.            write_date('T');
     
425.                 while(1)
     
426.             {
     
427. 
     
428.                     if(menu==0)
     
429.              {
     
430.                 delay(5);
     
431.                     if(menu==0)
     
432.                       {
     
433.                                      while(!menu);
     
434.                          s1num++;
     
435.                           }
     
436.                  }
     
437. 
     
438.                 rd=0;
     
439.                         miao=ReadSet1302(0x81);
     
440.                         second=miao;
     
441.                         WriteSet1302(0x80,miao|0x80);
     
442.                     write_com(0x0f);//光标闪射
     
443.                         
     
444.                         if(s1num==1)
     
445.                         {        year=ReadSet1302(0x8d);                 
     
446.                                 write_com(0x80+4);        //年光标
     
447. 
     
448.                             if(add==0)
     
449.                              {
     
450.                                delay(3);
     
451.                                if(add==0)
     
452.                                  {         while(!add);
     
453.                                turn_val(year,1,0x8d,1);                        
     
454.                
     
455.                                  }
     
456.                               }
     
457.                     if(dec==0)
     
458.                          {
     
459.                                 delay(3);
     
460.                                 if(dec==0)
     
461.                                  {        while(!dec);
     
462.                                    turn_val(year,0,0x8d,1);                                      
     
463.                                  }
     
464.                               }
     
465.                          }
     
466.                         if(s1num==2)
     
467.                         {
     
468.                           month=ReadSet1302(0x89);
     
469.                                 write_com(0x80+7);        //月光标
     
470.                                  if(add==0)
     
471.                         {
     
472.                           delay(3);
     
473.                           if(add==0)
     
474.                            {  while(!add);
     
475.                               turn_val(month,1,0x89,2);
     
476.                             }
     
477.                         }
     
478.                         if(dec==0)
     
479.                         {
     
480.                            delay(3);
     
481.                            if(dec==0)
     
482.                            {  while(!dec);
     
483.                               turn_val(month,0,0x89,2);
     
484.                            }
     
485.                         }
     
486.                         }
     
487.                         if(s1num==3)
     
488.                         {        day=ReadSet1302(0x87);
     
489.                                 write_com(0x80+10);//日光标
     
490.                                 if(add==0)
     
491.                           {
     
492.                           delay(3);
     
493.                           if(add==0)
     
494.                            { while(!add);
     
495.                          turn_val(day,1,0x87,3);
     
496.                             }
     
497.                         }
     
498.                         if(dec==0)
     
499.                         {
     
500.                            delay(3);
     
501.                            if(dec==0)
     
502.                            { while(!dec);
     
503.                              turn_val(day,0,0x87,3);                                //写入日寄存器
     
504.                            }
     
505.                         }
     
506.                         }
     
507.                         if(s1num==4)
     
508.                         {  week=ReadSet1302(0x8b);
     
509.                                 write_com(0x80+14);        //星期光标
     
510.                                   if(add==0)
     
511.                              {
     
512.                           delay(3);
     
513.                           if(add==0)
     
514.                            { while(!add);
     
515.                              turn_val(week,1,0x8b,4);
     
516.                             }
     
517.                         }
     
518.                         if(dec==0)
     
519.                         {
     
520.                            delay(3);
     
521.                            if(dec==0)
     
522.                            { while(!dec);
     
523.                      turn_val(week,0,0x8b,4);
     
524.                            }
     
525.                         }
     
526.                         }
     
527.                         if(s1num==5)
     
528.                         {        hour=ReadSet1302(0x85);
     
529.                                 write_com(0x80+0x40+2);        //时光标
     
530.                                  if(add==0)
     
531.                         {
     
532.                           delay(3);
     
533.                           if(add==0)
     
534.                            { while(!add);
     
535.                  turn_val(hour,1,0x85,5);
     
536.                             }
     
537.                         }
     
538.                         if(dec==0)
     
539.                         {
     
540.                            delay(3);
     
541.                            if(dec==0)
     
542.                            { while(!dec);
     
543.                          turn_val(hour,0,0x85,5);
     
544.                            }
     
545.                         }
     
546.                         }
     
547.                         if(s1num==6)//调时间分
     
548.                         {  minute=ReadSet1302(0x83);
     
549.                                 write_com(0x80+0x40+5);
     
550.                                 if(add==0)
     
551.                         {
     
552.                           delay(5);
     
553.                           if(add==0)
     
554.                            { while(!add);
     
555.                          turn_val(minute,1,0x83,6);                                //写入分寄存器   
     
556.                             }
     
557.                         }
     
558.                         if(dec==0)
     
559.                         {
     
560.                            delay(3);
     
561.                            if(dec==0)
     
562.                            { while(!dec);
     
563.                          turn_val(minute,0,0x83,6);                                //写入分寄存器
     
564.                            }
     
565.                         }
     
566.                         }
     
567.                         if(s1num==7)//调时间秒
     
568.                         {        second=ReadSet1302(0x81);
     
569.                                 write_com(0x80+0x40+8);//秒光标
     
570.                                 if(add==0)
     
571.                         {
     
572.                           delay(3);
     
573.                           if(add==0)
     
574.                            { while(!add);
     
575.                  if(second==0x60)
     
576.                     second=0x00;
     
577.                                  turn_val(second,1,0x81,7);        
     
578.                             }
     
579.                         }
     
580.                         if(dec==0)
     
581.                         {
     
582.                            delay(3);
     
583.                            if(dec==0)
     
584.                            { while(!dec);
     
585.                          turn_val(second,0,0x81,7);                                
     
586.                            }
     
587.                         }
     
588.                         }
     
589.             
     
590. 
     
591.                         if(s1num==8)
     
592.                         {        miao=ReadSet1302(0x81);
     
593.                                 second=miao;
     
594.                                 WriteSet1302(0x80,second&0x7f);
     
595.                                 s1num=0;//s1num清零//
     
596.                                 write_com(0x0c);//光标不闪烁//
     
597.                                 break;
     
598.                         }
     
599.                 }
     
600.         }
     
601.         }
     
602. 
     
603.   if(ct==0)
     
604.      {
     
605.        delay(5);
     
606.            if(ct==0)
     
607.            {
     
608.              while(!ct);         
     
609.                   s1num++;
     
610.        write_com(0xc9);
     
611.            write_date(' ');//显示符号位
     
612.            write_com(0xca);
     
613.            write_date(' ');//显示百位
     
614.            write_com(0xcb);
     
615.            write_date('C');//显示十位         
     
616.            write_com(0xcc);
     
617.            write_date('-');//显示个位         
     
618.            write_com(0xcd);
     
619.            write_date('S');//显示小数点         
     
620.            write_com(0xce);
     
621.            write_date('E');//显示小数位
     
622.            write_com(0xcf);
     
623.            write_date('T');
     
624.          DisplaySecond(szdata1[7]);           
     
625.      DisplayMinute(szdata1[6]);        
     
626.      DisplayHour(szdata1[5]);            
     
627.      DisplayDay(szdata1[3]);               
     
628.      DisplayMonth(szdata1[2]);            
     
629.      DisplayYear(szdata1[1]);         
     
630.          DisplayWeek(szdata1[4]);
     
631.                 while(1)
     
632.             {
     
633. 
     
634.                     if(ct==0)
     
635.              {
     
636.                 delay(5);
     
637.                     if(ct==0)
     
638.                       {
     
639.                                      while(!ct);
     
640.                          s1num++;
     
641.                           }
     
642.                  }
     
643. 
     
644.                 rd=0;
     
645.                         miao=ReadSet1302(0x81);
     
646.                         second=miao;
     
647.                         WriteSet1302(0x80,miao|0x80);
     
648.                     write_com(0x0f);//光标闪射
     
649.                         
     
650.                         if(s1num==1)
     
651.                         {        year=0x00;                 
     
652.                                 write_com(0x80+4);        //年光标
     
653. 
     
654.                             if(add==0)
     
655.                              {
     
656.                                delay(3);
     
657.                                if(add==0)
     
658.                                  {         while(!add);
     
659.                                turn_val11(year,1,0x8d,1);                        
     
660.                
     
661.                                  }
     
662.                               }
     
663.                     if(dec==0)
     
664.                          {
     
665.                                 delay(3);
     
666.                                 if(dec==0)
     
667.                                  {        while(!dec);
     
668.                                    turn_val11(year,0,0x8d,1);                                      
     
669.                                  }
     
670.                               }
     
671.                          }
     
672.                         if(s1num==2)
     
673.                         {
     
674.                           month=0x00;        
     
675.                                 write_com(0x80+7);        //月光标
     
676.                                  if(add==0)
     
677.                         {
     
678.                           delay(3);
     
679.                           if(add==0)
     
680.                            {  while(!add);
     
681.                               turn_val11(month,1,0x89,2);
     
682.                             }
     
683.                         }
     
684.                         if(dec==0)
     
685.                         {
     
686.                            delay(3);
     
687.                            if(dec==0)
     
688.                            {  while(!dec);
     
689.                               turn_val11(month,0,0x89,2);
     
690.                            }
     
691.                         }
     
692.                         }
     
693.                         if(s1num==3)
     
694.                         {        day=0x00;        
     
695.                                 write_com(0x80+10);//日光标
     
696.                                 if(add==0)
     
697.                           {
     
698.                           delay(3);
     
699.                           if(add==0)
     
700.                            { while(!add);
     
701.                          turn_val11(day,1,0x87,3);
     
702.                             }
     
703.                         }
     
704.                         if(dec==0)
     
705.                         {
     
706.                            delay(3);
     
707.                            if(dec==0)
     
708.                            { while(!dec);
     
709.                              turn_val11(day,0,0x87,3);                                //写入日寄存器
     
710.                            }
     
711.                         }
     
712.                         }
     
713.                         if(s1num==4)
     
714.                         {  week=0x00;        
     
715.                                 write_com(0x80+14);        //星期光标
     
716.                                   if(add==0)
     
717.                              {
     
718.                           delay(3);
     
719.                           if(add==0)
     
720.                            { while(!add);
     
721.                              turn_val11(week,1,0x8b,4);
     
722.                             }
     
723.                         }
     
724.                         if(dec==0)
     
725.                         {
     
726.                            delay(3);
     
727.                            if(dec==0)
     
728.                            { while(!dec);
     
729.                      turn_val11(week,0,0x8b,4);
     
730.                            }
     
731.                         }
     
732.                         }
     
733.                         if(s1num==5)
     
734.                         {        hour=0x00;        
     
735.                                 write_com(0x80+0x40+2);        //时光标
     
736.                                  if(add==0)
     
737.                         {
     
738.                           delay(3);
     
739.                           if(add==0)
     
740.                            { while(!add);
     
741.                  turn_val11(hour,1,0x85,5);
     
742.                             }
     
743.                         }
     
744.                         if(dec==0)
     
745.                         {
     
746.                            delay(3);
     
747.                            if(dec==0)
     
748.                            { while(!dec);
     
749.                          turn_val11(hour,0,0x85,5);
     
750.                            }
     
751.                         }
     
752.                         }
     
753.                         if(s1num==6)//调时间分
     
754.                         {  minute=0x00;        
     
755.                                 write_com(0x80+0x40+5);
     
756.                                 if(add==0)
     
757.                         {
     
758.                           delay(5);
     
759.                           if(add==0)
     
760.                            { while(!add);
     
761.                          turn_val11(minute,1,0x83,6);                                //写入分寄存器   
     
762.                             }
     
763.                         }
     
764.                         if(dec==0)
     
765.                         {
     
766.                            delay(3);
     
767.                            if(dec==0)
     
768.                            { while(!dec);
     
769.                          turn_val11(minute,0,0x83,6);                                //写入分寄存器
     
770.                            }
     
771.                         }
     
772.                         }
     
773.                         if(s1num==7)//调时间秒
     
774.                         {        second=0x00;        
     
775.                                 write_com(0x80+0x40+8);//秒光标
     
776.                                 if(add==0)
     
777.                         {
     
778.                           delay(3);
     
779.                           if(add==0)
     
780.                            { while(!add);
     
781.                  if(second==0x60)
     
782.                     second=0x00;
     
783.                                  turn_val11(second,1,0x81,7);        
     
784.                             }
     
785.                         }
     
786.                         if(dec==0)
     
787.                         {
     
788.                            delay(3);
     
789.                            if(dec==0)
     
790.                            { while(!dec);
     
791.                          turn_val11(second,0,0x81,7);                                
     
792.                            }
     
793.                         }
     
794.                         }
     
795.             
     
796. 
     
797.                         if(s1num==8)
     
798.                         {        miao=ReadSet1302(0x81);        
     
799.                                 second=miao;
     
800.                                 WriteSet1302(0x80,second&0x7f);
     
801.                                 s1num=0;//s1num清零//
     
802.                                 write_com(0x0c);//光标不闪烁//
     
803.                                 break;
     
804.                         }
     
805.                 }
     
806.         }
     
807.         }
     
808. }
     
809. 
     
810. void Timer0_init()
     
811. {
     
812.       js=0;
     
813.           TMOD=0x01;                                  //T0为定时器方式1
     
814.       TH0=0x4c;
     
815.           TL0=0x00;                        
     
816.      //IT1=1;
     
817.           ET0=1;//EX1=1;
     
818.           EA=1;        
     
819. }
     
820. 
     
821. void timer0() interrupt 1 using 1        
     
822. {
     
823.             TF0=0;
     
824.                  //TH0=0x4c;
     
825.                 //TL0=0x00;
     
826.                 TH0=0xb3;
     
827.                 TL0=0x4c;
     
828.                 js++;
     
829.                 if(js==1)
     
830.                   { js=0;
     
831.                     djs11++;
     
832.                         //led1=~led1;
     
833.                         if(djs11>59)
     
834.                           {
     
835.                             djs11=0;
     
836.                                 dsmin=dsmin+1;
     
837.                                 if(dsmin>59)
     
838.                                  {
     
839.                                    dsmin=0;
     
840.                                    dshour=dshour+1;
     
841.                                    if(dshour>24) dshour=0;
     
842.                                  }
     
843.                         }
     
844.                    }
     
845. }
     
846. void miaobiao()
     
847. {                int i,j;
     
848. 
     
849.             write_com(0x80);write_date(' ');
     
850.                         write_com(0x81);write_date(' ');
     
851.                         write_com(0x82);write_date(' ');
     
852.                         write_com(0x83);write_date(' ');
     
853.                         write_com(0x84);write_date(' ');
     
854.                         write_com(0x85);write_date(' ');
     
855.                         write_com(0x86);write_date(' ');
     
856.                         write_com(0x87);write_date(' ');
     
857.                     write_com(0x88);write_date(' ');
     
858.                         write_com(0x89);write_date(' ');
     
859.                         write_com(0x8a);write_date(' ');
     
860.                         write_com(0x8b);write_date(' ');
     
861.                         write_com(0x8c);write_date(' ');
     
862.                         write_com(0x8d);write_date(' ');
     
863.                         write_com(0x8e);write_date(' ');
     
864.                         write_com(0x8f);write_date(' ');
     
865.                         write_com(0xc0);write_date(' ');
     
866.                         write_com(0xc1);write_date(' ');
     
867.                         write_com(0xc2);write_date(' ');
     
868.                         write_com(0xc3);write_date(' ');
     
869.                         write_com(0xc4);write_date(' ');
     
870.                         write_com(0xc5);write_date(' ');
     
871.                         write_com(0xc6);write_date(' ');
     
872.                         write_com(0xc7);write_date(' ');
     
873.                     write_com(0xc8);write_date(' ');
     
874.                         write_com(0xc9);write_date(' ');
     
875.                         write_com(0xca);write_date(' ');
     
876.                         write_com(0xcb);write_date(' ');
     
877.                         write_com(0xcc);write_date(' ');
     
878.                         write_com(0xcd);write_date(' ');
     
879.                         write_com(0xce);write_date(' ');
     
880.                         write_com(0xcf);write_date(' ');
     
881.                    while(1)
     
882.                     {        if(add==0)
     
883.                               {
     
884.                                   delayms(30);
     
885.                                     if(add==0)
     
886.                                           {
     
887.                                             TR0=1;
     
888.                                           }
     
889. 
     
890.                                   }
     
891.                                 if(dec==0)
     
892.                               {
     
893.                                   delayms(30);
     
894.                                     if(dec==0)
     
895.                                           {
     
896.                                             TR0=0;
     
897.                                           }
     
898.                                           }
     
899.                                 if(set==0)
     
900.                               {
     
901.                                   delayms(30);
     
902.                                     if(set==0)
     
903.                                           {
     
904.                                             djs11=0;
     
905.                                                 TR0=0;
     
906.                                                                                                 dsmin=0;
     
907.                                                 dshour=0;
     
908.                                           }
     
909.                                           }
     
910.                                    if(djs==0)
     
911.                               {
     
912.                                   delayms(30);
     
913.                                     if(djs==0)
     
914.                                           {
     
915.                                                 yx();
     
916.                                           }
     
917.                                           }
     
918.                         write_com(0xc4);
     
919.                                                  i=dshour/10;
     
920.              j=dshour%10;   
     
921.              write_date(0x30+i);  
     
922.              write_date(0x30+j);
     
923. 
     
924.                          write_date(':');  
     
925.                          i=dsmin/10;
     
926.              j=dsmin%10;   
     
927.              write_date(0x30+i);  
     
928.              write_date(0x30+j);
     
929.                          write_date(':');   
     
930. 
     
931.                                                   i=djs11/10;
     
932.              j=djs11%10;
     
933.              write_date(0x30+i);  
     
934.              write_date(0x30+j);
     
935.                         }
     
936. }
     
937. void delay_18B20(unsigned int i)//延时1微秒
     
938. {
     
939.          while(i--);
     
940. }
     
941. void ds1820rst()/*ds1820复位*/
     
942. {  unsigned char x=0;
     
943.          DQ = 1;          //DQ复位
     
944.          delay_18B20(4);  //延时
     
945.          DQ = 0;          //DQ拉低
     
946.          delay_18B20(100); //精确延时大于480us
     
947.          DQ = 1;          //拉高
     
948.          delay_18B20(40);         
     
949.    }  
     
950.   
     
951.    uchar ds1820rd()/*读数据*/
     
952.   { unsigned char i=0;
     
953.          unsigned char dat = 0;
     
954.          for (i=8;i>0;i--)
     
955.          {   DQ = 0; //给脉冲信号
     
956.                   dat>>=1;
     
957.                   DQ = 1; //给脉冲信号
     
958.                   if(DQ)
     
959.                   dat|=0x80;
     
960.                   delay_18B20(10);
     
961.          }
     
962.          return(dat);
     
963.   }
     
964. 
     
965.   void ds1820wr(uchar wdata)/*写数据*/
     
966.   {unsigned char i=0;
     
967.     for (i=8; i>0; i--)
     
968.    { DQ = 0;
     
969.      DQ = wdata&0x01;
     
970.      delay_18B20(10);
     
971.      DQ = 1;
     
972.      wdata>>=1;
     
973.    }
     
974. ……………………
     
975. 
     
976. …………限于本文篇幅 余下代码请从51黑下载附件…………
     

复制代码

所有资料51hei提供下载:
基于51单片机的多功能时钟温度计.zip (1.06 MB, 下载次数: 37)

2021-1-4 16:21 上传

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

---

作者: BillJohnson    时间: 2021-1-5 08:31
你的附件里都有啥

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1