标题: STC89C52单片机+DS1302+数码管显示及按键调时的时钟程序Proteus仿真图 [打印本页]

---

作者: noble64    时间: 2021-11-13 09:58
标题: STC89C52单片机+DS1302+数码管显示及按键调时的时钟程序Proteus仿真图
STC89C52单片机+DS1302+数码管显示时钟及按键时+整点报时功能
资料含有程序源代码+及仿真原理图
仿真软件运行和实际焊接电路运行都通过验证。
//注意事项：//:仿真时请将程序char H=0,L=1,开发板下载试验请将变量char H=1  ,L=0;
//:请屏蔽此 DS1302初始化 //init_1302(); 函数。
void main()
{
        t0_init();
        t1_init();
        //init_1302();                //仿真时如你需要显示当前实时系统时间，请屏蔽此函数。          
        while(1)
        {
           read_sf();
           ExecuteKeyNum();
        }
        
仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）

1》按下设置启动键：分钟闪烁进入分钟调时，再次按下小时闪烁进入小时调时
2》按下参数加或参数减按钮：进行小时后分钟的时间设置
注意：仿真时请将程序里WELA的变量H=0  L=1,开发板试验请将变量H=1  L=0;

单片机源程序如下:

1. /*********************************************************************************
   
2. 描述： 8位共阴数码管时钟，显示88-88-88样式，正常走时的时候，两个“-”0.5秒闪烁一次；
   
3.        调时：按KEY1按键第1次分钟位闪烁，再按KEY2一次分钟加1，按KEY3一次分钟减1，长按连加连减；
   
4.                          按KEY1按键第2次小时位闪烁，再按KEY2一次小时加1，按KEY3一次小时减1，长按连加连减；
   
5.                          按KEY1按键第3次，秒从零开始累加，时钟回到正常走时；
   
6.                          对时的时候先调好时、分，分钟要比参考时间的分钟加1分，
   
7.                          再看参考时间的秒数到了59再按KEY1按键的第3次，这样对时可以很准的
   
8. 仿真 实物都通过.  11.0592MHz晶振，STC89C52RC，两个74HC573锁存器做位选、段选
   
9. **********************************************************************************/
   
10. #include<reg52.h>
    
11. #include<intrins.h>
    
12. 
    
13. #define uchar unsigned char
    
14. #define uint unsigned int
    
15. 
    
16. sbit sclk = P2^4;                                                                //1302时钟端口
    
17. sbit dio = P2^5;                                                                //1302数据端口
    
18. sbit ce = P2^6;
    
19.                                                                         //1302使能
    
20. sbit wela1 = P2^0;                                                                //位选
    
21. sbit wela2 = P2^1;                                                                //位选
    
22. sbit wela3 = P2^2;        
    
23. sbit wela4 = P2^3;        
    
24. 
    
25. sbit buzzer=P3^7;
    
26. 
    
27. sbit KEY1=P3^0;                                                                        //按键 设置/确认
    
28. sbit KEY2=P3^1;                                                                        //按键 加
    
29. sbit KEY3=P3^2;                                                                        //按键 减
    
30. 
    
31. uchar snum,fnum;
    
32. 
    
33. char shi,fen,miao,shi_alarm=6;
    
34. 
    
35. uchar ss,mm;
    
36. char H=0,L=1;                                                //用软件仿真时关闭数码管H全部改为0，单片机下载H改为1.
    
37. char FunctionKeyNum=0;                                //功能键键值
    
38. char FuncTempNum=0;                                        //功能键临时键值
    
39. typedef enum KeyState{StateInit,StateAffirm,StateSingle,StateRepeat};        //键值状态值
    
40. 
    
41. 
    
42. /***********写时DS1302地址************/
    
43. #define write_year  0x8c         //写年的地址
    
44. #define write_moon  0x88         //写月的地址
    
45. #define write_week  0x8a         //写周的地址
    
46. #define write_day   0x86         //写日的地址
    
47. #define write_shi  0x84                 //写时的地址
    
48. #define write_fen  0x82                 //写分的地址
    
49. #define write_miao 0x80                 //写秒的地址
    
50. #define write_ram  0xc0                 ////RAM的基地址
    
51. /***********读时DS1302地址************/
    
52. #define read_year  0x8d                 //读年的地址
    
53. #define read_moon  0x89                 //读月的地址
    
54. #define read_week 0x8b                 //读周的地址
    
55. #define read_day  0x87                 //读日的地址
    
56. #define read_shi  0x85                 //读时的地址
    
57. #define read_fen  0x83                 //读分的地址
    
58. #define read_miao 0x81                 //读秒的地址
    
59. #define read_ram  0xc1                 //RAM的基地址
    
60.                   // 0     1    2    3    4     5    6    7    8   9
    
61. //uchar d[]={0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F}; //共阴不带小数点
    
62. //uchar d[]={0xbf,0x86,0xdb,0xcf,0xe6,0xed,0xfd,0x87,0xff,0xef};  //        共阴带小数点
    
63. uchar d[]={0Xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90};          //共阳极
    
64. uchar dd[]={0x40,0x79,0x24,0x30,0x19,0x12,0x02,0x78,0x00,0x10};          //共阳极带小数点
    
65. 
    
66. void Time_alarm();                 //整点报时子程序
    
67. 
    
68. void delayms(uint z)
    
69. {
    
70.         uint x,y;
    
71.         for(x=z;x>0;x--)
    
72.                 for(y=120;y>0;y--);
    
73. }
    
74. /*
    
75. void buzzer1()
    
76. {
    
77. uint i;
    
78. for(i=0;i<10;i++)
    
79.         {
    
80.     buzzer=0;
    
81.         delayms(500);
    
82.         buzzer=1;
    
83.         delayms(500);
    
84.         }
    
85. }
    
86. */
    
87. void buzzer2() //发声子程序
    
88. {
    
89.          
    
90.           uint t,tt;
    
91.           for(t=0;t<50;t++) //45为蜂鸣器发声频率
    
92.           {
    
93.           buzzer=!buzzer;
    
94.           for(tt=0;tt<50;tt++); //45为蜂鸣器发声频率
    
95.           }
    
96. }
    
97. 
    
98. 
    
99. 
    
100. void t0_init()  //定时50ms一个中断
     
101. {
     
102.    
     
103.   TMOD |= 0X01;
     
104.   TH0 = (65536-46080)/256;
     
105.   TL0 = (65536-46080)%256;
     
106.   EA = 1;
     
107.   ET0 = 1;
     
108.   TR0 = 1;
     
109. 
     
110. }
     
111. 
     
112. void t1_init()
     
113. {
     
114.         TMOD |= 0x10;
     
115.         TH1 = 0x500;
     
116.         TL1 = 0x00;
     
117.         TR1 = 1;        
     
118. }
     
119. 
     
120. void temer0() interrupt 1
     
121. {
     
122.   TH0=(65536-46080)/256;
     
123.   TL0=(65536-46080)%256;
     
124.   ss++;
     
125.   mm++;
     
126.   if(ss==22)
     
127.   {
     
128.   ss=0;
     
129.   }
     
130.   if(mm==10)
     
131.   {
     
132.    mm=0;
     
133.    Time_alarm();   
     
134. }
     
135. }         
     
136. 
     
137. 
     
138. 
     
139. 
     
140. 
     
141. void Display(uchar shi,uchar fen)                          //显示函数
     
142. {
     
143.         if(FunctionKeyNum==0)
     
144.         {
     
145.                 snum=30;
     
146.                 fnum=30;
     
147.         }
     
148.         
     
149.         if(FunctionKeyNum==1)
     
150.         {
     
151.                 fnum++;
     
152.                 snum=30;
     
153.         }
     
154.         
     
155.         if(FunctionKeyNum==2)
     
156.         {
     
157.                 snum++;
     
158.                 fnum=30;
     
159.         }
     
160.         
     
161.             wela1=H;   //关闭所有数码管
     
162.                 wela2=H;   //用软件仿真时关闭数码管H全部改为0，单片机下载H改为1.
     
163.                 wela3=H;   //用软件仿真时关闭数码管H全部改为0，单片机下载H改为1.
     
164.                 wela4=H;
     
165. 
     
166.         
     
167.         if(snum>=30)
     
168.         {        
     
169.                 if((shi/10)<1)         //如果小时十位小于1，
     
170.                 {        
     
171.                 wela1=L;                 // 小时十位就不显示                  
     
172.                 P0=d[0];                           // 小时十位就显示"0"
     
173.                 delayms(2);
     
174.                 P0=0xff;
     
175.                 wela1=H;
     
176.         
     
177.                 }
     
178.         
     
179.                 else
     
180.                 {
     
181.                 wela1=L;
     
182.                 P0=d[shi/10];
     
183.                 delayms(2);
     
184.                 P0=0xff;
     
185.                 wela1=H;
     
186. 
     
187.                 }
     
188.   
     
189.         if(miao%2==0)            //if(miao%2==0) 1秒闪烁1次
     
190.   //        if(ss>=20)                 //        这里写为ss>=10，闪烁频率可调
     
191.                 {                                 
     
192.             wela2=L;
     
193.                 P0=dd[shi%10];
     
194.                 delayms(2);
     
195.                 P0=0xff;
     
196.                 wela2=H;
     
197.               }
     
198.                
     
199.                 else
     
200.                 {
     
201.                 wela2=L;
     
202.                 P0=d[shi%10];                                                        
     
203.                 delayms(2);
     
204.                 P0=0xff;
     
205.                 wela2=H;
     
206.                 }
     
207. 
     
208.                 if(snum==60)
     
209.                         snum=0;
     
210.         }  
     
211.                         
     
212.    //        if(miao%2==0)         //if(miao%2==0) 1秒闪烁1次
     
213.                   if(ss>=20)                 //        这里写为ss>=10，闪烁频率可调
     
214.                 {                                 
     
215.             wela2=L;
     
216.                 P0=d[shi%10];
     
217.                 delayms(2);
     
218.                 P0=0xff;
     
219.                 wela2=H;
     
220.               }
     
221.                                 
     
222.         if(fnum>=30)
     
223.         {  
     
224.                 wela3=L;
     
225.                 P0=d[fen/10];
     
226.                 delayms(2);
     
227.                 P0=0xff;
     
228.                 wela3=H;
     
229.                         
     
230.                 wela4=L;
     
231.                 P0=d[fen%10];
     
232.                 delayms(2);
     
233.                 P0=0xff;
     
234.                 wela4=H;
     
235.                
     
236.                
     
237.                 if(fnum==60)
     
238.                         fnum=0;
     
239.                                 }         
     
240. }
     
241. 
     
242. 
     
243. void write_1302(uchar add,dat)                 //写1302函数  
     
244. {
     
245.         uchar i,temp;
     
246.         temp=add;
     
247.         ce=0;
     
248.         _nop_();
     
249.         sclk=0;
     
250.         _nop_();
     
251.         ce=1;
     
252.         _nop_();
     
253.         for(i=0;i<8;i++)
     
254.         {
     
255.                 sclk=0;
     
256.                 _nop_();
     
257.                 if((temp&0x01)==0x01)
     
258.                         dio=1;
     
259.                         else
     
260.                         dio=0;
     
261.                 temp>>=1;
     
262.                 sclk=1;
     
263.                 _nop_();
     
264.         }
     
265.         temp=dat;
     
266.         for(i=0;i<8;i++)
     
267.         {
     
268.                 sclk=0;
     
269.                 _nop_();
     
270.                 if((temp&0x01)==0x01)
     
271.                         dio=1;
     
272.                         else
     
273.                         dio=0;
     
274.                 temp>>=1;
     
275.                 sclk=1;
     
276.                 _nop_();
     
277.         }
     
278.         ce=0;
     
279.         sclk=0;
     
280. }
     
281. uchar read_1302(uchar add)                                   //读1302函数               
     
282. {
     
283.         uchar dat,dat1,i,temp;
     
284.         temp=add;
     
285.         ce=0;
     
286.         _nop_();
     
287.         sclk=0;
     
288.         _nop_();
     
289.         ce=1;
     
290.         for(i=0;i<8;i++)
     
291.         {
     
292.                 sclk=0;
     
293.                 _nop_();
     
294.                 if((temp&0x01)==0x01)
     
295.                         dio=1;
     
296.                         else
     
297.                         dio=0;
     
298.                 temp>>=1;
     
299.                 sclk=1;
     
300.                 _nop_();
     
301.         }
     
302.         for(i=0;i<8;i++)
     
303.         {
     
304.                 sclk=0;
     
305.                 _nop_();
     
306.                 if(dio)
     
307.                     dat|=0x80;
     
308.                 if(i<7)
     
309.                         dat>>=1;
     
310.                 sclk=1;
     
311.         }
     
312.         dat1=dat/16;
     
313.         dat=dat%16;
     
314.         dat=dat1*10+dat;  
     
315.         ce=0;
     
316.         sclk=0;
     
317.         return dat;
     
318. }                        
     
319. 
     
320. 
     
321. 
     
322. void init_1302()                                                        //初始化函数 设置时间
     
323. {        
     
324.         write_1302(0x8e,0x00);                                        //保护取消，可以进行写操作
     
325.         write_1302(write_year,0x20);
     
326.         write_1302(write_moon,0x12);                        //写入时修改月
     
327.         write_1302(write_week,0x30);                        //写入时修改星期
     
328.         write_1302(write_day,0x04);                           //写时修改日期
     
329.         write_1302(write_miao,0x00);        
     
330.         write_1302(write_fen,0x30);
     
331.         write_1302(write_shi,0x10);
     
332.         write_1302(0x8e,0x80);                                        //保护启动，不能进行写操作
     
333. }         
     
334. 
     
335. void read_sf()
     
336. {
     
337.         shi=read_1302(read_shi);
     
338.         fen=read_1302(read_fen);
     
339.         miao=read_1302(read_miao);
     
340.         Display(shi,fen);
     
341. 
     
342. }
     
343. 
     
344. void KeyScan(void)
     
345. {
     
346.         static uchar KeyStateTemp1 = 0;                  //按键状态临时存储值1
     
347.         static uchar KeyStateTemp2 = 0;                  //按键状态临时存储值2
     
348.         static uchar KeyStateTemp3 = 0;                  //按键状态临时存储值3
     
349.         static uchar KeyTime = 0;                          //按键延时时间
     
350.         bit KeyPressTemp1;                                          //按键是否按下存储值1
     
351.         bit KeyPressTemp2;                                          //按键是否按下存储值2
     
352.         bit KeyPressTemp3;                                          //按键是否按下存储值3
     
353. 
     
354.         KeyPressTemp1 = KEY1;                                  //读取IO口的键值
     
355.         switch(KeyStateTemp1)
     
356.         {
     
357.                 case StateInit:
     
358.                         if(!KeyPressTemp1)                                        //KEY1按下
     
359.                                 KeyStateTemp1 = StateAffirm;        //按键状态切换到确认态
     
360.                 break;
     
361.                 case StateAffirm:                                                //确认状态
     
362.                         if(!KeyPressTemp1)                                        //按键还在按下
     
363.                         {
     
364.                                 KeyTime = 0;
     
365.                                 KeyStateTemp1 = StateSingle;        //按键状态切换到单击状态
     
366.                         }
     
367.                         else KeyStateTemp1 = StateInit;                //否则按键抬起，回到初始态
     
368.                 break;
     
369.                
     
370.                 case StateSingle:                                                //单击
     
371.                          if(KeyPressTemp1)
     
372.                          {
     
373.                                 KeyStateTemp1 = StateInit;                 //按键释放
     
374.                                 FuncTempNum++;                                         //键值加1
     
375.                                 if(FuncTempNum>3)  
     
376.                                 FuncTempNum = 0;
     
377.                          }
     
378. 
     
379.                          else if(++KeyTime>100)
     
380.                          {
     
381.                                          KeyPressTemp1 = StateRepeat;
     
382.                                         KeyTime = 0;
     
383.                          }
     
384.                 break;
     
385.         
     
386.                 case StateRepeat:                                                 //连发
     
387.                         if(KeyPressTemp1)
     
388.                                 KeyStateTemp1 = StateInit;
     
389.                         else
     
390.                         {
     
391.                                 if(++KeyTime > 10)
     
392.                                 {
     
393.                                         KeyTime = 0;
     
394.                                         FuncTempNum++;
     
395.                                         if(FuncTempNum>3)  
     
396.                                         FuncTempNum = 0;
     
397.                                 }
     
398.                                 break;
     
399.                         }
     
400.                 break;
     
401.         
     
402.                 default :KeyStateTemp1 = KeyStateTemp1 = StateInit; break;
     
403.                         
     
404.         }
     
405. 
     
406. 
     
407. if(FuncTempNum)                                                                //只有功能键被按下后，增加和减小键才有效
     
408.         {
     
409.                 KeyPressTemp2 = KEY2;                                        //读取I/O口的键值
     
410.                 switch(KeyStateTemp2)
     
411.                 {        
     
412.                         case StateInit:                                                //按键初始状态
     
413.                                 if(!KeyPressTemp2)                                //当按键按下，状态切换到确认态
     
414.                                         KeyStateTemp2 = StateAffirm;
     
415.                                 break;
     
416.                         case StateAffirm:                                        //按键确认态
     
417.                                 if(!KeyPressTemp2)
     
418.                                 {
     
419.                                         KeyTime = 0;
     
420.                                         KeyStateTemp2 = StateSingle;//切换到单次触发态        
     
421.                                 }
     
422.                                 else KeyStateTemp2 = StateInit; //按键已抬起，切换到初始态
     
423.                                 break;
     
424.                         case StateSingle:                                        //按键单发态
     
425.                                 if(KeyPressTemp2)                                //按下时间小于1s
     
426.                                 {
     
427.                                         KeyStateTemp2 = StateInit;  //按键释放，则回到初始态
     
428.                                         if(FunctionKeyNum == 1)                //若功能键第一次按下
     
429.                                         {
     
430.                                         fen++;
     
431.                                         fen=fen/10*16+fen%10;                //转为16进制
     
432.                                         if(fen==0x60)
     
433.                                             fen=0x00;
     
434.                                            write_1302(write_fen,fen);        //写入1302
     
435. ……………………
     
436. 
     
437. …………限于本文篇幅 余下代码请从51黑下载附件…………
     

复制代码

所有资料51hei附件下载:
STC89C52单片机+DS1302+数码管显示及按键调时的时钟程序.7z (72.88 KB, 下载次数: 58)

2021-11-13 17:47 上传

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

---

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

Powered by Discuz! X3.1