单片机电子密码锁

一、实验目的

二、实验内容

三、实验步骤

四、C代码如下

五、实验结果

六、实验体会

一、实验目的

1.了解单片机开发系统的组成及结构;

2. 掌握I/0口的操作方法;

3.能够熟练使用protues和keil软件进行连线和编程，并熟练掌握仿真方法;

4.掌握LCD显示屏的显示原理;

5. 掌握C语言编程方法;

6.培养查找错误和改正错误的能力。

二、实验内容

本设计采用单片机为主控芯片，结合外围电路组成电子密码控制系统。设计主要功能有:

1.设置6位密码，密码通过键盘输入，若密码正确，则锁打开，LCD显示

“Password Right Lock Opened!”。原始密码在首次开锁时为“000000”。

2. 重新设置密码时，LCD显示“******”， 按下“修改”键显示数值。

3.密码只能输入6位数字，无法输入多余数字。

4. 具有自动报警功能:当密码输入错误三次，报警，蜂鸣器响3秒。

5. LED数码管显示密码，为确保安全性所有密码均用“*”表示。

三、实验步骤



四、C代码如下

//-----------------------------------------------------------------
//原始程序中相邻两位密码不能相同.
//本压缩包中的HEX由修改后的新程序编译生成,允许输入任意密码.
//-----------------------------------------------------------------
//实训100例中本例内的main函数可用以下代码替换.
//改动的主要是main函数中while循环内的代码.
//-----------------------------------------------------------------
// 主程序
//-----------------------------------------------------------------
void main()
{
   uchar i = 0;
   uchar IIC_Password[10];
   uchar IS_Valid_User = 0;
   P0 = 0xFF;     
   P1 = 0xFF;
   P2 = 0xFF;  

   TMOD = 0x02;                     //T0设置为8位自动重装模式
   TH0 = 175;                  
   TL0 = 175;
   TR0 = 1;                         //启动T0

   DelayMS(10);                
   LCD_Init();                      //初始化LCD  
   
   IIC_24C04_Init();                //初始化24C04  
   
   Display_String(Title_Text,0x00); //在第1行显示标题
   
   //24C04的内容已由初始化BIN文件导入
   //将24C04中预先写入的密码读入pass
   RecString(0xa0, 0 , IIC_Password, 6);   
   IIC_Password[6] = '\0';

   while(1)
   { 
      P1 = 0xF0;
      if(P1 != 0xF0) KeyNo = Keys_Scan();  //扫描键盘获取键序号KeyNo
 
      switch ( KeyNo )
      {
           case 0:  case 1: case 2: case 3: case 4: 
           case 5:  case 6: case 7: case 8: case 9:
                        
                   if ( i<= 5 )             //密码限制在6位以内
                   {
                        //如果i为0则执行一次清屏
                        if (i ==0) Display_String("                ",0x40);
                    
                        UserPassword[i] = KeyNo + '0';
                        UserPassword[i+1] = '\0';
              
                        DSY_BUFFER[i] = '*';
                        DSY_BUFFER[i+1] = '\0';
                    
                        Display_String(DSY_BUFFER,0x40);
                     
                        i++;
                    }
                    break;
                
           case 10: //按A键开锁
                    if (strcmp(UserPassword,IIC_Password) == 0) 
                    {
                       LED_OPEN = 0;  //点亮LED
                       Clear_Password();
                       Display_String("Unlock OK!      ",0x40);
                       IS_Valid_User = 1;
                    }
                    else 
                    {
                       LED_OPEN =1;   //关闭LED
                       Clear_Password();
                       Display_String("ERROR !         ",0x40);
                       IS_Valid_User = 0;
                    }
                    i = 0;
                    break;
                    
           case 11: //按B键上锁
                    LED_OPEN =1;   
                    Clear_Password();
                    Display_String(Title_Text,0x00);
                    Display_String("                ",0x40);
                    i = 0;                         
                    IS_Valid_User = 0;               
                    break;
                                   
           case 12: //按C键设置新密码
                    //如果是合法用户则提示输入新密码
                    if ( !IS_Valid_User ) Display_String("No rights !",0x40);
                    else 
                    {
                       i = 0;
                       Display_String("New Password:   ",0x00);
                       Display_String("                ",0x40);
                     }
           
                    break;                        
                    
           case 13: //按D键保存新密码
                    if ( !IS_Valid_User ) Display_String("No rights !",0x40);
                    else 
                    {
                       SendString(0xa0, 0 , UserPassword, 6);
                       
                       //重新读入刚写的密码
                       RecString(0xa0, 0 , IIC_Password, 6);   
                       IIC_Password[6] = '\0';                           
                       
                       i = 0;
                       Display_String(Title_Text,0x00);
                       Display_String("Password Saved! ",0x40);
                     }               
                    
                    break;                        
       
           case 14: //按E键消除所有输入
                    i = 0;
                    Clear_Password();
                    Display_String("                ",0x40);            
       }
 
       Beep();          
       DelayMS(100);
       P1= 0xF0;
       while (P1 != 0xF0);    //如果有键未释放则等待
       while (P1 == 0xF0);    //如果没有再次按下按键则等待
   }
}

五、实验结果



六、实验体会

课程设计是培养学生综合运用所学知识发现、提出、分析和解决实际问题，锻炼实践能力的重要环节，是对学生实际工作能力的具体训练和考察过程。随着.科学技术发展的日新月异，单片机已经成为当今计算机应用中空前活跃的领域，在生活中可以说是无处不在。因此作为二十一.世纪的大学生来说掌握单片机的开发技术是十分重要的。本设计经过多次修改和整理，可以满足基本的要求。密码正确，锁开;密码输入错误三次，报警;输入密码超过6位之后的数无效; LCD显示屏显示密码.为“*”在设计的过程中遇到了各种各样的问题，譬如说断电密码保护的设计，由于电路和编程都过于复杂，本设计并未加入。在编程的过程中问题也是很多，由于程序较长，当实现了这个功能另外一个功能有不能很好的实现，所以要做到模块与模块之间的衔接。遇到的- -些问题也经过努力一-克服。回顾此次单片机课程设计，至今我仍感触颇多。在设计过程中从理论到实践我们可以到很多很多东西，巩固了以前学过的知识，还懂得了如何将理论联系实际。只有理论知识是远远不够的，只有将理论运用到实际中对我们来说才是有意义的，这样才能真正的为社会服务。

 

电子密码锁
1.LCD1602显示

2.有修改密码的功能

3.使用51单片机模拟I2C通信，数据通过读写EEPROM进行存储
代码
此代码只包含程序的主体（main），各使用器件的初始化放个其它引用文件中，程序中定义了很多标志位，变量名取的很随意取的。开机会显示一下密码
#include"reg52.h"
#include"key.h"
#include"lcd.h"
#include"iic.h"

#define u16 unsigned int
#define u8 unsigned char

//EEPROM的读写--不能有0号位置 

u8 poi[]="pji";
u8 datt,state,sta1;passqors_length=6,orig_password[10],enter_password[10],enter_pass_Length,enter_pass_Length2,Length_f,Length1_f,fs=3,lop=0,lop2=0,i=0,Length1_f2;
u16 key_va;

void state_0();
void state_1();
void state_2();
void state_3();
void state_4();
void state_5();
void state_6();

u8 input_password();
u8 cantrast();







void main(){
	u8 a,data1;
	//lcd_com(0x01);//进来先清下lcd屏幕

	lcd_init();
	for(data1=1;data1<passqors_length+3;data1++)		 //	开始的时候屏幕会显示下EEPROM中的数据
	{
		a=At24c02Read(data1)+0x30;
	 	lcd_data(a);	
  																   
 	}	
	delay(100);
	if(At24c02Read(1)!=1){								   //判断1位置--标志位{密码是否存在}--不存在初始化密码---888888
		At24c02Write(1,1);	//储存都是一个字节八位数据
		At24c02Write(2,6);	//密码长度定义为六
		for(datt=3;datt<passqors_length+3;datt++){
			At24c02Write(datt,8);
		}
	}
	delay(100);
	for(a=1;a<passqors_length+1;a++){					   //将密码读出来---保存到数组orig_password中去
		orig_password[a]=At24c02Read(a+2);
	}
	enter_pass_Length=0;
	sta1=0;			  //用于判断--是进入修改密码---还是登录
	state=0;
	Length_f=0;
	Length1_f=0;
	Length1_f2=0;
	
	while(1){
		key_va=keyvalude();	//每时每刻都在获取键值
		switch(state){
			case(0):
				state_0();
				break;
			case(1):
				state_1();
				break;
			case(2):
				state_2();
				break;
			case(3):
				state_3();
				break;
			case(4):
				state_4();
				break;
		  	case(5):
				state_5();
				break;
			case(6):
				state_6();
				break;
		
		}
	}

}


void state_0(){
	show(0x00,"----welcome----");
//	show(0x1f,key_va);
	if(key_va==16){
		state=1;
	}
		
}
void state_1(){
	show(0x00,"change password");
	show(0x0f,"<");
	show(0x10,"enter password");
	show(0x1f," "); 
	
	state=5;

}
void state_2(){
	 u8 flag;
	
	if(Length_f==1){
		enter_pass_Length=0;
		Length_f=0;
	}
	if(lop==0){
		lcd_com(0x01);
		show(0x00,"original password:");
		lcd_com(0x80+0x40);
		//lcd_com(0x06);
		lop=1;
	}		
	 

   
	
	if(key_va>0 && key_va<10){
	//	enter_pass_Length=0;
		enter_password[enter_pass_Length]=key_va;	   //密码长度不会冲突
		enter_pass_Length++;					   //输入密码的长度
		lcd_data(0x30+key_va);
	}
	if(key_va==16){
		flag=cantrast();
		if(flag==0){		  //密码修改成功---返回初始状态
			lcd_com(0x01);
			show(0x00,"OK");
			delay(1000);
			state=4;

		}else{
			lcd_com(0x01);
			show(0x00,"err_changep");
			delay(100);
			state=2;
			Length_f=1;
			lop=0;
		}
		enter_pass_Length=0;
	}	

}
void state_3(){
	u8 flag;
	if(Length1_f2==1){
		enter_pass_Length=0;
		Length1_f2=0;
	}
	if(lop2==0){
		lcd_com(0x01);
		show(0x00,"password:");
		lcd_com(0x80+0x40);
		lop2=1;
	}
	
	if(key_va>0 && key_va<10){
	//	enter_pass_Length=0;
		enter_password[enter_pass_Length]=key_va;
		enter_pass_Length++;					   //输入密码的长度
		lcd_data('*');
	}									   
	if(key_va==16){
		flag=cantrast();
		if(flag==0){		  //
			lcd_com(0x01);
			show(0x00,"china");
			delay(1000);
	
		}else{
			lcd_com(0x01);
			show(0x00,"err");
			delay(1000);
			Length1_f=1;
			lop2=0;
			state=3;
			
		}
	}
}

   



void state_4(){
	if(i==0){
	   show(0x00,"new password:");
		lcd_com(0x80+0x40);
	
	}
	
	
	if(key_va>0 && key_va<10){
		i=1;
		At24c02Write(fs,key_va);	 
		fs++;
		lcd_data('*');
	}
	if(key_va==16){
	lcd_com(0x01);
		show(0x00,"pass ok password");
		delay(1000);
		state=6;
	}

}

void state_5(){
	
	if(key_va==1){
		show(0x0f,"<");
		show(0x1f," "); 
		sta1=0;
	}
	if(key_va==5){
		show(0x0f," ");
		show(0x1f,"<");
	   	sta1=1;
	}
	if(key_va==16){
		if(sta1==0){
			state=2;	   //修改密码 
		}else{
	   		state=3;	   //输入密码
	
		}		
	}
}

void state_6(){
	lcd_com(0x01);
    show(0x00,"zengcheng");
	enter_pass_Length=0;
	sta1=0;
	Length_f=0;
	Length1_f=0;
	lop=0;
	lop2=0;
	i=0;
	fs=3;
	delay(10000);
    
   	  state=0;
    

}



u8 cantrast(){
	u8 x=0,y=0;
	if(enter_pass_Length==passqors_length){
		for(x=1;x<7;x++){
			if(enter_password[x-1]==At24c02Read(x+2)){
				break;	
			}else{
				return 1;
			}
		}	
	
	}else{
	   return 1;
	}

	return 0;
}



u8 input_password(){
	u8 flag;
	while(1){
	
		if(key_va>0 && key_va<10){
		//	enter_pass_Length=0;
			enter_password[enter_pass_Length]=key_va;	   //密码长度不会冲突
			enter_pass_Length++;					   //输入密码的长度
			lcd_data(0x30+key_va);
		}
		if(key_va==16){
			flag=cantrast();
			if(flag==0){		  //密码修改成功---返回初始状态
				lcd_com(0x01);
				show(0x00,"OK");
				delay(50);
			//	state=4;
				return 4;
	
			}else{
				lcd_com(0x01);
				show(0x00,"err_changep");
				delay(50);
			//	state=2;
				Length_f=1;
				lop=0;
				return 2;
			}
		}
 
   }

}

	

简介
大家好，这篇文章的内容是关于如何用51单片机来制作一个电子密码锁的教程，通过这篇教程可以让刚入门的朋友了解矩阵键盘、LCD1602的使用方法，以及密码输入和修改的程序介绍，我会对每个部分进行详细的介绍。
首先我们来看一下这个密码锁要实现哪些功能：
可通过矩阵键盘进行密码的输入和修改。
可通过LCD1602进行界面的显示。
在了解了我们需要实现的功能后我们就可一开始进行软硬件的设计了。本次密码锁的硬件部分我使用Proteus来进行仿真。
硬件设计
首先我们进行硬件的设计，密码锁的硬件部分还是很简单的，首先我们需要一个51单片机的最小系统，在Proteus中芯片并不需要外接晶振，直接放上芯片就可以使用，我选择AT89C52单片机，并给P0口外接一排上拉电阻来提升驱动能力，
接下来是界面显示部分，之前说过显示部分使用的是LCD1602，LCD的电路如下图，
首先我来简单介绍一下LCD1602的引脚功能：
VSS：接地
VDD：接电源
V0：对比度调整端，使用时可接电位器接地进行对比度调节
RS：寄存器选择，高电平选择数据寄存器，低电平选择指令寄存器
RW：读写信号线，高电平读，低电平写
E：使能端，下降沿写操作，高电平读操作
DB0：数据总线最低位
DB1：数据总线1位
DB2：数据总线2位
DB3：数据总线3位
DB4：数据总线4位
DB5：数据总线5位
DB6：数据总线6位
DB7：数据总线7位
A：背光电源正极
K：背光电源负极
我们可以看到LCD1602一共有上述16个引脚，我来根据图中的接法来介绍一下各个引脚的用法。
VDD和A分别用于给LCD和背光板供电，VSS和K为负极接地，仿真里面我们不需要接A、K引脚。
V0脚就是图中的VEE，这个脚使用来调节LCD的字符对比度，直接接地的时候对比度最高，不过容易出现鬼影，在实际使用的时候我们可以将这个脚通过一个10K的电位器接地来进行对比度的调节，在仿真里我就直接接地了。
RS脚是寄存器选择脚，这个脚我接到单片机的P3.5脚上，我们通过改变这个脚的高低电平可以选择给LCD发送数据还是发送指令。
RW脚是用来设置对LCD的读写操作的，因为在这里我们不需要对LCD进行读取操作，所以我就直接将这个脚接地了，也可以通过IO口来对RW进行设置。
E脚是LCD的使能端，仿真中接的单片机的P3.4脚。
最后的D0~D7脚就是LCD的数据脚，我们将这8个脚接到单片机接了上拉电阻的P0脚，这样就可以给LCD发送指令或数据了。
然后我们需要一个键盘进行密码的输入和修改，在Proteus里我们可以直接搜索KEYPAD来添加矩阵键盘，在这里我们使用一个3*4的键盘就够了，引脚与单片机的连接如下，
也可以使用按键自己连接一个矩阵键盘有助于对程序的理解。
软件设计
在介绍完硬件部分的设计后，我们就可以开始编写程序了，首先讲一下矩阵键盘的程序，
    int keyboard()            //键盘扫描    {        P2 = 0xf7;        k = P2;        k = k & 0xf0;        if(k == 0xf0)        {            kf = 0;        }        if(k != 0xf0)        {            delay(4);            k = P2;            k = k & 0xf0;            if(k != 0xf0)            {                switch(k)                {                    case 0xe0:                        key = 88;mod = 1;kf = 1;                        break;                    case 0xd0:                        key = 0;kf = 1;                        break;                    case 0xb0:                        key = 88;kf = 1;                        break;                    case 0x70:                        key = 88;kf = 1;                        break;                     }            }            }        P2 = 0xfb;        k = P2;        k = k & 0xf0;        if(k != 0xf0)        {            delay(4);            k = P2;            k = k & 0xf0;            if(k != 0xf0)            {                switch(k)                {                    case 0xe0:                        key = 7;kf = 1;                        break;                    case 0xd0:                        key = 8;kf = 1;                        break;                    case 0xb0:                        key = 9;kf = 1;                        break;                    case 0x70:                        key = 88;kf = 1;                        break;                }            }        }        P2 = 0xfd;        k = P2;        k = k & 0xf0;        if(k != 0xf0)        {            delay(4);            k = P2;            k = k & 0xf0;            if(k != 0xf0)            {                switch(k)                {                    case 0xe0:                        key = 4;kf = 1;                        break;                    case 0xd0:                        key = 5;kf = 1;                        break;                    case 0xb0:                        key = 6;kf = 1;                        break;                    case 0x70:                        key = 88;kf = 1;                        break;                }            }        }        P2 = 0xfe;        k = P2;        k = k & 0xf0;        if(k != 0xf0)        {            delay(4);            k = P2;            k = k & 0xf0;            if(k != 0xf0)            {                switch(k)                {                    case 0xe0:                        key = 1;kf = 1;                        break;                    case 0xd0:                        key = 2;kf = 1;                        break;                    case 0xb0:                        key = 3;kf = 1;                        break;                    case 0x70:                        key = 88;kf = 1;                        break;                }            }        }            return key;         }
上面这一段是矩阵键盘的程序，通过改变P1口的值来进行行列检测，同时增加一个标志位kf来判断按键是否松开。有了按键驱动下面就可以编写密码输入的函数了：
    void input()    //密码输入函数    {        keyboard();        if(key!=88)        {            while(kf)            {                keyboard();            }            s = (char)key;            s = s | 0x30;            lcd_pos(d);            write_date(s);            in[i] = key;            i++;            d++;                    key = 88;        }            }

在密码输入函数里我们调用键盘扫描函数，当有按键按下时我们就将对应的键值保存到输入密码的数组里，然后将每一个输入的按键的键值显示在LCD的显示屏上。LCD的驱动程序会在下面讲解。
现在要开始编写LCD的驱动用来显示输入的数字，我们首先需要两个函数，分别给LCD发送数据和指令，程序如下：
    void write_com(uchar com)        //LCD写指令    {        P0=com;        rs=0;        lcden=0;        delay(10);        lcden=1;        delay(10);        lcden=0;    }    void write_date(uchar date)        //LCD写数据    {        P0=date;        rs=1;        lcden=0;        delay(10);        lcden=1;        delay(10);        lcden=0;    }
我们可以通过写数据的函数发送给LCD要显示的数据，可以通过写命令函数向LCD发送指令来对LCD进行相应的设置，相关的指令大家可以自行到网上查阅，以下列出的函数分别用来改变光标位置，LCD初始化设置和清屏。
    void lcd_pos(uchar pos)        //设置LCD显示位置    {                                write_com(pos | 0x80);      }    void init()        //LCD初始化    {        write_com(0x38);        delay(20);        write_com(0x0f);        delay(20);        write_com(0x06);        delay(20);        write_com(0x01);        delay(20);            write_com(0x0c);        delay(20);    }    void clear()        //LCD清屏    {        write_com(0x01);        delay(20);    }
接下来我们可以对输入的密码进行判断，
    void judge()        //密码判断函数    {        if(i==6)        {            for(f = 0;f<6;f++)            {                if(password[f] == in[f])                m++;                }            if(m==6)            {                es = 0;                clear();                lcd_pos(0x03);                write_dates("Welcome!");                delay(1200);                clear();                lcd_pos(0x00);                write_dates("Password:");                lcd_pos(0x45);                write_dates("******");                }            else            {                es++;                clear();                lcd_pos(0x04);                write_dates("Error!");                delay(1200);                if(es == 3)                {                    lcd_pos(0x45);                    write_dates("WARNING");                    delay(5000);                    es = 0;                        clear();                }                lcd_pos(0x00);                write_dates("Password:");                lcd_pos(0x45);                write_dates("******");                                    }            m = 0;            i = 0;            d = 0x45;        }    }

密码锁的密码为6位，当输入6位密码后我们就可以对密码进行判断，判断过程就是将输入密码的数组与保存的密码的数组通过循环进行比较，当输入密码正确后就会显示欢迎界面，等待一段时间再返回密码输入界面，如果密码输入错误则进入错误界面，然后返回密码输入界面，我们可以检测错误的次数如果错误次数太多可以进行类似延长等待时间等操作。
最后就是密码修改的操作。
    void change()        //修改密码函数    {        if(mod==1)        {            lcd_pos(0x00);            write_dates("OldPassword:");            input();            if(i==6)            {                for(f = 0;f<6;f++)                {                    if(password[f] == in[f])                    m++;                    }                if(m==6)                {                    mod=2;                    clear();                    lcd_pos(0x45);                    write_dates("******");                    }                else                {                    clear();                    lcd_pos(0x04);                    write_dates("Error!");                    delay(1200);                    lcd_pos(0x00);                    write_dates("Password:");                    lcd_pos(0x45);                    write_dates("******");                        mod=0;                                    }                m = 0;                i = 0;                d = 0x45;            }            }        if(mod==2)        {            lcd_pos(0x00);            write_dates("NewPassword:");            input();            if(i==6)            {                for(f = 0;f<6;f++)                {                    password[f] = in[f];                }                    lcd_pos(0x44);                write_dates("success!");                delay(1200);                clear();                lcd_pos(0x00);                write_dates("Password:");                lcd_pos(0x45);                write_dates("******");                i = 0;                mod = 0;                d = 0x45;            }        }    }

修改密码需要我们先输入正确密码，然后会进入修改界面，再次输入新密码就可以保存了。过程就是用循环来更新数组内的值，这样一个简单的密码锁就做好了，不过这样的锁有一个缺点，就是设置的密码不会保存，等单片机再次上电后就会恢复到最初始的密码，要想在断电后继续保存密码，我们可以使用EEPROM来进行密码的保存，由于篇幅原因，我会在之后单独介绍EEPROM的读写操作。感谢各位的观看。
点“阅读原文”，阅读更多文章！
相关产品推荐：树莓派4B 现货，268元起！

	

简介
大家好，这篇文章的内容是关于如何用51单片机来制作一个电子密码锁的教程，通过这篇教程可以让刚入门的朋友了解矩阵键盘、LCD1602的使用方法，以及密码输入和修改的程序介绍，我会对每个部分进行详细的介绍。
首先我们来看一下这个密码锁要实现哪些功能：
可通过矩阵键盘进行密码的输入和修改。
可通过LCD1602进行界面的显示。
在了解了我们需要实现的功能后我们就可一开始进行软硬件的设计了。本次密码锁的硬件部分我使用Proteus来进行仿真。
硬件设计
首先我们进行硬件的设计，密码锁的硬件部分还是很简单的，首先我们需要一个51单片机的最小系统，在Proteus中芯片并不需要外接晶振，直接放上芯片就可以使用，我选择AT89C52单片机，并给P0口外接一排上拉电阻来提升驱动能力，
接下来是界面显示部分，之前说过显示部分使用的是LCD1602，LCD的电路如下图，
首先我来简单介绍一下LCD1602的引脚功能：
VSS：接地
VDD：接电源
V0：对比度调整端，使用时可接电位器接地进行对比度调节
RS：寄存器选择，高电平选择数据寄存器，低电平选择指令寄存器
RW：读写信号线，高电平读，低电平写
E：使能端，下降沿写操作，高电平读操作
DB0：数据总线最低位
DB1：数据总线1位
DB2：数据总线2位
DB3：数据总线3位
DB4：数据总线4位
DB5：数据总线5位
DB6：数据总线6位
DB7：数据总线7位
A：背光电源正极
K：背光电源负极
我们可以看到LCD1602一共有上述16个引脚，我来根据图中的接法来介绍一下各个引脚的用法。
VDD和A分别用于给LCD和背光板供电，VSS和K为负极接地，仿真里面我们不需要接A、K引脚。
V0脚就是图中的VEE，这个脚使用来调节LCD的字符对比度，直接接地的时候对比度最高，不过容易出现鬼影，在实际使用的时候我们可以将这个脚通过一个10K的电位器接地来进行对比度的调节，在仿真里我就直接接地了。
RS脚是寄存器选择脚，这个脚我接到单片机的P3.5脚上，我们通过改变这个脚的高低电平可以选择给LCD发送数据还是发送指令。
RW脚是用来设置对LCD的读写操作的，因为在这里我们不需要对LCD进行读取操作，所以我就直接将这个脚接地了，也可以通过IO口来对RW进行设置。
E脚是LCD的使能端，仿真中接的单片机的P3.4脚。
最后的D0~D7脚就是LCD的数据脚，我们将这8个脚接到单片机接了上拉电阻的P0脚，这样就可以给LCD发送指令或数据了。
然后我们需要一个键盘进行密码的输入和修改，在Proteus里我们可以直接搜索KEYPAD来添加矩阵键盘，在这里我们使用一个3*4的键盘就够了，引脚与单片机的连接如下，
也可以使用按键自己连接一个矩阵键盘有助于对程序的理解。
软件设计
在介绍完硬件部分的设计后，我们就可以开始编写程序了，首先讲一下矩阵键盘的程序，
    int keyboard()            //键盘扫描    {        P2 = 0xf7;        k = P2;        k = k & 0xf0;        if(k == 0xf0)        {            kf = 0;        }        if(k != 0xf0)        {            delay(4);            k = P2;            k = k & 0xf0;            if(k != 0xf0)            {                switch(k)                {                    case 0xe0:                        key = 88;mod = 1;kf = 1;                        break;                    case 0xd0:                        key = 0;kf = 1;                        break;                    case 0xb0:                        key = 88;kf = 1;                        break;                    case 0x70:                        key = 88;kf = 1;                        break;                     }            }            }        P2 = 0xfb;        k = P2;        k = k & 0xf0;        if(k != 0xf0)        {            delay(4);            k = P2;            k = k & 0xf0;            if(k != 0xf0)            {                switch(k)                {                    case 0xe0:                        key = 7;kf = 1;                        break;                    case 0xd0:                        key = 8;kf = 1;                        break;                    case 0xb0:                        key = 9;kf = 1;                        break;                    case 0x70:                        key = 88;kf = 1;                        break;                }            }        }        P2 = 0xfd;        k = P2;        k = k & 0xf0;        if(k != 0xf0)        {            delay(4);            k = P2;            k = k & 0xf0;            if(k != 0xf0)            {                switch(k)                {                    case 0xe0:                        key = 4;kf = 1;                        break;                    case 0xd0:                        key = 5;kf = 1;                        break;                    case 0xb0:                        key = 6;kf = 1;                        break;                    case 0x70:                        key = 88;kf = 1;                        break;                }            }        }        P2 = 0xfe;        k = P2;        k = k & 0xf0;        if(k != 0xf0)        {            delay(4);            k = P2;            k = k & 0xf0;            if(k != 0xf0)            {                switch(k)                {                    case 0xe0:                        key = 1;kf = 1;                        break;                    case 0xd0:                        key = 2;kf = 1;                        break;                    case 0xb0:                        key = 3;kf = 1;                        break;                    case 0x70:                        key = 88;kf = 1;                        break;                }            }        }            return key;         }
上面这一段是矩阵键盘的程序，通过改变P1口的值来进行行列检测，同时增加一个标志位kf来判断按键是否松开。有了按键驱动下面就可以编写密码输入的函数了：
    void input()    //密码输入函数    {        keyboard();        if(key!=88)        {            while(kf)            {                keyboard();            }            s = (char)key;            s = s | 0x30;            lcd_pos(d);            write_date(s);            in[i] = key;            i++;            d++;                    key = 88;        }            }

在密码输入函数里我们调用键盘扫描函数，当有按键按下时我们就将对应的键值保存到输入密码的数组里，然后将每一个输入的按键的键值显示在LCD的显示屏上。LCD的驱动程序会在下面讲解。
现在要开始编写LCD的驱动用来显示输入的数字，我们首先需要两个函数，分别给LCD发送数据和指令，程序如下：
    void write_com(uchar com)        //LCD写指令    {        P0=com;        rs=0;        lcden=0;        delay(10);        lcden=1;        delay(10);        lcden=0;    }    void write_date(uchar date)        //LCD写数据    {        P0=date;        rs=1;        lcden=0;        delay(10);        lcden=1;        delay(10);        lcden=0;    }
我们可以通过写数据的函数发送给LCD要显示的数据，可以通过写命令函数向LCD发送指令来对LCD进行相应的设置，相关的指令大家可以自行到网上查阅，以下列出的函数分别用来改变光标位置，LCD初始化设置和清屏。
    void lcd_pos(uchar pos)        //设置LCD显示位置    {                                write_com(pos | 0x80);      }    void init()        //LCD初始化    {        write_com(0x38);        delay(20);        write_com(0x0f);        delay(20);        write_com(0x06);        delay(20);        write_com(0x01);        delay(20);            write_com(0x0c);        delay(20);    }    void clear()        //LCD清屏    {        write_com(0x01);        delay(20);    }
接下来我们可以对输入的密码进行判断，
    void judge()        //密码判断函数    {        if(i==6)        {            for(f = 0;f<6;f++)            {                if(password[f] == in[f])                m++;                }            if(m==6)            {                es = 0;                clear();                lcd_pos(0x03);                write_dates("Welcome!");                delay(1200);                clear();                lcd_pos(0x00);                write_dates("Password:");                lcd_pos(0x45);                write_dates("******");                }            else            {                es++;                clear();                lcd_pos(0x04);                write_dates("Error!");                delay(1200);                if(es == 3)                {                    lcd_pos(0x45);                    write_dates("WARNING");                    delay(5000);                    es = 0;                        clear();                }                lcd_pos(0x00);                write_dates("Password:");                lcd_pos(0x45);                write_dates("******");                                    }            m = 0;            i = 0;            d = 0x45;        }    }

密码锁的密码为6位，当输入6位密码后我们就可以对密码进行判断，判断过程就是将输入密码的数组与保存的密码的数组通过循环进行比较，当输入密码正确后就会显示欢迎界面，等待一段时间再返回密码输入界面，如果密码输入错误则进入错误界面，然后返回密码输入界面，我们可以检测错误的次数如果错误次数太多可以进行类似延长等待时间等操作。
最后就是密码修改的操作。
    void change()        //修改密码函数    {        if(mod==1)        {            lcd_pos(0x00);            write_dates("OldPassword:");            input();            if(i==6)            {                for(f = 0;f<6;f++)                {                    if(password[f] == in[f])                    m++;                    }                if(m==6)                {                    mod=2;                    clear();                    lcd_pos(0x45);                    write_dates("******");                    }                else                {                    clear();                    lcd_pos(0x04);                    write_dates("Error!");                    delay(1200);                    lcd_pos(0x00);                    write_dates("Password:");                    lcd_pos(0x45);                    write_dates("******");                        mod=0;                                    }                m = 0;                i = 0;                d = 0x45;            }            }        if(mod==2)        {            lcd_pos(0x00);            write_dates("NewPassword:");            input();            if(i==6)            {                for(f = 0;f<6;f++)                {                    password[f] = in[f];                }                    lcd_pos(0x44);                write_dates("success!");                delay(1200);                clear();                lcd_pos(0x00);                write_dates("Password:");                lcd_pos(0x45);                write_dates("******");                i = 0;                mod = 0;                d = 0x45;            }        }    }

修改密码需要我们先输入正确密码，然后会进入修改界面，再次输入新密码就可以保存了。过程就是用循环来更新数组内的值，这样一个简单的密码锁就做好了，不过这样的锁有一个缺点，就是设置的密码不会保存，等单片机再次上电后就会恢复到最初始的密码，要想在断电后继续保存密码，我们可以使用EEPROM来进行密码的保存，由于篇幅原因，我会在之后单独介绍EEPROM的读写操作。感谢各位的观看。
点“阅读原文”，阅读更多文章！
相关产品推荐：树莓派4B 现货，268元起！