标题: 51单片机的电子密码锁仿真+程序 具有更改密码功能,密码存储 [打印本页]

---

作者: QEQWE123    时间: 2023-5-15 14:40
标题: 51单片机的电子密码锁仿真+程序 具有更改密码功能,密码存储
可具有更改密码功能，密码存储，显示屏1602功能
电子密码锁使用说明

一、    主要功能：
1.按键设置6位密码，输入密码若密码正确，则锁打开。显示open！
2.密码可以自己修改（6位密码），必须是锁打开时才能改密。为防止误操作，修改密码得输入两次。
3.若密码输入错误次数超过3次，蜂鸣器报警并且锁定键盘。
4.24C02有复位、掉电保存密码功能。
5.液晶屏亮度会随光线自动调整。
6.本设计有红外遥控的功能，可以通过红外遥控器输入密码操作锁的状态（数字键是对应的，C键是重设密码，中间的播放图标的按键是确认，后退箭头的按键是撤销键）
二、按键说明：（主板）
排列方式：1  2  3  A
  4  5  6  B
  7  8  9  C
  *  0  #  D
   ABC无定义、 *号键为取消当前操作、#号键为确认、D键为修改密码
三、调整说明：
1、    灰度调整：当焊接好后液晶屏可能会“无字”。这是调节液晶3脚与地之间的电位器阻值应为1.3k左右，液晶3脚与电源之间的电位器阻值应为8.7k左右。（如果是电阻，那就是1与3脚是1.5k，2与3脚是10k的电阻）
2、    自己焊接的电路，首次使用时输入：131420，对密码进行初始化，当显示：init password,证明密码初始化完成，此时的密码为：000000。然后可以改密了。（如密码忘记就再输入131420初始化，然后密码就是000000了，不要告诉别人哦~~~）
3、    按下 * 键或复位键，可以关锁并退出。
4、    当输入密码错误后，报警并锁定键盘3秒钟。
5、    修改密码：在开锁状态下，再次输入正确的密码并按下 # 键，此时听到两声提示，输入新的六位密码并按 D 键，再重复输入一次新密码并按 D ，会听到两声提示音，表示重设密码成功，内部保存新密码并存储。如两次输入的新密码不一样，则重设密码失败。
6、    祝您成功！

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


单片机源程序如下:

1. #include <REG52.h>
   
2. #include<intrins.h>
   
3. #include<stdlib.h>
   
4. #define LCM_Data  P0
   
5. #define uchar unsigned char
   
6. #define uint  unsigned int
   
7. 
   
8. sbit lcd1602_rs=P2^7;
   
9. //sbit lcd1602_rw=P2^6;
   
10. sbit lcd1602_en=P2^6;
    
11. 
    
12. sbit Scl=P2^0;                        //24C02串行时钟
    
13. sbit Sda=P2^1;                        //24C02串行数据
    
14. 
    
15. sbit ALAM = P3^6;                //报警       
    
16. sbit KEY = P3^2;                //开锁
    
17. 
    
18. 
    
19. bit  operation=0;                //操作标志位
    
20. bit  pass=0;                        //密码正确标志
    
21. bit  ReInputEn=0;                //重置输入充许标志       
    
22. bit  s3_keydown=0;                //3秒按键标志位
    
23. bit  key_disable=0;                //锁定键盘标志
    
24. 
    
25. unsigned char countt0,second;        //t0中断计数器,秒计数器
    
26. 
    
27. //解码变量
    
28. unsigned char Im[4]={0x00,0x00,0x00,0x00};
    
29. 
    
30. 
    
31. //全局变量
    
32. uchar f;
    
33. unsigned long m,Tc;
    
34. unsigned char IrOK;
    
35. 
    
36. 
    
37. unsigned char code a[]={0xFE,0xFD,0xFB,0xF7};                                                                                         //控盘扫描控制表
    
38. 
    
39. unsigned char code start_line[]        = {"password:       "};
    
40. unsigned char code name[]                  = {"===Coded Lock==="};                                                                                                //显示名称
    
41. unsigned char code Correct[]         = {"     correct    "};                                                                                         //输入正确
    
42. unsigned char code Error[]           = {"      error     "};                                                                                          //输入错误
    
43. unsigned char code codepass[]        = {"      pass      "};
    
44. unsigned char code LockOpen[]        = {"      open      "};                                                                                                //OPEN
    
45. unsigned char code SetNew[]         = {"SetNewWordEnable"};
    
46. unsigned char code Input[]           = {"input:          "};                                                                                                //INPUT
    
47. unsigned char code ResetOK[]         = {"ResetPasswordOK "};
    
48. unsigned char code initword[]        = {"Init password..."};
    
49. unsigned char code Er_try[]                = {"error,try again!"};
    
50. unsigned char code again[]                = {"input again     "};
    
51. 
    
52. unsigned char InputData[6];                                                                                                                                //输入密码暂存区
    
53. unsigned char CurrentPassword[6]={1,3,1,4,2,0};                                                                                                                 //当前密码值
    
54. unsigned char TempPassword[6];
    
55. unsigned char N=0;                                //密码输入位数记数
    
56. unsigned char ErrorCont;                        //错误次数计数
    
57. unsigned char CorrectCont;                        //正确输入计数
    
58. unsigned char ReInputCont;                         //重新输入计数
    
59. unsigned char code initpassword[6]={0,0,0,0,0,0};
    
60. 
    
61. unsigned char code suiji_password[6];
    
62. 
    
63. 
    
64. 
    
65. //=====================5ms延时==============================
    
66. void Delay5Ms()
    
67. {
    
68.         unsigned int TempCyc = 5552;
    
69.         while(TempCyc--);
    
70. }       
    
71. 
    
72. //===================400ms延时==============================
    
73. void Delay400Ms()
    
74. {
    
75. unsigned char TempCycA = 5;
    
76. unsigned int TempCycB;
    
77. while(TempCycA--)
    
78. {
    
79.   TempCycB=7269;
    
80.   while(TempCycB--);
    
81. }
    
82. }
    
83. 
    
84. //=============================================================================================
    
85. //================================24C02========================================================
    
86. //=============================================================================================
    
87. 
    
88. void mDelay(uint t) //延时
    
89. {
    
90.         uchar i;
    
91.            while(t--)
    
92.            {
    
93.                    for(i=0;i<125;i++)
    
94.                    {;}
    
95.            }
    
96. }
    
97.    
    
98. 
    
99. void Nop()                  //空操作
    
100. {
     
101.         _nop_();
     
102.         _nop_();
     
103.         _nop_();
     
104.         _nop_();
     
105. }
     
106. 
     
107. 
     
108. /*起始条件*/
     
109. 
     
110. void Start(void)
     
111. {
     
112.         Sda=1;
     
113.         Scl=1;
     
114.         Nop();
     
115.         Sda=0;
     
116.         Nop();
     
117. }
     
118. 
     
119. 
     
120. /*停止条件*/
     
121. void Stop(void)
     
122. {
     
123.         Sda=0;
     
124.         Scl=1;
     
125.         Nop();
     
126.         Sda=1;
     
127.         Nop();
     
128. }
     
129. 
     
130. /*应答位*/
     
131. void Ack(void)
     
132. {
     
133.         Sda=0;
     
134.         Nop();
     
135.         Scl=1;
     
136.         Nop();
     
137.         Scl=0;
     
138. }
     
139. 
     
140. /*反向应答位*/
     
141. void NoAck(void)
     
142. {
     
143.         Sda=1;
     
144.         Nop();
     
145.         Scl=1;
     
146.         Nop();
     
147.         Scl=0;
     
148. }       
     
149. 
     
150. /*发送数据子程序，Data为要求发送的数据*/
     
151. void Send(uchar Data)
     
152. {
     
153.            uchar BitCounter=8;
     
154.            uchar temp;
     
155.            do
     
156.            {
     
157.                    temp=Data;
     
158.                    Scl=0;
     
159.                    Nop();
     
160.                    if((temp&0x80)==0x80)
     
161.                    Sda=1;
     
162.                    else
     
163.                    Sda=0;
     
164.                    Scl=1;
     
165.                    temp=Data<<1;
     
166.                    Data=temp;
     
167.                    BitCounter--;
     
168.            }
     
169.            while(BitCounter);
     
170.            Scl=0;
     
171. }
     
172. 
     
173. /*读一字节的数据，并返回该字节值*/
     
174. uchar Read()
     
175. {
     
176.     uchar temp=0;
     
177.         uchar temp1=0;
     
178.         uchar BitCounter=8;
     
179.         Sda=1;
     
180.         do{
     
181.         Scl=0;
     
182.         Nop();
     
183.         Scl=1;
     
184.         Nop();
     
185.         if(Sda)
     
186.         temp=temp|0x01;
     
187.         else
     
188.         temp=temp&0xfe;
     
189.         if(BitCounter-1)
     
190.         {
     
191.         temp1=temp<<1;
     
192.         temp=temp1;
     
193.         }
     
194.         BitCounter--;
     
195.         }
     
196.         while(BitCounter);
     
197.         return(temp);
     
198.         }
     
199. 
     
200. void WrToROM(uchar Data[],uchar Address,uchar Num)
     
201. {
     
202.   uchar i;
     
203.   uchar *PData;
     
204.   PData=Data;
     
205.   for(i=0;i<Num;i++)
     
206.   {
     
207.   Start();
     
208.   Send(0xa0);
     
209.   Ack();
     
210.   Send(Address+i);
     
211.   Ack();
     
212.   Send(*(PData+i));
     
213.   Ack();
     
214.   Stop();
     
215.   mDelay(20);
     
216.   }
     
217. }
     
218. 
     
219. void RdFromROM(uchar Data[],uchar Address,uchar Num)
     
220. {
     
221.   uchar i;
     
222.   uchar *PData;
     
223.   PData=Data;
     
224.   for(i=0;i<Num;i++)
     
225.   {
     
226.   Start();
     
227.   Send(0xa0);
     
228.   Ack();
     
229.   Send(Address+i);
     
230.   Ack();
     
231.   Start();
     
232.   Send(0xa1);
     
233.   Ack();
     
234.   *(PData+i)=Read();
     
235.   Scl=0;
     
236.   NoAck();
     
237.   Stop();
     
238.   }
     
239. }
     
240. 
     
241. 
     
242. //==================================================================================================
     
243. //=======================================LCD1602====================================================
     
244. //==================================================================================================
     
245. 
     
246. #define yi 0x80 //LCD第一行的初始位置,因为LCD1602字符地址首位D7恒定为1（100000000=80）
     
247. #define er 0x80+0x40 //LCD第二行初始位置（因为第二行第一个字符位置地址是0x40）
     
248. 
     
249. 
     
250. //----------------延时函数，后面经常调用----------------------
     
251. void delay(uint xms)//延时函数，有参函数
     
252. {
     
253.         uint x,y;
     
254.         for(x=xms;x>0;x--)
     
255.          for(y=110;y>0;y--);
     
256. }
     
257. 
     
258. //--------------------------写指令---------------------------
     
259. void write_1602com(uchar com)//****液晶写入指令函数****
     
260. {
     
261.         lcd1602_rs=0;//数据/指令选择置为指令
     
262. //        lcd1602_rw=0; //读写选择置为写
     
263.         P0=com;//送入数据
     
264.         delay(1);
     
265.         lcd1602_en=1;//拉高使能端，为制造有效的下降沿做准备
     
266.         delay(1);
     
267.         lcd1602_en=0;//en由高变低，产生下降沿，液晶执行命令
     
268. }
     
269. 
     
270. //-------------------------写数据-----------------------------
     
271. void write_1602dat(uchar dat)//***液晶写入数据函数****
     
272. {
     
273.         lcd1602_rs=1;//数据/指令选择置为数据
     
274. //        lcd1602_rw=0; //读写选择置为写
     
275.         P0=dat;//送入数据
     
276.         delay(1);
     
277.         lcd1602_en=1; //en置高电平，为制造下降沿做准备
     
278.         delay(1);
     
279.         lcd1602_en=0; //en由高变低，产生下降沿，液晶执行命令
     
280. }
     
281. 
     
282. //-------------------------初始化-------------------------
     
283. void lcd_init()
     
284. {
     
285.         write_1602com(0x38);//设置液晶工作模式，意思：16*2行显示，5*7点阵，8位数据
     
286.         write_1602com(0x0c);//开显示不显示光标
     
287.         write_1602com(0x06);//整屏不移动，光标自动右移
     
288.         write_1602com(0x01);//清显示
     
289. }
     
290. //========================================================================================
     
291. //=========================================================================================
     
292. 
     
293. 
     
294. 
     
295. 
     
296. //==============将按键值编码为数值=========================
     
297. unsigned char coding(unsigned char hh)         
     
298. {
     
299.         unsigned char k;
     
300. 
     
301.                 switch(hh)
     
302.                 {
     
303.                         case (0): k=1;break;
     
304.                         case (1): k=2;break;
     
305.                         case (2): k=3;break;
     
306.                         case (3): k='A';break;
     
307.                         case (4): k=4;break;
     
308.                         case (5): k=5;break;
     
309.                         case (6): k=6;break;
     
310.                         case (7): k='B';break;
     
311.                         case (8): k=7;break;
     
312.                         case (9): k=8;break;
     
313.                         case (10): k=9;break;
     
314.                         case (11): k='C';break;
     
315.                         case (12): k='*';break;
     
316.                         case (13): k=0;break;
     
317.                         case (14): k='#';break;
     
318.                         case (15): k='D';break;
     
319.                 }
     
320. 
     
321. 
     
322.         return(k);
     
323. }
     
324. 
     
325. 
     
326. 
     
327. 
     
328. unsigned char KeyMemory;
     
329. 
     
330. //按键行定义
     
331. sbit KeyLine_1        =        P1^7;
     
332. sbit KeyLine_2        =        P1^5;
     
333. sbit KeyLine_3        =        P1^3;
     
334. sbit KeyLine_4        =        P1^1;
     
335. //按键列定义        
     
336. sbit Keylist_1        =        P1^0;       
     
337. sbit Keylist_2        =        P1^2;       
     
338. sbit Keylist_3        =        P1^4;       
     
339. sbit Keylist_4        =        P1^6;       
     
340. void KeyOut(unsigned char i)
     
341. {
     
342.         KeyLine_1 = 1;
     
343.         KeyLine_2 = 1;
     
344.         KeyLine_3 = 1;
     
345.         KeyLine_4 = 1;
     
346.         switch(i)
     
347.         {
     
348.                 case 0: KeyLine_1 = 0; break;
     
349.                 case 1: KeyLine_2 = 0; break;
     
350.                 case 2: KeyLine_3 = 0; break;
     
351.                 case 3: KeyLine_4 = 0; break;
     
352.         }       
     
353. }
     
354. 
     
355. unsigned char KeyIn(unsigned char i)
     
356. {
     
357.         static unsigned char a=1;
     
358.         switch(i)
     
359.         {
     
360.                 case 0: a=Keylist_1; break;
     
361.                 case 1: a=Keylist_2; break;
     
362.                 case 2: a=Keylist_3; break;
     
363.                 case 3: a=Keylist_4; break;
     
364.         }       
     
365.         return a;
     
366. }
     
367. //========================================================================
     
368. // 函数: u8 update_key(void)                                                                                                       
     
369. // 应用: key=u8 update_key();                        
     
370. // 描述: 扫描并返回按下的按键值,                              
     
371. // 参数:                                             
     
372. // 返回: 按下的键值,0-15;无按下返回0xff;               
     
373. // 版本: VER1.0                                       
     
374. // 日期: 2013-4-1                                    
     
375. // 备注:
     
376. //========================================================================
     
377. unsigned char keynum(void)
     
378. {
     
379.         unsigned char key_rt=0xff;//按键返回值
     
380.         unsigned char i, j;
     
381.         for(i = 0; i < 4; i++)             //i是输出口，依次置高电平
     
382.         {
     
383.                 KeyOut(i);
     
384.                 for(j = 0; j < 4; j++)            //j是输入口，当键按下时导通被置为高电平  //在1路输出高电平的时候输入扫描,并储存
     
385.                 {
     
386.                         if(KeyIn(j) == 0)                //如果有按键按下
     
387.                         {
     
388.                                 Delay5Ms();
     
389.                                 Delay5Ms();
     
390.                                 if(KeyIn(j) == 0)                //如果有按键按下
     
391.                                 {
     
392.                                         KeyMemory=(1<<i)*16+(1<<j);
     
393.                                 }
     
394.                         }
     
395.                         while(KeyIn(j) == 0);        //松手检测,假如有按键按下则等待,没有按下或松开则通过
     
396.                 }
     
397.         }
     
398.         for(i = 0; i < 4; i++)         
     
399.         {
     
400.                 if((KeyMemory/16)>>i==0x01)
     
401.                 {
     
402.                         for(j = 0; j < 4; j++)           
     
403.                         {       
     
404.                                 if((KeyMemory%16)>>j==0x01)
     
405.                                 {
     
406.                                         KeyMemory=0;
     
407.                                         key_rt=i*4+j;
     
408.                                 }
     
409.                         }
     
410.                 }
     
411.         }
     
412.         return key_rt;
     
413. }
     
414. 
     
415. 
     
416. 
     
417. //=======================一声提示音，表示有效输入========================
     
418. void OneAlam()
     
419. {
     
420.         ALAM=0;
     
421.         Delay5Ms();
     
422.     ALAM=1;
     
423. }
     
424. 
     
425. //========================二声提示音，表示操作成功========================
     
426. void TwoAlam()
     
427. {
     
428.         ALAM=0;
     
429.         Delay5Ms();
     
430.     ALAM=1;
     
431.     Delay5Ms();
     
432.         ALAM=0;
     
433.         Delay5Ms();
     
434.     ALAM=1;
     
435. }
     
436. 
     
437. //========================三声提示音,表示错误========================
     
438. void ThreeAlam()
     
439. {
     
440.         ALAM=0;
     
441.         Delay5Ms();
     
442.     ALAM=1;
     
443.     Delay5Ms();
     
444.         ALAM=0;
     
445.         Delay5Ms();
     
446.     ALAM=1;
     
447.     Delay5Ms();
     
448.         ALAM=0;
     
449.         Delay5Ms();
     
450.     ALAM=1;
     
451. 
     
452. }
     
453. 
     
454. 
     
455. //=======================显示提示输入=========================
     
456. void DisplayChar()
     
457. {
     
458.         unsigned char i;
     
459.         if(pass==1)
     
460.         {
     
461.                 write_1602com(er);
     
462.                 for(i=0;i<16;i++)
     
463.                 {
     
464.                         write_1602dat(LockOpen[i]);       
     
465.                 }
     
466.         }
     
467.         else
     
468.         {
     
469.                 if(N==0)
     
470.                 {
     
471.                         write_1602com(er);
     
472.                         for(i=0;i<16;i++)
     
473.                         {
     
474.                                 write_1602dat(Error[i]);       
     
475.                         }
     
476.                 }
     
477.                 else
     
478.                 {
     
479.                         write_1602com(er);
     
480.                         for(i=0;i<16;i++)
     
481.                         {
     
482.                                 write_1602dat(start_line[i]);       
     
483.                         }
     
484.                 }
     
485.         }
     
486. }
     
487. 
     
488. 
     
489. //========================重置密码==================================================
     
490. //==================================================================================
     
491. void ResetPassword()
     
492. {
     
493.         unsigned char i;       
     
494.         unsigned char j;
     
495.         if(pass==0)
     
496.         {
     
497.                 pass=0;
     
498.                 DisplayChar();
     
499.                 ThreeAlam();
     
500.         }
     
501.         else
     
502.         {
     
503.             if(ReInputEn==1)
     
504.                 {
     
505.                         if(N==6)
     
506.                         {
     
507.                                 ReInputCont++;                               
     
508.                                 if(ReInputCont==2)
     
509.                                 {
     
510.                                         for(i=0;i<6;)
     
511.                                         {
     
512.                                                 if(TempPassword[i]==InputData[i])        //将两次输入的新密码作对比
     
513.                                                         i++;
     
514.                                                 else
     
515.                                                 {
     
516.                                                         write_1602com(er);
     
517.                                                         for(j=0;j<16;j++)
     
518.                                                         {
     
519.                                                                 write_1602dat(Error[j]);       
     
520.                                                         }
     
521.                                                         ThreeAlam();                        //错误提示       
     
522.                                                         pass=0;
     
523.                                                         ReInputEn=0;                        //关闭重置功能，
     
524.                                                         ReInputCont=0;
     
525.                                                         DisplayChar();
     
526.                                                         break;
     
527.                                                 }
     
528.                                         }
     
529.                                         if(i==6)
     
530.                                         {
     
531.                                                 write_1602com(er);
     
532.                                                 for(j=0;j<16;j++)
     
533.                                                 {
     
534.                                                         write_1602dat(ResetOK[j]);       
     
535.                                                 }
     
536. 
     
537.                                                 TwoAlam();                                //操作成功提示
     
538.                                                  WrToROM(TempPassword,0,6);                //将新密码写入24C02存储
     
539.                                                 ReInputEn=0;
     
540.                                         }
     
541.                                         ReInputCont=0;
     
542.                                         CorrectCont=0;
     
543.                                 }
     
544.                                 else
     
545.                                 {
     
546.                                         OneAlam();
     
547.                                         write_1602com(er);
     
548.                                         for(j=0;j<16;j++)
     
549.                                         {
     
550.                                                 write_1602dat(again[j]);       
     
551.                                         }                                       
     
552.                                         for(i=0;i<6;i++)
     
553.                                         {
     
554.                                                 TempPassword[i]=InputData[i];                //将第一次输入的数据暂存起来                                               
     
555.                                         }
     
556.                                 }
     
557. 
     
558.                         N=0;                                                //输入数据位数计数器清零
     
559.                    }
     
560.             }
     
561.         }
     
562. 
     
563. }
     
564. 
     
565. 
     
566. 
     
567. //=======================输入密码错误超过三过，报警并锁死键盘======================
     
568. void Alam_KeyUnable()
     
569. {
     
570.         P1=0x00;
     
571.         {
     
572.                 ALAM=~ALAM;
     
573.                 Delay5Ms();
     
574.         }
     
575. }
     
576. 
     
577. 
     
578. //=======================取消所有操作============================================
     
579. void Cancel()
     
580. {       
     
581.         unsigned char i;
     
582.         unsigned char j;
     
583.         write_1602com(er);
     
584.         for(j=0;j<16;j++)
     
585.         {
     
586.                 write_1602dat(start_line[j]);       
     
587.         }
     
588.         TwoAlam();                                //提示音
     
589.         for(i=0;i<6;i++)
     
590.         {
     
591.                 InputData[i]=0;
     
592.         }
     
593.         KEY=1;                                        //关闭锁
     
594.         ALAM=1;                                        //报警关
     
595.         operation=0;                        //操作标志位清零
     
596.         pass=0;                                        //密码正确标志清零
     
597.         ReInputEn=0;                        //重置输入充许标志清零
     
598.         CorrectCont=0;                        //密码正确输入次数清零
     
599.         ReInputCont=0;                        //重置密码输入次数清零
     
600.         s3_keydown=0;
     
601.         key_disable=0;
     
602.         N=0;                                        //输入位数计数器清零
     
603. }
     
604. 
     
605. 
     
606. //==========================确认键，并通过相应标志位执行相应功能===============================
     
607. void Ensure()
     
608. {       
     
609.         unsigned char i,j;
     
610.         RdFromROM(CurrentPassword,0,6);                                         //从24C02里读出存储密码
     
611.     if(N==6)
     
612.         {
     
613.             if(ReInputEn==0)                                                        //重置密码功能未开启
     
614.                 {
     
615.                         for(i=0;i<6;)
     
616.                            {                                       
     
617.                                 if(CurrentPassword[i]==InputData[i])
     
618.                                 {
     
619.                                         i++;
     
620.                                 }
     
621.                                 else
     
622.                                 {
     
623.                                         i=7;                       
     
624.                                         ErrorCont++;
     
625.                                         if(ErrorCont>=3&&KEY==1)                        //错误输入计数达三次时，报警并锁定键盘
     
626.                                         {
     
627.                                                 write_1602com(er);
     
628.                                                 for(i=0;i<16;i++)
     
629.                                                 {
     
630.                                                         write_1602dat(Error[i]);       
     
631.                                                 }
     
632.                                                 Alam_KeyUnable();
     
633.                                                 TR0=1;                                //开启定时
     
634.                                                 key_disable=1;                        //锁定键盘
     
635.                                                 pass=0;
     
636.                                                 break;       
     
637.                                         }
     
638.                                 }  
     
639.                         }
     
640. 
     
641.                         if(i==6)
     
642.                         {
     
643.                                 CorrectCont++;
     
644.                                 if(CorrectCont==1)                                //正确输入计数，当只有一次正确输入时，开锁，
     
645.                                 {
     
646.                                         write_1602com(er);
     
647.                                         for(j=0;j<16;j++)
     
648.                                         {
     
649.                                                 write_1602dat(LockOpen[j]);       
     
650.                                         }
     
651.                                         TwoAlam();                        //操作成功提示音
     
652.                                         ErrorCont=0;
     
653.                                         KEY=0;                                                                                        //开锁
     
654.                                         pass=1;                                                                                        //置正确标志位
     
655.                                         TR0=1;                                                                                        //开启定时
     
656.                                         for(j=0;j<6;j++)                                                                //将输入清除
     
657.                                         {
     
658.                                                 InputData[i]=0;
     
659.                                         }
     
660.                                 }       
     
661.                                 else                                                                                                //当两次正确输入时，开启重置密码功能
     
662.                                 {
     
663.                                         write_1602com(er);
     
664.                                         for(j=0;j<16;j++)
     
665.                                         {
     
666.                                                 write_1602dat(SetNew[j]);       
     
667.                                         }
     
668.                                         TwoAlam();                                                                            //操作成功提示
     
669.                                         ReInputEn=1;                                                                        //允许重置密码输入
     
670.                                         CorrectCont=0;                                                                        //正确计数器清零
     
671.                                 }
     
672.                           }
     
673.        
     
674.                         else                        //=========================当第一次使用或忘记密码时可以用131420对其密码初始化============
     
675.                         {
     
676.                                 if((InputData[0]==1)&&(InputData[1]==3)&&(InputData[2]==1)&&(InputData[3]==4)&&(InputData[4]==2)&&(InputData[5]==0))
     
677.                                    {
     
678.                                         WrToROM(initpassword,0,6);                                 //强制将初始密码写入24C02存储
     
679.                                         write_1602com(er);
     
680.                                         for(j=0;j<16;j++)
     
681.                                         {
     
682.                                                 write_1602dat(initword[j]);       
     
683.                                         }
     
684.                                         TwoAlam();
     
685.                                         Delay400Ms();
     
686.                                         TwoAlam();
     
687.                                         N=0;
     
688.                                 }
     
689.                                 else
     
690.                                 {
     
691.                                         write_1602com(er);
     
692.                                         for(j=0;j<16;j++)
     
693.                                         {
     
694.                                                 write_1602dat(Error[j]);       
     
695.                                         }
     
696.                                         ThreeAlam();                                                                                //错误提示音
     
697.                                         pass=0;       
     
698.                                 }
     
699.                         }
     
700.                 }
     
701. 
     
702.                 else                                                                                        //当已经开启重置密码功能时，而按下开锁键，
     
703.                 {
     
704.                         write_1602com(er);
     
705.                         for(j=0;j<16;j++)
     
706.                         {
     
707.                                 write_1602dat(Er_try[j]);       
     
708.                         }
     
709.                         ThreeAlam();
     
710.                 }
     
711.         }
     
712. 
     
713.         else
     
714.         {
     
715.                 write_1602com(er);
     
716.                 for(j=0;j<16;j++)
     
717.                 {
     
718.                         write_1602dat(Error[j]);       
     
719.                 }
     
720. 
     
721.                 ThreeAlam();                                                                                //错误提示音
     
722.                 pass=0;       
     
723.         }
     
724.        
     
725.         N=0;                                                                                                        //将输入数据计数器清零，为下一次输入作准备
     
726. 
     
727.         operation=1;
     
728. }
     
729. 
     
730. 
     
731. //==============================主函数===============================
     
732. void main()
     
733. {
     
734.         unsigned char KEY,NUM;
     
735.         unsigned char i,j,m;
     
736.        
     
737.         P1=0xFF;
     
738.         EA=1;
     
739.         TMOD=0x11;
     
740.         IT1=1;//下降沿有效
     
741.         EX1=1;//外部中断1开
     
742.           
     
743.         TH0=0;//T0赋初值
     
744.         TL0=0;
     
745.         TR0=0;//t0开始计时
     
746.         TL1=0xB0;
     
747.         TH1=0x3C;
     
748. ……………………
     
749. 
     
750. …………限于本文篇幅 余下代码请从51黑下载附件…………
     

复制代码

Keil代码与Proteus仿真下载:
六位电子密码锁.rar (284.01 KB, 下载次数: 52)

2023-5-15 14:40 上传

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

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1