单片机案例开发——电子密码锁

最新推荐文章于 2023-09-19 16:36:01 发布
最新推荐文章于 2023-09-19 16:36:01 发布
阅读量1.5k 收藏 9
点赞数 2
文章标签： 单片机 C语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/matsukawahikari/article/details/83756903
版权 
#include <STCREG.H>
#define uint unsigned int
#define	uchar unsigned char
#define pwdLEN 10                   
#define STLEN 3                    
sbit l1 = P3^5;						
sbit bump = P3^6;					
sbit relay = P3^7;				
sbit lcden = P1^3;					
sbit lcdrw = P1^2;
sbit lcdrs = P1^1;
sbit sda = P1^6;				
sbit scl = P1^7;				

uchar code xianshi0[] = " input  password:";
uchar code xianshi1[] = " Please come in!";	
uchar code xianshi2[] = "*";				
uchar code xianshi3[] = " you are thief!";
uchar code xianshi4[] = " new  password:";	
uchar code xianshi5[] = " alter succeed!";	
uchar code xianshi6[] = "  first error!";
uchar code xianshi7[] = "  second error!";	
uchar code xianshi8[] = "  third error!";	
uchar code xianshi9[] = "  alter fail!!";	
uchar table[pwdLEN];					
uchar table1[12] ={0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x01,0x02,0x03};				
uchar mima[pwdLEN];					
uchar num, num1, num2, num3, etimes, fanhui, kai;
bit alterflog, cpflog, suoflog;	
void keyscan();						
void init();
void keydeal15();
void keydeal16();					

void delay_xs(uint x)
{
	uint i, j;
	for(i = x; i > 0; i--)
		for(j = 123; j > 0; j--);
}

void writecom(uchar com)			
{
	P0 = com;
	lcdrs = 0;
	lcdrw = 0;
	lcden = 0;
	lcden = 1;
}

void writedate(uchar date)		
{
	P0 = date;
	lcdrs = 1;
	lcdrw = 0;
	lcden = 0;
	lcden = 1;
}


void delay()		
{;;}

void start()					
{	
	sda = 1;
	delay();
	scl = 1;
	delay();
	sda = 0;
	delay();
}

void stop()						
{
	sda = 0;
	delay();
	scl = 1;
	delay();
	sda = 1;
	delay();
}

void respons()						
{
	uchar i;
	scl=1;
	delay();
	while((sda == 1) && (i < 250))
		i++;
	scl = 0;
	delay();
}

void write_byte(uchar date)			
{
	uchar i, temp;
	temp = date;

	for(i = 0; i < 8; i++)
	{
		temp = temp << 1;
		scl = 0;
		delay();
		sda = CY;
		delay();
		scl = 1;
		delay();
	}
	scl = 0;
	delay();
	sda = 1;
	delay();
}

uchar read_byte()				
{
	uchar i, k;
	scl = 0;
	delay();
	sda = 1;
	delay();
	for(i = 0; i < 8; i++)
	{
		scl = 1;
		delay();	
		k = (k <<1 ) | sda;
		scl = 0;
		delay();	
	}
	return k;
}

void write24c02(uchar address, uchar date) 
{
	start();
	write_byte(0xa0);
	respons();
	write_byte(address);
	respons();
	write_byte(date);
	respons();
	stop();
}

uchar read24c02(uchar address)		
{
	uchar date;
	start();
	write_byte(0xa0);
	respons();
	write_byte(address);
	respons();
	start();
	write_byte(0xa1);
	respons();
	date=read_byte();
	stop();
	return date;
}

void keydeal1()		              
{
	table[num] = 1;
	num++;
	if(alterflog == 1)
	{
		table1[num1] = 1;
		num1++;
	}
}

void keydeal2()		               
{
	table[num] = 2;
	num++;
	if(alterflog == 1)
	{
		table1[num1] = 2;
		num1++;
	}
}

void keydeal3()		             
{
	table[num] = 3;
	num++;
	if(alterflog == 1)
	{
		table1[num1] = 3;
		num1++;
	}
}
void keydeal4()		             
{
	table[num] = 4;
	num++;
	if(alterflog == 1)
	{
		table1[num1] = 4;
		num1++;
	}
}

void keydeal5()		              
{
	table[num] = 5;
	num++;
	if(alterflog == 1)
	{
		table1[num1] = 5;
		num1++;
	}
}

void keydeal6()					
{
	table[num] = 6;
	num++;
	if(alterflog == 1)
	{
		table1[num1] = 6;
		num1++;
	}
}

void keydeal7()					
{
	table[num] = 7;
	num++;
	if(alterflog == 1)
	{
		table1[num1] = 7;
		num1++;
	}
}

void keydeal8()						
{
	table[num] = 8;
	num++;
	if(alterflog == 1)
	{
		table1[num1] = 8;
		num1++;
	}
}
void keydeal9()					
{
	table[num] = 9;
	num++;
	if(alterflog == 1)
	{
		table1[num1] = 9;
		num1++;
	}
}

void keydeal10()				  
{
	table[num] = 0;
	num++;
	if(alterflog == 1)
	{
		table1[num1] = 0;
		num1++;
	}
}

void compare()						
{
	uchar j;
	for(j = 0; j < pwdLEN; j++)
	{
		if(table[j] == mima[j])
		{
			cpflog = 1;
			l1 = 0;
		}
		else
			cpflog = 0;
		l1 = 1;
	} 	
}

void keydeal11()				
{
	uchar j;
	if(alterflog == 1)
		goto n;					
	if(num == pwdLEN)				
	{
		num = 0;				
		compare();				
		for(j = 0; j < pwdLEN; j++)		
		{
			table[j] = 0x0f;
		}
	}

	if(cpflog == 1)				
	{
		l1 = 0;					
		cpflog = 0;					
		etimes = 0;					
		kai = 1;					
		writecom(0x01);			
		delay_xs(5);
		delay_xs(5);
		for(j = 0; j < 15; j++)
		{
			writedate(xianshi1[j]);
			delay_xs(5);
		}
		for(j = 0; j < 2; j++)		
		{
			bump=0;
			delay_xs(2000);
			bump=1;
			delay_xs(2000);
			bump=0;
			delay_xs(2000);
			bump=1;
			delay_xs(2000);
			relay = 0;
		}
	
		while((suoflog != 1) && (alterflog != 1)) 
		{
			P2 = 0xf7;
			if(P2 == 0xe7)
				{suoflog = 1;	
					relay = 1;
					}
			P2 = 0xfb;				
			if(P2 == 0xeb)
				alterflog = 1;				
			if(suoflog ==1 )	
			{
				init();
			}
n:			if(alterflog == 1)	
			{
				writecom(0x01);
				delay_xs(5);
				writecom(0x80);		
				delay_xs(5);
				for(j = 0; j < 15; j++)
				{
					writedate(xianshi4[j]);
					delay_xs(5);
				}
			}
		}
		suoflog = 0;			
	}
	else						
	{
		num = 0;					
		num1 = 0;				
		etimes++;				
		bump = 0;				
		delay_xs(5000);
		bump = 1;
		for(j = 0; j < pwdLEN; j++)	
		{
			table1[j] = 0x0f;
		}
		if(etimes == 1)			
		{
			writecom(0x01);			
			delay_xs(5);
			writecom(0x80);
			delay_xs(5);
			for(j = 0; j < 14; j++)
			{
				writedate(xianshi6[j]);
				delay_xs(5);
			}
			delay_xs(20000);		
			writecom(0x01);		
			delay_xs(5);
			writecom(0x80);
			delay_xs(5);
			for(j = 0; j < 16; j++)	
			{
				writedate(xianshi0[j]);
				delay_xs(5);
			}					   
			writecom(0x80 + 0x40 + STLEN);
			delay_xs(5);
			for(j = 0; j < pwdLEN; j++)
			{
				writedate('-');
				delay_xs(5);
			}
		}
		if(etimes == 2)			
		{
			writecom(0x01);
			delay_xs(5);
			writecom(0x80);
			delay_xs(5);
			for(j = 0; j < 15; j++)	
			{
				writedate(xianshi7[j]);
				delay_xs(5);
			}
			delay_xs(20000);			
			writecom(0x01);			
			delay_xs(5);
			writecom(0x80);
			delay_xs(5);
			for(j = 0; j < 16; j++)	
			{
				writedate(xianshi0[j]);
				delay_xs(5);
			}
			writecom(0x80 + 0x40 + STLEN);
			delay_xs(5);
			for(j = 0; j < pwdLEN; j++)	
			{
				writedate('-');
				delay_xs(5);
			}
		}
		if(etimes == 3)			
		{
			writecom(0x01);
			delay_xs(5);
			writecom(0x80);
			delay_xs(5);
			for(j = 0; j < 15; j++)	
			{
				writedate(xianshi3[j]);
				delay_xs(5);
			}
			for(j = 0; j < 10; j++)	
			{
				bump = 0;
				delay_xs(5000);
				bump = 1;
				delay_xs(5000);
			}
			init();				
		}
	}
}

void keydeal12()				
{
	uint i;
	if(kai == 0)				
	{							
		init();
	}
	else						
	{
		if(alterflog == 1)
		{
			num = 0;
			num1 = 0;
			writecom(0x01);
			delay_xs(5);
			writecom(0x80);			
			delay_xs(5);
			for(i = 0; i < 15; i++)
			{
				writedate(xianshi4[i]);
				delay_xs(5);
			}
		}
	}
}

void keydeal15()				
{
	uchar i;
	alterflog = 0;				
	num = 0;					
	for(i = 0; i < pwdLEN; i++)		
	{
		table[i] = 0x0f;	
	}
	if(num1 == 8)				
	{
		num1 = 0;				
		for(i = 0; i < pwdLEN; i++)	
		{
			write24c02(i, table1[i]);
			delay_xs(50);		
		}
		writecom(0x01);			
		delay_xs(5);
		writecom(0x80);
		delay_xs(5);
		for(i = 0; i < 15; i++)	
		{
			writedate(xianshi5[i]);
			delay_xs(5);
		}
		delay_xs(20000);
	}
	else						
	{
		num1 = 0;				
		writecom(0x01);			
		delay_xs(5);
		writecom(0x80);
		delay_xs(5);
		for(i = 0; i < 14; i++)	
		{
			writedate(xianshi9[i]);
			delay_xs(5);
		}
		delay_xs(20000);
	}
	
	if(kai == 1)				
	{
		num = 0;					
		delay_xs(2000);			
		writecom(0x01);			
		delay_xs(5);
		writecom(0x80);
		delay_xs(5);
		for(i = 0; i < 15; i++)	
		{
			writedate(xianshi1[i]);
			delay_xs(5);
		}						
		while((suoflog != 1) & (alterflog != 1))
		{
			P2 = 0xf7;
			if(P2 == 0xe7)
				suoflog = 1;
			P2 = 0xfb;
			if(P2 == 0xeb)
				alterflog = 1;
			if(suoflog == 1)
			{
				init();
			}
			if(alterflog == 1)
			{
				writecom(0x01);
				delay_xs(5);
				writecom(0x80);	
				delay_xs(5);
				for(i = 0; i < 15; i++)
				{
					writedate(xianshi4[i]);
					delay_xs(5);
				}
			}
		 }
	}
	else							
	{							
		delay_xs(2000);
		init();
	}
}

void keydeal16()				
{
	
}

void keyscan()
{
	uchar temp;

	P2 = 0xf7;
	temp = P2 & 0xf0;
	if(temp != 0xf0)
	{
		delay_xs(10);
		if(temp != 0xf0)
			temp = P2;
		switch(temp)
		{
			case 0x77:	keydeal7();		break;
			case 0xb7:	keydeal8();		break;
			case 0xd7:	keydeal9();		break;
			case 0xe7: 	
				break;
		}
		while((P2 & 0xf0) != 0xf0);	

	}

	P2 = 0xfb;
	temp = P2 & 0xf0;
	if(temp != 0xf0)
	{
		delay_xs(10);
		if(temp != 0xf0)
			temp = P2;
		switch(temp)
		{
			case 0x7b:	keydeal4();		break;
			case 0xbb: 	keydeal5();		break;
			case 0xdb:	keydeal6();		break;
			case 0xeb:	
				break;
		}
		while((P2 & 0xf0) != 0xf0);	
	}

	P2 = 0xfd; 
	temp = P2 & 0xf0;
	if(temp != 0xf0)
	{
		delay_xs(10);
		if(temp != 0xf0)
			temp = P2;
		switch(temp)
		{
			case 0x7d: 	keydeal1();		break;
			case 0xbd:	keydeal2();		break;
			case 0xdd:	keydeal3();		break;
			case 0xed:	keydeal12(); 	break;
		}
		while((P2 & 0xf0) != 0xf0);
	}

	P2 = 0xfe;
	temp = P2 & 0xf0;
	if(temp != 0xf0)
	{
		delay_xs(10);
		if(temp != 0xf0)
			temp = P2;
		switch(temp)
		{
			case 0x7e:	keydeal11();	break;
			case 0xbe:	keydeal10();	break;
			case 0xde: 	keydeal15(); 	break;
			case 0xee:	keydeal16(); 	break;
		}
		while((P2 & 0xf0) != 0xf0);
	}
}

void display()
{
	uint c;
	writecom(0x80 + 0x40 + STLEN);
	delay_xs(5);
	if(alterflog == 0)			
	{
		for(c = 0; c < num; c++)
		{
			writedate('*');
			delay_xs(5);
		}
	}
	else						
	{
		for(c = 0; c < num1; c++)
		{
		writedate('#');
		delay_xs(5);
		}
	}


}

void init()
{
	uint i, a, b;
	num = 0;					
	num1 = 0;
	kai = 0;					
	l1 = 1;						
	alterflog = 0;				
	sda = 1;		
	delay();
	scl = 1;
	delay();
	lcden = 1;
	writecom(0x38);				
	delay_xs(5);
	writecom(0x38);				
	delay_xs(5);
	writecom(0x0c);
	delay_xs(5);
	writecom(0x06);
	delay_xs(5);
	writecom(0x80);
	delay_xs(5);
	writecom(0x01);
	for(i = 0; i < pwdLEN; i++)		
	{
		mima[i] = read24c02(i);
	}
	delay_xs(5);
	writecom(0x01);				
	delay_xs(5);
	writecom(0x80);
	delay_xs(5);
	for(a = 0; a < 16; a++)		
	{
		writedate(xianshi0[a]);
		delay_xs(5);
	}
	writecom(0x80 + 0x40 + STLEN);	
	delay_xs(5);
	for(b = 0; b < pwdLEN; b++)
	{

		writedate('-');
		delay_xs(5);
	} 
}

void mimachuzhi(void)
{
	int i;
	sda = 1;			
	delay();
	scl = 1;
	delay();
	for(i = 0;i < pwdLEN; i++)	 
	{
		write24c02(i, table1[i]);
		delay_xs(50);			
	}
	for(i = 0; i < pwdLEN; i++)
	{
		table1[i] = 0x0f;
	}
}


void main()
{	  mimachuzhi();
	init();						
	while(1)					
	{
		keyscan();				
		display();				
	}
}
matsukawahikari
关注
  • 2
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于c51单片机电子密码锁
01-10
电子密码锁课程设计，本系统由AT89S51单片机系统（主要是AT89S51单片机最小系统）、4×4矩阵键盘、LCD1602显示和报警系统等组成，具有设置、修改六位用户密码、超次报警、超次锁定、密码错误报警等功能（本设计由P0口控制LCD显示，密码正确显示password ok！ 密码错误显示password error！超过三次输入错误自动锁定。由P1口控制矩阵键盘含有0-9数字键和A-F功能键。）。除上述基本的密码锁功能外，依据实际的情况还可以添加遥控功能。
设计分享|基于单片机电子密码锁（汇编）
DZGCSCZRJ的博客
12-03 1131
（1）共3位密码，每位的取值范围为1～8。（2）用户可以自行设定和修改密码。（3）按每个密码键时都有声、光提示。（4）若键入的3位开锁密码不完全正确，则报警5秒钟，以提醒他人注意。（5）开锁密码错3次要报警10分钟，报警期间输入密码无效，以防窃贼多次试探密码。（6）键入的3位开锁密码完全正确才能开锁，LED灯亮表示开锁，开锁时要有1秒的提示音。（7）密码键盘上只允许有8个密码按键和1个LED灯。（8）密码设定完毕后要有2秒的提示音。
单片机课程设计--电子密码锁（源代码+proteus仿真）
mylxcg的博客
09-13 3万+
总体设计 本设计是基于AT89C51单片机的电子密码锁设计，实现电子密码锁的基本功能。 器件选择 序号 器件编号 Proteus器件名称 器件性质 参数及说明 1 U1 AT89C51 单片机 12MHz 2 D1-D2 LED .
基于单片机控制的电子密码锁
最新发布
qq_61141142的博客
09-19 808
其中CLR键的功能是当输入密码错误的时候，清除前面已经输入的数据，重新输入。AT24C02是ATMEL公司的2KB字节的电可擦除存储芯片，采用两线串行的总线和单片机通讯，电压最低可以到2.5V，额定电流为1mA，静态电流10Ua(5.5V)，芯片内的资料可以在断电的情况下保存40年以上，而且采用8脚的DIP封装，使用方便。随着人们生活水平的提高，如何实现家庭防盗这一问题也变的尤其的突出，传统的机械锁由于其构造的简单，被撬的事件屡见不鲜，电子锁由于其保密性高，使用灵活性好，安全系数高，受到了广大用户的亲呢。
基于单片机的电子密码锁设计
嵌入式基地
09-23 1万+
                    基于单片机控制的电子密码锁     摘要：本系统由单片机系统、矩阵键盘、LED显示和报警系统组成。系统能完成开锁、超时报警、超次锁定、管理员解密、修改用户密码基本的密码锁的功能。除上述基本的密码锁功能外，还具有调电存储、声光提示等功能，依据实际的情况还可以添加遥控功能。本系统成本低廉，功能实用     关键词：STC89C52，AT24C02, 电子密码锁，矩阵键盘 一、 引言     随着人们生活水平的提高，如何实现家庭防盗这一问题也变的尤其的
实验5. 单片机入门高级实验例程-电子密码锁.zip
12-25
在本实验中，我们将探索单片机编程与应用的一个经典案例——电子密码锁。这个实验是针对初学者设计的，旨在提升对单片机工作原理和控制逻辑的理解。电子密码锁是一个常见且实用的项目，它通过设定一组密码来实现锁的...
单片机课程设计——矩阵式键盘实现的电子密码锁.zip
09-21
在本项目"单片机课程设计——矩阵式键盘实现的电子密码锁"中，我们主要关注的是使用AT89S52单片机通过C语言编程来实现一个基于矩阵键盘的电子密码锁系统。这个设计涵盖了单片机硬件原理、C语言编程技巧以及输入设备...
##单片机电子密码锁 1602 6位.rar
12-14
本项目聚焦于一个基础且实用的单片机应用——51单片机电子密码锁设计。这款电子密码锁采用1602液晶显示器显示6位数字密码，通过矩阵键盘输入，实现对电磁锁的控制，为初学者提供了一个深入理解单片机控制逻辑、接口...
0172、基于单片机的指纹识别电子密码锁设计.zip
01-25
总的来说，基于单片机的指纹识别电子密码锁设计涵盖了嵌入式系统设计的多个方面，包括硬件电路设计、单片机编程、传感器技术、生物特征识别等，是学习和实践嵌入式开发的绝佳案例。通过这个项目，开发者不仅能掌握...
电子密码锁-带源程序电路图和pcb.rar
03-26
《电子密码锁设计详解——基于STM32与嵌入式硬件技术》 电子密码锁作为现代生活中常见的安全设备，广泛应用于家庭、办公室以及各种储物柜。本项目以"电子密码锁-带源程序电路图和pcb.rar"为主题，深入探讨了基于STM...
基于51单片机电子密码锁
10-12
基于51单片机的电子密码锁+仿真，欢迎大家下载参考，本人亲自调试的
基于单片机的密码锁(包括开锁、报警、重置、锁屏等功能)
03-22
基于单片机的密码锁，包括（1）设置6位密码，密码通过键盘输入，若密码正确，则将锁打开。 （2）密码可以由用户自己修改设定（只支持6位密码），锁打开后才能修改密码。修改密码之前必须再次输入密码，在输入新密码时候需要二次确认，以防止误操作。 （3）报警、锁定键盘功能。密码输入错误数码显示器会出现错误提示，若密码输入错误次数超过3次，蜂鸣器报警并且锁定键盘。 经调试，绝对可用
基于单片机的电子密码锁系统的设计
10-16
本系统采用单片机作控制器，用红外监视装置监测是否出现非正常开门的情况，红外监视装置的发射器和接收器分别安装在门的两边。系统工作时，用户通过按键输入8位密码，按下“确认”键后，单片机将输入密码与设定密码进行比较，若密码正确，则发出开锁信号，将门打开，同时关闭红外监视装置，系统不报警；若密码不正确，则有相应的指示灯闪动，并要求重新输入密码，重新输入密码的次数不超过3次，若3次输入的密码都不正确，则发出报警信号。当发生破门而入等非正常开锁情况时，红外监视装置仍然工作，门打开后挡住了信号，接收器接收不到信号，此时系统报警。锁打开后还可通过按下“修改/重置”功能键，重新设置新密码。主人外出关门后可通过“修改/重置”功能键恢复红外监视装置的工作。
单片机密码锁
10-16
很好的密码锁程序，4x4键盘，4位密码，数码管显示，值得拥有,51单片机密码锁
基于51单片机的电子密码锁
03-22 6820
51单片机密码锁设计
（含代码）基于51单片机电子密码锁设计
热门推荐
Yali2388
03-27 3万+
基于51单片机电子密码锁设计，包含硬件说明，电路仿真，实物制作
51单片机——电子密码锁
huashaoguang的博客
03-17 8713
51单片机——电子密码锁 链接: link. 图片: !protues仿真 ，下面展示同样高亮的 代码片. #include&lt;reg51.h&gt; unsigned char zt=1; unsigned char password[8]; unsigned char table[8]; unsigned char smg[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,...
基于51单片机的电子密码锁设计
单片机设计分享与定制
04-25 1万+
具体实现功能 系统由AT89S52单片机+AT24C02数据存储模块+按键模块+LCD1602显示+报警模块等构成。 具体功能: 1、输入密码，且输入的密码显示在液晶显示屏上； 2、按下“DorBell”后，会响起门铃声； 3、初始密码为“1234”，输入正确后，显示“OK”，并且LED灯闪烁，表示开门； 4、输入密码错误后，显示“Eror”，三次输入错误后会报警； 5、按下“DELE”,清除输入的密码。
Proteus模拟电子密码锁设计——基于80C51单片机
关键词涉及的领域包括电子密码锁的硬件组成部分——4x4矩阵键盘和1602LCD显示器，以及控制核心——52单片机。通过这样的设计，学生可以深入理解单片机在实际应用中的工作流程，为将来在电子工程领域的发展打下坚实...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值