标题: 单片机红外遥控密码锁原理图与程序源码 [打印本页]

---

作者: 7139    时间: 2018-7-13 10:55
标题: 单片机红外遥控密码锁原理图与程序源码
单片机的密码锁设计程序带红外遥控功能的
电路原理图如下：


制作出来的实物图：


单片机源码：

1. #include <REG52.h>
   
2. #include<intrins.h>
   
3. #define LCM_Data  P0
   
4. #define uchar unsigned char
   
5. #define uint  unsigned int
   
6. //#define w 6                                //定义密码位数
   
7. //时间计算
   
8. #define Imax 14000    //此处为晶振为11.0592时的取值,
   
9. #define Imin 8000    //如用其它频率的晶振时,
   
10. #define Inum1 1450    //要改变相应的取值。
    
11. #define Inum2 700
    
12. #define Inum3 3000
    
13. 
    
14. sbit lcd1602_rs=P2^5;
    
15. sbit lcd1602_rw=P2^6;
    
16. sbit lcd1602_en=P2^7;
    
17. 
    
18. sbit Scl=P3^4;                        //24C02串行时钟
    
19. sbit Sda=P3^5;                        //24C02串行数据
    
20. 
    
21. sbit ALAM = P2^1;                //报警        
    
22. sbit KEY = P3^6;                //开锁
    
23. 
    
24. sbit open_led=P2^2;                //开锁指示灯
    
25. 
    
26. bit  operation=0;                //操作标志位
    
27. bit  pass=0;                        //密码正确标志
    
28. bit  ReInputEn=0;                //重置输入充许标志        
    
29. bit  s3_keydown=0;                //3秒按键标志位
    
30. bit  key_disable=0;                //锁定键盘标志
    
31. 
    
32. unsigned char countt0,second;        //t0中断计数器,秒计数器
    
33. 
    
34. //解码变量
    
35. unsigned char Im[4]={0x00,0x00,0x00,0x00};
    
36. 
    
37. //全局变量
    
38. uchar f;
    
39. unsigned char m,Tc;
    
40. unsigned char IrOK;
    
41. 
    
42. //void Delay5Ms(void);
    
43. 
    
44. unsigned char code a[]={0xFE,0xFD,0xFB,0xF7};                                                                                         //控盘扫描控制表
    
45. 
    
46. unsigned char code start_line[]        = {"password:       "};
    
47. unsigned char code name[]                  = {"===Coded Lock==="};                                                                                                //显示名称
    
48. unsigned char code Correct[]         = {"     correct    "};                                                                                         //输入正确
    
49. unsigned char code Error[]           = {"      error     "};                                                                                          //输入错误
    
50. unsigned char code codepass[]        = {"      pass      "};
    
51. unsigned char code LockOpen[]        = {"      open      "};                                                                                                //OPEN
    
52. unsigned char code SetNew[]         = {"SetNewWordEnable"};
    
53. unsigned char code Input[]           = {"input:          "};                                                                                                //INPUT
    
54. unsigned char code ResetOK[]         = {"ResetPasswordOK "};
    
55. unsigned char code initword[]        = {"Init password..."};
    
56. unsigned char code Er_try[]                = {"error,try again!"};
    
57. unsigned char code again[]                = {"input again     "};
    
58. 
    
59. unsigned char InputData[6];                                                                                                                                //输入密码暂存区
    
60. unsigned char CurrentPassword[6]={1,3,1,4,2,0};                                                                                                                 //当前密码值
    
61. unsigned char TempPassword[6];
    
62. unsigned char N=0;                                //密码输入位数记数
    
63. unsigned char ErrorCont;                        //错误次数计数
    
64. unsigned char CorrectCont;                        //正确输入计数
    
65. unsigned char ReInputCont;                         //重新输入计数
    
66. unsigned char code initpassword[6]={0,0,0,0,0,0};
    
67. 
    
68. 
    
69. //=====================5ms延时==============================
    
70. void Delay5Ms()
    
71. {
    
72.         unsigned int TempCyc = 5552;
    
73.         while(TempCyc--);
    
74. }        
    
75. 
    
76. //===================400ms延时==============================
    
77. void Delay400Ms()
    
78. {
    
79. unsigned char TempCycA = 5;
    
80. unsigned int TempCycB;
    
81. while(TempCycA--)
    
82. {
    
83.   TempCycB=7269;
    
84.   while(TempCycB--);
    
85. }
    
86. }
    
87. 
    
88. //=============================================================================================
    
89. //================================24C02========================================================
    
90. //=============================================================================================
    
91. 
    
92. void mDelay(uint t) //延时
    
93. {
    
94.         uchar i;
    
95.            while(t--)
    
96.            {
    
97.                    for(i=0;i<125;i++)
    
98.                    {;}
    
99.            }
    
100. }
     
101. 
     
102. 
     
103. void Nop()                  //空操作
     
104. {
     
105.          _nop_();
     
106.          _nop_();
     
107.          _nop_();
     
108.          _nop_();
     
109. }
     
110. 
     
111. 
     
112. /*起始条件*/
     
113. 
     
114. void Start(void)
     
115. {
     
116.          Sda=1;
     
117.          Scl=1;
     
118.          Nop();
     
119.          Sda=0;
     
120.          Nop();
     
121. }
     
122. 
     
123. 
     
124. /*停止条件*/
     
125. void Stop(void)
     
126. {
     
127.          Sda=0;
     
128.          Scl=1;
     
129.          Nop();
     
130.          Sda=1;
     
131.          Nop();
     
132. }
     
133. 
     
134. /*应答位*/
     
135. void Ack(void)
     
136. {
     
137.         Sda=0;
     
138.         Nop();
     
139.         Scl=1;
     
140.         Nop();
     
141.         Scl=0;
     
142. }
     
143. 
     
144. /*反向应答位*/
     
145. void NoAck(void)
     
146. {
     
147.          Sda=1;
     
148.          Nop();
     
149.          Scl=1;
     
150.          Nop();
     
151.          Scl=0;
     
152. }        
     
153. 
     
154. /*发送数据子程序，Data为要求发送的数据*/
     
155. void Send(uchar Data)
     
156. {
     
157.            uchar BitCounter=8;
     
158.            uchar temp;
     
159.            do
     
160.            {
     
161.                    temp=Data;
     
162.                    Scl=0;
     
163.                    Nop();
     
164.                    if((temp&0x80)==0x80)
     
165.                    Sda=1;
     
166.                    else
     
167.                    Sda=0;
     
168.                    Scl=1;
     
169.                    temp=Data<<1;
     
170.                    Data=temp;
     
171.                    BitCounter--;
     
172.            }
     
173.            while(BitCounter);
     
174.            Scl=0;
     
175. }
     
176. 
     
177. /*读一字节的数据，并返回该字节值*/
     
178. uchar Read()
     
179. {
     
180.     uchar temp=0;
     
181.         uchar temp1=0;
     
182.         uchar BitCounter=8;
     
183.         Sda=1;
     
184.         do{
     
185.         Scl=0;
     
186.         Nop();
     
187.         Scl=1;
     
188.         Nop();
     
189.         if(Sda)
     
190.         temp=temp|0x01;
     
191.         else
     
192.         temp=temp&0xfe;
     
193.         if(BitCounter-1)
     
194.         {
     
195.         temp1=temp<<1;
     
196.         temp=temp1;
     
197.         }
     
198.         BitCounter--;
     
199.         }
     
200.         while(BitCounter);
     
201.         return(temp);
     
202.         }
     
203. 
     
204. void WrToROM(uchar Data[],uchar Address,uchar Num)
     
205. {
     
206.   uchar i;
     
207.   uchar *PData;
     
208.   PData=Data;
     
209.   for(i=0;i<Num;i++)
     
210.   {
     
211.   Start();
     
212.   Send(0xa0);
     
213.   Ack();
     
214.   Send(Address+i);
     
215.   Ack();
     
216.   Send(*(PData+i));
     
217.   Ack();
     
218.   Stop();
     
219.   mDelay(20);
     
220.   }
     
221. }
     
222. 
     
223. void RdFromROM(uchar Data[],uchar Address,uchar Num)
     
224. {
     
225.   uchar i;
     
226.   uchar *PData;
     
227.   PData=Data;
     
228.   for(i=0;i<Num;i++)
     
229.   {
     
230.   Start();
     
231.   Send(0xa0);
     
232.   Ack();
     
233.   Send(Address+i);
     
234.   Ack();
     
235.   Start();
     
236.   Send(0xa1);
     
237.   Ack();
     
238.   *(PData+i)=Read();
     
239.   Scl=0;
     
240.   NoAck();
     
241.   Stop();
     
242.   }
     
243. }
     
244. 
     
245. 
     
246. //==================================================================================================
     
247. //=======================================LCD1602====================================================
     
248. //==================================================================================================
     
249. 
     
250. #define yi 0x80 //LCD第一行的初始位置,因为LCD1602字符地址首位D7恒定为1（100000000=80）
     
251. #define er 0x80+0x40 //LCD第二行初始位置（因为第二行第一个字符位置地址是0x40）
     
252. 
     
253. 
     
254. //----------------延时函数，后面经常调用----------------------
     
255. void delay(uint xms)//延时函数，有参函数
     
256. {
     
257.         uint x,y;
     
258.         for(x=xms;x>0;x--)
     
259.          for(y=110;y>0;y--);
     
260. }
     
261. 
     
262. //--------------------------写指令---------------------------
     
263. void write_1602com(uchar com)//****液晶写入指令函数****
     
264. {
     
265.         lcd1602_rs=0;//数据/指令选择置为指令
     
266.         lcd1602_rw=0; //读写选择置为写
     
267.         P0=com;//送入数据
     
268.         delay(1);
     
269.         lcd1602_en=1;//拉高使能端，为制造有效的下降沿做准备
     
270.         delay(1);
     
271.         lcd1602_en=0;//en由高变低，产生下降沿，液晶执行命令
     
272. }
     
273. 
     
274. //-------------------------写数据-----------------------------
     
275. void write_1602dat(uchar dat)//***液晶写入数据函数****
     
276. {
     
277.         lcd1602_rs=1;//数据/指令选择置为数据
     
278.         lcd1602_rw=0; //读写选择置为写
     
279.         P0=dat;//送入数据
     
280.         delay(1);
     
281.         lcd1602_en=1; //en置高电平，为制造下降沿做准备
     
282.         delay(1);
     
283.         lcd1602_en=0; //en由高变低，产生下降沿，液晶执行命令
     
284. }
     
285. 
     
286. //-------------------------初始化-------------------------
     
287. void lcd_init()
     
288. {
     
289.         write_1602com(0x01);//清显示
     
290.         write_1602com(0x38);//设置液晶工作模式，意思：16*2行显示，5*7点阵，8位数据
     
291.         write_1602com(0x0c);//开显示不显示光标
     
292.         write_1602com(0x06);//整屏不移动，光标自动右移
     
293. }
     
294. //========================================================================================
     
295. //=========================================================================================
     
296. 
     
297. 
     
298. 
     
299. 
     
300. //==============将按键值编码为数值=========================
     
301. unsigned char coding(unsigned char m1,unsigned char hh)         
     
302. {
     
303.         unsigned char k;
     
304.         if(IrOK==1)
     
305.         {
     
306.                 IrOK=0;
     
307.                 switch(m1)
     
308.                 {
     
309.                         case (0x0c): k=1;break;
     
310.                         case (0x18): k=2;break;
     
311.                         case (0x5e): k=3;break;
     
312. //                        case (0xff): k='A';break;         //
     
313.                         case (0x08): k=4;break;               
     
314.                         case (0x1c): k=5;break;
     
315.                         case (0x5a): k=6;break;
     
316. //                        case (0x82): k='B';break;           //
     
317.                         case (0x42): k=7;break;
     
318.                         case (0x52): k=8;break;
     
319.                         case (0x4a): k=9;break;
     
320. //                        case (0x84): k='C';break;        //
     
321.                         case (0x43): k='*';break;          //撤销
     
322.                         case (0x16): k=0;break;
     
323.                         case (0x15): k='#';break;           //确认键
     
324.                         case (0x0d): k='D';break;           //重设密码        
     
325.                         case (0x45): k='A';break;         //
     
326.                         case (0x47): k='A';break;         //
     
327.                         case (0x44): k='A';break;         //
     
328.                         case (0x40): k='A';break;         //
     
329.                         case (0x07): k='A';break;         //        
     
330.                         case (0x09): k='A';break;         //        
     
331.                         case (0x19): k='A';break;         //        
     
332. //                        default:;
     
333.                 }
     
334.         }
     
335.         else
     
336.         {
     
337.                 switch(hh)
     
338.                 {
     
339.                         case (0x11): k=1;break;
     
340.                         case (0x21): k=2;break;
     
341.                         case (0x41): k=3;break;
     
342.                         case (0x81): k='A';break;
     
343.                         case (0x12): k=4;break;
     
344.                         case (0x22): k=5;break;
     
345.                         case (0x42): k=6;break;
     
346.                         case (0x82): k='B';break;
     
347.                         case (0x14): k=7;break;
     
348.                         case (0x24): k=8;break;
     
349.                         case (0x44): k=9;break;
     
350.                         case (0x84): k='C';break;
     
351.                         case (0x18): k='*';break;
     
352.                         case (0x28): k=0;break;
     
353.                         case (0x48): k='#';break;
     
354.                         case (0x88): k='D';break;
     
355. //                        default:;
     
356.                 }
     
357.         }
     
358.         return(k);
     
359. }
     
360. 
     
361. 
     
362. //=====================按键检测并返回按键值===============================
     
363. unsigned char keynum()
     
364. {
     
365.          unsigned char row,col,i;
     
366.          P1=0xf0;
     
367.          if((P1&0xf0)!=0xf0)
     
368.          {
     
369.                    Delay5Ms();
     
370.         Delay5Ms();
     
371.                    if((P1&0xf0)!=0xf0)
     
372.                 {
     
373.                     row=P1^0xf0;          //确定行线
     
374.                         i=0;
     
375.                         P1=a[i];                  //精确定位
     
376.                         while(i<4)
     
377.                         {
     
378.                                  if((P1&0xf0)!=0xf0)
     
379.                                   {
     
380.                                            col=~(P1&0xff);          //确定列线
     
381.                                            break;            //已定位后提前退出   
     
382.                                   }
     
383.                                 else
     
384.                                   {
     
385.                                            i++;
     
386.                                            P1=a[i];
     
387.                                   }
     
388.                         }
     
389.                 }
     
390.                 else
     
391.                 {
     
392.                         return 0;
     
393.                 }
     
394.         
     
395.                 while((P1&0xf0)!=0xf0);
     
396. 
     
397.                 return (row|col);                         //行线与列线组合后返回
     
398.          }
     
399.          else return 0;                                 //无键按下时返回0
     
400. }
     
401. 
     
402. 
     
403. 
     
404. 
     
405. //=======================一声提示音，表示有效输入========================
     
406. void OneAlam()
     
407. {
     
408.         ALAM=0;
     
409.         Delay5Ms();
     
410.     ALAM=1;
     
411. }
     
412. 
     
413. //========================二声提示音，表示操作成功========================
     
414. void TwoAlam()
     
415. {
     
416.         ALAM=0;
     
417.         Delay5Ms();
     
418.     ALAM=1;
     
419.     Delay5Ms();
     
420.         ALAM=0;
     
421.         Delay5Ms();
     
422.     ALAM=1;
     
423. }
     
424. 
     
425. //========================三声提示音,表示错误========================
     
426. void ThreeAlam()
     
427. {
     
428.         ALAM=0;
     
429.         Delay5Ms();
     
430.     ALAM=1;
     
431.     Delay5Ms();
     
432.         ALAM=0;
     
433.         Delay5Ms();
     
434.     ALAM=1;
     
435.     Delay5Ms();
     
436.         ALAM=0;
     
437.         Delay5Ms();
     
438.     ALAM=1;
     
439. 
     
440. }
     
441. 
     
442. //=====================显示输入的N个数字，用H代替以便隐藏============================
     
443. void DisplayOne()
     
444. {
     
445. //        DisplayOneChar(9+N,1,'*');
     
446.         write_1602com(yi+5+N);
     
447.         write_1602dat('*');
     
448. }
     
449. 
     
450. //=======================显示提示输入=========================
     
451. void DisplayChar()
     
452. {
     
453.         unsigned char i;
     
454.         if(pass==1)
     
455.         {
     
456.                 //DisplayListChar(0,1,LockOpen);
     
457.                 write_1602com(er);
     
458.                 for(i=0;i<16;i++)
     
459.                 {
     
460.                         write_1602dat(LockOpen[i]);        
     
461.                 }
     
462.         }
     
463.         else
     
464.         {
     
465.                 if(N==0)
     
466.                 {
     
467.                         //DisplayListChar(0,1,Error);
     
468.                         write_1602com(er);
     
469.                         for(i=0;i<16;i++)
     
470.                         {
     
471.                                 write_1602dat(Error[i]);        
     
472.                         }
     
473.                 }
     
474.                 else
     
475.                 {
     
476.                         //DisplayListChar(0,1,start_line);        
     
477.                         write_1602com(er);
     
478.                         for(i=0;i<16;i++)
     
479.                         {
     
480.                                 write_1602dat(start_line[i]);        
     
481.                         }
     
482.                 }
     
483.         }
     
484. }
     
485. 
     
486. void DisplayInput()
     
487. {
     
488.         unsigned char i;
     
489.         if(CorrectCont==1)
     
490.         {
     
491.                 //DisplayListChar(0,0,Input);
     
492.                 write_1602com(er);
     
493.                 for(i=0;i<16;i++)
     
494.                 {
     
495.                         write_1602dat(Input[i]);        
     
496.                 }
     
497.         }
     
498. }
     
499. 
     
500. 
     
501. //========================重置密码==================================================
     
502. //==================================================================================
     
503. void ResetPassword()
     
504. {
     
505.         unsigned char i;        
     
506.         unsigned char j;
     
507.         if(pass==0)
     
508.         {
     
509.                 pass=0;
     
510.                 DisplayChar();
     
511.                 ThreeAlam();
     
512.         }
     
513.         else
     
514.         {
     
515.             if(ReInputEn==1)
     
516.                 {
     
517.                         if(N==6)
     
518.                         {
     
519.                                 ReInputCont++;                                
     
520.                                 if(ReInputCont==2)
     
521.                                 {
     
522.                                         for(i=0;i<6;)
     
523.                                         {
     
524.                                                 if(TempPassword[i]==InputData[i])        //将两次输入的新密码作对比
     
525.                                                         i++;
     
526.                                                 else
     
527.                                                 {
     
528.                                                         //DisplayListChar(0,1,Error);
     
529.                                                         write_1602com(er);
     
530.                                                         for(j=0;j<16;j++)
     
531.                                                         {
     
532.                                                                 write_1602dat(Error[j]);        
     
533.                                                         }
     
534.                                                         ThreeAlam();                        //错误提示        
     
535.                                                         pass=0;
     
536.                                                         ReInputEn=0;                        //关闭重置功能，
     
537.                                                         ReInputCont=0;
     
538.                                                         DisplayChar();
     
539.                                                         break;
     
540.                                                 }
     
541.                                         }
     
542.                                         if(i==6)
     
543.                                         {
     
544.                                                 //DisplayListChar(0,1,ResetOK);
     
545.                                                 write_1602com(er);
     
546.                                                 for(j=0;j<16;j++)
     
547.                                                 {
     
548.                                                         write_1602dat(ResetOK[j]);        
     
549.                                                 }
     
550. 
     
551.                                                 TwoAlam();                                //操作成功提示
     
552.                                                  WrToROM(TempPassword,0,6);                //将新密码写入24C02存储
     
553.                                                 ReInputEn=0;
     
554.                                         }
     
555.                                         ReInputCont=0;
     
556.                                         CorrectCont=0;
     
557.                                 }
     
558.                                 else
     
559.                                 {
     
560.                                         OneAlam();
     
561.                                         //DisplayListChar(0, 1, again);                 //显示再次输入一次
     
562.                                         write_1602com(er);
     
563.                                         for(j=0;j<16;j++)
     
564.                                         {
     
565.                                                 write_1602dat(again[j]);        
     
566.                                         }                                       
     
567.                                         for(i=0;i<6;i++)
     
568.                                         {
     
569.                                                 TempPassword[i]=InputData[i];                //将第一次输入的数据暂存起来                                                
     
570.                                         }
     
571.                                 }
     
572. 
     
573.                         N=0;                                                //输入数据位数计数器清零
     
574.                    }
     
575.             }
     
576.         }
     
577. 
     
578. }
     
579. 
     
580. 
     
581. 
     
582. //=======================输入密码错误超过三过，报警并锁死键盘======================
     
583. void Alam_KeyUnable()
     
584. {
     
585.         P1=0x00;
     
586.         {
     
587.                 ALAM=~ALAM;
     
588.                 Delay5Ms();
     
589.         }
     
590. }
     
591. 
     
592. 
     
593. //=======================取消所有操作============================================
     
594. void Cancel()
     
595. {        
     
596.         unsigned char i;
     
597.         unsigned char j;
     
598.         //DisplayListChar(0, 1, start_line);
     
599.         write_1602com(er);
     
600.         for(j=0;j<16;j++)
     
601.         {
     
602.                 write_1602dat(start_line[j]);        
     
603.         }
     
604.         TwoAlam();                                //提示音
     
605.         for(i=0;i<6;i++)
     
606.         {
     
607.                 InputData[i]=0;
     
608.         }
     
609.         KEY=1;                                        //关闭锁
     
610.         ALAM=1;                                        //报警关
     
611.         operation=0;                        //操作标志位清零
     
612.         pass=0;                                        //密码正确标志清零
     
613.         ReInputEn=0;                        //重置输入充许标志清零
     
614. //        ErrorCont=0;                        //密码错误输入次数清零
     
615.         CorrectCont=0;                        //密码正确输入次数清零
     
616.         ReInputCont=0;                        //重置密码输入次数清零
     
617.         open_led=1;
     
618.         s3_keydown=0;
     
619.         key_disable=0;
     
620.         N=0;                                        //输入位数计数器清零
     
621. }
     
622. 
     
623. 
     
624. //==========================确认键，并通过相应标志位执行相应功能===============================
     
625. void Ensure()
     
626. {        
     
627.         unsigned char i,j;
     
628.         RdFromROM(CurrentPassword,0,6);                                         //从24C02里读出存储密码
     
629.     if(N==6)
     
630.         {
     
631.             if(ReInputEn==0)                                                        //重置密码功能未开启
     
632.                 {
     
633.                         for(i=0;i<6;)
     
634.                            {                                       
     
635.                                 if(CurrentPassword[i]==InputData[i])
     
636.                                 {
     
637.                                         i++;
     
638.                                 }
     
639.                                 else
     
640.                                 {
     
641.                                         i=7;                        
     
642.                                         ErrorCont++;
     
643.                                         if(ErrorCont>=3&&KEY==1)                        //错误输入计数达三次时，报警并锁定键盘
     
644.                                         {
     
645.                                                 write_1602com(er);
     
646.                                                 for(i=0;i<16;i++)
     
647.                                                 {
     
648.                                                         write_1602dat(Error[i]);        
     
649.                                                 }
     
650.                                                 Alam_KeyUnable();
     
651.                                                 TR0=1;                                //开启定时
     
652.                                                 key_disable=1;                        //锁定键盘
     
653.                                                 pass=0;
     
654.                                                 break;        
     
655.                                         }
     
656.                                 }  
     
657.                         }
     
658. 
     
659.                         if(i==6)
     
660.                         {
     
661.                                 CorrectCont++;
     
662.                                 if(CorrectCont==1)                                //正确输入计数，当只有一次正确输入时，开锁，
     
663.                                 {
     
664.                                         //DisplayListChar(0,1,LockOpen);
     
665.                                         write_1602com(er);
     
666.                                         for(j=0;j<16;j++)
     
667.                                         {
     
668.                                                 write_1602dat(LockOpen[j]);        
     
669.                                         }
     
670.                                         TwoAlam();                        //操作成功提示音
     
671.                                         ErrorCont=0;
     
672.                                         KEY=0;                                                                                        //开锁
     
673.                                         pass=1;                                                                                        //置正确标志位
     
674.                                         TR0=1;                                                                                        //开启定时
     
675.                                         open_led=0;                                                                                //开锁指示灯亮
     
676.                                         for(j=0;j<6;j++)                                                                //将输入清除
     
677.                                         {
     
678.                                                 InputData[i]=0;
     
679.                                         }
     
680.                                 }        
     
681.                                 else                                                                                                //当两次正确输入时，开启重置密码功能
     
682.                                 {
     
683.                                         //DisplayListChar(0,1,SetNew);
     
684.                                         write_1602com(er);
     
685.                                         for(j=0;j<16;j++)
     
686.                                         {
     
687.                                                 write_1602dat(SetNew[j]);        
     
688.                                         }
     
689.                                         TwoAlam();                                                                            //操作成功提示
     
690.                                         ReInputEn=1;                                                                        //允许重置密码输入
     
691.                                         CorrectCont=0;                                                                        //正确计数器清零
     
692.                                 }
     
693.                           }
     
694.         
     
695.                         else                        //=========================当第一次使用或忘记密码时可以用131420对其密码初始化============
     
696.                         {
     
697.                                 if((InputData[0]==1)&&(InputData[1]==3)&&(InputData[2]==1)&&(InputData[3]==4)&&(InputData[4]==2)&&(InputData[5]==0))
     
698.                                    {
     
699.                                         WrToROM(initpassword,0,6);                                 //强制将初始密码写入24C02存储
     
700.                                         //DisplayListChar(0,1,initword);                        //显示初始化密码
     
701.                                         write_1602com(er);
     
702.                                         for(j=0;j<16;j++)
     
703.                                         {
     
704.                                                 write_1602dat(initword[j]);        
     
705.                                         }
     
706.                                         TwoAlam();
     
707.                                         Delay400Ms();
     
708.                                         TwoAlam();
     
709.                                         N=0;
     
710.                                 }
     
711.                                 else
     
712.                                 {
     
713.                                         //DisplayListChar(0,1,Error);
     
714.                                         write_1602com(er);
     
715.                                         for(j=0;j<16;j++)
     
716.                                         {
     
717.                                                 write_1602dat(Error[j]);        
     
718.                                         }
     
719.                                          ThreeAlam();                                                                                //错误提示音
     
720.                                         pass=0;        
     
721.                                 }
     
722.                         }
     
723.                 }
     
724. 
     
725.                 else                                                                                        //当已经开启重置密码功能时，而按下开锁键，
     
726.                 {
     
727.                         //DisplayListChar(0,1,Er_try);
     
728.                         write_1602com(er);
     
729.                         for(j=0;j<16;j++)
     
730.                         {
     
731.                                 write_1602dat(Er_try[j]);        
     
732.                         }
     
733.                         ThreeAlam();
     
734.                 }
     
735.         }
     
736. 
     
737.         else
     
738.         {
     
739.                 //DisplayListChar(0,1,Error);
     
740.                 write_1602com(er);
     
741.                 for(j=0;j<16;j++)
     
742.                 {
     
743.                         write_1602dat(Error[j]);        
     
744.                 }
     
745. 
     
746.                  ThreeAlam();                                                                                //错误提示音
     
747.                 pass=0;        
     
748.         }
     
749.         
     
750.         N=0;                                                                                                        //将输入数据计数器清零，为下一次输入作准备
     
751. 
     
752.         operation=1;
     
753. }
     
754. 
     
755. 
     
756. //==============================主函数===============================
     
757. void main()
     
758. {
     
759.          unsigned char KEY,NUM;
     
760.         unsigned char i,j;
     
761.          P1=0xFF;
     
762.         EA=1;
     
763.         TMOD=0x11;
     
764.         IT1=1;//下降沿有效
     
765.         EX1=1;//外部中断1开
     
766.            
     
767.         TH0=0;//T0赋初值
     
768.         TL0=0;
     
769.         TR0=0;//t0开始计时
     
770.          TL1=0xB0;
     
771.          TH1=0x3C;
     
772.          ET1=1;        
     
773.          TR1=0;
     
774.          Delay400Ms();         //启动等待，等LCM讲入工作状态
     
775.          lcd_init();         //LCD初始化
     
776.         write_1602com(yi);//日历显示固定符号从第一行第0个位置之后开始显示
     
777.         for(i=0;i<16;i++)
     
778.         {
     
779.                 write_1602dat(name[i]);//向液晶屏写日历显示的固定符号部分
     
780.         }
     
781.         write_1602com(er);//时间显示固定符号写入位置，从第2个位置后开始显示
     
782.         for(i=0;i<16;i++)
     
783.         {
     
784.                 write_1602dat(start_line[i]);//写显示时间固定符号，两个冒号
     
785.         }
     
786.         write_1602com(er+9);        //设置光标位置
     
787.         write_1602com(0x0f);        //设置光标为闪烁
     
788.          Delay5Ms(); //延时片刻(可不要)
     
789. 
     
790.          N=0;                                                                                                                //初始化数据输入位数
     
791.          while(1)
     
792.          {
     
793.                 if(key_disable==1)
     
794.                         Alam_KeyUnable();
     
795.                 else
     
796.                         ALAM=1;                                                                //关报警
     
797. 
     
798.                 KEY=keynum();
     
799.                 if(KEY!=0||IrOK==1)
     
800.                 {        
     
801.                         if(key_disable==1)
     
802.                         {
     
803.                                 second=0;
     
804.                         }
     
805.                         else
     
806.                         {
     
807.                                 NUM=coding(Im[2],KEY);
     
808.                                 {
     
809.                                         switch(NUM)
     
810.                                         {
     
811.                                                 case ('A'):         ;                                         break;
     
812.                                                 case ('B'):                ;                                     break;
     
813.                                                 case ('C'):         ;                                         break;
     
814.                                                 case ('D'): ResetPassword();                break;      //重新设置密码
     
815.                                                 case ('*'): Cancel();                                break;      //取消当前输入
     
816.                                                 case ('#'): Ensure();                                 break;           //确认键，
     
817.                                                 default:
     
818.                                                 {        
     
819.                                                         //DisplayListChar(0,1,Input);
     
820.                                                         write_1602com(er);
     
821.                                                         for(i=0;i<16;i++)
     
822.                                                         {
     
823.                                                                 write_1602dat(Input[i]);
     
824.                                                         }
     
825.                                                     operation=0;
     
826.                                                         if(N<6)                                                           //当输入的密码少于6位时，接受输入并保存，大于6位时则无效。
     
827.                                                         {  
     
828.                                                                 OneAlam();                                                                //按键提示音                                                
     
829.                                                                 //DisplayOneChar(6+N,1,'*');
     
830.                                                                  for(j=0;j<=N;j++)
     
831.                                                                 {
     
832.                                                                         write_1602com(er+6+j);
     
833.                                                                         write_1602dat('*');
     
834.                                                                 }
     
835.                                                                 InputData[N]=NUM;
     
836.                                                                 N++;
     
837.                                                         }
     
838.                                                         else                                                                                //输入数据位数大于6后，忽略输入
     
839.                                                         {
     
840.                                                                 N=6;
     
841.                                                                  break;
     
842.                                                         }
     
843.                                                 }
     
844.                                         }
     
845.                                 }
     
846.                         }
     
847.                  }
     
848.         }
     
849. }
     
850. 
     
851. //*********************************中断服务函数**************************************
     
852. void  time1_int() interrupt 3
     
853. {
     
854.          TL1=0xB0;
     
855.          TH1=0x3C;
     
856.          countt0++;
     
857.           if(countt0==20)
     
858.            {
     
859.                 countt0=0;
     
860.                 second++;
     
861.                 if(pass==1)
     
862.                 {
     
863.                         if(second==1)
     
864.                         {
     
865.                                 open_led=1;                        //关指示灯
     
866.                                 TR1=0;                                //关定时器
     
867.                                 TL1=0xB0;
     
868.                                  TH1=0x3C;
     
869.                                 second=0;
     
870.                         }
     
871.                 }
     
872.                 else
     
873.                 {
     
874.                         if(second==3)
     
875.                         {
     
876.                                 TR1=0;
     
877.                                 second=0;
     
878.                                 key_disable=0;        
     
879.                                 s3_keydown=0;        
     
880.                                 TL1=0xB0;
     
881.                                 TH1=0x3C;
     
882.                         }
     
883.                         else
     
884.                             TR1=1;
     
885.                 }
     
886.                         
     
887.            }
     
888. }
     
889. //外部中断解码程序_外部中断0
     
890. void intersvr1() interrupt 2 using 1
     
891. {
     
892.         TR0=1;
     
893.         Tc=TH0*256+TL0;//提取中断时间间隔时长
     
894.         TH0=0;
     
895.         TL0=0;         //定时中断重新置零
     
896.         if((Tc>Imin)&&(Tc<Imax))
     
897.         {
     
898.                 m=0;
     
899.                 f=1;
     
900.                 return;
     
901.          }       //找到启始码
     
902.          if(f==1)
     
903.         {
     
904.                 if(Tc>Inum1&&Tc<Inum3)
     
905.                 {
     
906.                         Im[m/8]=Im[m/8]>>1|0x80; m++;
     
907.                 }
     
908.             if(Tc>Inum2&&Tc<Inum1)
     
909.                 {
     
910.                         Im[m/8]=Im[m/8]>>1; m++; //取码
     
911.                 }
     
912.                 if(m==32)
     
913.                 {
     
914.                         m=0;  
     
915.                         f=0;
     
916.                         if(Im[2]==~Im[3])
     
917.                         {
     
918.                                 IrOK=1;
     
919.                                 TR0=0;
     
920.                         }
     
921.                         else IrOK=0;   //取码完成后判断读码是否正确
     
922.                 }          //准备读下一码   
     
923.         }
     
924. }

复制代码

电子密码锁红外遥控功能原理图.doc

2018-7-13 10:52 上传

点击文件名下载附件

下载积分: 黑币 -5

72.5 KB, 下载次数: 56, 下载积分: 黑币 -5

Protel Schematic.pdf

2018-7-13 10:52 上传

点击文件名下载附件

下载积分: 黑币 -5

72.32 KB, 下载次数: 47, 下载积分: 黑币 -5

---

作者: hs88    时间: 2018-7-18 14:25
根本没有红外的事，程序没有红外脚的定义，没有红外功能，浪费黑币，

---

作者: hs88    时间: 2018-7-21 09:54
程序没有红外的接入点，红外不起作用，浪费黑币

---

作者: vnbo    时间: 2018-9-26 09:57
看了评论竟然没有用红外啊，遗憾

---

作者: 1263558620    时间: 2019-3-22 16:15

hs88 发表于 2018-7-21 09:54
程序没有红外的接入点，红外不起作用，浪费黑币

不对吧，我到手的程序能用红外但是矩阵没效果

---

作者: lengnuan02    时间: 2019-3-29 23:06
下载下来看一看，虽然不会。。。。

---

作者: lengnuan02    时间: 2019-3-29 23:08
看评论都说没有红外，所以就没有红外功能了吗

---

作者: Ezreal1    时间: 2020-2-27 21:30
为什么我下载下来打不开呢？？？

---

作者: wsh791    时间: 2020-2-29 21:58
谢谢分享

---

作者: LinuxLeeSin    时间: 2020-3-6 11:43
红外不是定义在INT1管脚吗，用中断去做了吗

---

作者: 麒麟儿    时间: 2020-4-13 23:09
这个能吧红外改到INT0口吗 我开发版的红外在INT0上   初学者感觉有点看不懂中断定义

---

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

Powered by Discuz! X3.1