单片机密码锁程序 怎么改才能完成这些功能?

protues      

利用51单片机、24c02、键盘及LCD1602/12864液晶显示器件设计一个密码锁；

设置初始密码为“123456”；在锁已开状态下，能通过矩阵键盘重置密码；输入密码连续错误三次，则禁止输入密码一分钟。

/**************************************************************

二、单片机密码锁的设计
设计要求：1）利用51单片机、键盘及LCD1602/12864液晶显示器件设计一个密码锁；
2）密码允许3~6位；设置初始密码为“123456”；
3）在锁已开状态下，能通过矩阵键盘重置密码；
4）输入密码时，LCD显示“*”。密码输入正确在LCD1602显示“OPEN”，并用LED亮显示开锁的状态；
5）密码输入错误在LCD1602显示“ERROR”，并用LED熄灭表示关锁；
6）输入密码连续错误三次，则禁止输入密码一分钟。

**************************************************************/

1. #include<reg52.h>
   
2. #include <intrins.h>
   
3. #define uint unsigned int
   
4. #define uchar unsigned char
   
5.         
   
6. void shuru();
   
7. 
   
8. sbit sda=P2^0;                          //IO口定义
   
9. sbit scl=P2^1;
   
10. sbit rs=P2^2;
    
11. sbit lcden=P2^3;
    
12. sbit led=P1^0;
    
13. bit flag;
    
14. 
    
15. uchar password[]={1,2,3,4,5,6};
    
16. uchar enter[]={0,0,0,0,0,0,0};
    
17. 
    
18. uchar str[]="0123456789";
    
19. uchar wei,key,temp;
    
20. uchar new1,new2,new3,new4,new5,new6;  
    
21. bit allow,change,sure,wanbi,retry,close,reset;        
    
22. 
    
23. char key_buf[] = {0xee, 0xde, 0xbe, 0x7e,0xed, 0xdd, 0xbd, 0x7d,//定义键值
    
24.                                   0xeb, 0xdb, 0xbb, 0x7b};
    
25. uchar p,time,a;
    
26. 
    
27. void delay(uint x)
    
28. {
    
29.         uint a,b;
    
30.         for(a=x;a>0;a--)
    
31.                 for(b=10;b>0;b--);
    
32. }
    
33. 
    
34. /*****************************************************
    
35.                                 LCD1602初始化
    
36. *****************************************************/
    
37. 
    
38. void write_com(uchar com)         //些命令，RS=0
    
39. {
    
40.         P0=com;
    
41.         rs=0;
    
42.         lcden=0;
    
43.         delay(10);
    
44.         lcden=1;
    
45.         delay(10);
    
46.         lcden=0;
    
47.         
    
48. }
    
49. 
    
50. void write_data(uchar dat)           //写数据，RS=1
    
51. {
    
52.         P0=dat;
    
53.         rs=1;
    
54.         lcden=0;
    
55.         delay(10);
    
56.         lcden=1;
    
57.         delay(10);
    
58.         lcden=0;
    
59.         
    
60. }
    
61. 
    
62. void lcdinit()
    
63. {
    
64. 
    
65.         write_com(0x38);   //00111000工作方式设置：16×2显示，5×7点阵，8位数据接口
    
66. 
    
67.         write_com(0x0c);   
    
68. 
    
69.         write_com(0x06);   //00000110输入方式设置：光标右移，字符不移
    
70. 
    
71.         write_com(0x01);   //清屏幕指令，将以前的显示内容清除
    
72. 
    
73.         write_com(0x80);
    
74.         
    
75. }
    
76. 
    
77. /******************************************************
    
78.           24c02初始化
    
79. *******************************************************/
    
80. 
    
81. void nop()
    
82. {
    
83.         _nop_();
    
84.         _nop_();
    
85. }
    
86. 
    
87. void init()  //24c02初始化子程序
    
88. {
    
89.         scl=1;
    
90.         nop();
    
91.         sda=1;
    
92.         nop();
    
93. }
    
94. 
    
95. void start()        //启动I2C总线
    
96. {
    
97.         sda=1;
    
98.         nop();
    
99.         scl=1;
    
100.         nop();
     
101.         sda=0;
     
102.         nop();
     
103.         scl=0;
     
104.         nop();
     
105. }
     
106. 
     
107. void stop()         //停止I2C总线
     
108. {
     
109.         sda=0;
     
110.         nop();
     
111.         scl=1;
     
112.         nop();
     
113.         sda=1;
     
114.         nop();
     
115. }
     
116. 
     
117. void writebyte(unsigned char j)  //写一个字节
     
118. {
     
119.         unsigned char i,temp;
     
120.            temp=j;
     
121.            for (i=0;i<8;i++)
     
122.    {
     
123.            temp=temp<<1;
     
124.            scl=0;
     
125.            nop();
     
126.            sda=CY;                //temp左移时，移出的值放入了CY中
     
127.            nop();
     
128.            scl=1;                //待sda线上的数据稳定后，将scl拉高
     
129.            nop();
     
130.    }
     
131.    scl=0;
     
132.    nop();
     
133.    sda=1;
     
134.    nop();
     
135. }
     
136. 
     
137. unsigned char readbyte()   //读一个字节
     
138. {
     
139.    unsigned char i,j,k=0;
     
140.    scl=0; nop(); sda=1;
     
141.    for (i=0;i<8;i++)
     
142.    {  
     
143.                 nop(); scl=1; nop();
     
144.               if(sda==1)
     
145.                 j=1;
     
146.               else
     
147.                 j=0;
     
148.               k=(k<<1)|j;
     
149.                   scl=0;
     
150.         }
     
151.            nop();
     
152.         return(k);
     
153. }
     
154. 
     
155. void clock()         //I2C总线时钟
     
156. {
     
157.    unsigned char i=0;
     
158.    scl=1;
     
159.    nop();
     
160.    while((sda==1)&&(i<255))
     
161.              i++;
     
162.    scl=0;
     
163.    nop();
     
164. }
     
165. 
     
166. unsigned char read24c02(unsigned char address)
     
167. {
     
168.    unsigned char i;
     
169.    start();
     
170.    writebyte(0xa0);
     
171.    clock();
     
172.    writebyte(address);
     
173.    clock();
     
174.    start();
     
175.    writebyte(0xa1);
     
176.    clock();
     
177.    i=readbyte();
     
178.    stop();
     
179.    delay(100);
     
180.    return(i);
     
181. }
     
182. 
     
183. void write24c02(unsigned char address,unsigned char info)
     
184. {
     
185.    start();
     
186.    writebyte(0xa0);
     
187.    clock();
     
188.    writebyte(address);
     
189.    clock();
     
190.    writebyte(info);
     
191.    clock();
     
192.    stop();
     
193.    delay(5000); //这个延时一定要足够长，否则会出错。因为24c02在从sda上取得数据后，还需要一定时间的烧录过程。
     
194. }
     
195. 
     
196. /*******************************************
     
197.                                         矩阵键盘
     
198. ********************************************/
     
199. void keyscan()
     
200. {
     
201.         P3=0xff;                //独立按键优先
     
202.     temp=P3;
     
203.     temp=temp&0xf0;
     
204.     if(temp!=0xf0)
     
205.     {
     
206.       delay(10);
     
207.       if(temp!=0xf0)
     
208.       {        
     
209.                 if(temp==0xe0) retry=1;        //重试
     
210.                 if(temp==0xd0) close=1;        //关锁
     
211.                 if(temp==0x70) reset=1;        //清内存密码为000000
     
212.           }
     
213.         }
     
214. 
     
215.     P3=0xfe;
     
216.     temp=P3;
     
217.     temp=temp&0xf0;
     
218.     if(temp!=0xf0)
     
219.     {
     
220.       delay(10);
     
221.       if(temp!=0xf0)
     
222.       {        
     
223.         temp=P3;
     
224.         switch(temp)
     
225.         {
     
226.           case 0xee:
     
227.                key=0;
     
228.                                                         if(wei<6)
     
229.                                                         {
     
230.                                                                 enter[wei]=key;
     
231.                                                                 write_data('*');
     
232.                                                         }
     
233.                                                         wei++;
     
234.                break;
     
235. 
     
236.           case 0xde:
     
237.                key=1;
     
238.                                                         if(wei<6)
     
239.                                                         {
     
240.                                                                 enter[wei]=key;
     
241.                                                                 write_data('*');
     
242.                                                         }
     
243.                                                         wei++;
     
244.                break;
     
245. 
     
246.           case 0xbe:
     
247.                key=2;
     
248.                                                         if(wei<6)
     
249.                                                         {
     
250.                                                                 enter[wei]=key;
     
251.                                                                 write_data('*');
     
252.                                                         }
     
253.                                                         wei++;
     
254.                break;
     
255. 
     
256.           case 0x7e:
     
257.                key=3;
     
258.                                                                                    if(wei<6)
     
259.                                                         {
     
260.                                                                 enter[wei]=key;
     
261.                                                                 write_data('*');
     
262.                                                         }
     
263.                                                         wei++;
     
264.                break;
     
265.          }
     
266.          while(temp!=0xf0)
     
267.         {
     
268.            temp=P3;
     
269.            temp=temp&0xf0;
     
270. 
     
271.          }
     
272. 
     
273.       }
     
274.     }
     
275.     P3=0xfd;
     
276.     temp=P3;
     
277.     temp=temp&0xf0;
     
278.     if(temp!=0xf0)
     
279.     {
     
280.       delay(10);
     
281.       if(temp!=0xf0)
     
282.       {
     
283.         temp=P3;
     
284.         switch(temp)
     
285.         {
     
286.           case 0xed:
     
287.                key=4;
     
288.                                                         if(wei<6)
     
289.                                                         {
     
290.                                                                 enter[wei]=key;
     
291.                                                                 write_data('*');
     
292.                                                         }
     
293.                                                         wei++;
     
294.                break;
     
295. 
     
296.           case 0xdd:
     
297.                key=5;
     
298.                                                         if(wei<6)
     
299.                                                         {
     
300.                                                                 enter[wei]=key;
     
301.                                                                 write_data('*');
     
302.                                                         }
     
303.                                                         wei++;
     
304.                break;
     
305. 
     
306.           case 0xbd:
     
307.                key=6;
     
308.                                                         if(wei<6)
     
309.                                                         {
     
310.                                                                 enter[wei]=key;
     
311.                                                                 write_data('*');
     
312.                                                         }
     
313.                                                         wei++;
     
314.                break;
     
315. 
     
316.           case 0x7d:
     
317.                key=7;
     
318.                                                         if(wei<6)
     
319.                                                         {
     
320.                                                                 enter[wei]=key;
     
321.                                                                 write_data('*');
     
322.                                                         }
     
323.                                                         wei++;
     
324.                break;
     
325.          }
     
326.          while(temp!=0xf0)
     
327.          {
     
328.            temp=P3;
     
329.            temp=temp&0xf0;
     
330. 
     
331.          }
     
332. 
     
333.       }
     
334.       }
     
335.     P3=0xfb;
     
336.     temp=P3;
     
337.     temp=temp&0xf0;
     
338.     if(temp!=0xf0)
     
339.     {
     
340.       delay(10);
     
341.       if(temp!=0xf0)
     
342.       {
     
343.         temp=P3;
     
344.         switch(temp)
     
345.         {
     
346.           case 0xeb:
     
347.                key=8;
     
348.                                                         if(wei<6)
     
349.                                                         {
     
350.                                                                 enter[wei]=key;
     
351.                                                                 write_data('*');
     
352.                                                         }
     
353.                                                         wei++;
     
354.                break;
     
355. 
     
356.           case 0xdb:
     
357.                key=9;
     
358.                                                         if(wei<6)
     
359.                                                         {
     
360.                                                                 enter[wei]=key;
     
361.                                                                 write_data('*');
     
362.                                                         }
     
363.                                                         wei++;
     
364.                break;
     
365.                            
     
366.           case 0xbb:
     
367.                change=1;                 //改密
     
368.                            wei=0;
     
369.                break;
     
370. 
     
371.           case 0x7b:
     
372.                              if(allow)                 //改后确认
     
373.                sure=1;
     
374.                break;
     
375.          }
     
376.         while(temp!=0xf0)
     
377.          {
     
378.            temp=P3;
     
379.            temp=temp&0xf0;
     
380. 
     
381.          }
     
382. 
     
383.       }
     
384.       }
     
385.                
     
386. /*          P3=0xf7;
     
387.     temp=P3;
     
388.     temp=temp&0xf0;
     
389.     if(temp!=0xf0)
     
390.     {
     
391.       delay(10);
     
392.       if(temp!=0xf0)
     
393.       {
     
394.         temp=P3;
     
395.         switch(temp)
     
396.         {
     
397.           case 0xe7:
     
398.                              retry=1;
     
399.                break;
     
400. 
     
401.           case 0xd7:
     
402.                              close=1;
     
403.                break;
     
404.          }
     
405.         while(temp!=0xf0)
     
406.          {
     
407.            temp=P3;
     
408.            temp=temp&0xf0;
     
409.            beep=0;
     
410.          }
     
411.          beep=1;
     
412.       }
     
413.       }        */
     
414. }
     
415. 
     
416. void compare()
     
417. {
     
418.         if(wei==6)
     
419.         {
     
420.                 if((enter[0]==password[0])&(enter[1]==password[1])&(enter[2]==password[2])&(enter[3]==password[3])&(enter[4]==password[4])&(enter[5]==password[5]))
     
421.                         allow=1;
     
422.         }
     
423. }
     
424. 
     
425. void main()
     
426. {
     
427.         uchar b,c,d;
     
428.         init();
     
429.         lcdinit();
     
430.         
     
431.         /****************************
     
432. //        write24c02(110,0x01);
     
433. //        write24c02(111,0x02);//24c02的第110到115地址单元作为密码存储区
     
434. //        write24c02(112,0x03);
     
435. //        write24c02(113,0x04);
     
436. //        write24c02(114,0x05);
     
437. //        write24c02(115,0x06);
     
438.         
     
439.         *****************************/
     
440.         
     
441.         /*password[0]=read24c02(110);  
     
442.         password[1]=read24c02(111);
     
443.         password[2]=read24c02(112);
     
444.         password[3]=read24c02(113);
     
445.         password[4]=read24c02(114);
     
446.         password[5]=read24c02(115);*/
     
447.         
     
448.         while(1)
     
449.         {
     
450.                 keyscan();
     
451.                 compare();
     
452.                 if(allow)
     
453.                 {
     
454.                         P1=0x00;
     
455.                         write_com(0xc0);
     
456.                         write_data('O');
     
457.                         write_data('P');
     
458.                         write_data('E');
     
459.                         write_data('N');
     
460.                         delay(500);
     
461. 
     
462.                         
     
463.                 }
     
464.                
     
465.                 if(change)        
     
466.                 {
     
467.                         change=0;
     
468.                         if(allow)
     
469.                         {
     
470.                                 allow=0;
     
471.                                 write_com(0x01);
     
472.                                 write_com(0xc0);
     
473.                                 write_data('N');
     
474.                                 write_data('E');
     
475.                                 write_data('W');
     
476.                                 write_com(0x80);
     
477.                                 while(wei<6)
     
478.                                 {
     
479.                                         keyscan();
     
480.                                 }
     
481.                                 
     
482.                         }
     
483.                 }
     
484.                 if(sure)
     
485.                                 {
     
486.                                         sure=0;allow=0; wei=0;
     
487.                                         change=0;
     
488.                                         for(b=0;b<6;b++)
     
489.                                         {
     
490.                                                 password[b]=enter[b];
     
491.                                         }
     
492.                                         write24c02(110,enter[0]);
     
493.                                         write24c02(111,enter[1]);
     
494.                                         write24c02(112,enter[2]);
     
495.                                         write24c02(113,enter[3]);
     
496.                                         write24c02(114,enter[4]);
     
497.                                         write24c02(115,enter[5]);
     
498.                                         write_com(0x01);
     
499.                                 }
     
500.                 if(close)
     
501.                 {
     
502.                         close=0;change=0;//所有变量均被清零。
     
503.                         wei=0;        
     
504.                         allow=0;
     
505.                         P1=0xff;
     
506.                         write_com(0x01);
     
507.                 }
     
508.         }
     
509.         
     
510. }
     

复制代码