Proteus仿真单片机继电器家电控制程序

仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）


单片机源程序如下:

1. #include  "reg52.h"
   
2. #include "lcd1602.h"
   
3. #include <intrins.h>
   
4. #define uchar unsigned char
   
5. #define uint unsigned int
   
6. //继电器控制io
   
7. sbit j1= P3^0;
   
8. sbit j2= P3^1;      
   
9. sbit j3= P3^2;      
   
10. //---ds1302  IO---//
    
11. sbit DSIO=P3^5;
    
12. sbit RST=P3^3;
    
13. sbit SCLK=P3^4;
    
14. //---DS1302写入和读取时分秒的地址命令---//
    
15. //---秒分时日月周年 最低位读写位;-------//
    
16. uchar code READ_RTC_ADDR[7] = {0x81, 0x83, 0x85, 0x87, 0x89, 0x8b, 0x8d};
    
17. uchar code WRITE_RTC_ADDR[7] = {0x80, 0x82, 0x84, 0x86, 0x88, 0x8a, 0x8c};
    
18. //---DS1302时钟初始化2013年1月1日星期二12点00分00秒。---//
    
19. //---存储顺序是秒分时日月周年,存储格式是用BCD码---//
    
20. uchar TIME[7] = {0x49, 0x49, 0x05, 0x01, 0x01, 0x02, 0x13};
    
21. 
    
22. unsigned table[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f};
    
23. unsigned char number=0;
    
24. /********************************************************************
    
25.                             延时函数
    
26. *********************************************************************/
    
27. void delay10ms(void) //延时程序
    
28. {
    
29.         unsigned char i,j;
    
30.         for(i=20;i>0;i--)
    
31.         for(j=248;j>0;j--);
    
32. }
    
33. /*******************************************************************************
    
34. * 函 数 名         : Ds1302Write
    
35. * 函数功能                   : 向DS1302命令（地址+数据）
    
36. * 输    入         : addr,dat
    
37. * 输    出         : 无
    
38. *******************************************************************************/
    
39. void Ds1302Write(uchar addr, uchar dat)
    
40. {
    
41.         uchar n;
    
42.         RST = 0;
    
43.         _nop_();
    
44. 
    
45.         SCLK = 0;//先将SCLK置低电平。
    
46.         _nop_();
    
47.         RST = 1; //然后将RST(CE)置高电平。
    
48.         _nop_();
    
49. 
    
50.         for (n=0; n<8; n++)//开始传送八位地址命令
    
51.         {
    
52.                 DSIO = addr & 0x01;//数据从低位开始传送
    
53.                 addr >>= 1;
    
54.                 SCLK = 1;//数据在上升沿时，DS1302读取数据
    
55.                 _nop_();
    
56.                 SCLK = 0;
    
57.                 _nop_();
    
58.         }
    
59.         for (n=0; n<8; n++)//写入8位数据
    
60.         {
    
61.                 DSIO = dat & 0x01;
    
62.                 dat >>= 1;
    
63.                 SCLK = 1;//数据在上升沿时，DS1302读取数据
    
64.                 _nop_();
    
65.                 SCLK = 0;
    
66.                 _nop_();      
    
67.         }      
    
68.                  
    
69.         RST = 0;//传送数据结束
    
70.         _nop_();
    
71. }
    
72. 
    
73. /*******************************************************************************
    
74. * 函 数 名         : Ds1302Read
    
75. * 函数功能                   : 读取一个地址的数据
    
76. * 输    入         : addr
    
77. * 输    出         : dat
    
78. *******************************************************************************/
    
79. 
    
80. uchar Ds1302Read(uchar addr)
    
81. {
    
82.         uchar n,dat,dat1;
    
83.         RST = 0;
    
84.         _nop_();
    
85. 
    
86.         SCLK = 0;//先将SCLK置低电平。
    
87.         _nop_();
    
88.         RST = 1;//然后将RST(CE)置高电平。
    
89.         _nop_();
    
90. 
    
91.         for(n=0; n<8; n++)//开始传送八位地址命令
    
92.         {
    
93.                 DSIO = addr & 0x01;//数据从低位开始传送
    
94.                 addr >>= 1;
    
95.                 SCLK = 1;//数据在上升沿时，DS1302读取数据
    
96.                 _nop_();
    
97.                 SCLK = 0;//DS1302下降沿时，放置数据
    
98.                 _nop_();
    
99.         }
    
100.         _nop_();
     
101.         for(n=0; n<8; n++)//读取8位数据
     
102.         {
     
103.                 dat1 = DSIO;//从最低位开始接收
     
104.                 dat = (dat>>1) | (dat1<<7);
     
105.                 SCLK = 1;
     
106.                 _nop_();
     
107.                 SCLK = 0;//DS1302下降沿时，放置数据
     
108.                 _nop_();
     
109.         }
     
110. 
     
111.         RST = 0;
     
112.         _nop_();        //以下为DS1302复位的稳定时间,必须的。
     
113.         SCLK = 1;
     
114.         _nop_();
     
115.         DSIO = 0;
     
116.         _nop_();
     
117.         DSIO = 1;
     
118.         _nop_();
     
119.         return dat;      
     
120. }
     
121. 
     
122. /*******************************************************************************
     
123. * 函 数 名         : Ds1302Init
     
124. * 函数功能                   : 初始化DS1302.
     
125. * 输    入         : 无
     
126. * 输    出         : 无
     
127. *******************************************************************************/
     
128. 
     
129. void Ds1302Init()
     
130. {
     
131.         uchar n;
     
132.         Ds1302Write(0x8E,0X00);                 //禁止写保护，就是关闭写保护功能
     
133.         for (n=0; n<7; n++)//写入7个字节的时钟信号：分秒时日月周年
     
134.         {
     
135.                 Ds1302Write(WRITE_RTC_ADDR[n],TIME[n]);      
     
136.         }
     
137.         Ds1302Write(0x8E,0x80);                 //打开写保护功能
     
138. }
     
139. 
     
140. /*******************************************************************************
     
141. * 函 数 名         : Ds1302ReadTime
     
142. * 函数功能                   : 读取时钟信息
     
143. * 输    入         : 无
     
144. * 输    出         : 无
     
145. *******************************************************************************/
     
146. void Ds1302ReadTime()
     
147. {
     
148.         uchar n;
     
149.         for (n=0; n<7; n++)//读取7个字节的时钟信号：分秒时日月周年
     
150.         {
     
151.                 TIME[n] = Ds1302Read(READ_RTC_ADDR[n]);
     
152.         }               
     
153. }
     
154. /********************************************************************
     
155.                             键盘函数
     
156. *********************************************************************/  
     
157. uchar k=0;
     
158. uchar mode=2;
     
159. uchar time1;
     
160. 
     
161. void Getch (void)        //取键值函数
     
162. {
     
163. unsigned char X,Y,Z;
     
164. P1=0x0f; //先对P3 置数 行扫描
     
165. if(P1!=0x0f) //判断是否有键按下
     
166.         {
     
167.         delay10ms(); //延时,软件去干扰
     
168.         if(P1!=0x0f) //确认按键按下
     
169.                 {
     
170.                 X=P1; //保存行扫描时有键按下时状态
     
171.                 P1=0xf0; //列扫描
     
172.                 Y=P1;    //保存列扫描时有键按下时状态
     
173.                 Z=X|Y; //取出键值
     
174. /*********************************************************************/
     
175. switch ( Z ) //判断键值（那一个键按下）
     
176.                         {
     
177.                                 case 0xee: k=0; break; //对键值赋值
     
178.                                 case 0xed: k=1; break;
     
179.                                 case 0xeb: k=2; break;
     
180.                                 case 0xe7: k=3; break;
     
181.                                 case 0xde: k=4; break;
     
182.                                 case 0xdd: k=5; break;
     
183.                                 case 0xdb: k=6; break;
     
184.                                 case 0xd7: k=7; break;
     
185.                                 case 0xbe: k=8; break;
     
186.                                 case 0xbd: k=9; break;
     
187.                                 case 0xbb: k=10;break;
     
188.                                 case 0xb7: k=11;break;
     
189.                                 case 0x7e: k=12;break;
     
190.                                 case 0x7d: k=13;break;
     
191.                                 case 0x7b: k=14;break;
     
192.                                 case 0x77: k=15;break;
     
193.                         }
     
194.                         while(P1!=0xf0);  //等待按键放开
     
195.                  }         
     
196.          }
     
197. }
     
198. 
     
199. uchar j1_time[2]={0x05,0x50};
     
200. uchar j2_time_on[2]={0x05,0x51};
     
201. uchar j2_time_off[2]={0x05,0x52};
     
202. uchar j3_time[2]={0x05,0x52};
     
203. void sel_time(void) //选择模式
     
204. {
     
205.         uchar buff[9];
     
206.         static uchar temp[4];
     
207.         static uchar num=0;
     
208.         if(k==12) {
     
209.                 time1=1;
     
210.                 GotoXY(0,1);               
     
211.                 Print("          ");
     
212.                 GotoXY(0,1);               
     
213.                 Print("1: ");        }
     
214.         if(k==13) {
     
215.                 time1=2;
     
216.                 GotoXY(0,1);               
     
217.                 Print("          ");
     
218.                 GotoXY(0,1);               
     
219.                 Print("2: ");        }
     
220.         if(k==14) {
     
221.                 time1=3;
     
222.                 GotoXY(0,1);               
     
223.                 Print("          ");
     
224.                 GotoXY(0,1);               
     
225.                 Print("3: ");        }
     
226.         if(k==15) {
     
227.                 time1=4;
     
228.                 GotoXY(0,1);               
     
229.                 Print("          ");
     
230.                 GotoXY(0,1);               
     
231.                 Print("4: ");        }
     
232.         if(time1==1)
     
233.         {
     
234.                 if(k<10)
     
235.                 {
     
236.                         temp[num]=k;               
     
237.                         num++;
     
238.                         if(num>=4)
     
239.                         {
     
240.                               
     
241.                                 j1_time[0]=temp[0]*16+temp[1];
     
242.         j1_time[1]=temp[2]*16+temp[3];
     
243.                                 GotoXY(4,1);
     
244.                                 buff[0]=j1_time[0]/16 + '0';
     
245.                                 buff[1]=j1_time[0]%16 + '0';
     
246.                                 buff[2]=j1_time[1]/16 + '0';
     
247.                                 buff[3]=j1_time[1]%16 + '0';
     
248.                                 buff[4]='\0';
     
249.                                 Print(buff);
     
250.                                 num=0;
     
251.                                 time1=0;
     
252.                         }
     
253.                         k=22;
     
254.                 }
     
255.         }
     
256.         if(time1==2)
     
257.         {
     
258.                 if(k<10)
     
259.                 {
     
260.                         temp[num]=k;
     
261.                         num++;
     
262.                         if(num>=4)
     
263.                         {
     
264.                                 j2_time_on[0]=temp[0]*16+temp[1];
     
265.         j2_time_on[1]=temp[2]*16+temp[3];
     
266.                                         GotoXY(4,1);
     
267.                                 buff[0]=j2_time_on[0]/16 + '0';
     
268.                                 buff[1]=j2_time_on[0]%16 + '0';
     
269.                                 buff[2]=j2_time_on[1]/16 + '0';
     
270.                                 buff[3]=j2_time_on[1]%16 + '0';
     
271.                                 buff[4]='\0';
     
272.                                 Print(buff);
     
273.                                 num=0;
     
274.                                 time1=0;
     
275.                         }
     
276.                 }
     
277.                 k=22;
     
278.         }      
     
279.         if(time1==3)
     
280.         {
     
281.                 if(k<10)
     
282.                 {
     
283.                         temp[num]=k;
     
284.                         num++;
     
285.                         if(num>=4)
     
286.                         {
     
287.                                 j2_time_off[0]=temp[0]*16+temp[1];
     
288.         j2_time_off[1]=temp[2]*16+temp[3];
     
289.                                         GotoXY(4,1);
     
290.                                 buff[0]=j2_time_off[0]/16 + '0';
     
291.                                 buff[1]=j2_time_off[0]%16 + '0';
     
292.                                 buff[2]=j2_time_off[1]/16 + '0';
     
293.                                 buff[3]=j2_time_off[1]%16 + '0';
     
294.                                 buff[4]='\0';
     
295.                                 Print(buff);
     
296.                                 num=0;
     
297.                                 time1=0;
     
298.                         }
     
299.                         k=22;
     
300.                 }
     
301.         }
     
302.                 if(time1==4)
     
303.         {
     
304.                 if(k<10)
     
305.                 {
     
306.                         temp[num]=k;
     
307.                         num++;
     
308.                         if(num>=4)
     
309.                         {
     
310.                                 j3_time[0]=temp[0]*16+temp[1];
     
311.         j3_time[1]=temp[2]*16+temp[3];
     
312.                                         GotoXY(4,1);
     
313.                                 buff[0]=j3_time[0]/16 + '0';
     
314.                                 buff[1]=j3_time[0]%16 + '0';
     
315.                                 buff[2]=j3_time[1]/16 + '0';
     
316.                                 buff[3]=j3_time[1]%16 + '0';
     
317.                                 buff[4]='\0';
     
318.                                 Print(buff);
     
319.                                 num=0;
     
320.                                 time1=0;
     
321.                         }
     
322.                 }
     
323.                 k=22;
     
324.         }               
     
325. }
     
326. 
     
327. void j_control(void) //控制继电器
     
328. {
     
329.         if((j1_time[0] == TIME[2])&&(j1_time[1] == TIME[1]))
     
330.         {
     
331.           j1=0;
     
332.         }
     
333.                 if((j2_time_on[0] == TIME[2])&&(j2_time_on[1] == TIME[1]))
     
334.         {
     
335. 
     
336.         j2=0;
     
337.         }
     
338.                         if((j2_time_off[0] == TIME[2])&&(j2_time_off[1] == TIME[1]))
     
339.         {
     
340. 
     
341.         j2=1;
     
342.         }
     
343.                 if((j3_time[0] == TIME[2])&&(j3_time[1] == TIME[1]))
     
344.         {
     
345. 
     
346.          j3=0;
     
347.         }
     
348. }
     
349. void TimeToStr(unsigned char *buf)
     
350. {
     
351.         buf[0] = TIME[2]/16 + '0';
     
352.         buf[1] = TIME[2]%16 + '0';
     
353.         buf[2] = ':';
     
354.         buf[3] = TIME[1]/16 + '0';
     
355.         buf[4] = TIME[1]%16 + '0';
     
356.         buf[5] = ':';
     
357.         buf[6] = TIME[0]/16 + '0';
     
358.         buf[7] = TIME[0]%16 + '0';
     
359.         buf[8] = '\0';
     
360. }
     
361. 
     
362. 
     
363. void main(void)
     
364. {
     
365. unsigned char time_buf[9];
     
366. Ds1302Init(); //写入设置的时间      
     
367. LCD_Initial();
     
368. GotoXY(0,0);
     
369. Print("Time: ");      
     
370. while(1)
     
371. {
     
372.   Getch();
     
373.         sel_time();
     
374.   Ds1302ReadTime();  //读时间
     
375.         TimeToStr(time_buf);
     
376.   j_control();
     
377.         GotoXY(6,0);
     
378.         Print(time_buf);
     
379. }
     
380. }
     
381. 
     

复制代码

所有资料51hei提供下载:
家电控制.rar (98.36 KB, 下载次数: 33)

2020-6-5 13:20 上传

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