单片机电子密码锁电路程序带仿真，调试通过lcd1602+24C02

调试通过，，，电子密码锁，，，资料，，，，分享
lcd1602液晶屏显示 并且用24c02保存数据

仿真图 电路图（proteus仿真文件可以从51黑本贴附件下载）


全部资料（压缩包）下载：
密码锁单片机源程序仿真.zip (128 KB, 下载次数: 380)

2016-4-24 19:34 上传

点击文件名下载附件



S0-S9为密码数字键；
S10为删除键，删除上一次输入的数字；
S11为清除键，清除所有输入的数字；
S12为确认键，输入密码后按确认键确认密码是否输入正确；
S13为密码修改键。
S1-S10键按下5秒后，没有其他键按下，则发出报警声，声音持续10s；
输入密码后按确认键，若密码正确，则绿灯亮，否则则红灯亮。

下面是部分程序预览（完整版本请下载本帖附件）：

1. //S1-S9为数字密码输入键0-9
   
2. //S10-S13为功能键
   
3. //S10为单个数字删除键，S11为所以数字清除键，S12为密码确认键，S13为修改密码键
   
4. #include<reg52.h>   //包含头文件
   
5. #include"IIC.h"     //包含IIC总线头文件
   
6. #include"1602.h"    //包含1602头文件
   
7. #include"keyboard.h"    //包含键盘扫描头文件
   
8. 
   
9. sbit led_red=P2^5;  //位定义绿灯，密码输入正确时显示
   
10. sbit led_gre=P2^6;  //位定义红灯，密码输入错误时显示
    
11. sbit spk=P2^7;
    
12. 
    
13. uchar ASC[]={'0','1','2','3','4','5','6','7','8','9'};  //将数字转换成字符型数据供1602显示
    
14. 
    
15. uchar one=0,two=1,three=2,four=3;      //初始密码0123
    
16. 
    
17. uint t0,t1;     //定时器0、1分别溢出的次数
    
18. 
    
19. void Init_time0(void)   //定时器0初始化函数   
    
20. {
    
21.     TMOD=0x11;
    
22.     TH0=(65535-50000)/256;
    
23.     TL0=(65535-50000)%256;
    
24.     TH1=(65535-2000)/256;
    
25.     TL1=(65535-2000)%256;
    
26.     EA=1;
    
27.     ET0=1;
    
28.     ET1=1;
    
29.     TR0=0;
    
30.     TR1=0;
    
31. }
    
32. 
    
33. void main(void)     //主函数
    
34. {
    
35.     uchar flag=0,cflag=0;
    
36. //flag、cflag分别为修改密码标志和修改密码时初始密码输入正确标志（输入新密码标志）
    
37.     uchar i=0,k=0;
    
38. //i为输入密码时输入数字密码的个数
    
39. //k为修改密码时输入数字密码的个数
    
40.     uchar j=0,t=0,shu=1;
    
41. //j用于for循环中判断输入密码和存储密码对比
    
42. //t=0为进入修改密码状态，只要是为了修改密码时的初始显示
    
43. //shu用于输入新密码时，四位密码的地址
    
44.     uchar num,newpassword[4];
    
45. //num为按键值，newpassword数组存放每次输入的数字密码S0-S13和0-13对应
    
46.     Init_IIC();     //初始化IIC
    
47.     Init_1602();    //初始化1602
    
48.     Init_time0();   //初始化定时器0
    
49. 
    
50.     led_red=0;      //熄灭绿灯和红灯
    
51.     led_gre=0;
    
52.     spk=0;
    
53. 
    
54.     write_add(1,one);   //写入初始密码0123到E2PROM
    
55.     delay_ms(5);
    
56.     write_add(2,two);
    
57.     delay_ms(5);
    
58.     write_add(3,three);
    
59.     delay_ms(5);
    
60.     write_add(4,four);
    
61.     delay_ms(5);
    
62. 
    
63.     displaylistchar(0,0,"Input Password:");     //1602初始化后显示Input Password:
    
64. 
    
65.     while(1)
    
66.     {
    
67. /*检测是否有按键按下，若没有则不停扫描*/
    
68.         num=KeyPro();   //扫描按键
    
69. 
    
70.         if(num!=0xff)   //如果有键按下
    
71.         {
    
72. /*******************************************************************************************/
    
73. /*输入密码*/
    
74.             if((num!=13)&&(flag==0))    //S13为修改密码键，flag为修改密码标志，flag=1时修改密码，判断是否修改密码
    
75.             {
    
76.                 displaylistchar(0,0,"Input Password:");
    
77. 
    
78.                 if(num>=0&&num<=9)  //如果是0-9按下，则输入0-9并在液晶上显示0-9
    
79.                 {
    
80.                     TR0=~TR0;   //若按键后五秒内没有打开锁，则报警
    
81.                     t0=0;
    
82.                     displayonechar(i,1,ASC[num]);   //显示输入的数字密码
    
83.                     newpassword[i++]=num;        
    
84.                 }
    
85.    
    
86.                 if(num==10)     //如果10按下，在有数字输入的情况下删除上次输入的数字
    
87.                 {
    
88.                     TR0=~TR0;   //若按键后五秒内没有打开锁，则报警
    
89.                     t0=0;
    
90.                     if(i>0)
    
91.                     {
    
92.                         i=i-1;
    
93.                         displayonechar(i,1,' ');
    
94.                     }
    
95.                 }
    
96.    
    
97.                 if(num==11)     //如果是11按下，清除所有输入的数据，重新输入
    
98.                 {
    
99.                     TR0=0;
    
100.                     i=0;
     
101.                     displaylistchar(0,1,"                ");//清除该行
     
102.                 }
     
103.    
     
104.                 if(num==12)     //确认键，如果密码正确，则绿灯亮红灯熄，否则则红灯亮绿灯熄
     
105.                 {
     
106.                     TR0=0;
     
107.                     if(i==4)    //四位密码，所以只在输入四个密码的情况下检测密码是否正确
     
108.                     {
     
109.                         for(j=0;j<4;j++)
     
110.                         {
     
111.                             if(newpassword[j]!=read_add(j+1))   //输入的密码和存储的密码对比，若有一个错误，则跳出密码对比
     
112.                                 break;
     
113.                         }
     
114.                         if(j==i)    //若j=i成立，则密码正确
     
115.                         {                                               
     
116.                             led_gre=1;  //亮绿灯
     
117.                             led_red=0;
     
118.                             displaylistchar(0,1,"Right Open!");     //显示输入正确
     
119.                             delay_ms(1000);
     
120.                             i=0;    //按键输入数置0
     
121.                             displaylistchar(0,1,"                ");//清除该行
     
122.                         }
     
123.                         else        //若不成立则密码不正确
     
124.                         {
     
125.                             led_gre=0;      //亮红灯
     
126.                             led_red=1;
     
127.                             displaylistchar(0,1,"Wrong Retry!");     //显示输入错误
     
128.                             delay_ms(1000);
     
129.                             i=0;    //按键输入数置0
     
130.                             displaylistchar(0,1,"                ");//清除该行
     
131.                         }
     
132.                     }
     
133. 
     
134.                     else        //若按键输入数i不等于4，则密码肯定错误
     
135.                     {
     
136.                         led_gre=0;      //亮红灯
     
137.                         led_red=1;
     
138.                         displaylistchar(0,1,"Wrong Retry!");        //显示输入错误
     
139.                         delay_ms(1000);
     
140.                         i=0;     //按键输入数置0
     
141.                         displaylistchar(0,1,"                ");//清除该行
     
142.                     }
     
143.                 }
     
144.    
     
145.                 if(i==6)    //虚设六位密码，数字按键输入六次后还没有按确定的话，则提示密码错误
     
146.                 {
     
147.                     TR0=0;
     
148.                     led_gre=0;        //亮红灯
     
149.                     led_red=1;
     
150.                     displaylistchar(0,1,"Wrong Retry!");        //显示输入错误
     
151.                     delay_ms(1000);
     
152.                     i=0;       //按键输入数置0
     
153.                     displaylistchar(0,1,"                ");//清除该行
     
154.                 }
     
155.             }
     
156. /*******************************************************************************************/
     
157. /*******************************************************************************************/
     
158. /*修改密码*/
     
159.             else               //有S13键按下或修改密码标志flag置1
     
160.             {
     
161.                 if(cflag==0)    //修改密码时初始密码输入正确标志cflag置0时为输入初始密码检测状态，类似前面的密码输入   
     
162.                 {
     
163.                     i=0;        //按键输入数置0
     
164.                     flag=1;     //S13键按下，修改密码标志置1
     
165.                     if(t==0)    //t=0为进入修改密码状态，只要是为了修改密码时的初始显示
     
166.                     {
     
167.                         displaylistchar(0,0,"Change Password:");
     
168.                         delay_ms(500);
     
169.                         displaylistchar(0,1,"Old Password:");
     
170.                         delay_ms(500);     
     
171.                         displaylistchar(0,1,"                ");//清除该行
     
172.                     }
     
173.                     t++;        //正在修改密码状态，则不用再次进入修改密码状态
     
174.                     if(num>=0&&num<=9)  //如果是0-9按下，则输入0-9并在液晶上显示0-9
     
175.                     {
     
176.                         TR0=~TR0;   //若按键后五秒内没有打开锁，则报警
     
177.                         t0=0;
     
178.                         displayonechar(k,1,ASC[num]);
     
179.                         newpassword[k++]=num;        
     
180.                     }
     
181.         
     
182.                     if(num==10)     //单个密码删除键，和输入密码时一样
     
183.                     {
     
184.                         TR0=~TR0;   //若按键后五秒内没有打开锁，则报警
     
185.                         t0=0;
     
186.                         if(k>0)
     
187.                         {
     
188.                             k=k-1;
     
189.                             displayonechar(i,1,' ');
     
190.                         }
     
191.                     }
     
192.         
     
193.                     if(num==11)     //所以密码清除键，和输入密码时一样
     
194.                     {
     
195.                         TR0=0;
     
196.                         k=0;
     
197.                         flag=0;
     
198.                         displaylistchar(0,1,"                ");//清除该行
     
199.                     }  
     
200.    
     
201.                     if(num==12)     //确认键，和输入密码时一样
     
202.                     {
     
203.                         TR0=0;
     
204.                         if(k==4)
     
205.                         {
     
206.                             for(j=0;j<4;j++)
     
207.                             {
     
208.                                 if(newpassword[j]!=read_add(j+1))
     
209.                                     break;
     
210.                             }
     
211.                             if(j==k)        //若初始密码输入正确后提示输入新密码，并将输入新密码标志cflag置1
     
212.                             {                                               
     
213.                                 led_gre=1;
     
214.                                 led_red=0;
     
215.                                 displaylistchar(0,1,"Right Open!");
     
216.                                 delay_ms(500);
     
217.                                 displaylistchar(0,1,"                ");//清除该行
     
218.                                 displaylistchar(0,1,"New Password:");
     
219.                                 delay_ms(500);
     
220.                                 displaylistchar(0,1,"                ");//清除该行
     
221.                                 k=0;
     
222.                                 cflag=1;
     
223.                             }
     
224.                             else        //若输入错误，则跳出密码修改，flag=0
     
225.                             {
     
226.                                 led_gre=0;
     
227.                                 led_red=1;
     
228.                                 displaylistchar(0,1,"Wrong Retry!");
     
229.                                 delay_ms(1000);
     
230.                                 k=0;
     
231.                                 flag=0;
     
232.                                 displaylistchar(0,1,"                ");//清除该行
     
233.                                 displaylistchar(0,0,"                ");//清除该行
     
234.                                 displaylistchar(0,0,"Input Password:");
     
235.                             }
     
236.                         }
     
237.                         else    //修改密码时输入原密码数不等于4，显然密码错误，跳出密码修改
     
238.                         {
     
239.                             led_gre=0;
     
240.                             led_red=1;
     
241.                             displaylistchar(0,1,"Wrong Retry!");
     
242.                             delay_ms(1000);
     
243.                             k=0;
     
244.                             flag=0;
     
245.                             displaylistchar(0,1,"                ");//清除该行
     
246.                             displaylistchar(0,0,"                ");//清除该行
     
247.                             displaylistchar(0,0,"Input Password:");
     
248.    
     
249.                         }
     
250.                     }
     
251.                     if(k==6)    //数字按键输入六次后还没有按确定的话，则提示密码错误 ，跳出密码修改
     
252.                     {
     
253.                         TR0=0;
     
254.                         led_gre=0;
     
255.                         led_red=1;
     
256.                         displaylistchar(0,1,"Wrong Retry!");
     
257.                         delay_ms(1000);
     
258.                         k=0;
     
259.                         flag=0;
     
260.                         displaylistchar(0,1,"                ");//清除该行
     
261.                         displaylistchar(0,0,"                ");//清除该行
     
262.                         displaylistchar(0,0,"Input Password:");
     
263.                     }
     
264.                 }   
     
265.                 else        //输入新密码标志置1，输入新密码并显示新输入的密码
     
266.                 {
     
267.                     if(num>=0&&num<=9)
     
268.                     {
     
269.                         write_add(shu,num);
     
270.                         displayonechar(shu-1,1,ASC[num]);
     
271.                         shu++;
     
272.                         if(shu==5)
     
273.                         {
     
274.                             t=0;
     
275.                             shu=1;
     
276.                             cflag=0;
     
277.                             flag=0;
     
278.                             displaylistchar(0,1,"Change Success!");
     
279.                             delay_ms(500);
     
280.                             displaylistchar(0,0,"                ");//清除该行
     
281.                             displaylistchar(0,1,"                ");//清除该行
     
282.                             displaylistchar(0,0,"Input Password:");
     
283.                         }
     
284.                     }
     
285.                 }                 
     
286.             }
     
287. 
     
288.         }
     
289.                     
     
290.     }
     
291. }
     
292. 
     
293. void time0(void) interrupt 1
     
294. {
     
295.     TH0=(65535-50000)/256;
     
296.     TL0=(65535-50000)%256;
     
297.     t0++;
     
298.     if(t0==100)
     
299.     {
     
300.         t0=0;
     
301.         TR0=0;
     
302.         TR1=1;      
     
303.     }
     
304. }
     
305. 
     
306. void time1(void) interrupt 3
     
307. {
     
308.     TH1=(65535-2000)/256;
     
309.     TL1=(65535-2000)%256;
     
310.     t1++;
     
311.     spk=~spk;
     
312.     if(t1==5000)
     
313.     {
     
314.         t1=0;
     
315.         TR1=0;
     
316.     }
     
317. }
     
318. 
     

复制代码

还差1分 才能下

thanks for sharing

thanks for sharing

thanks for sharing

下载不了

谢谢分享！不过积分不够~~~

下载不了，求补附件

不错我可以学习到真正意义上的知识了

thanks for sharing

学习下24c02存储程序

多谢。。。。。。。

很好谢谢

楼主厉害

还差点分，加油

这是六位密码吗，有仿真的图和程序的吗

学习24c02存储程序