设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 电子技术分类讨论区 › 资料共享 › 蓝牙密码锁 单片机源代码
返回列表 发新帖
查看: 7302|回复: 13
打印 上一主题 下一主题
收起左侧

蓝牙密码锁 单片机源代码

  [复制链接]
跳转到指定楼层
楼主
ID:189829 发表于 2017-4-15 15:02 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
  1.    //包含头文件
  2. #include <REG52.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. #define w 6                                //定义密码位数
  9. //1602的控制脚

  11. sbit lcd1602_rs=P2^7;
  12. sbit lcd1602_rw=P2^6;
  13. sbit lcd1602_en=P2^5;

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

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


  22. bit  operation=0;                //操作标志位
  23. bit  pass=0;                        //密码正确标志
  24. bit  ReInputEn=0;                //重置输入允许标志        
  25. bit  s3_keydown=0;                //3秒按键标志位
  26. bit  key_disable=0;                //锁定键盘标志
  27. bit  flag_REC =0;       //串口接受标志位
  28. unsigned char buff[5]=0;
  29. unsigned char countt0,second;        //t0中断计数器,秒计数器

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

  33. unsigned char code a[]={0xFE,0xFD,0xFB,0xF7};                                 //控盘扫描控制表
  34. //液晶显示数据数组
  35. unsigned char code start_line[]        = {"password:       "};
  36. unsigned char code name[]                  = { "===Coded Lock==="};        //显示名称
  37. unsigned char code Correct[]         = {"     correct    "};                //输入正确
  38. unsigned char code Error[]           = {"      error     "};          //输入错误
  39. unsigned char code codepass[]        = {"      pass      "};
  40. unsigned char code LockOpen[]        = {"      open      "};                //OPEN
  41. unsigned char code SetNew[]         = {"SetNewWordEnable"};
  42. unsigned char code Input[]           = {"input:          "};                //INPUT
  43. unsigned char code ResetOK[]         = {"ResetPasswordOK "};
  44. unsigned char code initword[]        = {"Init password..."};
  45. unsigned char code Er_try[]                = {"error,try again!"};
  46. unsigned char code again[]                = {"input again     "};

  48. unsigned char InputData[16];                                                                        //输入密码暂存区
  49. unsigned char CurrentPassword[16]={1,3,1,4,2,0};                         //管理员密码（只可在程序中修改）
  50. unsigned char TempPassword[16];
  51. unsigned char N=0,M=0,flag=0;                                //密码输入位数记数
  52. unsigned char ErrorCont;                        //错误次数计数
  53. unsigned char CorrectCont;                        //正确输入计数
  54. unsigned char ReInputCont;                         //重新输入计数
  55. unsigned char code initpassword[16]={0,0,0,0,0,0};                        //输入管理员密码后将密码初始为000000
  56. unsigned char  MM[2]={0,0};

  58. //=====================5ms延时==============================
  59. void Delay5Ms(void)
  60. {
  61.         unsigned int TempCyc = 5552;
  62.         while(TempCyc--);
  63. }

  65. //===================400ms延时==============================
  66. void Delay400Ms(void)
  67. {
  68. unsigned char TempCycA = 5;
  69. unsigned int TempCycB;
  70. while(TempCycA--)
  71. {
  72.   TempCycB=7269;
  73.   while(TempCycB--);
  74. }
  75. }

  77. //=============================================================================================
  78. //================================24C02========================================================
  79. //=============================================================================================

  81. void mDelay(uint t) //延时
  82. {
  83.         uchar i;
  84.            while(t--)
  85.            {
  86.                    for(i=0;i<125;i++)
  87.                    {;}
  88.            }
  89. }


  92. void Nop(void)                  //空操作
  93. {
  94.          _nop_();                  //仅作延时用一条语句大约1us
  95.          _nop_();
  96.          _nop_();
  97.          _nop_();
  98. }

  100. /*****24c02程序参照24c02时序图*****/
  101. /*起始条件*/

  103. void Start(void)
  104. {
  105.          Sda=1;
  106.          Scl=1;
  107.          Nop();
  108.          Sda=0;
  109.          Nop();
  110. }


  113. /*停止条件*/
  114. void Stop(void)
  115. {
  116.          Sda=0;
  117.          Scl=1;
  118.          Nop();
  119.          Sda=1;
  120.          Nop();
  121. }

  123. /*应答位*/
  124. void Ack(void)
  125. {
  126.         Sda=0;
  127.         Nop();
  128.         Scl=1;
  129.         Nop();
  130.         Scl=0;
  131. }

  133. /*反向应答位*/
  134. void NoAck(void)
  135. {
  136.          Sda=1;
  137.          Nop();
  138.          Scl=1;
  139.          Nop();
  140.          Scl=0;
  141. }

  143. /*发送数据子程序，Data为要求发送的数据*/
  144. void Send(uchar Data)
  145. {
  146.            uchar BitCounter=8;
  147.            uchar temp;
  148.            do
  149.            {
  150.                    temp=Data;                                           //将待发送数据暂存temp
  151.                    Scl=0;
  152.                    Nop();
  153.                    if((temp&0x80)==0x80)                   //将读到的数据&0x80
  154.                    Sda=1;
  155.                    else
  156.                    Sda=0;
  157.                    Scl=1;
  158.                    temp=Data<<1;                                   //数据左移
  159.                    Data=temp;                                           //数据左移后重新赋值Data
  160.                    BitCounter--;                                   //该变量减到0时，数据也就传送完成了
  161.            }
  162.            while(BitCounter);                                   //判断是否传送完成
  163.            Scl=0;
  164. }

  166. /*读一字节的数据，并返回该字节值*/
  167. uchar Read(void)
  168. {
  169.     uchar temp=0;
  170.         uchar temp1=0;
  171.         uchar BitCounter=8;
  172.         Sda=1;
  173.         do
  174.         {
  175.                 Scl=0;
  176.                 Nop();
  177.                 Scl=1;
  178.                 Nop();
  179.                 if(Sda)                                   //数据位是否为1
  180.                         temp=temp|0x01;           //为1 temp的最低位为1（|0x01，就是将最低位变为1）
  181.                 else                                   //如果为0
  182.                         temp=temp&0xfe;           //temp最低位为0（&0xfe（11111110）最低位就是0）
  183.                 if(BitCounter-1)           //BitCounter减1后是否为真
  184.                 {
  185.                         temp1=temp<<1;           //temp左移
  186.                         temp=temp1;
  187.                 }
  188.                 BitCounter--;                   //BitCounter减到0时，数据就接收完了
  189.         }
  190.         while(BitCounter);                   //判断是否接收完成
  191.         return(temp);
  192. }

  194. void WrToROM(uchar Data[],uchar Address,uchar Num)
  195. {
  196.   uchar i;
  197.   uchar *PData;
  198.   PData=Data;
  199.   for(i=0;i<Num;i++)
  200.   {
  201.   Start();
  202.   Send(0xa0);
  203.   Ack();
  204.   Send(Address+i);
  205.   Ack();
  206.   Send(*(PData+i));
  207.   Ack();
  208.   Stop();
  209.   mDelay(20);
  210.   }
  211. }

  213. void RdFromROM(uchar Data[],uchar Address,uchar Num)
  214. {
  215.   uchar i;
  216.   uchar *PData;
  217.   PData=Data;
  218.   for(i=0;i<Num;i++)
  219.   {
  220.   Start();
  221.   Send(0xa0);
  222.   Ack();
  223.   Send(Address+i);
  224.   Ack();
  225.   Start();
  226.   Send(0xa1);
  227.   Ack();
  228.   *(PData+i)=Read();
  229.   Scl=0;
  230.   NoAck();
  231.   Stop();
  232.   }
  233. }


  236. //==================================================================================================
  237. //=======================================LCD1602====================================================
  238. //==================================================================================================

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


  244. //----------------延时函数，后面经常调用----------------------
  245. void delay(uint xms)//延时函数，有参函数
  246. {
  247.         uint x,y;
  248.         for(x=xms;x>0;x--)
  249.          for(y=110;y>0;y--);
  250. }

  252. //--------------------------写指令---------------------------
  253. void write_1602com(uchar com)//****液晶写入指令函数****
  254. {
  255.         lcd1602_rs=0;//数据/指令选择置为指令
  256.         lcd1602_rw=0; //读写选择置为写
  257.         P0=com;//送入数据
  258.         delay(1);
  259.         lcd1602_en=1;//拉高使能端，为制造有效的下降沿做准备
  260.         delay(1);
  261.         lcd1602_en=0;//en由高变低，产生下降沿，液晶执行命令
  262. }

  264. //-------------------------写数据-----------------------------
  265. void write_1602dat(uchar dat)//***液晶写入数据函数****
  266. {
  267.         lcd1602_rs=1;//数据/指令选择置为数据
  268.         lcd1602_rw=0; //读写选择置为写
  269.         P0=dat;//送入数据
  270.         delay(1);
  271.         lcd1602_en=1; //en置高电平，为制造下降沿做准备
  272.         delay(1);
  273.         lcd1602_en=0; //en由高变低，产生下降沿，液晶执行命令
  274. }

  276. //-------------------------初始化-------------------------
  277. void lcd_init(void)
  278. {
  279.         write_1602com(0x38);//设置液晶工作模式，意思：16*2行显示，5*7点阵，8位数据
  280.         write_1602com(0x0c);//开显示不显示光标
  281.         write_1602com(0x06);//整屏不移动，光标自动右移
  282.         write_1602com(0x01);//清显示
  283. }
  284. //========================================================================================
  285. //=========================================================================================




  290. //==============将按键值编码为数值=========================
  291. unsigned char coding(unsigned char m)         
  292. {
  293.         unsigned char k;
  294.         
  295.         switch(m)
  296.         {
  297.                 case (0x11): k=1;break;
  298.                 case (0x21): k=2;break;
  299.                 case (0x41): k=3;break;
  300.                 case (0x81): k='A';break;
  301.                 case (0x12): k=4;break;
  302.                 case (0x22): k=5;break;
  303.                 case (0x42): k=6;break;
  304.                 case (0x82): k='B';break;
  305.                 case (0x14): k=7;break;
  306.                 case (0x24): k=8;break;
  307.                 case (0x44): k=9;break;
  308.                 case (0x84): k='C';break;
  309.                 case (0x18): k='*';break;
  310.                 case (0x28): k=0;break;
  311.                 case (0x48): k='#';break;
  312.                 case (0x88): k='D';break;
  313.         }
  314.         return(k);
  315. }


  318. //=====================按键检测并返回按键值===============================
  319. unsigned char keynum(void)
  320. {
  321.          unsigned char row,col,i;

  323.          if(flag_REC==1)                                    //
  324.          {
  325.                  flag_REC=0;
  326.                 if(buff[0]=='O'&&buff[1]=='N')        //第一个字节为O，第二个字节为N，第三个字节为控制码
  327.                     switch(buff[2])
  328.                 {
  329.                         
  330.                       case '1' :                                                
  331.                            return(0x11);
  332.                           break;
  333.                       case '2':                                         
  334.                            return(0x21);
  335.                           break;                                   
  336.                       case '3':                                         
  337.                             return(0x41);
  338.                           break;
  339.                       case '4':                                 
  340.                             return(0x12);
  341.                           break;
  342.                           case '5':                                 
  343.                             return(0x22);
  344.                           break;
  345.                           case '6':                                 
  346.                             return(0x42);
  347.                           break;
  348.                           case '7':                                 
  349.                             return(0x14);
  350.                           break;
  351.                           case '8':                                 
  352.                             return(0x24);
  353.                           break;
  354.                           case '9':                                 
  355.                             return(0x44);
  356.                           break;
  357.                           case 'A':                                 
  358.                             return(0x84);
  359.                           break;
  360.                           case 'B':                                 
  361.                             return(0x18);
  362.                           break;
  363.                           case 'C':                                 
  364.                             return(0x48);
  365.                           break;
  366.                           case 'D':                                 
  367.                             return(0x88);
  368.                           break;
  369.                            case 'E':                                 
  370.                             return(0x28);
  371.                           break;
  372.         
  373.                   }                                         
  374.           }  
  375.                    P1=0xf0;
  376.          if((P1&0xf0)!=0xf0)
  377.          {
  378.                    Delay5Ms();
  379.         Delay5Ms();
  380.                    if((P1&0xf0)!=0xf0)
  381.                 {
  382.                     row=P1^0xf0;          //确定行线
  383.                         i=0;
  384.                         P1=a[i];                  //精确定位
  385.                         while(i<4)
  386.                         {
  387.                                  if((P1&0xf0)!=0xf0)
  388.                                   {
  389.                                            col=~(P1&0xff);          //确定列线
  390.                                            break;            //已定位后提前退出   
  391.                                   }
  392.                                 else
  393.                                   {
  394.                                            i++;
  395.                                            P1=a[i];
  396.                                   }
  397.                         }
  398.                 }
  399.                 else
  400.                 {
  401.                         return 0;
  402.                 }
  403.         
  404.                 while((P1&0xf0)!=0xf0);

  406.                 return (row|col);                         //行线与列线组合后返回
  407.          }
  408.          else return 0;                                 //无键按下时返回0

  410. }




  415. //=======================一声提示音，表示有效输入========================
  416. void OneAlam(void)
  417. {
  418.         ALAM=0;
  419.         Delay5Ms();
  420.     ALAM=1;
  421. }

  423. //========================二声提示音，表示操作成功========================
  424. void TwoAlam(void)
  425. {
  426.         ALAM=0;
  427.         Delay5Ms();
  428.     ALAM=1;
  429.     Delay5Ms();
  430.         ALAM=0;
  431.         Delay5Ms();
  432.     ALAM=1;
  433. }

  435. //========================三声提示音,表示错误========================
  436. void ThreeAlam(void)
  437. {
  438.         ALAM=0;
  439.         Delay5Ms();
  440.     ALAM=1;
  441.     Delay5Ms();
  442.         ALAM=0;
  443.         Delay5Ms();
  444.     ALAM=1;
  445.     Delay5Ms();
  446.         ALAM=0;
  447.         Delay5Ms();
  448.     ALAM=1;

  450. }

  452. //=====================显示输入的N个数字，用H代替以便隐藏============================


  455. //=======================显示提示输入=========================
  456. void DisplayChar(void)
  457. {
  458.         unsigned char i;
  459.         if(pass==1)
  460.         {
  461.                 //DisplayListChar(0,1,LockOpen);
  462.                 write_1602com(er);                                   //在二行开始显示
  463.                 for(i=0;i<16;i++)
  464.                 {
  465.                         write_1602dat(LockOpen[i]);           //显示open 开锁成功
  466.                 }
  467.         }
  468.         else
  469.         {
  470.                 if(N==0)
  471.                 {
  472.                         //DisplayListChar(0,1,Error);
  473.                         write_1602com(er);
  474.                         for(i=0;i<16;i++)
  475.                         {
  476.                                 write_1602dat(Error[i]);        //显示错误
  477.                         }
  478.                 }
  479.                 else
  480.                 {
  481.                         //DisplayListChar(0,1,start_line);        
  482.                         write_1602com(er);
  483.                         for(i=0;i<16;i++)
  484.                         {
  485.                                 write_1602dat(start_line[i]);//显示开始输入        
  486.                         }
  487.                 }
  488.         }
  489. }



  493. //========================重置密码==================================================
  494. //==================================================================================
  495. void ResetPassword(void)
  496. {
  497.         unsigned char i;        
  498.         unsigned char j;
  499.         write_1602com(yi);//日历显示固定符号从第一行第0个位置之后开始显示
  500.         for(i=0;i<16;i++)
  501.         {
  502.                 write_1602dat(name[i]);//向液晶屏写开机画面
  503.         }
  504.         if(pass==0)
  505.         {
  506.                 pass=0;                           
  507.                 DisplayChar();           //显示错误
  508.                 ThreeAlam();           //没开锁时按下重置密码报警3声
  509.         }
  510.         else                                   //开锁状态下才能进行密码重置程序
  511.         {
  512.             if(ReInputEn==1)   //开锁状态下，ReInputEn置1，重置密码允许
  513.                 {
  514.                         if(N==M)           //输入6位密码
  515.                         {
  516.                                 ReInputCont++;                        //密码次数计数        
  517.                                 if(ReInputCont==2)                //输入两次密码
  518.                                 {
  519.                                         for(i=0;i<M;)
  520.                                         {
  521.                                                 if(TempPassword[i]==InputData[i])        //将两次输入的新密码作对比
  522.                                                         i++;
  523.                                                 else                                                                //如果两次的密码不同
  524.                                                 {
  525.                                                         //DisplayListChar(0,1,Error);
  526.                                                         write_1602com(er);
  527.                                                         for(j=0;j<16;j++)
  528.                                                         {
  529.                                                                 write_1602dat(Error[j]);        //显示错误Error
  530.                                                         }
  531.                                                         ThreeAlam();                        //错误提示        
  532.                                                         pass=0;                                        //关锁
  533.                                                         ReInputEn=0;                        //关闭重置功能，
  534.                                                         ReInputCont=0;
  535.                                                         DisplayChar();
  536.                                                         break;
  537.                                                 }
  538.                                         }
  539.                                         if(i==M)
  540.                                         {
  541.                                                 //DisplayListChar(0,1,ResetOK);
  542.                                                 write_1602com(er);
  543.                                                 for(j=0;j<16;j++)
  544.                                                 {
  545.                                                         write_1602dat(ResetOK[j]);          //密码修改成功，显示
  546.                                                 }

  548.                                                 TwoAlam();                                //操作成功提示
  549.                                                 MM[0]=M;
  550.                                                  WrToROM(TempPassword,0,M);                //将新密码写入24C02存储
  551.                                                 WrToROM(MM,17,1);
  552.                                                 ReInputEn=0;
  553.                                         }
  554.                                         ReInputCont=0;
  555.                                         CorrectCont=0;
  556.                                 }
  557.                                 else                                          //输入一次密码时
  558.                                 {
  559.                                         OneAlam();
  560.                                         //DisplayListChar(0, 1, again);                 //显示再次输入一次
  561.                                         write_1602com(er);
  562.                                         for(j=0;j<16;j++)
  563.                                         {
  564.                                                 write_1602dat(again[j]);                        //显示再输入一次
  565.                                         }                                       
  566.                                         for(i=0;i<M;i++)
  567.                                         {
  568.                                                 TempPassword[i]=InputData[i];                //将第一次输入的数据暂存起来                                                
  569.                                         }
  570.                                 }

  572.                         N=0;                                                //输入数据位数计数器清零
  573.                    }
  574.             }
  575.         }

  577. }



  581. //=======================输入密码错误超过三过，报警并锁死键盘======================
  582. void Alam_KeyUnable(void)
  583. {
  584.         P1=0x00;
  585.         {
  586.                 ALAM=~ALAM;                                 //蜂鸣器一直闪烁鸣响
  587.                 Delay5Ms();
  588.         }
  589. }


  592. //=======================取消所有操作============================================
  593. void Cancel(void)
  594. {        
  595.         unsigned char i;
  596.         unsigned char j;
  597.         //DisplayListChar(0, 1, start_line);
  598.         write_1602com(yi);//日历显示固定符号从第一行第0个位置之后开始显示
  599.         for(i=0;i<16;i++)
  600.         {
  601.                 write_1602dat(name[i]);//向液晶屏写开机画面
  602.         }
  603.         write_1602com(er);
  604.         for(j=0;j<16;j++)
  605.         {
  606.                 write_1602dat(start_line[j]);          //显示开机输入密码界面
  607.         }
  608.         TwoAlam();                                //提示音
  609.         for(i=0;i<6;i++)
  610.         {
  611.                 InputData[i]=0;                //将输入密码清零
  612.         }
  613.         KEY=1;                                        //关闭锁
  614.         ALAM=1;                                        //报警关
  615.         operation=0;                        //操作标志位清零
  616.         pass=0;                                        //密码正确标志清零
  617.         ReInputEn=0;                        //重置输入充许标志清零
  618.         ErrorCont=0;                        //密码错误输入次数清零
  619.         CorrectCont=0;                        //密码正确输入次数清零
  620.         ReInputCont=0;                        //重置密码输入次数清零

  622.         s3_keydown=0;
  623.         key_disable=0;                        //锁定键盘标志清零
  624.         N=0;                                        //输入位数计数器清零
  625. }


  628. //==========================确认键，并通过相应标志位执行相应功能===============================
  629. void Ensure(void)
  630. {        
  631.         unsigned char i,j,k;
  632.         write_1602com(yi);//日历显示固定符号从第一行第0个位置之后开始显示
  633.         for(i=0;i<16;i++)
  634.         {
  635.                 write_1602dat(name[i]);//向液晶屏写开机画面
  636.         }
  637.         RdFromROM(MM,17,1);
  638.         M=MM[0];
  639.         if(M==0)
  640.         M=6;

  642.         RdFromROM(CurrentPassword,0,M);                                         //从24C02里读出存储密码
  643.         if(N==6)
  644.         {
  645.                     if((InputData[0]==1)&&(InputData[1]==3)&&(InputData[2]==1)&&(InputData[3]==4)&&(InputData[4]==2)&&(InputData[5]==0))
  646.                                    {
  647.                                      flag=1;
  648.                                     MM[0]=6;
  649.                                     WrToROM(MM,17,1);
  650.                                         WrToROM(initpassword,0,6);                                 //强制将初始密码写入24C02存储
  651.                                         //DisplayListChar(0,1,initword);                        //显示初始化密码
  652.                                         write_1602com(er);
  653.                                         for(j=0;j<16;j++)
  654.                                         {
  655.                                                 write_1602dat(initword[j]);                                //显示初始化密码
  656.                                         }
  657.                                         TwoAlam();                                                                        //成功提示音
  658.                                         Delay400Ms();                                                                //延时400ms
  659.                                         TwoAlam();                                                                        //成功提示音
  660.                                         N=0;                                                                                //输入位数计数器清零
  661.                                 }
  662.                          else
  663.                             flag=0;
  664.          
  665.         }

  667.                 if(N>M&&flag!=1)
  668.         {
  669.                   
  670.                 for(i=0;i<16;i++)
  671.                 {
  672.                    for(j=0;j<M;j++)
  673.                  {  if(InputData[i+j]==CurrentPassword[j])
  674.                     k=1;
  675.            
  676.                     else
  677.                
  678.                         k=0;
  679.                 if(k==0)
  680.                 break;        
  681.                         
  682.                 }
  683.                 if(k==1)
  684.                 break;
  685.                 }
  686.                 if(k==1)
  687.                 {         
  688.                         CorrectCont++;                                        //输入正确变量++
  689.                
  690.                                 if(CorrectCont==1)                                //正确输入计数，当只有一次正确输入时，开锁
  691.                                 {
  692.                                         //DisplayListChar(0,1,LockOpen);
  693.                                         write_1602com(er);
  694.                                         for(j=0;j<16;j++)
  695.                                         {
  696.                                                 write_1602dat(LockOpen[j]);                  //显示open开锁画面
  697.                                         }
  698.                                         TwoAlam();                        //操作成功提示音
  699.                                         KEY=0;                                                                                        //开锁
  700.                                         pass=1;                                                                                        //置正确标志位
  701.                                         TR0=1;                                                                                        //开启定时
  702.                                  
  703.                                         for(j=0;j<16;j++)                                                                //将输入清除
  704.                                         {
  705.                                                 InputData[j]=j;                                                                //开锁后将输入位清零
  706.                                         }
  707.                                 }        
  708.                                 else                                                                                                //当两次正确输入时，开启重置密码功能
  709.                                 {
  710.                                         //DisplayListChar(0,1,SetNew);
  711.                                         write_1602com(er);
  712.                                         for(j=0;j<16;j++)
  713.                                         {
  714.                                                 write_1602dat(SetNew[j]);                                        //显示重置密码界面
  715.                                         }
  716.                                         TwoAlam();                                                                            //操作成功提示
  717.                                         ReInputEn=1;                                                                        //允许重置密码输入
  718.                                         CorrectCont=0;                                                                        //正确计数器清零
  719.                                 }         
  720.                 }
  721.         
  722.             if(k==0)                                                                                
  723.                  {
  724.                                         ErrorCont++;                                                //错误次数++
  725.                                                 write_1602com(er);
  726.                                                 for(i=0;i<16;i++)
  727.                                                 {
  728.                                                         write_1602dat(Error[i]);        
  729.                                                 }
  730.                                         if(ErrorCont==3)                        //错误输入计数达三次时，报警并锁定键盘
  731.                                         {
  732.                                                 write_1602com(er);
  733.                                                 for(i=0;i<16;i++)
  734.                                                 {
  735.                                                         write_1602dat(Error[i]);        
  736.                                                 }
  737.                                                 do
  738.                                                 Alam_KeyUnable();
  739.                                                 while(1);
  740.                                         }
  741.                                         else                                         //错误次数小于3次时，锁死键盘3秒，然后重新可以输入
  742.                                         {
  743.                                                 TR0=1;                                //开启定时
  744.                                                 key_disable=1;                        //锁定键盘
  745.                                                 pass=0;                                        //pass位清零
  746.                                        
  747.                                         }
  748.               }
  749.                   k=0;N=0;
  750.         }        
  751.     if(N==M&&N!=0)
  752.         {
  753.             if(ReInputEn==0)                                                        //重置密码功能未开启
  754.                 {
  755.                         for(i=0;i<M;)
  756.                            {                                       
  757.                                 if(CurrentPassword[i]==InputData[i])        //判断输入密码和24c02中的密码是否相同
  758.                                 {
  759.                                         i++;                                                                //相同一位 i就+1
  760.                                 }
  761.                                 else                                                                         //如果有密码不同
  762.                                 {                                                                                
  763.                                         ErrorCont++;                                                //错误次数++
  764.                                         if(ErrorCont==3)                        //错误输入计数达三次时，报警并锁定键盘
  765.                                         {
  766.                                                 write_1602com(er);
  767.                                                 for(i=0;i<16;i++)
  768.                                                 {
  769.                                                         write_1602dat(Error[i]);        
  770.                                                 }
  771.                                                 do
  772.                                                 Alam_KeyUnable();
  773.                                                 while(1);
  774.                                         }
  775.                                         else                                         //错误次数小于3次时，锁死键盘3秒，然后重新可以输入
  776.                                         {
  777.                                                 write_1602com(er);
  778.                                                 for(i=0;i<16;i++)
  779.                                                 {
  780.                                                         write_1602dat(Error[i]);        
  781.                                                 }
  782.                                                 TR0=1;                                //开启定时
  783.                                                 key_disable=1;                        //锁定键盘
  784.                                                 pass=0;                                        //pass位清零
  785.                                                 break;                                        //跳出
  786.                                         }
  787.                                 }
  788.                         }

  790.                         if(i==M)                                         //密码输入对时
  791.                         {
  792.                                 CorrectCont++;                                        //输入正确变量++
  793.                                 if(CorrectCont==1)                                //正确输入计数，当只有一次正确输入时，开锁
  794.                                 {
  795.                                         //DisplayListChar(0,1,LockOpen);
  796.                                         write_1602com(er);
  797.                                         for(j=0;j<16;j++)
  798.                                         {
  799.                                                 write_1602dat(LockOpen[j]);                  //显示open开锁画面
  800.                                         }
  801.                                         TwoAlam();                        //操作成功提示音
  802.                                         KEY=0;                                                                                        //开锁
  803.                                         pass=1;                                                                                        //置正确标志位
  804.                                         TR0=1;                                                                                        //开启定时
  805.                  
  806.                                         for(j=0;j<M;j++)                                                                //将输入清除
  807.                                         {
  808.                                                 InputData[i]=0;                                                                //开锁后将输入位清零
  809.                                         }
  810.                                 }        
  811.                                 else                                                                                                //当两次正确输入时，开启重置密码功能
  812.                                 {
  813.                                         //DisplayListChar(0,1,SetNew);
  814.                                         write_1602com(er);
  815.                                         for(j=0;j<16;j++)
  816.                                         {
  817.                                                 write_1602dat(SetNew[j]);                                        //显示重置密码界面
  818.                                         }
  819.                                         TwoAlam();                                                                            //操作成功提示
  820.                                         ReInputEn=1;                                                                        //允许重置密码输入
  821.                                         CorrectCont=0;                                                                        //正确计数器清零
  822.                                 }
  823.                           }
  824.         
  825.                         else                        //=========================当第一次使用或忘记密码时可以用131420对其密码初始化============
  826.                         {
  827.                           
  828.                         }
  829.                 }

  831.                 else                                                                                        //当已经开启重置密码功能时，而按下开锁键，
  832.                 {
  833.                         //DisplayListChar(0,1,Er_try);
  834.                         write_1602com(er);
  835.                         for(j=0;j<16;j++)
  836.                         {
  837.                                 write_1602dat(Er_try[j]);                          //错误，请重新输入
  838.                         }
  839.                         ThreeAlam();                                                          //错误提示音
  840.                 }
  841.         }

  843.         if(N<M&&flag!=1&&N!=0)
  844.         {
  845.                 //DisplayListChar(0,1,Error);
  846.                 write_1602com(er);
  847.                 for(j=0;j<16;j++)
  848.                 {
  849.                         write_1602dat(Error[j]);                 //显示错误
  850.                 }

  852.                  ThreeAlam();                                                                                //错误提示音
  853.                 pass=0;        
  854.         }
  855.         
  856.         N=0;                                                                                                        //将输入数据计数器清零，为下一次输入作准备

  858.         operation=1;

  860. }


  863. //==============================主函数===============================
  864. void main(void)
  865. {
  866.          unsigned char KEY,NUM;
  867.         unsigned char i,j;
  868.          P1=0xFF;                                    //P1口复位
  869.         TMOD=0x21;                                   //定义工作方式
  870.          TL0=0xB0;
  871.          TH0=0x3C;                                   //定时器赋初值
  872.          EA=1;                                           //打开中断总开关
  873.          ET0=1;                                           //打开中断允许开关
  874.          TR0=0;                                           //打开定时器开关
  875.         TH1=0Xfd;
  876.         TL1=0Xfd;            //9600
  877.         TR1=1;                     // 定时器1启动  
  878.         SM0=0;            // 设置串口的工作模式
  879.         SM1=1;             //方式1
  880.         REN=1;                  // 允许串口接收数据         
  881.         ES=1;              // 串口中断应许
  882.          
  883.          Delay400Ms();         //启动等待，等LCM讲入工作状态
  884.          lcd_init();         //LCD初始化
  885.         write_1602com(yi);//日历显示固定符号从第一行第0个位置之后开始显示
  886.         for(i=0;i<16;i++)
  887.         {
  888.                 write_1602dat(name[i]);//向液晶屏写开机画面
  889.         }
  890.         write_1602com(er);
  891.         for(i=0;i<16;i++)
  892.         {
  893.                 write_1602dat(start_line[i]);//写输入密码等待界面
  894.         }
  895.         write_1602com(er+9);        //设置光标位置
  896.         write_1602com(0x0f);        //设置光标为闪烁
  897.          Delay5Ms(); //延时片刻(可不要)

  899.          N=0;                                                                                                                //初始化数据输入位数
  900.         RdFromROM(MM,17,1);
  901.         M=MM[0];
  902.                 if(M==0||M>16)
  903.         {
  904.          M=6;
  905.          MM[0]=6;
  906.          WrToROM(MM,17,1);
  907.         }
  908.          while(1)                 //进入循环
  909.          {
  910.                 if(key_disable==1)                                                //锁定键盘标志为1时
  911.                         Alam_KeyUnable();                                        //报警键盘锁
  912.                 else
  913.                         ALAM=1;                                                                //关报警

  915.                 KEY=keynum();                                                        //读按键的位置码
  916.                 if(KEY!=0)                                                                //当有按键按下时
  917.                 {        
  918.                         if(key_disable==1)                                        //锁定键盘标志为1时
  919.                         {
  920.                                 second=0;                                                //秒清零
  921.                         }
  922.                         else                                                                //没有锁定键盘时
  923.                         {
  924.                                 NUM=coding(KEY);                                //根据按键的位置将其编码，编码值赋值给NUM
  925.                                 {
  926.                                         switch(NUM)                                        //判断按键值
  927.                                         {
  928.                                                 case ('A'):         ;                                         break;
  929.                                                 case ('B'):                ;                                     break;
  930.                                                 case ('C'):
  931.                                                                 write_1602com(yi);//日历显示固定符号从第一行第0个位置之后开始显示
  932.                                                                 for(i=0;i<16;i++)
  933.                                                                 {
  934.                                                                         write_1602dat(name[i]);//向液晶屏写开机画面
  935.                                                                 }
  936.                                                        if(N>=1) N--;        OneAlam();                                                                //按键提示音                                                
  937.                                                                 //DisplayOneChar(6+N,1,'*');
  938.                                                            for(j=N;j<16;j++)
  939.                                                           {
  940.                                                           write_1602com(er+j);
  941.                                                                write_1602dat(' ');
  942.                                                           }
  943.                                                            for(j=0;j<N;j++)
  944.                                                           {
  945.                                                                         write_1602com(er+j);                                //显示位数随输入增加而增加
  946.                                                                         write_1602dat('*');                                        //但不显示实际数字，用*代替
  947.                                                                 }  
  948.                                                                         InputData[N]=N+4;
  949.                                                                                         break;                //ABC是无定义按键
  950.                                                 case ('D'): ResetPassword();                break;      //重新设置密码
  951.                                                 case ('*'): Cancel();                                break;      //取消当前输入
  952.                                                 case ('#'): Ensure();                                 break;           //确认键，
  953.                                                 default:                                                                                 //如果不是功能键按下时，就是数字键按下
  954.                                                 {        
  955.                                                         //DisplayListChar(0,1,Input);
  956.                                                         write_1602com(yi);
  957.                                                         for(i=0;i<16;i++)
  958.                                                         {
  959.                                                                 write_1602dat(Input[i]);                                //显示输入画面
  960.                                                         }
  961.                                                     operation=0;                                                                //操作标志清零
  962.                                                         if(N<16)                                                           //当输入的密码少于6位时，接受输入并保存，大于6位时则无效。
  963.                                                         {  
  964.                                                                 OneAlam();                                                                //按键提示音                                                
  965.                                                                 //DisplayOneChar(6+N,1,'*');
  966.                                                                  for(j=0;j<16;j++)
  967.                                                                 {
  968.                                                                     if(j>N)
  969.                                                                         {
  970.                                                                           write_1602com(er+j);
  971.                                                                           write_1602dat(' ');
  972.                                                                         }
  973.                                                                     if(j<=N)
  974.                                                                         {
  975.                                                                         write_1602com(er+j);                                //显示位数随输入增加而增加
  976.                                                                         write_1602dat('*');                                        //但不显示实际数字，用*代替         
  977.                                                                         }
  978.                                                                 }
  979.                                                                 InputData[N]=NUM;                                                //将数字键的码赋值给InputData[]数组暂存
  980.                                                                 N++;                                                                        //密码位数加
  981.                                                         }
  982.                                                         else                                                                                //输入数据位数大于6后，忽略输入
  983.                                                         {
  984.                                                                 N=16;                                                                        //密码输入大于6位时，不接受输入
  985.                                                                  break;
  986.                                                         }
  987.                                                         write_1602com(er+N);
  988.                                                         if(ReInputEn==1&&ReInputCont==0)
  989.                                                         M=N;
  990.                                                 }
  991.                                         }
  992.                                 }
  993.                         }
  994.                  }
  995.         }
  996. }

  998. //*********************************中断服务函数**************************************
  999. void  time0_int(void) interrupt 1                    //定时器T0
  1000. {
  1001.          TL0=0xB0;
  1002.          TH0=0x3C;                  //定时器重新赋初值
  1003.          //TR0=1;
  1004.          countt0++;                           //计时变量加，加1次时50ms
  1005.           if(countt0==20)                   //加到20次就是1s
  1006.            {
  1007.                 countt0=0;                   //变量清零
  1008.                 second++;                   //秒加
  1009.                 if(pass==1)                   //开锁状态时
  1010.                 {
  1011.                         if(second==1)                        //秒加到1s时
  1012.                         {
  1013.                         
  1014.                                 TR0=0;                                //关定时器
  1015.                                 TL0=0xB0;
  1016.                                  TH0=0x3C;                        //再次赋初值
  1017.                                 second=0;                        //秒清零
  1018.                         }
  1019.                 }
  1020.                 else                                                //不在开锁状态时
  1021.                 {
  1022.                         if(second==3)                        //秒加到3时
  1023.                         {
  1024.                                 TR0=0;                                //关闭定时器
  1025.                                 second=0;                        //秒清零
  1026.                                 key_disable=0;                //锁定键盘清零
  1027.                                 s3_keydown=0;        
  1028.                                 TL0=0xB0;
  1029.                                 TH0=0x3C;                        //重新赋初值
  1030.                         }
  1031.                         else
  1032.                             TR0=1;                                //打开定时器
  1033.                 }
  1034.                         
  1035.            }
  1036. }

  1038. //  通讯中断接收程序   中断函数无返回值
  1039.   void uart_rx(void)  interrupt 4        using 3          //放在这里 和放在main（）里面是一样的
  1040. {

  1042.            unsigned char i;
  1043.         unsigned char flag;
  1044.         unsigned char dat;
  1045.     if(RI)                         //是否接收中断
  1046.     {
  1047.        RI=0;
  1048.        dat=SBUF;
  1049.        if(dat=='O'&&(i==0)) //接收数据第一帧
  1050.        {
  1051.             buff[i]=dat;
  1052.             flag=1;        //开始接收数据
  1053.        }
  1054.        else
  1055.               if(flag==1)
  1056.               {
  1057.                       i++;
  1058.                       buff[i]=dat;
  1059.                       if(i>=2)
  1060.                   {
  1061.                            i=0;
  1062.                            flag=0;
  1063.                            flag_REC=1 ;
  1064.                       }  // 停止接收
  1065.               }
  1066.          }

  1068. }

复制代码
密码锁, 蓝牙

T6ZL42_$AAQE5W03LT7I_MV.png (94.99 KB, 下载次数: 112)

T6ZL42_$AAQE5W03LT7I_MV.png
分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏3 分享淘帖 顶顶 踩踩

相关帖子
回复

使用道具 举报

沙发
ID:189829 发表于 2017-4-15 15:04 | 只看该作者
程序非常清楚
回复

使用道具 举报

板凳
ID:192867 发表于 2017-4-23 21:49 | 只看该作者
但是好像，程序有错，我用Kil3通不过编译
回复

使用道具 举报

地板
ID:189829 发表于 2017-5-18 13:52 | 只看该作者
15283187608 发表于 2017-4-23 21:49
但是好像，程序有错，我用Kil3通不过编译

用keil4试试
回复

使用道具 举报

5#
ID:192867 发表于 2017-5-23 18:42 | 只看该作者
楼主，这个程序和原理图是不是配套的？
回复

使用道具 举报

6#
ID:186936 发表于 2017-6-9 22:42 | 只看该作者
有没有app
回复

使用道具 举报

7#
ID:186936 发表于 2017-6-9 22:42 | 只看该作者
app给一下可以吗：QQ1306501801
回复

使用道具 举报

8#
ID:195403 发表于 2017-6-13 16:39 | 只看该作者
蓝牙连接上去以后无法使用蓝牙的功能
回复

使用道具 举报

9#
ID:195403 发表于 2017-6-13 16:45 | 只看该作者
蓝牙部分如何操作？
回复

使用道具 举报

10#
ID:210319 发表于 2017-6-15 07:13 | 只看该作者
楼主APP用超级串口么
回复

使用道具 举报

11#
ID:210319 发表于 2017-6-15 08:08 | 只看该作者
楼主 蓝牙部分怎么操作啊
回复

使用道具 举报

12#
ID:192867 发表于 2017-6-15 16:43 | 只看该作者
楼主按键，部分不怎么能对上号
回复

使用道具 举报

13#
ID:418215 发表于 2018-12-10 20:42 | 只看该作者
怎么用蓝牙串口输入密码
回复

使用道具 举报

14#
ID:660034 发表于 2019-12-9 21:20 | 只看该作者
蓝牙模块没有程序吧，连接蓝牙用不了，大佬可以发一下吗？
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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