带I2C记忆的电子密码锁protues仿真及程序

I2C芯片




带记忆的电子密码锁仿真工程文件及程序下载：
电子密码锁 - I2C芯片.zip (78.97 KB, 下载次数: 45)

2016-9-25 13:35 上传

点击文件名下载附件


源程序：

1. #include<reg51.h>
   
2. #include"24c02.h"
   
3. #include"1602.h"
   
4. #include"keyscan.h"
   
5. sbit GRE=P2^2;
   
6. sbit RED=P2^3;
   
7. uchar num,shu;
   
8. uchar code table[]="please input key";
   
9. uchar code you[]="you left ";
   
10. uchar code chance[]=" chance";
    
11. uchar code wait[]="please wait 5s";
    
12. uchar code change[]="you can change";
    
13. uchar code the[]="the key";
    
14. uchar code please[]="please input";
    
15. uchar code new[]=" the new key";
    
16. uchar code ok[]="ok try again";
    
17. uchar  key1[6]={1,2,3,4};
    
18. uchar  key[6];
    
19. uchar key_xin[6];
    
20. char key0=0;
    
21. char a,b,chan,c_xin=0;
    
22. void delayms1(uint xms)
    
23. {
    
24.         uint i,j;
    
25.         for(i=0;i<xms;i++)
    
26.                 for(j=0;j<110;j++);
    
27. }
    
28. void main()
    
29. {
    
30.         init_24c02();
    
31.         if(read(0xa0,0)!=0xff)
    
32.         key1[0]=read(0xa0,0);
    
33.         if(read(0xa0,1)!=0xff)
    
34.         key1[1]=read(0xa0,1);
    
35.         if(read(0xa0,2)!=0xff)
    
36.         key1[2]=read(0xa0,2);
    
37.         if(read(0xa0,3)!=0xff)
    
38.         key1[3]=read(0xa0,3);
    
39.         init_1602();
    
40.         write_com(0x80);
    
41.         for(num=0;num<16;num++)
    
42.         {
    
43.                 write_date(table[num]);
    
44.                 delayms1(5);
    
45.         }
    
46.         delayms1(1000);
    
47.         write_com(0x01);
    
48.         write_com(0x80);
    
49.         while(1)
    
50.         {
    
51.                 shu=keyscan();
    
52.                 switch(shu)
    
53.                 {
    
54.                         case 7:
    
55.                                 write_date('7');
    
56.                                 if(c_xin%2==0)
    
57.                                 key[key0++]=7;
    
58.                                 else
    
59.                                 key_xin[key0++]=7;
    
60.                                 break;
    
61.                         case 8:
    
62.                                 write_date('8');
    
63.                                 if(c_xin%2==0)
    
64.                             key[key0++]=8;
    
65.                                 else
    
66.                                 key_xin[key0++]=8;
    
67.                                 break;
    
68.                         case 9:
    
69.                                 write_date('9');
    
70.                                 if(c_xin%2==0)
    
71.                                 key[key0++]=9;
    
72.                                 else
    
73.                                 key_xin[key0++]=9;
    
74.                                 break;
    
75.                         case 4:
    
76.                                 write_date('4');
    
77.                                 if(c_xin%2==0)
    
78.                                 key[key0++]=4;
    
79.                                 else
    
80.                                 key_xin[key0++]=4;
    
81.                                 break;
    
82.                         case 5:
    
83.                                 write_date('5');
    
84.                                 if(c_xin%2==0)
    
85.                                 key[key0++]=5;
    
86.                                 else
    
87.                                 key_xin[key0++]=5;
    
88.                                 break;
    
89.                         case 6:
    
90.                                 write_date('6');
    
91.                                 if(c_xin%2==0)
    
92.                                 key[key0++]=6;
    
93.                                 else
    
94.                                 key_xin[key0++]=6;
    
95.                                 break;
    
96.                         case 1:
    
97.                                 write_date('1');
    
98.                                 if(c_xin%2==0)
    
99.                                 key[key0++]=1;
    
100.                                 else
     
101.                                 key_xin[key0++]=1;
     
102.                                 break;
     
103.                         case 2:
     
104.                                 write_date('2');
     
105.                                 if(c_xin%2==0)
     
106.                                 key[key0++]=2;
     
107.                                 else
     
108.                                 key_xin[key0++]=2;
     
109.                                 break;
     
110.                         case 3:
     
111.                                 write_date('3');
     
112.                                 if(c_xin%2==0)
     
113.                                 key[key0++]=3;
     
114.                                 else
     
115.                                 key_xin[key0++]=3;
     
116.                                 break;
     
117.                         case 0:
     
118.                                 write_date('0');
     
119.                                 if(c_xin%2==0)
     
120.                                 key[key0++]=0;
     
121.                                 else
     
122.                                 key_xin[key0++]=0;
     
123.                                 break;
     
124.                         case 'w':
     
125.                                 key0=0;
     
126.                                 break;
     
127.                         case '=':
     
128.                                 c_xin++;
     
129.                                 if(c_xin%2==1)
     
130.                            {
     
131.                                         write_com(0x01);
     
132.                                         for(b=0;b<12;b++)
     
133.                                         {
     
134.                                                 write_date(please[b]);
     
135.                                                 delayms1(25);
     
136.                                         }
     
137.                                         write_com(0x80+0x40);
     
138.                                         for(b=0;b<12;b++)
     
139.                                         {
     
140.                                                 write_date(new[b]);
     
141.                                                 delayms1(25);
     
142.                                         }
     
143.                                         delayms1(1500);
     
144.                                         write_com(0x01);
     
145.                           }
     
146.                           else
     
147.                           {
     
148.                                   write(0xa0,0,key_xin[0]);
     
149.                                 write(0xa0,1,key_xin[1]);
     
150.                                 write(0xa0,2,key_xin[2]);
     
151.                                 write(0xa0,3,key_xin[3]);
     
152.                                 write_com(0x01);
     
153.                                   for(b=0;b<12;b++)
     
154.                                 {
     
155.                                         write_date(ok[b]);
     
156.                                         delayms(25);
     
157.                                 }
     
158.                                 delayms1(1500);
     
159.                                 write_com(0x01);
     
160.                                 key0=0;
     
161.                           }
     
162.                                 break;
     
163.                 }
     
164.                 if(key0==4&&c_xin%2==0)
     
165.                 {       
     
166.                         delayms1(500);
     
167.                         if(c_xin==0)
     
168.                         {
     
169.                                 for(a=key0-1;a>=0;a--)
     
170.                                 {
     
171.                                         if(key[a]!=key1[a])
     
172.                                         break;
     
173.                                 }
     
174.                         }
     
175.                         else
     
176.                         {
     
177.                                 for(a=key0-1;a>=0;a--)
     
178.                                 {
     
179.                                         if(key[a]!=key_xin[a])
     
180.                                         break;
     
181.                                 }                               
     
182.                         }
     
183.                     key0=0;
     
184.                         if(a>=0)
     
185.                         {
     
186.                                 write_com(0x01);
     
187.                                 write_date('e');
     
188.                                 write_date('r');
     
189.                                 write_date('r');
     
190.                                 write_date('o');
     
191.                                 write_date('r');
     
192.                                 GRE=1;
     
193.                                 RED=0;
     
194.                                 delayms1(600);
     
195.                                 write_com(0x01);
     
196.                                 chan++;
     
197.                                 if(chan<3)
     
198.                                 {
     
199.                                         for(b=0;b<9;b++)
     
200.                                         {
     
201.                                                 write_date(you[b]);
     
202.                                                 delayms1(1);
     
203.                                         }
     
204.                                         write_date(0x30+3-chan);
     
205.                                         for(b=0;b<7;b++)
     
206.                                         {
     
207.                                                 write_date(chance[b]);
     
208.                                                 delayms1(10);
     
209.                                         }
     
210.                                         delayms1(1000);
     
211.                                         write_com(0x01);
     
212.                                 }
     
213.                                 else
     
214.                                 {
     
215.                                         chan=0;
     
216.                                         for(b=0;b<14;b++)
     
217.                                         {
     
218.                                                 write_date(wait[b]);
     
219.                                                 delayms1(100);
     
220.                                         }
     
221.                                         delayms1(5000);
     
222.                                         write_com(0x01);
     
223.                                 }
     
224.                         }
     
225.                         else
     
226.                         {
     
227.                                 write_com(0x01);
     
228.                                 write_date('r');
     
229.                                 write_date('i');
     
230.                                 write_date('g');
     
231.                                 write_date('h');
     
232.                                 write_date('t');
     
233.                                 GRE=0;
     
234.                                 RED=1;
     
235.                                 delayms1(1000);
     
236.                                 write_com(0x01);
     
237.                                 for(b=0;b<14;b++)
     
238.                                 {
     
239.                                         write_date(change[b]);
     
240.                                         delayms1(25);
     
241.                                 }
     
242.                                         write_com(0x80+0x40);
     
243.                                 for(b=0;b<7;b++)
     
244.                                 {
     
245.                                         write_date(the[b]);
     
246.                                         delayms1(25);
     
247.                                 }                                                                                               
     
248.                         }
     
249.                 }
     
250.         }
     
251. }

复制代码

bucuocbucuo

真的好厉害啊

请问下，这个程序能不能更改为设置八位密码呢？可以的话在那里更改？

赞一个