DS1302+lcd1602按钮调时程序加仿真

弄了2天，终于弄好的，仿真加程序！

谢谢楼主分享

好东西 还有仿真 适合初学者这里贴一下楼主的代码：

1. #include<reg51.h>      
   
2. #include<intrins.h>   
   
3.                      
   
4. #define        uint unsigned int
   
5. #define uchar unsigned char
   
6. 
   
7. uchar second,minute,hour,day,month,year,week,keynum;
   
8. 
   
9. sbit daio=P3^6;   
   
10. sbit rst=P3^4;     
    
11. sbit sclk=P3^5;   
    
12. 
    
13. sbit rs=P2^0;            
    
14. sbit rw=P2^1;            
    
15. sbit ep=P2^2;            
    
16.            
    
17. sbit keyfw=P2^5;
    
18. sbit keyjia=P2^6;
    
19. sbit keyjian=P2^7;
    
20. 
    
21. void delaynus(unsigned char n)
    
22. {
    
23. unsigned char i;
    
24. for(i=0;i<n;i++);
    
25. }
    
26. 
    
27. void write1302(uchar dat)
    
28. {
    
29.   uchar i;
    
30.   sclk=0;            
    
31.   delaynus(2);        
    
32.   for(i=0;i<8;i++)      
    
33.     {
    
34.                 daio=dat&0x01;  
    
35.                 delaynus(2);        
    
36.                 sclk=1;            
    
37.                 delaynus(2);      
    
38.                 sclk=0;            
    
39.              dat>>=1;         
    
40.    }
    
41. 
    
42. }
    
43. 
    
44. void writeset1302(uchar add,uchar dat)
    
45. {
    
46.         rst=0;            
    
47.         sclk=0;           
    
48.         rst=1;            
    
49.         delaynus(2);      
    
50.         write1302(add);   
    
51.         write1302(dat);   
    
52.         sclk=1;           
    
53.         rst=0;           
    
54. }
    
55. 
    
56. uchar read1302()
    
57. {
    
58.    uchar i,dat;
    
59.    delaynus(2);        
    
60.   for(i=0;i<8;i++)   
    
61.   {
    
62.    dat>>=1;      
    
63.    if(daio==1)      
    
64.    dat|=0x80;     
    
65.    sclk=1;        
    
66.    delaynus(2);   
    
67.    sclk=0;        
    
68.    delaynus(2);                                      
    
69.    }  
    
70.   return dat;        
    
71. }
    
72. 
    
73.   
    
74. uchar readset1302(uchar add)
    
75. {
    
76.   uchar dat;
    
77.   rst=0;                 
    
78.   sclk=0;                 
    
79.   rst=1;                 
    
80.   write1302(add);      
    
81.   dat=read1302();        
    
82.   sclk=1;               
    
83.   rst=0;               
    
84.   return dat;           
    
85. }
    
86. 
    
87. void Init_1302()
    
88. {
    
89.         writeset1302(0x8E,0x00);                  
    
90.         writeset1302(0x80,((56/10)<<4|(56%10)));            
    
91.         writeset1302(0x82,((59/10)<<4|(59%10)));   
    
92.         writeset1302(0x84,((23/10)<<4|(23%10)));  
    
93.         writeset1302(0x86,((26/10)<<4|(26%10)));  
    
94.         writeset1302(0x88,((12/10)<<4|(12%10)));
    
95.         writeset1302(0x8a,((5/10)<<4|(5%10)));
    
96.         writeset1302(0x8c,((14/10)<<4|(14%10)));   
    
97. }
    
98. 
    
99. 
    
100. void delay1ms()
     
101. {
     
102.    unsigned char i,j;
     
103.   for(i=0;i<10;i++)
     
104.    for(j=0;j<33;j++);   
     
105. }
     
106. 
     
107. void delaynms(unsigned char n)
     
108. {
     
109.    unsigned char i;
     
110. for(i=0;i<n;i++)
     
111.     delay1ms();
     
112. }
     
113. 
     
114. void delay(uint z)
     
115. {
     
116.   uint x,y;
     
117.   for(x=z;x>0;x--)
     
118.   for(y=110;y>0;y--);
     
119. 
     
120. }
     
121. 
     
122. void write_com(uchar com)
     
123. {
     
124. rs=0;
     
125. rw=0;
     
126. ep=0;
     
127. P0=com;
     
128. delay(2);
     
129. ep=1;
     
130. delay(2);
     
131. ep=0;
     
132. delay(2);
     
133. }
     
134. 
     
135. void write_dat(uchar dat)
     
136. {
     
137. rs=1;
     
138. rw=0;
     
139. ep=0;
     
140. P0=dat;
     
141. delay(2);
     
142. ep=1;
     
143. delay(2);
     
144. ep=0;
     
145. delay(2);
     
146. }
     
147. void write_zfc(uchar *p)
     
148. {
     
149.   while(*p!=0)
     
150.   write_dat(*p++);
     
151. }
     
152. void init_1602()
     
153. {
     
154. write_com(0x38);
     
155. write_com(0x01);
     
156. write_com(0x06);
     
157. write_com(0x0c);
     
158. 
     
159. write_com(0x80);
     
160. write_zfc(" 20  -  -  ");
     
161. write_com(0xc0);
     
162. write_zfc("     :  :  ");
     
163. }
     
164. void write_1602(uchar add,uchar dat)
     
165. {
     
166. write_com(add);
     
167. write_dat(dat+0x30);
     
168. }
     
169. 
     
170. void DisplaySecond(uchar x)
     
171. {
     
172. unsigned char shi,ge;      
     
173. shi=x/10;
     
174. ge=x%10;   
     
175.    
     
176. write_1602(0xc0+9,shi);
     
177. write_1602(0xc0+10,ge);
     
178. delaynms(50);            
     
179. }
     
180. 
     
181. void DisplayMinute(uchar x)
     
182. {
     
183. unsigned char shi,ge;      
     
184. shi=x/10;
     
185. ge=x%10;      
     
186. write_1602(0xc0+6,shi );
     
187. write_1602(0xc0+7,ge );
     
188. delaynms(50);         
     
189. }
     
190. 
     
191. void DisplayHour(uchar x)
     
192. {
     
193. unsigned char shi,ge;   
     
194. shi=x/10;
     
195. ge=x%10;      
     
196. write_1602(0xc0+3,shi);
     
197. write_1602(0xc0+4,ge);
     
198. delaynms(50);            
     
199. }
     
200. 
     
201. void DisplayDay(uchar x)
     
202. {
     
203. unsigned char shi,ge;      
     
204. shi=x/10;
     
205. ge=x%10;      
     
206. write_1602(0x80+9,shi );
     
207. write_1602(0x80+10,ge );
     
208. delaynms(50);              
     
209. }
     
210. 
     
211. void Displayweek()
     
212. {                                          
     
213.    write_1602(0x80+12,week+0x30);
     
214.    switch(week)
     
215.    {
     
216.             case 1: write_com(0x80+12);
     
217.                          write_zfc("mon");
     
218.          break;
     
219.          case 2:write_com(0x80+12);
     
220.                          write_zfc("tue");
     
221.          break;
     
222.          case 3:write_com(0x80+12);
     
223.                 write_zfc("wed");
     
224.          break;
     
225.          case 4:write_com(0x80+12);
     
226.                 write_zfc("thu");
     
227.          break;
     
228.          case 5:write_com(0x80+12);
     
229.                 write_zfc("fri");
     
230.          break;
     
231.          case 6:write_com(0x80+12);
     
232.                 write_zfc("sta");
     
233.          break;
     
234.          case 7:write_com(0x80+12);
     
235.                 write_zfc("sun");
     
236.          break;
     
237.    }
     
238.    
     
239. 
     
240. }
     
241.   
     
242. void DisplayMonth(uchar x)
     
243. {
     
244. uchar shi,ge;     
     
245. shi=x/10;
     
246. ge=x%10;      
     
247. write_1602(0x80+6,shi );
     
248. write_1602(0x80+7,ge );
     
249. delaynms(50);            
     
250. }
     
251. 
     
252. void DisplayYear(unsigned char x)
     
253. {
     
254. unsigned char shi,ge;  
     
255. shi=x/10;
     
256. ge=x%10;      
     
257. write_1602(0x80+3,shi);
     
258. write_1602(0x80+4,ge);
     
259. delaynms(50);              
     
260. }
     
261. 
     
262. void keyscan()
     
263. {
     
264.   if(keyfw==0)
     
265.   {
     
266.           delay(2);
     
267.         if(keyfw==0)
     
268.         {
     
269.           while(!keyfw);
     
270.           {
     
271.              keynum++;
     
272.                  switch(keynum)
     
273.                  {
     
274.                   case 1:write_com(0x0f);
     
275.                          write_com(0xc0+10);
     
276.                   break;
     
277. 
     
278.                   case 2:write_com(0x0f);
     
279.                          write_com(0xc0+7);
     
280.                   break;
     
281. 
     
282.                   case 3:write_com(0x0f);
     
283.                          write_com(0xc0+4);
     
284.                   break;
     
285. 
     
286.                   case 4:write_com(0x0f);
     
287.                          write_com(0x80+12);
     
288.                   break;
     
289. 
     
290.                   case 5:write_com(0x0f);
     
291.                          write_com(0x80+10);
     
292.                   break;
     
293. 
     
294.                   case 6:write_com(0x0f);
     
295.                          write_com(0x80+7);
     
296.                   break;
     
297. 
     
298.                   case 7:write_com(0x0f);
     
299.                          write_com(0x80+4);
     
300.                   break;
     
301. 
     
302.                           case 8: keynum=0;
     
303.             write_com(0x0c);
     
304.                 writeset1302(0x80,((second/10)<<4|(second%10)));            
     
305.                 writeset1302(0x82,((minute/10)<<4|(minute%10)));   
     
306.                 writeset1302(0x84,((hour/10)<<4|(hour%10)));  
     
307.                 writeset1302(0x86,((day/10)<<4|(day%10)));  
     
308.                 writeset1302(0x88,((month/10)<<4|(month%10)));
     
309.                 writeset1302(0x8a,((week/10)<<4|(week%10)));
     
310.                 writeset1302(0x8c,((year/10)<<4|(year%10)));  
     
311.                                 
     
312.                 break;
     
313.                  
     
314.                  }
     
315.           }
     
316.         
     
317.         }
     
318.   
     
319.   }
     
320. 
     
321. if(keynum!=0)
     
322.   {
     
323.           if(keyjia==0)
     
324.         {
     
325.          delay(5);
     
326.          if(keyjia==0)
     
327.          {
     
328.                  while(!keyjia);
     
329.                 {
     
330.                   switch(keynum)
     
331.                   {
     
332.                   case 1:second++;
     
333.                          if(second==60)
     
334.                                  second=0;
     
335.                          write_com(0xc0+12);
     
336.                                  DisplaySecond(second);
     
337.                   break;
     
338. 
     
339.                   case 2:minute++;
     
340.                          if(minute==60)
     
341.                                  minute=0;
     
342.                                  DisplayMinute(minute);
     
343.                          write_com(0xc0+7);
     
344.                   break;
     
345. 
     
346.                   case 3:hour++;
     
347.                                    if(hour==24)
     
348.                                   hour=0;
     
349.                           DisplayHour(hour);
     
350.                           write_com(0xc0+4);
     
351.                   break;
     
352. 
     
353.                   case 4:week++;
     
354.                           if(week==8)
     
355.                                    week=0;
     
356.                                  Displayweek();
     
357.                          write_com(0x80+12);
     
358.                   break;
     
359. 
     
360.                   case 5:day++;
     
361.                          if(day==32)
     
362.                                  day=1;
     
363.                                  DisplayDay(day);
     
364.                          write_com(0x80+10);
     
365.                   break;
     
366. 
     
367.                   case 6:month++;
     
368.                              if(month==13)
     
369.                                    month=1;
     
370.                                    DisplayMonth(month);
     
371.                          write_com(0x80+7);
     
372.                   break;
     
373. 
     
374.                   case 7:year++;
     
375.                          if(year==100)
     
376.                                  year=0;
     
377.                                  DisplayYear(year);
     
378.                          write_com(0x80+4);
     
379.                   break;
     
380.                  
     
381.                   }
     
382.                
     
383.                 }
     
384.          
     
385.          }
     
386.         
     
387.         }
     
388.   
     
389.   
     
390.   }
     
391. 
     
392. if(keynum!=0)
     
393.   {
     
394.           if(keyjian==0)
     
395.         {
     
396.          delay(2);
     
397.          if(keyjian==0)
     
398.          {
     
399.                  while(!keyjian);
     
400.                 {
     
401.                   switch(keynum)
     
402.                   {
     
403.                   case 1:second--;
     
404.                          if(second==-1)
     
405.                                  second=59;
     
406.                          write_com(0xc0+12);
     
407.                                  DisplaySecond(second);
     
408.                   break;
     
409. 
     
410.                   case 2:minute--;
     
411.                          if(minute==-1)
     
412.                                  minute=59;
     
413.                                  DisplayMinute(minute);
     
414.                          write_com(0xc0+7);
     
415.                   break;
     
416. 
     
417.                   case 3:hour--;
     
418.                                    if(hour==-1)
     
419.                                   hour=23;
     
420.                           DisplayHour(hour);
     
421.                           write_com(0xc0+4);
     
422.                   break;
     
423. 
     
424.                   case 4:week--;
     
425.                           if(week==-1)
     
426.                                    week=7;
     
427.                                  Displayweek();
     
428.                          write_com(0x80+12);
     
429.                   break;
     
430. 
     
431.                   case 5:day++;
     
432.                          if(day==0)
     
433.                                  day=31;
     
434.                                  DisplayDay(day);
     
435.                          write_com(0x80+10);
     
436.                   break;
     
437. 
     
438.                   case 6:month--;
     
439.                              if(month==0)
     
440.                                    month=12;
     
441.                                    DisplayMonth(month);
     
442.                          write_com(0x80+7);
     
443.                   break;
     
444. 
     
445.                   case 7:year--;
     
446.                          if(year==-1)
     
447.                                  year=99;
     
448.                                  DisplayYear(year);
     
449.                          write_com(0x80+4);
     
450.                   break;
     
451.                  
     
452.                   }
     
453.                
     
454.                 }
     
455.          
     
456.          }
     
457.         
     
458.         }
     
459.   
     
460.   
     
461.   }
     
462. 
     
463. 
     
464. }
     
465. 
     
466. 
     
467. void main()
     
468. {
     
469.       
     
470.   uchar ReadValue;   
     
471.   init_1602();
     
472.   Init_1302();        
     
473. 
     
474.   while(1)
     
475.     {
     
476.         keyscan();
     
477.   if(keynum==0)
     
478.   {
     
479.                 ReadValue =readset1302(0x8b);   
     
480.                    week=((ReadValue&0x70)>>4)*10+(ReadValue&0x0F);
     
481.                    Displayweek();
     
482.                
     
483.                 ReadValue = readset1302(0x81);   
     
484.                      second=((ReadValue&0x70)>>4)*10 + (ReadValue&0x0F);
     
485.                    DisplaySecond(second);         
     
486.                
     
487.                 ReadValue = readset1302(0x83);   
     
488.                      minute=((ReadValue&0x70)>>4)*10 + (ReadValue&0x0F);  
     
489.                    DisplayMinute(minute);        
     
490.                
     
491.                 ReadValue = readset1302(0x85);   
     
492.                      hour=((ReadValue&0x70)>>4)*10 + (ReadValue&0x0F);  
     
493.                    DisplayHour(hour);               
     
494.                                                                                                                           
     
495.                 ReadValue = readset1302(0x87);   
     
496.                      day=((ReadValue&0x70)>>4)*10 + (ReadValue&0x0F);  
     
497.                    DisplayDay(day);               
     
498.                
     
499.                 ReadValue = readset1302(0x89);   
     
500.                      month=((ReadValue&0x70)>>4)*10 + (ReadValue&0x0F);  
     
501.                    DisplayMonth(month);            
     
502.                
     
503.                 ReadValue = readset1302(0x8d);   
     
504.                      year=((ReadValue&0x70)>>4)*10 + (ReadValue&0x0F);  
     
505.                    DisplayYear(year);
     
506.    }            
     
507.   }
     
508. }
     

复制代码

感谢提供分享！

感谢提供分享，学习一下。

不需要单片机么？

感觉楼主程序不够好，显示2014年，而不是现在时间，没仔细看程序

厉害了 老哥

厉害了 老哥