程序写的不错，就是二月份不管是什么年份都直接跳过了

yzwzfyz 发表于 2016-5-26 12:12
方法:
设你的长按键叫CA,S就是你长按的时间门限值;
1,设定一个标记叫CAOK,=1时表示长按成功;

好久之前写的东西了，这些功能后来已经实现了，还有1302，屏幕也换成12864了，已经移植到STM32上了，不过还是多谢了

方法:
设你的长按键叫CA,S就是你长按的时间门限值;
1,设定一个标记叫CAOK,=1时表示长按成功;
2,做一个按键计时器K,设定一个标记KY,约定KY=1时,由时间中断(如10ms)进行K+1;
实现:
1,每次检测时:有CA时KY=1.<起动计时器>
2,每次检测时:无CA时KY=1,K=0.KY=0<清计时器并清0>(必须多次检测,且间隔时间<<S);
3,当K=S时,置CAOK=1;
4,当CAOK被使用完成后,请记得清CAOK=0;
这样还不够,这里不说了.就是长按时间>S后的处理.留给你自己解决吧.

二楼写得不错

程序不错

proteus7.8闹钟显示不对怎么办

程序如上，识别按键被按下，做对应的输出

仿真及程序都在压缩包里

1. #include<reg52.h>
   
2. #define uint unsigned int
   
3. #define uchar unsigned char
   
4. sbit RS=P1^3;
   
5. sbit R_W=P1^4;
   
6. sbit E=P1^5;
   
7. sbit wx=P2^6;
   
8. sbit dx=P2^7;
   
9. sbit O=P3^4;
   
10. sbit L=P3^5;
    
11. sbit R=P3^6;
    
12. sbit S=P3^7;
    
13. sbit beep=P2^2;
    
14. uint n=2015;
    
15. uchar num,w,s=6,f=0,m=0,q,p,y=5,d=5,cs,cf,t=0x58;
    
16. char r=0;
    
17. bit a;
    
18. uchar code table[]={0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39};
    
19. uchar code table1[]={"Mon"};
    
20. uchar code table2[]={"Tue"};
    
21. uchar code table3[]={"Wed"};
    
22. uchar code table4[]={"Thu"};
    
23. uchar code table5[]={"Fri"};
    
24. uchar code table6[]={"Sat"};
    
25. uchar code table7[]={"Sun"};
    
26. void lcdshow();
    
27. void delay(uchar s)
    
28. {
    
29.         uchar j,k;
    
30.         for(j=s;j>0;j--)
    
31.                 for(k=114;k>0;k--);
    
32. }
    
33. void R_busy()
    
34. {
    
35.         P0=0x00;
    
36.         RS=0;
    
37.         R_W=1;
    
38.         E=1;
    
39.         while(P0&0x80);
    
40.         E=0;
    
41. }
    
42. void W_cmd(uchar com)
    
43. {
    
44.         R_busy();
    
45.         RS=0;
    
46.         R_W=0;
    
47.         P0=com;
    
48.         delay(2);
    
49.         E=1;
    
50.         delay(2);
    
51.         E=0;
    
52. }
    
53. void W_data(uchar date)
    
54. {
    
55.         R_busy();
    
56.         RS=1;
    
57.         R_W=0;
    
58.         P0=date;
    
59.         delay(2);
    
60.         E=1;
    
61.         delay(2);
    
62.         E=0;
    
63. }
    
64. void init()
    
65. {
    
66.         wx=0;
    
67.         dx=0;
    
68.         E=0;
    
69.         EA=1;
    
70.         ET0=1;
    
71.         TR0=1;
    
72.         TMOD=0x01;
    
73.         TH0=(65536-46080)/256;
    
74.         TL0=(65536-46080)%256;
    
75.         W_cmd(0x38);
    
76.         W_cmd(0x0c);
    
77.         W_cmd(0x06);
    
78.         W_cmd(0x01);
    
79. }
    
80. void week()
    
81. {
    
82.         uchar m;
    
83.         w=((n/100)/4)-2*(n/100)+(n%100)+((n%100)/4)+((13*(y+1))/5)+d-1;
    
84.         W_cmd(0x80+0x0c);
    
85.         switch(w%7)
    
86.         {
    
87.                 case 0:
    
88.                 for(m=0;m<3;m++)
    
89.                 {
    
90.                         W_data(table7[m]);
    
91.                 }
    
92.                 break;
    
93. 
    
94.                 case 1:
    
95.                 for(m=0;m<3;m++)
    
96.                 {
    
97.                         W_data(table1[m]);
    
98.                 }
    
99.                 break;
    
100. 
     
101.                 case 2:
     
102.                 for(m=0;m<3;m++)
     
103.                 {
     
104.                         W_data(table2[m]);
     
105.                 }
     
106.                 break;
     
107. 
     
108.                 case 3:
     
109.                 for(m=0;m<3;m++)
     
110.                 {
     
111.                         W_data(table3[m]);
     
112.                 }
     
113.                 break;
     
114. 
     
115.                 case 4:
     
116.                 for(m=0;m<3;m++)
     
117.                 {
     
118.                         W_data(table4[m]);
     
119.                 }
     
120.                 break;
     
121. 
     
122.                 case 5:
     
123.                 for(m=0;m<3;m++)
     
124.                 {
     
125.                         W_data(table5[m]);
     
126.                 }
     
127.                 break;
     
128. 
     
129.                 case 6:
     
130.                 for(m=0;m<3;m++)
     
131.                 {
     
132.                         W_data(table6[m]);
     
133.                 }
     
134.                 break;
     
135. 
     
136.                 default:
     
137.                 break;
     
138.         }
     
139. }
     
140. void control_move()
     
141. {
     
142.         switch(r)
     
143.         {
     
144.                 case 0:
     
145.                 W_cmd(0x80+0x01);
     
146.                 break;
     
147. 
     
148.                 case 1:
     
149.                 W_cmd(0x80+0x02);
     
150.                 break;
     
151. 
     
152.                 case 2:
     
153.                 W_cmd(0x80+0x03);
     
154.                 break;
     
155. 
     
156.                 case 3:
     
157.                 W_cmd(0x80+0x04);
     
158.                 break;
     
159. 
     
160.                 case 4:
     
161.                 W_cmd(0x80+0x06);
     
162.                 break;
     
163. 
     
164.                 case 5:
     
165.                 W_cmd(0x80+0x07);
     
166.                 break;
     
167. 
     
168.                 case 6:
     
169.                 W_cmd(0x80+0x09);
     
170.                 break;
     
171. 
     
172.                 case 7:
     
173.                 W_cmd(0x80+0x0a);
     
174.                 break;
     
175. 
     
176.                 case 8:
     
177.                 W_cmd(0x80+0x44);
     
178.                 break;
     
179. 
     
180.                 case 9:
     
181.                 W_cmd(0x80+0x45);
     
182.                 break;
     
183. 
     
184.                 case 10:
     
185.                 W_cmd(0x80+0x47);
     
186.                 break;
     
187. 
     
188.                 case 11:
     
189.                 W_cmd(0x80+0x48);
     
190.                 break;
     
191. 
     
192.                 case 12:
     
193.                 W_cmd(0x80+0x4a);
     
194.                 break;
     
195. 
     
196.                 case 13:
     
197.                 W_cmd(0x80+0x4b);
     
198.                 break;
     
199. 
     
200.                 case 14:
     
201.                 W_cmd(0x80+0x4e);
     
202.                 break;
     
203. 
     
204.                 case 16:
     
205.                 W_cmd(0x80+0x11);
     
206.                 W_data(table[cs/10]);
     
207.                 W_cmd(0x80+0x11);
     
208.                 break;
     
209. 
     
210.                 case 17:
     
211.                 W_cmd(0x80+0x12);
     
212.                 W_data(table[cs%10]);
     
213.                 W_cmd(0x80+0x12);
     
214.                 break;
     
215. 
     
216.                 case 18:
     
217.                 W_cmd(0x80+0x14);
     
218.                 W_data(table[cf/10]);
     
219.                 W_cmd(0x80+0x14);
     
220.                 break;
     
221. 
     
222.                 case 19:
     
223.                 W_cmd(0x80+0x15);
     
224.                 W_data(table[cf%10]);
     
225.                 W_cmd(0x80+0x15);
     
226.                 break;
     
227. 
     
228.                 case 20:
     
229.                 W_cmd(0x80+0x17);
     
230.                 break;
     
231. 
     
232.                 case 21:
     
233.                 W_cmd(0x80+0x19);
     
234.                 break;
     
235. 
     
236.                 default:
     
237.                 if(r>20)
     
238.                         W_cmd(0x80+0x11);
     
239.                 if(r<16)
     
240.                         W_cmd(0x80+0x01);
     
241.                 break;
     
242.         }
     
243. }
     
244. void leap()
     
245. {
     
246.         switch(y)
     
247.         {
     
248.                 case 2:
     
249.                 if(n%4==0&&n%100!=0||n%400==0)
     
250.                 {
     
251.                         if(d>29)
     
252.                         d=1;
     
253.                         y++;
     
254.                 }
     
255.                 else
     
256.                 {
     
257.                         if(d>28)
     
258.                         d=1;
     
259.                         y++;
     
260.                 }
     
261.                 break;
     
262. 
     
263.                 case 4:
     
264.                 if(d>30)
     
265.                 {
     
266.                         d=1;
     
267.                         y++;
     
268.                 }
     
269.                 break;
     
270. 
     
271.                 case 6:
     
272.                 if(d>30)
     
273.                 {
     
274.                         d=1;
     
275.                         y++;
     
276.                 }
     
277.                 break;
     
278. 
     
279.                 case 9:
     
280.                 if(d>30)
     
281.                 {
     
282.                         d=1;
     
283.                         y++;
     
284.                 }
     
285.                 break;
     
286. 
     
287.                 case 11:
     
288.                 if(d>30)
     
289.                 {
     
290.                         d=1;
     
291.                         y++;
     
292.                 }
     
293.                 break;
     
294. 
     
295.                 default:
     
296.                 if(d>31)
     
297.                 {
     
298.                         d=1;
     
299.                         y++;
     
300.                 }
     
301.                 break;
     
302.         }
     
303. }
     
304. void lcdshow()
     
305. {
     
306.         W_cmd(0x80);
     
307.         W_data(0x20);
     
308.         W_data(table[n/1000]);
     
309.         W_data(table[(n/100)%10]);
     
310.         W_data(table[(n/10)%10]);
     
311.         W_data(table[n%10]);
     
312.         W_data(0x2f);
     
313.         W_data(table[y/10]);
     
314.         W_data(table[y%10]);
     
315.         W_data(0x2f);
     
316.         W_data(table[d/10]);
     
317.         W_data(table[d%10]);
     
318.         W_cmd(0x80+0x44);
     
319.         W_data(table[s/10]);
     
320.         W_data(table[s%10]);
     
321.         W_data(0x3a);
     
322.         W_data(table[f/10]);
     
323.         W_data(table[f%10]);
     
324.         W_data(0x3a);
     
325.         W_data(table[m/10]);
     
326.         W_data(table[m%10]);   
     
327.         W_cmd(0x80+0x11);
     
328.         W_data(table[cs/10]);
     
329.         W_data(table[cs%10]);
     
330.         W_data(0x3a);
     
331.         W_data(table[cf/10]);
     
332.         W_data(table[cf%10]);
     
333.         W_cmd(0x80+0x17);
     
334.         W_data(t);
     
335.         W_cmd(0x80+0x19);
     
336.         W_data(0x3c);
     
337.         week();
     
338.         beep=1;
     
339. }
     
340. 
     
341. void control_set()
     
342. {
     
343.         uchar c;       
     
344.         switch(r)
     
345.         {
     
346.                 case 0:
     
347.                 n=n+1000;
     
348.                 if(n>9999)
     
349.                         n=0;
     
350.                 lcdshow();
     
351.                 W_cmd(0x80+0x01);
     
352.                 break;
     
353. 
     
354.                 case 1:
     
355.                 n=n+100;
     
356.                 if(n>9999)
     
357.                         n=0;
     
358.                 lcdshow();
     
359.                 W_cmd(0x80+0x02);
     
360.                 break;
     
361. 
     
362.                 case 2:
     
363.                 n=n+10;
     
364.                 if(n>9999)
     
365.                         n=0;
     
366.                 lcdshow();
     
367.                 W_cmd(0x80+0x03);
     
368.                 break;
     
369. 
     
370.                 case 3:
     
371.                 n=n+1;
     
372.                 if(n>9999)
     
373.                         n=0;
     
374.                 lcdshow();
     
375.                 W_cmd(0x80+0x04);
     
376.                 break;
     
377. 
     
378.                 case 4:
     
379.                 y=y+10;
     
380.                 if(y>12)
     
381.                 {
     
382.                         y=1;
     
383.                 }
     
384.                 lcdshow();
     
385.                 W_cmd(0x80+0x06);
     
386.                 break;
     
387. 
     
388.                 case 5:
     
389.                 y=y+1;
     
390.                 if(y>12)
     
391.                 {       
     
392.                         y=1;
     
393.                 }
     
394.                 lcdshow();
     
395.                 W_cmd(0x80+0x07);
     
396.                 break;
     
397. 
     
398.                 case 6:
     
399.                 d=d+10;
     
400.                 leap();
     
401.                 lcdshow();
     
402.                 W_cmd(0x80+0x09);
     
403.                 break;
     
404. 
     
405.                 case 7:
     
406.                 d=d+1;
     
407.                 leap();
     
408.                 lcdshow();
     
409.                 W_cmd(0x80+0x0a);
     
410.                 break;
     
411. 
     
412.                 case 8:
     
413.                 s=s+10;
     
414.                 if(s>23)       
     
415.                         s=0;
     
416.                 lcdshow();
     
417.                 W_cmd(0x80+0x44);
     
418.                 break;
     
419. 
     
420.                 case 9:
     
421.                 s=s+1;
     
422.                 if(s>23)
     
423.                         s=0;
     
424.                 lcdshow();
     
425.                 W_cmd(0x80+0x45);
     
426.                 break;
     
427. 
     
428.                 case 10:
     
429.                 f=f+10;
     
430.                 if(f>59)
     
431.                         f=0;
     
432.                 lcdshow();
     
433.                 W_cmd(0x80+0x47);
     
434.                 break;
     
435. 
     
436.                 case 11:
     
437.                 f=f+1;
     
438.                 if(f>59)
     
439.                         f=0;
     
440.                 lcdshow();
     
441.                 W_cmd(0x80+0x48);
     
442.                 break;
     
443. 
     
444.                 case 12:
     
445.                 m=m+10;
     
446.                 if(m>59)
     
447.                         m=0;
     
448.                 lcdshow();
     
449.                 W_cmd(0x80+0x4a);
     
450.                 break;
     
451. 
     
452.                 case 13:
     
453.                 m=m+1;
     
454.                 if(m>59)
     
455.                         m=0;
     
456.                 lcdshow();
     
457.                 W_cmd(0x80+0x4b);
     
458.                 break;
     
459. 
     
460.                 case 14:
     
461.                 for(c=0;c<16;c++)
     
462.                 {
     
463.                         W_cmd(0x18);
     
464.                         delay(150);
     
465.                 }
     
466.                 r=16;
     
467.                 W_cmd(0x80+0x11);
     
468.                 break;
     
469. 
     
470.                 case 16:
     
471.                 cs=cs+10;
     
472.                 if(cs>23)
     
473.                         cs=0;
     
474.                 W_cmd(0x80+0x11);
     
475.                 W_data(table[cs/10]);
     
476.                 W_data(table[cs%10]);
     
477.                 W_cmd(0x80+0x11);
     
478.                 break;
     
479. 
     
480.                 case 17:
     
481.                 cs=cs+1;
     
482.                 if(cs>23)
     
483.                         cs=0;
     
484.                 W_cmd(0x80+0x11);
     
485.                 W_data(table[cs/10]);
     
486.                 W_data(table[cs%10]);
     
487.                 W_cmd(0x80+0x12);
     
488.                 break;
     
489. 
     
490.                 case 18:
     
491.                 cf=cf+10;
     
492.                 if(cf>59)
     
493.                         cf=0;
     
494.                 W_data(table[cf/10]);
     
495.                 W_data(table[cf%10]);
     
496.                 W_cmd(0x80+0x14);
     
497.                 break;
     
498. 
     
499.                 case 19:
     
500.                 cf=cf+1;
     
501.                 if(cf>59)
     
502.                         cf=0;
     
503.                 W_cmd(0x80+0x14);
     
504.                 W_data(table[cf/10]);
     
505.                 W_data(table[cf%10]);
     
506.                 W_cmd(0x80+0x15);
     
507.                 break;
     
508. 
     
509.                 case 20:
     
510.                 a=~a;
     
511.                 if(a==1)
     
512.                         t=0x4f;
     
513.                 else
     
514.                         t=0x58;
     
515.                 W_cmd(0x80+0x17);
     
516.                 W_data(t);
     
517.                 W_cmd(0x80+0x17);
     
518.                 break;
     
519. 
     
520.                 case 21:
     
521.                 for(c=0;c<16;c++)
     
522.                 {
     
523.                         W_cmd(0x1c);
     
524.                         delay(150);
     
525.                 }
     
526.                 W_cmd(0x80+0x01);
     
527.                 r=0;
     
528.                 break;
     
529.         }
     
530. }
     
531. void control()
     
532. {
     
533.         if(O==0)
     
534.         {
     
535.                 delay(10);
     
536.                 if(O==0)
     
537.                 {
     
538.                         while(!O);
     
539.                         TR0=0;
     
540.                         W_cmd(0x0f);
     
541.                         W_cmd(0x80+0x4e);
     
542.                         W_data(0x43);
     
543.                         W_cmd(0x80+0x01);
     
544.                         while(1)
     
545.                         {
     
546.                                 if(O==0)
     
547.                                 {
     
548.                                         delay(10);
     
549.                                         if(O==0)
     
550.                                         {
     
551.                                                 while(!O);
     
552.                                                 TR0=1;
     
553.                                                 r=0;
     
554.                                                 init();
     
555.                                                 break;
     
556.                                         }
     
557.                                 }
     
558.                                 if(L==0)
     
559.                                 {
     
560.                                         delay(10);
     
561.                                         if(L==0)
     
562.                                         {
     
563.                                                 while(!L);
     
564.                                                 r--;
     
565.                                                 if(r<0)
     
566.                                                 {
     
567.                                                         r=14;
     
568.                                                         W_cmd(0x80+0x4b);
     
569.                                                 }
     
570.                                                 if(r>14&&r<16)
     
571.                                                 {
     
572.                                                         r=21;
     
573.                                                         W_cmd(0x80+0x15);
     
574.                                                 }
     
575.                                                 control_move();
     
576.                                         }
     
577.                                 }
     
578.                                 if(R==0)
     
579.                                 {
     
580.                                         delay(10);
     
581.                                         if(R==0)
     
582.                                         {
     
583.                                                 while(!R);
     
584.                                                 r++;
     
585.                                                 if(r>14)
     
586.                                                 {
     
587.                                                         if(r<16)
     
588.                                                         {
     
589.                                                                 r=0;
     
590.                                                                 W_cmd(0x80+0x01);
     
591.                                                         }
     
592.                                                         if(r>21)
     
593.                                                         {
     
594.                                                                 r=16;
     
595.                                                                 W_cmd(0x80+0x11);
     
596.                                                         }
     
597.                                                 }
     
598.                                                 control_move();
     
599.                                         }
     
600.                                 }
     
601.                                 if(S==0)
     
602.                                 {
     
603.                                         delay(10);
     
604.                                         if(S==0)
     
605.                                         {
     
606.                                                 while(!S);
     
607.                                                 control_set();
     
608.                                         }
     
609.                                 }               
     
610.                         }
     
611.                         lcdshow();
     
612.                 }
     
613.         }
     
614. }
     
615. void count()
     
616. {
     
617.         if(num==20)
     
618.         {
     
619.                 m++;
     
620.                 if(a==1)
     
621.                 {
     
622.                         if(cs==s)
     
623.                         {
     
624.                                 if(cf==f)
     
625.                                 {
     
626.                                         beep=~beep;
     
627.                                 }
     
628.                         }
     
629.                 }
     
630.                 num=0;
     
631.                 if(m==60)
     
632.                 {
     
633.                         f++;
     
634.                         m=0;
     
635.                         if(f==60)
     
636.                         {
     
637.                                 beep=0;
     
638.                                 s++;
     
639.                                 f=0;
     
640.                                 if(s==24)
     
641.                                 {
     
642.                                         s=0;
     
643.                                         d++;
     
644.                                         leap();
     
645.                                         if(y>12)
     
646.                                         {
     
647.                                                 y=1;
     
648.                                                 n++;
     
649.                                                 if(n>9999)
     
650.                                                         n=0;
     
651.                                         }
     
652.                                 }
     
653.                         }
     
654.                 }
     
655.                 lcdshow();       
     
656.         }
     
657. }
     
658. void main()
     
659. {
     
660.         init();
     
661.         lcdshow();
     
662.         while(1)
     
663.         {
     
664.                 count();
     
665.                 control();
     
666.         }
     
667. }
     
668. void Timer()interrupt 1
     
669. {
     
670.         TH0=(65536-46080)/256;
     
671.         TL0=(65536-46080)%256;
     
672.         num++;
     
673. }

复制代码