基于单片机数码管的可调数字钟闹钟Proteus仿真程序

这款闹钟具备整点报时，设置多个闹钟，能够调时等功能，非常全面，分享一下。


单片机源程序如下:

1. #include<reg51.h>              
   
2. #include<intrins.h>
   
3. //****************************宏定义********************************
   
4. typedef unsigned char uchar;   
   
5. typedef unsigned int  uint;
   
6. //****************************位声明********************************
   
7. sbit key1=P1^0;               
   
8. sbit key2=P1^1;
   
9. sbit key3=P1^2;
   
10. sbit key4=P1^3;
    
11. sbit beep=P3^0;       
    
12. //************************数码管显示的数值**************************
    
13. uchar code table[]=        {
    
14.                                                 0x3f,0x06,0x5b,0x4f,0x66,0x6d,
    
15.                                                 0x7d,0x07,0x7f,0x6f,0x40,0x00
    
16.                                         };                      
    
17. //****************************函数声明******************************
    
18. void jia();   
    
19. void jian();
    
20. //********************数组定义，数组内含有8个数值******************
    
21. uchar table1[8],table2[8],table3[8],table4[8];
    
22. //**************************时间显示初始值**************************
    
23. uchar shi=12,fen=0,miao=0;  
    
24. //**************************定义全局变量****************************
    
25. uchar shi1,fen1,miao1,shi2,fen2,miao2,shi3,fen3,miao3;
    
26. uchar shi4,fen4,miao4;
    
27. uchar flag, flag1, wss, cnt, cnt1, alm1, alm2, alm3;
    
28. //    1秒   等时  位闪 次数 校时   闹1  闹2   闹3
    
29. uint flag2;
    
30. //   蜂鸣
    
31. //*********************延时函数，用于动态扫描数码管*****************
    
32. void delay(uchar i)                                    
    
33. {  
    
34.         uchar x,y;
    
35.            for(x=i;x>0;x--)
    
36.              for(y=120;y>0;y--);
    
37. }
    
38. //*******************************初始化函数*************************
    
39. void init()   
    
40. {  
    
41.         TMOD=0x01;         //工作方式1                                                                               
    
42.            TH0=0x3c;          //定时时间为：50ms        (65536-50000)/256
    
43.            TL0=0x0b0;         //(65536-50000)%256
    
44.         EA=1;              //开总中断
    
45.            ET0=1;             //打开定时器
    
46.            TR0=1;             //启动定时器
    
47.         beep=0;
    
48. }
    
49. //********************显示子函数，用于显示时间数值*****************
    
50. void display()  
    
51. {  
    
52.         uchar i,j;
    
53.            if(cnt!=10||wss==0)
    
54.     {
    
55.                 table1[0]=miao%10;        //分离秒的个位与十位
    
56.                table1[1]=miao/10;
    
57.         }
    
58.         else
    
59.                  table1[0]=table1[1]=11;
    
60.         if(cnt!=11||wss==0)
    
61.         {
    
62.                 table1[3]=fen%10;         //分离分的个位与十位
    
63.                table1[4]=fen/10;
    
64.         }
    
65.         else
    
66.                   table1[3]=table1[4]=11;
    
67.         if(cnt!=12||wss==0)
    
68.         {
    
69.                 table1[6]=shi%10;         //分离时的个位与十位
    
70.                table1[7]=shi/10;
    
71.         }
    
72.         else
    
73.                 table1[6]=table1[7]=11;
    
74.     table1[2]=table1[5]=10;
    
75.     j=0xfb;
    
76.     for(i=0;i<=7;i++)          //从秒到时的扫描
    
77.     {  
    
78.                 P2=j;
    
79.         P0=table[table1[i]];  //显示数值
    
80.         delay(10);
    
81.         j=_cror_(j,1);        //循环右移
    
82.     }
    
83. }
    
84. //*******************显示子函数，用于显示定时1时间*****************
    
85. void display1()
    
86. {  
    
87.         uchar i,j;
    
88.            if(alm1==0)
    
89.     {
    
90.                 if(cnt!=1||wss==0)
    
91.             {
    
92.                         table2[0]=miao1%10;        //以下含义同上
    
93.                    table2[1]=miao1/10;
    
94.                 }
    
95.                    else
    
96.                       table2[0]=table2[1]=11;
    
97.                    if(cnt!=2||wss==0)
    
98.             {
    
99.                         table2[3]=fen1%10;
    
100.                    table2[4]=fen1/10;
     
101.                 }
     
102.                    else
     
103.                      table2[3]=table2[4]=11;
     
104.                    if(cnt!=3||wss==0)
     
105.             {
     
106.                         table2[6]=shi1%10;
     
107.                    table2[7]=shi1/10;
     
108.                 }
     
109.                    else
     
110.                      table2[6]=table2[7]=11;
     
111.         }
     
112.         else
     
113.                    table2[0]=table2[1]=table2[3]=table2[4]=table2[6]=table2[7]=10;
     
114.            table2[2]=table2[5]=10;
     
115.            j=0xfb;
     
116.            for(i=0;i<=7;i++)
     
117.            {  
     
118.                 P2=j;
     
119.         P0=table[table2[i]];
     
120.                 delay(10);
     
121.         j=_cror_(j,1);
     
122.            }
     
123. }
     
124. //********************显示子函数，用于显示定时2时间******************
     
125. void display2()
     
126. {  
     
127.         uchar i,j;
     
128.            if(alm2==0)
     
129.     {
     
130.                 if(cnt!=4||wss==0)
     
131.             {
     
132.                         table3[0]=miao2%10;        //以下含义同上
     
133.                    table3[1]=miao2/10;
     
134.                    }
     
135.                    else
     
136.                       table3[0]=table3[1]=11;
     
137.                    if(cnt!=5||wss==0)
     
138.             {
     
139.                         table3[3]=fen2%10;
     
140.                    table3[4]=fen2/10;
     
141.                 }
     
142.                 else
     
143.                           table3[3]=table3[4]=11;
     
144.                 if(cnt!=6||wss==0)
     
145.                 {
     
146.                         table3[6]=shi2%10;
     
147.                    table3[7]=shi2/10;
     
148.                 }
     
149.                 else
     
150.                          table3[6]=table3[7]=11;
     
151.         }
     
152.         else
     
153.            table3[0]=table3[1]=table3[3]=table3[4]=table3[6]=table3[7]=10;
     
154.            table3[2]=table3[5]=10;
     
155.            j=0xfb;
     
156.            for(i=0;i<=7;i++)
     
157.     {         
     
158.                 P2=j;
     
159.         P0=table[table3[i]];
     
160.                 delay(10);
     
161.         j=_cror_(j,1);
     
162.     }
     
163. }
     
164. //***************显示子函数，用于显示定时3时间数值****************//
     
165. void display3()  
     
166. {
     
167.         uchar i,j;
     
168.            if(alm3==0)
     
169.     {  
     
170.                 if(cnt!=7||wss==0)
     
171.             {
     
172.                         table4[0]=miao3%10;        //分离秒的个位与十位
     
173.             table4[1]=miao3/10;
     
174.         }
     
175.                 else
     
176.                            table4[0]=table4[1]=11;
     
177.                 if(cnt!=8||wss==0)
     
178.                 {
     
179.                         table4[3]=fen3%10;         //分离分的个位与十位
     
180.             table4[4]=fen3/10;
     
181.                 }
     
182.                 else
     
183.                           table4[3]=table4[4]=11;
     
184.                 if(cnt!=9||wss==0)
     
185.                 {
     
186.                         table4[6]=shi3%10;         //分离时的个位与十位
     
187.             table4[7]=shi3/10;
     
188.                 }
     
189.                 else
     
190.                           table4[6]=table4[7]=11;
     
191.     }
     
192.     else
     
193.             table4[0]=table4[1]=table4[3]=table4[4]=table4[6]=table4[7]=10;
     
194.            table4[2]=table4[5]=10;
     
195.            j=0xfb;                    //从秒到时的扫描
     
196.            for(i=0;i<=7;i++)
     
197.            {  
     
198.                 P2=j;
     
199.         P0=table[table4[i]];  //显示数值
     
200.                 delay(10);
     
201.         j=_cror_(j,1);        //循环右移
     
202.            }
     
203. }
     
204. //***********************时间子函数 *****************************//
     
205. void shijian()         
     
206. {  
     
207.         if(flag>=20)               //判断是否到一秒
     
208.     {
     
209.                 wss=~wss;
     
210.                    flag=0;                                 //到了，则标志位清零
     
211.                    if(cnt1!=0)
     
212.             {
     
213.                         miao4++;          //秒加1
     
214.                    if(miao4>59)    //判断秒是否到60s
     
215.             {
     
216.                                 miao4=0;      //到了，则清零
     
217.                 fen4++;       //分加1
     
218.                 if(fen4>59)  //以下含义同上
     
219.                 {        
     
220.                                         fen4=0;
     
221.                                        
     
222.                     shi4++;
     
223.                                         if(flag1>1)               //等时方波驱动蜂鸣器
     
224.                                      {         beep=~beep;
     
225.                                                 flag1=0;
     
226.                                }
     
227.                     if(shi4>23)
     
228.                       shi4=0;                                                                                                                  
     
229.                  }       
     
230.              }
     
231.         }
     
232.                    else
     
233.                {
     
234.                         miao++;          //秒加1
     
235.                  if(miao>59)    //判断秒是否到60s
     
236.                    {
     
237.                                 miao=0;      //到了，则清零
     
238.                      fen++;       //分加1
     
239.                      if(fen>59)  //以下含义同上
     
240.                        {
     
241.                                         fen=0;
     
242.                          shi++;
     
243.                          if(shi>23)
     
244.                                    shi=0;                                                                                                                  
     
245.                 }       
     
246.             }
     
247.         }
     
248.     }
     
249. }
     
250. //**************************键盘扫描子函数************************//
     
251. void key_scan()
     
252. {  
     
253.         if(key1==0)
     
254.     {  
     
255.                 while(!key1)          //防止掉显
     
256.         {  
     
257.                         if(cnt==1||cnt==2||cnt==3)
     
258.                 display1();
     
259.                         if(cnt==4||cnt==5||cnt==6)
     
260.                 display2();
     
261.                         if(cnt==7||cnt==8||cnt==9)
     
262.                 display3();
     
263.                         if(cnt==0||cnt==10||cnt==11||cnt==12||cnt==13)
     
264.                     display();
     
265.         }
     
266.         cnt++;     //记下按键key1按下的次数                   
     
267.                 if(cnt==10&&cnt1==0)
     
268.                 {
     
269.                         miao4=miao;
     
270.                     fen4=fen;
     
271.                         shi4=shi;
     
272.                         cnt1++;
     
273.                 }
     
274.                 if(cnt==13)
     
275.                 {
     
276.                         cnt=0;
     
277.                     if(cnt1==1)
     
278.                         {
     
279.                                 miao=miao4;
     
280.                                 fen=fen4;
     
281.                                 shi=shi4;
     
282.                         }
     
283.                     cnt1=0;
     
284.                 }         
     
285.         }
     
286.            if(key2==0)              //判断key2是否按下
     
287.            {  
     
288.                 while(!key2)          //防止掉显
     
289.         {  
     
290.                         if(cnt==1||cnt==2||cnt==3)
     
291.                 display1();
     
292.                         if(cnt==4||cnt==5||cnt==6)
     
293.                 display2();
     
294.                         if(cnt==7||cnt==8||cnt==9)
     
295.                 display3();
     
296.                         if(cnt==0||cnt==10||cnt==11||cnt==12||cnt==13)
     
297.                 display();
     
298.         }
     
299.         jia();
     
300.            }
     
301.            if(key3==0)              //判断key3是否按下
     
302.            {  
     
303.                 while(!key3)          //防止掉显
     
304.         {  
     
305.                         if(cnt==1||cnt==2||cnt==3)
     
306.                 display1();
     
307.                         if(cnt==4||cnt==5||cnt==6)
     
308.                 display2();
     
309.                         if(cnt==7||cnt==8||cnt==9)
     
310.                 display3();  
     
311.                         if(cnt==0||cnt==10||cnt==11||cnt==12||cnt==13)
     
312.                 display();
     
313.         }
     
314.         jian();                    //调用减1子函数           
     
315.            }
     
316.         if(key4==0)                   //判断key4是否按下
     
317.         {
     
318.                 while(!key4)            //防止掉
     
319.             {
     
320.                         if(cnt==1||cnt==2||cnt==3)
     
321.                     {  
     
322.                                 alm1=~alm1;
     
323.                             display1();
     
324.                         }
     
325.                     if(cnt==4||cnt==5||cnt==6)
     
326.                     {  
     
327.                                 alm2=~alm2;
     
328.                             display2();
     
329.                         }
     
330.                     if(cnt==7||cnt==8||cnt==9)
     
331.                     {  
     
332.                                 alm3=~alm3;
     
333.                             display3();
     
334.                         }
     
335.                         if(cnt==0||cnt==10||cnt==11||cnt==12||cnt==13)
     
336.                        display();
     
337.                  }
     
338.         }      
     
339. }
     
340. //****************************加1子函数***************************
     
341. void jia()            
     
342. {
     
343.         if(cnt==1)                         //判断key1按下的次数是否为1
     
344.     {  
     
345.                 miao1++;                 //是，则秒加1
     
346.                if(miao1>59)         //判断秒是否大于60，是，则秒清零
     
347.            miao1=0;
     
348.     }
     
349.         if(cnt==2)                         //以下含意同上
     
350.     {  
     
351.                 fen1++;
     
352.         if(fen1>59)
     
353.            fen1=0;
     
354.     }
     
355.           if(cnt==3)
     
356.     {  
     
357.                 shi1++;
     
358.         if(shi1>23)
     
359.            shi1=0;
     
360.     }
     
361.           if(cnt==4)
     
362.     {  
     
363.                 miao2++;
     
364.         if(miao2>59)
     
365.            miao2=0;
     
366.     }
     
367.           if(cnt==5)
     
368.     {  
     
369.                 fen2++;
     
370.         if(fen2>59)
     
371.            fen2=0;
     
372.     }
     
373.           if(cnt==6)
     
374.     {  
     
375.                 shi2++;
     
376.         if(shi2>23)
     
377.            shi2=0;
     
378.     }
     
379.           if(cnt==7)
     
380.     {  
     
381.                 miao3++;
     
382.         if(miao3>59)
     
383.            miao3=0;
     
384.     }
     
385.           if(cnt==8)
     
386.     {  
     
387.                 fen3++;
     
388.         if(fen3>59)
     
389.            fen3=0;
     
390.     }
     
391.           if(cnt==9)
     
392.     {  
     
393.                 shi3++;
     
394.         if(shi3>23)
     
395.            shi3=0;
     
396.     }
     
397.           if(cnt==10)         
     
398.     {  
     
399.                 miao++;         
     
400.                if(miao>59)      
     
401.           miao=0;
     
402.                 cnt1++;
     
403.     }
     
404.           if(cnt==11)         
     
405.     {  
     
406.                 fen++;
     
407.         if(fen>59)
     
408.            fen=0;
     
409.                 cnt1++;
     
410.     }
     
411.           if(cnt==12)
     
412.     {  
     
413.                 shi++;
     
414.         if(shi>23)
     
415.            shi=0;
     
416.                 cnt1++;
     
417.     }
     
418. }
     
419. //***************************减1子函数**************************//
     
420. void jian()   
     
421. {  
     
422.         if(cnt==1)                        //判断key1按下的次数是否为1，是则秒减1
     
423.     {  
     
424.                 miao1--;
     
425.         if(miao1==255)        //判断秒是否减到255，是，则秒置59
     
426.            miao1=59;
     
427.     }
     
428.            if(cnt==2)                        //以下含意同上
     
429.     {  
     
430.                 fen1--;
     
431.         if(fen1==255)
     
432.            fen1=59;
     
433.     }
     
434.            if(cnt==3)
     
435.     {  
     
436.                 shi1--;
     
437.                if(shi1==255)
     
438.            shi1=23;
     
439.     }
     
440.            if(cnt==4)
     
441.     {  
     
442.                 miao2--;
     
443.                if(miao2==255)
     
444.            miao2=59;
     
445.     }
     
446.            if(cnt==5)
     
447.     {  
     
448.                 fen2--;
     
449.         if(fen2==255)
     
450.            fen2=59;
     
451.     }
     
452.            if(cnt==6)
     
453.     {  
     
454.                 shi2--;
     
455.         if(shi2==255)
     
456.            shi2=23;
     
457.     }
     
458.         if(cnt==7)
     
459.     {  
     
460.                 miao3--;
     
461.         if(miao3==255)
     
462.             miao3=59;
     
463.     }
     
464.     if(cnt==8)
     
465.     {  
     
466.                 fen3--;
     
467.         if(fen3==255)
     
468.             fen3=59;
     
469.     }
     
470.     if(cnt==9)
     
471.     {  
     
472.                 shi3--;
     
473.         if(shi3==255)
     
474.             shi3=23;
     
475.     }
     
476.     if(cnt==10)         
     
477.     {  
     
478.                 miao--;
     
479.         if(miao==255)  
     
480.             miao=59;
     
481.                 cnt1++;
     
482.     }
     
483.     if(cnt==11)
     
484.     {  
     
485.                 fen--;
     
486.         if(fen==255)
     
487.             fen=59;
     
488.                 cnt1++;
     
489.     }
     
490.     if(cnt==12)
     
491.     {  
     
492.                 shi--;
     
493.         if(shi==255)
     
494.             shi=23;
     
495.                 cnt1++;
     
496.     }
     
497. }
     
498. //***************************闹铃子函数***************************//
     
499. void clock()           
     
500. {  
     
501.         //判断秒的数值是否相等
     
502.         if(miao==miao1&&alm1==0||miao==miao2&&alm2==0||miao==miao3&&alm3==0)
     
503.         //是，在判断分是否相等                                   
     
504.             if(fen==fen1&&alm1==0||fen==fen2&&alm2==0||fen==fen3&&alm3==0)
     
505.         //是，再判断时是否相等             
     
506.                     if(shi==shi1&&alm1==0||shi==shi2&&alm2==0||shi==shi3&&alm3==0)
     
507.                     {
     
508.                                 flag2=0;                       //是，则标志位，flag2清零
     
509.                         while(!(flag2==1200)&&(cnt==0)) //判断flag2是否到1200且不                          
     
510.                         {
     
511.                                         //             为调时状态
     
512.                                         if(key4==0)                                 //没有，则继续驱动蜂鸣器响
     
513.                                         {
     
514.                                                 while(!key4)
     
515.                                                 {
     
516.                                                         flag2=1200;
     
517.                                                           cnt==1;
     
518.                                                         miao1 =miao1-1;fen1=fen1-1; shi1=shi1+3;
     
519.                                                 }
     
520.                                         }
     
521.                                         if(flag1>1)               //等时方波驱动蜂鸣器
     
522.                                 {
     
523.                                                 beep=~beep;
     
524.                                                 flag1=0;
     
525.                                         }
     
526.                             shijian();         //调用时间子函数
     
527.                             display();         //调用显示子函数  
     
528.                         }
     
529.                         beep=0;                  //关闭蜂鸣器
     
530.                         }
     
531. }
     
532. //**************************主函数********************************//
     
533. void main()
     
534. {  
     
535.         init();                         //调用初始化子函数
     
536.            while(1)
     
537.     {  
     
538.                 clock();                   //闹钟子函数                   
     
539.         if(cnt==1||cnt==2||cnt==3) //显示子函数
     
540.                    display1();
     
541.                 if(cnt==4||cnt==5||cnt==6)
     
542.                    display2();
     
543.                 if(cnt==7||cnt==8||cnt==9)
     
544.                    display3();
     
545.                 if(cnt==0||cnt==10||cnt==11||cnt==12||cnt==13)
     
546.                    display();
     
547.             shijian();                 //调用时间子函数
     
548.                 key_scan();                //调用键盘扫描子函数
     
549. 
     
550.                 if(miao==0&&fen==0)
     
551.                 {
     
552.                                 if(flag1>1)               //等时方波驱动蜂鸣器
     
553.                                 {
     
554.                                                 beep=~beep;
     
555.                                                 flag1=0;
     
556.                                         }
     
557.                 }
     
558.     }
     
559. }
     
560. //**************************定时中断******************************//
     
561. void t0() interrupt 1         
     
562. {   
     
563.         TH0=0x3c;        //初值50ms (65536-50000)/256
     
564.     TL0=0x0b0;                 // (65536-50000)%256
     
565.     flag++;          //标志位
     
566.     flag1++;
     
567.         flag2++;                 }
     

复制代码

所有资料51hei提供下载:
可调数字钟闹钟整点报时功能.zip (135.18 KB, 下载次数: 70)

2020-7-9 10:02 上传

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