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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 电子技术分类讨论区 › 资料共享 › 单片机密码锁（掉电可记忆）源程序
返回列表 发新帖
查看: 2083|回复: 0
打印 上一主题 下一主题
收起左侧

单片机密码锁（掉电可记忆）源程序

[复制链接]
跳转到指定楼层
楼主
ID:263893 发表于 2017-12-19 20:27 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
单片机源程序如下:
  1.                                                         

  3. 程序功能： 本程序结合了24C02存储器的存储功能，可以掉电保存密码。
  4.                         第一次运行时，若输入000000原始密码后无反应，可以试验着将主程序中前面的
  5.                         一小段被注释线屏蔽的程序前的注释线删掉，然后重新编译下载（可以将密码还原为000000）。
  6.                         此后，再将这小段程序屏蔽掉，再编译下载。方可正常使用。
  7.                    1、开锁：
  8.                   下载程序后，直接按六次S1（即代表数字1），8位LED亮，锁被打开，输入密码时，
  9.                   六位数码管依次显示小横杠。
  10.                   2、更改密码：
  11.                   只有当开锁（LED亮）后，该功能方可使用。
  12.                   首先按下更改密码键S11，然后设置相应密码，此时六位数码管会显示设置密码对应
  13.                   的数字。最后设置完六位后，按下S12确认密码更改，此后新密码即生效。
  14.                   3、重试密码：
  15.                   当输入密码时，密码输错后按下键S13，可重新输入六位密码。
  16.                   当设置密码时，设置中途想更改密码，也可按下此键重新设置。
  17.                   4、关闭密码锁：
  18.                   按下S14即可将打开的密码锁关闭。
  19. 推荐初级演示步骤：输入原始密码000000---按下更改密码按键S11---按0到9设置密码---按S12
  20.                         确认密码更改---按S14关闭密码锁---输入新的密码打开密码锁
  21. *******************************************************************************/
  22. #include<reg52.h>
  23. #include <intrins.h>
  24. #define uint unsigned int
  25. #define uchar unsigned char

  27. uchar old1,old2,old3,old4,old5,old6; //原始密码000000
  28. uchar new1,new2,new3,new4,new5,new6;  //每次MCU采集到的密码输入
  29. uchar a=16,b=16,c=16,d=16,e=16,f=16; //送入数码管显示的变量
  30. uchar wei,key,temp;

  32. bit allow,genggai,ok,wanbi,retry,close;         //各个状态位

  34. sbit dula=P2^6;
  35. sbit wela=P2^7;
  36. sbit beep=P2^3;
  37. sbit sda=P2^0;                          //IO口定义
  38. sbit scl=P2^1;

  40. unsigned char code table[]=
  41. {0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,
  42. 0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71,0x00,0x40};

  44. /*****************IIC芯片24C02存储器驱动程序************************************/

  46. void nop()
  47. {
  48.         _nop_();
  49.         _nop_();
  50. }
  51. /////////24C02读写驱动程序////////////////////
  52. void delay1(unsigned int m)
  53. {        unsigned int n;
  54.           for(n=0;n<m;n++);
  55. }

  57. void init()  //24c02初始化子程序
  58. {
  59.         scl=1;
  60.         nop();
  61.         sda=1;
  62.         nop();
  63. }

  65. void start()        //启动I2C总线
  66. {
  67.         sda=1;
  68.         nop();
  69.         scl=1;
  70.         nop();
  71.         sda=0;
  72.         nop();
  73.         scl=0;
  74.         nop();
  75. }

  77. void stop()         //停止I2C总线
  78. {
  79.         sda=0;
  80.         nop();
  81.         scl=1;
  82.         nop();
  83.         sda=1;
  84.         nop();
  85. }

  87. void writebyte(unsigned char j)  //写一个字节
  88. {
  89.         unsigned char i,temp;
  90.            temp=j;
  91.            for (i=0;i<8;i++)
  92.    {
  93.            temp=temp<<1;
  94.            scl=0;
  95.            nop();
  96.            sda=CY;                //temp左移时，移出的值放入了CY中
  97.            nop();
  98.            scl=1;                //待sda线上的数据稳定后，将scl拉高
  99.            nop();
  100.    }
  101.    scl=0;
  102.    nop();
  103.    sda=1;
  104.    nop();
  105. }

  107. unsigned char readbyte()   //读一个字节
  108. {
  109.    unsigned char i,j,k=0;
  110.    scl=0; nop(); sda=1;
  111.    for (i=0;i<8;i++)
  112.    {  
  113.                 nop(); scl=1; nop();
  114.               if(sda==1)
  115.                 j=1;
  116.               else
  117.                 j=0;
  118.               k=(k<<1)|j;
  119.                   scl=0;
  120.         }
  121.            nop();
  122.         return(k);
  123. }

  125. void clock()         //I2C总线时钟
  126. {
  127.    unsigned char i=0;
  128.    scl=1;
  129.    nop();
  130.    while((sda==1)&&(i<255))
  131.              i++;
  132.    scl=0;
  133.    nop();
  134. }

  136. ////////从24c02的地址address中读取一个字节数据/////
  137. unsigned char read24c02(unsigned char address)
  138. {
  139.    unsigned char i;
  140.    start();
  141.    writebyte(0xa0);
  142.    clock();
  143.    writebyte(address);
  144.    clock();
  145.    start();
  146.    writebyte(0xa1);
  147.    clock();
  148.    i=readbyte();
  149.    stop();
  150.    delay1(100);
  151.    return(i);
  152. }

  154. //////向24c02的address地址中写入一字节数据info/////
  155. void write24c02(unsigned char address,unsigned char info)
  156. {
  157.    start();
  158.    writebyte(0xa0);
  159.    clock();
  160.    writebyte(address);
  161.    clock();
  162.    writebyte(info);
  163.    clock();
  164.    stop();
  165.    delay1(5000); //这个延时一定要足够长，否则会出错。因为24c02在从sda上取得数据后，还需要一定时间的烧录过程。
  166. }
  167. /****************************密码锁程序模块********************************************************/

  169. void delay(unsigned char i)
  170. {
  171.         uchar j,k;
  172.   for(j=i;j>0;j--)
  173.     for(k=125;k>0;k--);
  174. }

  176. void display(uchar a,uchar b,uchar c,uchar d,uchar e,uchar f)
  177. {
  178.    dula=0;
  179.    P0=table[a];
  180.    dula=1;
  181.    dula=0;

  183.    wela=0;
  184.    P0=0xfe;
  185.    wela=1;
  186.    wela=0;
  187.    delay(5);

  189.    P0=table[b];
  190.    dula=1;
  191.    dula=0;

  193.    P0=0xfd;
  194.    wela=1;
  195.    wela=0;
  196.    delay(5);

  198.    P0=table[c];
  199.    dula=1;
  200.    dula=0;

  202.    P0=0xfb;
  203.    wela=1;
  204.    wela=0;
  205.    delay(5);

  207.    P0=table[d];
  208.    dula=1;
  209.    dula=0;

  211.    P0=0xf7;
  212.    wela=1;
  213.    wela=0;
  214.    delay(5);

  216.    P0=table[e];
  217.    dula=1;
  218.    dula=0;

  220.    P0=0xef;
  221.    wela=1;
  222.    wela=0;
  223.    delay(5);

  225.    P0=table[f];
  226.    dula=1;
  227.    dula=0;

  229.    P0=0xdf;
  230.    wela=1;
  231.    wela=0;
  232.    delay(5);
  233. }


  236. void keyscan()
  237. {
  238.   {        
  239.     P3=0xfe;
  240.     temp=P3;
  241.     temp=temp&0xf0;
  242.     if(temp!=0xf0)
  243.     {
  244.       delay(10);
  245.       if(temp!=0xf0)
  246.       {        
  247.         temp=P3;
  248.         switch(temp)
  249.         {
  250.           case 0xee:
  251.                key=0;
  252.                            wei++;
  253.                break;

  255.           case 0xde:
  256.                key=1;
  257.                            wei++;
  258.                break;

  260.           case 0xbe:
  261.                key=2;
  262.                            wei++;
  263.                break;

  265.           case 0x7e:
  266.                key=3;
  267.                            wei++;
  268.                break;
  269.          }
  270.          while(temp!=0xf0)
  271.         {
  272.            temp=P3;
  273.            temp=temp&0xf0;
  274.            beep=0;
  275.          }
  276.          beep=1;
  277.       }
  278.     }
  279.     P3=0xfd;
  280.     temp=P3;
  281.     temp=temp&0xf0;
  282.     if(temp!=0xf0)
  283.     {
  284.       delay(10);
  285.       if(temp!=0xf0)
  286.       {
  287.         temp=P3;
  288.         switch(temp)
  289.         {
  290.           case 0xed:
  291.                key=4;
  292.                            wei++;
  293.                break;

  295.           case 0xdd:
  296.                key=5;
  297.                            wei++;
  298.                break;

  300.           case 0xbd:
  301.                key=6;
  302.                            wei++;
  303.                break;

  305.           case 0x7d:
  306.                key=7;
  307.                            wei++;
  308.                break;
  309.          }
  310.          while(temp!=0xf0)
  311.          {
  312.            temp=P3;
  313.            temp=temp&0xf0;
  314.            beep=0;
  315.          }
  316.          beep=1;
  317.       }
  318.       }
  319.     P3=0xfb;
  320.     temp=P3;
  321.     temp=temp&0xf0;
  322.     if(temp!=0xf0)
  323.     {
  324.       delay(10);
  325.       if(temp!=0xf0)
  326.       {
  327.         temp=P3;
  328.         switch(temp)
  329.         {
  330.           case 0xeb:
  331.                key=8;
  332.                            wei++;
  333.                break;

  335.           case 0xdb:
  336.                key=9;
  337.                            wei++;
  338.                break;
  339.                            
  340.           case 0xbb:
  341.                genggai=1;
  342.                            wei=0;
  343.                break;

  345.           case 0x7b:
  346.                              if(allow)
  347.                ok=1;
  348.                break;
  349.          }
  350.         while(temp!=0xf0)
  351.          {
  352.            temp=P3;
  353.            temp=temp&0xf0;
  354.            beep=0;
  355.          }
  356.          beep=1;
  357.       }
  358.       }
  359.           P3=0xf7;
  360.     temp=P3;
  361.     temp=temp&0xf0;
  362.     if(temp!=0xf0)
  363.     {
  364.       delay(10);
  365.       if(temp!=0xf0)
  366.       {
  367.         temp=P3;
  368.         switch(temp)
  369.         {
  370.           case 0xe7:
  371.                              retry=1;
  372.                break;

  374.           case 0xd7:
  375.                              close=1;
  376.                break;
  377.          }
  378.         while(temp!=0xf0)
  379.          {
  380.            temp=P3;
  381.            temp=temp&0xf0;
  382.            beep=0;
  383.          }
  384.          beep=1;
  385.       }
  386.       }
  387. }
  388. }

  390. void shumima()                //对按键采集来的数据进行分配
  391. {
  392.         if(!wanbi)
  393.         {
  394.         switch(wei)
  395.         {
  396.                 case 1:new1=key;
  397.                             if(!allow)        a=17;
  398.                            else a=key;        break;
  399.                 case 2:new2=key;
  400.                                 if(a==17) b=17;
  401.                                 else b=key;        break;
  402.                 case 3:new3=key;
  403.                                 if(a==17) c=17;
  404.                                 else c=key;        break;
  405.                 case 4:new4=key;
  406.                                 if(a==17) d=17;
  407.                                 else d=key;        break;
  408.                 case 5:new5=key;
  409.                                 if(a==17) e=17;
  410.                                 else e=key;        break;
  411.                 case 6:new6=key;
  412.                                 if(a==17) f=17;
  413.                                 else f=key;
  414.                                 wanbi=1;        break;
  415.         }
  416.         }
  417. }

  419. void yanzheng()          //验证密码是否正确
  420. {
  421.         if(wanbi)         //只有当六位密码均输入完毕后方进行验证
  422.         {
  423.         if((new1==old1)&(new2==old2)&(new3==old3)&(new4==old4)&(new5==old5)&(new6==old6))
  424.                 allow=1;        //当输入的密码正确，会得到allowe置一
  425.         }
  426. }

  428. void main()
  429. {
  430.         
  431.         init();        //初始化24C02
  432. /*********下面的一小段程序的功能为格式化密码存储区。************
  433. ******当24c02中这些存储区由于其他程序的运行而导致***************
  434. *******所存数据发生了变化，或者密码遗忘时，        ********************
  435. ******可以删掉其前面的注释线，然后重新编译下载。****************
  436. ******而将密码还原为000000后，请将下面的程序用******************
  437. ******注释屏蔽掉，重新编译、下载，方可正常使用****************/
  438. //        write24c02(110,0x00);
  439. //        write24c02(111,0x00);//24c02的第110到115地址单元作为密码存储区
  440. //        write24c02(112,0x00);
  441. //        write24c02(113,0x00);
  442. //        write24c02(114,0x00);
  443. //        write24c02(115,0x00);
  444. /*******************************************************************/


  447.         old1=read24c02(110);  
  448.         old2=read24c02(111);
  449.         old3=read24c02(112);
  450.         old4=read24c02(113);
  451.         old5=read24c02(114);
  452.         old6=read24c02(115);

  454.         while(1)
  455.         {
  456.                 keyscan();
  457.                 shumima();
  458.                 yanzheng();
  459.                 if(allow)         //验证完后，若allow为1，则开锁
  460.                 {
  461.                         P1=0x00;
  462.                         if(!genggai)
  463.                                 wanbi=0;
  464.                 }
  465.                 if(genggai)          //当S16更改密码键被按下，genggai会被置一
  466.                 {
  467.                         if(allow)         //若已经把锁打开，才有更改密码的权限
  468.                         {
  469.                                 while(!wanbi)        //当新的六位密码没有设定完，则一直在这里循环
  470.                                 {
  471.                                          keyscan();
  472.                                         shumima();
  473.                                         if(retry|close)         //而当探测到重试键S18或者关闭密码锁键S19被按下时，则跳出
  474.                                         {        wanbi=1;
  475.                                                 break;
  476.                                         }
  477.                                         display(a,b,c,d,e,f);
  478.                                 }
  479.                         }
  480.                 }
  481.                 if(ok)          //更改密码时，当所有六位新密码均被按下时，可以按下此键，结束密码更改
  482.                 {                  //其他时间按下此键无效
  483.                         ok=0; wei=0;
  484.                         genggai=0;
  485.                         old1=new1;old2=new2;old3=new3; //此时，旧的密码将被代替
  486.                         old4=new4;old5=new5;old6=new6;
  487.                         //新密码写入存储区。
  488.                         write24c02(110,old1);
  489.                         write24c02(111,old2);
  490.                         write24c02(112,old3);
  491.                         write24c02(113,old4);
  492.                         write24c02(114,old5);
  493.                         write24c02(115,old6);
  494.                         a=16;b=16;c=16;d=16;e=16;f=16;
  495.                 }
  496.                 if(retry)        //当重试按键S18被按下，retry会被置位
  497.                 {
  498.                 retry=0; wei=0;wanbi=0;
  499.                 a=16;b=16;c=16;d=16;e=16;f=16;
  500.                 new1=0;new2=0;new3=0;new4=0;new5=0;new6=0;               
  501.                 }
  502.                 if(close)  //当关闭密码锁按键被按下，close会被置位
  503.                 {
  504.                         close=0;genggai=0;//所有变量均被清零。
  505.                         wei=0;        wanbi=0;
  506.                         allow=0;
  507.                         P1=0xff;
  508.                         a=16;b=16;c=16;d=16;e=16;f=16;
  509.                         new1=0;new2=0;new3=0;new4=0;new5=0;new6=0;
  510.                 }
  511.                 display(a,b,c,d,e,f); //实时显示
  512.         }
  513. }

复制代码

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

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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