5位51单片机电子密码锁设计

电子密码锁设计

1．实验任务

根据设定好的密码，采用二个按键实现密码的输入功能，当密码输入正确之后，锁就打开，如果输入的三次的密码不正确，就锁定按键3秒钟，同时发现报警声，直到没有按键按下3种后，才打开按键锁定功能；否则在3秒钟内仍有按键按下，就重新锁定按键3秒时间并报警。

2．电路原理图

图4.32.1

3．系统板上硬件连线

（1）． 把“单片机系统”区域中的P0.0/AD0用导线连接到“音频放大模块”区域中的SPK IN端子上；

（2）． 把“音频放大模块”区域中的SPK OUT端子接喇叭和；

（3）． 把“单片机系统”区域中的P2.0/A8－P2.7/A15用8芯排线连接到“四路静态数码显示”区域中的任一个ABCDEFGH端子上；

（4）． 把“单片机系统“区域中的P1.0用导线连接到“八路发光二极管模块”区域中的L1端子上；

（5）． 把“单片机系统”区域中的P3.6/WR、P3.7/RD用导线连接到“独立式键盘”区域中的SP1和SP2端子上；

4．程序设计内容

（1）． 密码的设定，在此程序中密码是固定在程序存储器ROM中，假设预设的密码为“12345”共5位密码。

（2）． 密码的输入问题：

由于采用两个按键来完成密码的输入，那么其中一个按键为功能键，另一个按键为数字键。在输入过程中，首先输入密码的长度，接着根据密码的长度输入密码的位数，直到所有长度的密码都已经输入完毕；或者输入确认功能键之后，才能完成密码的输入过程。进入密码的判断比较处理状态并给出相应的处理过程。

（3）． 按键禁止功能：初始化时，是允许按键输入密码，当有按键按下并开始进入按键识别状态时，按键禁止功能被激活，但启动的状态在3次密码输入不正确的情况下发生的。

5．C语言单片机源程序

1. #include <AT89X52.H>
   
2. 　
   
3. unsigned char code ps[]={1,2,3,4,5};
   
4. unsigned char code dispcode[]={0x3f,0x06,0x5b,0x4f,0x66,
   
5. 0x6d,0x7d,0x07,0x7f,0x6f,0x00,0x40};
   
6. 　
   
7. unsigned char pslen=9;
   
8. unsigned char templen;
   
9. unsigned char digit;
   
10. unsigned char funcount;
    
11. unsigned char digitcount;
    
12. unsigned char psbuf[9];
    
13. bit cmpflag;
    
14. bit hibitflag;
    
15. bit errorflag;
    
16. bit rightflag;
    
17. unsigned int second3;
    
18. unsigned int aa;
    
19. unsigned int bb;
    
20. bit alarmflag;
    
21. bit exchangeflag;
    
22. unsigned int cc;
    
23. unsigned int dd;
    
24. bit okflag;
    
25. unsigned char oka;
    
26. unsigned char okb;
    
27. 　
    
28. void main(void)
    
29. {
    
30. unsigned char i,j;
    
31. P2=dispcode[digitcount];
    
32. TMOD=0x01;
    
33. TH0=(65536-500)/256;
    
34. TL0=(65536-500)%256;
    
35. TR0=1;
    
36. ET0=1;
    
37. EA=1;
    
38. 　
    
39. while(1)
    
40. {
    
41. if(cmpflag==0)
    
42. {
    
43. if(P3_6==0) //function key
    
44. {
    
45. for(i=10;i>0;i--)
    
46. for(j=248;j>0;j--);
    
47. if(P3_6==0)
    
48. {
    
49. if(hibitflag==0)
    
50. {
    
51. funcount++;
    
52. if(funcount==pslen+2)
    
53. {
    
54. funcount=0;
    
55. cmpflag=1;
    
56. }
    
57. P1=dispcode[funcount];
    
58. }
    
59. else
    
60. {
    
61. second3=0;
    
62. }
    
63. while(P3_6==0);
    
64. }
    
65. }
    
66. 　
    
67. if(P3_7==0) //digit key
    
68. {
    
69. for(i=10;i>0;i--)
    
70. for(j=248;j>0;j--);
    
71. if(P3_7==0)
    
72. {
    
73. if(hibitflag==0)
    
74. {
    
75. digitcount++;
    
76. if(digitcount==10)
    
77. {
    
78. digitcount=0;
    
79. }
    
80. P2=dispcode[digitcount];
    
81. if(funcount==1)
    
82. {
    
83. pslen=digitcount;
    
84. templen=pslen;
    
85. }
    
86. else if(funcount>1)
    
87. {
    
88. psbuf[funcount-2]=digitcount;
    
89. }
    
90. }
    
91. else
    
92. {
    
93. second3=0;
    
94. }
    
95. while(P3_7==0);
    
96. }
    
97. }
    
98. }
    
99. else
    
100. {
     
101. cmpflag=0;
     
102. for(i=0;i<pslen;i++)
     
103. {
     
104. if(ps[i]!=psbuf[i])
     
105. {
     
106. hibitflag=1;
     
107. i=pslen;
     
108. errorflag=1;
     
109. rightflag=0;
     
110. cmpflag=0;
     
111. second3=0;
     
112. goto a;
     
113. }
     
114. }
     
115. cc=0;
     
116. errorflag=0;
     
117. rightflag=1;
     
118. hibitflag=0;
     
119. a: cmpflag=0;
     
120. }
     
121. }
     
122. }
     
123. 　
     
124. void t0(void) interrupt 1 using 0
     
125. {
     
126. TH0=(65536-500)/256;
     
127. TL0=(65536-500)%256;
     
128. 　
     
129. if((errorflag==1) && (rightflag==0))
     
130. {
     
131. bb++;
     
132. if(bb==800)
     
133. {
     
134. bb=0;
     
135. alarmflag=~alarmflag;
     
136. }
     
137. if(alarmflag==1)
     
138. {
     
139. P0_0=~P0_0;
     
140. }
     
141. 　
     
142. aa++;
     
143. if(aa==800)
     
144. {
     
145. aa=0;
     
146. P0_1=~P0_1;
     
147. }
     
148. second3++;
     
149. if(second3==6400)
     
150. {
     
151. second3=0;
     
152. hibitflag=0;
     
153. errorflag=0;
     
154. rightflag=0;
     
155. cmpflag=0;
     
156. P0_1=1;
     
157. alarmflag=0;
     
158. bb=0;
     
159. aa=0;
     
160. }
     
161. }
     
162. 　
     
163. if((errorflag==0) && (rightflag==1))
     
164. {
     
165. P0_1=0;
     
166. cc++;
     
167. if(cc<1000)
     
168. {
     
169. okflag=1;
     
170. }
     
171. else if(cc<2000)
     
172. {
     
173. okflag=0;
     
174. }
     
175. else
     
176. {
     
177. errorflag=0;
     
178. rightflag=0;
     
179. hibitflag=0;
     
180. cmpflag=0;
     
181. P0_1=1;
     
182. cc=0;
     
183. oka=0;
     
184. okb=0;
     
185. okflag=0;
     
186. P0_0=1;
     
187. }
     
188. if(okflag==1)
     
189. {
     
190. oka++;
     
191. if(oka==2)
     
192. {
     
193. oka=0;
     
194. P0_0=~P0_0;
     
195. }
     
196. }
     
197. else
     
198. {
     
199. okb++;
     
200. if(okb==3)
     
201. {
     
202. okb=0;
     
203. P0_0=~P0_0;
     
204. }
     
205. }
     
206. }
     
207. }

复制代码