標(biāo)題: 求大神指點一下為啥電子密碼鎖（液晶顯示）能輸入管理員密碼，但是初始化密碼.... [打印本頁]
作者: 小小孟love    時間: 2018-12-28 22:26
標(biāo)題: 求大神指點一下為啥電子密碼鎖（液晶顯示）能輸入管理員密碼，但是初始化密碼....
有木有大神指點一下，為啥電子密碼鎖（液晶顯示）能輸入管理員密碼，但是初始化密碼顯示錯誤
  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^4;
  10. sbit lcd1602_rw=P2^5;
  11. sbit lcd1602_en=P2^6;

  13. sbit Scl=P1^1;                        //24C02串行時鐘
  14. sbit Sda=P1^2;                        //24C02串行數(shù)據(jù)

  16. sbit ALAM = P1^3;                //報警        
  17. sbit KEY = P1^6;                //開鎖

  19. bit  pass=0;                        //密碼正確標(biāo)志
  20. bit  ReInputEn=0;                //重置輸入允許標(biāo)志        
  21. bit  s3_keydown=0;                //3秒按鍵標(biāo)志位
  22. bit  key_disable=0;                //鎖定鍵盤標(biāo)志

  24. unsigned char countt0,second;        //t0中斷計數(shù)器,秒計數(shù)器

  26. void Delay5Ms(void);                //聲明延時函數(shù)

  28. unsigned char code a[]={0xFE,0xFD,0xFB,0xF7};                                 //控盤掃描控制表
  29. //液晶顯示數(shù)據(jù)數(shù)組
  30. unsigned char code start_line[]        = {"password:       "};
  31. unsigned char code name[]                  = {"===Coded Lock==="};        //顯示名稱
  32. unsigned char code Correct[]         = {"     correct    "};                //輸入正確
  33. unsigned char code Error[]           = {"      error     "};          //輸入錯誤
  34. unsigned char code codepass[]        = {"      pass      "};
  35. unsigned char code LockOpen[]        = {"      open      "};                //OPEN
  36. unsigned char code SetNew[]         = {"SetNewWordEnable"};
  37. unsigned char code Input[]           = {"input:          "};                //INPUT
  38. unsigned char code ResetOK[]         = {"ResetPasswordOK "};
  39. unsigned char code initword[]        = {"Init password..."};
  40. unsigned char code Er_try[]                = {"error,try again!"};
  41. unsigned char code again[]                = {"input again     "};

  43. unsigned char InputData[6];                                                                        //輸入密碼暫存區(qū)
  44. unsigned char CurrentPassword[6]={0,0,0,0,0,0};                         //讀取EEPROM密碼暫存數(shù)組
  45. unsigned char TempPassword[6];
  46. unsigned char N=0;                                //密碼輸入位數(shù)記數(shù)
  47. unsigned char ErrorCont;                        //錯誤次數(shù)計數(shù)
  48. unsigned char CorrectCont;                        //正確輸入計數(shù)
  49. unsigned char ReInputCont;                         //重新輸入計數(shù)
  50. unsigned char code initpassword[6]={0,0,0,0,0,0};                        //輸入管理員密碼后將密碼初始為000000
  51. unsigned char code adminpassword[6]={1,3,1,4,2,0};                        //輸入管理員密碼后將密碼初始為000000
  52. //=====================5ms延時==============================
  53. void Delay5Ms(void)
  54. {
  55.         unsigned int TempCyc = 5552;
  56.         while(TempCyc--);
  57. }
  58. //===================400ms延時==============================
  59. void Delay400Ms(void)
  60. {
  61. unsigned char TempCycA = 5;
  62. unsigned int TempCycB;
  63. while(TempCycA--)
  64. {
  65.   TempCycB=7269;
  66.   while(TempCycB--);
  67. }
  68. }
  69. //================================24C02========================================================
  70. void mDelay(uint t) //延時
  71. {
  72.         uchar i;
  73.            while(t--)
  74.            {
  75.                    for(i=0;i<125;i++)
  76.                    {;}
  77.            }
  78. }
  79. void Nop(void)                  //空操作
  80. {
  81.          _nop_();                  //僅作延時用一條語句大約1us
  82.          _nop_();
  83.          _nop_();
  84.          _nop_();
  85. }

  87. /*****24c02程序參照24c02時序圖*****/
  88. /*起始條件*/

  90. void Start(void)
  91. {
  92.          Sda=1;
  93.          Scl=1;
  94.          Nop();
  95.          Sda=0;
  96.          Nop();
  97. }
  98. /*停止條件*/
  99. void Stop(void)
  100. {
  101.          Sda=0;
  102.          Scl=1;
  103.          Nop();
  104.          Sda=1;
  105.          Nop();
  106. }

  108. /*應(yīng)答位*/
  109. void Ack(void)
  110. {
  111.         Sda=0;
  112.         Nop();
  113.         Scl=1;
  114.         Nop();
  115.         Scl=0;
  116. }

  118. /*反向應(yīng)答位*/
  119. void NoAck(void)
  120. {
  121.          Sda=1;
  122.          Nop();
  123.          Scl=1;
  124.          Nop();
  125.          Scl=0;
  126. }

  128. /*發(fā)送數(shù)據(jù)子程序，Data為要求發(fā)送的數(shù)據(jù)*/
  129. void Send(uchar Data)
  130. {
  131.            uchar BitCounter=8;
  132.            uchar temp;
  133.            do
  134.            {
  135.                    temp=Data;                                           //將待發(fā)送數(shù)據(jù)暫存temp
  136.                    Scl=0;
  137.                    Nop();
  138.                    if((temp&0x80)==0x80)                   //將讀到的數(shù)據(jù)&0x80
  139.                    Sda=1;
  140.                    else
  141.                    Sda=0;
  142.                    Scl=1;
  143.                    temp=Data<<1;                                   //數(shù)據(jù)左移
  144.                    Data=temp;                                           //數(shù)據(jù)左移后重新賦值Data
  145.                    BitCounter--;                                   //該變量減到0時，數(shù)據(jù)也就傳送完成了
  146.            }
  147.            while(BitCounter);                                   //判斷是否傳送完成
  148.            Scl=0;
  149. }

  151. /*讀一字節(jié)的數(shù)據(jù)，并返回該字節(jié)值*/
  152. uchar Read(void)
  153. {
  154.     uchar temp=0;
  155.         uchar temp1=0;
  156.         uchar BitCounter=8;
  157.         Sda=1;
  158.         do
  159.         {
  160.                 Scl=0;
  161.                 Nop();
  162.                 Scl=1;
  163.                 Nop();
  164.                 if(Sda)                                   //數(shù)據(jù)位是否為1
  165.                         temp=temp|0x01;           //為1 temp的最低位為1（|0x01，就是將最低位變?yōu)?）
  166.                 else                                   //如果為0
  167.                         temp=temp&0xfe;           //temp最低位為0（&0xfe（11111110）最低位就是0）
  168.                 if(BitCounter-1)           //BitCounter減1后是否為真
  169.                 {
  170.                         temp1=temp<<1;           //temp左移
  171.                         temp=temp1;
  172.                 }
  173.                 BitCounter--;                   //BitCounter減到0時，數(shù)據(jù)就接收完了
  174.         }
  175.         while(BitCounter);                   //判斷是否接收完成
  176.         return(temp);
  177. }

  179. void WrToROM(uchar Data[],uchar Address,uchar Num)
  180. {
  181.   uchar i;
  182.   uchar *PData;
  183.   PData=Data;
  184.   for(i=0;i<Num;i++)
  185.   {
  186.   Start();
  187.   Send(0xa0);
  188.   Ack();
  189.   Send(Address+i);
  190.   Ack();
  191.   Send(*(PData+i));
  192.   Ack();
  193.   Stop();
  194.   mDelay(20);
  195.   }
  196. }

  198. void RdFromROM(uchar Data[],uchar Address,uchar Num)
  199. {
  200.   uchar i;
  201.   uchar *PData;
  202.   PData=Data;
  203.   for(i=0;i<Num;i++)
  204.   {
  205.   Start();
  206.   Send(0xa0);
  207.   Ack();
  208.   Send(Address+i);
  209.   Ack();
  210.   Start();
  211.   Send(0xa1);
  212.   Ack();
  213.   *(PData+i)=Read();
  214.   Scl=0;
  215.   NoAck();
  216.   Stop();
  217.   }
  218. }
  219. //=======================================LCD1602====================================================
  220. #define yi 0x80 //LCD第一行的初始位置,因為LCD1602字符地址首位D7恒定為1（100000000=80）
  221. #define er 0x80+0x40 //LCD第二行初始位置（因為第二行第一個字符位置地址是0x40）


  224. //----------------延時函數(shù)，后面經(jīng)常調(diào)用----------------------
  225. void delay(uint xms)//延時函數(shù)，有參函數(shù)
  226. {
  227.         uint x,y;
  228.         for(x=xms;x>0;x--)
  229.          for(y=110;y>0;y--);
  230. }

  232. //--------------------------寫指令---------------------------
  233. void write_1602com(uchar com)//****液晶寫入指令函數(shù)****
  234. {
  235.         lcd1602_rs=0;//數(shù)據(jù)/指令選擇置為指令
  236.         lcd1602_rw=0; //讀寫選擇置為寫
  237.         P0=com;//送入數(shù)據(jù)
  238.         delay(1);
  239.         lcd1602_en=1;//拉高使能端，為制造有效的下降沿做準(zhǔn)備
  240.         delay(1);
  241.         lcd1602_en=0;//en由高變低，產(chǎn)生下降沿，液晶執(zhí)行命令
  242. }

  244. //-------------------------寫數(shù)據(jù)-----------------------------
  245. void write_1602dat(uchar dat)//***液晶寫入數(shù)據(jù)函數(shù)****
  246. {
  247.         lcd1602_rs=1;//數(shù)據(jù)/指令選擇置為數(shù)據(jù)
  248.         lcd1602_rw=0; //讀寫選擇置為寫
  249.         P0=dat;//送入數(shù)據(jù)
  250.         delay(1);
  251.         lcd1602_en=1; //en置高電平，為制造下降沿做準(zhǔn)備
  252.         delay(1);
  253.         lcd1602_en=0; //en由高變低，產(chǎn)生下降沿，液晶執(zhí)行命令
  254. }

  256. //-------------------------初始化-------------------------
  257. void lcd_init(void)
  258. {
  259.         write_1602com(0x38);//設(shè)置液晶工作模式，意思：16*2行顯示，5*7點陣，8位數(shù)據(jù)
  260.         write_1602com(0x0c);//開顯示不顯示光標(biāo)
  261.         write_1602com(0x06);//整屏不移動，光標(biāo)自動右移
  262.         write_1602com(0x01);//清顯示
  263. }
  264. //==============將按鍵值編碼為數(shù)值=========================
  265. unsigned char coding(unsigned char m)         
  266. {
  267.         unsigned char k;
  268.         switch(m)
  269.         {
  270.           case (0x11): k=1;break;
  271.                 case (0x21): k=2;break;
  272.                 case (0x41): k=3;break;
  273.                 case (0x81): k='A';break;
  274.                 case (0x12): k=4;break;
  275.                 case (0x22): k=5;break;
  276.                 case (0x42): k=6;break;
  277.                 case (0x82): k='B';break;
  278.                 case (0x14): k=7;break;
  279.                 case (0x24): k=8;break;
  280.                 case (0x44): k=9;break;
  281.                 case (0x84): k='C';break;
  282.                 case (0x18): k='*';break;
  283.                 case (0x28): k=0;break;
  284.                 case (0x48): k='#';break;
  285.                 case (0x88): k='D';break;
  286.                 /*case (0x12): k=1;break;
  287.                 case (0x14): k=4;break;
  288.                 case (0x18): k=7;break;
  289.                 case (0x21): k='*';break;
  290.                 case (0x22): k=2;break;
  291.                 case (0x24): k=5;break;
  292.                 case (0x28): k=8;break;
  293.                 case (0x11): k=0;break;
  294.                 case (0x42): k=3;break;
  295.                 case (0x44): k=6;break;
  296.                 case (0x48): k=9;break;
  297.                 case (0x41): k='#';break;
  298.                 case (0x88): k='A';break;
  299.                 case (0x84): k='B';break;
  300.                 case (0x82): k='C';break;
  301.                 case (0x81): k='D';break;*/
  302.         }
  303.         return(k);
  304. }
  305. //=====================按鍵檢測并返回按鍵值===============================
  306. unsigned char keynum(void)
  307. {
  308.          unsigned char row,col,i;
  309.          P3=0xf0;
  310.          if((P3&0xf0)!=0xf0)
  311.          {
  312.                    Delay5Ms();
  313.         Delay5Ms();
  314.                    if((P3&0xf0)!=0xf0)
  315.                 {
  316.                     row=P3^0xf0;          //確定行線
  317.                         i=0;
  318.                         P3=a[i];                  //精確定位
  319.                         while(i<4)
  320.                         {
  321.                                  if((P3&0xf0)!=0xf0)
  322.                                   {
  323.                                            col=~(P3&0xff);          //確定列線
  324.                                            break;            //已定位后提前退出   
  325.                                   }
  326.                                 else
  327.                                   {
  328.                                            i++;
  329.                                            P3=a[i];
  330.                                   }
  331.                         }
  332.                 }
  333.                 else
  334.                 {
  335.                         return 0;
  336.                 }
  337.                 while((P3&0xf0)!=0xf0);
  338.                 return (row|col);                         //行線與列線組合后返回
  339.          }
  340.          else return 0;                                 //無鍵按下時返回0
  341. }
  342. //=======================一聲提示音，表示有效輸入========================
  343. void OneAlam(void)
  344. {
  345.         ALAM=0;
  346.         Delay5Ms();
  347.     ALAM=1;
  348. }
  349. //========================二聲提示音，表示操作成功========================
  350. void TwoAlam(void)
  351. {
  352.         ALAM=0;
  353.         Delay5Ms();
  354.     ALAM=1;
  355.     Delay5Ms();
  356.         ALAM=0;
  357.         Delay5Ms();
  358.     ALAM=1;
  359. }
  360. //========================三聲提示音,表示錯誤========================
  361. void ThreeAlam(void)
  362. {
  363.         ALAM=0;
  364.         Delay5Ms();
  365.     ALAM=1;
  366.     Delay5Ms();
  367.         ALAM=0;
  368.         Delay5Ms();
  369.     ALAM=1;
  370.     Delay5Ms();
  371.         ALAM=0;
  372.         Delay5Ms();
  373.     ALAM=1;
  374. }
  375. //=====================顯示輸入的N個數(shù)字，用H代替以便隱藏============//
  376. void DisplayOne(void)
  377. {
  378. //        DisplayOneChar(9+N,1,'*');
  379.         write_1602com(yi+5+N);
  380.         write_1602dat('*');
  381. }
  382. void   DisplayOneChar(uchar X, uchar Y)        //按指定位置顯示一個字符
  383. {
  384.   Y &= 0x01;
  385.   X &= 0x0F;              //限制X不能大于15，Y不能大于1
  386.   if (Y) X |= 0x40;       //當(dāng)要顯示第二行時地址碼+0x40;
  387.   X |= 0x80;              //算出指令碼
  388.   write_1602com(X);  //這里不檢測忙信號，發(fā)送地址碼
  389.         }
  390. //=======================顯示提示輸入=========================
  391. void DisplayChar(void)
  392. {
  393.         unsigned char i;
  394.         if(pass==1)
  395.         {
  396.                 //DisplayListChar(0,1,LockOpen);
  397.                 write_1602com(er);                                   //在二行開始顯示
  398.                 for(i=0;i<16;i++)
  399.                 {
  400.                         write_1602dat(LockOpen[i]);           //顯示open 開鎖成功
  401.                 }
  402.         }
  403.         else
  404.         {
  405.                 if(N==0)
  406.                 {
  407.                         //DisplayListChar(0,1,Error);
  408.                         write_1602com(er);
  409.                         for(i=0;i<16;i++)
  410.                         {
  411.                                 write_1602dat(Error[i]);        //顯示錯誤
  412.                         }
  413.                 }
  414.                 else
  415.                 {
  416.                         //DisplayListChar(0,1,start_line);        
  417.                         write_1602com(er);
  418.                         for(i=0;i<16;i++)
  419.                         {
  420.                                 write_1602dat(start_line[i]);//顯示開始輸入        
  421.                         }
  422.                 }
  423.         }
  424. }

  426. //========================重置密碼==================================================
  427. void ResetPassword(void)
  428. {
  429.         unsigned char i;        
  430.         unsigned char j;
  431.         if(pass==0)
  432.         {
  433.                 pass=0;                           
  434.                 DisplayChar();           //顯示錯誤
  435.                 ThreeAlam();           //沒開鎖時按下重置密碼報警3聲
  436.         }
  437.         else                                   //開鎖狀態(tài)下才能進(jìn)行密碼重置程序
  438.         {
  439.             if(ReInputEn==1)   //開鎖狀態(tài)下，ReInputEn置1，重置密碼允許
  440.                 {
  441.                         if(N==6)           //輸入6位密碼
  442.                         {
  443.                                 ReInputCont++;                        //密碼次數(shù)計數(shù)        
  444.                                 if(ReInputCont==2)                //輸入兩次密碼
  445.                                 {
  446.                                         for(i=0;i<6;)
  447.                                         {
  448.                                                 if(TempPassword[i]==InputData[i])        //將兩次輸入的新密碼作對比
  449.                                                         i++;
  450.                                                 else                                                                //如果兩次的密碼不同
  451.                                                 {
  452.                                                         //DisplayListChar(0,1,Error);
  453.                                                         write_1602com(er);
  454.                                                         for(j=0;j<16;j++)
  455.                                                         {
  456.                                                                 write_1602dat(Error[j]);        //顯示錯誤Error
  457.                                                         }
  458.                                                         ThreeAlam();                        //錯誤提示        
  459.                                                         pass=0;                                        //關(guān)鎖
  460.                                                         ReInputEn=0;                        //關(guān)閉重置功能，
  461.                                                         ReInputCont=0;
  462.                                                         DisplayChar();
  463.                                                         break;
  464.                                                 }
  465.                                         }
  466.                                         if(i==6)
  467.                                         {
  468.                                                 //DisplayListChar(0,1,ResetOK);
  469.                                                 write_1602com(er);
  470.                                                 for(j=0;j<16;j++)
  471.                                                 {
  472.                                                         write_1602dat(ResetOK[j]);          //密碼修改成功，顯示
  473.                                                 }

  475.                                                 TwoAlam();                                //操作成功提示
  476.                                                  WrToROM(TempPassword,0,6);                //將新密碼寫入24C02存儲
  477.                                                 ReInputEn=0;
  478.                                         }
  479.                                         ReInputCont=0;
  480.                                         CorrectCont=0;
  481.                                 }
  482.                                 else                                          //輸入一次密碼時
  483.                                 {
  484.                                         OneAlam();
  485.                                         //DisplayListChar(0, 1, again);                 //顯示再次輸入一次
  486.                                         write_1602com(er);
  487.                                         for(j=0;j<16;j++)
  488.                                         {
  489.                                                 write_1602dat(again[j]);                        //顯示再輸入一次
  490.                                         }                                       
  491.                                         for(i=0;i<6;i++)
  492.                                         {
  493.                                                 TempPassword[i]=InputData[i];                //將第一次輸入的數(shù)據(jù)暫存起來                                                
  494.                                         }
  495.                                 }

  497.                         N=0;                                                //輸入數(shù)據(jù)位數(shù)計數(shù)器清零
  498.                    }
  499.             }
  500.         }
  501. }
  502. //=======================輸入密碼錯誤超過三過，報警并鎖死鍵盤======================
  503. void Alam_KeyUnable(void)
  504. {
  505.         P1=0x00;
  506.         {
  507.                 ALAM=~ALAM;                                 //蜂鳴器一直閃爍鳴響
  508.                 Delay5Ms();
  509.         }
  510. }
  511. //=======================取消所有操作============================================
  512. void Cancel(void)
  513. {        
  514.         unsigned char i;
  515.         unsigned char j;
  516.         //DisplayListChar(0, 1, start_line);
  517.         write_1602com(er);
  518.         for(j=0;j<16;j++)
  519.         {
  520.                 write_1602dat(start_line[j]);          //顯示開機輸入密碼界面
  521.         }
  522.         TwoAlam();                                //提示音
  523.         for(i=0;i<6;i++)
  524.         {
  525.                 InputData[i]=0;                //將輸入密碼清零
  526.         }
  527.         KEY=1;                                        //關(guān)閉鎖
  528.         ALAM=1;                                        //報警關(guān)
  529.         pass=0;                                        //密碼正確標(biāo)志清零
  530.         ReInputEn=0;                        //重置輸入充許標(biāo)志清零
  531.         ErrorCont=0;                        //密碼錯誤輸入次數(shù)清零
  532.         CorrectCont=0;                        //密碼正確輸入次數(shù)清零
  533.         ReInputCont=0;                        //重置密碼輸入次數(shù)清零
  534.         s3_keydown=0;
  535.         key_disable=0;                        //鎖定鍵盤標(biāo)志清零
  536.         N=0;                                        //輸入位數(shù)計數(shù)器清零
  537. }

  539. //==========================確認(rèn)鍵，并通過相應(yīng)標(biāo)志位執(zhí)行相應(yīng)功能===============================
  540. void Ensure(void)
  541. {        
  542.         unsigned char i,j;
  543.         RdFromROM(CurrentPassword,0,6);                                         //從24C02里讀出存儲密碼
  544.     if(N==6)
  545.         {
  546.             if(ReInputEn==0)                                                        //重置密碼功能未開啟
  547.                 {
  548.                         for(i=0;i<6;)
  549.                            {                                       
  550.                                 if(CurrentPassword[i]==InputData[i])        //判斷輸入密碼和24c02中的密碼是否相同
  551.                                 {
  552.                                         i++;                                                                //相同一位 i就+1
  553.                                 }
  554.                                 else                                                                         //如果有密碼不同
  555.                                 {                                                                                
  556.                                         ErrorCont++;                                                //錯誤次數(shù)++
  557.                                         if(ErrorCont==3)                        //錯誤輸入計數(shù)達(dá)三次時，報警并鎖定鍵盤
  558.                                         {
  559.                                                 write_1602com(er);
  560.                                                 for(i=0;i<16;i++)
  561.                                                 {
  562.                                                         write_1602dat(Error[i]);        
  563.                                                 }
  564.                                                 do
  565.                                                 Alam_KeyUnable();
  566.                                                 while(1);
  567.                                         }
  568.                                         else                                         //錯誤次數(shù)小于3次時，鎖死鍵盤3秒，然后重新可以輸入
  569.                                         {
  570.                                                 TR0=1;                                //開啟定時
  571.                                                 key_disable=1;                        //鎖定鍵盤
  572.                                                 pass=0;                                        //pass位清零
  573.                                                 break;                                        //跳出
  574.                                         }
  575.                                 }
  576.                         }

  578.                         if(i==6)                                         //密碼輸入對時
  579.                         {
  580.                                 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]))
  581.                                    {
  582.                                         WrToROM(initpassword,0,6);                                 //強制將初始密碼寫入24C02存儲
  583.                                         write_1602com(er);
  584.                                         for(j=0;j<16;j++)
  585.                                         {
  586.                                                 write_1602dat(initword[j]);                                //顯示初始化密碼
  587.                                         }
  588.                                         TwoAlam();                                                                        //成功提示音
  589.                                         Delay400Ms();                                                                //延時400ms
  590.                                         TwoAlam();                                                                        //成功提示音
  591.                                         N=0;                                                                                //輸入位數(shù)計數(shù)器清零
  592.                                 }
  593.                                 else
  594.                                 {
  595.                                         CorrectCont++;                                        //輸入正確變量++
  596.                                         if(CorrectCont==1)                                //正確輸入計數(shù)，當(dāng)只有一次正確輸入時，開鎖
  597.                                         {
  598.                                                 //DisplayListChar(0,1,LockOpen);
  599.                                                 write_1602com(er);
  600.                                                 for(j=0;j<16;j++)
  601.                                                 {
  602.                                                         write_1602dat(LockOpen[j]);                  //顯示open開鎖畫面
  603.                                                 }
  604.                                                 TwoAlam();                        //操作成功提示音
  605.                                                 KEY=0;                                                                                        //開鎖
  606.                                                 pass=1;                                                                                        //置正確標(biāo)志位
  607.                                                 TR0=1;                                                                                        //開啟定時
  608.                                                 for(j=0;j<6;j++)                                                                //將輸入清除
  609.                                                 {
  610.                                                         InputData[i]=0;                                                                //開鎖后將輸入位清零
  611.                                                 }
  612.                                         }        
  613.                                         else                                                                                                //當(dāng)兩次正確輸入時，開啟重置密碼功能
  614.                                         {
  615.                                                 write_1602com(er);
  616.                                                 for(j=0;j<16;j++)
  617.                                                 {
  618.                                                         write_1602dat(SetNew[j]);                                        //顯示重置密碼界面
  619.                                                 }
  620.                                                 TwoAlam();                                                                            //操作成功提示
  621.                                                 ReInputEn=1;                                                                        //允許重置密碼輸入
  622.                                                 CorrectCont=0;                                                                        //正確計數(shù)器清零
  623.                                         }
  624.                                 }
  625.                           }
  626.         
  627.                         else                        //=========================當(dāng)?shù)谝淮问褂没蛲浢艽a時可以用131420對其密碼初始化============
  628.                         {
  629.                                 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]))
  630.                                    {
  631.                                         WrToROM(initpassword,0,6);                                 //強制將初始密碼寫入24C02存儲
  632.                                         write_1602com(er);
  633.                                         for(j=0;j<16;j++)
  634.                                         {
  635.                                                 write_1602dat(initword[j]);                                //顯示初始化密碼
  636.                                         }
  637.                                         TwoAlam();                                                                        //成功提示音
  638.                                         Delay400Ms();                                                                //延時400ms
  639.                                         TwoAlam();                                                                        //成功提示音
  640.                                         N=0;                                                                                //輸入位數(shù)計數(shù)器清零
  641.                                 }
  642.                                 else                                                                                        //密碼輸入錯誤
  643.                                 {
  644.                                         write_1602com(er);
  645.                                         for(j=0;j<16;j++)
  646.                                         {
  647.                                                 write_1602dat(Error[j]);                                 //顯示錯誤信息
  648.                                         }
  649.                                          ThreeAlam();                                                                                //錯誤提示音
  650.                                         pass=0;        
  651.                                 }
  652.                         }
  653.                 }

  655.                 else                                                                                        //當(dāng)已經(jīng)開啟重置密碼功能時，而按下開鎖鍵，
  656.                 {
  657.                         //DisplayListChar(0,1,Er_try);
  658.                         write_1602com(er);
  659.                         for(j=0;j<16;j++)
  660.                         {
  661.                                 write_1602dat(Er_try[j]);                          //錯誤，請重新輸入
  662.                         }
  663.                         ThreeAlam();                                                          //錯誤提示音
  664.                 }
  665.         }

  667.         else                                   //密碼沒有輸入到6位時，按下確認(rèn)鍵時
  668.         {
  669.                 //DisplayListChar(0,1,Error);
  670.                 write_1602com(er);
  671.                 for(j=0;j<16;j++)
  672.                 {
  673.                         write_1602dat(Error[j]);                 //顯示錯誤
  674.                 }

  676.                  ThreeAlam();                                                                                //錯誤提示音
  677.                 pass=0;        
  678.         }
  679.         
  680.         N=0;                                                                                                        //將輸入數(shù)據(jù)計數(shù)器清零，為下一次輸入作準(zhǔn)備
  681. }


  684. //==============================主函數(shù)===============================
  685. void main(void)
  686. {
  687.          unsigned char KEY,NUM;
  688.         unsigned char i,j;
  689.          P3=0xFF;                                    //P3口復(fù)位
  690.         TMOD=0x11;                                   //定義工作方式
  691.          TL0=0xB0;
  692.          TH0=0x3C;                                   //定時器賦初值
  693.          EA=1;                                           //打開中斷總開關(guān)
  694.          ET0=1;                                           //打開中斷允許開關(guān)
  695.          TR0=0;                                           //打開定時器開關(guān)
  696.          Delay400Ms();         //啟動等待，等LCM講入工作狀態(tài)
  697.          lcd_init();         //LCD初始化
  698.         write_1602com(yi);//日歷顯示固定符號從第一行第0個位置之后開始顯示
  699.         for(i=0;i<16;i++)
  700.         {
  701.                 write_1602dat(name[i]);//向液晶屏寫開機畫面
  702.         }
  703.         write_1602com(er);
  704.         for(i=0;i<16;i++)
  705.         {
  706.                 write_1602dat(start_line[i]);//寫輸入密碼等待界面
  707.         }
  708.         write_1602com(er+9);        //設(shè)置光標(biāo)位置
  709.         write_1602com(0x0f);        //設(shè)置光標(biāo)為閃爍
  710.          Delay5Ms(); //延時片刻(可不要)

  712.          N=0;                                                                                                                //初始化數(shù)據(jù)輸入位數(shù)
  713.          while(1)                 //進(jìn)入循環(huán)
  714.          {
  715.                 if(key_disable==1)                                                //鎖定鍵盤標(biāo)志為1時
  716.                         Alam_KeyUnable();                                        //報警鍵盤鎖
  717.                 else
  718.                         ALAM=1;                                                                //關(guān)報警

  720.                 KEY=keynum();                                                        //讀按鍵的位置碼
  721.                 if(KEY!=0)                                                                //當(dāng)有按鍵按下時
  722.                 {        
  723.                         if(key_disable==1)                                        //鎖定鍵盤標(biāo)志為1時
  724.                         {
  725.                                 second=0;                                                //秒清零
  726.                         }
  727.                         else                                                                //沒有鎖定鍵盤時
  728.                         {
  729.                                 NUM=coding(KEY);                                //根據(jù)按鍵的位置將其編碼，編碼值賦值給NUM
  730.                                 {
  731.                                         switch(NUM)                                        //判斷按鍵值
  732.                                         {
  733.                                                 case ('A'):         ;                                         break;
  734.                                                 case ('B'):                ;                                     break;
  735.                                                 case ('C'):
  736.                                                                         write_1602com(yi);//日歷顯示固定符號從第一行第0個位置之后開始顯示
  737.                                                                         for(i=0;i<16;i++)
  738.                                                                         {
  739.                                                                                 write_1602dat(name[i]);//向液晶屏寫開機畫面
  740.                                                                         }
  741.                                                                         if(N>=1) N--;        OneAlam();                                                                //按鍵提示音                                                
  742.                                                                         //DisplayOneChar(6+N,1,'*');
  743.                                                                         for(j=N;j<16;j++)
  744.                                                                         {
  745.                                                                                 write_1602com(er+6+j);
  746.                                                                                 write_1602dat(' ');
  747.                                                                         }
  748.                                                                         for(j=0;j<N;j++)
  749.                                                                         {
  750.                                                                                 write_1602com(er+6+j);                                //顯示位數(shù)隨輸入增加而增加
  751.                                                                                 write_1602dat('*');                                        //但不顯示實際數(shù)字，用*代替
  752.                                                                         }  
  753.                                                                         InputData[N]=N+4;
  754.                                                                         break;                //ABC是無定義按鍵
  755.                                                 case ('D'): ResetPassword();                break;      //重新設(shè)置密碼
  756.                                                 case ('*'): Cancel();                                break;      //取消當(dāng)前輸入
  757.                                                 case ('#'): Ensure();                                 break;           //確認(rèn)鍵，
  758.                                                 default:                                                                                 //如果不是功能鍵按下時，就是數(shù)字鍵按下
  759.                                                 {        
  760.                                                         //DisplayListChar(0,1,Input);
  761.                                                         if(N<6)                                                           //當(dāng)輸入的密碼少于6位時，接受輸入并保存，大于6位時則無效。
  762.                                                         {
  763.                                                                 write_1602com(er);
  764.                                                                 for(i=0;i<16;i++)
  765.                                                                 {
  766.                                                                         write_1602dat(Input[i]);                                //顯示輸入畫面
  767.                                                                 }
  768.                                                                 OneAlam();                                                                //按鍵提示音        
  769.                                                                  for(j=0;j<=N;j++)
  770.                                                                 {
  771.                                                                         write_1602com(er+6+j);                                //顯示位數(shù)隨輸入增加而增加
  772.                                                                         write_1602dat('*');                                        //但不顯示實際數(shù)字，用*代替
  773.                                                                 }
  774.                                                                 InputData[N]=NUM;                                                //將數(shù)字鍵的碼賦值給InputData[]數(shù)組暫存
  775.                                                                 N++;                                                                        //密碼位數(shù)加
  776.                                                         }
  777.                                                         else                                                                                //輸入數(shù)據(jù)位數(shù)大于6后，忽略輸入
  778.                                                         {
  779.                                                                 N=6;                                                                        //密碼輸入大于6位時，不接受輸入
  780.                                                                  break;
  781.                                                         }
  782.                                                 }
  783.                                         }
  784.                                 }
  785.                         }
  786.                  }
  787.         }
  788. }

  790. //*********************************中斷服務(wù)函數(shù)**************************************
  791. void  time0_int(void) interrupt 1                    //定時器T0
  792. {
  793.          TL0=0xB0;
  794.          TH0=0x3C;                  //定時器重新賦初值
  795.          //TR0=1;
  796.          countt0++;                           //計時變量加，加1次時50ms
  797.           if(countt0==20)                   //加到20次就是1s
  798.            {
  799.                 countt0=0;                   //變量清零
  800.                 second++;                   //秒加
  801.                 if(pass==1)                   //開鎖狀態(tài)時
  802.                 {
  803.                         if(second==1)                        //秒加到1s時
  804.                         {
  805.                                 TR0=0;                                //關(guān)定時器
  806.                                 TL0=0xB0;
  807.                                  TH0=0x3C;                        //再次賦初值
  808.                                 second=0;                        //秒清零
  809.                         }
  810.                 }
  811.                 else                                                //不在開鎖狀態(tài)時
  812.                 {
  813.                         if(second==3)                        //秒加到3時
  814.                         {
  815.                                 TR0=0;                                //關(guān)閉定時器
  816.                                 second=0;                        //秒清零
  817.                                 key_disable=0;                //鎖定鍵盤清零
  818.                                 s3_keydown=0;        
  819.                                 TL0=0xB0;
  820.                                 TH0=0x3C;                        //重新賦初值
  821.                         }
  822.                         else
  823.                             TR0=1;                                //打開定時器
  824.                 }
  825.                         
  826.            }
  827. }
復(fù)制代碼
作者: admin    時間: 2018-12-29 03:16
您這個問題給的信息不全，估計是沒人能回答得了的，先轉(zhuǎn)移到冷門區(qū)了，自行點擊編輯按鈕補充一下吧，審核員會幫你重新轉(zhuǎn)到熱門問答區(qū)的
作者: #include51.h    時間: 2019-1-23 04:46
你這個情況是能開鎖，但是不能修改密碼，現(xiàn)在我將修正過的發(fā)給你
改好密碼鎖LCD1602.rar (93.53 KB, 下載次數(shù): 58)
16位LCD12864密碼鎖.rar (33.34 KB, 下載次數(shù): 15)
另外給你一個16位的仿真文檔。
LCD1602那款同你的是一樣的電路與源碼

51黑論壇_改好密碼鎖LCD1602.rar

93.53 KB, 下載次數(shù): 25

51黑論壇_16位LCD12864密碼鎖.rar

33.34 KB, 下載次數(shù): 15



歡迎光臨 (http://www.torrancerestoration.com/bbs/) Powered by Discuz! X3.1