单片机论坛

 找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 192|回复: 0
收起左侧

单片机电子密码锁代码+Proteus仿真(24C02+LCD1602显示)

[复制链接]
a1357787200 发表于 2019-6-12 19:34 | 显示全部楼层 |阅读模式
基于51单片机的电子密码锁按键设置6位密码,输入密码若密码正确,则锁打开。显示open!
密码可以自己修改(6位密码),必须是锁打开时才能改密。为防止误操作,修改密码得输入两次。
1.按键设置6位密码,输入密码若密码正确,则锁打开。显示open!
2.密码可以自己修改(6位密码),必须是锁打开时才能改密。为防止误操作,修改密码得输入两次。
3.若密码输入错误次数超过3次,蜂鸣器报警并且锁定键盘。
4.24C02有复位、掉电保存密码功能
按键排列方式:     1  2 3  A
  4 5  6  B
  7 8  9  C
  * 0  #  D
ABC无定义、 *号键为取消当前操作、#号键为确认、D键为修改密码自己焊接的电路,首次使用时输入:131420,对密码进行初始化,当显示:initpassword,证明密码初始化完成,此时的密码为:000000。然后可以改密了
按下 * 键或复位键,可以关锁并退出。当输入密码错误后,报警并锁定键盘3秒钟。
修改密码:在开锁状态下,再次输入正确的密码并按下 # 键,此时听到两声提示,输入新的六位密码并按 D 键,再重复输入一次新密码并按 D ,会听到两声提示音,表示重设密码成功,内部保存新密码并存储。如两次输入的新密码不一样,则重设密码失败。

仿真原理图如下(proteus仿真工程文件可到本帖附件中下载)
0.png
单片机源程序如下:
  1. //包含头文件
  2. #include <REG51.h>
  3. #include<intrins.h>
  4. //宏定义
  5. #define LCM_Data  P0                  //将P0口定义为LCM_Data
  6. #define uchar unsigned char
  7. #define uint  unsigned int
  8. //1602的控制脚
  9. sbit lcd1602_rs=P2^5;
  10. sbit lcd1602_rw=P2^6;
  11. sbit lcd1602_en=P2^7;

  12. sbit Scl=P3^4;                        //24C02串行时钟
  13. sbit Sda=P3^5;                        //24C02串行数据

  14. sbit ALAM = P2^1;                //报警       
  15. sbit KEY = P3^6;                //开锁

  16. bit  pass=0;                        //密码正确标志
  17. bit  ReInputEn=0;                //重置输入允许标志       
  18. bit  s3_keydown=0;                //3秒按键标志位
  19. bit  key_disable=0;                //锁定键盘标志

  20. unsigned char countt0,second;        //t0中断计数器,秒计数器

  21. void Delay5Ms(void);                //声明延时函数

  22. unsigned char code a[]={0xFE,0xFD,0xFB,0xF7};                                 //控盘扫描控制表
  23. //液晶显示数据数组
  24. unsigned char code start_line[]        = {"password:       "};
  25. unsigned char code name[]                  = {"===Coded Lock==="};        //显示名称
  26. unsigned char code Correct[]         = {"     correct    "};                //输入正确
  27. unsigned char code Error[]           = {"      error     "};          //输入错误
  28. unsigned char code codepass[]        = {"      pass      "};
  29. unsigned char code LockOpen[]        = {"      open      "};                //OPEN
  30. unsigned char code SetNew[]         = {"SetNewWordEnable"};
  31. unsigned char code Input[]           = {"input:          "};                //INPUT
  32. unsigned char code ResetOK[]         = {"ResetPasswordOK "};
  33. unsigned char code initword[]        = {"Init password..."};
  34. unsigned char code Er_try[]                = {"error,try again!"};
  35. unsigned char code again[]                = {"input again     "};

  36. unsigned char InputData[6];                                                                        //输入密码暂存区
  37. unsigned char CurrentPassword[6]={0,0,0,0,0,0};                         //读取EEPROM密码暂存数组
  38. unsigned char TempPassword[6];
  39. unsigned char N=0;                                //密码输入位数记数
  40. unsigned char ErrorCont;                        //错误次数计数
  41. unsigned char CorrectCont;                        //正确输入计数
  42. unsigned char ReInputCont;                         //重新输入计数
  43. unsigned char code initpassword[6]={0,0,0,0,0,0};                        //输入管理员密码后将密码初始为000000
  44. unsigned char code adminpassword[6]={1,3,1,4,2,0};                        //输入管理员密码后将密码初始为000000


  45. //=====================5ms延时==============================
  46. void Delay5Ms(void)
  47. {
  48.         unsigned int TempCyc = 5552;
  49.         while(TempCyc--);
  50. }

  51. //===================400ms延时==============================
  52. void Delay400Ms(void)
  53. {
  54. unsigned char TempCycA = 5;
  55. unsigned int TempCycB;
  56. while(TempCycA--)
  57. {
  58.   TempCycB=7269;
  59.   while(TempCycB--);
  60. }
  61. }

  62. //=============================================================================================
  63. //================================24C02========================================================
  64. //=============================================================================================

  65. void mDelay(uint t) //延时
  66. {
  67.         uchar i;
  68.            while(t--)
  69.            {
  70.                    for(i=0;i<125;i++)
  71.                    {;}
  72.            }
  73. }
  74.    

  75. void Nop(void)                  //空操作
  76. {
  77.         _nop_();                  //仅作延时用一条语句大约1us
  78.         _nop_();
  79.         _nop_();
  80.         _nop_();
  81. }

  82. /*****24c02程序参照24c02时序图*****/
  83. /*起始条件*/

  84. void Start(void)
  85. {
  86.         Sda=1;
  87.         Scl=1;
  88.         Nop();
  89.         Sda=0;
  90.         Nop();
  91. }


  92. /*停止条件*/
  93. void Stop(void)
  94. {
  95.         Sda=0;
  96.         Scl=1;
  97.         Nop();
  98.         Sda=1;
  99.         Nop();
  100. }

  101. /*应答位*/
  102. void Ack(void)
  103. {
  104.         Sda=0;
  105.         Nop();
  106.         Scl=1;
  107.         Nop();
  108.         Scl=0;
  109. }

  110. /*反向应答位*/
  111. void NoAck(void)
  112. {
  113.         Sda=1;
  114.         Nop();
  115.         Scl=1;
  116.         Nop();
  117.         Scl=0;
  118. }

  119. /*发送数据子程序,Data为要求发送的数据*/
  120. void Send(uchar Data)
  121. {
  122.            uchar BitCounter=8;
  123.            uchar temp;
  124.            do
  125.            {
  126.                    temp=Data;                                           //将待发送数据暂存temp
  127.                    Scl=0;
  128.                    Nop();
  129.                    if((temp&0x80)==0x80)                   //将读到的数据&0x80
  130.                    Sda=1;
  131.                    else
  132.                    Sda=0;
  133.                    Scl=1;
  134.                    temp=Data<<1;                                   //数据左移
  135.                    Data=temp;                                           //数据左移后重新赋值Data
  136.                    BitCounter--;                                   //该变量减到0时,数据也就传送完成了
  137.            }
  138.            while(BitCounter);                                   //判断是否传送完成
  139.            Scl=0;
  140. }

  141. /*读一字节的数据,并返回该字节值*/
  142. uchar Read(void)
  143. {
  144.     uchar temp=0;
  145.         uchar temp1=0;
  146.         uchar BitCounter=8;
  147.         Sda=1;
  148.         do
  149.         {
  150.                 Scl=0;
  151.                 Nop();
  152.                 Scl=1;
  153.                 Nop();
  154.                 if(Sda)                                   //数据位是否为1
  155.                         temp=temp|0x01;           //为1 temp的最低位为1(|0x01,就是将最低位变为1)
  156.                 else                                   //如果为0
  157.                         temp=temp&0xfe;           //temp最低位为0(&0xfe(11111110)最低位就是0)
  158.                 if(BitCounter-1)           //BitCounter减1后是否为真
  159.                 {
  160.                         temp1=temp<<1;           //temp左移
  161.                         temp=temp1;
  162.                 }
  163.                 BitCounter--;                   //BitCounter减到0时,数据就接收完了
  164.         }
  165.         while(BitCounter);                   //判断是否接收完成
  166.         return(temp);
  167. }

  168. void WrToROM(uchar Data[],uchar Address,uchar Num)
  169. {
  170.   uchar i;
  171.   uchar *PData;
  172.   PData=Data;
  173.   for(i=0;i<Num;i++)
  174.   {
  175.   Start();
  176.   Send(0xa0);
  177.   Ack();
  178.   Send(Address+i);
  179.   Ack();
  180.   Send(*(PData+i));
  181.   Ack();
  182.   Stop();
  183.   mDelay(20);
  184.   }
  185. }

  186. void RdFromROM(uchar Data[],uchar Address,uchar Num)
  187. {
  188.   uchar i;
  189.   uchar *PData;
  190.   PData=Data;
  191.   for(i=0;i<Num;i++)
  192.   {
  193.   Start();
  194.   Send(0xa0);
  195.   Ack();
  196.   Send(Address+i);
  197.   Ack();
  198.   Start();
  199.   Send(0xa1);
  200.   Ack();
  201.   *(PData+i)=Read();
  202.   Scl=0;
  203.   NoAck();
  204.   Stop();
  205.   }
  206. }


  207. //==================================================================================================
  208. //=======================================LCD1602====================================================
  209. //==================================================================================================

  210. #define yi 0x80 //LCD第一行的初始位置,因为LCD1602字符地址首位D7恒定为1(100000000=80)
  211. #define er 0x80+0x40 //LCD第二行初始位置(因为第二行第一个字符位置地址是0x40)


  212. //----------------延时函数,后面经常调用----------------------
  213. void delay(uint xms)//延时函数,有参函数
  214. {
  215.         uint x,y;
  216.         for(x=xms;x>0;x--)
  217.          for(y=110;y>0;y--);
  218. }

  219. //--------------------------写指令---------------------------
  220. void write_1602com(uchar com)//****液晶写入指令函数****
  221. {
  222.         lcd1602_rs=0;//数据/指令选择置为指令
  223.         lcd1602_rw=0; //读写选择置为写
  224.         P0=com;//送入数据
  225.         delay(1);
  226.         lcd1602_en=1;//拉高使能端,为制造有效的下降沿做准备
  227.         delay(1);
  228.         lcd1602_en=0;//en由高变低,产生下降沿,液晶执行命令
  229. }

  230. //-------------------------写数据-----------------------------
  231. void write_1602dat(uchar dat)//***液晶写入数据函数****
  232. {
  233.         lcd1602_rs=1;//数据/指令选择置为数据
  234.         lcd1602_rw=0; //读写选择置为写
  235.         P0=dat;//送入数据
  236.         delay(1);
  237.         lcd1602_en=1; //en置高电平,为制造下降沿做准备
  238.         delay(1);
  239.         lcd1602_en=0; //en由高变低,产生下降沿,液晶执行命令
  240. }

  241. //-------------------------初始化-------------------------
  242. void lcd_init(void)
  243. {
  244.         write_1602com(0x38);//设置液晶工作模式,意思:16*2行显示,5*7点阵,8位数据
  245.         write_1602com(0x0c);//开显示不显示光标
  246.         write_1602com(0x06);//整屏不移动,光标自动右移
  247.         write_1602com(0x01);//清显示
  248. }
  249. //========================================================================================
  250. //=========================================================================================
  251. //==============将按键值编码为数值=========================
  252. unsigned char coding(unsigned char m)         
  253. {
  254.         unsigned char k;
  255.         switch(m)
  256.         {
  257.                 case (0x11): k=1;break;
  258.                 case (0x21): k=2;break;
  259.                 case (0x41): k=3;break;
  260.                 case (0x81): k='A';break;
  261.                 case (0x12): k=4;break;
  262.                 case (0x22): k=5;break;
  263.                 case (0x42): k=6;break;
  264.                 case (0x82): k='B';break;
  265.                 case (0x14): k=7;break;
  266.                 case (0x24): k=8;break;
  267.                 case (0x44): k=9;break;
  268.                 case (0x84): k='C';break;
  269.                 case (0x18): k='*';break;
  270.                 case (0x28): k=0;break;
  271.                 case (0x48): k='#';break;
  272.                 case (0x88): k='D';break;
  273.         }
  274.         return(k);
  275. }
  276. //=====================按键检测并返回按键值===============================
  277. unsigned char keynum(void)
  278. {
  279.         unsigned char row,col,i;
  280.         P1=0xf0;
  281.         if((P1&0xf0)!=0xf0)
  282.         {
  283.                    Delay5Ms();
  284.         Delay5Ms();
  285.                    if((P1&0xf0)!=0xf0)
  286.                 {
  287.                     row=P1^0xf0;          //确定行线
  288.                         i=0;
  289.                         P1=a[i];                  //精确定位
  290.                         while(i<4)
  291.                         {
  292.                                  if((P1&0xf0)!=0xf0)
  293.                                   {
  294.                                            col=~(P1&0xff);          //确定列线
  295.                                            break;            //已定位后提前退出   
  296.                                   }
  297.                                 else
  298.                                   {
  299.                                            i++;
  300.                                            P1=a[i];
  301.                                   }
  302.                         }
  303.                 }
  304.                 else
  305.                 {
  306.                         return 0;
  307.                 }
  308.                 while((P1&0xf0)!=0xf0);
  309.                 return (row|col);                         //行线与列线组合后返回
  310.         }
  311.         else return 0;                                 //无键按下时返回0
  312. }
  313. //=======================一声提示音,表示有效输入========================
  314. void OneAlam(void)
  315. {
  316.         ALAM=0;
  317.         Delay5Ms();
  318.     ALAM=1;
  319. }
  320. //========================二声提示音,表示操作成功========================
  321. void TwoAlam(void)
  322. {
  323.         ALAM=0;
  324.         Delay5Ms();
  325.     ALAM=1;
  326.     Delay5Ms();
  327.         ALAM=0;
  328.         Delay5Ms();
  329.     ALAM=1;
  330. }
  331. //========================三声提示音,表示错误========================
  332. void ThreeAlam(void)
  333. {
  334.         ALAM=0;
  335.         Delay5Ms();
  336.     ALAM=1;
  337.     Delay5Ms();
  338.         ALAM=0;
  339.         Delay5Ms();
  340.     ALAM=1;
  341.     Delay5Ms();
  342.         ALAM=0;
  343.         Delay5Ms();
  344.     ALAM=1;
  345. }
  346. //=======================显示提示输入=========================
  347. void DisplayChar(void)
  348. {
  349.         unsigned char i;
  350.         if(pass==1)
  351.         {
  352.                 //DisplayListChar(0,1,LockOpen);
  353.                 write_1602com(er);                                   //在二行开始显示
  354.                 for(i=0;i<16;i++)
  355.                 {
  356.                         write_1602dat(LockOpen[i]);           //显示open 开锁成功
  357.                 }
  358.         }
  359.         else
  360.         {
  361.                 if(N==0)
  362.                 {
  363.                         //DisplayListChar(0,1,Error);
  364.                         write_1602com(er);
  365.                         for(i=0;i<16;i++)
  366.                         {
  367.                                 write_1602dat(Error[i]);        //显示错误
  368.                         }
  369.                 }
  370.                 else
  371.                 {
  372.                         //DisplayListChar(0,1,start_line);       
  373.                         write_1602com(er);
  374.                         for(i=0;i<16;i++)
  375.                         {
  376.                                 write_1602dat(start_line[i]);//显示开始输入       
  377.                         }
  378.                 }
  379.         }
  380. }

  381. //========================重置密码==================================================
  382. //==================================================================================
  383. void ResetPassword(void)
  384. {
  385.         unsigned char i;       
  386.         unsigned char j;
  387.         if(pass==0)
  388.         {
  389.                 pass=0;                          
  390.                 DisplayChar();           //显示错误
  391.                 ThreeAlam();           //没开锁时按下重置密码报警3声
  392.         }
  393.         else                                   //开锁状态下才能进行密码重置程序
  394.         {
  395.             if(ReInputEn==1)   //开锁状态下,ReInputEn置1,重置密码允许
  396.                 {
  397.                         if(N==6)           //输入6位密码
  398.                         {
  399.                                 ReInputCont++;                        //密码次数计数       
  400.                                 if(ReInputCont==2)                //输入两次密码
  401.                                 {
  402.                                         for(i=0;i<6;)
  403.                                         {
  404.                                                 if(TempPassword[i]==InputData[i])        //将两次输入的新密码作对比
  405.                                                         i++;
  406.                                                 else                                                                //如果两次的密码不同
  407.                                                 {
  408.                                                         //DisplayListChar(0,1,Error);
  409.                                                         write_1602com(er);
  410.                                                         for(j=0;j<16;j++)
  411.                                                         {
  412.                                                                 write_1602dat(Error[j]);        //显示错误Error
  413.                                                         }
  414.                                                         ThreeAlam();                        //错误提示       
  415.                                                         pass=0;                                        //关锁
  416.                                                         ReInputEn=0;                        //关闭重置功能,
  417.                                                         ReInputCont=0;
  418.                                                         DisplayChar();
  419.                                                         break;
  420.                                                 }
  421.                                         }
  422.                                         if(i==6)
  423.                                         {
  424.                                                 //DisplayListChar(0,1,ResetOK);
  425.                                                 write_1602com(er);
  426.                                                 for(j=0;j<16;j++)
  427.                                                 {
  428.                                                         write_1602dat(ResetOK[j]);          //密码修改成功,显示
  429.                                                 }

  430.                                                 TwoAlam();                                //操作成功提示
  431.                                                  WrToROM(TempPassword,0,6);                //将新密码写入24C02存储
  432.                                                 ReInputEn=0;
  433.                                         }
  434.                                         ReInputCont=0;
  435.                                         CorrectCont=0;
  436.                                 }
  437.                                 else                                          //输入一次密码时
  438.                                 {
  439.                                         OneAlam();
  440.                                         //DisplayListChar(0, 1, again);                 //显示再次输入一次
  441.                                         write_1602com(er);
  442.                                         for(j=0;j<16;j++)
  443.                                         {
  444.                                                 write_1602dat(again[j]);                        //显示再输入一次
  445.                                         }                                       
  446.                                         for(i=0;i<6;i++)
  447.                                         {
  448.                                                 TempPassword[i]=InputData[i];                //将第一次输入的数据暂存起来                                               
  449.                                         }
  450.                                 }

  451.                         N=0;                                                //输入数据位数计数器清零
  452.                    }
  453.             }
  454.         }
  455. }
  456. //=======================输入密码错误超过三过,报警并锁死键盘======================
  457. void Alam_KeyUnable(void)
  458. {
  459.         P1=0x00;
  460.         {
  461.                 ALAM=~ALAM;                                 //蜂鸣器一直闪烁鸣响
  462.                 Delay5Ms();
  463.         }
  464. }
  465. //=======================取消所有操作============================================
  466. void Cancel(void)
  467. {       
  468.         unsigned char i;
  469.         unsigned char j;
  470.         //DisplayListChar(0, 1, start_line);
  471.         write_1602com(er);
  472.         for(j=0;j<16;j++)
  473.         {
  474.                 write_1602dat(start_line[j]);          //显示开机输入密码界面
  475.         }
  476.         TwoAlam();                                //提示音
  477.         for(i=0;i<6;i++)
  478.         {
  479.                 InputData[i]=0;                //将输入密码清零
  480.         }
  481.         KEY=1;                                        //关闭锁
  482.         ALAM=1;                                        //报警关
  483.         pass=0;                                        //密码正确标志清零
  484.         ReInputEn=0;                        //重置输入充许标志清零
  485.         ErrorCont=0;                        //密码错误输入次数清零
  486.         CorrectCont=0;                        //密码正确输入次数清零
  487.         ReInputCont=0;                        //重置密码输入次数清零
  488.         s3_keydown=0;
  489.         key_disable=0;                        //锁定键盘标志清零
  490.         N=0;                                        //输入位数计数器清零
  491. }

  492. //==========================确认键,并通过相应标志位执行相应功能===============================
  493. void Ensure(void)
  494. {       
  495.         unsigned char i,j;
  496.         RdFromROM(CurrentPassword,0,6);                                         //从24C02里读出存储密码
  497.     if(N==6)
  498.         {
  499.             if(ReInputEn==0)                                                        //重置密码功能未开启
  500.                 {
  501.                         for(i=0;i<6;)
  502.                            {                                       
  503.                                 if(CurrentPassword[i]==InputData[i])        //判断输入密码和24c02中的密码是否相同
  504.                                 {
  505.                                         i++;                                                                //相同一位 i就+1
  506.                                 }
  507.                                 else                                                                         //如果有密码不同
  508.                                 {                                                                               
  509.                                         ErrorCont++;                                                //错误次数++
  510.                                         if(ErrorCont==3)                        //错误输入计数达三次时,报警并锁定键盘
  511.                                         {
  512.                                                 write_1602com(er);
  513.                                                 for(i=0;i<16;i++)
  514.                                                 {
  515.                                                         write_1602dat(Error[i]);       
  516.                                                 }
  517.                                                 do
  518.                                                 Alam_KeyUnable();
  519.                                                 while(1);
  520.                                         }
  521.                                         else                                         //错误次数小于3次时,锁死键盘3秒,然后重新可以输入
  522.                                         {
  523.                                                 TR0=1;                                //开启定时
  524.                                                 key_disable=1;                        //锁定键盘
  525.                                                 pass=0;                                        //pass位清零
  526.                                                 break;                                        //跳出
  527.                                         }
  528.                                 }
  529.                         }

  530.                         if(i==6)                                         //密码输入对时
  531.                         {
  532.                                 if((InputData[0]==adminpassword[0])&&(InputData[1]==adminpassword[1])&&(InputData[2]==adminpassword[2])&&(InputData[3]==adminpassword[3])&&(InputData[4]==adminpassword[4])&&(InputData[5]==adminpassword[5]))
  533.                                    {
  534.                                         WrToROM(initpassword,0,6);                                 //强制将初始密码写入24C02存储
  535.                                         write_1602com(er);
  536.                                         for(j=0;j<16;j++)
  537.                                         {
  538.                                                 write_1602dat(initword[j]);                                //显示初始化密码
  539.                                         }
  540.                                         TwoAlam();                                                                        //成功提示音
  541.                                         Delay400Ms();                                                                //延时400ms
  542.                                         TwoAlam();                                                                        //成功提示音
  543.                                         N=0;                                                                                //输入位数计数器清零
  544.                                 }
  545.                                 else
  546.                                 {
  547.                                         CorrectCont++;                                        //输入正确变量++
  548.                                         if(CorrectCont==1)                                //正确输入计数,当只有一次正确输入时,开锁
  549.                                         {
  550.                                                 //DisplayListChar(0,1,LockOpen);
  551.                                                 write_1602com(er);
  552.                                                 for(j=0;j<16;j++)
  553.                                                 {
  554.                                                         write_1602dat(LockOpen[j]);                  //显示open开锁画面
  555.                                                 }
  556.                                                 TwoAlam();                        //操作成功提示音
  557.                                                 KEY=0;                                                                                        //开锁
  558.                                                 pass=1;                                                                                        //置正确标志位
  559.                                                 TR0=1;                                                                                        //开启定时
  560.                                                 for(j=0;j<6;j++)                                                                //将输入清除
  561.                                                 {
  562.                                                         InputData[i]=0;                                                                //开锁后将输入位清零
  563.                                                 }
  564.                                         }       
  565.                                         else                                                                                                //当两次正确输入时,开启重置密码功能
  566.                                         {
  567.                                                 write_1602com(er);
  568.                                                 for(j=0;j<16;j++)
  569.                                                 {
  570.                                                         write_1602dat(SetNew[j]);                                        //显示重置密码界面
  571.                                                 }
  572.                                                 TwoAlam();                                                                            //操作成功提示
  573.                                                 ReInputEn=1;                                                                        //允许重置密码输入
  574.                                                 CorrectCont=0;                                                                        //正确计数器清零
  575.                                         }
  576.                                 }
  577.                           }
  578.        
  579.                         else                        //=========================当第一次使用或忘记密码时可以用131420对其密码初始化============
  580.                         {
  581.                                 if((InputData[0]==adminpassword[0])&&(InputData[1]==adminpassword[1])&&(InputData[2]==adminpassword[2])&&(InputData[3]==adminpassword[3])&&(InputData[4]==adminpassword[4])&&(InputData[5]==adminpassword[5]))
  582.                                    {
  583.                                         WrToROM(initpassword,0,6);                                 //强制将初始密码写入24C02存储
  584.                                         write_1602com(er);
  585.                                         for(j=0;j<16;j++)
  586.                                         {
  587.                                                 write_1602dat(initword[j]);                                //显示初始化密码
  588.                                         }
  589.                                         TwoAlam();                                                                        //成功提示音
  590.                                         Delay400Ms();                                                                //延时400ms
  591.                                         TwoAlam();                                                                        //成功提示音
  592.                                         N=0;                                                                                //输入位数计数器清零
  593.                                 }
  594.                                 else                                                                                        //密码输入错误
  595.                                 {
  596.                                         write_1602com(er);
  597.                                         for(j=0;j<16;j++)
  598.                                         {
  599.                                                 write_1602dat(Error[j]);                                 //显示错误信息
  600.                                         }
  601.                                         ThreeAlam();                                                                                //错误提示音
  602.                                         pass=0;       
  603.                                 }
  604.                         }
  605.                 }

  606.                 else                                                                                        //当已经开启重置密码功能时,而按下开锁键,
  607.                 {
  608.                         //DisplayListChar(0,1,Er_try);
  609.                         write_1602com(er);
  610.                         for(j=0;j<16;j++)
  611.                         {
  612.                                 write_1602dat(Er_try[j]);                          //错误,请重新输入
  613.                         }
  614.                         ThreeAlam();                                                          //错误提示音
  615.                 }
  616.         }

  617.         else                                   //密码没有输入到6位时,按下确认键时
  618.         {
  619.                 //DisplayListChar(0,1,Error);
  620.                 write_1602com(er);
  621.                 for(j=0;j<16;j++)
  622.                 {
  623.                         write_1602dat(Error[j]);                 //显示错误
  624.                 }

  625.                 ThreeAlam();                                                                                //错误提示音
  626.                 pass=0;       
  627.         }
  628.        
  629.         N=0;                                                                                                        //将输入数据计数器清零,为下一次输入作准备
  630. }


  631. //==============================主函数===============================
  632. void main(void)
  633. {
  634.         unsigned char KEY,NUM;
  635.         unsigned char i,j;
  636.         P1=0xFF;                                    //P1口复位
  637.         TMOD=0x11;                                   //定义工作方式
  638.         TL0=0xB0;
  639.         TH0=0x3C;                                   //定时器赋初值
  640.         EA=1;                                           //打开中断总开关
  641.         ET0=1;                                           //打开中断允许开关
  642.         TR0=0;                                           //打开定时器开关
  643.         Delay400Ms();         //启动等待,等LCM讲入工作状态
  644.         lcd_init();         //LCD初始化
  645.         write_1602com(yi);//日历显示固定符号从第一行第0个位置之后开始显示
  646.         for(i=0;i<16;i++)
  647.         {
  648.                 write_1602dat(name[i]);//向液晶屏写开机画面
  649.         }
  650.         write_1602com(er);
  651.         for(i=0;i<16;i++)
  652.         {
  653.                 write_1602dat(start_line[i]);//写输入密码等待界面
  654.         }
  655.         write_1602com(er+9);        //设置光标位置
  656.         write_1602com(0x0f);        //设置光标为闪烁
  657.         Delay5Ms(); //延时片刻(可不要)

  658.         N=0;                                                                                                                //初始化数据输入位数
  659.         while(1)                 //进入循环
  660.         {
  661.                 if(key_disable==1)                                                //锁定键盘标志为1时
  662.                         Alam_KeyUnable();                                        //报警键盘锁
  663.                 else
  664.                         ALAM=1;                                                                //关报警

  665.                 KEY=keynum();                                                        //读按键的位置码
  666.                 if(KEY!=0)                                                                //当有按键按下时
  667.                 {       
  668.                         if(key_disable==1)                                        //锁定键盘标志为1时
  669.                         {
  670.                                 second=0;                                                //秒清零
  671.                         }
  672.                         else                                                                //没有锁定键盘时
  673.                         {
  674.                                 NUM=coding(KEY);                                //根据按键的位置将其编码,编码值赋值给NUM
  675.                                 {
  676.                                         switch(NUM)                                        //判断按键值
  677.                                         {
  678.                                                 case ('A'):         ;                                         break;
  679.                                                 case ('B'):                ;                                     break;
  680.                                                 case ('C'):
  681.                                                                         write_1602com(yi);//日历显示固定符号从第一行第0个位置之后开始显示
  682.                                                                         for(i=0;i<16;i++)
  683.                                                                         {
  684.                                                                                 write_1602dat(name[i]);//向液晶屏写开机画面
  685.                                                                         }
  686.                                                                         if(N>=1) N--;        OneAlam();                                                                //按键提示音                                               
  687.                                                                         //DisplayOneChar(6+N,1,'*');
  688.                                                                         for(j=N;j<16;j++)
  689.                                                                         {
  690.                                                                                 write_1602com(er+6+j);
  691.                                                                                 write_1602dat(' ');
  692.                                                                         }
  693.                                                                         for(j=0;j<N;j++)
  694.                                                                         {
  695.                                                                                 write_1602com(er+6+j);                                //显示位数随输入增加而增加
  696.                                                                                 write_1602dat('*');                                        //但不显示实际数字,用*代替
  697.                                                                         }  
  698.                                                                         InputData[N]=N+4;
  699.                                                                         break;                //ABC是无定义按键
  700.                                                 case ('D'): ResetPassword();                break;      //重新设置密码
  701.                                                 case ('*'): Cancel();                                break;      //取消当前输入
  702.                                                 case ('#'): Ensure();                                 break;           //确认键,
  703.                                                 default:                                                                                 //如果不是功能键按下时,就是数字键按下
  704.                                                 {       
  705.                                                         //DisplayListChar(0,1,Input);
  706.                                                         if(N<6)                                                           //当输入的密码少于6位时,接受输入并保存,大于6位时则无效。
  707.                                                         {
  708.                                                                 write_1602com(er);
  709.                                                                 for(i=0;i<16;i++)
  710.                                                                 {
  711.                                                                         write_1602dat(Input[i]);                                //显示输入画面
  712.                                                                 }
  713.                                                                 OneAlam();                                                                //按键提示音       
  714.                                                                  for(j=0;j<=N;j++)
  715.                                                                 {
  716.                                                                         write_1602com(er+6+j);                                //显示位数随输入增加而增加
  717.                                                                         write_1602dat('*');                                        //但不显示实际数字,用*代替
  718.                                                                 }
  719.                                                                 InputData[N]=NUM;                                                //将数字键的码赋值给InputData[]数组暂存
  720.                                                                 N++;                                                                        //密码位数加
  721.                                                         }
  722.                                                         else                                                                                //输入数据位数大于6后,忽略输入
  723.                                                         {
  724.                                                                 N=6;                                                                        //密码输入大于6位时,不接受输入
  725.                                                                  break;
  726.                                                         }
  727.                                                 }
  728.                                         }
  729.                                 }
  730.                         }
  731.                  }
  732.         }
  733. }

  734. //*********************************中断服务函数**************************************
  735. void  time0_int(void) interrupt 1                    //定时器T0
  736. {
  737.         TL0=0xB0;
  738.         TH0=0x3C;                  //定时器重新赋初值
  739.         //TR0=1;
  740.         countt0++;                           //计时变量加,加1次时50ms
  741.           if(countt0==20)                   //加到20次就是1s
  742.            {
  743.                 countt0=0;                   //变量清零
  744.                 second++;                   //秒加
  745.                 if(pass==1)                   //开锁状态时
  746.                 {
  747.                         if(second==1)                        //秒加到1s时
  748.                         {
  749.                                 TR0=0;                                //关定时器
  750.                                 TL0=0xB0;
  751.                                 TH0=0x3C;                        //再次赋初值
  752.                                 second=0;                        //秒清零
  753.                         }
  754.                 }
  755.                 else                                                //不在开锁状态时
  756.                 {
  757.                         if(second==3)                        //秒加到3时
  758.                         {
  759.                                 TR0=0;                                //关闭定时器
  760.                                 second=0;                        //秒清零
  761.                                 key_disable=0;                //锁定键盘清零
  762.                                 s3_keydown=0;       
  763.                                 TL0=0xB0;
  764.                                 TH0=0x3C;                        //重新赋初值
  765.                         }
  766.                         else
  767.                             TR0=1;                                //打开定时器
  768.                 }
  769.                        
  770.            }
  771. }
复制代码
0.png

所有资料51hei提供下载:
51hei密码锁.zip (117.93 KB, 下载次数: 17)
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

QQ|手机版|小黑屋|单片机论坛 |51Hei单片机16群 联系QQ:125739409;技术交流QQ群7344883

Powered by 单片机教程网

快速回复 返回顶部 返回列表