单片机数码管万年历Proteus仿真+代码

宝上的，给大家共享



单片机源程序如下:

1. #include <reg52.h>                 //调用单片机头文件
   
2. #define uchar unsigned char  //无符号字符型 宏定义        变量范围0~255
   
3. #define uint  unsigned int         //无符号整型 宏定义        变量范围0~65535
   
4. 
   
5. #include "ds1302.h"
   
6. 
   
7. 
   
8. 
   
9. //数码管段选定义      0     1    2    3    4    5          6         7          8           9        
   
10. uchar code smg_du[]={0xa0,0x75,0x32,0x2a,0x32,0x25,0xb4,0xBa,0x20,0x28,
    
11.                                            0x30,0x25,0xe4,0x23,0x64,0x74,0xff};         //断码
    
12. 
    
13. 
    
14. //数码管位选定义
    
15. uchar code smg_we[]={0xfe,0xbf,0xfb,0xef,0xf7,0xdf,0xfd,0x7f};//数码管位选定义
    
16. uchar dis_smg[8] = {0xa0,0xbb,0x62,0x2a,0x39,0x2c,0x24,0xBa};        
    
17. uchar smg_i = 8;    //显示数码管的个位数
    
18. 
    
19. bit flag_200ms ;
    
20. bit flag_100ms ;
    
21. bit flag_500ms;     //500ms标志位
    
22. 
    
23. sbit beep = P3^7;          //蜂鸣器定义
    
24. bit flag_beep_en;
    
25. uint clock_value;     //用作闹钟用的
    
26. uchar flag_s = 0x03;//控制数码管闪烁的变量
    
27. 
    
28. sbit dq   = P3^1;          //18b20 IO口的定义
    
29. uint temperature ;    //温度变量
    
30. uchar flag_nl;        //农历 阳历显示标志位
    
31. 
    
32. uchar menu_1,menu_2,menu_i;
    
33. 
    
34. 
    
35. sbit dat0 = B^0;
    
36. sbit dat1 = B^1;
    
37. sbit dat2 = B^2;
    
38. sbit dat3 = B^3;
    
39. sbit dat4 = B^4;
    
40. sbit dat5 = B^5;
    
41. sbit dat6 = B^6;
    
42. sbit dat7 = B^7;
    
43. 
    
44. 
    
45. //控制数码管闪烁的函数
    
46. void smg_s(uchar dat)
    
47. {
    
48.         B = dat;
    
49.         if(dat0 == 1)
    
50.                 dis_smg[0] = 0xff;
    
51.         if(dat1 == 1)
    
52.                 dis_smg[1] = 0xff;
    
53.         if(dat2 == 1)
    
54.                 dis_smg[2] = 0xff;
    
55.         if(dat3 == 1)
    
56.                 dis_smg[3] = 0xff;
    
57.         if(dat4 == 1)
    
58.                 dis_smg[4] = 0xff;
    
59.         if(dat5 == 1)
    
60.                 dis_smg[5] = 0xff;
    
61.         if(dat6 == 1)
    
62.                 dis_smg[6] = 0xff;
    
63.         if(dat7 == 1)
    
64.                 dis_smg[7] = 0xff;
    
65. }
    
66. 
    
67. /***********************延时函数************************/
    
68. void delay_uint(uint q)
    
69. {
    
70.         while(q--);
    
71. }
    
72. 
    
73. /***********************1ms延时函数*****************************/
    
74. void delay_1ms(uint q)
    
75. {
    
76.         uint i,j;
    
77.         for(i=0;i<q;i++)
    
78.                 for(j=0;j<120;j++);
    
79. }
    
80. 
    
81. /********************独立按键程序*****************/
    
82. uchar key_can;         //按键值
    
83. 
    
84. void key()         //独立按键程序
    
85. {
    
86.         static uchar key_new;
    
87.         key_can = 20;                   //按键值还原
    
88.         P3 |= 0x78;                     //对应的按键IO口输出为1
    
89.         if((P3 & 0x78) != 0x78)                //按键按下
    
90.         {
    
91.                 delay_1ms(1);                     //按键消抖动
    
92.                 if(((P3 & 0x78) != 0x78) && (key_new == 1))
    
93.                 {                                                //确认是按键按下
    
94.                         key_new = 0;
    
95.                         switch(P3 & 0x78)
    
96.                         {
    
97.                                 case 0xe0:  key_can = 1;  break;         //得到按键值
    
98.                                 case 0x68:  key_can = 2;  break;         //得到按键值
    
99.                                 case 0x58:  key_can = 3;  break;         //得到按键值
    
100.                                 case 0x98:  key_can = 4;  break;         //得到按键值
     
101.                         }
     
102.                 }                        
     
103.         }
     
104.         else
     
105.                 key_new = 1;        
     
106. }
     
107. 
     
108. #include "menu.h"
     
109. 
     
110. 
     
111. /************菜单处理函数****************/
     
112. void menu_dis()
     
113. {
     
114.         if((menu_1 > 0) && (menu_2 == 0))         //选择键面
     
115.         {               
     
116.                 if(flag_500ms == 1)
     
117.                 {
     
118.                         dis_smg[0] = smg_du[1];          //1
     
119.                         dis_smg[1] = smg_du[10];  //A
     
120.                         dis_smg[2] = smg_du[2];          //2
     
121.                         dis_smg[3] = smg_du[10];  //A
     
122.                         dis_smg[4] = smg_du[3];          //3
     
123.                         dis_smg[5] = smg_du[10];  //A
     
124.                         dis_smg[6] = smg_du[4];          //4
     
125.                         dis_smg[7] = smg_du[10];  //A
     
126.                         smg_i = 8;
     
127.                 }
     
128.                 else
     
129.                         smg_s(flag_s);        
     
130.         }
     
131.         if((menu_1 == 1) && (menu_2 > 0))         //选设置时 分 秒
     
132.         {
     
133.                 smg_i = 8;
     
134.                 if(flag_500ms == 1)
     
135.                 {
     
136.                         dis_smg[0] = smg_du[miao % 16];   //显示秒
     
137.                         dis_smg[1] = smg_du[miao / 16];   //
     
138.                         dis_smg[2] = 0x7f;
     
139.                         dis_smg[3] = smg_du[fen % 16];   //显示分
     
140.                         dis_smg[4] = smg_du[fen / 16];   //
     
141.                         dis_smg[5] = 0x7f;
     
142.                         dis_smg[6] = smg_du[shi % 16];   //显示秒
     
143.                         dis_smg[7] = smg_du[shi / 16];   //
     
144.                 }
     
145.                 else
     
146.                         smg_s(flag_s);               
     
147.         }
     
148.         if((menu_1 == 2) && (menu_2 > 0))         //选设置年 月 日
     
149.         {
     
150.                 smg_i = 8;
     
151.                 if(flag_500ms == 1)
     
152.                 {
     
153.                         dis_smg[0] = smg_du[ri % 16];   //显示日
     
154.                         dis_smg[1] = smg_du[ri / 16];   //
     
155.                         dis_smg[2] = 0x7f;
     
156.                         dis_smg[3] = smg_du[yue % 16];   //显示月
     
157.                         dis_smg[4] = smg_du[yue / 16];   //
     
158.                         dis_smg[5] = 0x7f;
     
159.                         dis_smg[6] = smg_du[nian % 16];   //显示年
     
160.                         dis_smg[7] = smg_du[nian / 16];   //
     
161.                 }
     
162.         }
     
163.         if((menu_1 == 3) && (menu_2 > 0))         //设置星期 和 闹钟的开和关
     
164.         {
     
165.                 smg_i = 8;
     
166.                 if(flag_500ms == 1)
     
167.                 {
     
168.                         dis_smg[0] = smg_du[week % 16];   //显示星期
     
169.                         dis_smg[1] = smg_du[week / 16];   //
     
170.                         dis_smg[2] = 0x7f;
     
171.                         if(open1 == 1)           //开闹钟
     
172.                         {
     
173.                                 dis_smg[3] = 0xb0;           //OPEN
     
174.                                 dis_smg[4] = 0x64;   
     
175.                                 dis_smg[5] = 0x70;
     
176.                                 dis_smg[6] = 0xa0;   
     
177.                         }else
     
178.                         {
     
179.                                 dis_smg[3] = 0x74;           //OFF
     
180.                                 dis_smg[4] = 0x74;   
     
181.                                 dis_smg[5] = 0xa0;
     
182.                                 dis_smg[6] = 0xFF;   
     
183.                         }
     
184.                         dis_smg[7] = 0xff;   
     
185.                 }
     
186.         }
     
187.         if((menu_1 == 4) && (menu_2 > 0))         //选设置时 分 秒
     
188.         {
     
189.                 smg_i = 8;
     
190.                 if(flag_500ms == 1)
     
191.                 {
     
192.                         dis_smg[0] = 0xff;   //
     
193.                         dis_smg[1] = 0xff;   //
     
194.                         dis_smg[2] = smg_du[fen1 % 16];   //显示分
     
195.                         dis_smg[3] = smg_du[fen1 / 16];   //
     
196.                         dis_smg[4] = 0x7f;
     
197.                         dis_smg[5] = smg_du[shi1 % 16];   //显示秒
     
198.                         dis_smg[6] = smg_du[shi1 / 16];   //
     
199.                         dis_smg[7] = 0xff;
     
200.                 }
     
201.         }
     
202. 
     
203. }
     
204. 
     
205. /*************闹钟报警函数***************/
     
206. void clock_dis()
     
207. {
     
208.         static uchar mm,value;
     
209.         if(flag_100ms == 1)                  //100ms执行一次
     
210.         {
     
211.                 flag_100ms = 0;
     
212.                 if(open1 == 1)        //如果闹钟打开
     
213.                 {
     
214.                         if((miao == 0) && (fen == fen1) && (shi == shi1))
     
215.                         {               
     
216.                                 flag_beep_en = 1;        //有报警 打开蜂鸣器响的标志位                                
     
217.                         }               
     
218.                         if(flag_beep_en == 1)        //闹钟以被打开
     
219.                         {
     
220.                                 clock_value++;
     
221.                                 if(clock_value <= 30)         
     
222.                                         beep = ~beep;           //蜂鸣器叫3秒
     
223.                                 else if(clock_value > 30)
     
224.                                 {
     
225.                                         beep = 1;                    //蜂鸣器停1秒
     
226.                                         if(clock_value > 40)
     
227.                                         {
     
228.                                                 clock_value = 0;
     
229. 
     
230.                                         }
     
231.                                 }
     
232.                         }
     
233.                 }        
     
234.         }
     
235. }
     
236. 
     
237. /*************定时器0初始化程序***************/
     
238. void time_init()         
     
239. {
     
240.         EA   = 1;                   //开总中断
     
241.         TMOD = 0X01;          //定时器0、工作方式1
     
242.         ET0  = 1;                  //开定时器0中断
     
243.         TR0  = 1;                  //允许定时器0定时
     
244. }
     
245. 
     
246. /***********************18b20初始化函数*****************************/
     
247. void init_18b20()
     
248. {
     
249.         bit q;
     
250.         dq = 1;                                //把总线拿高
     
251.         delay_uint(1);            //15us
     
252.         dq = 0;                                //给复位脉冲
     
253.         delay_uint(80);                //750us
     
254.         dq = 1;                                //把总线拿高 等待
     
255.         delay_uint(10);                //110us
     
256.         q = dq;                                //读取18b20初始化信号
     
257.         delay_uint(20);                //200us
     
258.         dq = 1;                                //把总线拿高 释放总线
     
259. }
     
260. 
     
261. /*************写18b20内的数据***************/
     
262. void write_18b20(uchar dat)
     
263. {
     
264.         uchar i;
     
265.         for(i=0;i<8;i++)
     
266.         {                                         //写数据是低位开始
     
267.                 dq = 0;                         //把总线拿低写时间隙开始
     
268.                 dq = dat & 0x01; //向18b20总线写数据了
     
269.                 delay_uint(5);         // 60us
     
270.                 dq = 1;                         //释放总线
     
271.                 dat >>= 1;
     
272.         }        
     
273. }
     
274. 
     
275. /*************读取18b20内的数据***************/
     
276. uchar read_18b20()
     
277. {
     
278.         uchar i,value;
     
279.         for(i=0;i<8;i++)
     
280.         {
     
281.                 dq = 0;                         //把总线拿低读时间隙开始
     
282.                 value >>= 1;         //读数据是低位开始
     
283.                 dq = 1;                         //释放总线
     
284.                 if(dq == 1)                 //开始读写数据
     
285.                         value |= 0x80;
     
286.                 delay_uint(5);         //60us        读一个时间隙最少要保持60us的时间
     
287.         }
     
288.         return value;                 //返回数据
     
289. }
     
290. 
     
291. /*************读取温度的值 读出来的是小数***************/
     
292. uint read_temp()
     
293. {
     
294.         uint value;
     
295.         uchar low;                           //在读取温度的时候如果中断的太频繁了，就应该把中断给关了，否则会影响到18b20的时序
     
296.         init_18b20();                   //初始化18b20
     
297.         write_18b20(0xcc);           //跳过64位ROM
     
298.         write_18b20(0x44);           //启动一次温度转换命令
     
299.         delay_uint(50);                   //500us
     
300. 
     
301.         init_18b20();                   //初始化18b20
     
302.         
     
303.         write_18b20(0xcc);           //跳过64位ROM
     
304.         write_18b20(0xbe);           //发出读取暂存器命令
     
305.         
     
306.         EA = 0;
     
307.         low = read_18b20();           //读温度低字节
     
308.         value = read_18b20();  //读温度高字节
     
309.         EA = 1;
     
310.         value <<= 8;                   //把温度的高位左移8位
     
311.         value |= low;                   //把读出的温度低位放到value的低八位中
     
312.         value *= 0.625;               //转换到温度值 小数
     
313.         return value;                   //返回读出的温度 带小数
     
314. }
     
315. 
     
316. /*************时钟显示***************/
     
317. void init_1602_ds1302()
     
318. {
     
319.         static uchar value;
     
320.         smg_i = 8;
     
321.         value ++;
     
322.         if(value <= 5*2)  //2秒
     
323.         {
     
324.                 dis_smg[0] = smg_du[miao % 16];   //显示秒
     
325.                 dis_smg[1] = smg_du[miao / 16];   //
     
326.                 dis_smg[2] = 0x3f;
     
327.                 dis_smg[3] = smg_du[fen % 16];   //显示分
     
328.                 dis_smg[4] = smg_du[fen / 16];   //
     
329.                 dis_smg[5] = 0x3f;
     
330.                 dis_smg[6] = smg_du[shi % 16];   //显示秒
     
331.                 dis_smg[7] = smg_du[shi / 16];   //
     
332.         }
     
333.         else if(value <= 5*4)  //2秒
     
334.         {
     
335.                 dis_smg[0] = smg_du[ri % 16];   //显示日
     
336.                 dis_smg[1] = smg_du[ri / 16];   //
     
337.                 dis_smg[2] = 0x7f;
     
338.                 dis_smg[3] = smg_du[yue % 16];   //显示月
     
339.                 dis_smg[4] = smg_du[yue / 16];   //
     
340.                 dis_smg[5] = 0x7f;
     
341.                 dis_smg[6] = smg_du[nian % 16];   //显示年
     
342.                 dis_smg[7] = smg_du[nian / 16];   //
     
343.         }
     
344.         else if(value <= 5*6)  //2秒
     
345.         {
     
346.                 dis_smg[0] = smg_du[week % 16];   //显示星期
     
347.                 dis_smg[1] = smg_du[week / 16];   //
     
348.                 dis_smg[2] = 0xff;               
     
349.                 dis_smg[3] = smg_du[12];               
     
350.                 dis_smg[4] = smg_du[temperature % 10] ;   //
     
351.                 dis_smg[6] = smg_du[temperature / 100 % 10];   
     
352.                 dis_smg[7] = 0xff;
     
353.         }
     
354.         else
     
355.                 value = 0;
     
356. }
     
357. 
     
358. /*****************主函数********************/
     
359. void main()
     
360. {        
     
361.         init_ds1302();                 //ds1302初始化
     
362.         time_init();   //定时器初始化
     
363.         init_menu();
     
364.         while(1)
     
365.         {
     
366.                 key();                         //按键程序
     
367.                 if(key_can < 10)
     
368.                 {
     
369.                         key_with();        
     
370.                 }
     
371. 
     
372.                 if(flag_200ms == 1)
     
373.                 {        
     
374.                         flag_200ms = 0;
     
375.                         if(menu_1 == 0)
     
376.                         {
     
377.                                 read_time();                  //读时间
     
378.                                 temperature = read_temp();        //先读出温度的值
     
379.                                 init_1602_ds1302();   //显示时钟
     
380.                         }
     
381.                 }
     
382.                 menu_dis();          //设置的对应的显示处理
     
383.                 clock_dis();  //闹钟报警函数
     
384.                 delay_1ms(1);
     
385.         }
     
386. }
     
387. 
     
388. /*************定时器0中断服务程序***************/
     
389. void time0_int() interrupt 1
     
390. {        
     
391.         static uint value;
     
392.         static uchar ii;
     
393.         TH0 = 0xF8;
     
394.         TL0 = 0x30;     // 2ms         12M
     
395. 
     
396.     value ++;
     
397.         if((value % 50) == 0)         //100ms  
     
398.                 flag_100ms = 1;         
     
399.         if(value >= 250)
     
400.         {
     
401.                 value = 0;
     
402.                 flag_500ms = ~flag_500ms;
     
403.         }
     
404. 
     
405.         P0 = 0xff;                         //消隐
     
406.         P2 = smg_we[ii];                          //位选
     
407.         P0 = dis_smg[ii];                 //段选            
     
408.                
     
409.         ii++;
     
410.         if(ii >= smg_i)
     
411.                 ii = 0;        
     
412.         
     
413. }
     

复制代码

所有资料51hei提供下载:
单片机万年历数码管显示 发送资料 SMG.7z (3.28 MB, 下载次数: 88)

2019-5-27 02:36 上传

点击文件名下载附件

小白，想请问以下这个是AT89C51单片机吗？