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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 单片机密码锁源代码（掉电可记忆密码）
返回列表 发新帖
查看: 2580|回复: 0
打印 上一主题 下一主题
收起左侧

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

[复制链接]
跳转到指定楼层
楼主
ID:260372 发表于 2017-12-12 11:43 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
仿真原理图：http://www.51hei.com/bbs/dpj-101350-1.html
单片机源程序如下:
  1. /********************************************************************************
  2.                                                                 功能键
  3.                                                 S6---S115        数字键0-9
  4.                                 S16---更改密码                S17---更改密码完毕后确认
  5.                                 S18---重试密码、重新设定        S19---关闭密码锁
  6.                                 初始密码：000000         密码位数：6位
  7.                                 注意：掉电后，所设密码会丢失，重新上点时，密码恢复为原始的000000
  8.                                 与P1相连的8位发光LED点亮代表锁被打开；熄灭代表锁被锁上

  10. 程序功能：
  11.                   1、开锁：
  12.                   下载程序后，直接按六次S6（即代表数字0），8位LED亮，锁被打开，输入密码时，
  13.                   六位数码管依次显示小横杠。
  14.                   2、更改密码：
  15.                   只有当开锁（LED亮）后，该功能方可使用。
  16.                   首先按下更改密码键S16，然后设置相应密码，此时六位数码管会显示设置密码对应
  17.                   的数字。最后设置完六位后，按下S17确认密码更改，此后新密码即生效。
  18.                   3、重试密码：
  19.                   当输入密码时，密码输错后按下键S18，可重新输入六位密码。
  20.                   当设置密码时，设置中途想更改密码，也可按下此键重新设置。
  21.                   4、关闭密码锁：
  22.                   按下S19即可将打开的密码锁关闭。
  23. 推荐初级演示步骤：输入原始密码000000按6次S6密码正确后LED全部亮表示锁已打开---按下更
  24. 改密码按键S16---按S6到S15设置密码---按S17
  25.                         确认密码更改---按S19关闭密码锁---输入新的密码打开密码锁
  26. *******************************************************************************/
  27. #include<reg52.h>
  28. #include <intrins.h>
  29. #define uint unsigned int
  30. #define uchar unsigned char

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

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

  39. sbit dula=P2^6;
  40. sbit wela=P2^7;
  41. sbit beep=P2^3;
  42. sbit sda=P2^0;                          //IO口定义
  43. sbit scl=P2^1;

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

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

  51. void nop()
  52. {
  53.         _nop_();
  54.         _nop_();
  55. }
  56. /////////24C02读写驱动程序////////////////////
  57. void delay1(unsigned int m)
  58. {        unsigned int n;
  59.           for(n=0;n<m;n++);
  60. }

  62. void init()  //24c02初始化子程序
  63. {
  64.         scl=1;
  65.         nop();
  66.         sda=1;
  67.         nop();
  68. }

  70. void start()        //启动I2C总线
  71. {
  72.         sda=1;
  73.         nop();
  74.         scl=1;
  75.         nop();
  76.         sda=0;
  77.         nop();
  78.         scl=0;
  79.         nop();
  80. }

  82. void stop()         //停止I2C总线
  83. {
  84.         sda=0;
  85.         nop();
  86.         scl=1;
  87.         nop();
  88.         sda=1;
  89.         nop();
  90. }

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

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

  130. void clock()         //I2C总线时钟
  131. {
  132.    unsigned char i=0;
  133.    scl=1;
  134.    nop();
  135.    while((sda==1)&&(i<255))
  136.              i++;
  137.    scl=0;
  138.    nop();
  139. }

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

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

  174. void delay(unsigned char i)
  175. {
  176.         uchar j,k;
  177.   for(j=i;j>0;j--)
  178.     for(k=125;k>0;k--);
  179. }

  181. void display(uchar a,uchar b,uchar c,uchar d,uchar e,uchar f)
  182. {
  183.    dula=0;
  184.    P0=table[a];
  185.    dula=1;
  186.    dula=0;
  187.    
  188.    wela=0;
  189.    P0=0xfe;
  190.    wela=1;
  191.    wela=0;
  192.    delay(5);
  193.    
  194.    P0=table[b];
  195.    dula=1;
  196.    dula=0;
  197.    
  198.    P0=0xfd;
  199.    wela=1;
  200.    wela=0;
  201.    delay(5);

  203.    P0=table[c];
  204.    dula=1;
  205.    dula=0;
  206.    
  207.    P0=0xfb;
  208.    wela=1;
  209.    wela=0;
  210.    delay(5);
  211.    
  212.    P0=table[d];
  213.    dula=1;
  214.    dula=0;
  215.    
  216.    P0=0xf7;
  217.    wela=1;
  218.    wela=0;
  219.    delay(5);
  220.    
  221.    P0=table[e];
  222.    dula=1;
  223.    dula=0;
  224.    
  225.    P0=0xef;
  226.    wela=1;
  227.    wela=0;
  228.    delay(5);
  229.    
  230.    P0=table[f];
  231.    dula=1;
  232.    dula=0;
  233.    
  234.    P0=0xdf;
  235.    wela=1;
  236.    wela=0;
  237.    delay(5);
  238. }


  241. void keyscan()
  242. {
  243.   {        
  244.     P3=0xfe;
  245.     temp=P3;
  246.     temp=temp&0xf0;
  247.     if(temp!=0xf0)
  248.     {
  249.       delay(10);
  250.       if(temp!=0xf0)
  251.       {        
  252.         temp=P3;
  253.         switch(temp)
  254.         {
  255.           case 0xee:
  256.                key=0;
  257.                            wei++;
  258.                break;

  260.           case 0xde:
  261.                key=1;
  262.                            wei++;
  263.                break;

  265.           case 0xbe:
  266.                key=2;
  267.                            wei++;
  268.                break;

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

  300.           case 0xdd:
  301.                key=5;
  302.                            wei++;
  303.                break;

  305.           case 0xbd:
  306.                key=6;
  307.                            wei++;
  308.                break;

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

  340.           case 0xdb:
  341.                key=9;
  342.                            wei++;
  343.                break;
  344.                            
  345.           case 0xbb:
  346.                genggai=1;
  347.                            wei=0;
  348.                break;

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

  379.           case 0xd7:
  380.                              close=1;
  381.                break;
  382.          }
  383.         while(temp!=0xf0)
  384.          {
  385.            temp=P3;
  386.            temp=temp&0xf0;
  387.            beep=0;
  388.          }
  389.          beep=1;
  390.       }
  391.       }
  392. }
  393. }

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

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

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


  452.         old1=read24c02(110);  
  453.         old2=read24c02(111);
  454.         old3=read24c02(112);
  455.         old4=read24c02(113);
  456.         old5=read24c02(114);
  457.         old6=read24c02(115);

  459.         while(1)
  460.         {
  461.                 keyscan();
  462.                 shumima();
  463.                 yanzheng();
  464. ……………………

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

所有资料51hei提供下载:
密码锁（掉电可记忆密码）.rar (36.07 KB, 下载次数: 25)


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

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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