可修改密码的单片机密码锁设计 LCD1602显示带程序和仿真

LCD1602显示  6位密码  可修改 有程序 有仿真



仿真工程文件及程序等所有资料下载：
密码锁.zip (89.12 KB, 下载次数: 49)

2016-9-25 15:25 上传

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

源程序：

1. //proteus仿真论坛
   
2. #include<reg51.h>
   
3. #include<intrinS.h>
   
4. #include<absacc.h>
   
5. 
   
6. #define uchar unsigned char
   
7. #define C02_write 0xa0
   
8. #define C02_read  0xa1
   
9. 
   
10. #define no0 0x28
    
11. #define no1 0x14
    
12. #define no2 0x24
    
13. #define no3 0x44
    
14. #define no4 0x12
    
15. #define no5 0x22
    
16. #define no6 0x42
    
17. #define no7 0x11
    
18. #define no8 0x21
    
19. #define no9 0x41
    
20. #define enter 0x88
    
21. #define backspace 0x81
    
22. 
    
23. #define lcm_write_cmd_add XBYTE[0x80FF]
    
24. #define lcm_write_data_add XBYTE[0x81FF]
    
25. #define lcm_read_busy_add XBYTE[0x82FF]
    
26. #define lcm_read_data_add XBYTE[0x83FF]
    
27. 
    
28. uchar idata temp5_password[6]={0x00,0x00,0x00,0x00,0x00,0x00};
    
29. uchar idata key_code[]={no0,no1,no3,no4,no5,no6,no7,no8,no9};
    
30. 
    
31. sbit SCL=P3^0;
    
32. sbit SDA=P3^1;
    
33. sbit i=P3^2;
    
34. bit ack;
    
35. 
    
36. uchar        int_counter_1;
    
37. unsigned int int_counter_2;
    
38. 
    
39. void delayms(uchar i)
    
40. {
    
41.         uchar j;
    
42.         for(;i>0;i--)
    
43.         for(j=124;j>0;j--);
    
44. }
    
45. 
    
46. void longdelay(uchar i)
    
47. {
    
48.         unsigned int j;
    
49.         for(;i>0;i--)
    
50.         for(j=10000;j>0;j--);
    
51. }
    
52. 
    
53. void lcm_wait()
    
54. {
    
55.         while(lcm_read_busy_add&0x80);
    
56. }
    
57. 
    
58. void lcm_write_cmd(uchar lcm_cmd)
    
59. {
    
60.         lcm_wait();
    
61.         lcm_write_cmd_add=lcm_cmd;
    
62. }
    
63. 
    
64. void lcm_write_data(uchar lcm_data)
    
65. {
    
66.         lcm_wait();
    
67.         lcm_write_data_add=lcm_data;
    
68. }
    
69. 
    
70. uchar lcm_read_data(void)
    
71. {
    
72.         uchar lcm_data;
    
73.         lcm_wait();
    
74.         lcm_data=lcm_read_data_add;
    
75.         return(lcm_data);
    
76. }
    
77. 
    
78. void lcm_setxy(uchar x,uchar y)
    
79. {
    
80.         if(y==1) lcm_write_cmd(x|0x80);
    
81.         if(y==2) lcm_write_cmd(x|0xc0);
    
82. }
    
83. 
    
84. void lcm_write_string(uchar *string)
    
85. {
    
86.         uchar i=0;
    
87.         while(string[i]!='\0')
    
88.         {
    
89.                 lcm_write_data(string[i]);
    
90.                 i++;
    
91.         }
    
92. }
    
93. 
    
94. void lcm_roll_display(uchar *string,uchar y)
    
95. {
    
96.         uchar counter;
    
97.         lcm_write_cmd(0x06);
    
98.         lcm_setxy(0,y);
    
99.         while(string[counter]!='\0')
    
100.         {
     
101.                 lcm_write_data(string[counter]);
     
102.                 counter++;
     
103.                 if (counter==19) lcm_setxy(19,y);
     
104.                 longdelay(2);
     
105. 
     
106.         }
     
107.         lcm_write_cmd(0x07);
     
108.         lcm_setxy(19,y);
     
109.                 while(string[counter]!='\0')
     
110.         {
     
111.                 lcm_write_data(string[counter]);
     
112.                 counter++;
     
113.                 if (counter==19) lcm_setxy(19,y);
     
114.                 longdelay(2);
     
115. 
     
116.         }
     
117. }
     
118. 
     
119. void lcm_init()
     
120. {
     
121.         delayms(20);
     
122.         lcm_write_cmd_add=0x38;
     
123.         delayms(4);
     
124.         lcm_write_cmd_add=0x38;
     
125.         delayms(1);
     
126.         lcm_write_cmd_add=0x38;
     
127.         lcm_write_cmd(0x38);
     
128.         lcm_write_cmd(0x0f);       
     
129.         lcm_write_cmd(0x01);
     
130.         lcm_write_cmd(0x06);
     
131. }
     
132. 
     
133. void I2C_start(void)
     
134. {
     
135.         SDA=1;
     
136.         SCL=1;
     
137.         _nop_();
     
138.         _nop_();
     
139.         _nop_();
     
140.         _nop_();
     
141.         _nop_();
     
142.         SDA=0;
     
143.         _nop_();
     
144.         _nop_();
     
145.         _nop_();
     
146.         _nop_();
     
147.         _nop_();
     
148.         SCL=0;
     
149.         _nop_();
     
150.         _nop_();
     
151. }
     
152. 
     
153. void I2C_stop(void)
     
154. {
     
155.         SDA=0;
     
156.         SCL=1;
     
157.         _nop_();
     
158.         _nop_();
     
159.         _nop_();
     
160.         _nop_();
     
161.         _nop_();
     
162.         SDA=1;
     
163.         _nop_();
     
164.         _nop_();
     
165.         _nop_();
     
166.         _nop_();
     
167.         _nop_();
     
168.         SCL=0;
     
169.         _nop_();
     
170.         _nop_();
     
171. }
     
172. 
     
173. void I2C_ackownledge(void)
     
174. {
     
175.         SDA=0;
     
176.         _nop_();
     
177.         _nop_();
     
178.         SCL=1;
     
179.         _nop_();
     
180.         _nop_();
     
181.         _nop_();
     
182.         _nop_();
     
183.         _nop_();
     
184.         SCL=0;
     
185.         _nop_();
     
186.         _nop_();
     
187.         _nop_();
     
188. }
     
189. 
     
190. void I2C_no_ackownledge(void)
     
191. {
     
192.         SDA=1;
     
193.         _nop_();
     
194.         _nop_();
     
195.         SCL=1;
     
196.         _nop_();
     
197.         _nop_();
     
198.         _nop_();
     
199.         _nop_();
     
200.         _nop_();
     
201.         SCL=0;
     
202.         _nop_();
     
203.         _nop_();
     
204.         _nop_();
     
205. }
     
206. 
     
207. void I2C_sendB(uchar byte)
     
208. {
     
209.         uchar counter;
     
210.         for(counter=0;counter<8;counter++)
     
211.         {
     
212.                 if(byte&0x80)        SDA=1;
     
213.                 else        SDA=0;
     
214.                 _nop_();
     
215.                 SCL=1;
     
216.                 _nop_();
     
217.                 _nop_();
     
218.                 _nop_();
     
219.                 _nop_();
     
220.                 _nop_();
     
221.                 SCL=0;
     
222.                 _nop_();
     
223.                 _nop_();
     
224.                 byte<<=1;
     
225.         }
     
226.         _nop_();
     
227.         _nop_();
     
228.         SDA=1;
     
229.         _nop_();
     
230.         _nop_();
     
231.         _nop_();
     
232.         SCL=1;
     
233.         _nop_();
     
234.         _nop_();
     
235.         _nop_();
     
236.         if(SDA==0)        ack=1;
     
237.         else         ack=0;
     
238.         SCL=0;
     
239.         _nop_();
     
240.         _nop_();
     
241. }
     
242.        
     
243. uchar I2C_receiveB(void)
     
244. {
     
245.         uchar temp;
     
246.         uchar counter;
     
247.         temp=0;
     
248.         SDA=1;
     
249.         _nop_();
     
250.         _nop_();
     
251.         for(counter=0;counter<8;counter++)
     
252.         {
     
253.                  _nop_();
     
254.                  _nop_();
     
255.                  _nop_();
     
256.                  _nop_();
     
257.                  _nop_();
     
258.                  SCL=1;
     
259.                  _nop_();
     
260.                  _nop_();
     
261.                  if(SDA==1)        temp=(temp<<1)|0x01;
     
262.                  else        temp=temp<<1;
     
263.                  _nop_();
     
264.                  _nop_();
     
265.                  SCL=0;
     
266.                  _nop_();
     
267.                  _nop_();
     
268.                  _nop_();
     
269.         }
     
270.         _nop_();
     
271.         _nop_();
     
272.         return(temp);
     
273. }
     
274. 
     
275. /*bit I2C_write_byte(uchar byte,uchar address)
     
276. {
     
277.         I2C_sendB(address);
     
278.         if(ack=0)       
     
279.         {
     
280.                 I2C_stop();
     
281.                 return(0);
     
282.         }
     
283.         else        I2C_sendB(byte);  */
     
284.        
     
285. 
     
286. bit I2C_send_string(uchar *string,uchar no,uchar address)
     
287. {
     
288.         uchar counter;
     
289.         for(counter=0;counter<no;counter++)
     
290.         {
     
291.                 I2C_start();
     
292.                 I2C_sendB(C02_write);
     
293.                 if(ack==0) return(0);
     
294.                 I2C_sendB(address+counter);
     
295.                 if(ack==0) return(0);
     
296.                 I2C_sendB(string[counter]);
     
297.                 I2C_stop();
     
298.                 delayms(20);               
     
299.         }
     
300.         return(1);
     
301. }
     
302. 
     
303. bit I2C_receive_string(uchar *string,uchar no,uchar address)
     
304. {
     
305.         uchar counter;
     
306.         for(counter=0;counter<no;counter++)
     
307.         {
     
308.                 I2C_start();
     
309.                 I2C_sendB(C02_write);
     
310.                 if(ack==0) return(0);
     
311.                 I2C_sendB(address+counter);
     
312.                 if(ack==0) return(0);
     
313.                 I2C_start();
     
314.                 I2C_sendB(C02_read);
     
315.                 if(ack==0) return(0);
     
316.                 *(string+counter)=I2C_receiveB();
     
317.                 I2C_no_ackownledge();
     
318.                 I2C_stop();
     
319.         }
     
320. }
     
321. 
     
322. uchar get_key()
     
323. {
     
324.         uchar row_code;
     
325.         uchar col_code;
     
326.         P1=0xf0;
     
327.         if(P1!=0xf0)
     
328.         {
     
329.                 delayms(10);
     
330.                 if(P1!=0xf0)
     
331.                 {
     
332.                         row_code=0xfe;
     
333.                         while(row_code!=0x7f)
     
334.                         {       
     
335.                                 P1=row_code;
     
336.                                 if(P1!=row_code)
     
337.                                 {
     
338.                                         col_code=(P1&0xf0)|0x0f;
     
339.                                         return(        (~col_code)|(~row_code));
     
340.                                 }
     
341.                                 row_code=((row_code<<1)|0x01);
     
342.                         }
     
343.                 }
     
344.         }
     
345.         return(0x00);
     
346. }
     
347. 
     
348. void convert_code(uchar *string)
     
349. {
     
350.         uchar counter=0;
     
351.         for(counter=0;counter<6;counter++)
     
352.         {
     
353.                 switch(*string)
     
354.                 {
     
355.                         case no0:
     
356.                                                 *string=0x00;
     
357.                                                 break;
     
358.                         case no1:
     
359.                                                 *string=0x01;
     
360.                                                 break;
     
361.                         case no2:
     
362.                                                 *string=0x02;
     
363.                                                 break;
     
364.                         case no3:
     
365.                                                 *string=0x03;
     
366.                                                 break;
     
367.                         case no4:
     
368.                                                 *string=0x04;
     
369.                                                 break;
     
370.                         case no5:
     
371.                                                 *string=0x05;
     
372.                                                 break;
     
373.                         case no6:
     
374.                                                 *string=0x06;
     
375.                                                 break;
     
376.                         case no7:
     
377.                                                 *string=0x07;
     
378.                                                 break;
     
379.                         case no8:
     
380.                                                 *string=0x08;
     
381.                                                 break;
     
382.                         case no9:
     
383.                                                 *string=0x09;
     
384.                                                 break;
     
385.                         default:
     
386.                                                 break;
     
387.                 }
     
388.                 string++;                               
     
389.         }
     
390. }
     
391. 
     
392. bit compare_string(uchar *string1,uchar *string2)
     
393. {
     
394.         uchar counter;
     
395.         for(counter=0;counter<6;counter++)
     
396.         {
     
397.                 if(string1[counter]!=string2[counter]) return(0);
     
398.         }
     
399.         return(1);
     
400. }
     
401. 
     
402. uchar step_choose(void)
     
403. {
     
404.         unsigned int i;
     
405.         uchar key;
     
406.         do{
     
407.                 lcm_write_cmd(0x01);
     
408.                 lcm_write_cmd(0x06);
     
409.                 lcm_setxy(0,1);
     
410.                 lcm_write_string("input password");
     
411.                 lcm_setxy(0,2);
     
412.                 lcm_write_string("please press 1");
     
413.                 for(i=0;i<30000;i++)
     
414.                 {
     
415.                         key=get_key();
     
416.                         if((key==no1)||(key==no2))        break;
     
417.                 }
     
418.                 if((key!=no1)&&(key!=no2))
     
419.                 {
     
420.                         lcm_write_cmd(0x01);
     
421.                         lcm_write_cmd(0x06);
     
422.                         lcm_setxy(0,1);
     
423.                         lcm_write_string("change password");
     
424.                         lcm_setxy(0,2);
     
425.                         lcm_write_string("please press 2");
     
426.                         for(i=0;i<30000;i++)
     
427.                         {
     
428.                                 key=get_key();
     
429.                                 if((key==no1)||(key==no2))        break;
     
430.                         }
     
431.                 }
     
432.                 }
     
433.         while((key!=no1)&&(key!=no2));
     
434.         return(key);
     
435. }
     
436. 
     
437. bit input_password(uchar *password)
     
438. {
     
439.         uchar counter;
     
440.         uchar key;
     
441.         lcm_setxy(0,2);
     
442.         for(counter=0;counter<7;counter++)
     
443.         {
     
444.                 longdelay(3);
     
445.                 if(counter<6)
     
446.                 {
     
447.                         do{
     
448.                                 key=get_key();
     
449.                              }
     
450.                     while(key==0x00);
     
451.                         if((key!=backspace)&&(key!=enter))
     
452.                         {
     
453.                                 lcm_write_data('*');
     
454.                                 password[counter]=key;
     
455.                         }
     
456.                         if(key==backspace)
     
457.                         {
     
458.                                 if(counter>0)
     
459.                                 {
     
460.                                         lcm_setxy(--counter,2);
     
461.                                         lcm_write_data(' ');
     
462.                                         password[counter]=0x00;
     
463.                                         lcm_setxy(counter,2);
     
464.                                         counter--;
     
465.                                 }
     
466.                         }
     
467.                         if(key==enter)
     
468.                         {
     
469.                                 lcm_setxy(0,1);                               
     
470.                                 return(        0);
     
471.                         }               
     
472.                 }
     
473.                 if(counter==6)
     
474.                 {
     
475.                         do{
     
476.                                 key=get_key();
     
477.                              }
     
478.                         while((key!=backspace)&&(key!=enter));
     
479.                         if(key==backspace)
     
480.                         {
     
481.                                 lcm_setxy(--counter,2);
     
482.                                 lcm_write_data(' ');
     
483.                                 password[counter]=0x00;
     
484.                                 lcm_setxy(counter,2);
     
485.                                 counter--;
     
486.                         }
     
487.                         if(key==enter)
     
488.                         {                                                 
     
489.                                 return(1);                       
     
490.                     }
     
491.                 }               
     
492.         }
     
493. }
     
494. 
     
495. void mima()
     
496. {
     
497.         uchar key;
     
498.         uchar idata temp1_password[6]={0,0,0,0,0,0};
     
499.         uchar idata temp3_password[6]={0,0,0,0,0,0};
     
500.         uchar idata temp2_password[6]={0,0,0,0,0,0};
     
501.         uchar idata temp4_password[6]={0,0,0,0,0,0};
     
502.         key=step_choose();
     
503.         if(key==no1)
     
504.         {
     
505.                 I2C_receive_string(temp1_password,6,0x00);
     
506.                 lcm_write_cmd(0x01);
     
507.                 lcm_write_cmd(0x06);
     
508.                 lcm_setxy(2,0);
     
509.                 lcm_write_string("input password");       
     
510.                 if(input_password(temp2_password))
     
511.                 {
     
512.                         convert_code(temp2_password);
     
513.                         if(compare_string(temp1_password,temp2_password))
     
514.                         {
     
515.                                 lcm_setxy(0,2);
     
516.                                 lcm_write_string("correct!");
     
517.                                 longdelay(6);
     
518.                                 return;
     
519.                         }
     
520.                         else
     
521.                         {
     
522.                                 lcm_setxy(0,2);
     
523.                                 lcm_write_string("wrong password");
     
524.                                 longdelay(6);
     
525.                                 return;
     
526.                         }
     
527.                 }
     
528.                 else
     
529.                 {
     
530.                         lcm_setxy(0,2);
     
531.                         lcm_write_string("error!  ");
     
532.                         longdelay(6);
     
533.                 }                 
     
534.         }
     
535.         else
     
536.         {
     
537.                 I2C_receive_string(temp1_password,6,0x00);
     
538.                 lcm_write_cmd(0x01);
     
539.                 lcm_write_cmd(0x06);
     
540.                 lcm_setxy(0,0);
     
541.                 lcm_write_string("input old password");
     
542.             if(input_password(temp2_password))
     
543.                 {
     
544.                         convert_code(temp2_password);
     
545.                         if(compare_string(temp1_password,temp2_password))
     
546.                         {
     
547.                                 lcm_setxy(0,2);
     
548.                                 lcm_write_string("password correct!");
     
549.                                 longdelay(6);
     
550.                                 lcm_write_cmd(0x01);
     
551.                                 lcm_write_cmd(0x06);
     
552.                                 lcm_setxy(0,1);
     
553.                                 lcm_write_string("input new password");
     
554.                                 if(input_password(temp3_password))
     
555.                                 {
     
556.                                         lcm_write_cmd(0x01);
     
557.                                         lcm_write_cmd(0x06);
     
558.                                         lcm_setxy(0,1);
     
559.                                         lcm_write_string("input password again");
     
560.                                         if(input_password(temp4_password))
     
561.                                         {
     
562.                                                 if(compare_string(temp3_password,temp4_password))
     
563.                                                 {
     
564.                                                         convert_code(temp3_password);
     
565.                                                         I2C_send_string(temp3_password,6,0x00);
     
566.                                                         lcm_write_cmd(0x01);
     
567.                                                         lcm_write_cmd(0x06);
     
568.                                                         lcm_setxy(0,1);
     
569.                                                         lcm_write_string("password has");
     
570.                                                         lcm_setxy(0,2);
     
571.                                                         lcm_write_string("been changed");
     
572.                                                         longdelay(10);
     
573.                                                         return;
     
574.                                                 }
     
575.                                                 else
     
576.                                                 {
     
577.                                                    lcm_write_cmd(0x01);
     
578.                                                    lcm_write_cmd(0x06);
     
579.                                                    lcm_setxy(0,1);
     
580.                                                    lcm_write_string("twice input");
     
581.                                                    lcm_setxy(0,2);
     
582.                                                    lcm_write_string("is different");
     
583.                                                    longdelay(10);
     
584.                                                    return;
     
585.                                                 }
     
586.                                         }
     
587.                                         else
     
588.                                         {
     
589.                                                 lcm_setxy(0,2);
     
590.                                                 lcm_write_string("error!  ");
     
591.                                                 longdelay(10);
     
592.                                                 return;
     
593.                                         }
     
594.                                 }
     
595.                                 else
     
596.                                 {
     
597.                                         lcm_setxy(0,2);
     
598.                                         lcm_write_string("error!  ");
     
599.                                         longdelay(10);
     
600.                                         return;
     
601.                                 }
     
602.                         }
     
603.                         else
     
604.                         {
     
605.                                 lcm_setxy(0,2);
     
606.                                 lcm_write_string("wrong password");
     
607.                                 longdelay(6);
     
608.                                 return;
     
609.                         }
     
610.                 }
     
611.                 else
     
612.                 {
     
613.                         lcm_setxy(0,2);
     
614.                         lcm_write_string("error!  ");
     
615.                         longdelay(6);
     
616.                         return;
     
617.                 }                 
     
618.         }
     
619.                           
     
620.                                
     
621. }
     
622. 
     
623. void        int_service(void)        using 0 interrupt        0
     
624. {
     
625.         EA=0;
     
626.         EX0=0;
     
627.         for(int_counter_1=10;int_counter_1>0;int_counter_1--)
     
628.         {
     
629.                 for(int_counter_2=0xffff;int_counter_2>0;int_counter_2--)
     
630.                 {
     
631.                         if(i)
     
632.                         {
     
633.                                 EA=1;
     
634.                                 EX0=1;
     
635.                                 return;
     
636.                         }       
     
637.                 }
     
638.         }
     
639.         lcm_write_cmd(0x01);
     
640.         lcm_write_cmd(0x06);
     
641.         lcm_write_string("rest success!");
     
642.         longdelay(12);
     
643.         I2C_send_string(temp5_password,6,0x00);
     
644. 
     
645.         (*(void(*)())0)();
     
646. }
     
647.   
     
648. 
     
649. 
     
650. void main(void)
     
651. {
     
652.        
     
653.         IT0=1;
     
654.         EX0=1;
     
655.         EA=1;
     
656.        
     
657.         lcm_init();
     
658.     while(1)
     
659.         {
     
660.                 mima();
     
661.         }
     
662. }
     
663.        
     
664.                                
     

复制代码

能换成C语言的吗？

可以，很强

老铁，来个压缩包

老铁，来个安装包

支持支持学习了

不知道为啥下载不了资源了，楼主你能解决一下吗