找回密码
 立即注册

QQ登录

只需一步,快速开始

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

电子密码锁仿真,可掉电保存密码 涉及了24C02、IIC 、E2PROM

[复制链接]
跳转到指定楼层
楼主
自己设计了一个电子密码锁,可掉电保存密码!涉及了24C02、IIC  、E2PROM等,采用LCD12864中文显示
1、在这一版中,将24C02的两引脚SCL和SDA接在了P3.2和P3.3,原来接的是P2.0和P2.1



全部资料下载:
password终极版.zip (180.19 KB, 下载次数: 113)


矩阵键盘信息:
1 0x7e   2 0xbe   3 0xde
4 0x7d   5 0xbd   6 0xdd
7 0x7b   8 0xbb   9 0xdb
0 0x77   * 0xb7   # 0xd7
0xee 改密码
0xed 启动
0xeb 消除
0xe7 确定

键盘扫描程序
uchar keyscan()  //键盘扫描函数,使用行列反转扫描法
{
        uchar cord_h,cord_l;        //行列值中间变量
        P1=0x0f;                    //行线输出全为1  列线输出全为0
        cord_h=P1 & 0x0f;       //读入行线值
        if(cord_h != 0x0f)      //先检测有无按键按下
        {
                Delay(10);          //去抖
                if(cord_h!=0x0f)
                {
                        cord_h=P1 & 0x0f;             //读入行线值
                        P1=cord_h | 0xf0;             //注意:执行这一步的时候后,按键还没有松开
                        cord_l=P1 & 0xf0;             //读入列线值
                        return(cord_h + cord_l);        //键盘最后组合码值
                }
        }
        return(0xff);     //返回该值
}


源码如下:
  1. #include<reg52.h>
  2. #include<intrins.h>
  3. #include"delay.h"
  4. #include"lcd12864.h"
  5. #include"keyboard.h"
  6. #include"24C02.h"
  7. #include"uart.h"
  8. #include"T0.h"
  9. #include"character.h"





  10. #define uchar unsigned char
  11. #define uint unsigned int


  12. uchar dumima,oldmima_flag,newmima_flag,newpass_flag,again_flag,flag,again_and_again_flag;
  13. uchar code chushimima_tab[]={1,2,3,4,5,6};  //设定系统第一次初始密码为123456
  14. uchar data dumima_tab1[6]="      ";                //从24C02中读取写入的初始或修改的密码保存
  15. uchar data dumima_tab2[6]="      ";                // 储存键入的密码,用于与24C02中的对比
  16. uchar data dumima_tab3[6]="      ";                // 储存键入的新密码
  17. uchar data dumima_tab4[6]="      ";                // 储存再次键入的新密码
  18. uchar code key_table[]={0,1,2,3,4,5,6,7,8,9};           //显示密码数字字符
  19. uchar code tiaoshi_ok[]="01";                //调试用


  20. void main()
  21. {
  22.         uchar j;        
  23.         Init_lcd12864();
  24.         Display_interface();
  25.         UART_init();               //读出0x00处的数据,发送到串口查看
  26.         InitI2C();                           //初始化
  27.         Timer0_init();          //定时器0初始化
  28.         mm=3;            //可以有5次输入密码的机会
  29. /*        for(i=0;i<6;i++)                 //先将密码写入24C02
  30.         {
  31.                 write_eeprom(i+2,chushimima_tab[i]);
  32.                 Delayms(10);                                
  33.         }                  */
  34. //        c = read_eeprom(0x07);            //串口发送程序段,可以用来测试
  35. //        UART_send_byte(c);
  36. //        dumima = read_eeprom(0x01);         //读取01地址的数据判断是否写入初始或修改的密码
  37. //        if(dumima != 1)
  38. //        {
  39. //                write_eeprom(0x01,0x01);     //在0X01出写入1
  40. //                for(j=0;j<6;j++)                        //从02地址开始写初始密码数据
  41. //                {
  42. //                        write_eeprom(j+2,chushimima_tab[j]);
  43. //                        Delayms(10);                                
  44. //                }                                                               
  45. //        }
  46. /*****************如果忘记密码,可以利用这段程序重新设置初始密码*************
  47.                 for(j=0;j<6;j++)                        //从02地址开始写初始密码数据
  48.                 {
  49.                         write_eeprom(j+2,chushimima_tab[j]);         //初始密码123456
  50.                         Delayms(10);                                
  51.                 }
  52. *********************************************************************************/
  53.         for(j=0;j<6;j++)                                 //将24C02中的密码读取出来保存在dumima_tab1[]数组中
  54.         {
  55.                  dumima_tab1[j] = read_eeprom(j+2);
  56.                 Delayms(10);               
  57.         }         
  58.         while(1)                        //程序大循环
  59.         {

  60.                 keyscan();                          //调用键盘扫描   查询按键是否有按下(只对启动和修改密码按键有效)
  61.                 if(start == 1)                        //启动
  62.                 {
  63.                         prevent_wucaozuo();            //防止误操作
  64.                         Input_password();
  65.                         char_num=0;loop=1;
  66.                         while(loop==1)
  67.                         {
  68.                                 keyscan();                         //仅数字键和取消键有效
  69.                                 if(key_flag==1)                //有数字键被按下
  70.                                 {
  71.                                         prevent_wucaozuo();                                              //防止误操作
  72.                                         Display_num(i,char_num);                                 //显示键入的数字
  73.                                         dumima_tab2[char_num] =  key_table[i];          //储存键入的数字
  74.                                         UART_send_byte(key_table[i]);          //调试用
  75.                                         decide_songkai();                                   //判断按键是否松开
  76.                                         char_num++;  
  77.                                         if(char_num==6)
  78.                                         {
  79.                                                  loop=0; char_num=0;         wait_ok=1;
  80.                                                 for(j=0;j<6;j++)                                 //将24C02中的密码读取出来保存在dumima_tab1[]数组中
  81.                                                 {
  82.                                                          dumima_tab1[j] = read_eeprom(j+2);
  83.                                                         Delayms(10);               
  84.                                                 }
  85.                                                 while(wait_ok==1)
  86.                                                 {
  87.                                                         keyscan();   //等待确认键按下
  88.                                                         if(ok==1)
  89.                                                         {
  90.                                                                 prevent_wucaozuo(); wait_ok=0;
  91.                                                                 if(dumima_tab2[0]==dumima_tab1[0]&&dumima_tab2[1]==dumima_tab1[1]
  92.                                                                  &&dumima_tab2[2]==dumima_tab1[2]&&dumima_tab2[3]==dumima_tab1[3]
  93.                                                                  &&dumima_tab2[4]==dumima_tab1[4]&&dumima_tab2[5]==dumima_tab1[5])
  94.                                                                 {
  95. //                                                                         UART_send_byte(tiaoshi_ok[1]);
  96.                                                                         input_password_ok();         //显示输入的密码正确
  97.                                                                         Delayms(2000);                         //延时显示
  98.                                                                         Display_interface();          //返回界面
  99.                                                                 }
  100.                                                                 else                           //执行密码输入错误操作
  101.                                                                 {
  102. //                                                                        UART_send_byte(dumima_tab2[5]);
  103.                                                                         input_password_no();          //显示"密码错误"
  104.                                                                         Delayms(2000);                         //延时显示
  105.                                                                         mm--;                                   //输入机会减少一次
  106.                                                                         if(mm>0)
  107.                                                                         {
  108.                                                                                 Display_tishi_information(mm);        //提示信息
  109.                                                                                 Delayms(2000);
  110.                                                                                 start = 1;                                                                                
  111.                                                                         }
  112.                                                                         else
  113.                                                                         {
  114. //                                                                                UART_send_byte(mm);        
  115.                                                                                 Display_suoping_information();        //锁屏信息
  116.                                                                                 TR0=1;                                                        //启动定时器0,在Timer0_service();中关闭
  117.                                                                                 suoping_flag=10;                                //锁屏秒数
  118.                                                                                 while(suoping_flag)
  119.                                                                                 {
  120.                                                                                         Timer0_service();                  //锁屏倒计时服务函数
  121.                                                                                 }
  122.                                                                                 suoping_flag=10;                         //重新恢复锁屏次数
  123.                                                                                 Delayms(1000);                                 //延时
  124.                                                                                 start = 0;                                        //重新进入while(1)大循环
  125.                                                                                 mm=3;                                                //重新恢复可输入密码的次数
  126.                                                                                 Display_interface();                //显示开始界面                                                                        
  127.                                                                         }
  128.                                                                                 
  129.                                                                 }        
  130.                                                         }        
  131.                                                  }
  132.                                                 
  133.                                         }
  134.                                 }

  135.                                 if(remove==1)                                //在输入密码的过程中可以按“取消”键取消输入密码,直接返回到开始界面
  136.                                 {
  137.                                         prevent_wucaozuo();            //防止误操作
  138.                                         start = 0;                                        //重新进入while(1)大循环
  139.                                         loop = 0;
  140.                                         mm=3;                                                //重新恢复可输入密码的次数
  141.                                         Display_interface();                //显示开始界面                                
  142.                                 }                        
  143.                         }                        
  144.                 }

  145. /*******************按下"重置密码"键**************************/
  146.                 if(alter_password ==1)
  147.                 {
  148.                         prevent_wucaozuo();            //防止误操作
  149.                         Input_old_password();         //输入旧密码
  150.                         char_num=0;oldmima_flag = 1;     //char_num为输入密码的位数
  151.                         while(oldmima_flag==1)                   //
  152.                         {
  153.                                 keyscan();                         //仅数字键和取消键有效
  154.                                 if(key_flag==1)                //有数字键被按下
  155.                                 {
  156.                                         prevent_wucaozuo();                    //防止误操作
  157.                                         Display_num(i,char_num);                                 //显示键入的数字
  158.                                         dumima_tab2[char_num] =  key_table[i];          //储存键入的数字
  159. //                                        UART_send_byte(key_table[i]);          //调试用
  160.                                         decide_songkai();                                   //判断按键是否松开
  161.                                         char_num++;
  162.                                         if(char_num==6)
  163.                                         {
  164.                                                 oldmima_flag=0; char_num=0;         wait_ok=1;           //在按下确认键之前将其置为0,其实也可以在两分支(1.输入密码成功 2.输入密码错误)内将其置为0
  165.                                                 while(wait_ok==1)                   //记得在这个循环里将wait_ok置0  
  166.                                                 {
  167.                                                         keyscan();   //等待确认键按下
  168.                                                         if(ok==1)
  169.                                                         {
  170.                                                                 prevent_wucaozuo();
  171.                                                                 if(dumima_tab2[0]==dumima_tab1[0]&&dumima_tab2[1]==dumima_tab1[1]
  172.                                                                  &&dumima_tab2[2]==dumima_tab1[2]&&dumima_tab2[3]==dumima_tab1[3]
  173.                                                                  &&dumima_tab2[4]==dumima_tab1[4]&&dumima_tab2[5]==dumima_tab1[5])
  174.                                                                 {
  175.                                                                         input_password_ok();         //显示输入的密码正确
  176.                                                                         Delayms(2000);                         //延时显示
  177.                                                                         Input_new_password();          //显示“输入新密码”界面
  178.                                                                         newmima_flag=1;
  179.                                                                         while(newmima_flag==1)                //记得在这个循环里将newmima_flag置0
  180.                                                                         {
  181.                                                                                 keyscan();          //只有数字键和取消键有效
  182.                                                                                 if(key_flag==1)
  183.                                                                                 {
  184.                                                                                         prevent_wucaozuo();                    //防止误操作
  185.                                                                                         Display_num(i,char_num);                                 //显示键入的数字
  186.                                                                                         dumima_tab3[char_num] =  key_table[i];          //储存键入的新密码
  187.         //                                                                                UART_send_byte(key_table[i]);
  188.                                                                                         decide_songkai();                                   //判断按键是否松开
  189.                                                                                         char_num++;        
  190.                                                                                         if(char_num==6)
  191.                                                                                         {
  192.                                                                                                  char_num=0;         newpass_flag=1;
  193.                                                                                                  for(j=0;j<6;j++)                        //从02地址开始写初始密码数据
  194.                                                                                                 {
  195.                                                                                                                 write_eeprom(j+2,dumima_tab3[j]);
  196.                                                                                                                 Delayms(10);                                
  197.                                                                                                 }
  198.                                                                                                 //将新密码保存在24C02中
  199.                                                                                                 while(newpass_flag == 1)                  
  200.                                                                                                 {
  201.                                                                                                 
  202.                                                                                                         keyscan();         
  203.                                                                                                         if(ok==1)          //只有确认键有效
  204.                                                                                                         {
  205.                                                                                                                 prevent_wucaozuo();                    //防止误操作
  206.                                                                                                                 Input_new_password_again();        
  207.                                                                                                                 again_flag=1;
  208.                                                                                                                 while(again_flag==1)         //再次输入新密码
  209.                                                                                                                 {
  210.                                                                                                                         keyscan();          //只有数字键有效
  211.                                                                                                                         if(key_flag==1)
  212.                                                                                                                         {
  213.                                                                                                                                 prevent_wucaozuo();                    //防止误操作
  214.                                                                                                                                 Display_num(i,char_num);                                 //显示键入的数字
  215.                                                                                                                                 dumima_tab4[char_num] =  key_table[i];          //储存键入的新密码
  216.                                                 //                                                                                UART_send_byte(key_table[i]);
  217.                                                                                                                                 decide_songkai();                                   //判断按键是否松开
  218.                                                                                                                                 char_num++;        
  219.                                                                                                                                 if(char_num==6)
  220.                                                                                                                                 {
  221.                                                                                                                                         char_num = 0; again_flag=0; flag=1;
  222.                                                                                                                                         while(flag==1)
  223.                                                                                                                                         {
  224.                                                                                                                                                 keyscan();
  225.                                                                                                                                                 if(1==ok)
  226.                                                                                                                                                 {
  227.                                                                                                                                                         prevent_wucaozuo();                    //防止误操作
  228.                                                                                                                                                         if(dumima_tab3[0]==dumima_tab4[0]&&dumima_tab3[1]==dumima_tab4[1]
  229.                                                                                                                                                          &&dumima_tab3[2]==dumima_tab4[2]&&dumima_tab3[3]==dumima_tab4[3]
  230.                                                                                                                                                          &&dumima_tab3[4]==dumima_tab4[4]&&dumima_tab3[5]==dumima_tab4[5])
  231.                                                                                                                                                          {
  232.                                                                                                                                                                  flag=0;        newpass_flag=0;again_flag=0;newmima_flag=0;wait_ok=0;
  233.                                                                                                                                                                 Alter_password_success();
  234.                                                                                                                                                                 Delayms(2000);        
  235.                                                                                                                                                                 Display_interface();                //显示开始界面        
  236.                                                                                                                                                          }
  237.                                                                                                                                                          else                                           //两次输入的新密码不一致执行的操作
  238.                                                                                                                                                          {
  239.                                                                                                                                                                  Display_again_cuowu_information();          //显示第二次输入的密码错误
  240.                                                                                                                                                                 Delayms(3000);
  241.                                                                                                                                                                 Input_new_password_again();        
  242.                                                                                                                                                                 again_and_again_flag = 1;
  243.                                                                                                                                                                 while(again_and_again_flag==1)
  244.                                                                                                                                                                 {
  245.                                                                                                                                                                         keyscan();          //只有数字键有效
  246.                                                                                                                                                                         if(key_flag==1)
  247.                                                                                                                                                                         {
  248.                                                                                                                                                                                 prevent_wucaozuo();                    //防止误操作
  249.                                                                                                                                                                                 Display_num(i,char_num);                                 //显示键入的数字
  250.                                                                                                                                                                                 dumima_tab4[char_num] =  key_table[i];          //储存键入的新密码
  251.                                                                                                 //                                                                                UART_send_byte(key_table[i]);
  252.                                                                                                                                                                                 decide_songkai();                                   //判断按键是否松开
  253.                                                                                                                                                                                 char_num++;        
  254.                                                                                                                                                                                 if(char_num==6)
  255.                                                                                                                                                                                 {
  256.                                                                                                                                                                                         char_num = 0;again_and_again_flag=0; flag=1;
  257.                                                                                                                                                                                         while(flag==1)
  258.                                                                                                                                                                                         {
  259.                                                                                                                                                                                                 keyscan();
  260.                                                                                                                                                                                                 if(1==ok)
  261.                                                                                                                                                                                                 {
  262.                                                                                                                                                                                                         prevent_wucaozuo();                    //防止误操作
  263.                                                                                                                                                                                                         if(dumima_tab3[0]==dumima_tab4[0]&&dumima_tab3[1]==dumima_tab4[1]
  264.                                                                                                                                                                                                          &&dumima_tab3[2]==dumima_tab4[2]&&dumima_tab3[3]==dumima_tab4[3]
  265.                                                                                                                                                                                                          &&dumima_tab3[4]==dumima_tab4[4]&&dumima_tab3[5]==dumima_tab4[5])
  266.                                                                                                                                                                                                          {
  267.                                                                                                                                                                                                                  flag=0;        again_and_again_flag=0;newpass_flag=0;again_flag=0;newmima_flag=0;wait_ok=0;
  268.                                                                                                                                                                                                                 Alter_password_success();
  269.                                                                                                                                                                                                                 Delayms(2000);        
  270.                                                                                                                                                                                                                 Display_interface();                //显示开始界面        
  271.                                                                                                                                                                                                          }
  272.                                                                                                                                                                                                          else                                                        //又一次第二次输错新密码(有点绕^_^)
  273.                                                                                                                                                                                                          {
  274.                                                                                                                                                                                                                         flag=0;        again_and_again_flag=0;newpass_flag=0;again_flag=0;newmima_flag=0;wait_ok=0;
  275.                                                                                                                                                                                                                         Alter_no_success();           //修改密码失败
  276.                                                                                                                                                                                                                         Delayms(2000);        
  277.                                                                                                                                                                                                                         Display_interface();                //显示开始界面                                
  278.                                                                                                                                                                                                          }        
  279.                                                                                                                                                                                                 }               
  280.                                                                                                                                                                                         }
  281.                                                                                                                                                                                        
  282.                                                                                                                                                                                 }
  283.                                                                                                                                                                         }        
  284.                                                                                                                                                                 }        
  285.                                                                                                                                                          }        
  286.                                                                                                                                                 }               
  287.                                                                                                                                         }                                                                                                                                       
  288.                                                                                                                                 }               
  289.                                                                                                                         }
  290.                                                                                                                 }        
  291.                                                                                                         }
  292.                                                                                                 }
  293.                                                                                         }
  294.                                                                                 }
  295.                                                                                 if(remove==1)        //第一次输入新密码过程中按下“取消”按键执行的操作
  296.                                                                                 {
  297.                                                                                         prevent_wucaozuo();                    //防止误操作
  298.                                                                                         newmima_flag = 0; wait_ok = 0; alter_password = 0;
  299.                                                                                         Display_interface();                //显示开始界面                                                
  300.                                                                                 }                        
  301.                                                                         }
  302.                                                                 }
  303.                                                                 else       //输入的密码错误执行操作
  304.                                                                 {
  305.                                                                         input_password_no();          //显示"密码错误"
  306.                                                                         Delayms(2000);                         //延时显示
  307.                                                                         mm--;                                   //输入机会减少一次
  308.                                                                         if(mm>0)
  309.                                                                         {
  310.                                                                                 Display_tishi_information(mm);        //提示信息
  311.                                                                                 Delayms(2000);
  312.                                                                                 alter_password = 1;            //还是将alter_password置0比较合适
  313.                                                                                 wait_ok = 0;                                                                        
  314.                                                                         }
  315.                                                                         else
  316.                                                                         {
  317. //                                                                                UART_send_byte(mm);        
  318.                                                                                 Display_suoping_information();        //锁屏信息
  319.                                                                                 TR0=1;                                                        //启动定时器0,在Timer0_service();中关闭
  320.                                                                                 suoping_flag=10;                                //锁屏秒数
  321.                                                                                 while(suoping_flag)
  322.                                                                                 {
  323.                                                                                         Timer0_service();                  //锁屏倒计时服务函数
  324.                                                                                 }
  325.                                                                                 suoping_flag=10;                         //重新恢复锁屏次数
  326.                                                                                 Delayms(1000);                                 //延时
  327.                                                                                 alter_password = 0;                                        //重新进入while(1)大循环
  328.                                                                                 mm=3;        wait_ok = 0;                        //重新恢复可输入密码的次数
  329.                                                                                 Display_interface();                //显示开始界面                                                                        
  330.                                                                         }        
  331.                                                                 }        
  332.                                                         }                        
  333.                                                 }        
  334.                                         }               
  335.                                 }
  336.                                 if(remove==1)                //在输入密码的过程中可以按“取消”键取消输入密码,直接返回到开始界面
  337.                                 {
  338.                                         prevent_wucaozuo();                    //防止误操作
  339.                                         oldmima_flag=0;
  340.                                         alter_password=0;      //我觉得这里应该吧alter_password置为0
  341.                                         Display_interface();                //显示开始界面               
  342.                                 }                                         
  343.                         }
  344.                 }        
  345.         }        
  346. }
复制代码




评分

参与人数 1黑币 +10 收起 理由
YJGG + 10 共享资料的黑币奖励!

查看全部评分

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

使用道具 举报

地板
ID:377803 发表于 2019-9-12 16:15 | 只看该作者
仿真的时候输入初始密码123456,错误啊。初始密码是什么呢
回复

使用道具 举报

板凳
ID:604991 发表于 2019-8-29 09:07 | 只看该作者
谢谢楼主分享,正好有用
回复

使用道具 举报

沙发
ID:197445 发表于 2017-7-17 13:06 | 只看该作者
谢谢楼主
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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