久久久久久久999_99精品久久精品一区二区爱城_成人欧美一区二区三区在线播放_国产精品日本一区二区不卡视频_国产午夜视频_欧美精品在线观看免费

 找回密碼
 立即注冊

QQ登錄

只需一步,快速開始

搜索
查看: 9150|回復: 5
收起左側

51單片機密碼鎖+1602顯示+繼電器驅動+蜂鳴器+鍵盤 PCB文件

  [復制鏈接]
ID:515975 發表于 2021-1-20 22:06 | 顯示全部樓層 |閱讀模式
(1)本設計為了防止密碼被竊取在輸入密碼時在LCD屏幕上顯示*號。
(2)設計開鎖密碼位六位密碼的電子密碼鎖。
(3)能夠LCD顯示在密碼正確時顯示OPEN,密碼錯誤時顯示 Error。
(4)實現輸入密碼錯誤超過限定的五次電子密碼鎖定。
(5)4×4的矩陣鍵盤其中包括0-9的數字鍵、*、#和A-D的功能鍵。
(6)本設計具備報警功能,當輸入密碼錯誤時蜂鳴器響。
(7)密碼可以修改設定(只支持6位密碼),按修改密碼鍵修改密碼,在輸入新密碼

Altium Designer畫的原理圖和PCB圖如下:(51hei附件中可下載工程文件)
51hei.png

51hei.png

仿真原理圖如下(proteus仿真工程文件可到本帖附件中下載)
51hei圖片20210120220241.png

單片機源程序如下:
  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. #define uchar unsigned char       
  9. #define uint unsigned int          

  10. sbit led=P3^6; //繼電器接口
  11. uint dumima,old_mima,new_mima,shige;
  12. uchar code chushimima_tab[]={1,2,3,4,5,6};        //設第一次初始密碼為123456
  13. uchar data dumima_tab1[6]={0};                //從24C02中讀取寫入的初始或修改的密碼保存
  14. uchar data dumima_tab2[6]={0};                // 保存讀取的密碼
  15. uchar data shurumima_tab1[6]={0};        //保存輸入的密碼,以便和讀取的密碼對比
  16. uchar data shurumima_tab2[6]={0};        //保存輸入的密碼,以便和讀取的密碼對比
  17. void main()
  18. {
  19.         uchar j,mm=5;  //j顯示位置字符,mm報警次數計數及輸入錯誤機會為5次
  20.         led=1;
  21.         speak=1;
  22.         init();           //1602初始化
  23.         jiemian(); //1602顯示界面
  24.         ding_time=50000;  //設T1定時器定時50ms
  25.         timer1_init( );         
  26.         TR1=1;                                       
  27.         dumima=AT24C02_read_byte(0x02);//判斷24c02是否寫入初始或修改的密碼
  28.         if(dumima!=1)                  //如果不等于1,判斷沒寫初始或修改的密碼,需要寫入
  29.         {
  30.                 AT24C02_write_byte(0x02,0x01); //在第2個地址中寫入1,以便判斷下次不用寫入
  31.                 delay_ms(10);         
  32.                 for(j=0;j<6;j++)
  33.                 {                                        //從第4個地址開始寫初始密碼數據
  34.                         AT24C02_write_byte(j+4,chushimima_tab[j]);
  35.                         delay_ms(10);         
  36.                 }
  37.         }
  38.         for(j=0;j<6;j++)  
  39.         {                                        //從24C02中讀取寫入的初始或修改的密碼保存
  40.                 dumima_tab1[j]=AT24C02_read_byte(j+4);
  41.                 delay_ms(10);         
  42.         }                                  
  43.         been();
  44.         while(1)
  45.         {
  46.                 key4x4();        //查詢按鍵是否有按下,只對啟動和修改密碼鍵有效
  47.                 if(start_stop==1)  //啟動按鍵輸入密碼
  48.                 {
  49.                         ok=0;                 //取消其他按鍵誤動作及退出判斷
  50.                         quxiao=0;
  51.                         key_valu=0;
  52.                         xiugaimima=0;  
  53.                         start_stop=0;
  54.                         TR1=0;
  55.                         been();         
  56.                         write_com(0x80);        //第一行顯示“Please input You”
  57.                         for(j=0;j<16;j++)
  58.                         {
  59.                                 write_data(you_table[j]);
  60.                                 delay_us(10);
  61.                         }
  62.                         write_com(0xc0);        //第二行顯示“Password:                 ”
  63.                         for(j=0;j<16;j++)
  64.                         {
  65.                                 write_data(table3[j]);
  66.                                 delay_us(10);
  67.                         }
  68.                         num=0; start4x4=1;         //num輸入顯示計數位置設置及等待輸入密碼循環開始
  69.                         while(start4x4==1)         //等待鍵按下
  70.                         {
  71.                                 key4x4();                 //只對數字按鍵和取消按鍵有效
  72.                                 if(key_valu==1)         //在輸入密碼過程中,可以隨時取消輸入重來
  73.                                 {                                 //但是輸入滿6位時不能取消,必須按確認鍵
  74.                                         ok=0;                 
  75.                                         quxiao=0;
  76.                                         key_valu=0;
  77.                                         xiugaimima=0;  
  78.                                         start_stop=0;
  79.                                         been();         //輸入按鍵提示聲音
  80.                                         write_com(0xca+num);          //第二行顯示輸入的密碼
  81.                                         write_data(xing_tab[0]); //用*號代替數字保密
  82.                                         dumima_tab2[num]=key_table2[i];        //將輸入的密碼進行保存以便核對
  83.                                         while(dengdai==1)        //判斷按鍵是否松開,
  84.                                         {
  85.                                                 tem=P1;
  86.                                                 if(tem!=0xf0) dengdai=1;                //按下就繼續等待
  87.                                                 else                 dengdai=0;                //松開就返回
  88.                                         }
  89.                                         num++;                            
  90.                                         if(num==6)          //按下6個數字,等待確認鍵按下
  91.                                         {
  92.                                                 num=0; start4x4=0;dengdai_ok=1;         //進入下一個顯示環節,等待按確認鍵確認密碼
  93.                                                 while(dengdai_ok==1)
  94.                                                 {
  95.                                                            key4x4();
  96.                                                         if(ok==1) //確認按鍵按下,進行密碼對比
  97.                                                         {
  98.                                                                 ok=0;               
  99.                                                                 quxiao=0;
  100.                                                                 key_valu=0;
  101.                                                                 xiugaimima=0;  dengdai_ok=0;
  102.                                                                 start_stop=0;       
  103.                                                                 if(dumima_tab2[0]==dumima_tab1[0]&&dumima_tab2[1]==dumima_tab1[1]
  104.                                                                  &&dumima_tab2[2]==dumima_tab1[2]&&dumima_tab2[3]==dumima_tab1[3]
  105.                                                                  &&dumima_tab2[4]==dumima_tab1[4]&&dumima_tab2[5]==dumima_tab1[5])
  106.                                                                  {       
  107.                                                                         been();          
  108.                                                                         baojing=0; mm=5;   
  109.                                                                         write_com(0xc0);        //第二行顯示:Password: 0pen!
  110.                                                                         for(j=0;j<16;j++)
  111.                                                                         {
  112.                                                                                 write_data(table4[j]);
  113.                                                                                 delay_us(10);
  114.                                                                         }
  115.                                                                         led=0;       
  116.                                                                         delay_ms(5000);       
  117.                                                                         jiemian();              
  118.                                                                         TR1=1; time=0;xian1=0;xian2=1; //啟動定時器開鎖工作
  119.                                                                         delay_ms(5000);led=1;         //指示燈延時5秒之后關閉
  120.                                                                 }
  121.                                                                 else         //密碼錯誤
  122.                                                                 {
  123.                                                                         been();delay_ms(50);been();delay_ms(500); //輸入密碼錯誤提示
  124.                                                                         write_com(0xc0);        //第二行顯示:Password: Error!
  125.                                                                         for(j=0;j<16;j++)
  126.                                                                         {
  127.                                                                                 write_data(table5[j]);
  128.                                                                                 delay_us(10);
  129.                                                                         }
  130.                                                                            delay_ms(2000);
  131.                                                                         mm--;                          //輸入機會減少1次
  132.                                                                         if(mm>0)           //少于5次時顯示輸入機會
  133.                                                                         {
  134.                                                                                 write_com(0x80);//第二行顯示" Sorry! You have"
  135.                                                                                 for(j=0;j<16;j++)
  136.                                                                                 {
  137.                                                                                         write_data(chan_tab1[j]);
  138.                                                                                         delay_us(10);
  139.                                                                                 }
  140.                                                                                 write_com(0xc0);
  141.                                                                                 for(j=0;j<16;j++)         //清除第二行內容
  142.                                                                                 {
  143.                                                                                         write_data(kong_tabb[j]);
  144.                                                                                         delay_us(10);
  145.                                                                                 }
  146.                                                                                 write_com(0xc3);        //第二行顯示"12345“
  147.                                                                                 write_data(chan_tab3[mm]);
  148.                                                                                 delay_us(5);
  149.                                                                                 write_com(0xc7);        //第二行顯示"       Chance!!!"
  150.                                                                                 for(j=0;j<9;j++)
  151.                                                                                 {
  152.                                                                                         write_data(chan_tab2[j]);
  153.                                                                                         delay_us(10);
  154.                                                                                 }
  155.                                                                                 delay_ms(5000);
  156.                                                                                 start_stop=1;  //返回繼續等待重新輸入密碼開鎖
  157.                                                                         }                                                                          
  158.                                                                         else  //輸錯5次報警
  159.                                                                         {
  160.                                                                                 been();delay_ms(50);been();delay_ms(50);been();delay_ms(500);
  161.                                                                                 P1=0x00;mm=1; //鎖定鍵盤,同時限制輸入次數只能為1次
  162.                                                                                 jiemian();                 
  163.                                                                                 TR1=1; time=0;xian1=0;xian2=1;
  164.                                                                                 baojing=1;  
  165.                                                                                 speaker();          //蜂鳴器報警
  166.                                                                                 for(j=0;j<20;j++)         //延時20秒不輸入,鎖定鍵盤
  167.                                                                                 {                                         
  168.                                                                                         delay_ms(1000);
  169.                                                                                 }                                //延時時間到重啟輸入,但是只給一次機會
  170.                                                                                 TR1=0;         
  171.                                                                                 write_com(0x80);       
  172.                                                                                 for(j=0;j<16;j++)
  173.                                                                                 {
  174.                                                                                         write_data(chan_tab1[j]);
  175.                                                                                         delay_us(10);
  176.                                                                                 }
  177.                                                                                 write_com(0xc0);         
  178.                                                                                 for(j=0;j<16;j++)       
  179.                                                                                 {
  180.                                                                                         write_data(kong_tabb[j]);
  181.                                                                                         delay_us(10);
  182.                                                                                 }
  183.                                                                                 write_com(0xc1);
  184.                                                                                 write_data(chan_tab3[mm]);
  185.                                                                                 delay_us(5);
  186.                                                                                 write_com(0xc3);       
  187.                                                                                 for(j=0;j<9;j++)
  188.                                                                                 {
  189.                                                                                         write_data(chan_tab2[j]);
  190.                                                                                         delay_us(10);
  191.                                                                                 }
  192.                                                                                 write_com(0xcd);        //第二行顯示"             ok?"
  193.                                                                                 for(j=0;j<3;j++)
  194.                                                                                 {
  195.                                                                                         write_data(ok_tab[j]);       
  196.                                                                                         delay_us(10);
  197.                                                                                 }
  198.                                                                                 delay_ms(2000);
  199.                                                                                 dengdai_ok=1; been();delay_ms(50);been();delay_ms(50);been();delay_ms(500);
  200.                                                                                 while(dengdai_ok==1)  //提示最后輸入密碼
  201.                                                                                 {
  202.                                                                                         key4x4();
  203.                                                                                         if(ok==1)          
  204.                                                                                         {
  205.                                                                                                 ok=0;                 
  206.                                                                                                 quxiao=0;
  207.                                                                                                 key_valu=0;
  208.                                                                                                 start_stop=0;  
  209.                                                                                                 dengdai_ok=0;
  210.                                                                                                 start_stop=1;  
  211.                                                                                         }
  212.                                                                                 }
  213.                                                                         }
  214.                                                                 }
  215.                                                         }
  216.                                                 }
  217.                                         }
  218.                                 }
  219.                                 if(quxiao==1)          //按下取消按鍵
  220.                                 {
  221.                                         ok=0;               
  222.                                         quxiao=0;
  223.                                         key_valu=0;
  224.                                         xiugaimima=0;  
  225.                                         start_stop=0;
  226.                                         dengdai_ok=0; start4x4=0;  been();
  227.                                         jiemian();          
  228.                                         TR1=1;time=0;xian1=0;xian2=1;
  229.                                         while(dengdai==1)        //判斷按鍵是否松開,
  230.                                         {
  231.                                                 tem=P1;
  232.                                                 if(tem!=0xf0)         dengdai=1;                //按下就繼續等待
  233.                                                 else                         dengdai=0;                //松開就返回
  234.                                         }
  235.                                 }
  236.                         }
  237.                 }

  238. /**********************修改密碼程序        ******************/
  239.                 if(xiugaimima==1)       
  240.                 {
  241.                         ok=0;               
  242.                         quxiao=0;
  243.                         key_valu=0;
  244.                         start_stop=0;
  245.                         xiugaimima=0; been();       
  246.                         TR1=0;
  247.                         write_com(0x80);
  248.                         for(j=0;j<16;j++)
  249.                         {
  250.                                 write_data(old_table[j]);//顯示"Please input Old"
  251.                                 delay_us(100);       
  252.                         }
  253.                         write_com(0xc0);
  254.                         for(j=0;j<16;j++)
  255.                         {
  256.                                 write_data(table3[j]);         //顯示"password:       "
  257.                                 delay_us(10);       
  258.                         }
  259.                         start4x4=1;
  260.                         while(start4x4==1)         //等待密碼輸入
  261.                         {
  262.                                 key4x4();                 //只對數字按鍵和取消按鍵有效
  263.                                 if(key_valu==1)         //在輸入密碼過程中,可隨時去取消輸入重來
  264.                                 {
  265.                                         ok=0;                 
  266.                                         quxiao=0;
  267.                                         key_valu=0;
  268.                                         start_stop=0;
  269.                                         xiugaimima=0; been();
  270.                                         write_com(0xca+num);          
  271.                                         write_data(key_table[i]); //顯示密碼,
  272.                                         write_com(0xca+num);         
  273.                                         write_data(xing_tab[0]); //用*號代替保密
  274.                                         dumima_tab2[num]=key_table2[i];        //將輸入的密碼進行保存以便核對
  275.                                         while(dengdai==1)        //判斷按鍵是否松開
  276.                                         {
  277.                                                 tem=P1;
  278.                                                 if(tem!=0xf0)         dengdai=1;                //按下就繼續等待
  279.                                                 else                         dengdai=0;                //松開就返回
  280.                                         }
  281.                                         num++;                           
  282.                                         if(num==6)           
  283.                                         {
  284.                                                 num=0; dengdai_ok=1;start4x4=0;
  285.                                                 while(dengdai_ok==1)
  286.                                                 {
  287.                                                            key4x4();
  288.                                                         if(ok==1) //確認按鍵按下,進行密碼對比
  289.                                                         {
  290.                                                                 ok=0;                 
  291.                                                                 quxiao=0;
  292.                                                                 key_valu=0;
  293.                                                                 xiugaimima=0;  dengdai_ok=0;
  294.                                                                 start_stop=0;         //密碼對比判斷是否正確
  295.                                                                 if(dumima_tab2[0]==dumima_tab1[0]&&dumima_tab2[1]==dumima_tab1[1]
  296.                                                                  &&dumima_tab2[2]==dumima_tab1[2]&&dumima_tab2[3]==dumima_tab1[3]
  297.                                                                  &&dumima_tab2[4]==dumima_tab1[4]&&dumima_tab2[5]==dumima_tab1[5] )
  298.                                                                 {         //密碼正確
  299.                                                                         been();
  300.                                                                         mm=5;
  301.                                                                         write_com(0x80);
  302.                                                                         for(j=0;j<16;j++)
  303.                                                                         {
  304.                                                                                 write_data(new_table[j]);//顯示"Please input New"
  305.                                                                                 delay_us(10);       
  306.                                                                         }
  307.                                                                         write_com(0xc0);
  308.                                                                         for(j=0;j<16;j++)
  309.                                                                         {
  310.                                                                                 write_data(table3[j]);         //顯示"password:       "
  311.                                                                                 delay_us(10);       
  312.                                                                         }
  313.                                                                         old_mima=1;
  314.                                                                         while(old_mima==1)
  315.                                                                         {
  316.                                                                                 key4x4();                 //只對數字按鍵和取消按鍵有效
  317.                                                                                 if(key_valu==1)         //在輸入密碼過程中,可隨時取消輸入重來
  318.                                                                                 {
  319.                                                                                         ok=0;                 
  320.                                                                                         quxiao=0;
  321.                                                                                         key_valu=0;
  322.                                                                                         xiugaimima=0;  
  323.                                                                                         start_stop=0;         been();
  324.                                                                                         write_com(0xca+num);          
  325.                                                                                         write_data(key_table[i]);
  326.                                                                                         write_com(0xca+num);
  327.                                                                                         write_data(xing_tab[0]); //用*號代替保密
  328.                                                                                         shurumima_tab1[num]=key_table2[i];        //將輸入的密碼進行保存以便核對
  329.                                                                                         while(dengdai==1)        //判斷按鍵是否松開,
  330.                                                                                         {
  331.                                                                                                 tem=P1;
  332.                                                                                                 if(tem!=0xf0)         dengdai=1;                //按下就繼續等待
  333.                                                                                                 else                         dengdai=0;                //松開就返回
  334.                                                                                         }
  335.                                                                                         num++;                           
  336.                                                                                         if(num==6)           
  337.                                                                                         {
  338.                                                                                                 num=0; dengdai_ok=1;old_mima=0;
  339.                                                                                                 while(dengdai_ok==1)
  340.                                                                                                 {
  341.                                                                                                            key4x4();
  342.                                                                                                         if(ok==1)
  343.                                                                                                         {
  344.                                                                                                                 ok=0;                 
  345.                                                                                                                 quxiao=0;
  346.                                                                                                                 key_valu=0;
  347.                                                                                                                 xiugaimima=0;  
  348.                                                                                                                 start_stop=0;       
  349.                                                                                                                 dengdai_ok=0;          been();
  350.                                                                                                                  write_com(0x80);
  351.                                                                                                                 for(j=0;j<16;j++)
  352.                                                                                                                 {
  353.                                                                                                                         write_data(agn_table[j]);//顯示" Again input new"
  354.                                                                                                                         delay_us(10);       
  355.                                                                                                                 }
  356.                                                                                                                 write_com(0xc0);
  357.                                                                                                                 for(j=0;j<16;j++)
  358.                                                                                                                 {
  359.                                                                                                                         write_data(table3[j]);        //顯示"password:       "
  360.                                                                                                                         delay_us(10);       
  361.                                                                                                                 }
  362.                                                                                                                 while(dengdai==1)        //判斷按鍵是否松開,
  363.                                                                                                                 {
  364.                                                                                                                         tem=P1;
  365.                                                                                                                         if(tem!=0xf0)         dengdai=1;                //按下就繼續等待
  366.                                                                                                                         else                         dengdai=0;                //松開就返回
  367.                                                                                                                 }
  368.                                                                                                                 new_mima=1;  
  369.                                                                                                                 while(new_mima==1)
  370.                                                                                                                 {
  371.                                                                                                                         key4x4();                 //只對數字按鍵和取消按鍵有效
  372.                                                                                                                         if(key_valu==1)         //在輸入密碼過程中,可隨時取消輸入重來
  373.                                                                                                                         {
  374.                                                                                                                                 ok=0;                 
  375.                                                                                                                                 quxiao=0;
  376.                                                                                                                                 key_valu=0;
  377.                                                                                                                                 xiugaimima=0;  
  378.                                                                                                                                 start_stop=0;        been(); //輸入提示音
  379.                                                                                                         //                        write_com(0xca+num);         
  380.                                                                                                         //                        write_data(key_table[i]); //顯示密碼,
  381.                                                                                                                                 write_com(0xca+num);         
  382.                                                                                                                                 write_data(xing_tab[0]); //用*號代替保密
  383.                                                                                                                                 shurumima_tab2[num]=key_table2[i];        //將輸入的密碼進行保存以便核對
  384.                                                                                                                                 while(dengdai==1)        //判斷按鍵是否松開,
  385.                                                                                                                                 {
  386.                                                                                                                                         tem=P1;
  387.                                                                                                                                         if(tem!=0xf0)         dengdai=1;                //按下就繼續等待
  388.                                                                                                                                         else                         dengdai=0;                //松開就返回
  389.                                                                                                                                 }
  390.                                                                                                                                 num++;                           
  391.                                                                                                                                 if(num==6)           
  392.                                                                                                                                 {
  393.                                                                                                                                         num=0; dengdai_ok=1; new_mima=0;
  394.                                                                                                                                         while(dengdai_ok==1)
  395.                                                                                                                                         {
  396.                                                                                                                                                    key4x4();
  397.                                                                                                                                                 if(ok==1)
  398.                                                                                                                                                 {
  399.                                                                                                                                                         ok=0;               
  400.                                                                                                                                                         quxiao=0;
  401.                                                                                                                                                         key_valu=0;
  402.                                                                                                                                                         xiugaimima=0;  
  403.                                                                                                                                                         start_stop=0;         
  404.                                                                                                                                                         dengdai_ok=0;
  405.                                                                                                                                                         if(shurumima_tab1[0]==shurumima_tab2[0]&&shurumima_tab1[1]==shurumima_tab2[1]&&
  406.                                                                                                                                                            shurumima_tab1[2]==shurumima_tab2[2]&&shurumima_tab1[3]==shurumima_tab2[3]&&
  407.                                                                                                                                                            shurumima_tab1[4]==shurumima_tab2[4]&&shurumima_tab1[5]==shurumima_tab2[5]   )
  408.                                                                                                                                                         {                //判斷兩次輸入的密碼是否一樣,一樣就寫入24c02,否則就報錯。                                       
  409.                                                                                                                                                                 been();
  410.                                                                                                                                                                 AT24C02_write_byte(2,1); //在第2個地址中寫入1,以便判斷下次不用寫入
  411.                                                                                                                                                                 delay_ms(10);
  412.                                                                                                                                                                 for(j=0;j<6;j++)
  413.                                                                                                                                                                 {                                        //從第4個地址開始寫初始密碼數據
  414.                                                                                                                                                                         AT24C02_write_byte(j+4,shurumima_tab1[j]);
  415.                                                                                                                                                                         delay_ms(10);         
  416.                                                                                                                                                                 }
  417.                                                                                                                                                        
  418.                                                                                                                                                                    for(j=0;j<6;j++)  
  419.                                                                                                                                                                 {                                        //從24C02中讀取寫入的初始或修改的密碼保存
  420.                                                                                                                                                                         dumima_tab1[j]=AT24C02_read_byte(j+4);
  421.                                                                                                                                                                         delay_ms(10);
  422.                                                                                                                                                                     write_com(0x80);
  423.                                                                                                                                                                 }
  424.                                                                                                                                                                 for(j=0;j<16;j++)
  425.                                                                                                                                                                 {
  426.                                                                                                                                                                         write_data(cag_table[j]);//顯示"Changed password"
  427.                                                                                                                                                                         delay_us(10);       
  428.                                                                                                                                                                 }
  429.                                                                                                                                                                 write_com(0xc0);
  430.                                                                                                                                                                 for(j=0;j<16;j++)
  431.                                                                                                                                                                 {
  432.                                                                                                                                                                         write_data(suc_table[j]);//顯示" You Successful ";
  433.                                                                                                                                                                         delay_us(10);       
  434.                                                                                                                                                                 }
  435.                                                                                                                                                                 delay_ms(3000);       
  436.                                                                                                                                                                  jiemian();       
  437.                                                                                                                                                                 TR1=1;time=0;xian1=0;xian2=1;
  438.                                                                                                                                                                    while(dengdai==1)        //判斷按鍵是否松開,
  439.                                                                                                                                                                 {
  440.                                                                                                                                                                         tem=P1;
  441.                                                                                                                                                                         if(tem!=0xf0)         dengdai=1;                //按下就繼續等待
  442.                                                                                                                                                                         else                         dengdai=0;                //松開就返回
  443.                                                                                                                                                                 }
  444.                                                                                                                                                         }
  445.                                                                                                                                                         else  //兩次輸入密碼不一致
  446.                                                                                                                                                         {
  447.                                                                                                                                                                 been();        delay_ms(50);been();delay_ms(500);
  448.                                                                                                                                                                 write_com(0x80);
  449.                                                                                                                                                                 for(j=0;j<16;j++)
  450.                                                                                                                                                                 {
  451.                                                                                                                                                                         write_data(diff_tab1[j]);//顯示" 2 New passwords"
  452.                                                                                                                                                                         delay_us(10);       
  453.                                                                                                                                                                 }
  454.                                                                                                                                                                 write_com(0xc0);
  455.                                                                                                                                                                 for(j=0;j<16;j++)
  456.                                                                                                                                                                 {
  457.                                                                                                                                                                         write_data(diff_tab2[j]);//顯示"are different!!!"
  458.                                                                                                                                                                         delay_us(10);       
  459.                                                                                                                                                                 }         
  460.                                                                                                                                                                 delay_ms(2000);
  461.                                                                                                                                                                 write_com(0x80);
  462.                                                                                                                                                                 for(j=0;j<16;j++)
  463.                                                                                                                                                                 {
  464.                                                                                                                                                                         write_data(new_table[j]);//顯示"Please input New"
  465.                                                                                                                                                                         delay_us(10);       
  466.                                                                                                                                                                 }
  467.                                                                                                                                                                 write_com(0xc0);
  468.                                                                                                                                                                 for(j=0;j<16;j++)
  469.                                                                                                                                                                 {
  470.                                                                                                                                                                         write_data(table3[j]);         //顯示"password:       "
  471.                                                                                                                                                                         delay_us(10);       
  472.                                                                                                                                                                 }
  473.                                                                                                                                                                 delay_ms(2000);
  474.                                                                                                                                                                 old_mima=1;        been();  
  475.                                                                                                                                                         }
  476.                                                                                                                                                 }
  477.                                                                                                                                         }
  478.                                                                                                                                 }
  479.                                                                                                                         }
  480.                                                                                                                         if(quxiao==1)          //按下取消按鍵
  481.                                                                                                                         {
  482.                                                                                                                                 ok=0;num=0;               
  483.                                                                                                                                 quxiao=0;
  484.                                                                                                                                 key_valu=0;
  485.                                                                                                                                 xiugaimima=0;  
  486.                                                                                                                                 start_stop=0;
  487.                                                                                                                                 dengdai_ok=0; start4x4=0; old_mima=0;new_mima=0;
  488.                                                                                                                                 jiemian();
  489.                                                                                                                                 TR1=1;time=0;xian1=0;xian2=1;
  490.                                                                                                                                 been();
  491.                                                                                                                                 while(dengdai==1)        //判斷按鍵是否松開,
  492.                                                                                                                                 {
  493.                                                                                                                                         tem=P1;
  494.                                                                                                                                         if(tem!=0xf0)         dengdai=1;                //按下就繼續等待
  495.                                                                                                                                         else                         dengdai=0;                //松開就返回
  496.                                                                                                                                 }
  497. ……………………

  498. …………限于本文篇幅 余下代碼請從51黑下載附件…………
復制代碼

所有資料51hei提供下載:
密碼鎖原理圖及PCB.zip (112.6 KB, 下載次數: 247)

評分

參與人數 1黑幣 +50 收起 理由
admin + 50 共享資料的黑幣獎勵!

查看全部評分

回復

使用道具 舉報

ID:100749 發表于 2022-4-28 09:57 | 顯示全部樓層
下載試用,非常好的程序
回復

使用道具 舉報

ID:1008194 發表于 2022-5-15 10:08 | 顯示全部樓層
繼電器有什么用哇,沒有繼電器不也是一樣的嘛
回復

使用道具 舉報

ID:1027639 發表于 2022-5-20 00:04 | 顯示全部樓層
這個挺實用的
回復

使用道具 舉報

ID:1027639 發表于 2022-5-20 00:06 | 顯示全部樓層
為啥蜂鳴器不響呀
回復

使用道具 舉報

ID:825397 發表于 2022-5-26 20:09 | 顯示全部樓層
好像運行不了,按啟動B鍵無效
回復

使用道具 舉報

您需要登錄后才可以回帖 登錄 | 立即注冊

本版積分規則

手機版|小黑屋|51黑電子論壇 |51黑電子論壇6群 QQ 管理員QQ:125739409;技術交流QQ群281945664

Powered by 單片機教程網

快速回復 返回頂部 返回列表
主站蜘蛛池模板: 欧美一级在线免费观看 | 成人在线欧美 | 黄色大片在线 | 精品久久香蕉国产线看观看亚洲 | 亚洲欧美综合精品久久成人 | 一区二区三区四区在线视频 | 日韩一区二区三区在线视频 | 日本国产精品视频 | 欧美一区二区视频 | 日韩成人在线播放 | 日韩在线一区二区三区 | 综合久久综合久久 | 黄色片免费看视频 | 亚洲精品中文字幕av | 欧美一级做性受免费大片免费 | 国产精品视频一二三区 | 成人av在线播放 | 国产欧美精品一区二区三区 | 国产观看 | 在线一区视频 | 青娱乐av | av片在线免费看 | 国产真实乱对白精彩久久小说 | 中文字幕视频在线免费 | 91精品国产乱码久久久久久久久 | 亚洲视频在线一区 | 亚洲一区网站 | 精品欧美乱码久久久久久1区2区 | 国产精品久久 | 欧美中文字幕一区二区三区亚洲 | 亚洲精品白浆高清久久久久久 | 玖玖色在线视频 | 欧美九九九| 亚洲视屏| 久久久人| 精品在线看 | 中文字幕亚洲视频 | 久久福利网站 | 狠狠色狠狠色综合日日92 | 日韩精品一区二区三区在线观看 | 国产精品综合 |