74HC595驱动数码管时钟仿真

/***以下是部分源码，完整源码见附件***
74HC595驱动数码管时钟仿真，8位共阳数码管显示88-88-88样式，两个“-”1秒闪烁1次；按键调时部分没写，有兴趣的自己去添加；附件里有完整源码和仿真文件。

单片机源程序如下:

1. [code]#include <reg52.h>
   
2. #include <intrins.h>
   
3. #define uchar unsigned char
   
4. 
   
5. 
   
6. uchar code Table[] =
   
7. { // 0         1          2           3        4         5          6           7        8         9          A           b        C    d          E    F    -
   
8.         0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,0x8C,0xBF,0xC6,0xA1,0x86,0xFF,0xbf
   
9. };
   
10. //-----------------------------------------------------------------------------
    
11. 
    
12. sbit SER = P1^0;        //串行数据输入端
    
13. sbit STCP = P1^1;        //存储寄存器时钟端，并行输出
    
14. sbit SHCP = P1^2;        / /移位寄存器时钟端
    
15. 
    
16. sbit key1 = P3^0;        //选择键
    
17. sbit key2 = P3^1;        //加键
    
18. sbit key3 = P3^2;        //减键
    
19. sbit key4 = P3^3;
    
20. 
    
21. uchar shan,A,K,C,D,E,F;
    
22. uchar knum;                //选择键计数变量
    
23. 
    
24. void TimerInit();
    
25. void KeyScan();
    
26. void Display (uchar shi10,uchar shi,uchar fen10,uchar fen,uchar miao10,uchar miao);        // 数码管显示
    
27. void SMG_Int(uchar Dat);                // 数码管单字节串行移位函数
    
28. 
    
29. //*****************************************************************************
    
30. // 主程序
    
31. void main ()
    
32. {
    
33.         TimerInit();
    
34.         while(1)
    
35.         {
    
36.                 Display (A,K,C,D,E,F);
    
37.                 KeyScan();
    
38.         }
    
39. }
    
40. 
    
41. void KeyScan()
    
42. {
    
43.         
    
44. }
    
45. 
    
46. 
    
47. void Display (uchar shi10,uchar shi,uchar fen10,uchar fen,uchar miao10,uchar miao)
    
48. {
    
49.         uchar i;
    
50. 
    
51.         //显示第1位        小时10位
    
52.         i = Table[shi10];
    
53. 
    
54.         SMG_Int(i);                        
    
55.         SMG_Int(0x01);               
    
56. 
    
57.         STCP = 0;         //数据并行输出，（借助上升沿）
    
58.         _nop_();
    
59.         _nop_();
    
60.         STCP = 1;
    
61. 
    
62.         //显示第2位        小时个位
    
63.         i = Table[shi];
    
64. 
    
65.         SMG_Int(i);               
    
66.         SMG_Int(0x02);               
    
67. 
    
68.         STCP = 0;
    
69.         _nop_();
    
70.         _nop_();
    
71.         STCP = 1;
    
72. 
    
73.         //显示第3位        -
    
74.         if(shan<10)         //"-" 闪烁
    
75.         i = Table[16];
    
76.         else
    
77.         i = Table[15];
    
78.         SMG_Int(i);                        
    
79.         SMG_Int(0x04);        
    
80. 
    
81.         STCP = 0;
    
82.         _nop_();
    
83.         _nop_();
    
84.         STCP = 1;
    
85. 
    
86.         //显示第4位        分钟10位
    
87.         i = Table[fen10];
    
88. 
    
89.         SMG_Int(i);                        
    
90.         SMG_Int(0x08);               
    
91. 
    
92.         STCP = 0;
    
93.         _nop_();
    
94.         _nop_();
    
95.         STCP = 1;
    
96. 
    
97.         //显示第5位        分钟个位
    
98.         i = Table[fen];
    
99. 
    
100.         SMG_Int(i);                        
     
101.         SMG_Int(0x10);        
     
102. 
     
103.         STCP = 0;
     
104.         _nop_();
     
105.         _nop_();
     
106.         STCP = 1;
     
107. 
     
108.         //显示第6位        -
     
109.         if(shan<10)           //"-" 闪烁
     
110.         i = Table[16];
     
111.         else
     
112.         i = Table[15];
     
113. 
     
114.         SMG_Int(i);                        
     
115.         SMG_Int(0x20);        
     
116. 
     
117.         STCP = 0;
     
118.         _nop_();
     
119.         _nop_();
     
120.         STCP = 1;
     
121. 
     
122.         //显示第7位        秒10位
     
123.         i = Table[miao10];
     
124. 
     
125.         SMG_Int(i);                        
     
126.         SMG_Int(0x40);        
     
127. 
     
128.         STCP = 0;
     
129.         _nop_();
     
130.         _nop_();
     
131.         STCP = 1;
     
132. 
     
133.         //显示第8位        秒个位
     
134.         i = Table[miao];
     
135. 
     
136.         SMG_Int(i);               
     
137.         SMG_Int(0x80);        
     
138. 
     
139.         STCP = 0;
     
140.         _nop_();
     
141.         _nop_();
     
142.         STCP = 1;
     
143. }
     
144. 
     
145. void SMG_Int(uchar Dat)         //通过8次循环将8位数据移入74HC595
     
146. {
     
147.         uchar i;
     
148.         for(i=8;i>=1;i--)
     
149.         {
     
150.                 if (Dat & 0x80)
     
151.                 {
     
152.                         SER = 1;
     
153.                 }
     
154.                
     
155.                 else
     
156.                 {
     
157.                         SER = 0;
     
158.                 }
     
159.                 Dat <<= 1;
     
160.                 SHCP = 0;
     
161.                 _nop_();
     
162.                 _nop_();
     
163.                 SHCP = 1;
     
164.         }
     
165. }
     
166. 
     
167. void TimerInit()         //定时器0初始化
     
168. {
     
169.         TMOD = 0x01;
     
170.         TH0 = (65536-50000)/256;        //50ms初值
     
171.         TL0 = (65536-50000)%256;
     
172.         EA = 1;
     
173.         ET0 = 1;
     
174.         TR0 = 1;
     
175. 
     
176. }
     
177. 
     
178. void Timer0() interrupt 1
     
179. {
     
180.         static uchar cnt,shi=12,fen=59,miao=30;
     
181.         
     
182.         TH0 = (65536-50000)/256;
     
183.         TL0 = (65536-50000)%256;
     
184.         
     
185.         shan++;
     
186.         if(shan==20)
     
187.                 shan=0;
     
188. 
     
189.         cnt++;
     
190.         if(cnt==20)
     
191.         {
     
192.                 cnt = 0;
     
193.                 miao++;
     
194.                 if(miao == 60)
     
195.                 {
     
196.                         miao = 0;
     
197.                         fen++;
     
198.                         if(fen==60)
     
199.                         {
     
200.                                 fen = 0;
     
201.                                 shi++;
     
202.                                 if(shi==24)
     
203.                                 {
     
204.                                         shi=0;
     
205.                                 }
     
206.                         }
     
207.                 }
     
208.         }
     
209. 
     
210.         A=shi/10;
     
211.         K=shi%10;
     
212.         C=fen/10;
     
213.         D=fen%10;
     
214.         E=miao/10;
     
215.         F=miao%10;
     
216. }
     
217. 
     
218. …………限于本文篇幅 余下代码请从51黑下载附件…………

复制代码

所有资料51hei提供下载(按键调时程序还没有写):
595数码管时钟资料.rar (20.57 KB, 下载次数: 191)

2017-9-14 10:40 上传

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

谢谢分享！正需要 这个。

不错！！！

用上时钟芯片就好了

谢谢分享！非常有用！

谢谢分享！正需要 这个。

按键完全没用

下载了学习一下，谢谢楼主的资料，楼主辛苦了！

希望补齐按键程序，不然就不是完整程序，按键等于虚设。

你们要的按键完整程序来了

kz0018 发表于 2022-11-29 20:23
希望补齐按键程序，不然就不是完整程序，按键等于虚设。

加按键调时的代码

1. #include <reg52.h>
   
2. #include <intrins.h>
   
3. #define uchar unsigned char
   
4. 
   
5. 
   
6. uchar code Table[] =
   
7. { // 0         1          2           3        4         5          6           7        8         9          A           b        C    d          E    不显    -
   
8.         0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,0x88,0x83,0xC6,0xA1,0x86,0xFF,0xbf
   
9. };
   
10. //-----------------------------------------------------------------------------
    
11. 
    
12. sbit SER = P1^0;        //串行数据输入端
    
13. sbit STCP = P1^1;        //时钟脉冲信号——上升沿有效 存储寄存器时钟输入端，并行输出
    
14. sbit SHCP = P1^2;        //输入信号————上升沿有效 移位寄存器时钟输入端
    
15. 
    
16. sbit key1 = P3^0;        //选择键
    
17. sbit key2 = P3^1;        //加键
    
18. sbit key3 = P3^2;        //减键
    
19. sbit key4 = P3^3;
    
20. 
    
21. char shi=12,fen=59,miao=30;
    
22. uchar shan,A,K,C,D,E,F;
    
23. uchar knum;                //选择键计数变量
    
24. uchar keycont1,keycont2,keycont3;//消抖计时变量
    
25. bit lock1,lock2,lock3;//按键自锁标志
    
26. 
    
27. void TimerInit();
    
28. void KeyScan();
    
29. void Display (uchar shi10,uchar shi,uchar fen10,uchar fen,uchar miao10,uchar miao);        // 数码管显示
    
30. void SMG_Int(uchar Dat);                // 数码管单字节串行移位函数
    
31. 
    
32. //*****************************************************************************
    
33. // 主程序
    
34. void main ()
    
35. {
    
36.         TimerInit();
    
37.         while(1)
    
38.         {
    
39.                 Display (A,K,C,D,E,F);
    
40.                 KeyScan();
    
41.         }
    
42. }
    
43. 
    
44. void KeyScan()
    
45. {
    
46.         if(key1)
    
47.         {
    
48.                 keycont1=0;
    
49.                 lock1=0;       
    
50.         }
    
51.         else if(lock1==0)
    
52.         {
    
53.                 keycont1++;
    
54.                 if(keycont1>50)
    
55.                 {
    
56.                         keycont1=0;
    
57.                         lock1=1;
    
58.                         knum++;
    
59.                         if(knum==4)
    
60.                                 knum=0;                       
    
61.                 }       
    
62.         }
    
63. /////////////////////////
    
64.         if(key2)
    
65.         {
    
66.                 keycont2=0;
    
67.                 lock2=0;       
    
68.         }
    
69.         else if(lock2==0)
    
70.         {
    
71.                 keycont2++;
    
72.                 if(keycont2>50)
    
73.                 {
    
74.                         keycont2=0;
    
75.                         lock2=1;
    
76.                         switch(knum)
    
77.                         {
    
78.                                 case 0:  break;
    
79.                                 case 1: shi++; if(shi==24)shi=0; break;
    
80.                                 case 2: fen++; if(fen==60)fen=0; break;
    
81.                                 case 3: miao++; if(miao==60)miao=0; break;
    
82. 
    
83.                         }
    
84.                                        
    
85.                 }       
    
86.         }
    
87. /////////////////////////
    
88.         if(key3)
    
89.         {
    
90.                 keycont3=0;
    
91.                 lock3=0;       
    
92.         }
    
93.         else if(lock3==0)
    
94.         {
    
95.                 keycont3++;
    
96.                 if(keycont3>50)
    
97.                 {
    
98.                         keycont3=0;
    
99.                         lock3=1;
    
100.                         switch(knum)
     
101.                         {
     
102.                                 case 0:  break;
     
103.                                 case 1: shi--; if(shi<0)shi=23; break;
     
104.                                 case 2: fen--; if(fen<0)fen=59; break;
     
105.                                 case 3: miao--; if(miao<0)miao=59; break;
     
106.                         }
     
107.                 }
     
108.         }
     
109. }
     
110. 
     
111. 
     
112. void Display (uchar shi10,uchar shi,uchar fen10,uchar fen,uchar miao10,uchar miao)
     
113. {
     
114.         uchar i;
     
115. 
     
116.         //显示第1位        小时10位
     
117.         if(knum==1)
     
118.         {
     
119.                 if(shan%4==0)         //
     
120.                 i = Table[15];
     
121.                 else
     
122.                 i = Table[shi10];
     
123.        
     
124.                 SMG_Int(i);                       
     
125.                 SMG_Int(0x01);               
     
126.        
     
127.                 STCP = 0;         //数据并行输出，（借助上升沿）
     
128.                 _nop_();
     
129.                 _nop_();
     
130.                 STCP = 1;
     
131.        
     
132.                 //显示第2位        小时个位
     
133.                 if(shan%4==0)         //
     
134.                 i = Table[15];
     
135.                 else
     
136.                 i = Table[shi];
     
137.        
     
138.                 SMG_Int(i);               
     
139.                 SMG_Int(0x02);               
     
140.        
     
141.                 STCP = 0;
     
142.                 _nop_();
     
143.                 _nop_();
     
144.                 STCP = 1;
     
145.         }
     
146.         else
     
147.         {
     
148.                 i = Table[shi10];
     
149.        
     
150.                 SMG_Int(i);                       
     
151.                 SMG_Int(0x01);               
     
152.        
     
153.                 STCP = 0;         //数据并行输出，（借助上升沿）
     
154.                 _nop_();
     
155.                 _nop_();
     
156.                 STCP = 1;
     
157.        
     
158.                 //显示第2位        小时个位
     
159.                 i = Table[shi];
     
160.        
     
161.                 SMG_Int(i);               
     
162.                 SMG_Int(0x02);               
     
163.        
     
164.                 STCP = 0;
     
165.                 _nop_();
     
166.                 _nop_();
     
167.                 STCP = 1;       
     
168.         }
     
169.         //显示第3位        -
     
170.         if(shan<10)         //"-" 闪烁
     
171.         i = Table[16];
     
172.         else
     
173.         i = Table[15];
     
174.         SMG_Int(i);                       
     
175.         SMG_Int(0x04);       
     
176. 
     
177.         STCP = 0;
     
178.         _nop_();
     
179.         _nop_();
     
180.         STCP = 1;
     
181. 
     
182.         //显示第4位        分钟10位
     
183.         if(knum==2)
     
184.         {
     
185.                 if(shan%4==0)         //
     
186.                 i = Table[15];
     
187.                 else
     
188.                 i = Table[fen10];       
     
189.                 SMG_Int(i);                       
     
190.                 SMG_Int(0x08);               
     
191.        
     
192.                 STCP = 0;
     
193.                 _nop_();
     
194.                 _nop_();
     
195.                 STCP = 1;
     
196.        
     
197.                 //显示第5位        分钟个位
     
198.                 if(shan%4==0)         //
     
199.                 i = Table[15];
     
200.                 else
     
201.                 i = Table[fen];
     
202.        
     
203.                 SMG_Int(i);                       
     
204.                 SMG_Int(0x10);       
     
205.        
     
206.                 STCP = 0;
     
207.                 _nop_();
     
208.                 _nop_();
     
209.                 STCP = 1;
     
210.         }
     
211.         else
     
212.         {
     
213.                 i = Table[fen10];
     
214.        
     
215.                 SMG_Int(i);                       
     
216.                 SMG_Int(0x08);               
     
217.        
     
218.                 STCP = 0;
     
219.                 _nop_();
     
220.                 _nop_();
     
221.                 STCP = 1;
     
222.        
     
223.                 //显示第5位        分钟个位
     
224.                 i = Table[fen];
     
225.        
     
226.                 SMG_Int(i);                       
     
227.                 SMG_Int(0x10);       
     
228.        
     
229.                 STCP = 0;
     
230.                 _nop_();
     
231.                 _nop_();
     
232.                 STCP = 1;       
     
233.         }
     
234.         //显示第6位        -
     
235.         if(shan<10)           //"-" 闪烁
     
236.         i = Table[16];
     
237.         else
     
238.         i = Table[15];
     
239. 
     
240.         SMG_Int(i);                       
     
241.         SMG_Int(0x20);       
     
242. 
     
243.         STCP = 0;
     
244.         _nop_();
     
245.         _nop_();
     
246.         STCP = 1;
     
247. 
     
248.         if(knum==3)
     
249.         {
     
250.                 //显示第7位        秒10位
     
251.                 if(shan%4==0)         //
     
252.                 i = Table[15];
     
253.                 else
     
254.                 i = Table[miao10];
     
255.        
     
256.                 SMG_Int(i);                       
     
257.                 SMG_Int(0x40);       
     
258.        
     
259.                 STCP = 0;
     
260.                 _nop_();
     
261.                 _nop_();
     
262.                 STCP = 1;
     
263.        
     
264.                 //显示第8位        秒个位
     
265.                 if(shan%4==0)         //
     
266.                 i = Table[15];
     
267.                 else
     
268.                 i = Table[miao];
     
269.        
     
270.                 SMG_Int(i);               
     
271.                 SMG_Int(0x80);       
     
272.        
     
273.                 STCP = 0;
     
274.                 _nop_();
     
275.                 _nop_();
     
276.                 STCP = 1;
     
277.         }
     
278.         else
     
279.         {
     
280.                 //显示第7位        秒10位
     
281.                 i = Table[miao10];
     
282.        
     
283.                 SMG_Int(i);                       
     
284.                 SMG_Int(0x40);       
     
285.        
     
286.                 STCP = 0;
     
287.                 _nop_();
     
288.                 _nop_();
     
289.                 STCP = 1;
     
290.        
     
291.                 //显示第8位        秒个位
     
292.                 i = Table[miao];
     
293.        
     
294.                 SMG_Int(i);               
     
295.                 SMG_Int(0x80);       
     
296.        
     
297.                 STCP = 0;
     
298.                 _nop_();
     
299.                 _nop_();
     
300.                 STCP = 1;       
     
301.         }
     
302. }
     
303. 
     
304. void SMG_Int(uchar Dat)         //通过8次循环将8位数据移入74HC595
     
305. {
     
306.         uchar i;
     
307.         for(i=8;i>=1;i--)
     
308.         {
     
309.                 if (Dat & 0x80)
     
310.                 {
     
311.                         SER = 1;
     
312.                 }
     
313.                
     
314.                 else
     
315.                 {
     
316.                         SER = 0;
     
317.                 }
     
318.                 Dat <<= 1;
     
319.                 SHCP = 0;
     
320.                 _nop_();
     
321.                 _nop_();
     
322.                 SHCP = 1;
     
323.         }
     
324. }
     
325. 
     
326. void TimerInit()         //定时器0初始化
     
327. {
     
328.         TMOD = 0x01;
     
329.         TH0 = (65536-50000)/256;        //50ms初值
     
330.         TL0 = (65536-50000)%256;
     
331.         EA = 1;
     
332.         ET0 = 1;
     
333.         TR0 = 1;
     
334. 
     
335. }
     
336. 
     
337. void Timer0() interrupt 1
     
338. {
     
339.         static uchar cnt;
     
340.        
     
341.         TH0 = (65536-50000)/256;
     
342.         TL0 = (65536-50000)%256;
     
343.        
     
344.         shan++;
     
345.         if(shan==20)
     
346.                 shan=0;
     
347.         if(knum==0)
     
348.         {
     
349.                 cnt++;
     
350.                 if(cnt==20)
     
351.                 {
     
352.                         cnt = 0;
     
353.                         miao++;
     
354.                         if(miao == 60)
     
355.                         {
     
356.                                 miao = 0;
     
357.                                 fen++;
     
358.                                 if(fen==60)
     
359.                                 {
     
360.                                         fen = 0;
     
361.                                         shi++;
     
362.                                         if(shi==24)
     
363.                                         {
     
364.                                                 shi=0;
     
365.                                         }
     
366.                                 }
     
367.                         }
     
368.                 }
     
369.         }
     
370.         A=shi/10;
     
371.         K=shi%10;
     
372.         C=fen/10;
     
373.         D=fen%10;
     
374.         E=miao/10;
     
375.         F=miao%10;
     
376. }
     
377. 
     
378. 
     
379. 
     

复制代码

动画演示