代码:

1. 
   
2. 
   
3. //这个只是读取出时间，其它功能没有写出来，用了四位共阴数码管显示。
   
4. // 小数点闪烁  第3位数码管倒置显示小数点
   
5. //  与第二位数码管一起显示“：”，1秒闪烁一次
   
6. 
   
7. //仿真用了4个一位的数码管和一个四位的数码管
   
8. /**********************************
   
9. *                DS1302简单时间显示                  *
   
10. *                        数码管显示                          *
    
11. ***********************************/
    
12. #include <reg52.h>
    
13. #include<intrins.h>
    
14. #define uchar unsigned char
    
15. #define uint unsigned int
    
16. #define W P2                                                                          //位选
    
17. #define D P0                                                                        //段选
    
18. sbit dio=P1^1;                                                                          //数据口
    
19. sbit sclk=P1^0;                                                                         //控制数据时钟
    
20. sbit RST=P1^2;                                                                          //使能端、复位端
    
21. /************按键引脚定义***********/
    
22. sbit s1=P3^0;                                                                        //按键 加
    
23. sbit s2=P3^1;                                                                        //按键 减
    
24. sbit s3=P3^2;                                                                        //按键 选择
    
25. char knum=0,snum,fnum;
    
26. 
    
27. /***********写时分秒地址************/
    
28. #define write_shi  0x84
    
29. #define write_fen  0x82
    
30. #define write_miao 0x80
    
31. /***********读时分秒地址************/
    
32. #define read_shi  0x85
    
33. #define read_fen  0x83
    
34. #define read_miao 0x81
    
35. 
    
36. char shi,fen,miao;                                                                 //读出数据存储变量
    
37. //uchar d[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xd8,0x80,0x90};                //不带小数点
    
38. //uchar dd[]={0x40,0x79,0x24,0x30,0x19,0x12,0x02,0x78,0x00,0x10};                //带小数点
    
39. 
    
40. 
    
41.                            // 0     1         2          3           4    5    6    7   8     9    10   11        
    
42. uchar code d[]={ 0x3F,0x06,0x5B,0x4F,0x66,0x6D,0x7D,0x07,0x7F,0x6F,0x40,0x00};                //共阴不带小数点  
    
43. 
    
44. uchar code dd[]={0xbf,0x86,0xdb,0xcf,0xe6,0xed,0xfd,0x87,0xff,0xef};//        共阴带小数点
    
45. 
    
46. void delay(uint z)                                                          //延时函数,z的取值为这个函数的延时ms数，如delay(200);大约延时200ms.
    
47. {                                                                                                //delay(500);大约延时500ms.
    
48.         uint x,y;
    
49.         for(x=z;x>0;x--)
    
50.                 for(y=110;y>0;y--);        
    
51. }
    
52. 
    
53. void write_1302(uchar add,dat)                 //写函数  qx
    
54. {
    
55.         uchar i,temp;
    
56.         temp=add;
    
57.         RST=0;
    
58.         _nop_();
    
59.         sclk=0;
    
60.         _nop_();
    
61.         RST=1;
    
62.         _nop_();
    
63.         for(i=0;i<8;i++)
    
64.         {
    
65.                 sclk=0;
    
66.                 _nop_();
    
67.                 if((temp&0x01)==0x01)
    
68.                         dio=1;
    
69.                         else
    
70.                         dio=0;
    
71.                 temp>>=1;
    
72.                 sclk=1;
    
73.                 _nop_();
    
74.         }
    
75.         temp=dat;
    
76.         for(i=0;i<8;i++)
    
77.         {
    
78.                 sclk=0;
    
79.                 _nop_();
    
80.                 if((temp&0x01)==0x01)
    
81.                         dio=1;
    
82.                         else
    
83.                         dio=0;
    
84.                 temp>>=1;
    
85.                 sclk=1;
    
86.                 _nop_();
    
87.         }
    
88.         RST=0;
    
89.         sclk=0;
    
90. }
    
91. uchar read_1302(uchar add)                                   //读函数                qx
    
92. {
    
93.         uchar dat,dat1,i,temp;
    
94.         temp=add;
    
95.         RST=0;
    
96.         _nop_();
    
97.         sclk=0;
    
98.         _nop_();
    
99.         RST=1;
    
100.         for(i=0;i<8;i++)
     
101.         {
     
102.                 sclk=0;
     
103.                 _nop_();
     
104.                 if((temp&0x01)==0x01)
     
105.                         dio=1;
     
106.                         else
     
107.                         dio=0;
     
108.                 temp>>=1;
     
109.                 sclk=1;
     
110.                 _nop_();
     
111.         }
     
112.         for(i=0;i<8;i++)
     
113.         {
     
114.                 sclk=0;
     
115.                 _nop_();
     
116.                 if(dio)
     
117.                     dat|=0x80;
     
118.                 if(i<7)
     
119.                         dat>>=1;
     
120.                 sclk=1;
     
121.         }
     
122.         dat1=dat/16;
     
123.         dat=dat%16;
     
124.         dat=dat1*10+dat;  
     
125.         RST=0;
     
126.         sclk=0;
     
127.         return dat;
     
128. }                                 
     
129. 
     
130. 
     
131. 
     
132. 
     
133. void init_1302()                                                        //初始化函数 设置时间
     
134. {
     
135.         write_1302(0x8e,0x00);                                        //保护取消，可以进行读写操作
     
136.         write_1302(write_miao,0x56);        
     
137.         write_1302(write_fen,0x49);
     
138.         write_1302(write_shi,0x14);
     
139.         write_1302(0x8e,0x80);                                        //保护启动，不能进行读写操作
     
140. }
     
141. 
     
142. void display(uchar shi,uchar fen,uchar miao)                          //显示函数
     
143. {
     
144.         if(knum==0)
     
145.         {
     
146.                 snum=30;
     
147.                 fnum=30;
     
148.         }
     
149.         if(knum==1)
     
150.         {
     
151.                 fnum++;
     
152.                 snum=30;
     
153.         }
     
154.         if(knum==2)
     
155.         {
     
156.                 snum++;
     
157.                 fnum=30;
     
158.         }
     
159.         
     
160.         if(snum>=30)
     
161.         {
     
162.                 P2=0x01;                                                                        //位选
     
163.                 P0=d[shi/10];                                                        //段选
     
164.                 delay(5);
     
165.                 P0=0X00;
     
166.                                                                                 //位选
     
167.                                                                         //消隐
     
168.                 if(miao%2==0)                                                        //小数点闪烁
     
169.                 {
     
170.                         P2=0x02;
     
171.                         P0=dd[shi%10];
     
172.                         delay(5);
     
173.                         P0=0X00;
     
174.                                                                                 //消隐
     
175.                 }
     
176.                 else
     
177.                 {
     
178.                     P2=0x02;
     
179.                         P0=d[shi%10];
     
180.                         delay(5);
     
181.                         P0=0X00;
     
182.                                                                                                 //消?
     
183.                 }
     
184.             if(snum==60)
     
185.                         snum=0;
     
186.         }               
     
187.         if(fnum>=30)
     
188.         {
     
189.                
     
190.                 if(miao%2==0)                                                        //小数点闪烁  第3位数码管倒置显示小数点
     
191.                                                                                                  //与第二位数码管一起显示“：”，1秒闪烁一次
     
192.                 {
     
193.                 P2=0x04;
     
194.                 P0=dd[fen/10];
     
195.                 delay(5);
     
196.                 P0=0X00;
     
197.                 }                                                                //消隐
     
198. 
     
199. 
     
200.            else
     
201.            {
     
202.                    P2=0x04;
     
203.                 P0=d[fen/10];
     
204.                 delay(5);
     
205.                 P0=0X00;
     
206.            
     
207.            }
     
208.                 P2=0x08;
     
209.                 P0=d[fen%10];
     
210.                 delay(5);
     
211.                 P0=0X00;
     
212.                                                                                         //消隐
     
213.                 if(fnum==60)
     
214.                         fnum=0;
     
215.         }
     
216. }
     
217. void read_sf()
     
218. {
     
219.         shi=read_1302(read_shi);
     
220.         fen=read_1302(read_fen);
     
221.         miao=read_1302(read_miao);
     
222.         display(shi,fen,miao);
     
223. }
     
224. void keyscan()                                                                   //按键扫描函数
     
225. {                                                                                   
     
226.         if(s3==0)                                                                   //选择按键按下
     
227.         {
     
228.                 delay(10);
     
229.                 if(s3==0)
     
230.                 {
     
231.                         while(!s3)
     
232.                                 display(shi,fen,miao);        //加上这句，按键按下就不会闪
     
233.                         knum++;
     
234.                         if(knum==1)                                                  //分闪烁
     
235.                         {
     
236.                                  write_1302(0x8e,0x00);                //保护取消
     
237.                                  write_1302(write_miao,0x80);
     
238.                         }
     
239.                         if(knum==3)                                                   //时钟启动
     
240.                         {
     
241.                                 knum=0;
     
242.                                 write_1302(write_miao,0x00);
     
243.                                 write_1302(0x8e,0x80);                //保护启动
     
244.                         }
     
245.                 }
     
246.         }
     
247.         if(knum==1)                                                                //分钟调节
     
248.         {
     
249.                 if(s1==0)                                                        //加
     
250.                 {
     
251.                         delay(10);
     
252.                         if(s1==0)
     
253.                         {        
     
254.                                 while(!s1)
     
255.                                         display(shi,fen,miao);        //加上这句，按键按下就不会闪
     
256.                                 fen++;
     
257.                                 fen=fen/10*16+fen%10;                //转为16进制
     
258.                                 if(fen==0x60)
     
259.                                         fen=0x00;
     
260.                                 write_1302(write_fen,fen);        //写入1302
     
261.                                 read_sf();                                        //读出时间，然后显示
     
262.                         }
     
263.                 }
     
264.                 if(s2==0)
     
265.                 {
     
266.                         delay(10);
     
267.                         if(s2==0)
     
268.                         {        
     
269.                                 while(!s2)
     
270.                                         display(shi,fen,miao);        //加上这句，按键按下就不会闪
     
271.                                 fen--;
     
272.                                 fen=fen/10*16+fen%10;                //转为16进制
     
273.                                 if(fen==-1)
     
274.                                         fen=0x59;
     
275.                                 write_1302(write_fen,fen);
     
276.                                 read_sf();
     
277.                         }
     
278.                 }
     
279.         }
     
280.         if(knum==2)
     
281.         {
     
282.                 if(s1==0)
     
283.                 {
     
284.                         delay(10);
     
285.                         if(s1==0)
     
286.                         {        
     
287.                                 while(!s1)
     
288.                                         display(shi,fen,miao);        //加上这句，按键按下就不会闪
     
289.                                 shi++;
     
290.                                 shi=shi/10*16+shi%10;                //转为16进制
     
291.                                 if(shi==0x24)
     
292.                                         shi=0x00;
     
293.                                 write_1302(write_shi,shi);
     
294.                                 read_sf();
     
295.                         }
     
296.                 }
     
297.                 if(s2==0)
     
298.                 {
     
299.                         delay(10);
     
300.                         if(s2==0)
     
301.                         {        
     
302.                                 while(!s2)
     
303.                                           display(shi,fen,miao);        //加上这句，按键按下就不会闪
     
304.                                 shi--;
     
305.                                 shi=shi/10*16+shi%10;                //转为16进制
     
306.                                 if(shi==-1)
     
307.                                         shi=0x23;
     
308.                                 write_1302(write_shi,shi);
     
309.                                 read_sf();
     
310.                         }
     
311.                 }
     
312.         }
     
313. }
     
314. void main()
     
315. {
     
316.         init_1302();
     
317.         while(1)
     
318.         {
     
319.                 read_sf();
     
320.                 keyscan();
     
321. 
     
322.                 display(shi,fen,miao);
     
323.         }
     
324. }