找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 3678|回复: 4
打印 上一主题 下一主题
收起左侧

基于51单片机的密码锁Proteus仿真程序设计 LCD1602显示 超过三次输入错误自动锁定

[复制链接]
跳转到指定楼层
#
第一次发帖,难免有错请指出  

由STC89C52单片机系统(主要是STC89C52单片机最小系统)、4×4矩阵键盘、LCD1602显示和报警系统等组成一个密码锁,具有设置、修改六位用户密码、超次报警、超次锁定、密码错误报警等功能。
密码正确显示OPEN! 密码错误显示error!超过三次输入错误自动锁定。
输入密码时在LCD屏幕上显示*号,若密码输入错误次数超过3次,蜂
鸣器报警并且锁定键盘。
对输入的6位密码进行隐藏;通过发光二极管和蜂鸣器,对解密正确或者错误进行声光报警;

仿真原理图如下(proteus仿真工程文件可到本帖附件中下载)


单片机源程序如下:
  1. //<font style="background-color:rgb(255, 255, 255)">
  2. #include <reg51.h>
  3. #include<intrins.h>
  4. #define LCM_Data  P0
  5. #define uchar unsigned char
  6. #define uint  unsigned int
  7. #define w 6                                                        //定义密码位数
  8. sbit lcd1602_rs=P2^7;
  9. sbit lcd1602_rw=P2^6;
  10. sbit lcd1602_en=P2^5;

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

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

  15. sbit open_led=P2^2;                            //开锁指示灯

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

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

  22. void Delay5Ms(void);

  23. unsigned char code a[]={0xFE,0xFD,0xFB,0xF7};                                              //控盘扫描控制表

  24. unsigned char code start_line[]              = {"password:       "};
  25. unsigned char code name[]                             = {"===Coded Lock==="};       //显示名称
  26. unsigned char code Correct[]               = {"     correct    "};              //输入正确
  27. unsigned char code Error[]                 = {"      error     "};               //输入错误
  28. unsigned char code codepass[]              = {"      pass      "};
  29. unsigned char code LockOpen[]              = {"      open      "};                //OPEN
  30. unsigned char code SetNew[]               = {"SetNewWordEnable"};
  31. unsigned char code Input[]                 = {"input:          "};          //INPUT
  32. unsigned char code ResetOK[]               = {"ResetPasswordOK "};
  33. unsigned char code initword[]              = {"Init password..."};
  34. unsigned char code Er_try[]                            = {"error,try again!"};
  35. unsigned char code again[]                            = {"input again     "};

  36. unsigned char InputData[6];                                                 //输入密码暂存区
  37. unsigned char CurrentPassword[6]={1,3,1,4,2,0};                          //当前密码值
  38. unsigned char TempPassword[6];
  39. unsigned char N=0;                                                        //密码输入位数记数
  40. unsigned char ErrorCont;                                          //错误次数计数
  41. unsigned char CorrectCont;                                          //正确输入计数
  42. unsigned char ReInputCont;                                           //重新输入计数
  43. unsigned char code initpassword[6]={0,0,0,0,0,0};

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

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

  61. //=============================================================================================
  62. //================================24C02========================================================
  63. //=============================================================================================

  64. void mDelay(uint t) //延时
  65. {
  66.               uchar i;
  67.                  while(t--)
  68.                  {
  69.                                for(i=0;i<125;i++)
  70.                                {;}
  71.                  }
  72. }
  73.    void Nop(void)                              //空操作
  74. {
  75.               _nop_();
  76.               _nop_();
  77.               _nop_();
  78.               _nop_();
  79. }


  80. /*起始条件*/

  81. void Start(void)
  82. {
  83.               Sda=1;
  84.               Scl=1;
  85.               Nop();
  86.               Sda=0;
  87.               Nop();
  88. }


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

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

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

  116. /*发送数据子程序,Data为要求发送的数据*/
  117. void Send(uchar Data)
  118. {
  119.                  uchar BitCounter=8;
  120.                  uchar temp;
  121.                  do
  122.                  {
  123.                                temp=Data;
  124.                                Scl=0;
  125.                                Nop();
  126.                                if((temp&0x80)==0x80)
  127.                                Sda=1;
  128.                                else
  129.                                Sda=0;
  130.                                Scl=1;
  131.                                temp=Data<<1;
  132.                                Data=temp;
  133.                                BitCounter--;
  134.                  }
  135.                  while(BitCounter);
  136.                  Scl=0;
  137. }

  138. /*读一字节的数据,并返回该字节值*/
  139. uchar Read(void)
  140. {
  141.     uchar temp=0;
  142.               uchar temp1=0;
  143.               uchar BitCounter=8;
  144.               Sda=1;
  145.               do{
  146.               Scl=0;
  147.               Nop();
  148.               Scl=1;
  149.               Nop();
  150.               if(Sda)
  151.               temp=temp|0x01;
  152.               else
  153.               temp=temp&0xfe;
  154.               if(BitCounter-1)
  155.               {
  156.               temp1=temp<<1;
  157.               temp=temp1;
  158.               }
  159.               BitCounter--;
  160.               }
  161.               while(BitCounter);
  162.               return(temp);
  163.               }

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

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

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


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

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

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

  237. //-------------------------初始化-------------------------
  238. void lcd_init(void)
  239. {
  240.               write_1602com(0x38);//设置液晶工作模式,意思:16*2行显示,5*7点阵,8位数据
  241.               write_1602com(0x0c);//开显示不显示光标
  242.               write_1602com(0x06);//整屏不移动,光标自动右移
  243.               write_1602com(0x01);//清显示
  244. }
  245. //========================================================================================
  246. //=========================================================================================

  247. //==============将按键值编码为数值=========================
  248. unsigned char coding(unsigned char m)            
  249. {
  250.               unsigned char k;
  251.             
  252.               switch(m)
  253.               {
  254.                             case (0x11): k=1;break;
  255.                             case (0x21): k=2;break;
  256.                             case (0x41): k=3;break;
  257.                             case (0x81): k='A';break;
  258.                             case (0x12): k=4;break;
  259.                             case (0x22): k=5;break;
  260.                             case (0x42): k=6;break;
  261.                             case (0x82): k='B';break;
  262.                             case (0x14): k=7;break;
  263.                             case (0x24): k=8;break;
  264.                             case (0x44): k=9;break;
  265.                             case (0x84): k='C';break;
  266.                             case (0x18): k='*';break;
  267.                             case (0x28): k=0;break;
  268.                             case (0x48): k='#';break;
  269.                             case (0x88): k='D';break;
  270.               }
  271.               return(k);
  272. }


  273. //=====================按键检测并返回按键值===============================
  274. unsigned char keynum(void)
  275. {
  276.               unsigned char row,col,i;
  277.               P1=0xf0;
  278.               if((P1&0xf0)!=0xf0)
  279.               {
  280.                                Delay5Ms();
  281.         Delay5Ms();
  282.                                if((P1&0xf0)!=0xf0)
  283.                             {
  284.                                 row=P1^0xf0;          //确定行线
  285.                                           i=0;
  286.                                           P1=a[i];                        //精确定位
  287.                                           while(i<4)
  288.                                           {
  289.                                                         if((P1&0xf0)!=0xf0)
  290.                                                           {
  291.                                                                          col=~(P1&0xff);                //确定列线
  292.                                                                          break;            //已定位后提前退出  
  293.                                                           }
  294.                                                         else
  295.                                                           {
  296.                                                                          i++;
  297.                                                                          P1=a[i];
  298.                                                           }
  299.                                           }
  300.                             }
  301.                             else
  302.                             {
  303.                                           return 0;
  304.                             }
  305.             
  306.                             while((P1&0xf0)!=0xf0);
  307.        return (row|col);                                          //行线与列线组合后返回
  308.               }
  309.               else return 0;                                                   //无键按下时返回0
  310. }
  311. //=======================一声提示音,表示有效输入========================
  312. void OneAlam(void)
  313. {
  314.               ALAM=0;
  315.               Delay5Ms();
  316.     ALAM=1;
  317. }
  318. //========================二声提示音,表示操作成功========================
  319. void TwoAlam(void)
  320. {
  321.               ALAM=0;
  322.               Delay5Ms();
  323.     ALAM=1;
  324.     Delay5Ms();
  325.               ALAM=0;
  326.               Delay5Ms();
  327.     ALAM=1;
  328. }
  329. //========================三声提示音,表示错误========================
  330. void ThreeAlam(void)
  331. {
  332.               ALAM=0;
  333.               Delay5Ms();
  334.     ALAM=1;
  335.     Delay5Ms();
  336.               ALAM=0;
  337.               Delay5Ms();
  338.     ALAM=1;
  339.     Delay5Ms();
  340.               ALAM=0;
  341.               Delay5Ms();
  342.     ALAM=1;

  343. }
  344. //=====================显示输入的N个数字,用H代替以便隐藏============================
  345. void DisplayOne(void)
  346. {
  347. //              DisplayOneChar(9+N,1,'*');
  348.               write_1602com(yi+5+N);
  349.               write_1602dat('*');
  350. }
  351. //=======================显示提示输入=========================
  352. void DisplayChar(void)
  353. {
  354.               unsigned char i;
  355.               if(pass==1)
  356.               {
  357.                             //DisplayListChar(0,1,LockOpen);
  358.                             write_1602com(er);
  359.                             for(i=0;i<16;i++)
  360.                             {
  361.                                           write_1602dat(LockOpen[i]);            
  362.                             }
  363.               }
  364.               else
  365.               {
  366.                             if(N==0)
  367.                             {
  368.                                           //DisplayListChar(0,1,Error);
  369.                                           write_1602com(er);
  370.                                           for(i=0;i<16;i++)
  371.                                           {
  372.                                                         write_1602dat(Error[i]);            
  373.                                           }
  374.                             }
  375.                             else
  376.                             {
  377.                                           //DisplayListChar(0,1,start_line);            
  378.                                           write_1602com(er);
  379.                                           for(i=0;i<16;i++)
  380.                                           {
  381.                                                         write_1602dat(start_line[i]);            
  382.                                           }
  383.                             }
  384.               }
  385. }

  386. void DisplayInput(void)
  387. {
  388.               unsigned char i;
  389.               if(CorrectCont==1)
  390.               {
  391.                             //DisplayListChar(0,0,Input);
  392.                             write_1602com(er);
  393.                             for(i=0;i<16;i++)
  394.                             {
  395.                                           write_1602dat(Input[i]);            
  396.                             }
  397.               }
  398. }


  399. //========================重置密码==================================================
  400. //==================================================================================
  401. void ResetPassword(void)
  402. {
  403.               unsigned char i;            
  404.               unsigned char j;
  405.               if(pass==0)
  406.               {
  407.                             pass=0;
  408.                             DisplayChar();
  409.                             ThreeAlam();
  410.               }
  411.               else
  412.               {
  413.                   if(ReInputEn==1)
  414.                             {
  415.                                           if(N==6)
  416.                                           {
  417.                                                         ReInputCont++;                                                      
  418.                                                         if(ReInputCont==2)
  419.                                                         {
  420.                                                                       for(i=0;i<6;)
  421.                                                                       {
  422.                                                                                     if(TempPassword[i]==InputData[i])              //将两次输入的新密码作对比
  423.                                                                                                   i++;
  424.                                                                                     else
  425.                                                                                     {
  426.                                                                                                   //DisplayListChar(0,1,Error);
  427.                                                                                                   write_1602com(er);
  428.                                                                                                   for(j=0;j<16;j++)
  429.                                                                                                   {
  430.                                                                                                                 write_1602dat(Error[j]);            
  431.                                                                                                   }
  432.                                                                                                   ThreeAlam();          //错误提示            
  433.                                                                                                   pass=0;
  434.                                                                                                   ReInputEn=0;        //关闭重置功能,
  435.                                                                                                   ReInputCont=0;
  436.                                                                                                   DisplayChar();
  437.                                                                                                   break;
  438.                                                                                     }
  439.                                                                       }
  440.                                                                       if(i==6)
  441.                                                                       {
  442.                                                                                     //DisplayListChar(0,1,ResetOK);
  443.                                                                                     write_1602com(er);
  444.                                                                                     for(j=0;j<16;j++)
  445.                                                                                     {
  446.                                                                                                   write_1602dat(ResetOK[j]);            
  447.                                                                                     }

  448.                                                                                     TwoAlam();                     //操作成功提示
  449.                                                                                     WrToROM(TempPassword,0,6);     //将新密码写入24C02存储
  450.                                                                                     ReInputEn=0;
  451.                                                                       }
  452.                                                                       ReInputCont=0;
  453.                                                                       CorrectCont=0;
  454.                                                         }
  455.                                                         else
  456.                                                         {
  457.                                                                       OneAlam();
  458.                                                                       //DisplayListChar(0, 1, again);  //显示再次输入一次
  459.                                                                       write_1602com(er);
  460.                                                                       for(j=0;j<16;j++)
  461.                                                                       {
  462.                                                                                     write_1602dat(again[j]);            
  463.                                                                       }                                                                     
  464.                                                                       for(i=0;i<6;i++)
  465.                                                                       {
  466.                                                                                     TempPassword[i]=InputData[i];     //将第一次输入的数据暂存起来                                                                                   
  467.                                                                       }
  468.                                                         }

  469.                                           N=0;                        //输入数据位数计数器清零
  470.                                }
  471.                   }
  472.               }

  473. }



  474. //=======================输入密码错误超过三过,报警并锁死键盘======================
  475. void Alam_KeyUnable(void)
  476. {
  477.               P1=0x00;
  478.               {
  479.                             ALAM=~ALAM;
  480.                             Delay5Ms();
  481.               }
  482. }


  483. //=======================取消所有操作============================================
  484. void Cancel(void)
  485. {            
  486.               unsigned char i;
  487.               unsigned char j;
  488.               //DisplayListChar(0, 1, start_line);
  489.               write_1602com(er);
  490.               for(j=0;j<16;j++)
  491.               {
  492.                             write_1602dat(start_line[j]);            
  493.               }
  494.               TwoAlam();                                                        //提示音
  495.               for(i=0;i<6;i++)
  496.               {
  497.                             InputData[i]=0;
  498.               }
  499.               KEY=1;                                                                      //关闭锁
  500.               ALAM=1;                                                                      //报警关
  501.               operation=0;                                          //操作标志位清零
  502.               pass=0;                                                                      //密码正确标志清零
  503.               ReInputEn=0;                                          //重置输入充许标志清零
  504.               ErrorCont=0;                                          //密码错误输入次数清零
  505.               CorrectCont=0;                                          //密码正确输入次数清零
  506.               ReInputCont=0;                                          //重置密码输入次数清零
  507.               open_led=1;
  508.               s3_keydown=0;
  509.               key_disable=0;
  510.               N=0;                                                                      //输入位数计数器清零
  511. }


  512. //==========================确认键,并通过相应标志位执行相应功能===============================
  513. void Ensure(void)
  514. {            
  515.               unsigned char i,j;
  516.               RdFromROM(CurrentPassword,0,6);                              //从24C02里读出存储密码
  517.     if(N==6)
  518.               {
  519.                   if(ReInputEn==0)                                              //重置密码功能未开启
  520.                             {
  521.                                           for(i=0;i<6;)
  522.                                              {                                                                     
  523.                                                         if(CurrentPassword[i]==InputData[i])
  524.                                                         {
  525.                                                                       i++;
  526.                                                         }
  527.                                                         else
  528.                                                         {                                         
  529.                                                                       ErrorCont++;
  530.                                                                       if(ErrorCont==3)      //错误输入计数达三次时,报警并锁定键盘
  531.                                                                       {
  532.                                                                                     write_1602com(er);
  533.                                                                                     for(i=0;i<16;i++)
  534.                                                                                     {
  535.                                                                                                   write_1602dat(Error[i]);            
  536.                                                                                     }
  537.                                                                                     do
  538.                                                                                     Alam_KeyUnable();
  539.                                                                                     while(1);
  540.                                                                       }
  541.                                                                       else
  542.                                                                       {
  543.                                                                                     TR0=1;               //开启定时
  544.                                                                                     key_disable=1;   //锁定键盘
  545.                                                                                     pass=0;
  546.                                                                                     break;
  547.                                                                       }
  548.                                                         }
  549.                                           }

  550.                                           if(i==6)
  551.                                           {
  552.                                                         CorrectCont++;
  553.                                                         if(CorrectCont==1)         //正确输入计数,当只有一次正确输入时,开锁,
  554.                                                         {
  555.                                                                       //DisplayListChar(0,1,LockOpen);
  556.                                                                       write_1602com(er);
  557.                                                                       for(j=0;j<16;j++)
  558.                                                                       {
  559.                                                                                     write_1602dat(LockOpen[j]);            
  560.                                                                       }
  561.                                                                       TwoAlam();                                          //操作成功提示音
  562.                                                                       KEY=0;              //开锁
  563.                                                                       pass=1;             //置正确标志位
  564.                                                                       TR0=1;                //开启定时
  565.                                                                       open_led=0;        //开锁指示灯亮
  566.                                                                       for(j=0;j<6;j++)      //将输入清除
  567.                                                                       {
  568.                                                                                     InputData[i]=0;
  569.                                                                       }
  570.                                                         }            
  571.                                                         else                                                //当两次正确输入时,开启重置密码功能
  572.                                                         {
  573.                                                                       //DisplayListChar(0,1,SetNew);
  574.                                                                       write_1602com(er);
  575.                                                                       for(j=0;j<16;j++)
  576.                                                                       {
  577.                                                                                     write_1602dat(SetNew[j]);            
  578.                                                                       }
  579.                                                                       TwoAlam();                                 //操作成功提示
  580.                                                                       ReInputEn=1;                               //允许重置密码输入
  581.                                                                       CorrectCont=0;                              //正确计数器清零
  582.                                                         }
  583.                                             }
  584.             
  585.                                           else                           //=========================当第一次使用或忘记密码时可以用131420对其密码初始化============
  586.                                           {
  587.                                                         if((InputData[0]==1)&&(InputData[1]==3)&&(InputData[2]==1)&&(InputData[3]==4)&&(InputData[4]==2)&&(InputData[5]==0))
  588.                                                           {
  589.                                                                       WrToROM(initpassword,0,6);            //强制将初始密码写入24C02存储
  590.                                                                       //DisplayListChar(0,1,initword);       //显示初始化密码
  591.                                                                       write_1602com(er);
  592.                                                                       for(j=0;j<16;j++)
  593.                                                                       {
  594.                                                                                     write_1602dat(initword[j]);            
  595.                                                                       }
  596.                                                                       TwoAlam();
  597.                                                                       Delay400Ms();
  598.                                                                       TwoAlam();
  599.                                                                       N=0;
  600.                                                         }
  601.                                                         else
  602.                                                         {
  603.                                                                       //DisplayListChar(0,1,Error);
  604.                                                                       write_1602com(er);
  605.                                                                       for(j=0;j<16;j++)
  606.                                                                       {
  607.                                                                                     write_1602dat(Error[j]);            
  608.                                                                       }
  609.                                                                       ThreeAlam();     //错误提示音
  610.                                                                       pass=0;            
  611.                                                         }
  612.                                           }
  613.                             }

  614.                             else        //当已经开启重置密码功能时,而按下开锁键,
  615.                             {
  616.                                           //DisplayListChar(0,1,Er_try);
  617.                                           write_1602com(er);
  618.                                           for(j=0;j<16;j++)
  619.                                           {
  620.                                                         write_1602dat(Er_try[j]);            
  621.                                           }
  622.                                           ThreeAlam();
  623.                             }
  624.               }

  625.               else
  626.               {
  627.                             //DisplayListChar(0,1,Error);
  628.                             write_1602com(er);
  629.                             for(j=0;j<16;j++)
  630.                             {
  631.                                           write_1602dat(Error[j]);            
  632.                             }

  633.                             ThreeAlam();                                                                              //错误提示音
  634.                             pass=0;            
  635.               }
  636.               N=0;                                                                                               //将输入数据计数器清零,为下一次输入作准备
  637.   operation=1;
  638. }
  639. //==============================主函数===============================
  640. void main(void)
  641. {
  642.               unsigned char KEY,num;
  643.               unsigned char i,j;
  644.               P1=0xF0;
  645.               TMOD=0x11;
  646.               TL0=0xB0;
  647.               TH0=0x3C;
  648.               EA=1;
  649.               ET0=1;            
  650.               TR0=0;
  651.               Delay400Ms();               //启动等待,等LCM讲入工作状态
  652.               lcd_init();               //LCD初始化
  653.               write_1602com(yi);//日历显示固定符号从第一行第0个位置之后开始显示
  654.               for(i=0;i<16;i++)
  655.               {
  656.                             write_1602dat(name[i]);//向液晶屏写日历显示的固定符号部分
  657.               }
  658.               write_1602com(er);//时间显示固定符号写入位置,从第2个位置后开始显示
  659.               for(i=0;i<16;i++)
  660.               {
  661.                             write_1602dat(start_line[i]);//写显示时间固定符号,两个冒号
  662.               }
  663.               write_1602com(er+9);              //设置光标位置
  664.               write_1602com(0x0f);              //设置光标为闪烁
  665.               Delay5Ms(); //延时片刻(可不要)
  666.               N=0;                      //初始化数据输入位数
  667.               while(1)
  668.               {
  669.              if(key_disable==1)
  670.               Alam_KeyUnable();
  671.               else
  672.               ALAM=1;
  673.                          num++;
  674.              if(num>20)
  675.              {
  676.                  num=0;
  677.              }
  678.               KEY=keynum();
  679.                           if(KEY!=0)
  680.                           {
  681.               if(key_disable==1)
  682.                           {
  683.               second=0;
  684.                           }
  685.               else
  686. ……………………

  687. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
密码锁.zip (29.3 KB, 下载次数: 134)
密码锁。DSN.zip (21.03 KB, 下载次数: 104)

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏4 分享淘帖 顶 踩
回复

使用道具 举报

地板
ID:866685 发表于 2020-12-27 10:52 | 只看该作者
仿真成功,谢谢楼主
回复

使用道具 举报

板凳
ID:858605 发表于 2020-12-15 15:04 | 只看该作者
楼主您好,有物料清单吗
回复

使用道具 举报

沙发
ID:849218 发表于 2020-11-27 19:04 | 只看该作者
老哥 重置密码的两次具体怎么操作欸
回复

使用道具 举报

楼主
ID:849218 发表于 2020-11-27 18:44 | 只看该作者
仿真是proteus那个版本啊?
回复

使用道具 举报

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

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

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