标题: 基于DS1302的电子时钟制作 [打印本页]

---

作者: 小松tws    时间: 2016-12-4 18:12
标题: 基于DS1302的电子时钟制作

资料下载：
大时钟【原理图】.PDF (119.6 KB, 下载次数: 90)

2016-12-4 18:11 上传

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

大时钟【源程序】.zip (75.04 KB, 下载次数: 102)

2016-12-4 18:11 上传

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

1. 
   
2. /*        项目名称：多功能数码管时钟设计
   
3.         调试要求：
   
4.         1.MCU:STC89C51
   
5.         2.晶振:12MHz
   
6.         功能：实时时钟+温度计+闹钟+整点报时+正计时器+倒计时器+计数器*/
   
7. #include <reg52.h>
   
8. #include <intrins.h>
   
9. #define uchar unsigned char
   
10. #define uint  unsigned int
    
11. #define smg_data    P0//定义数码管数据
    
12. 
    
13. sbit smg1=P2^4;//位码1声明 时
    
14. sbit smg2=P2^5;//位码2声明
    
15. sbit smg3=P2^6;//位码3声明 分
    
16. sbit smg4=P2^7;//位码4声明
    
17. sbit smg5=P1^6;//位码5声明 秒
    
18. sbit smg6=P1^7;//位码6声明
    
19. sbit gm=P1^3; //黑暗时等于1
    
20. sbit k1=P1^2; //按键k1的声明
    
21. sbit k2=P1^1; //按键k2的声明
    
22. sbit k3=P1^0; //按键k3的声明
    
23. 
    
24. sbit bell=P3^7;        //蜂鸣器声明
    
25. sbit clk_ds1302=P2^0;//定义控制DS1302的时钟线
    
26. sbit io_ds1302=P2^1;//定义控制DS1302的串行数据
    
27. sbit rest_ds1302=P2^2;
    
28. 
    
29. const uchar tab1[16]={//共阳数码管段码表
    
30. 0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,0x86,0x87,0xFF,0xc6,0xbf,0xff};
    
31. //0        ，1        ，2        ，3        ，4        ，5        ，6        ，7        ，8        ，9        ，                       
    
32. const uchar tab2[16]={//数码管3特殊处理用的段码表
    
33. 0xc0,0xf9,0x64,0x70,0x59,0x52,0x42,0xf8,0x40,0x50,0x86,0x87,0xFF,0xc6,0x7f,0xff};
    
34.                         //    C      -
    
35. bit gm_en=0,zdbs_en=0;//光敏使能信号/整点报时使能信号
    
36. uchar gm_time=40; //光敏控制亮度值
    
37. char shi,fen,miao,b_shi=7,b_fen=0; //必须是有符号型：数据暂存单元shi/fen/miao，闹铃时间b_shi,b_fen,
    
38. uchar hour,minute,second,n=0,a=0,b=0;//从1302读出的实时时间数据hour,minute,second，        b控制字符闪烁
    
39. uchar tab23[3];//={0x40,0x59,0x23,0x28,0x11,0x06,0x09};//首次上电时默认的时间
    
40. uchar bell_en=0,x=1;//闹钟使能信号，任意键关闭铃声标志位
    
41. char zjs_en=0,zjs_shi=0,zjs_fen=0,djs_en=0,djs_shi=60,djs_fen=0,jsq_shi=0,jsq_fen=0;
    
42. void key();
    
43. void  delay_3us();//3US的延时程序
    
44. void  delay_50us(uint t);//延时50*T微妙函数的声明
    
45. void  display(uchar shi,fen,miao);//显示子程序
    
46. void  set_ds1302();//设置时间
    
47. void  get_ds1302();//读取当前时间
    
48. void  w_1byte_ds1302(uchar t);//向DS1302写一个字节的数据
    
49. uchar r_1byte_ds1302();//从DS1302读一个字节的数据
    
50. void init(); //初始化函数
    
51. 
    
52. void baojing()//报警函数
    
53. {
    
54.          uint j=10,i=10;
    
55.          bell=0;
    
56.          while(i--)display(shi,fen,miao);
    
57.          bell=1;
    
58.          while(j--)display(shi,fen,miao);
    
59. }
    
60. 
    
61. /******温度传感器18b20  IO引脚定义********/
    
62. sbit DS=P2^3;           //定义DS18B20接口
    
63. uchar ly_dis[4];                //定义显示温度的缓冲区
    
64. float tt;                        //定义浮点型变量tt存放温度值
    
65. uchar temp_en=0;
    
66. uchar wendu=0;
    
67. uint t=0;
    
68. 
    
69. /**********18b20延时子函数 *************/
    
70. void delayb(uint count)
    
71. {
    
72.   uint i;
    
73.   while(count)
    
74.   {
    
75.     i=200;
    
76.     while(i>0)
    
77.     i--;
    
78.     count--;
    
79.   }
    
80. }
    
81. 
    
82. /*********DS18B20初始化************/
    
83. void dsreset(void)
    
84. {
    
85.   uint i;
    
86.   DS=0;
    
87.   i=103;
    
88.   while(i>0)i--;
    
89.   DS=1;
    
90.   i=4;
    
91.   while(i>0)i--;
    
92. }
    
93. 
    
94. /**********18b20读一位***********/
    
95. bit tmpreadbit(void)
    
96. {
    
97.    uint i;
    
98.    bit dat;
    
99.    DS=0;
    
100.    i++;          //小延时一下
     
101.    DS=1;
     
102.    i++;i++;
     
103.    dat=DS;
     
104.    i=8;
     
105.    while(i>0)i--;
     
106.    return (dat);
     
107. }
     
108. 
     
109. /**********18b20读一个**********/
     
110. uchar tmpread(void)
     
111. {
     
112.   uchar i,j,dat;
     
113.   dat=0;
     
114.   for(i=1;i<=8;i++)
     
115.   {
     
116.     j=tmpreadbit();
     
117.     dat=(j<<7)|(dat>>1);   //读出的数据最低位在最前面，这样刚好//一个字节在DAT里
     
118.   }
     
119.   return(dat);             //将一个字节数据返回
     
120. }
     
121. 
     
122. /**********18b20写一个字节**********/
     
123. void tmpwritebyte(uchar dat)
     
124. {
     
125.   uint i;
     
126.   uchar j;
     
127.   bit testb;
     
128.   for(j=1;j<=8;j++)
     
129.   {
     
130.     testb=dat&0x01;
     
131.     dat=dat>>1;
     
132.     if(testb)     // 写1部分
     
133.     {
     
134.       DS=0;
     
135.       i++;i++;
     
136.       DS=1;
     
137.       i=8;
     
138.           while(i>0)i--;
     
139.     }
     
140.     else
     
141.     {
     
142.       DS=0;       //写0部分
     
143.       i=8;
     
144.           while(i>0)i--;
     
145.       DS=1;
     
146.       i++;i++;
     
147.     }
     
148.   }
     
149. }
     
150. 
     
151. /***********18b20发送温度转换命令*************/
     
152. void tmpchange(void)
     
153. {
     
154.   dsreset();             //初始化DS18B20
     
155.   delayb(1);             //延时
     
156.   tmpwritebyte(0xcc);  // 跳过序列号命令
     
157.   tmpwritebyte(0x44);  //发送温度转换命令
     
158. }
     
159. 
     
160. /***********获得温度************/
     
161. int tmp()
     
162. {
     
163.   int temp;
     
164.   uchar a,b;
     
165.   dsreset();
     
166.   delayb(1);
     
167. 
     
168.   tmpwritebyte(0xcc);  
     
169.   tmpwritebyte(0xbe);   //发送读取数据命令
     
170. 
     
171.   a=tmpread();          //连续读两个字节数据
     
172.   b=tmpread();
     
173.   temp=b;
     
174.   temp<<=8;
     
175.   temp=temp|a;                 //两字节合成一个整型变量。
     
176.   return temp;     //返回温度值
     
177. }
     
178. void dis_temp()
     
179. {        
     
180.         tmpchange();              //温度转换
     
181.         tt=tmp()*0.0625;          //得到真实十进制温度值，因为DS18B20
     
182.         wendu=tt;                                                                //可以精确到0.0625度，所以读回数据的最低位代表的是0.0625度。
     
183.         if(tt<0)        //判断第一位显示整数还是负号
     
184.         tt=0;        
     
185.         if((wendu%100/10)<1) //如果温度小于10，不显示十位
     
186.         smg1=1;
     
187.         else
     
188.         {
     
189.                 smg_data=tab1[wendu%100/10];//送显示断码  十位
     
190.                 smg1=0;
     
191.                 delay_50us(gm_time);
     
192.                 smg1=1;
     
193.         }
     
194.         smg_data=tab1[wendu%10];//送显示断码  个位
     
195.         smg2=0;
     
196.         delay_50us(gm_time);
     
197.         smg2=1;
     
198.         smg_data=tab1[10];//送显示断码  ℃
     
199.         smg3=0;
     
200.         delay_50us(gm_time);
     
201.         smg3=1;        
     
202.         smg4=1;
     
203. }
     
204. //***********************************************************************
     
205. //主程序
     
206. void main()
     
207. {        
     
208.         tmpchange();              //温度转换,为了消除首次显示的85，每次提前转换一次即可解决
     
209.     init();
     
210.         gm=1;
     
211.         while(1)
     
212.     {        
     
213.                 if(n==0&&temp_en==1)
     
214.                 dis_temp();//每15秒切换显示温度一次
     
215.                 else
     
216.                 {
     
217.                         get_ds1302();
     
218.                         display(shi,fen,miao);
     
219.                         key();
     
220.                         if(n==0&&x==1&&bell_en==1&&b_shi==hour&&b_fen==minute)
     
221.                         baojing();
     
222.                         if(hour==b_shi&&minute==b_fen+1)x=1;
     
223.                 }
     
224.                 if(gm_en==1)//光敏控制亮度开关
     
225.                 {
     
226.                         if(gm==1)
     
227.                         gm_time=1;
     
228.                         else gm_time=40;
     
229.                 }
     
230.                 else gm_time=40;
     
231.                 if(zdbs_en==1&&n==0&&minute==0&&miao==0)//整点报时开关
     
232.                 baojing();                                                                 
     
233.     }
     
234. }
     
235. 
     
236. //数码管显示程序
     
237. void  display(uchar s,f,m)
     
238. {
     
239.    if((s/10)<1) smg1=1;
     
240.    else
     
241.    {
     
242.            smg_data=tab1[s/10];//送显示断码  时
     
243.            if((n==1||n==3)&&a<5)
     
244.            smg1=1;//锁存数据
     
245.            else smg1=0;
     
246.            delay_50us(gm_time);
     
247.            smg1=1;        
     
248.    }
     
249. 
     
250.    if((n==1||n==3)&&a<5)        smg_data=0x7f; //字符闪烁，小点不闪
     
251.    else if(b>=10)                        smg_data=tab1[s%10]-0x80;//小点闪烁，字符不闪
     
252.    else                                         smg_data=tab1[s%10];//送显示断码
     
253.    smg2=0;
     
254.    delay_50us(gm_time);
     
255.    smg2=1;
     
256. 
     
257.    if((n==2||n==4)&&a<5)         smg_data=0xbf;//b是控制小数点闪烁的，需要闪烁的时候他等于a
     
258.    else if(b>=10)                        smg_data=tab2[f/10]&0xbf; //显示小点//送显示断码
     
259.    else                                                smg_data=tab2[f/10];//送显示断码         分
     
260.    smg3=0;//锁存数据
     
261.    delay_50us(gm_time);
     
262.    smg3=1;         
     
263. 
     
264.    if(bell_en==1)         smg_data=tab1[f%10]-0x80;//送显示断码
     
265.    else                         smg_data=tab1[f%10];//送显示断码
     
266.    if((n==2||n==4)&&a<5)
     
267.    smg4=1;//锁存数据
     
268.    else smg4=0;
     
269.    delay_50us(gm_time);
     
270.    smg4=1;
     
271. /**************秒，不需要显示********************/   
     
272.    smg_data=tab2[m/10];//送显示断码   秒
     
273.    smg5=0;//锁存数据
     
274.    delay_50us(40);
     
275.    smg5=1;
     
276. 
     
277.    smg_data=tab1[m%10];//送显示断码
     
278.    smg6=0;//锁存数据
     
279.    delay_50us(40);
     
280.    smg6=1;
     
281. /*********************************************/
     
282. 
     
283. }
     
284. void key() //按键控制函数
     
285. {
     
286.         if(k2==0&&k3==0) //k2k3同时按下，切换闹铃开关 并且在按下之后查看闹钟时间松手后恢复时间显示
     
287.         {
     
288.                 delay_50us(1);
     
289.                 if(k2==0&&k3==0)
     
290.                 {        
     
291.                         shi=b_shi;
     
292.                         fen=b_fen;
     
293.                         bell_en=!bell_en;
     
294.                         baojing();
     
295.                         baojing();
     
296.                         while(k2==0&&k3==0)display(shi,fen,miao);//等待松手
     
297.                         shi=hour;
     
298.                         fen=minute;
     
299.                 }
     
300.         }
     
301.         
     
302.         if(k1==0&&k3==0) //k1k3同时按下，切换闹铃开关 并且在按下之后查看闹钟时间松手后恢复时间显示
     
303.         {
     
304.                 delay_50us(1);
     
305.                 if(k1==0&&k3==0)
     
306.                 {        
     
307.                         gm_en=!gm_en;
     
308.                         if(gm_en==1)//使能的话报警两声
     
309.                         {baojing();baojing();}
     
310.                         else baojing();//无效的话报警一声
     
311.                         while(k1==0&&k3==0)display(shi,fen,miao);//等待松手
     
312.                 }
     
313.         }
     
314.         if(k1==0&&k2==0) //k1k2同时按下，切换整点报时开关
     
315.         {
     
316.                 delay_50us(1);
     
317.                 if(k1==0&&k2==0)
     
318.                 {        
     
319.                         zdbs_en=!zdbs_en;
     
320.                         if(zdbs_en==1)//使能的话报警两声
     
321.                         {baojing();baojing();}
     
322.                         else baojing();//无效的话报警一声        
     
323.                         while(k1==0&&k2==0)display(shi,fen,miao);//等待松手
     
324.                 }
     
325.         }
     
326.         if(n==0&&(k2==0||k3==0)&&bell_en==1&&b_shi==hour&&b_fen==minute&&x==1)
     
327.         { //功能键k1被按下
     
328.                 delay_50us(1);//消抖延时
     
329.                 if(n==0&&(k2==0||k3==0)&&bell_en==1&&b_shi==hour&&b_fen==minute&&x==1)
     
330.                 {        
     
331.                         x=0;   //如果处于响零状态，就任意键关闭响铃
     
332.                         while(k1==0)display(shi,fen,miao);//等待松手
     
333.                 }
     
334.         }
     
335.         if(k1==0)
     
336.         { //功能键k1被按下
     
337.                 delay_50us(1);//消抖延时
     
338.                 if(k1==0)
     
339.                 {        
     
340.                         uint i=0;
     
341.                         while(k1==0)
     
342.                         {
     
343.                                 display(shi,fen,miao);//等待松手
     
344.                                 i++;
     
345.                                 if(i>(2*(70-gm_time))){n=0;baojing();baojing();break;}//长按K1退出
     
346.                         }
     
347.                         if(bell_en==1&&b_shi==hour&&b_fen==minute&&x==1)x=0;   //如果处于响零状态，就任意键关闭响铃
     
348.                         else if(i<=(2*(70-gm_time)))
     
349.                         {
     
350.                                 n++;//n记录功能键状态
     
351.                                 if(n>7)  n=0; //n清零
     
352.                                 baojing();        
     
353.                         }
     
354.                         i=0;                        
     
355.                 }
     
356.         }
     
357. 
     
358.         if(n==0)//状态0，正常显示时间
     
359.         {
     
360.                 b=a; //b是控制小数点闪烁的
     
361.                 shi=hour;
     
362.                 fen=minute;
     
363.                 miao=second;
     
364.         }        
     
365.         if(n==1)//状态1：调节时间的“时”
     
366.         {
     
367.                 b=10;
     
368.                 if(k2==0)
     
369.                 { //k2被按下
     
370.                         uint i=6,j=10;
     
371.                         while(i--)display(shi,fen,miao);//长按连续递减                        
     
372.                         if(k2==0)
     
373.                         {
     
374.                                 shi++;//小时加一
     
375.                                 if(shi==24)
     
376.                                 shi=0;//达到24清零        
     
377.                         }
     
378.                          while(j--)display(shi,fen,miao);//长按连续递减
     
379.                 }
     
380.                
     
381.                 if(k3==0)
     
382.                 {  //k3被按下
     
383.                         uint i=6,j=10;
     
384.                         while(i--)display(shi,fen,miao);//长按连续递减        
     
385.                         if(k3==0)
     
386.                         {
     
387.                                 shi--; //小时减一
     
388.                                 if(shi<0)
     
389.                                 shi=23;//小于0，重新复制
     
390.                         }
     
391.                         while(j--)display(shi,fen,miao);//长按连续递减
     
392.                 }               
     
393.         }
     
394.         if(n==2)//状态2：调节时间的“分”
     
395.         {        b=10;
     
396.                  if(k2==0)
     
397.                 { //k2被按下
     
398.                         uint i=6,j=10;
     
399.                         while(i--)display(shi,fen,miao);//长按连续递减
     
400.                         if(k2==0)
     
401.                         {
     
402.                                 fen++;//分加一
     
403.                                 if(fen==60)
     
404.                                 fen=0;//分到达60 分清零        
     
405.                         }        
     
406.                         while(j--)display(shi,fen,miao);//长按连续递减
     
407.                 }
     
408.                
     
409.                 if(k3==0)
     
410.                 {  //k3被按下
     
411.                         uint i=6,j=10;
     
412.                         while(i--)display(shi,fen,miao);//长按连续递减
     
413.                         if(k3==0)
     
414.                         {
     
415.                                 fen--;//分减一
     
416.                                 if(fen<0)
     
417.                                 fen=59;//分小于0，分重新赋值59                                          
     
418.                         }
     
419.                         while(j--)display(shi,fen,miao);//长按连续递减
     
420.                 }
     
421.                 tab23[2]=shi/10*16+shi%10;
     
422.         tab23[1]=fen/10*16+fen%10;
     
423.         hour=shi;
     
424.         minute=fen;
     
425.         second=0;
     
426.         tab23[0]=0;
     
427.         set_ds1302();//设置DS1302的初始时间               
     
428.         }
     
429.         
     
430.         if(n==3)//状态三：调节闹铃“时”
     
431.         {        
     
432.                 shi=b_shi;
     
433.                 fen=b_fen;
     
434.                 b=10;
     
435.                 if(k2==0)
     
436.                 {  //k2被按下
     
437.                         uint i=6,j=10;
     
438.                         while(i--)display(shi,fen,miao);//长按连续递减
     
439.                         if(k2==0)
     
440.                         {
     
441.                                 b_shi++;//闹铃时间加一
     
442.                                 if(b_shi==24)
     
443.                                 b_shi=0;//闹铃时间清零        
     
444.                         }
     
445.                         while(j--)display(shi,fen,miao);//长按连续递减
     
446.                 }
     
447.                
     
448.                 if(k3==0)
     
449.                 {  //k3被按下
     
450.                         uint i=6,j=10;
     
451.                         while(i--)display(shi,fen,miao);//长按连续递减
     
452.                         if(k3==0)
     
453.                         {
     
454.                                 b_shi--;//闹铃时间减一
     
455.                                 if(b_shi<0)
     
456.                                 b_shi=23;//闹铃时间        
     
457.                         }
     
458.                         while(j--)display(shi,fen,miao);//长按连续递减
     
459.                 }               
     
460.         }
     
461. 
     
462.         if(n==4)//状态四 ：调节闹铃的”分“
     
463.         {        b=10;
     
464.         shi=b_shi;
     
465.                 fen=b_fen;
     
466.                 if(k2==0)
     
467.                 {  //k2被按下
     
468.                         uint i=6,j=10;
     
469.                         while(i--)display(shi,fen,miao);//长按连续递减
     
470.                         if(k2==0)
     
471.                         {
     
472.                                 b_fen++;//闹铃时间分加一
     
473.                                 if(b_fen==60)
     
474.                                 b_fen=0;//闹铃分到达60 清零        
     
475.                         }        
     
476.                         while(j--)display(shi,fen,miao);//长按连续递减
     
477.                 }
     
478.                
     
479.                 if(k3==0)
     
480.                 {  //k3被按下
     
481.                         uint i=6,j=10;
     
482.                         while(i--)display(shi,fen,miao);//长按连续递减
     
483.                         if(k3==0)
     
484.                         {
     
485.                                 b_fen--;//闹铃时间分减一
     
486.                                 if(b_fen<0)
     
487.                                 b_fen=59;//闹铃时间分重新赋值
     
488.                         }
     
489.                         while(j--)display(shi,fen,miao);//长按连续递减                        
     
490.                 }               
     
491.         }
     
492.         if(n==5)//状态5 ：正计时
     
493.         {
     
494.                 b=10; //显示小点
     
495.                 shi=zjs_shi;
     
496.                 fen=zjs_fen;
     
497.                 if(k2==0)
     
498.                 {  //k2被按下
     
499.                         delay_50us(1);//消抖延时
     
500.                         if(k2==0)
     
501.                         {        
     
502.                                 zjs_en=!zjs_en;        
     
503.                                 baojing();
     
504.                                 while(k2==0)display(shi,fen,miao);//等待松手
     
505.                         }
     
506.                 }
     
507.                
     
508.                 if(k3==0)
     
509.                 {  //k3被按下
     
510.                         delay_50us(1);//消抖延时
     
511.                         if(k3==0)
     
512.                         {
     
513.                                 zjs_shi=0;
     
514.                                 zjs_fen=0;
     
515.                                 baojing();
     
516.                                 while(k3==0)display(shi,fen,miao);//等待松手        
     
517.                         }
     
518.                 }               
     
519.         }
     
520.         if(n==6)//状态5 ：倒计时
     
521.         {        b=10; //显示小点
     
522.         shi=djs_shi;
     
523.                 fen=djs_fen;
     
524.                 if(k2==0)
     
525.                 {  //k2被按下
     
526.                         delay_50us(1);//消抖延时
     
527.                         if(k2==0)
     
528.                         {        
     
529.                                 djs_en=!djs_en;        
     
530.                                 baojing();
     
531.                                 while(k2==0)display(shi,fen,miao);//等待松手
     
532.                         }
     
533.                 }
     
534.                
     
535.                 if(k3==0&&djs_en==0)
     
536.                 {  //k3被按下
     
537.                         uint i=6,j=10;
     
538.                         while(i--)display(shi,fen,miao);//长按连续递减
     
539.                         if(k3==0)
     
540.                         {
     
541.                                 djs_shi--;
     
542.                                 if(djs_shi<0)
     
543.                                 djs_shi=60;               
     
544.                         }
     
545.                         while(j--)display(shi,fen,miao);//长按连续递减
     
546.                 }
     
547.                 if(k3==0&&djs_en==1)
     
548.                 {  //k3被按下
     
549.                         delay_50us(1);//消抖延时
     
550.                         if(k3==0)
     
551.                         {
     
552.                                 djs_shi=60;
     
553.                                 djs_fen=0;
     
554.                                 baojing();
     
555.                                 while(k3==0)display(shi,fen,miao);//等待松手        
     
556.                         }
     
557.                 }               
     
558.         }
     
559.         if(n==7)//状态5 ：计数器
     
560.         {        
     
561.                 b=1; //不显示小点
     
562.                 shi=jsq_shi;
     
563.                 fen=jsq_fen;
     
564.         
     
565.                 if(k2==0)
     
566.                 {  
     
567.                         uint i=6,j=10;
     
568.                         while(i--)display(shi,fen,miao);//长按连续递减
     
569.                         if(k2==0)
     
570.                         {
     
571.                                 jsq_fen++;
     
572.                                 if(jsq_fen>99)
     
573.                                 {
     
574.                                         jsq_fen=0;
     
575.                                         jsq_shi++;
     
576.                                         if(jsq_shi>99)
     
577.                                         jsq_shi=0;
     
578.                                 }                        
     
579.                         }
     
580.                         while(j--)display(shi,fen,miao);//长按连续递减
     
581.                 }
     
582.                 if(k3==0)
     
583.                 {  //k3被按下
     
584.                         delay_50us(1);//消抖延时
     
585.                         if(k3==0)
     
586.                         {
     
587.                                 jsq_shi=0;
     
588.                                 jsq_fen=0;
     
589.                                 baojing();
     
590.                                 while(k3==0)display(shi,fen,miao);//等待松手        
     
591.                         }
     
592.                 }               
     
593.         }                        
     
594. }
     
595. void init()        //初始化函数
     
596. {
     
597.         IE=0X82;//1000 0010
     
598.         TMOD=0X01;    //0000 0001选择定时器0的工作方式1        选择定时器1的工作方式1
     
599.         TH0=(65536-50000)/256;//初值15536定时50mS
     
600.         TL0=(65536-50000)%256;
     
601.         TR0=1; //开启定时器0
     
602. }
     
603. 
     
604. void timer0() interrupt        1  //定时器0中断服务程序，用来设置冒号闪烁频率
     
605. {
     
606.         TH0=(65536-50000)/256;//进入中断重新赋初值15536
     
607.         TL0=(65536-50000)%256;//计数5万次（50毫秒）
     
608.         a++; //标志位b，用来确定光标闪烁频率
     
609.         t++;
     
610.         if(t==300)t=0;
     
611.         if(t>260)temp_en=1;
     
612.         else temp_en=0;
     
613.         
     
614.         if(a==20)
     
615.         {        
     
616.                 a=0;//a=20 时被清零        
     
617.                 if(zjs_en==1)        //正计时
     
618.                 {
     
619.                         zjs_fen++;
     
620.                         if(zjs_fen==60)
     
621.                         {
     
622.                                 zjs_fen=0;
     
623.                                 zjs_shi++;
     
624.                                 if(zjs_shi==60)
     
625.                                 {
     
626.                                         zjs_shi=0;        
     
627.                                 }
     
628.                         }        
     
629.                 }
     
630.                 /**********倒计时**********/
     
631.                 if(djs_en==1)
     
632.                 {
     
633.                         djs_fen--;
     
634.                         if(djs_fen==-1)
     
635.                         {
     
636.                                 djs_fen=59;
     
637.                                 djs_shi--;
     
638.                                 if(djs_shi==-1)
     
639.                                 {
     
640.                                         djs_shi=0;
     
641.                                         djs_fen=0;
     
642.                                         djs_en=0;//关闭倒计时
     
643.                                         baojing();
     
644.                                 baojing();
     
645.                                 baojing();
     
646.                                 }
     
647.                         }        
     
648.                 }
     
649.                 /*************************/
     
650.         }
     
651. }
     
652. 
     
653. 
     
654. //函数名称：void delay_50US(unsigned int t)
     
655. //功能： 延时50*t(us)
     
656. void delay_50us(uint t)
     
657. {
     
658.   unsigned char j;
     
659.   for(;t>0;t--)
     
660.   {
     
661.     for(j=19;j>0;j--);
     
662.   }
     
663. }
     
664. //*******************************************************************************
     
665. 
     
666. //*******************************************************************************
     
667. //3微秒延时程序
     
668. void delay_3us()
     
669. {
     
670.   ;
     
671.   ;
     
672. }
     
673. 
     
674. 
     
675. //;##############################################################################
     
676. //;子程序名：w_1byte_ds1302
     
677. //;功能：    向DS1302写一个字节的数据
     
678. void w_1byte_ds1302(uchar t)
     
679. {
     
680.   uchar i;
     
681.   for(i=0;i<8;i++)
     
682.   {
     
683.     if(t & 0x01)
     
684.      {io_ds1302=1;}
     
685.     else
     
686.      {io_ds1302=0;}
     
687.     clk_ds1302=1;
     
688.     delay_3us();
     
689.     delay_3us();
     
690.     clk_ds1302=0;
     
691.     delay_3us();
     
692.     delay_3us();
     
693.     t>>=1;
     
694.   }  
     
695. }
     
696. //;########################################################################
     
697. //;子程序名：r_1byte_ds1302()
     
698. //;功能：    从DS1302读一个字节的数据
     
699. uchar r_1byte_ds1302()
     
700. {
     
701.   uchar i,temp11=0;
     
702.   io_ds1302=1;//置IO为1，准备读入数据
     
703.   for(i=0;i<8;i++)
     
704.   {
     
705.     temp11>>=1;
     
706.     if(io_ds1302) temp11 |= 0x80;
     
707.     clk_ds1302=1;
     
708.     delay_3us();
     
709.     delay_3us();
     
710.     clk_ds1302=0;
     
711.     delay_3us();
     
712.   }
     
713.   return(temp11);
     
714. }  
     
715. //;#################################################################################
     
716. //;子程序名：setbds1302
     
717. //;功能：   设置DS1302初始时间,并启动计时
     
718. void set_ds1302()
     
719. {
     
720.   uchar i,j;
     
721.   rest_ds1302=0;
     
722.   delay_3us();
     
723.   clk_ds1302=0;
     
724.   delay_3us();
     
725.   rest_ds1302=1;
     
726.   delay_3us();
     
727.   w_1byte_ds1302(0x8e);//写控制命令字
     
728.   delay_3us();
     
729.   w_1byte_ds1302(0x00);//写保护关闭
     
730.   clk_ds1302=1;
     
731.   delay_3us();
     
732.   rest_ds1302=0;
     
733.   for(i=0,j=0x80;i<7;i++,j+=2)
     
734.   {
     
735.     rest_ds1302=0;
     
736.     delay_3us();
     
737.     clk_ds1302=0;
     
738.     delay_3us();
     
739.     rest_ds1302=1;
     
740.     delay_3us();
     
741.     w_1byte_ds1302(j);
     
742.     delay_3us();
     
743.     w_1byte_ds1302(tab23[i]);
     
744.     delay_3us();
     
745.     delay_3us();
     
746.     clk_ds1302=1;
     
747.     delay_3us();
     
748.     rest_ds1302=0;
     
749.     delay_3us();
     
750.     delay_3us();
     
751.   }
     
752.   rest_ds1302=0;
     
753.   delay_3us();
     
754.   clk_ds1302=0;
     
755.   delay_3us();
     
756.   rest_ds1302=1;
     
757.   delay_3us();
     
758.   w_1byte_ds1302(0x8e);
     
759.   delay_3us();
     
760.   w_1byte_ds1302(0x80);
     
761.   clk_ds1302=1;
     
762.   delay_3us();
     
763.   rest_ds1302=0;
     
764.   delay_3us();
     
765. }  
     
766. //;#################################################################-------
     
767. //;子程序名：get1302
     
768. void get_ds1302()
     
769. {  uchar hour_count,minute_count,second_count;
     
770.    uchar temp11[7],i,j;
     
771.    for(i=0;i<7;i++)
     
772.    {temp11[i]=0;}
     
773.    for(i=0,j=0x81;i<7;i++,j+=2)
     
774.    {  
     
775.     rest_ds1302=0;
     
776.     delay_3us();
     
777.     clk_ds1302=0;
     
778.     delay_3us();
     
779.     rest_ds1302=1;
     
780.     delay_3us();
     
781.     w_1byte_ds1302(j);
     
782.     temp11[i]=r_1byte_ds1302();
     
783.     delay_3us();
     
784.     clk_ds1302=1;
     
785.     delay_3us();
     
786.     rest_ds1302=0;
     
787.     delay_3us();
     
788.   }
     
789.   if(temp11[0]!=0xff)
     
790.   {second_count=temp11[0];}
     
791.   if(temp11[1]!=0xff)// 数据验证
     
792.   {minute_count=temp11[1];}
     
793.   if(temp11[2]!=0xff)//数据验证
     
794.   {hour_count=temp11[2];}
     
795.          hour=hour_count/16*10+hour_count%16;
     
796.         minute=minute_count/16*10+minute_count%16;
     
797.         second=second_count/16*10+second_count%16;
     
798.           /*zancun4=hour_count&0xf0;
     
799.           zancun4>>=4;
     
800.           zancun5=minute_count&0xf0;
     
801.           zancun5>>=4;
     
802.           zancun6=second_count&0xf0;
     
803.           zancun6>>=4;*/
     
804. }

复制代码

---

作者: mslong    时间: 2016-12-5 21:21
支持下需要，51黑有你更精彩！！！

---

作者: liuzhaoxin1020    时间: 2017-1-2 13:57
51黑有你更精彩

---

作者: kiop    时间: 2017-1-16 23:59
下載玩玩感謝你...

---

作者: juese    时间: 2017-1-17 10:42
好东西，可以做一做，有没有原件和封装库

---

作者: asdkder    时间: 2017-1-17 13:16

不错，收下了，谢谢！

---

作者: faridzled    时间: 2017-1-18 22:47
thanks for sharing

---

作者: 随易而安    时间: 2017-1-20 23:47
很厉害。

---

作者: bg8apy    时间: 2017-1-22 10:46
六位更好。。。。

---

作者: taoqiba88    时间: 2017-1-27 16:48
为啥重影

---

作者: nessus    时间: 2017-1-28 19:57
楼主厉害，感谢分享

---

作者: taoqiba88    时间: 2017-1-29 13:53
第三段，h一直在闪是怎么回事

---

作者: taoqiba88    时间: 2017-1-30 06:44
if((n==2||n==4)&&a<5)         smg_data=0xff;//b是控制小数点闪烁的，需要闪烁的时候他等于a    else if(b>=10)                        smg_data=tab1[f/10]; //显示小点//送显示断码    else                                                smg_data=tab1[f/10];//送显示断码         分    smg3=0;//锁存数据    delay_50us(gm_time);    smg3=1;  

---

作者: 51jia    时间: 2017-2-1 22:31
学习一下，看看你的编程思路

---

作者: 艾格CG    时间: 2017-3-4 19:40
开玩笑 stc89C51 能装下11k的程序：？

---

作者: jiafjian    时间: 2017-3-28 20:31
谢谢分享，正在好一个。

---

作者: 绊脚石13    时间: 2017-12-7 11:15
学习了  最近在也正好在仿照这个

---

作者: YBZYBZ    时间: 2017-12-9 16:34
楼主这个程序有问题，能不能重新发个能用的烧写文件

---

作者: 45894894    时间: 2017-12-27 18:58
学习学习！！

---

作者: tbjgdtcn    时间: 2018-1-6 00:49
编译不过？RAMSIZE(256)
*** WARNING L15: MULTIPLE CALL TO SEGMENT
    SEGMENT: ?PR?BAOJING?DSZ
    CALLER1: ?C_C51STARTUP
    CALLER2: ?PR?TIMER0?DSZ
*** WARNING L15: MULTIPLE CALL TO SEGMENT
    SEGMENT: ?PR?_DISPLAY?DSZ
    CALLER1: ?C_C51STARTUP
    CALLER2: ?PR?TIMER0?DSZ
******************************************************************************
* RESTRICTED VERSION WITH 0800H BYTE CODE SIZE LIMIT; USED: 0B63H BYTE (142%) *
******************************************************************************
Program Size: data=100.3 xdata=0 code=3805
LINK/LOCATE RUN COMPLETE.  2 WARNING(S),  0 ERROR(S)
*** WARNING L15: MULTIPLE CALL TO SEGMENT
    SEGMENT: ?PR?BAOJING?DSZ
    CALLER1: ?C_C51STARTUP
    CALLER2: ?PR?TIMER0?DSZ
*** WARNING L15: MULTIPLE CALL TO SEGMENT
    SEGMENT: ?PR?_DISPLAY?DSZ
    CALLER1: ?C_C51STARTUP
    CALLER2: ?PR?TIMER0?DSZ
*** FATAL ERROR L250: CODE SIZE LIMIT IN RESTRICTED VERSION EXCEEDED
    MODULE:  C:\KEIL\C51\LIB\C51S.LIB (-----)
    LIMIT:   0800H BYTES
Target not created

---

作者: 54321    时间: 2018-1-7 15:05
闹铃不会响

---

作者: 54321    时间: 2018-1-7 16:02
每次断电重启闹钟时间就恢复初始值了，

---

作者: tbjgdtcn    时间: 2018-1-13 23:48
分的十位g段一直闪，秋楼主解惑。。谢谢

---

作者: gxlin    时间: 2018-6-21 16:33
我修改一下，在Professional试过能用。
/*        项目名称：多功能数码管时钟设计
        调试要求：
        1.MCU:STC89C51
        2.晶振:12MHz
        功能：实时时钟+温度计+闹钟+整点报时+正计时器+倒计时器+计数器*/

1. #include <reg52.h>
   
2. #include <intrins.h>
   
3. #define uchar unsigned char
   
4. #define uint  unsigned int
   
5. #define smg_data    P0//定义数码管数据
   
6. 
   
7. sbit smg1=P2^4;//位码1声明 时
   
8. sbit smg2=P2^5;//位码2声明
   
9. sbit smg3=P2^6;//位码3声明 分
   
10. sbit smg4=P2^7;//位码4声明
    
11. sbit smg5=P1^6;//位码5声明 秒
    
12. sbit smg6=P1^7;//位码6声明
    
13. sbit gm=P1^3; //黑暗时等于1
    
14. sbit k1=P1^2; //按键k1的声明
    
15. sbit k2=P1^1; //按键k2的声明
    
16. sbit k3=P1^0; //按键k3的声明
    
17. 
    
18. sbit bell=P3^7;        //蜂鸣器声明
    
19. sbit clk_ds1302=P2^0;//定义控制DS1302的时钟线
    
20. sbit io_ds1302=P2^1;//定义控制DS1302的串行数据
    
21. sbit rest_ds1302=P2^2;
    
22. 
    
23. const uchar tab1[16]={//共阳数码管段码表
    
24. 0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,0x86,0x87,0xFF,0xc6,0xbf,0xff};
    
25. //0        ，1        ，2        ，3        ，4        ，5        ，6        ，7        ，8        ，9        ，                       
    
26. const uchar tab2[16]={//数码管3特殊处理用的段码表
    
27. 0xc0,0xf9,0x64,0x70,0x59,0x52,0x42,0xf8,0x40,0x50,0x86,0x87,0xFF,0xc6,0x7f,0xff};
    
28.                         //    C      -
    
29. bit gm_en=0,zdbs_en=0;//光敏使能信号/整点报时使能信号
    
30. uchar gm_time=40; //光敏控制亮度值
    
31. char shi,fen,miao,b_shi=7,b_fen=0; //必须是有符号型：数据暂存单元shi/fen/miao，闹铃时间b_shi,b_fen,
    
32. uchar hour,minute,second,n=0,a=0,b=0;//从1302读出的实时时间数据hour,minute,second，        b控制字符闪烁
    
33. uchar tab23[3];//={0x40,0x59,0x23,0x28,0x11,0x06,0x09};//首次上电时默认的时间
    
34. uchar bell_en=0,x=1;//闹钟使能信号，任意键关闭铃声标志位
    
35. char zjs_en=0,zjs_shi=0,zjs_fen=0,djs_en=0,djs_shi=60,djs_fen=0,jsq_shi=0,jsq_fen=0;
    
36. void key();
    
37. void  delay_3us();//3US的延时程序
    
38. void  delay_50us(uint t);//延时50*T微妙函数的声明
    
39. void  display(uchar shi,fen,miao);//显示子程序
    
40. void  set_ds1302();//设置时间
    
41. void  get_ds1302();//读取当前时间
    
42. void  w_1byte_ds1302(uchar t);//向DS1302写一个字节的数据
    
43. uchar r_1byte_ds1302();//从DS1302读一个字节的数据
    
44. void init(); //初始化函数
    
45. 
    
46. void baojing()//报警函数
    
47. {
    
48.          uint j=10,i=10;
    
49.          bell=0;
    
50.          while(i--)display(shi,fen,miao);
    
51.          bell=1;
    
52.          while(j--)display(shi,fen,miao);
    
53. }
    
54. 
    
55. /******温度传感器18b20  IO引脚定义********/
    
56. sbit DS=P2^3;           //定义DS18B20接口
    
57. uchar ly_dis[4];                //定义显示温度的缓冲区
    
58. float tt;                        //定义浮点型变量tt存放温度值
    
59. uchar temp_en=0;
    
60. uchar wendu=0;
    
61. uint t=0;
    
62. 
    
63. /**********18b20延时子函数 *************/
    
64. void delayb(uint count)
    
65. {
    
66.   uint i;
    
67.   while(count)
    
68.   {
    
69.     i=200;
    
70.     while(i>0)
    
71.     i--;
    
72.     count--;
    
73.   }
    
74. }
    
75. 
    
76. /*********DS18B20初始化************/
    
77. void dsreset(void)
    
78. {
    
79.   uint i;
    
80.   DS=0;
    
81.   i=103;
    
82.   while(i>0)i--;
    
83.   DS=1;
    
84.   i=4;
    
85.   while(i>0)i--;
    
86. }
    
87. 
    
88. /**********18b20读一位***********/
    
89. bit tmpreadbit(void)
    
90. {
    
91.    uint i;
    
92.    bit dat;
    
93.    DS=0;
    
94.    i++;          //小延时一下
    
95.    DS=1;
    
96.    i++;i++;
    
97.    dat=DS;
    
98.    i=8;
    
99.    while(i>0)i--;
    
100.    return (dat);
     
101. }
     
102. 
     
103. /**********18b20读一个**********/
     
104. uchar tmpread(void)
     
105. {
     
106.   uchar i,j,dat;
     
107.   dat=0;
     
108.   for(i=1;i<=8;i++)
     
109.   {
     
110.     j=tmpreadbit();
     
111.     dat=(j<<7)|(dat>>1);   //读出的数据最低位在最前面，这样刚好//一个字节在DAT里
     
112.   }
     
113.   return(dat);             //将一个字节数据返回
     
114. }
     
115. 
     
116. /**********18b20写一个字节**********/
     
117. void tmpwritebyte(uchar dat)
     
118. {
     
119.   uint i;
     
120.   uchar j;
     
121.   bit testb;
     
122.   for(j=1;j<=8;j++)
     
123.   {
     
124.     testb=dat&0x01;
     
125.     dat=dat>>1;
     
126.     if(testb)     // 写1部分
     
127.     {
     
128.       DS=0;
     
129.       i++;i++;
     
130.       DS=1;
     
131.       i=8;
     
132.           while(i>0)i--;
     
133.     }
     
134.     else
     
135.     {
     
136.       DS=0;       //写0部分
     
137.       i=8;
     
138.           while(i>0)i--;
     
139.       DS=1;
     
140.       i++;i++;
     
141.     }
     
142.   }
     
143. }
     
144. 
     
145. /***********18b20发送温度转换命令*************/
     
146. void tmpchange(void)
     
147. {
     
148.   dsreset();             //初始化DS18B20
     
149.   delayb(1);             //延时
     
150.   tmpwritebyte(0xcc);  // 跳过序列号命令
     
151.   tmpwritebyte(0x44);  //发送温度转换命令
     
152. }
     
153. 
     
154. /***********获得温度************/
     
155. int tmp()
     
156. {
     
157.   int temp;
     
158.   uchar a,b;
     
159.   dsreset();
     
160.   delayb(1);
     
161. 
     
162.   tmpwritebyte(0xcc);  
     
163.   tmpwritebyte(0xbe);   //发送读取数据命令
     
164. 
     
165.   a=tmpread();          //连续读两个字节数据
     
166.   b=tmpread();
     
167.   temp=b;
     
168.   temp<<=8;
     
169.   temp=temp|a;                 //两字节合成一个整型变量。
     
170.   return temp;     //返回温度值
     
171. }
     
172. void dis_temp()
     
173. {        
     
174.         tmpchange();              //温度转换
     
175.         tt=tmp()*0.0625;          //得到真实十进制温度值，因为DS18B20
     
176.         wendu=tt;                                                                //可以精确到0.0625度，所以读回数据的最低位代表的是0.0625度。
     
177.         if(tt<0)        //判断第一位显示整数还是负号
     
178.         tt=0;        
     
179.         if((wendu%100/10)<1) //如果温度小于10，不显示十位
     
180.         smg1=1;
     
181.         else
     
182.         {
     
183.                 smg_data=tab1[wendu%100/10];//送显示断码  十位
     
184.                 smg1=0;
     
185.                 delay_50us(gm_time);
     
186.                 smg1=1;
     
187.         }
     
188.         smg_data=tab1[wendu%10];//送显示断码  个位
     
189.         smg2=0;
     
190.         delay_50us(gm_time);
     
191.         smg2=1;
     
192.         smg_data=tab1[13];//送显示断码  ℃
     
193.         smg3=0;
     
194.         delay_50us(gm_time);
     
195.         smg3=1;        
     
196.         smg4=1;
     
197. }
     
198. //***********************************************************************
     
199. //主程序
     
200. void main()
     
201. {        
     
202.         tmpchange();              //温度转换,为了消除首次显示的85，每次提前转换一次即可解决
     
203.     init();
     
204.         gm=1;
     
205.         while(1)
     
206.     {        
     
207.                 if(n==0&&temp_en==1)
     
208.                 dis_temp();//每15秒切换显示温度一次
     
209.                 else
     
210.                 {
     
211.                         get_ds1302();
     
212.                         display(shi,fen,miao);
     
213.                         key();
     
214.                         if(n==0&&x==1&&bell_en==1&&b_shi==hour&&b_fen==minute)
     
215.                         baojing();
     
216.                         if(hour==b_shi&&minute==b_fen+1)x=1;
     
217.                 }
     
218.                 if(gm_en==1)//光敏控制亮度开关
     
219.                 {
     
220.                         if(gm==1)
     
221.                         gm_time=1;
     
222.                         else gm_time=40;
     
223.                 }
     
224.                 else gm_time=40;
     
225.                 if(zdbs_en==1&&n==0&&minute==0&&miao==0)//整点报时开关
     
226.                 baojing();                                                                 
     
227.     }
     
228. }
     
229. 
     
230. //数码管显示程序
     
231. void  display(uchar s,f,m)
     
232. {
     
233.    if((s/10)<1) smg1=1;
     
234.    else
     
235.    {
     
236.            smg_data=tab1[s/10];//送显示断码  时
     
237.            if((n==1||n==3)&&a<5)
     
238.            smg1=1;//锁存数据
     
239.            else smg1=0;
     
240.            delay_50us(gm_time);
     
241.            smg1=1;        
     
242.    }
     
243. 
     
244.    if((n==1||n==3)&&a<5)        smg_data=0x7f; //字符闪烁，小点不闪
     
245.    else if(b>=10)                        smg_data=tab1[s%10]-0x80;//小点闪烁，字符不闪
     
246.    else                                         smg_data=tab1[s%10];//送显示断码
     
247.    smg2=0;
     
248.    delay_50us(gm_time);
     
249.    smg2=1;
     
250. 
     
251.    if((n==2||n==4)&&a<5)         smg_data=0xbf;//b是控制小数点闪烁的，需要闪烁的时候他等于a
     
252.    else if(b>=10)                        smg_data=tab1[f/10]; //显示小点//送显示断码
     
253.    else                                       smg_data=tab1[f/10];//送显示断码         分
     
254.    smg3=0;//锁存数据
     
255.    delay_50us(gm_time);
     
256.    smg3=1;         
     
257. 
     
258.    if(bell_en==1)         smg_data=tab1[f%10]-0x80;//送显示断码
     
259.    else                         smg_data=tab1[f%10];//送显示断码
     
260.    if((n==2||n==4)&&a<5)
     
261.    smg4=1;//锁存数据
     
262.    else smg4=0;
     
263.    delay_50us(gm_time);
     
264.    smg4=1;
     
265. /**************秒，不需要显示********************/   
     
266.    smg_data=tab2[m/10];//送显示断码   秒
     
267.    smg5=0;//锁存数据
     
268.    delay_50us(40);
     
269.    smg5=1;
     
270. 
     
271.    smg_data=tab1[m%10];//送显示断码
     
272.    smg6=0;//锁存数据
     
273.    delay_50us(40);
     
274.    smg6=1;
     
275. /*********************************************/
     
276. 
     
277. }
     
278. void key() //按键控制函数
     
279. {
     
280.         if(k2==0&&k3==0) //k2k3同时按下，切换闹铃开关 并且在按下之后查看闹钟时间松手后恢复时间显示
     
281.         {
     
282.                 delay_50us(1);
     
283.                 if(k2==0&&k3==0)
     
284.                 {        
     
285.                         shi=b_shi;
     
286.                         fen=b_fen;
     
287.                         bell_en=!bell_en;
     
288.                         baojing();
     
289.                         baojing();
     
290.                         while(k2==0&&k3==0)display(shi,fen,miao);//等待松手
     
291.                         shi=hour;
     
292.                         fen=minute;
     
293.                 }
     
294.         }
     
295.         
     
296.         if(k1==0&&k3==0) //k1k3同时按下，切换闹铃开关 并且在按下之后查看闹钟时间松手后恢复时间显示
     
297.         {
     
298.                 delay_50us(1);
     
299.                 if(k1==0&&k3==0)
     
300.                 {        
     
301.                         gm_en=!gm_en;
     
302.                         if(gm_en==1)//使能的话报警两声
     
303.                         {baojing();baojing();}
     
304.                         else baojing();//无效的话报警一声
     
305.                         while(k1==0&&k3==0)display(shi,fen,miao);//等待松手
     
306.                 }
     
307.         }
     
308.         if(k1==0&&k2==0) //k1k2同时按下，切换整点报时开关
     
309.         {
     
310.                 delay_50us(1);
     
311.                 if(k1==0&&k2==0)
     
312.                 {        
     
313.                         zdbs_en=!zdbs_en;
     
314.                         if(zdbs_en==1)//使能的话报警两声
     
315.                         {baojing();baojing();}
     
316.                         else baojing();//无效的话报警一声        
     
317.                         while(k1==0&&k2==0)display(shi,fen,miao);//等待松手
     
318.                 }
     
319.         }
     
320.         if(n==0&&(k2==0||k3==0)&&bell_en==1&&b_shi==hour&&b_fen==minute&&x==1)
     
321.         { //功能键k1被按下
     
322.                 delay_50us(1);//消抖延时
     
323.                 if(n==0&&(k2==0||k3==0)&&bell_en==1&&b_shi==hour&&b_fen==minute&&x==1)
     
324.                 {        
     
325.                         x=0;   //如果处于响零状态，就任意键关闭响铃
     
326.                         while(k1==0)display(shi,fen,miao);//等待松手
     
327.                 }
     
328.         }
     
329.         if(k1==0)
     
330.         { //功能键k1被按下
     
331.                 delay_50us(1);//消抖延时
     
332.                 if(k1==0)
     
333.                 {        
     
334.                         uint i=0;
     
335.                         while(k1==0)
     
336.                         {
     
337.                                 display(shi,fen,miao);//等待松手
     
338.                                 i++;
     
339.                                 if(i>(2*(70-gm_time))){n=0;baojing();baojing();break;}//长按K1退出
     
340.                         }
     
341.                         if(bell_en==1&&b_shi==hour&&b_fen==minute&&x==1)x=0;   //如果处于响零状态，就任意键关闭响铃
     
342.                         else if(i<=(2*(70-gm_time)))
     
343.                         {
     
344.                                 n++;//n记录功能键状态
     
345.                                 if(n>7)  n=0; //n清零
     
346.                                 baojing();        
     
347.                         }
     
348.                         i=0;                        
     
349.                 }
     
350.         }
     
351. 
     
352.         if(n==0)//状态0，正常显示时间
     
353.         {
     
354.                 b=a; //b是控制小数点闪烁的
     
355.                 shi=hour;
     
356.                 fen=minute;
     
357.                 miao=second;
     
358.         }        
     
359.         if(n==1)//状态1：调节时间的“时”
     
360.         {
     
361.                 b=10;
     
362.                 if(k2==0)
     
363.                 { //k2被按下
     
364.                         uint i=6,j=10;
     
365.                         while(i--)display(shi,fen,miao);//长按连续递减                        
     
366.                         if(k2==0)
     
367.                         {
     
368.                                 shi++;//小时加一
     
369.                                 if(shi==24)
     
370.                                 shi=0;//达到24清零        
     
371.                         }
     
372.                          while(j--)display(shi,fen,miao);//长按连续递减
     
373.                 }
     
374.                
     
375.                 if(k3==0)
     
376.                 {  //k3被按下
     
377.                         uint i=6,j=10;
     
378.                         while(i--)display(shi,fen,miao);//长按连续递减        
     
379.                         if(k3==0)
     
380.                         {
     
381.                                 shi--; //小时减一
     
382.                                 if(shi<0)
     
383.                                 shi=23;//小于0，重新复制
     
384.                         }
     
385.                         while(j--)display(shi,fen,miao);//长按连续递减
     
386.                 }               
     
387.         }
     
388.         if(n==2)//状态2：调节时间的“分”
     
389.         {        b=10;
     
390.                  if(k2==0)
     
391.                 { //k2被按下
     
392.                         uint i=6,j=10;
     
393.                         while(i--)display(shi,fen,miao);//长按连续递减
     
394.                         if(k2==0)
     
395.                         {
     
396.                                 fen++;//分加一
     
397.                                 if(fen==60)
     
398.                                 fen=0;//分到达60 分清零        
     
399.                         }        
     
400.                         while(j--)display(shi,fen,miao);//长按连续递减
     
401.                 }
     
402.                
     
403.                 if(k3==0)
     
404.                 {  //k3被按下
     
405.                         uint i=6,j=10;
     
406.                         while(i--)display(shi,fen,miao);//长按连续递减
     
407.                         if(k3==0)
     
408.                         {
     
409.                                 fen--;//分减一
     
410.                                 if(fen<0)
     
411.                                 fen=59;//分小于0，分重新赋值59                                          
     
412.                         }
     
413.                         while(j--)display(shi,fen,miao);//长按连续递减
     
414.                 }
     
415.                 tab23[2]=shi/10*16+shi%10;
     
416.         tab23[1]=fen/10*16+fen%10;
     
417.         hour=shi;
     
418.         minute=fen;
     
419.         second=0;
     
420.         tab23[0]=0;
     
421.         set_ds1302();//设置DS1302的初始时间               
     
422.         }
     
423.         
     
424.         if(n==3)//状态三：调节闹铃“时”
     
425.         {        
     
426.                 shi=b_shi;
     
427.                 fen=b_fen;
     
428.                 b=10;
     
429.                 if(k2==0)
     
430.                 {  //k2被按下
     
431.                         uint i=6,j=10;
     
432.                         while(i--)display(shi,fen,miao);//长按连续递减
     
433.                         if(k2==0)
     
434.                         {
     
435.                                 b_shi++;//闹铃时间加一
     
436.                                 if(b_shi==24)
     
437.                                 b_shi=0;//闹铃时间清零        
     
438.                         }
     
439.                         while(j--)display(shi,fen,miao);//长按连续递减
     
440.                 }
     
441.                
     
442.                 if(k3==0)
     
443.                 {  //k3被按下
     
444.                         uint i=6,j=10;
     
445.                         while(i--)display(shi,fen,miao);//长按连续递减
     
446.                         if(k3==0)
     
447.                         {
     
448.                                 b_shi--;//闹铃时间减一
     
449.                                 if(b_shi<0)
     
450.                                 b_shi=23;//闹铃时间        
     
451.                         }
     
452.                         while(j--)display(shi,fen,miao);//长按连续递减
     
453.                 }               
     
454.         }
     
455. 
     
456.         if(n==4)//状态四 ：调节闹铃的”分“
     
457.         {        b=10;
     
458.         shi=b_shi;
     
459.                 fen=b_fen;
     
460.                 if(k2==0)
     
461.                 {  //k2被按下
     
462.                         uint i=6,j=10;
     
463.                         while(i--)display(shi,fen,miao);//长按连续递减
     
464.                         if(k2==0)
     
465.                         {
     
466.                                 b_fen++;//闹铃时间分加一
     
467.                                 if(b_fen==60)
     
468.                                 b_fen=0;//闹铃分到达60 清零        
     
469.                         }        
     
470.                         while(j--)display(shi,fen,miao);//长按连续递减
     
471.                 }
     
472.                
     
473.                 if(k3==0)
     
474.                 {  //k3被按下
     
475.                         uint i=6,j=10;
     
476.                         while(i--)display(shi,fen,miao);//长按连续递减
     
477.                         if(k3==0)
     
478.                         {
     
479.                                 b_fen--;//闹铃时间分减一
     
480.                                 if(b_fen<0)
     
481.                                 b_fen=59;//闹铃时间分重新赋值
     
482.                         }
     
483.                         while(j--)display(shi,fen,miao);//长按连续递减                        
     
484.                 }               
     
485.         }
     
486.         if(n==5)//状态5 ：正计时
     
487.         {
     
488.                 b=10; //显示小点
     
489.                 shi=zjs_shi;
     
490.                 fen=zjs_fen;
     
491.                 if(k2==0)
     
492.                 {  //k2被按下
     
493.                         delay_50us(1);//消抖延时
     
494.                         if(k2==0)
     
495.                         {        
     
496.                                 zjs_en=!zjs_en;        
     
497.                                 baojing();
     
498.                                 while(k2==0)display(shi,fen,miao);//等待松手
     
499.                         }
     
500.                 }
     
501.                
     
502.                 if(k3==0)
     
503.                 {  //k3被按下
     
504.                         delay_50us(1);//消抖延时
     
505.                         if(k3==0)
     
506.                         {
     
507.                                 zjs_shi=0;
     
508.                                 zjs_fen=0;
     
509.                                 baojing();
     
510.                                 while(k3==0)display(shi,fen,miao);//等待松手        
     
511.                         }
     
512.                 }               
     
513.         }
     
514.         if(n==6)//状态5 ：倒计时
     
515.         {        b=10; //显示小点
     
516.         shi=djs_shi;
     
517.                 fen=djs_fen;
     
518.                 if(k2==0)
     
519.                 {  //k2被按下
     
520.                         delay_50us(1);//消抖延时
     
521.                         if(k2==0)
     
522.                         {        
     
523.                                 djs_en=!djs_en;        
     
524.                                 baojing();
     
525.                                 while(k2==0)display(shi,fen,miao);//等待松手
     
526.                         }
     
527.                 }
     
528.                
     
529.                 if(k3==0&&djs_en==0)
     
530.                 {  //k3被按下
     
531.                         uint i=6,j=10;
     
532.                         while(i--)display(shi,fen,miao);//长按连续递减
     
533.                         if(k3==0)
     
534.                         {
     
535.                                 djs_shi--;
     
536.                                 if(djs_shi<0)
     
537.                                 djs_shi=60;               
     
538.                         }
     
539.                         while(j--)display(shi,fen,miao);//长按连续递减
     
540.                 }
     
541.                 if(k3==0&&djs_en==1)
     
542.                 {  //k3被按下
     
543.                         delay_50us(1);//消抖延时
     
544.                         if(k3==0)
     
545.                         {
     
546.                                 djs_shi=60;
     
547.                                 djs_fen=0;
     
548.                                 baojing();
     
549.                                 while(k3==0)display(shi,fen,miao);//等待松手        
     
550.                         }
     
551.                 }               
     
552.         }
     
553.         if(n==7)//状态5 ：计数器
     
554.         {        
     
555.                 b=1; //不显示小点
     
556.                 shi=jsq_shi;
     
557.                 fen=jsq_fen;
     
558.         
     
559.                 if(k2==0)
     
560.                 {  
     
561.                         uint i=6,j=10;
     
562.                         while(i--)display(shi,fen,miao);//长按连续递减
     
563.                         if(k2==0)
     
564.                         {
     
565.                                 jsq_fen++;
     
566.                                 if(jsq_fen>99)
     
567.                                 {
     
568.                                         jsq_fen=0;
     
569.                                         jsq_shi++;
     
570.                                         if(jsq_shi>99)
     
571.                                         jsq_shi=0;
     
572.                                 }                        
     
573.                         }
     
574.                         while(j--)display(shi,fen,miao);//长按连续递减
     
575.                 }
     
576.                 if(k3==0)
     
577.                 {  //k3被按下
     
578.                         delay_50us(1);//消抖延时
     
579.                         if(k3==0)
     
580.                         {
     
581.                                 jsq_shi=0;
     
582.                                 jsq_fen=0;
     
583.                                 baojing();
     
584.                                 while(k3==0)display(shi,fen,miao);//等待松手        
     
585.                         }
     
586.                 }               
     
587.         }                        
     
588. }
     
589. void init()        //初始化函数
     
590. {
     
591.         IE=0X82;//1000 0010
     
592.         TMOD=0X01;    //0000 0001选择定时器0的工作方式1        选择定时器1的工作方式1
     
593.         TH0=(65536-50000)/256;//初值15536定时50mS
     
594.         TL0=(65536-50000)%256;
     
595.         TR0=1; //开启定时器0
     
596. }
     
597. 
     
598. void timer0() interrupt        1  //定时器0中断服务程序，用来设置冒号闪烁频率
     
599. {
     
600.         TH0=(65536-50000)/256;//进入中断重新赋初值15536
     
601.         TL0=(65536-50000)%256;//计数5万次（50毫秒）
     
602.         a++; //标志位b，用来确定光标闪烁频率
     
603.         t++;
     
604.         if(t==300)t=0;
     
605.         if(t>260)temp_en=1;
     
606.         else temp_en=0;
     
607.         
     
608.         if(a==20)
     
609.         {        
     
610.                 a=0;//a=20 时被清零        
     
611.                 if(zjs_en==1)        //正计时
     
612.                 {
     
613.                         zjs_fen++;
     
614.                         if(zjs_fen==60)
     
615.                         {
     
616.                                 zjs_fen=0;
     
617.                                 zjs_shi++;
     
618.                                 if(zjs_shi==60)
     
619.                                 {
     
620.                                         zjs_shi=0;        
     
621.                                 }
     
622.                         }        
     
623.                 }
     
624.                 /**********倒计时**********/
     
625.                 if(djs_en==1)
     
626.                 {
     
627.                         djs_fen--;
     
628.                         if(djs_fen==-1)
     
629.                         {
     
630.                                 djs_fen=59;
     
631.                                 djs_shi--;
     
632.                                 if(djs_shi==-1)
     
633.                                 {
     
634.                                         djs_shi=0;
     
635.                                         djs_fen=0;
     
636.                                         djs_en=0;//关闭倒计时
     
637.                                         baojing();
     
638.                                 baojing();
     
639.                                 baojing();
     
640.                                 }
     
641.                         }        
     
642.                 }
     
643.                 /*************************/
     
644.         }
     
645. }
     
646. 
     
647. 
     
648. //函数名称：void delay_50US(unsigned int t)
     
649. //功能： 延时50*t(us)
     
650. void delay_50us(uint t)
     
651. {
     
652.   unsigned char j;
     
653.   for(;t>0;t--)
     
654.   {
     
655.     for(j=19;j>0;j--);
     
656.   }
     
657. }
     
658. //*******************************************************************************
     
659. 
     
660. //*******************************************************************************
     
661. //3微秒延时程序
     
662. void delay_3us()
     
663. {
     
664.   ;
     
665.   ;
     
666. }
     
667. 
     
668. 
     
669. //;##############################################################################
     
670. //;子程序名：w_1byte_ds1302
     
671. //;功能：    向DS1302写一个字节的数据
     
672. void w_1byte_ds1302(uchar t)
     
673. {
     
674.   uchar i;
     
675.   for(i=0;i<8;i++)
     
676.   {
     
677.     if(t & 0x01)
     
678.      {io_ds1302=1;}
     
679.     else
     
680.      {io_ds1302=0;}
     
681.     clk_ds1302=1;
     
682.     delay_3us();
     
683.     delay_3us();
     
684.     clk_ds1302=0;
     
685.     delay_3us();
     
686.     delay_3us();
     
687.     t>>=1;
     
688.   }  
     
689. }
     
690. //;########################################################################
     
691. //;子程序名：r_1byte_ds1302()
     
692. //;功能：    从DS1302读一个字节的数据
     
693. uchar r_1byte_ds1302()
     
694. {
     
695.   uchar i,temp11=0;
     
696.   io_ds1302=1;//置IO为1，准备读入数据
     
697.   for(i=0;i<8;i++)
     
698.   {
     
699.     temp11>>=1;
     
700.     if(io_ds1302) temp11 |= 0x80;
     
701.     clk_ds1302=1;
     
702.     delay_3us();
     
703.     delay_3us();
     
704.     clk_ds1302=0;
     
705.     delay_3us();
     
706.   }
     
707.   return(temp11);
     
708. }  
     
709. //;#################################################################################
     
710. //;子程序名：setbds1302
     
711. //;功能：   设置DS1302初始时间,并启动计时
     
712. void set_ds1302()
     
713. {
     
714.   uchar i,j;
     
715.   rest_ds1302=0;
     
716.   delay_3us();
     
717.   clk_ds1302=0;
     
718.   delay_3us();
     
719.   rest_ds1302=1;
     
720.   delay_3us();
     
721.   w_1byte_ds1302(0x8e);//写控制命令字
     
722.   delay_3us();
     
723.   w_1byte_ds1302(0x00);//写保护关闭
     
724.   clk_ds1302=1;
     
725.   delay_3us();
     
726.   rest_ds1302=0;
     
727.   for(i=0,j=0x80;i<7;i++,j+=2)
     
728.   {
     
729.     rest_ds1302=0;
     
730.     delay_3us();
     
731.     clk_ds1302=0;
     
732.     delay_3us();
     
733.     rest_ds1302=1;
     
734.     delay_3us();
     
735.     w_1byte_ds1302(j);
     
736.     delay_3us();
     
737.     w_1byte_ds1302(tab23[i]);
     
738.     delay_3us();
     
739.     delay_3us();
     
740.     clk_ds1302=1;
     
741.     delay_3us();
     
742.     rest_ds1302=0;
     
743.     delay_3us();
     
744.     delay_3us();
     
745.   }
     
746.   rest_ds1302=0;
     
747.   delay_3us();
     
748.   clk_ds1302=0;
     
749.   delay_3us();
     
750.   rest_ds1302=1;
     
751.   delay_3us();
     
752.   w_1byte_ds1302(0x8e);
     
753.   delay_3us();
     
754.   w_1byte_ds1302(0x80);
     
755.   clk_ds1302=1;
     
756.   delay_3us();
     
757.   rest_ds1302=0;
     
758.   delay_3us();
     
759. }  
     
760. //;#################################################################-------
     
761. //;子程序名：get1302
     
762. void get_ds1302()
     
763. {  uchar hour_count,minute_count,second_count;
     
764.    uchar temp11[7],i,j;
     
765.    for(i=0;i<7;i++)
     
766.    {temp11[i]=0;}
     
767.    for(i=0,j=0x81;i<7;i++,j+=2)
     
768.    {  
     
769.     rest_ds1302=0;
     
770.     delay_3us();
     
771.     clk_ds1302=0;
     
772.     delay_3us();
     
773.     rest_ds1302=1;
     
774.     delay_3us();
     
775.     w_1byte_ds1302(j);
     
776.     temp11[i]=r_1byte_ds1302();
     
777.     delay_3us();
     
778.     clk_ds1302=1;
     
779.     delay_3us();
     
780.     rest_ds1302=0;
     
781.     delay_3us();
     
782.   }
     
783.   if(temp11[0]!=0xff)
     
784.   {second_count=temp11[0];}
     
785.   if(temp11[1]!=0xff)// 数据验证
     
786.   {minute_count=temp11[1];}
     
787.   if(temp11[2]!=0xff)//数据验证
     
788.   {hour_count=temp11[2];}
     
789.          hour=hour_count/16*10+hour_count%16;
     
790.         minute=minute_count/16*10+minute_count%16;
     
791.         second=second_count/16*10+second_count%16;
     
792.           /*zancun4=hour_count&0xf0;
     
793.           zancun4>>=4;
     
794.           zancun5=minute_count&0xf0;
     
795.           zancun5>>=4;
     
796.           zancun6=second_count&0xf0;
     
797.           zancun6>>=4;*/
     
798. }

复制代码

---

作者: wcstars    时间: 2019-3-18 20:15
谢谢楼主的分享，下载下来看看。

---

作者: wifingtta    时间: 2019-3-28 09:58
很厉害。写数据到DS1302一直没做成功能，看了楼主的，很快成功了，51有你更精彩。真感谢！

---

作者: ilovedpj    时间: 2019-3-29 13:09
不错，谢谢分享。

---

作者: zsf333666    时间: 2019-4-27 21:37
有人做出成品了吗？ 请教个问题!为什我做出来后时钟芯片备用电池不但没有效果还被掏空了电

---

作者: yzhbyyy    时间: 2019-5-13 16:00
很给力！

---

作者: minjunshuyi    时间: 2020-3-6 18:00
学习了！

---

作者: hellopcd    时间: 2024-5-8 21:42
真的对我帮助很大！

---

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

Powered by Discuz! X3.1