微波EDA网,见证研发工程师的成长!
首页 > 研发问答 > 嵌入式设计讨论 > MCU和单片机设计讨论 > 密码锁,求帮助

密码锁,求帮助

时间:10-02 整理:3721RD 点击:
想把一个别的程序移植到自己的硬件上,纯小白,不会改,求帮助求帮助求帮助。
原图
我的图
主程序

  1. #include <reg52.h>
  2. #include "delay.h"        //延时头文件
  3. #include "LCD1602.h"
  4. #include "speaker.h"
  5. #include "key4x4.h"
  6. #include "AT24C02.h"
  7. #include "t1.h"
  8. /***************************************************************/
  9. #define uchar unsigned char          // 无符号字符整形 0~ 256
  10. #define uint unsigned int           //定义无符号整形        0~65536
  11. /**************************************************************/
  12. sbit led=P2^3; //仿真软件使用接口
  13. uint dumima,old_mima,new_mima,shige;
  14. uchar code chushimima_tab[]={1,2,3,4,5,6};        //设定系统第一次初始密码为123456
  15. uchar data dumima_tab1[6]={0};                //从24C02中读取写入的初始或修改的密码保存
  16. uchar data dumima_tab2[6]={0};                // 用于读取密码是保存在内存中,        启动打开密码锁时用到
  17. uchar data shurumima_tab1[6]={0};        //从键盘输入的密码保存,以便和读取的密码对比  修改密码时用到
  18. uchar data shurumima_tab2[6]={0};        //从键盘输入的密码保存,以便和读取的密码对比  修改密码时用到
  19. void main()
  20. {
  21.         uchar j,mm=5;  //j显示位置字符,mm提示报警次数计数及显示输入错误机会次数为5次
  22.         led=1;
  23.         speak=1;
  24.         init();           //1602初始化
  25.         jiemian(); //1602显示界面
  26.         ding_time=50000;                          //设定T1定时器定时时长50ms
  27.         timer1_init( );                     //T1定时器初始化
  28.         TR1=1;                                           //T1定时器启动开始定时
  29. /*************************************************************/
  30.         dumima=AT24C02_read_byte(0x02);//读取02地址的数据判断是否写入初始或修改的密码
  31.         if(dumima!=1)                  //如果不等于1,则判断没写初始或修改的密码,需要写入
  32.         {
  33.                 AT24C02_write_byte(0x02,0x01); //在第2个地址中写入1,以便判断下次不用写入
  34.                 delay_ms(10);         
  35.                 for(j=0;j<6;j++)
  36.                 {                                        //从第4个地址开始写初始密码数据
  37.                         AT24C02_write_byte(j+4,chushimima_tab[j]);
  38.                         delay_ms(10);         
  39.                 }
  40.         }
  41.         for(j=0;j<6;j++)          //从第4个地址开始写初始密码数据
  42.         {                                        //从24C02中读取写入的初始或修改的密码保存
  43.                 dumima_tab1[j]=AT24C02_read_byte(j+4);
  44.                 delay_ms(10);         
  45.         }                                  
  46. /*************************************************************/
  47.         been();                //初始化读写密码完成之后提示声音,同时进入主程序大循环
  48.         while(1)        //进入程序大循环
  49.         {
  50.                 key4x4();                        //查询按键是否有按下(只对启动和修改密码按键有效)
  51. /*********************************************************/
  52.                 if(start_stop==1)  //启动按键密码输入打开密码锁
  53.                 {
  54.                         ok=0;                 //取消其他按键误动作及退出判断
  55.                         quxiao=0;
  56.                         key_valu=0;
  57.                         xiugaimima=0;  
  58.                         start_stop=0;
  59.                         TR1=0;//关闭定时器
  60.                         been();         // 启动按键提示音
  61.                         write_com(0x80);        //第一行显示“Please input You”
  62.                         for(j=0;j<16;j++)
  63.                         {
  64.                                 write_data(you_table[j]);
  65.                                 delay_us(10);
  66.                         }
  67.                         write_com(0xc0);        //第二行显示“Password:                 ”
  68.                         for(j=0;j<16;j++)
  69.                         {
  70.                                 write_data(table3[j]);
  71.                                 delay_us(10);
  72.                         }
  73.                         num=0; start4x4=1;         //num输入显示计数位置设置及等待输入密码循环开始
  74.                         while(start4x4==1)         //等待数字键按下作为密码输入
  75.                         {
  76.                                 key4x4();                 //只对数字按键和取消按键有效
  77.                                 if(key_valu==1)         //在输入密码过程中,可以随时去取消输入重来
  78.                                 {                                 //但是输入满6位的时候不能取消,必须按确认键
  79.                                         ok=0;                 //取消其他按键误动作及退出判断
  80.                                         quxiao=0;
  81.                                         key_valu=0;
  82.                                         xiugaimima=0;  
  83.                                         start_stop=0;  been();         //输入按键提示声音
  84.                                         write_com(0xca+num);          //第二行适当位置ca起显示输入的密码
  85.                                         write_data(key_table[i]); //显示对应的数字密码,        
  86.                                         write_data(xing_tab[0]); //用*号代替数字保密         /*更改此处可显示数字*/
  87.                                         dumima_tab2[num]=key_table2[i];        //将输入的密码进行保存以便核对
  88.                                         while(dengdai==1)        //将P1端口的值读出判断按键是否松开,
  89.                                         {
  90.                                                 tem=P1;
  91.                                                 if(tem!=0xf0)         dengdai=1;                //按下就继续等待
  92.                                                 else                         dengdai=0;                //松开就返回
  93.                                         }
  94.                                         num++;                            //显示下一个字符
  95.                                         if(num==6)           //按下6个数字的操作,等待确认按下
  96.                                         {
  97.                                                 num=0; start4x4=0;dengdai_ok=1;         //进入下一个显示环节,等待按确认键确认密码
  98.                                                 while(dengdai_ok==1)
  99.                                                 {
  100.                                                            key4x4();
  101.                                                         if(ok==1) //确认按键按下,进行密码对比
  102.                                                         {
  103.                                                                 ok=0;                 //取消按键误动作
  104.                                                                 quxiao=0;
  105.                                                                 key_valu=0;
  106.                                                                 xiugaimima=0;  dengdai_ok=0;
  107.                                                                 start_stop=0;         
  108.                                                                         //密码逐位对比判断(密码对比)
  109.                                                                 if(dumima_tab2[0]==dumima_tab1[0]&&dumima_tab2[1]==dumima_tab1[1]
  110.                                                                  &&dumima_tab2[2]==dumima_tab1[2]&&dumima_tab2[3]==dumima_tab1[3]
  111.                                                                  &&dumima_tab2[4]==dumima_tab1[4]&&dumima_tab2[5]==dumima_tab1[5])
  112.                                                                 {                //密码输入正确的操作
  113.                                                                         been();          //输入密码正确按键提示声音
  114.                                                                         baojing=0; mm=5;   //消除报警和输入限制次数清零
  115.                                                                         write_com(0xc0);        //第二行显示"Password: -OK!- "
  116.                                                                         for(j=0;j<16;j++)
  117.                                                                         {
  118.                                                                                 write_data(table4[j]);
  119.                                                                                 delay_us(10);
  120.                                                                         }
  121.                                                                         led=0;          //执行密码正确指令功能         /*更改此处可修改功能*/
  122.                                                                         delay_ms(2000);        //成功或者不成功 延时5秒钟之后判断显示界面
  123.                                                                         jiemian();    //显示界面信息               
  124.                                                                         TR1=1; time=0;xian1=0;xian2=1; //启动定时器开锁工作
  125.                                                                         delay_ms(5000);led=1;         //指示灯延时5秒之后关闭
  126.                                                                 }
  127.                                                                 else         //执行密码输入错误 操作
  128.                                                                 {
  129.                                                                         been();delay_ms(50);been();delay_ms(500); //输入密码错误提示
  130.                                                                         write_com(0xc0);        //第二行显示"Password: -No!- "”
  131.                                                                         for(j=0;j<16;j++)
  132.                                                                         {
  133.                                                                                 write_data(table5[j]);
  134.                                                                                 delay_us(10);
  135.                                                                         }
  136.                                                                            delay_ms(2000);
  137.                                                                         mm--;                          //输入机会减少1次        最高最低各5次
  138.                                                                         if(mm>0)           //少于5次时显示输入机会
  139.                                                                         {
  140.                                                                                 write_com(0x80);        //第二行显示" Sorry! You have"
  141.                                                                                 for(j=0;j<16;j++)
  142.                                                                                 {
  143.                                                                                         write_data(chan_tab1[j]);
  144.                                                                                         delay_us(10);
  145.                                                                                 }
  146.                                                                                 write_com(0xc0);        //第二行显示"                "
  147.                                                                                 for(j=0;j<16;j++)         //清楚第二行内容,
  148.                                                                                 {
  149.                                                                                         write_data(kong_tabb[j]);
  150.                                                                                         delay_us(10);
  151.                                                                                 }
  152.                                                                                 write_com(0xc3);        //第二行显示"12345“
  153.                                                                                 write_data(chan_tab3[mm]);
  154.                                                                                 delay_us(5);
  155.                                                                                 write_com(0xc7);        //第二行显示"       Chance!"
  156.                                                                                 for(j=0;j<9;j++)
  157.                                                                                 {
  158.                                                                                         write_data(chan_tab2[j]);
  159.                                                                                         delay_us(10);
  160.                                                                                 }
  161.                                                                                 delay_ms(5000);
  162.                                                                                 start_stop=1;  //返回继续等待重新输入密码开锁
  163.                                                                         }                                                                          
  164.                                                                         else  //mm=0;执行密码错误指令功能:输错5次报警
  165.                                                                         {
  166.                                                                                 been();delay_ms(50);been();delay_ms(50);been();delay_ms(500);
  167.                                                                                 P1=0x00;mm=1; //锁定键盘,同时限制输入次数只能为1次
  168.                                                                                 jiemian();      //显示界面之后再进行报警            
  169.                                                                                 TR1=1; time=0;xian1=0;xian2=1;
  170.                                                                                 baojing=1;  // 只有输入成功才能给5次机会,同时撤出报警
  171.                                                                                 speaker();          //蜂鸣器执行报警程序   报警完毕之后延长时间停止再次输入
  172.                                                                                 for(j=0;j<20;j++)         //延时20秒不输入,锁定键盘
  173.                                                                                 {                                         //同时又开始锁定时间,让键盘功能无效  6000
  174.                                                                                         delay_ms(1000);
  175.                                                                                 }                                //延时时间到重启输入,但是只给一次机会
  176.                                                                                 TR1=0;         //关闭定时器显示提示输入信息界面,
  177.                                                                                 write_com(0x80);        //第二行显示" Sorry! You have"
  178.                                                                                 for(j=0;j<16;j++)
  179.                                                                                 {
  180.                                                                                         write_data(chan_tab1[j]);
  181.                                                                                         delay_us(10);
  182.                                                                                 }
  183.                                                                                 write_com(0xc0);        //第二行显示"                "
  184.                                                                                 for(j=0;j<16;j++)         //清楚第二行内容,
  185.                                                                                 {
  186.                                                                                         write_data(kong_tabb[j]);
  187.                                                                                         delay_us(10);
  188.                                                                                 }
  189.                                                                                 write_com(0xc1);        //第二行显示" 12345"
  190.                                                                                 write_data(chan_tab3[mm]);
  191.                                                                                 delay_us(5);
  192.                                                                                 write_com(0xc3);        //第二行显示"       Chance!"
  193.                                                                                 for(j=0;j<9;j++)
  194.                                                                                 {
  195.                                                                                         write_data(chan_tab2[j]);
  196.                                                                                         delay_us(10);
  197.                                                                                 }
  198.                                                                                 write_com(0xcd);        //第二行显示"             ok?"
  199.                                                                                 for(j=0;j<3;j++)
  200.                                                                                 {
  201.                                                                                         write_data(ok_tab[j]);       
  202.                                                                                         delay_us(10);
  203.                                                                                 }
  204.                                                                                 delay_ms(2000);
  205.                                                                                 dengdai_ok=1; been();delay_ms(50);been();delay_ms(50);been();delay_ms(500);
  206.                                                                                 while(dengdai_ok==1)  //提示最后输入密码
  207.                                                                                 {
  208.                                                                                         key4x4();
  209.                                                                                         if(ok==1)          //等待确认按键按下再次输入密码开锁
  210.                                                                                         {
  211.                                                                                                 ok=0;                 //取消按键误动作
  212.                                                                                                 quxiao=0;
  213.                                                                                                 key_valu=0;
  214.                                                                                                 start_stop=0;  
  215.                                                                                                 dengdai_ok=0;
  216.                                                                                                 start_stop=1;  //返回继续等待重新输入密码开锁
  217.                                                                                         }
  218.                                                                                 }
  219.                                                                         }
  220.                                                                 }
  221.                                                         }
  222.                                                 }
  223.                                         }
  224.                                 }
  225.                                 if(quxiao==1)          //按下取消按键则显示界面联系电话
  226.                                 {
  227.                                         ok=0;                 //取消按键误动作
  228.                                         quxiao=0;
  229.                                         key_valu=0;
  230.                                         xiugaimima=0;  
  231.                                         start_stop=0;
  232.                                         dengdai_ok=0; start4x4=0;  been();
  233.                                         jiemian();           //开启定时器,显示界面和欢迎和电话信息
  234.                                         TR1=1;time=0;xian1=0;xian2=1;
  235.                                         while(dengdai==1)        //将P1端口的值读出判断按键是否松开,
  236.                                         {
  237.                                                 tem=P1;
  238.                                                 if(tem!=0xf0)         dengdai=1;                //按下就继续等待
  239.                                                 else                         dengdai=0;                //松开就返回
  240.                                         }
  241.                                 }
  242.                         }
  243.                 }
  244. /*********************************************************/
  245. /*********************************************************/
  246. /*********************************************************/
  247.                 if(xiugaimima==1)        //修改密码程序               
  248.                 {
  249.                         ok=0;                 //取消按键误动作
  250.                         quxiao=0;
  251.                         key_valu=0;
  252.                         start_stop=0;
  253.                         xiugaimima=0;         been();       
  254.                         TR1=0;//关闭定时器T1
  255.                         write_com(0x80);
  256.                         for(j=0;j<16;j++)
  257.                         {
  258.                                 write_data(old_table[j]);//显示"Please input Old"
  259.                                 delay_us(100);       
  260.                         }
  261.                         write_com(0xc0);
  262.                         for(j=0;j<16;j++)
  263.                         {
  264.                                 write_data(table3[j]);         //显示"password:       "
  265.                                 delay_us(10);       
  266.                         }
  267.                         start4x4=1;        //修改密码等待有效
  268.                         while(start4x4==1)         //等待数字键按下作为密码输入
  269.                         {
  270.                                 key4x4();                 //只对数字按键和取消按键有效
  271.                                 if(key_valu==1)         //在输入密码过程中,可以随时去取消输入重来
  272.                                 {
  273.                                         ok=0;                 //取消按键误动作
  274.                                         quxiao=0;
  275.                                         key_valu=0;
  276.                                         start_stop=0;
  277.                                         xiugaimima=0; been(); //输入密码提示音
  278.                                         write_com(0xca+num);          //显示输入密码
  279.                                         write_data(key_table[i]); //显示对应的数字密码,
  280.                                         write_com(0xca+num);          //显示输入密码 ,调到键盘松开之后可以显示数字
  281.                                         write_data(xing_tab[0]); //用*号代替保密   但是需要将前面两个注释去掉
  282.                                         dumima_tab2[num]=key_table2[i];        //将输入的密码进行保存以便核对
  283.                                         while(dengdai==1)        //将P1端口的值读出判断按键是否松开,
  284.                                         {
  285.                                                 tem=P1;
  286.                                                 if(tem!=0xf0)         dengdai=1;                //按下就继续等待
  287.                                                 else                         dengdai=0;                //松开就返回
  288.                                         }
  289.                                         num++;                            //显示下一个字符
  290.                                         if(num==6)           //按下6个数字的操作,等待确认和取下
  291.                                         {
  292.                                                 num=0; dengdai_

Copyright © 2017-2020 微波EDA网 版权所有

网站地图

Top