找回密码
 立即注册

QQ登录

只需一步,快速开始

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

单片机密码锁Proteus仿真图+代码下载

[复制链接]
ID:458954 发表于 2019-1-5 21:13 | 显示全部楼层 |阅读模式
单片机密码锁仿真原理图如下(proteus仿真工程文件可到本帖附件中下载)
截图02.jpg
截图03.jpg

单片机源程序如下:
  1. #include<AT89x51.h>
  2. #include"intrins.h"
  3. #include"key.h"
  4. #include"xsh.h"
  5. #include"24c02.h"
  6. #define ulong unsigned long
  7. bit  BJCB=0;//报警标志                                          
  8.      XG=0,//修改密码标志位
  9.      BJ=0,//报警标志位
  10.      SJ=0;//锁键盘标志位
  11.     // xg=0;//修改密码标志位
  12. uchar PSWD0_0[16]={0};//密码输入缓存存储单元
  13. //uchar code PSWD0_1[16]={1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8};//用户初始密码存储单元
  14. //uchar PSWD1_0[16]={0};//读出密码缓存存储单元
  15. uchar PSWD1_1[16]={1,2,3,4,5,6,7,8,1,2,3,4,5,6,7,8};////管理员初始密码存储单元
  16. sbit OUT=P3^5;//输出端口
  17. sbit L1=P0^2;//上电指示
  18. sbit L2=P0^1;//开锁指示
  19. sbit L3=P0^0;//报警指示
  20. uint   mg=0,//密码个数
  21.        KSC=0,//开锁次数
  22.        BJC=0,//报警次数
  23.            TCNTY=0,//用户按键定时次数累加
  24.            TCNTG=0,//管理员输入密码定时次数
  25.            yhsh,//用户输入标志位
  26.            glsh,//管理员输标志位
  27.            shw;//密码输完标志位
  28. void yhmimaxig();//密码修改程序
  29. void glmimaxig();//管理员修改程序
  30. void bjyin(ulong t)
  31. {
  32. ulong c;
  33. uint n;
  34. for(c=0;c<t;c++)
  35. {
  36. for(n=0;n<50;n++); //延时
  37. BEEP=~BEEP; //取反输出到喇叭的信号
  38. }
  39. }
  40. void delay_10ms(void)
  41. {
  42.         uint i = 1000;
  43.         while(i--);
  44. }
  45. //////////////定时中断服务函数//////////////////////////////////////
  46. void timer0() interrupt 1
  47. {
  48. uint i;
  49. TH0=(65536-50000)/256; //对TH0 TL0赋值50MS定时
  50. TL0=(65536-50000)%256; //重装计数初值
  51. if(yhsh==1)
  52. {
  53.   TCNTY++;//用户定时计数
  54.   if(shw==1)
  55. {
  56.   TR0=0;
  57.   TCNTY=0;
  58.   }
  59.   if(TCNTY==400)
  60.   {
  61.    TR0=0;//关闭T0定时器
  62.    TCNTY=0;
  63.     mg=0;//密码个数清零
  64.         L1=1;
  65.         for(i=0;i<2;i++)//声光报警电路
  66.          {
  67.                   L3=0;
  68.                   bjyin(1000);
  69.                   L3=1;
  70.                   delay(1000);
  71.           }
  72.           L1=0;
  73.      }
  74.     }
  75.         else if(glsh==1)
  76.             {
  77.                  TCNTG++;//管理员定时计数
  78.          if(shw==1)
  79.         {
  80.            TR0=0;
  81.            TCNTG=0;
  82.          }
  83.        if(TCNTG==400)
  84.        {
  85.         TR0=0;//关闭T0定时器
  86.         TCNTG=0;
  87.         mg=0;//密码个数清零
  88.                 L1=1;
  89.              for(i=0;i<2;i++)//声光报警电路
  90.             {
  91.                   L3=0;
  92.                   bjyin(1000);
  93.                   L3=1;
  94.                   delay(1000);
  95.                  }
  96.                  L1=0;
  97.                 }
  98.                 }          
  99.                 }                      
  100.             
  101. void main()
  102. {  
  103.    uint i;
  104.    TMOD=0x01;  //定时器工作在方式1
  105.    ET0=1;
  106.    EA=1;
  107.    TH0=(65536-50000)/256; //对TH0 TL0赋值
  108.    TL0=(65536-50000)%256; //使定时器0.05秒中断一次
  109.   //Read_page24c02(0x00,PSWD1_1,16);//向24c02里读用户初始密码
  110.    //i2cWrite24LC16B(0,0X20);
  111. /////////////第一次向24c02里写入初始管理员密码、用户密码、开锁次数/////////////////////
  112.    for(i=0;i<16;i++)        //用一次写一个向24c02里写
  113.   {
  114.    i2cWrite24LC16B(PSWD1_1[i],i);
  115.    delay_10ms;  
  116.   }
  117.    for(i=0;i<16;i++)        //用一次写一个向24c02里写
  118.   {
  119.    i2cWrite24LC16B(PSWD1_1[i],0x10+i);
  120.    delay_10ms;  
  121.   }  //proteus仿真时用,烧程序时,第一次用,第二次不用。
  122.   KSC=i2cRead24LC16B(0X20);
  123. loop:  L1=0;//上电红灯亮
  124.                 L2=1;//开锁成功后绿灯亮
  125.                 L3=1;//输错时黄灯亮报警
  126.                 OUT=0;//开信号关闭
  127.        display_0(KSC);//开锁前显示
  128.             
  129. ///////////密码输入/////////////////
  130. if(SJ==0)//锁键盘标志位为0
  131. {
  132.   do
  133.    {
  134.     flag=0;//键盘标志位
  135.     key();
  136.         if(flag==1&&num==12) //判断是否为管理员功能键按下
  137.         {
  138.          goto gl;
  139.            }
  140.            if(flag==1&&num<=9)
  141.          {
  142.           PSWD0_0[mg]=num;
  143.           mg++;//密码个数
  144.          }
  145.          if(flag==1&&num==14&&mg>=1)//输入错误删除
  146.          {
  147.            mg=mg-1;
  148.            }
  149.          if(mg==1) //有密码键按下开定时器限时
  150.          {
  151.           TR0=1;
  152.           yhsh=1;
  153.           }
  154.    }       
  155.    while(num!=15);
  156.    if(mg!=16)
  157.    {
  158.     for(i=mg;i<16;i++)
  159.         {
  160.          PSWD0_0[i]=0;
  161.         }
  162.    }   
  163. /////////////////密码比较电路////////////////////////////
  164. if(flag==1&&num==15)  
  165. { flag=0;
  166.    yhsh=0;
  167.    shw=1;
  168.    num=0;
  169.   for(i=0;i<16;i++)        //从24c02里读出16个密码
  170.   {
  171.     PSWD1_1[i]=i2cRead24LC16B(i);
  172.     delay_10ms;  
  173.   }
  174.   for(i=0;i<16;i++)
  175. {
  176.    if(PSWD1_1[i]!=PSWD0_0[i])
  177.    {
  178.      BJCB=1;
  179.      break;
  180.         }
  181.    else
  182.    BJCB=0;       
  183.    
  184.   }
  185. }
  186.    if(BJCB!=0)
  187.        {
  188.              BJC++;
  189.                  if(BJC!=3)          
  190.             {
  191.                  BJCB=0; //第一次和第二次报警
  192.              delay(500);
  193.                  mg=0;//密码个数清零
  194.                  L1=1;
  195.                  for(i=0;i<3;i++)//声光报警电路
  196.                  {
  197.                   L3=0;
  198.                   display_3();
  199.                   bjyin(1000);
  200.                   L3=1;
  201.                   delay(1000);
  202.                   }
  203.                  goto loop;         
  204.                 }
  205.           else if(BJC==3)
  206.             {
  207.                  BJC=0;
  208.              BJCB=0;
  209.              display_5();//三次输入密码失败,自锁
  210.              SJ=1;//锁键盘标志位
  211.              mg=0;//密码个数清零
  212.                  L1=1;
  213.                  for(i=0;i<2;i++)//声光报警电路
  214.                  {
  215.                   L3=0;
  216.                   bjyin(1000);
  217.                   L3=1;
  218.                   delay(1000);
  219.                   }
  220.              goto loop;
  221.                 }
  222.                 }               
  223.            else
  224.            if(BJCB==0)
  225.           {
  226.            KSC++;
  227.            display_1(KSC);
  228.            i2cWrite24LC16B(KSC,0X20);
  229.            if(KSC==100)
  230.            {
  231.             SJ=1;
  232.                  }
  233.            L2=0;
  234.            L1=1;
  235.            OUT=1;
  236.            mg=0;//密码个数清零
  237. loop1:do           //键盘扫描等待功能键按下
  238.            {
  239.             flag=0;
  240.             key();
  241.                 if(flag)
  242.            {       
  243.              flag=0;
  244.             switch(num)
  245.            {   
  246.             case 13:          
  247.                 {
  248.                           display_2();
  249.              do
  250.             {
  251.              flag=0;//键盘标志位
  252.              key();
  253.                 if(flag==1&&num<=9)
  254.                {
  255.                  PSWD0_0[mg]=num;
  256.                  mg++;//密码个数
  257.                 }
  258.                if(flag==1&&num==14&&mg>=1)//输入错误删除
  259.               {
  260.                mg=mg-1;
  261.               }
  262.               if(mg==16)
  263.              {
  264.                do           //键盘扫描等待功能键按下
  265.              {
  266.                flag=0;
  267.                key();
  268.              }
  269.             while(num!=15);
  270.            }
  271.        }       
  272.        while(num!=15);
  273.       if(mg!=16&&num==15)
  274.      {
  275.       for(i=mg;i<16;i++)
  276.          {
  277.            PSWD0_0[i]=0;
  278.           }
  279.          }
  280.         if(flag==1&&num==15)
  281.    {
  282.      flag=0;       
  283.          mg=0;
  284.    for(i=0;i<16;i++)        //用一次写一个向24c02里写
  285.   {
  286.    i2cWrite24LC16B(PSWD0_0[i],i);
  287.    delay_10ms;  
  288.   }
  289.   display_1(KSC);
  290.    do           //键盘扫描等待功能键按下
  291.    {
  292.          flag=0;
  293.          key();
  294.         }
  295.         while(num!=11); //按下返回键,锁锁返回
  296.         {
  297.       goto loop;
  298.         }
  299.     }
  300.         };break;
  301.                
  302.    case 11: {
  303.                        goto loop;
  304.                                   //break;           
  305.                     }
  306.                     }
  307.                         }
  308.                         }
  309.           while(flag!=0);//如果设置密码键按下
  310.           goto loop1;
  311. // i2cWrite24c02_page(0x00,PSWD1_1,mg);
  312.    }
  313.    }
  314. else
  315.     {
  316.          do
  317.     {
  318.     flag=0;
  319.     key();
  320.         }
  321.         while(num!=12);//判断是否为管理员功能键按下          
  322.   gl:do//管理员输入密码
  323.      {
  324.      flag=0;
  325.      key();
  326.             if(flag==1&&num<=9)
  327.          {
  328.           PSWD0_0[mg]=num;
  329.           mg++;//密码个数
  330.          }
  331.          if(flag==1&&num==14&&mg>=1)//删除键按下
  332.          {
  333.            mg=mg-1;
  334.          }
  335.          if(mg==1)
  336.           {
  337.            TR0=1;
  338.           }//开定时器TO限5秒开锁
  339.       }       
  340.    while(num!=15);
  341.    if(mg!=16&&num==15)
  342.    {
  343.     for(i=mg;i<16;i++)
  344.         {
  345.          PSWD0_0[i]=0;
  346.         }
  347.    }
  348.   //////////管理员密码比较///////////////////////
  349. //Read_page24c02(0x10,PSWD0_1,16)
  350. for(i=0;i<16;i++)        //从24c02里读出16个密码
  351. {
  352.     PSWD1_1[i]=i2cRead24LC16B((0x10+i));
  353.     delay_10ms;  
  354. }       
  355. if(flag==1&&num==15)  
  356. {  flag=0;
  357.    shw=1;
  358.    num=0;
  359.   for(i=0;i<mg;i++)
  360. {
  361.    if(PSWD1_1[i]!=PSWD0_0[i])
  362.    { BJCB=1;
  363.      break;
  364.         }
  365.    else       
  366.    BJCB=0;
  367.    }
  368.    }
  369.    if(BJCB!=0)
  370.        {
  371.              BJC++;
  372.                  if(BJC!=3)          
  373.             {
  374.                  BJCB=0; //第一次和第二次报警
  375.              
  376.                  mg=0;//密码个数清零
  377.                  L1=1;
  378.                  for(i=0;i<2;i++)//声光报警电路
  379.                  {
  380.                   L3=0;
  381.                   display_3();
  382.                   bjyin(1000);
  383.                   L3=1;
  384.                   delay(1000);
  385.                   }
  386.                  display_1(KSC);
  387.                  goto loop;         
  388.                 }
  389.           else
  390.             {
  391.                  BJCB=0;
  392.              display_5();//三次输入密码失败,自锁
  393.              mg=0;//密码个数清零
  394.                  delay(10000);
  395.                  display_1(KSC);
  396.              goto loop;
  397.                 }            
  398.            }   
  399.            else
  400.           {
  401.            SJ=0;
  402.            display_4();//管理员开锁显示
  403.        mg=0;
  404.            L2=0;
  405.            L1=1;
  406.            L3=0;//密码个数清零
  407.            do           //键盘扫描等待功能键按下
  408.            {
  409.             flag=0;
  410.             key();
  411.            }
  412.            while(flag==0); //如果设置密码键按下
  413.            if(flag==1&&num==13)
  414.            {
  415.              flag=0;
  416.              display_2();
  417.              do
  418.             {
  419.              flag=0;//键盘标志位
  420.              key();
  421.                 if(flag==1&&num<=9)
  422.                {
  423.                  PSWD0_0[mg]=num;
  424.                  mg++;//密码个数
  425.                 }
  426.                if(flag==1&&num==14&&mg>=1)//输入错误删除
  427.              {
  428.                mg=mg-1;
  429.               }
  430.               if(mg==16)
  431.              {
  432.                do           //键盘扫描等待功能键按下
  433.              {
  434.                flag=0;
  435.                key();
  436.              }
  437.             while(num!=15);
  438.            }
  439.        }       
  440.        while(num!=15);
  441.       if(mg!=16&&num==15)
  442.      {
  443.       for(i=mg;i<16;i++)
  444.          {
  445.            PSWD0_0[i]=0;
  446.           }
  447.          }
  448.         if(flag==1&&num==15)
  449.    {
  450.      flag=0;       
  451.          mg=0;
  452.    for(i=0;i<16;i++)        //用一次写一个向24c02里写
  453.   {
  454.    i2cWrite24LC16B(PSWD0_0[i],(0x10+i));
  455.    delay_10ms;  
  456.   }
  457.   display_4();
  458.    do           //键盘扫描等待功能键按下
  459.    {
  460.          flag=0;
  461.          key();
  462.         }
  463.         while(num!=11); //按下返回键,锁锁返回
  464.         {
  465.       goto loop;
  466.         }
  467.     }
  468.            }
  469.            if(flag==1&&num==10)
  470.            {
  471.             KSC=0;
  472.                 i2cWrite24LC16B(KSC,0X20);
  473.                 display_1(KSC);
  474.             do           //键盘扫描等待功能键按下
  475.            {
  476.             flag=0;
  477.             key();
  478.            }
  479.            while(num!=11);//按下返回键,锁锁返回
  480.             goto loop;
  481.        }
  482.            if(flag==1&&num==11)//按下返回键,锁锁返回
  483.            {
  484.             goto loop;
  485.                 }
  486.        }
  487.            }
  488.            }
复制代码

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

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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