找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 2402|回复: 0
收起左侧

基于单片机+LCD1602的简易电子密码锁程序

[复制链接]
ID:427492 发表于 2019-5-13 19:53 | 显示全部楼层 |阅读模式
//程序移植时,请注意修改I/O端口
  1. /*-----------------------------------------------
  2.   名称:基于1602的简易密码锁
  3.   描述:当密码验证正确后,会在1602上显示: password right!  
  4.           密码验证错误时,会在1602上显示: password error!
  5.   矩阵按键分布:        0  1  2  3
  6.                                         4  5  6  7
  7.                                         8  9  10 11
  8.                                         12 13 14 15
  9.                                        
  10.   矩阵按键功能:11:功能选择界面     0:输入密码开锁界面(这里以1602显示password right!代表开锁成功)
  11.                                 13:修改密码界面     1~9:为密码元素       15:验证密码
  12.                                 14:撤销误操作输入的错误密码元素
  13.   具体流程如下:  
  14.                 程序烧录到单片机后,1602会显示:“ Welcome!     Input password! ”
  15.                                 这时按按键11,进入功能选择界面,1602会显示:“ 0:enter mima       13:alter mima ”
  16.                                 如果按按键0,1602会显示:“ password: ”
  17.                                     那么此时你就可以按按键1~9输入密码(我的初始密码为12345678)输入完成后按按键15,
  18.                                         如果密码正确,1602会显示:“ password right! ”,否则,1602显示:“ password error! ”。
  19.                                         这时可以再按按键0,重新输入密码。
  20.                                 在1602显示:“ password right! ”或“ password error! ”状态下,按按键11,返回功能界面。
  21.                                 如果按按键13,1602会显示:“ old password: ”,这时需要输入旧密码(我这里输入12345678);
  22.                                     输入完成后按按键15,如果旧密码正确,1602会快速显示:“ oldpassword right! ”,然后显示:
  23.                                         “ new password: ”,这时输入8位新密码后,1602会显示:“ alter success! ”。这时按按键11,返回
  24.                                         功能界面。
  25.                                 
  26. ------------------------------------------------*/
  27. #include <stc8.h> //包含头文件,一般情况不需要改动,头文件包含特殊功能寄存器的定义
  28. #include <stdio.h>
  29. #include "1602.h"
  30. #include "delay.h"
  31. #include "key.h"
  32. #include "intrins.h"
  33. #include "AT24C0X.h"

  34. unsigned char password[8]={1,2,3,4,5,6,7,8};// 可以更改此密码做多组测试
  35. u16 bool = 0;
  36. /*------------------------------------------------
  37.                     主程序
  38. ------------------------------------------------*/
  39. void main()
  40. {
  41.         unsigned char keyvalue = '#',i=0,j=0,val=0x00;                  
  42.         bit Flag=0 , flag=0 ,flag_ok=0,flag_enter=0;    // Flag用于判断密码对错标志,flag用于是否进入密码输入界面
  43.         u8 table[8] = {0};            // 用于接收输入的密码,用于与设定的密码进行对比工作
  44.         u8 newtable[8] = {0};   // 用于存储输入的新密码
  45.         // 将初始化密码写入AT24C04中
  46.         write_24c04(0x00,password[0]);
  47.         DELAY();
  48.         write_24c04(0x01,password[1]);
  49.         DELAY();
  50.         write_24c04(0x02,password[2]);
  51.         DELAY();
  52.         write_24c04(0x03,password[3]);
  53.         DELAY();
  54.         write_24c04(0x04,password[4]);
  55.         DELAY();
  56.         write_24c04(0x05,password[5]);
  57.         DELAY();
  58.         write_24c04(0x06,password[6]);
  59.         DELAY();
  60.         write_24c04(0x07,password[7]);
  61.         DELAY();
  62.         LCD_Init();                              // 初始化液晶屏
  63.         DelayMs(10);                             // 延时用于稳定,可以去掉
  64.         LCD_Clear();                             // 清屏
  65.         LCD_Write_String(0,0,"    Welcome!");    // 写入第一行信息,主循环中不再更改此信息,所以在while之前写入
  66.         LCD_Write_String(0,1,"Input password!"); // 写入第二行信息,提示输入密码
  67.         while (1)                                // 主循环
  68.         {
  69.                 keyvalue = key_scan();               // 扫描键盘
  70.                 if(keyvalue == 11)
  71.                 {
  72.                         LCD_Clear();
  73.                         LCD_Write_String(0,0,"0 : enter mima");
  74.                         LCD_Write_String(0,1,"13: alter mima");
  75.                         flag = 1;
  76.                 }
  77.                 // 进入密码输入界面
  78.                 if((keyvalue == 0) && (flag==1))                    
  79.                 {
  80.                         LCD_Clear();
  81.                         LCD_Write_String(0,0,"password:");
  82.                         i=0;
  83.                         flag=2;
  84.                         while(1)
  85.                         {
  86.                                 keyvalue = key_scan();
  87.                                 
  88.                                 if((keyvalue != '#') && (flag==2))   // 输入的密码显示
  89.                                 {
  90.                                         if(keyvalue > 0 && keyvalue <= 9)
  91.                                         {
  92.                                                 switch(bool)
  93.                                                 {
  94.                                                 case 0:
  95.                                                                 if(i==8)
  96.                                                                 {
  97.                                                                         i=0;break;
  98.                                                                 }
  99.                                                                 table[i]=keyvalue;
  100.                                                                 LCD_Write_Com(0xc0+i);
  101.                                                                 LCD_Write_Data(0x30+keyvalue);
  102.                                                                 i++;
  103.                                                                 DelayMs(300);                                                        
  104.                                                                 break;
  105.                                                 }
  106.                                         }
  107.                                 }
  108.                                 if((keyvalue == 15)&&(flag==2))       // 验证密码
  109.                                 {
  110.                                         val = 0x00;
  111.                                         // 从at24c04中读出密码
  112.                                         password[0] = read_24c04(0x00);
  113.                                         DELAY();
  114.                                         password[1] = read_24c04(0x01);
  115.                                         DELAY();
  116.                                         password[2] = read_24c04(0x02);
  117.                                         DELAY();
  118.                                         password[3] = read_24c04(0x03);
  119.                                         DELAY();
  120.                                         password[4] = read_24c04(0x04);
  121.                                         DELAY();
  122.                                         password[5] = read_24c04(0x05);
  123.                                         DELAY();
  124.                                         password[6] = read_24c04(0x06);
  125.                                         DELAY();
  126.                                         password[7] = read_24c04(0x07);
  127.                                         DELAY();
  128.                                         if(i != 0)
  129.                                         {
  130.                                                 for(j=i;j<8;j++)
  131.                                                         table[i] = 0;
  132.                                         }
  133.                                         for(j=0;j<8;j++)
  134.                                         {
  135.                                                 if(password[j]!=table[j])
  136.                                                 {
  137.                                                         LCD_Clear();
  138.                                                         LCD_Write_String(0,0,"password error!");                                
  139.                                                         Flag = 1;                //密码错误标志
  140.                                                         i=0;
  141.                                                         //该注释代码用于密码输入错误时,查看正确密码
  142. //                                                        for(j=0;j<8;j++)
  143. //                                                        {
  144. //                                                                LCD_Write_Com(0xc0+j);
  145. //                                                                LCD_Write_Data(0x30+password[j]);
  146. //                                                        }
  147.                                                         break;
  148.                                                 }
  149.                                         }
  150.                                         if(!Flag)                        // 密码正确
  151.                                         {
  152.                                                 LCD_Clear();
  153.                                                 LCD_Write_String(0,0,"password right!");
  154.                                                 i=0;
  155.                                         }
  156.                                         Flag=0;
  157.                                         for(j=0;j<8;j++)
  158.                                                 table[j] = 0;
  159.                                         break;
  160.                                 }
  161.                                 if((keyvalue==14)&&(flag==2))        // 撤销错误密码元素
  162.                                 {
  163.                                         i=i-1;
  164.                                         table[i]=0;
  165.                                         LCD_Write_Com(0xc0+i);
  166.                                         LCD_Write_Data(' ');
  167.                                 }
  168.                         }
  169.                                                                                 
  170.                 }
  171.                 // 修改密码界面
  172.                 if((keyvalue == 13) && (flag == 1))               
  173.                 {
  174.                         LCD_Clear();
  175.                         LCD_Write_String(0,0,"old password:");
  176.                         flag=3;
  177.                         flag_ok = 0;
  178.                         flag_enter = 0;
  179.                         for(j=0;j<8;j++)
  180.                                 newtable[j]=0;
  181.                         i=0;
  182.                         while(1)
  183.                         {
  184.                                 keyvalue = key_scan();
  185.                                 if((keyvalue != '#') && (flag==3))   // 输入的密码显示
  186.                                 {
  187.                                         if(keyvalue > 0 && keyvalue <= 9)
  188.                                         {
  189.                                                 switch(bool)
  190.                                                 {
  191.                                                 case 0:
  192.                                                                 if(i==8)
  193.                                                                 {
  194.                                                                         i=0;break;
  195.                                                                 }
  196.                                                                 if(flag_ok==1)
  197.                                                                 {
  198.                                                                         newtable[i]=keyvalue;         
  199.                                                                         LCD_Write_Com(0xc0+i);
  200.                                                                         LCD_Write_Data(0x30+keyvalue);
  201.                                                                         i++;
  202.                                                                         DelayMs(300);
  203.                                                                 }
  204.                                                                 if(flag_ok==0)
  205.                                                                 {
  206.                                                                         table[i]=keyvalue;         
  207.                                                                         LCD_Write_Com(0xc0+i);
  208.                                                                         LCD_Write_Data(0x30+keyvalue);
  209.                                                                         i++;
  210.                                                                         DelayMs(300);
  211.                                                                 }        
  212.                                                                 break;
  213.                                                 }
  214.                                         }
  215.                                 }
  216.                         
  217.                                 
  218.                                 if((keyvalue == 15)&&(flag==3))       // 验证密码
  219.                                 {
  220.                                         val = 0x00;
  221.                                         for(j=0;j<8;j++)                  // 从at24c04中读出密码
  222.                                         {                                
  223.                                                 password[j] = read_24c04(val);
  224.                                                 DELAY();
  225.                                                 val = val + 0x01;
  226.                                                 if(j==8)
  227.                                                         val=0x00;
  228.                                         }
  229.                                         if((i!=0)&&(table[i]!=0))
  230.                                         {
  231.                                                 for(j=i;j<8;j++)
  232.                                                         table[j] = 0;
  233.                                         }
  234.                                         if((i!=0)&&(newtable[i]!=0))
  235.                                         {
  236.                                                 for(j=i;j<8;j++)
  237.                                                         newtable[j]=0;
  238.                                         }
  239.                                         for(j=0;j<8;j++)
  240.                                         {
  241.                                                 if(password[j]!=table[j])
  242.                                                 {
  243.                                                         LCD_Clear();
  244.                                                         LCD_Write_String(0,0,"oldpassword err!");                                
  245.                                                         Flag = 1;                //密码错误标志
  246.                                                         flag_ok = 0;
  247.                                                         i=0;
  248.                                                         break;
  249.                                                 }
  250.                                         }
  251.                                         if(!Flag)                        // 密码正确
  252.                                         {
  253.                                                 LCD_Clear();
  254.                                                 LCD_Write_String(0,0,"oldpassword ok!");
  255.                                                 DelayMs(1000);
  256.                                                 DelayMs(1000);
  257.                                                 DelayMs(1000);
  258.                                                 DelayMs(1000);
  259.                                                 flag_ok = 1;
  260.                                                 LCD_Clear();
  261.                                                 LCD_Write_String(0,0,"new password:");
  262.                                                 i=0;
  263.                                         }
  264.                                         Flag=0;
  265.                                         for(j=0;j<8;j++)
  266.                                                 table[j] = 0;
  267.                                 }
  268.                                 if((keyvalue==14)&&(flag==3))        // 撤销错误密码元素
  269.                                 {
  270. ……………………

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

  1. #include <stc8.h>            
  2. #include <stdio.h>
  3. #include "1602.h"
  4. #include "delay.h"
  5. #include "key.h"
  6. #include "intrins.h"
  7. #include "AT24C0X.h"
  8. unsigned char password[8]={1,2,3,4,5,6,7,8};          //初始密码
  9. u16 bool = 0;
  10. void main()
  11. {
  12.         unsigned char keyvalue = '#',i=0,j=0,val=0x00;                  
  13.         bit Flag=0 , flag=0 ,flag_ok=0;    // Flag标志,用于判断密码真假。flag标志,用于是进密码输入界面还是修改密码界面
  14.                                                                // flag_ok标志,用于区别此时输入的是旧密码还是新密码
  15.         u8 table[8] = {0};                               // 用于存储输入的数字,与密码比较时使用
  16.         u8 newtable[8] = {0};                        // 用于存储输入的新密码
  17.         // 将初始密码写入到at24c04中
  18.         write_24c04(0x00,password[0]);
  19.         DELAY();
  20.         write_24c04(0x01,password[1]);
  21.         DELAY();
  22.         write_24c04(0x02,password[2]);
  23.         DELAY();
  24.         write_24c04(0x03,password[3]);
  25.         DELAY();
  26.         write_24c04(0x04,password[4]);
  27.         DELAY();
  28.         write_24c04(0x05,password[5]);
  29.         DELAY();
  30.         write_24c04(0x06,password[6]);
  31.         DELAY();
  32.         write_24c04(0x07,password[7]);
  33.         DELAY();
  34.         LCD_Init();                                          // 1602液晶初始化
  35.         DelayMs(10);                           
  36.         LCD_Clear();                                       // 清屏
  37.         LCD_Write_String(0,0,"    Welcome!");     
  38.         LCD_Write_String(0,1,"Input password!")
  39.         while (1)                             
  40.         {
  41.                 keyvalue = key_scan();               // 按键扫描
  42.                 if(keyvalue == 11)
  43.                 {
  44.                         LCD_Clear();
  45.                         LCD_Write_String(0,0,"0 : enter mima");
  46.                         LCD_Write_String(0,1,"13: alter mima");
  47.                         flag = 1;

  48.                 }


  49.                 // 进入输入密码界面
  50.                 if((keyvalue == 0) && (flag==1))                    
  51.                 {
  52.                         LCD_Clear();
  53.                         LCD_Write_String(0,0,"password:");
  54.                         i=0;
  55.                         flag=2;
  56.                         while(1)
  57.                         {
  58.                                 keyvalue = key_scan();
  59.                                 
  60.                                 if((keyvalue != '#') && (flag==2))   //输入密码
  61.                                 {
  62.                                         if(keyvalue > 0 && keyvalue <= 9)
  63.                                         {
  64.                                                 switch(bool)
  65.                                                 {
  66.                                                 case 0:
  67.                                                                 if(i==8)
  68.                                                                 {
  69.                                                                         i=0;break;
  70.                                                                 }
  71.                                                                 table=keyvalue;
  72.                                                                 LCD_Write_Com(0xc0+i);
  73.                                                                 LCD_Write_Data(0x30+keyvalue);
  74.                                                                 i++;
  75.                                                                 DelayMs(300);                                                        
  76.                                                                 break;
  77.                                                 }
  78.                                         }
  79.                                 }
  80.                                 if((keyvalue == 15)&&(flag==2))       // 验证密码
  81.                                 {
  82.                                         val = 0x00;
  83.                                         // 从at24c04中读取密码
  84.                                         password[0] = read_24c04(0x00);
  85.                                         DELAY();
  86.                                         password[1] = read_24c04(0x01);
  87.                                         DELAY();
  88.                                         password[2] = read_24c04(0x02);
  89.                                         DELAY();
  90.                                         password[3] = read_24c04(0x03);
  91.                                         DELAY();
  92.                                         password[4] = read_24c04(0x04);
  93.                                         DELAY();
  94.                                         password[5] = read_24c04(0x05);
  95.                                         DELAY();
  96.                                         password[6] = read_24c04(0x06);
  97.                                         DELAY();
  98.                                         password[7] = read_24c04(0x07);
  99.                                         DELAY();
  100.                                         if(i != 0)
  101.                                         {
  102.                                                 for(j=i;j<8;j++)
  103.                                                         table = 0;
  104.                                         }
  105.                                         for(j=0;j<8;j++)
  106.                                         {
  107.                                                 if(password[j]!=table[j])
  108.                                                 {
  109.                                                         LCD_Clear();
  110.                                                         LCD_Write_String(0,0,"password error!");                                
  111.                                                         Flag = 1;                //密码错误标志
  112.                                                         i=0;
  113.                                                         //该注释代码用于密码错误时,提示正确密码,调试时使用
  114. //                                                        for(j=0;j<8;j++)
  115. //                                                        {
  116. //                                                                LCD_Write_Com(0xc0+j);
  117. //                                                                LCD_Write_Data(0x30+password[j]);
  118. //                                                        }
  119.                                                         break;
  120.                                                 }
  121.                                         }
  122.                                         if(!Flag)                        //密码正确
  123.                                         {
  124.                                                 LCD_Clear();
  125.                                                 LCD_Write_String(0,0,"password right!");
  126.                                                 i=0;
  127.                                         }
  128.                                         Flag=0;
  129.                                         for(j=0;j<8;j++)
  130.                                                 table[j] = 0;
  131.                                         break;
  132.                                 }
  133.                                 if((keyvalue==14)&&(flag==2))        // 撤销错误密码元素
  134.                                 {
  135.                                         i=i-1;
  136.                                         table[ i ]=0;                       
  137.                                         LCD_Write_Com(0xc0+i);
  138.                                         LCD_Write_Data(' ');
  139.                                 }
  140.                         }
  141.                                                                                 
  142.                 }
  143.                 // 修改密码界面
  144.                 详情请下载文件。
复制代码

全部资料51hei下载地址:
基于1602的电子密码锁源码.rar (88.01 KB, 下载次数: 43)

评分

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

查看全部评分

回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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