標(biāo)題: 51單片機(jī)+PCF8574簡易密碼鎖程序 帶詳細(xì)注釋 1602顯示 [打印本頁]
作者: LUQIMAI    時(shí)間: 2020-6-8 08:17
標(biāo)題: 51單片機(jī)+PCF8574簡易密碼鎖程序 帶詳細(xì)注釋 1602顯示
本帖最后由 LUQIMAI 于 2020-6-10 12:52 編輯

*      名稱：基于STC51的簡易密碼鎖
*        硬件配置：IAP15W4K61S4+LCD1602+PCF8574+4*4矩陣鍵盤
*        功能說明：鍵盤表
*                                          [   0,1,2,3,
*                                             4,5,6,7,
*                                              8,9,a,b,
*                                              c,d,e,f
*                                         ]
*                                                按鍵說明：f:確認(rèn)鍵；e：設(shè)置鍵；b：上鎖鍵
*                                         初始密碼：1234
*                                         開門流程：通電，輸入初始密碼，按f鍵，提示open，同時(shí)P2燈亮代表開門。
*                                         修改密碼流程：通電后，按e鍵，首先輸入舊的密碼(第一次設(shè)置時(shí)，舊密碼就是初始密碼)，按照LCD提示操作即可。
*                                                上鎖流程：開門后，按下b鍵，上鎖，P2燈滅
*                                                燈光說明：流水燈-在修改密碼時(shí)，每一步成功都會(huì)有流水燈提示
*                                                                全亮燈-門開
*                                                                全滅燈-門關(guān)
*        不足之處：1.不知是單片機(jī)識(shí)別出現(xiàn)問題，還是鍵盤讀入的問題。有時(shí)輸入正確的密碼，但提示錯(cuò)誤，慢慢的按鍵輸入，出錯(cuò)的幾率會(huì)低些
*                                                2.需要一直通電，如果重新供電后，修改的密碼會(huì)失效，所以離應(yīng)用到實(shí)際生活還有距離
*                                                3.暫時(shí)這些，有問題望指
*        如果有不同想法的朋友，歡迎一起交流學(xué)習(xí)��！
硬件連接圖如下：
硬件連接的詳細(xì)接法程序中有，不清楚的也可以直接回帖問我
注意注意！�。�！做了幾處修改，下面是優(yōu)化版
注意注意�。。�！做了幾處修改，下面是優(yōu)化版
注意注意�。。。∽隽藥滋幮薷�，下面是優(yōu)化版
修改：        1.添加刪除功能

        2.優(yōu)化了幾處錯(cuò)誤，基本完成所有密碼鎖的功能
如有發(fā)現(xiàn)其他錯(cuò)誤，望不惜賜教！！
此處是優(yōu)化版的源碼，請下載這個(gè)：
優(yōu)化版.rar (83.14 KB, 下載次數(shù): 44)



(有幾處錯(cuò)誤)單片機(jī)源程序如下:
  1. #include <stc15.h>
  2. #include "intrins.h"
  3. #define uchar unsigned char  
  4. #define uint unsigned int  
  5. #define KeyPort P0                                //外接鍵盤，低四位接行，高四位接列

  7. uchar  KEY_TABLE[16] =
  8. {
  9.     0xEE, 0xDE, 0xBE, 0x7E,
  10.     0xED, 0xDD, 0xBD, 0x7D,
  11.     0xEB, 0xDB, 0xBB, 0x7B,
  12.     0xE7, 0xD7, 0xB7, 0x77
  13. };
  14. int flag1=0;                                                                                                                                                                                                                                                                                        //修改密碼標(biāo)志位
  15. uchar num,i=0,j;            
  16. uchar passwordtemp[16],password[16]={'1','2','3','4'},newpassword[16];       //輸入的密碼，默認(rèn)的密碼
  17. uchar inputtimes;                                                                                                                                                                                                      //密碼輸入錯(cuò)誤次數(shù)
  18. uint n,m;                                                                                                                                                                                                                                                                    //輸入密碼長度，實(shí)際密碼長度
  19. bit Flag=0;\
  20. uchar light,light1=0,light2=0xf0;                                                                                                                                                        //設(shè)置成功，開鎖，錯(cuò)誤,
  21.    
  22. sbit SCL = P1^0;
  23. sbit SDA = P1^1;

  25. char ADDR = 0x4e;    // PCF8574  T  模塊的地址碼
  26. //char ADDR = 0x7e;    // PCF8574   AT  模塊的地址碼

  28. //***************************** 延時(shí) y  ms ***********************************************
  29. void delay1(int y)   //
  30. {
  31.          ;
  32.         while(y--)
  33.         {
  34.         unsigned char a,b,c;
  35.         for(c=1;c>0;c--)
  36.         for(b=142;b>0;b--)
  37.         for(a=2;a>0;a--);
  38.         }
  39. }

  41. //******************************** IIC 串口開始 ********************************************

  43. void IIC_start(void)
  44. {
  45.         SDA=1;
  46.         _nop_();
  47.         SCL=1;
  48.         _nop_();
  49.         _nop_();
  50.         _nop_();
  51.         _nop_();
  52.         _nop_();
  53.         SDA=0;
  54.         _nop_();
  55.         _nop_();
  56.         _nop_();
  57.         _nop_();
  58.         _nop_();
  59.         SCL=0;
  60.                                 _nop_();
  61.                                 _nop_();
  62.         
  63. }


  66. //********************************** IIC 串口寫1個(gè)字節(jié) ******************************************


  69. void IIC_writeByte(char temp)
  70. {
  71.         char i;
  72.         for(i=0;i<8;i++)
  73.         {
  74.                 SDA=(bit)(temp & 0x80) ;   // 根據(jù)規(guī)定1602的數(shù)據(jù)最高位必須為  1  
  75.                 temp <<=1;
  76.                 _nop_();
  77.                 _nop_();
  78.                 SCL=1;
  79.                 _nop_();
  80.                 _nop_();
  81.                 _nop_();
  82.                 _nop_();
  83.                 _nop_();
  84.                 SCL=0;
  85.         }
  86.         _nop_();
  87.         _nop_();
  88.         _nop_();
  89.         _nop_();
  90.         SDA=1;
  91.         _nop_();
  92.         _nop_();
  93.         _nop_();
  94.         _nop_();
  95.         SCL=1;
  96.         _nop_();
  97.         _nop_();
  98.         _nop_();
  99.         while(SDA);
  100.         _nop_();
  101.         SCL=0;
  102. }

  104. //******************************** 1602寫命令 ********************************************


  107. void LCD_write_command(char comm)
  108. {
  109.         char tmp;
  110.         IIC_start();          // 串口開始
  111.         IIC_writeByte(ADDR);  // 先選PCF 8574T 的地址  （應(yīng)該是相當(dāng)于選中的意思吧）
  112.         
  113.         tmp = comm & 0xF0;    // 與0xf0 應(yīng)該是取第四位的意思吧
  114.         tmp |= 0x0C;         //保留高4位為指令的高四位，低四位為   RS = 0, RW = 0, EN = 1  
  115.         IIC_writeByte(tmp);  //從串口送出
  116.         delay1(20);
  117.         tmp &= 0xFB;        //Make EN = 0
  118.         IIC_writeByte(tmp);
  119.         
  120.         tmp = (comm & 0x0F) << 4 ;  //將指令的低四位 送到高位置保存
  121.         tmp |= 0x0C;        //RS = 0, RW = 0, EN = 1
  122.         IIC_writeByte(tmp);
  123.         delay1(20);
  124.         tmp &= 0xFB; // Make EN = 0
  125.         IIC_writeByte(tmp);
  126.         
  127. }
  128. //******************************** 1602寫數(shù)據(jù) ********************************************


  131. void LCD_write_data(char data1)
  132. {
  133.         char tmp;
  134.         IIC_start();
  135.         IIC_writeByte(ADDR);   // 先選PCF 8574T 的地址  （應(yīng)該是相當(dāng)于選中的意思吧）
  136.         
  137.         tmp = data1 & 0xF0;
  138.         tmp |= 0x0D; //RS = 1, RW = 0, EN = 1
  139.         IIC_writeByte(tmp);
  140.         delay1(20);
  141.         tmp &= 0xFB; //Make EN = 0
  142.         IIC_writeByte(tmp);
  143.         
  144.         tmp = (data1 & 0x0F) << 4 ;
  145.         tmp |= 0x0D; //RS = 0, RW = 0, EN = 1
  146.         IIC_writeByte(tmp);
  147.         delay1(20);
  148.         tmp &= 0xFB ; // Make EN = 0
  149.         IIC_writeByte(tmp);
  150. }


  153. //******************************** 1602初始化 ********************************************


  156. void Init_Lcd(void)
  157. {
  158.         LCD_write_command(0x33); //將8位總線轉(zhuǎn)為4位總線
  159.         delay1(50) ;
  160.         LCD_write_command(0x32); //
  161.         delay1(50) ;
  162.         LCD_write_command(0x28); // 4位數(shù)據(jù)線，顯示2行，5*7點(diǎn)陣字符  ！如果是0x38  則為8位數(shù)據(jù)線，顯示2行，5*7點(diǎn)陣字符
  163.         delay1(50) ;
  164.         LCD_write_command(0x0C); // 開顯示，關(guān)閉光標(biāo)，不閃爍
  165.         delay1(50) ;  
  166.         LCD_write_command(0x06); // 設(shè)定輸入方式，增量不位移
  167.         delay1(50) ;
  168.         LCD_write_command(0x01); // 清屏
  169.         delay1(50) ;
  170. }


  173. //*************************************** 在指定位置顯示字符串 *************************************


  176. void Write_LCD(int x, int y, char *str)
  177. {
  178.         char addr;
  179.         if( x < 0)
  180.         {
  181.                 x = 0;
  182.         }
  183.         if(x > 15)
  184.         {
  185.                 x = 15;
  186.         }
  187.         if(y<0)
  188.         {
  189.                 y = 0;
  190.         }
  191.         if(y > 1)
  192.         {
  193.                 y = 1;
  194.         }
  195.         
  196.         addr = 0x80 + 0x40 * y + x;   // Move cursor  移動(dòng)光標(biāo)
  197.         LCD_write_command(addr);
  198.         while (*str)
  199.         {
  200.                 LCD_write_data(*str++);
  201.         }
  202. }


  205. //-------------------------------------------- 顯示字符串的函數(shù) ----------------------------------------------------


  208. void LCD_write_word(unsigned char *s)                  //顯示字符串的函數(shù)
  209. {
  210.         while(*s>0)
  211.         {
  212.                 LCD_write_data(*s);
  213.                 s++;
  214.                                                                
  215.         }
  216. }

  218. //********************************* 指定位置顯示一個(gè)字符*******************************************


  221. /*
  222. void Print_Char (unsigned char line,unsigned char num,unsigned char date)
  223. {
  224.                 LCD_write_command(line+num);
  225.                 LCD_write_data(date);
  226. }


  229. */

  231. //按指定位置顯示一個(gè)字符(針對1602液晶)-用在溫度顯示

  233. void DisplayOneChar(unsigned char X, unsigned char Y, unsigned char DData)
  234. {
  235. Y &= 0x1;
  236. X &= 0xF;                 //限制X不能大于15，Y不能大于1
  237. if (Y) X |= 0x40;        //當(dāng)要顯示第二行時(shí)地址碼+0x40;
  238. X |= 0x80;               // 算出指令碼
  239. LCD_write_command(X);    //這里不檢測忙信號(hào)，發(fā)送地址碼
  240. LCD_write_data(DData);
  241. }

  243. //--------------------------------------初始化----------------------------------------------------------------
  244. void initial()
  245. {
  246.         P1M0=0;
  247.         P1M1=0;
  248.         P2M0=0;
  249.         P2M1=0;
  250.         P0M0=0;
  251.         P0M1=0;
  252. }

  254. /*------------------------------------------------
  255. 按鍵掃描函數(shù)，返回掃描鍵值
  256. ------------------------------------------------*/

  258. unsigned char KeyScan(void)  //鍵盤掃描函數(shù)，使用行列反轉(zhuǎn)掃描法
  259. {
  260.          uchar cord_h,cord_l;            //行列值中間變量
  261.         uchar tempt;
  262.         uint i;
  263.          KeyPort=0xf0;                                                    //列線輸出全為0
  264.          cord_l=KeyPort&0xf0;     //讀入行線值
  265.          if(cord_l!=0xf0)    //先檢測有無按鍵按下
  266.          {
  267.                   delay1(10);        //去抖
  268.                   if(cord_l!=0xf0)
  269.                   {
  270.                             cord_l=KeyPort&0xf0;  //讀入列線值
  271.                             KeyPort=0x0f;                                        //行線輸出為0
  272.                             cord_h=KeyPort&0x0f;  //讀入行線值
  273.                             while((KeyPort&0x0f)!=0x0f);//等待松開并輸出
  274.                             tempt = cord_l+cord_h;
  275.                                         for(i=0;i<16;i++)
  276.                                    if(KEY_TABLE[i]==tempt)
  277.                                                  break;
  278.                                         return(KEY_TABLE[i]);
  279.                    }
  280.           }
  281.           return(0xff);     //返回該值
  282. }

  284. /*------------------------------------------------
  285. 按鍵值處理函數(shù)，返回掃鍵值
  286. ------------------------------------------------*/

  288. unsigned char KeyPro(void)
  289. {
  290. switch(KeyScan())
  291. {
  292.   case 0xee:return '0';break;//0 按下相應(yīng)的鍵顯示相對應(yīng)的碼值
  293.   case 0xde:return '1';break;//1
  294.   case 0xbe:return '2';break;//2
  295.   case 0x7e:return '3';break;//3
  296.   case 0xed:return '4';break;//4
  297.   case 0xdd:return '5';break;//5
  298.   case 0xbd:return '6';break;//6
  299.   case 0x7d:return '7';break;//7
  300.   case 0xeb:return '8';break;//8
  301.   case 0xdb:return '9';break;//9
  302.   case 0xbb:return 'a';break;//a
  303.   case 0x7b:return 'b';break;//b
  304.   case 0xe7:return 'c';break;//c
  305.   case 0xd7:return 'd';break;//d
  306.   case 0xb7:return 'e';break;//e
  307.   case 0x77:return 'f';break;//f
  308.   default:return 0xff;break;
  309. }
  310. }

  312. //--------------------------------------------------------流水燈--------------------------------------------------------

  314. void RuningLight()                                                                                                                                                                                                //流水燈
  315. {
  316.         light=0xfe;
  317.         P2=light;
  318.         for(j=0;j<8;j++)
  319.            { light<<=1 ;
  320.                          delay1(250);
  321.                          P2=light;
  322.                  }
  323.         P2=0xff;
  324.                         
  325.         
  326. }

  328. //--------------------------------------------------------密碼驗(yàn)證--------------------------------------------------------

  330. void VriefytPassword()                                                                                                                                                                        //驗(yàn)證密碼
  331. {        if(flag1)
  332.                                                 m=sizeof(newpassword);                                                                                                                        //記錄新密碼的長度
  333.                                  else
  334.                                           m=sizeof(password);                                                                                                                                        //記錄舊密碼的長度
  335.                                                 n=sizeof(passwordtemp);                                                                                                                        //記錄輸入密碼的長度
  336.                                  if(m==n)                                                                                                        //長度判斷
  337.                                                 {
  338.                                                          if(flag1)                                                                                                                                                                                        //修改密碼后
  339.                                                                         for(j=0;j<sizeof(passwordtemp);j++)                                                                //是否一一對應(yīng)
  340.                                                                                 { if(passwordtemp[j]==newpassword[j])
  341.                                                                                         Flag=0;
  342.                                                                                         else
  343.                                                                                         { Flag=1;
  344.                                                                                                 break;
  345.                                                                                         }
  346.                                                                                 }
  347.                                                                 else                                                                                                                                                                                                //修改密碼前
  348.                                                                         for(j=0;j<sizeof(passwordtemp);j++)                                                                //是否一一對應(yīng)
  349.                                                                                 { if(passwordtemp[j]==password[j])
  350.                                                                                         Flag=0;
  351.                                                                                         else
  352.                                                                                         { Flag=1;
  353.                                                                                                 break;
  354.                                                                                         }
  355.                                                                                 }
  356.                                                 }
  357.                                  else
  358.                                  {         Flag=1;
  359.                                                 Write_LCD(0,1,"                ");                //清除該行
  360.                                                 delay1(10);
  361.                                                 Write_LCD(0,1,"Wrong length!");                                //密碼正確顯示的信息
  362.                                           delay1(10);
  363.                                  }
  364.                                  if(Flag)                                                                                                                                        //輸入錯(cuò)誤提示和輸入錯(cuò)誤總次數(shù)判斷，限定三次
  365.                                  {
  366.                                                 Write_LCD(0,1,"                ");                //清除該行
  367.                                                 delay1(10);
  368.                                                 Write_LCD(0,1,"Wrong Retry!");                                //輸入錯(cuò)誤提示
  369.                                           for(j=0;j<sizeof(passwordtemp);j++)   //清除輸入的錯(cuò)誤密碼
  370.                                               passwordtemp[j]='\0';
  371.                                           inputtimes++;                                                                                                        //連續(xù)輸入錯(cuò)誤，則次數(shù)累加
  372.                                                 i=0;
  373.                                                         if(inputtimes==3)
  374.                                                                 {
  375.                                                                         Write_LCD(0,1,"                ");//清除該行
  376.                                                                         delay1(10);
  377.                                                                         Write_LCD(0,1,"Wrong 3 times!");//密碼錯(cuò)誤，提示重新輸入
  378.                                                                         while(1)
  379.                                                                                 P2=light2;                                                                                                 //停止該位置，重啟電源后才能輸入，實(shí)際實(shí)用中則需要等到一定時(shí)間后才能再次輸入。
  380.                                                                 }
  381.                                  }
  382.                                         else
  383.                                         {
  384.                                                                 Write_LCD(0,1,"                ");//清除該行
  385.                                                                 delay1(10);
  386.                                                                 Write_LCD(0,1,"Right Open!>>>>");//密碼正確顯示的信息
  387.                                                                 P2=light1;
  388.                                                                 inputtimes=0;//輸入正確則次數(shù)清零，重新計(jì)數(shù)
  389.                                                                 Flag=0;      //清除正確標(biāo)志
  390.                                                                 i=0;
  391.                                                                
  392.                                         }
  393. }

  395. //--------------------------------------------------------修改密碼時(shí)的密碼驗(yàn)證--------------------------------------------------------

  397. void SetPassword()                                                                                                                                                                                                                                        //設(shè)置新密碼時(shí)，先驗(yàn)證
  398. { while(1)
  399.         { num=KeyPro();  //掃描鍵盤
  400.            if(num!=0xff)  //如果掃描是按鍵有效值則進(jìn)行處理
  401.                         {
  402.                                 if(i==0)
  403.                                         Write_LCD(0,1,"                ");//清除該行
  404.                                 if(num=='f')                                                                                                                                                                                        //確定鍵按下，進(jìn)入判斷密碼對錯(cuò)
  405.                                         {
  406.                                                 i=0;
  407.                                                 if(flag1)
  408.                                                         m=sizeof(newpassword);
  409.                                                 else
  410.                                                         m=sizeof(password);
  411.                                                         n=sizeof(passwordtemp);
  412.                                  
  413.                                                 if(m==n)                                                                                                        //長度判斷
  414.                                                 { if(flag1)
  415.                                                                 for(j=0;j<sizeof(passwordtemp);j++)                                                                //是否一一對應(yīng)
  416.                                                         { if(passwordtemp[j]==newpassword[j])
  417.                                                                         Flag=0;
  418.                                                                 else
  419.                                                                         { Flag=1;
  420.                                                                                 break;
  421.                                                                         }
  422.                                                         }
  423.                                                         for(j=0;j<sizeof(passwordtemp);j++)                                                                //是否一一對應(yīng)
  424.                                                         { if(passwordtemp[j]==password[j])
  425.                                                                         Flag=0;
  426.                                                                 else
  427.                                                                         { Flag=1;
  428.                                                                                 break;
  429.                                                                         }
  430.                                                         }
  431.                                                 }
  432.                                  else
  433.                                  {  Flag=1;
  434.                                           Write_LCD(0,1,"                ");                //清除該行
  435.                                                 delay1(10);
  436.                                                 Write_LCD(0,1,"Wrong length!");                                //密碼正確顯示的信息
  437.                                           delay1(10);
  438.                                                 i=0;
  439.                                           P2=light2;
  440.                                           inputtimes++;
  441.                                          
  442.                                  }
  443.                                  if(Flag)                                                                                                                                        //輸入錯(cuò)誤提示和輸入錯(cuò)誤總次數(shù)判斷，限定三次
  444.                                  {
  445.                                                 Write_LCD(0,1,"                ");                //清除該行
  446.                                                 delay1(10);
  447.                                                 Write_LCD(0,1,"Wrong Retry!");                                //密碼錯(cuò)誤
  448.                                           for(j=0;j<sizeof(passwordtemp);j++)
  449.                                               passwordtemp[j]='\0';
  450.                                           inputtimes++;                                                                                                        //連續(xù)輸入錯(cuò)誤，則次數(shù)累加
  451.                                                         if(inputtimes==3)
  452.                                                                 {
  453.                                                                         Write_LCD(0,1,"                ");//清除該行
  454.                                                                         delay1(10);
  455.                                                                         Write_LCD(0,1,"Wrong 3 times!");//密碼錯(cuò)誤，提示重新輸入
  456.                                                                         while(1)
  457.                                                                                 P2=light2;                                                                                                 //停止該位置，重啟電源后才能輸入，實(shí)際實(shí)用中則需要等到一定時(shí)間后才能再次輸入。
  458.                                                                 }
  459.                                  }
  460.                                         else
  461.                                         {
  462.                                                                 Write_LCD(0,1,"                ");//清除該行
  463.                                                                 delay1(10);
  464.                                                                 Write_LCD(0,1,"Right Password!");//密碼正確
  465.                                                                 RuningLight();
  466.                                                                 i=0;
  467.                                                                 inputtimes=0;//輸入正確則次數(shù)清零，重新計(jì)數(shù)
  468.                                                                 Flag=0;      //清除正確標(biāo)志
  469.                                                                 break;
  470.                                         }
  471.                         }
  472.                                 
  473.                         else                                                                                                                                                                 //沒有按確定鍵，保存鍵值
  474.                         {
  475.                                 if(i<16)
  476.                                 {
  477.                                         passwordtemp[i]=num;                                                                                //保存密碼
  478.                                         DisplayOneChar(i,1,num);                                                                //輸入的密碼用"*"代替
  479.                                         i++;                                                                                                                                                //計(jì)數(shù)，不能超過16位
  480.                                 }
  481.                                 else
  482.                                 {        Write_LCD(0,1,"                ");//清除該行
  483.                                         delay1(10);
  484.                                         Write_LCD(0,1,"Too Many Retry");
  485.                                         inputtimes++;
  486.                                         i=0;        
  487.                                         P2=light2;
  488.                                 }
  489.                         }
  490. }
  491. }
  492. }

  494. //--------------------------------------------------------新密碼輸入--------------------------------------------------------

  496. void NewPasswordInput()                                                                                                                                                                                                        //新密碼輸入
  497. {
  498.                                 while(1)
  499.                                 {        num=KeyPro();  //掃描鍵盤
  500.                                         if(num!=0xff)  //如果掃描是按鍵有效值則進(jìn)行處理
  501.                                         {
  502.                                                 if(i==0)
  503.                                                         Write_LCD(0,1,"                ");//清除該行
  504.                                                 if(num=='f')
  505.                                                   { i=0;
  506.                                                                 RuningLight();
  507.                                                                 break;
  508.                                                         }
  509.                                                 else if(i<16)                                                                                                                                                        //新密碼不能超過16位
  510.                                                         {
  511.                                                                 newpassword[i]=num;                                                                                //保存密碼
  512.                                                                 DisplayOneChar(i,1,num);                                                                //顯示新密碼
  513.                                                                 i++;                                                                                                                                                //計(jì)數(shù)，不能超過16位
  514.                                                         }
  515.                                                 else
  516.                                                         {        i=0;
  517.                                                                 Write_LCD(0,1,"                ");                        //清除該行
  518.                                                                 delay1(10);
  519.                                                                 Write_LCD(0,1,"Too Many Retry");                                //輸入過多，報(bào)錯(cuò)
  520.                                                                 delay1(10);
  521.                                                                 for(j=0;j<sizeof(newpassword);j++)                        //清除新密碼
  522.                                                                                 newpassword[j]='\0';
  523.                                                                 P2=light2;
  524.                                                                 Write_LCD(0,1,"                ");                                                                                        //清除該行
  525.                                                                 delay1(10);
  526.                                                                 Write_LCD(0,1,"new password!");                                                                                                 //重新輸入新密碼
  527.                                                                 delay1(10);
  528.                                                                
  529.                                                 }        
  530.                                         }
  531.                                 }
  532. }

  534. //--------------------------------------------------------確認(rèn)修改的密碼--------------------------------------------------------

  536. void AgainInput()                                                                                                                                                                                                                //新密碼確認(rèn)
  537. {
  538.         while(1)
  539.         {      
  540.                                         num=KeyPro();  //掃描鍵盤
  541.                                         if(num!=0xff)  //如果掃描是按鍵有效值則進(jìn)行處理
  542.                                                         { if(i==0)
  543.                                                                         Write_LCD(0,1,"                ");//清除該行
  544.                                                                 if(num=='f')
  545.                                                                 {        
  546.                                                                                 i=0;
  547.                                                                                 n=sizeof(passwordtemp);
  548.                                                                                 m=sizeof(newpassword);
  549.                                                                                 if(m==n)                                                                                                        //長度判斷
  550.                                                                                         {
  551.                                                                                                 for(j=0;j<sizeof(passwordtemp);j++)                                                                //是否一一對應(yīng)
  552.                                                                                                         { if(passwordtemp[j]==newpassword[j])
  553.                                                                                                                 Flag=0;
  554.                                                                                                                 else
  555.                                                                                                                 { Flag=1;
  556.                                                                                                                         break;
  557.                                                                                                                 }
  558.                                                                                                         }
  559.                                                                                         }
  560.                                                                                 else
  561.                                                                                  Flag=1;
  562.                                                                                 if(Flag)                                                                                                                                        //輸入錯(cuò)誤提示和輸入錯(cuò)誤總次數(shù)判斷，限定三次
  563.                                                                                         {
  564.                                                                                                 Write_LCD(0,1,"                ");                //清除該行
  565.                                                                                                 delay1(10);
  566.                                                                                                 Write_LCD(0,1,"Difference!!");                                //密碼正確顯示的信息
  567.                                                                                                 for(j=0;j<sizeof(passwordtemp);j++)                        //清除密碼
  568.                                                                                                         passwordtemp[j]='\0';
  569.                                                                                                 i=0;
  570.                                                                                                 Flag=0;
  571.                                                                                                 P2=light2;
  572.                                                                                         }
  573.                                                                
  574.                                                                                 else
  575.                                                                                         {
  576.                                                                                                 Write_LCD(0,1,"                ");//清除該行
  577.                                                                                                 delay1(10);
  578.                                                                                                 Write_LCD(0,1,"Right!");                                        //密碼正確顯示的信息
  579.                                                                                                 delay1(10);
  580.                                                                                                 Write_LCD(0,1,"                ");//清除該行
  581.                                                                                                 delay1(10);
  582.                                                                                                 Write_LCD(0,1,"Finish!");        
  583.                                                                                                 RuningLight();
  584.                                                                                                 Write_LCD(0,1,"                ");//清除該行
  585.                                                                                                 delay1(10);
  586.                                                                                                 Write_LCD(0,1,"Right Open>>>");//清除該行
  587.                                                                                                 P2=light1;
  588.                                                                                                 inputtimes=0;//輸入正確則次數(shù)清零，重新計(jì)數(shù)
  589.                                                                                                 Flag=0;      //清除正確標(biāo)志
  590.                                                                                                 i=0;
  591.                                                                                                 break;
  592.                                                                                         }

  594.                                                                         }        
  595.                                                                 else if(i<16)                                                                                                                                                                                                        //密碼不能超過16位
  596.                                                                                                 {
  597.                                                                                                         passwordtemp[i]=num;                                                                                //保存密碼
  598.                                                                                                         DisplayOneChar(i,1,num);                                                                //顯示新密碼
  599.                                                                                                         i++;                                                                                                                                                //計(jì)數(shù)，不能超過16位
  600.                                                                                                 }
  601.                                                                                         else
  602.                                                                                                 {        Write_LCD(0,1,"                ");                        //清除該行
  603.                                                                                                         delay1(10);
  604.                                                                                                         Write_LCD(0,1,"Too Many Retry");                                //輸入過多，報(bào)錯(cuò)
  605.                                                                                                         delay1(10);
  606.                                                                                                         for(j=0;j<sizeof(passwordtemp);j++)                        //清除密碼
  607.                                                                                                         passwordtemp[j]='\0';
  608.                                                                                                         i=0;                                                                                                                                                //重新輸入
  609.                                                                                                         P2=light2;
  610.                                                                                                         Write_LCD(0,1,"                ");                        //清除該行
  611.                                                                                                         delay1(10);
  612.                                                                                                         Write_LCD(0,1,"Input New Again!");                        //重新輸入新密碼
  613.                                                                                                         delay1(10);        
  614.                                                                                                 }
  615.                                                         }
  616.                                        
  617.                 }
  618.         }

  620. //--------------------------------------------------------主函數(shù)--------------------------------------------------------

  622. void main()
  623. {
  624.         initial();
  625.         Init_Lcd();         //初始化液晶屏
  626.         delay1(10);        //延時(shí)用于穩(wěn)定，可以去掉
  627.         Write_LCD(0,0,"  Welcome! ");    //寫入第一行信息，主循環(huán)中不再更改此信息，所以在while之前寫入
  628.         delay1(10);
  629.         Write_LCD(0,1,"Input password!");    //寫入第二行信息，提示輸入密碼
  630.         delay1(10);
  631. while (1)         //主循環(huán)
  632. {

  634.          num=KeyPro();  //掃描鍵盤
  635.          if(num!=0xff)  //如果掃描是按鍵有效值則進(jìn)行處理
  636.            {
  637.                         if(i==0)
  638.                   Write_LCD(0,1,"                ");                                                                                                //清除該行
  639.                         if(num=='e')                                                                                                                                                                                        //設(shè)置新密碼
  640.                         { P2=0xff;
  641.                                 for(j=0;j<sizeof(newpassword);j++)                                                                                        //釋放存儲(chǔ)新密碼數(shù)組
  642.                                  newpassword[j] = '\0';                 
  643.                                 Write_LCD(0,1,"Set Password!");
  644.                                 delay1(10);
  645.                                 Write_LCD(0,1,"                ");                                                                                        //清除該行
  646.                                 delay1(10);
  647.                                 Write_LCD(0,1,"Input Password!");                                                                                                //用戶驗(yàn)證
  648.                                 delay1(10);
  649.                                 SetPassword();                                                                                                                                                                        //驗(yàn)證密碼
  650.                                 P2=0xff;
  651.                                         Write_LCD(0,1,"                ");                                                                                        //清除該行
  652.                                 delay1(10);
  653.                                 Write_LCD(0,1,"New Password!");                                                                                                         //新密碼輸入
  654.                                 delay1(10);
  655.                                 NewPasswordInput();                                                                                                                                                        //新密碼輸入
  656.                                 P2=0xff;
  657.                                 Write_LCD(0,1,"                ");               
  658.                                 delay1(10);
  659.                                 Write_LCD(0,1,"Again Input!!");
  660.                                 AgainInput();                                                                                                                                                                                //新密碼確認(rèn)
  661.                                 for(j=0;j<sizeof(passwordtemp);j++)                                                                                        //釋放存儲(chǔ)輸入密碼數(shù)組
  662.                                  passwordtemp[j] = '\0';
  663.                                  flag1=1;                                                                                                                                                                                                        //修改密碼標(biāo)志位        
  664.                         }
  665.                         else if(num=='f')                                                                                                                                                                                        //確定鍵按下，進(jìn)入判斷密碼對錯(cuò)
  666.                                                 { i=0;                                                                                                                                                                                                        //清除輸入標(biāo)志
  667.                                                         VriefytPassword();                                                                                                                                                //密碼認(rèn)證
  668.                                                 }
  669.                                                 else if(num=='b')                                                                                                                                                                //上鎖
  670.                                                 {
  671.                                                         P2=0xff;
  672.                                                         delay1(10);        
  673.                                                         Write_LCD(0,1,"                ");                                                                                        //清除該行
  674.                                                         delay1(10);
  675.                                                         Write_LCD(0,1,"Input password!");
  676.                                                         i=0;
  677.                                                         for(j=0;j<sizeof(passwordtemp);j++)
  678.                                                           passwordtemp[j] ='\0';                                                                        
  679.                                                 }
  680.                                                 else                                                                                                                                                                                                                //沒有按確定鍵，上鎖鍵，設(shè)置鍵，保存鍵值
  681.                                                 {
  682.                                                         if(i<16)
  683.                                                                 {
  684.                                                                         passwordtemp[i]=num;                                                                                //保存密碼
  685.                                                                         DisplayOneChar(i,1,num);                                                                //輸入的密碼用"*"代替
  686.                                                                         i++;                                                                                                                                                //計(jì)數(shù)，不能超過16位
  687.                                                                 }
  688.                                                         else
  689.                                                                 {        Write_LCD(0,1,"                ");//清除該行
  690.                                                                         delay1(10);
  691.                                                                         Write_LCD(0,1,"Too Many Retry");
  692.                                                                         inputtimes++;
  693.                                                                         i=0;        
  694.                                                                 }
  695.                                                 }
  696.                 }
  697.         }
  698. }
復(fù)制代碼

所有程序51hei提供下載:
基于STC51的簡易密碼鎖.rar (50.08 KB, 下載次數(shù): 22)


作者: 欣語寶貝    時(shí)間: 2020-7-30 21:26
沙發(fā)是我



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