基于单片机的智能密码锁

Ⅰ 基于单片机的电子密码锁设计

功能键
S6---S15 数字键0-9
S16---更改密码 S17---更改密码完毕后确认
S18---重试密码、重新设定 S19---关闭密码锁
初始密码：000000 密码位数：6位
注意：掉电后，所设密码会丢失，重新上点时，密码恢复为原始的000000
与P1相连的8位发光LED点亮代表锁被打开；熄灭代表锁被锁上

程序功能： 本程序结合了24C02存储器的存储功能，可以掉电保存密码。
第一次运行时，若输入000000原始密码后无反应，可以试验着将主程序中前面的
一小段被注释线屏蔽的程序前的注释线删掉，然后重新编译下载（可以将密码还原为000000）。
此后，再将这小段程序屏蔽掉，再编译下载。方可正常使用。
1、开锁：
下载程序后，直接按六次S7（即代表数字1），8位LED亮，锁被打开，输入密码时，
六位数码管依次显示小横杠。
2、更改密码：
只有当开锁（LED亮）后，该功能方可使用。
首先按下更改密码键S16，然后设置相应密码，此时六位数码管会显示设置密码对应
的数字。最后设置完六位后，按下S17确认密码更改，此后新密码即生效。
3、重试密码：
当输入密码时，密码输错后按下键S18，可重新输入六位密码。
当设置密码时，设置中途想更改密码，也可按下此键重新设置。
4、关闭密码锁：
按下S19即可将打开的密码锁关闭。
推荐初级演示步骤：输入原始密码000000---按下更改密码按键S16---按0到9设置密码---按S17
确认密码更改---按S18关闭密码锁---输入新的密码打开密码锁
*******************************************************************************/
#include<reg52.h>
#include <intrins.h>
#define uint unsigned int
#define uchar unsigned char

uchar old1,old2,old3,old4,old5,old6; //原始密码000000
uchar new1,new2,new3,new4,new5,new6; //每次MCU采集到的密码输入
uchar a=16,b=16,c=16,d=16,e=16,f=16; //送入数码管显示的变量
uchar wei,key,temp;

bit allow,genggai,ok,wanbi,retry,close; //各个状态位

sbit la=P2^6;
sbit wela=P2^7;
sbit beep=P2^3;
sbit sda=P2^0; //IO口定义
sbit scl=P2^1;

unsigned char code table[]=
{0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,
0x6f,0x77,0x7c,0x39,0x5e,0x79,0x71,0x00,0x40};

/*****************IIC芯片24C02存储器驱动程序************************************/

void nop()
{
_nop_();
_nop_();
}
/////////24C02读写驱动程序////////////////////
void delay1(unsigned int m)
{ unsigned int n;
for(n=0;n<m;n++);
}

void init() //24c02初始化子程序
{
scl=1;
nop();
sda=1;
nop();
}

void start() //启动I2C总线
{
sda=1;
nop();
scl=1;
nop();
sda=0;
nop();
scl=0;
nop();
}

void stop() //停止I2C总线
{
sda=0;
nop();
scl=1;
nop();
sda=1;
nop();
}

void writebyte(unsigned char j) //写一个字节
{
unsigned char i,temp;
temp=j;
for (i=0;i<8;i++)
{
temp=temp<<1;
scl=0;
nop();
sda=CY; //temp左移时，移出的值放入了CY中
nop();
scl=1; //待sda线上的数据稳定后，将scl拉高
nop();
}
scl=0;
nop();
sda=1;
nop();
}

unsigned char readbyte() //读一个字节
{
unsigned char i,j,k=0;
scl=0; nop(); sda=1;
for (i=0;i<8;i++)
{
nop(); scl=1; nop();
if(sda==1)
j=1;
else
j=0;
k=(k<<1)|j;
scl=0;
}
nop();
return(k);
}

void clock() //I2C总线时钟
{
unsigned char i=0;
scl=1;
nop();
while((sda==1)&&(i<255))
i++;
scl=0;
nop();
}

////////从24c02的地址address中读取一个字节数据/////
unsigned char read24c02(unsigned char address)
{
unsigned char i;
start();
writebyte(0xa0);
clock();
writebyte(address);
clock();
start();
writebyte(0xa1);
clock();
i=readbyte();
stop();
delay1(100);
return(i);
}

//////向24c02的address地址中写入一字节数据info/////
void write24c02(unsigned char address,unsigned char info)
{
start();
writebyte(0xa0);
clock();
writebyte(address);
clock();
writebyte(info);
clock();
stop();
delay1(5000); //这个延时一定要足够长，否则会出错。因为24c02在从sda上取得数据后，还需要一定时间的烧录过程。
}
/****************************密码锁程序模块********************************************************/

void delay(unsigned char i)
{
uchar j,k;
for(j=i;j>0;j--)
for(k=125;k>0;k--);
}

void display(uchar a,uchar b,uchar c,uchar d,uchar e,uchar f)
{
la=0;
P0=table[a];
la=1;
la=0;

wela=0;
P0=0xfe;
wela=1;
wela=0;
delay(5);

P0=table[b];
la=1;
la=0;

P0=0xfd;
wela=1;
wela=0;
delay(5);

P0=table[c];
la=1;
la=0;

P0=0xfb;
wela=1;
wela=0;
delay(5);

P0=table[d];
la=1;
la=0;

P0=0xf7;
wela=1;
wela=0;
delay(5);

P0=table[e];
la=1;
la=0;

P0=0xef;
wela=1;
wela=0;
delay(5);

P0=table[f];
la=1;
la=0;

P0=0xdf;
wela=1;
wela=0;
delay(5);
}

void keyscan()
{
{
P3=0xfe;
temp=P3;
temp=temp&0xf0;
if(temp!=0xf0)
{
delay(10);
if(temp!=0xf0)
{
temp=P3;
switch(temp)
{
case 0xee:
key=0;
wei++;
break;

case 0xde:
key=1;
wei++;
break;

case 0xbe:
key=2;
wei++;
break;

case 0x7e:
key=3;
wei++;
break;
}
while(temp!=0xf0)
{
temp=P3;
temp=temp&0xf0;
beep=0;
}
beep=1;
}
}
P3=0xfd;
temp=P3;
temp=temp&0xf0;
if(temp!=0xf0)
{
delay(10);
if(temp!=0xf0)
{
temp=P3;
switch(temp)
{
case 0xed:
key=4;
wei++;
break;

case 0xdd:
key=5;
wei++;
break;

case 0xbd:
key=6;
wei++;
break;

case 0x7d:
key=7;
wei++;
break;
}
while(temp!=0xf0)
{
temp=P3;
temp=temp&0xf0;
beep=0;
}
beep=1;
}
}
P3=0xfb;
temp=P3;
temp=temp&0xf0;
if(temp!=0xf0)
{
delay(10);
if(temp!=0xf0)
{
temp=P3;
switch(temp)
{
case 0xeb:
key=8;
wei++;
break;

case 0xdb:
key=9;
wei++;
break;

case 0xbb:
genggai=1;
wei=0;
break;

case 0x7b:
if(allow)
ok=1;
break;
}
while(temp!=0xf0)
{
temp=P3;
temp=temp&0xf0;
beep=0;
}
beep=1;
}
}
P3=0xf7;
temp=P3;
temp=temp&0xf0;
if(temp!=0xf0)
{
delay(10);
if(temp!=0xf0)
{
temp=P3;
switch(temp)
{
case 0xe7:
retry=1;
break;

case 0xd7:
close=1;
break;
}
while(temp!=0xf0)
{
temp=P3;
temp=temp&0xf0;
beep=0;
}
beep=1;
}
}
}
}

void shumima() //对按键采集来的数据进行分配
{
if(!wanbi)
{
switch(wei)
{
case 1:new1=key;
if(!allow) a=17;
else a=key; break;
case 2:new2=key;
if(a==17) b=17;
else b=key; break;
case 3:new3=key;
if(a==17) c=17;
else c=key; break;
case 4:new4=key;
if(a==17) d=17;
else d=key; break;
case 5:new5=key;
if(a==17) e=17;
else e=key; break;
case 6:new6=key;
if(a==17) f=17;
else f=key;
wanbi=1; break;
}
}
}

void yanzheng() //验证密码是否正确
{
if(wanbi) //只有当六位密码均输入完毕后方进行验证
{
if((new1==old1)&(new2==old2)&(new3==old3)&(new4==old4)&(new5==old5)&(new6==old6))
allow=1; //当输入的密码正确，会得到allowe置一
}
}

void main()
{

init(); //初始化24C02
/*********下面的一小段程序的功能为格式化密码存储区。************
******当24c02中这些存储区由于其他程序的运行而导致***************
*******所存数据发生了变化，或者密码遗忘时， ********************
******可以删掉其前面的注释线，然后重新编译下载。****************
******而将密码还原为000000后，请将下面的程序用******************
******注释屏蔽掉，重新编译、下载，方可正常使用****************/
// write24c02(110,0x00);
// write24c02(111,0x00);//24c02的第110到115地址单元作为密码存储区
// write24c02(112,0x00);
// write24c02(113,0x00);
// write24c02(114,0x00);
// write24c02(115,0x00);
/*******************************************************************/

old1=read24c02(110);
old2=read24c02(111);
old3=read24c02(112);
old4=read24c02(113);
old5=read24c02(114);
old6=read24c02(115);

while(1)
{
keyscan();
shumima();
yanzheng();
if(allow) //验证完后，若allow为1，则开锁
{
P1=0x00;
if(!genggai)
wanbi=0;
}
if(genggai) //当S16更改密码键被按下，genggai会被置一
{
if(allow) //若已经把锁打开，才有更改密码的权限
{
while(!wanbi) //当新的六位密码没有设定完，则一直在这里循环
{
keyscan();
shumima();
if(retry|close) //而当探测到重试键S18或者关闭密码锁键S19被按下时，则跳出
{ wanbi=1;
break;
}
display(a,b,c,d,e,f);
}
}
}
if(ok) //更改密码时，当所有六位新密码均被按下时，可以按下此键，结束密码更改
{ //其他时间按下此键无效
ok=0; wei=0;
genggai=0;
old1=new1;old2=new2;old3=new3; //此时，旧的密码将被代替
old4=new4;old5=new5;old6=new6;
//新密码写入存储区。
write24c02(110,old1);
write24c02(111,old2);
write24c02(112,old3);
write24c02(113,old4);
write24c02(114,old5);
write24c02(115,old6);
a=16;b=16;c=16;d=16;e=16;f=16;
}
if(retry) //当重试按键S18被按下，retry会被置位
{
retry=0; wei=0;wanbi=0;
a=16;b=16;c=16;d=16;e=16;f=16;
new1=0;new2=0;new3=0;new4=0;new5=0;new6=0;
}
if(close) //当关闭密码锁按键被按下，close会被置位
{
close=0;genggai=0;//所有变量均被清零。
wei=0; wanbi=0;
allow=0;
P1=0xff;
a=16;b=16;c=16;d=16;e=16;f=16;
new1=0;new2=0;new3=0;new4=0;new5=0;new6=0;
}
display(a,b,c,d,e,f); //实时显示
}
}
对着代码自己做吧，，要是还做不出来，，那我就不说什么了，，

Ⅱ 基于单片机课程设计密码锁

采用数字密码锁电路的好处就是设计简单。用以74LS112双JK触发器构成的数字逻辑电路作为密码锁的核心控制，共设了9个用户输入键，其中只有4个是有效的密码按键，其它的都是干扰按键，若按下干扰键，键盘输入电路自动清零，原先输入的密码无效，需要重新输入；如果用户输入密码的时间超过40秒（一般情况下，用户不会超过40秒，若用户觉得不便，还可以修改）电路将报警80秒，若电路连续报警三次，电路将锁定键盘5分钟，防止他人的非法操作。
电路由两大部分组成：密码锁电路和备用电源(UPS)，其中设置UPS电源是为了防止因为停电造成的密码锁电路失效，使用户免遭麻烦。
密码锁电路包含：键盘输入、密码修改、密码检测、开锁电路、执行电路、报警电路、键盘输入次数锁定电路。

Ⅲ 基于51单片机的密码锁程序

用STC52编的，下面是C程序，调试已经成功，自己看程序吧……
#include<reg52.h>
#include <intrins.h>

#define uchar unsigned char
#define uint unsigned int

#define LCD_data P0
sbit SDA=P3^5;
sbit SCL=P3^4;//24C08控制口设置
sbit LCD_RS = P3^3; //寄存器选择输入
sbit LCD_RW = P3^6; //液晶读/写控制
sbit LCD_EN = P3^7; //液晶使能控制
sbit LCD_PSB = P3^2; //串/并方式控制
sbit FM=P2^4;//蜂鸣器控制口
sbit RS=P2^5;
sbit T_CLK = P2^0; //实时时钟时钟线引脚 //
sbit T_IO = P2^1; //实时时钟数据线引脚 //
sbit T_RST = P2^2; //实时时钟复位线引脚 //
sbit ds=P2^3;
sbit EN=P2^6;
sbit ZZ=P2^7;
sbit FZ=P3^1;
sbit ACC0=ACC^0;
sbit ACC7=ACC^7;

uint temp1,s_temp; //定义整形变量
float f_temp; //定义浮点型变量

uchar time[]=" : : ";
uchar day[]=" 20 / / ( ) ";
uchar temp0[]=" 温度: . 度 ";
uchar num,num1,flag,count,a,b;
uchar unlock_i;//解密标志位

uchar t[4];
uchar t1[4];

void delay_ms(uint z)//长延时
{
uint x,y;
for(x=z;x>0;x--)
for(y=110;y>0;y--);
}

void delay() //短延时，大约5us
{
; ;
}
void reshi()
{
if(RS==1)
{ unlock_i=1;
}
else
{
unlock_i=0;
}
}
uchar code mima[]={'0','1','2','3','4','5','6','7','8','9','0','*'};

void lcd_xieping0(uchar x,uchar y,uchar date);
void lcd_xieping(uchar x,uchar y,uchar *str);
//********************************************************
// 开机显示
//********************************************************
void kjxs()
{
uint i,j;
lcd_xieping(0,0,"****************");
lcd_xieping(1,0," 欢迎进入 ");
lcd_xieping(2,0," 密码锁系统！ ");
lcd_xieping(3,0,"****************");
delay_ms(4000);
lcd_xieping(0,0," 系统初始化中 ");
lcd_xieping(1,0," 请稍后… ");
lcd_xieping(2,0,"————————");
lcd_xieping(3,0," ");
for(j=3;j>0;j--)
{
for(i=0;i<8;i++)
{
lcd_xieping(3,i,"*");
delay_ms(250);
}
lcd_xieping(3,0," ");
}
}
//********************************************************
// 12864显示
//********************************************************
void write_cmd(uchar cmd)
{
LCD_RS = 0;
LCD_RW = 0;
LCD_EN = 0;
P0 = cmd;
delay_ms(5);
LCD_EN = 1;
delay_ms(5);
LCD_EN = 0;
}
void write_dat(uchar dat)
{
LCD_RS = 1;
LCD_RW = 0;
LCD_EN = 0;
P0 = dat;
delay_ms(5);
LCD_EN = 1;
delay_ms(5);
LCD_EN = 0;
}
void lcd_xieping0(uchar x,uchar y,uchar date)
{
switch(x)
{
case 0: write_cmd(0x80+y); break;
case 1: write_cmd(0x90+y); break;
case 2: write_cmd(0x88+y); break;
case 3: write_cmd(0x98+y); break;
}
write_dat(date);
}
void lcd_xieping(uchar x,uchar y,uchar *str)
{
switch(x)
{
case 0: write_cmd(0x80+y); break;
case 1: write_cmd(0x90+y); break;
case 2: write_cmd(0x88+y); break;
case 3: write_cmd(0x98+y); break;
}
while (*str)
{
write_dat(*str);
str++;
}
}
void lcd_init()
{
LCD_PSB = 1; //并口方式
write_cmd(0x30); //基本指令操作
delay_ms(5);
write_cmd(0x0C); //显示开，关光标
delay_ms(5);
write_cmd(0x01); //清除LCD的显示内容
delay_ms(5);
}
//**************************************************************
// 键盘扫描函数
//**************************************************************
uchar keyscan1() //矩阵键盘扫描函数
{
uchar temp;
while(!num)
{P1=0xfe; //赋值
temp=P1; //读回数据
temp=temp&0xf0; //与运算
if(temp!=0xf0) //判断
{
delay_ms(2); //延时消抖
temp=P1; //读回数据
temp=temp&0xf0;
if(temp!=0xf0)
{
switch(temp) //多分支选择
{
case 0x70:num=1;break; //跳出
case 0xb0:num=2;break;
case 0xd0:num=3;break;
case 0xe0:num=4;break;
}
while(temp!=0xf0)
{
temp=P1;
temp=temp&0xf0;
}//等待按键释放
}
}
P1=0xfd; //赋值
temp=P1; //读回数据
temp=temp&0xf0; //与运算
if(temp!=0xf0) //判断
{
delay_ms(2); //延时消抖
temp=P1; //读回数据
temp=temp&0xf0;
if(temp!=0xf0)
{
switch(temp) //多分支选择
{
case 0x70:num=5;break; //跳出
case 0xb0:num=6;break;
case 0xd0:num=7;break;
case 0xe0:num=8;break;
}
while(temp!=0xf0)
{
temp=P1;
temp=temp&0xf0;
}//等待按键释放
}
}
P1=0xfb; //赋值
temp=P1; //读回数据
temp=temp&0xf0; //与运算
if(temp!=0xf0) //判断
{
delay_ms(2); //延时消抖
temp=P1; //读回数据
temp=temp&0xf0;
if(temp!=0xf0)
{
switch(temp) //多分支选择
{
case 0x70:num=9;break; //跳出
case 0xb0:num=10;break;
case 0xd0:num=11;break;
case 0xe0:num=12;break;
}
while(temp!=0xf0)
{
temp=P1;
temp=temp&0xf0;
}//等待按键释放
}
}
}
return(num); //返回值
}

uchar keyscan2()
{
uchar temp;
while(!num1)
{P1=0xf7; //赋值
temp=P1; //读回数据
temp=temp&0xf0; //与运算
if(temp!=0xf0) //判断
{
delay_ms(2); //延时消抖
temp=P1; //读回数据
temp=temp&0xf0;
if(temp!=0xf0)
{
switch(temp) //多分支选择
{
case 0x70:num1=1;break; //跳出
case 0xb0:num1=2;break;
case 0xd0:num1=3;break;
case 0xe0:num1=4;break;
}
while(temp!=0xf0)
{
temp=P1;
temp=temp&0xf0;
}//等待按键释放
}
}
}
return(num1);
}
//**************************************************************
// 直流电机
//**************************************************************
void dianjiZZ()
{
EN=1;
ZZ=1;
FZ=0;
}
void dianjiFZ()
{
EN=1;
ZZ=0;
FZ=1;
}
void dianji_stop()
{
EN=0;
}
//**************************************************************
// EPPROM
//**************************************************************
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 writebyte(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 readbyte() //读一个字节
{
uchar i,k;
SCL=0;
delay();
SDA=1;
for(i=0;i<8;i++)
{
SCL=1;
delay();
k=(k<<1)|SDA;
SCL=0;
delay();
}
delay();
return(k);

}
void write(uchar add,uchar date) //在一个地址写一个字节
{
start();
writebyte(0xa0);
respons();
writebyte(add);
respons();
writebyte(date);
respons();
stop();

}
uchar read(uchar add) //在一个地址读一个字节
{
start();
writebyte(0xa0);
respons();
writebyte(add);
respons();
start();
writebyte(0xa1);
respons();
b=readbyte();
respons();
stop();
return(b);
}
//**************************************************************
// 时间日期函数
//**************************************************************
void v_WTInputByte(uchar ucDa)
{
uchar i;
ACC= ucDa;
for(i=8; i>0; i--)
{
T_IO = ACC0; //*相当于汇编中的 RRC
T_CLK = 1;
T_CLK = 0;
ACC =ACC>> 1;
}
}
uchar uc_RTOutputByte(void)
{
uchar i;
for(i=8; i>0; i--)
{
ACC = ACC>>1; //*相当于汇编中的 RRC
ACC7 = T_IO;
T_CLK = 1;
T_CLK = 0;
}
return(ACC);
}
void v_W1302(uchar ucAddr, uchar ucDa)
{
T_RST = 0;
T_CLK = 0;
T_RST = 1;
v_WTInputByte(ucAddr); /* 地址，命令 */
v_WTInputByte(ucDa); /* 写1Byte数据*/
T_CLK = 1;
T_RST =0;
}
uchar uc_R1302(uchar ucAddr)
{
uchar ucDa;
T_RST = 0;
T_CLK = 0;
T_RST = 1;
v_WTInputByte(ucAddr); // 地址，命令 //
ucDa = uc_RTOutputByte(); // 读1Byte数据 //
T_CLK = 1;
T_RST =0;
return(ucDa);
}
void Init1302(void)
{
v_W1302(0x8e,0x00); //控制写入WP=0
v_W1302(0x80,0x80);
v_W1302(0x90,0xa9);
v_W1302(0x80,0x00); //秒
v_W1302(0x82,0x24); //分
v_W1302(0x84,0x12); //时
v_W1302(0x86,0x29); //日
v_W1302(0x88,0x10); //月
v_W1302(0x8a,0x05); //星期
v_W1302(0x8c,0x10); //年 //
v_W1302(0x8e,0x80);
}
void donetime(void)
{
uchar d;
d=uc_R1302(0x87);
day[10]=(d&0x0f)+48;
day[9]=((d>>4)&0x03)+48;
d=uc_R1302(0x89);
day[7]=(d&0x0f)+48;
day[6]=((d>>4)&0x01)+48;
d=uc_R1302(0x8b);
day[13]=(d&0x07)+48;
d=uc_R1302(0x8d);
day[4]=(d&0x0f)+48;
day[3]=(d>>4)+48;
d=uc_R1302(0x81);
time[15]=(d&0x0f)+48;
time[14]=(d>>4)+48;
d=uc_R1302(0x83);
time[12]=(d&0x0f)+48;
time[11]=(d>>4)+48;
d=uc_R1302(0x85);
time[9]=(d&0x0f)+48;
time[8]=(d>>4)+48;
}
//**************************************************************
// 温度检测函数
//**************************************************************
void dsreset(void) //18B20复位，初始化函数
{
uint i;
ds=0;
i=103;
while(i>0)i--;
ds=1;
i=4;
while(i>0)i--;
}
bit tempreadbit(void) //读1位函数
{
uint i;
bit dat;
ds=0;i++; //i++ 起延时作用
ds=1;i++;i++;
dat=ds; //读数据
i=8;while(i>0)i--;
return (dat);
}
uchar tempread(void) //读1个字节
{
uchar i,j,dat;
dat=0;
for(i=1;i<=8;i++)
{
j=tempreadbit();
dat=(j<<7)|(dat>>1); //读出的数据最低位在最前面，这样刚好一个字节在DAT里
}
return(dat);
}
void tempwritebyte(uchar dat) //向18B20写一个字节数据
{
uint i;
uchar j;
bit testb;
for(j=1;j<=8;j++)
{
testb=dat&0x01; //判断最后一位是1还是0
dat=dat>>1;
if(testb) //写 1
{
ds=0;
i++;i++;
ds=1;
i=8;while(i>0)i--;
}
else
{
ds=0; //写 0
i=8;while(i>0)i--;
ds=1;
i++;i++;
}
}
}

void tempchange(void) //DS18B20 开始获取温度并转换
{
dsreset(); //初始化，每次对18B20的操作都首先要初始化
delay_ms(1);
tempwritebyte(0xcc); // 写跳过读ROM指令
tempwritebyte(0x44); // 写温度转换指令
}
void get_temp() //读取寄存器中存储的温度数据
{
uchar a,b;
dsreset(); //初始化
delay_ms(1);
tempwritebyte(0xcc); // 写跳过读ROM指令
tempwritebyte(0xbe); //写读指令
a=tempread(); //读低8位
b=tempread(); //读高8位
temp1=b;
temp1<<=8; //两个字节组合为1个字
temp1=temp1|a;
f_temp=temp1*0.0625; //温度在寄存器中为12位 分辨率位0.0625°
}
//**************************************************************
// 解密函数
//**************************************************************
void unlock()
{
uchar in,i;
if(num==0)
{
lcd_xieping(0,0,"**密码锁系统** ");
lcd_xieping(1,0,"—————————");
lcd_xieping(2,0," 请输入密码： ");
lcd_xieping(3,0," ");
for(i=0;i<4;i++)
{
t1[i]=keyscan1();
lcd_xieping(3,i,"*");
num=0;
}//输密码
}
in=keyscan1();
if(in==12)//in-确定键标志位
{
in=0;
num=0;
if((t1[0]==t[0])&&(t1[1]==t[1])&&(t1[2]==t[2])&&(t1[3]==t[3]))
{
flag=1;//解密成功与否标志位
//unlock_i=1;
a=0;//功能键标志
lcd_xieping(0,0,"**密码锁系统** ");
lcd_xieping(1,0,"——————————");
lcd_xieping(2,0," 密码正确！ ");
lcd_xieping(3,0," 您的身份已确认");
delay_ms(1500);
lcd_xieping(1,0,"————————");
lcd_xieping(2,0,"功能 I 开锁 ");
lcd_xieping(3,0," II修改密码");
}
else
{
flag=0;
count++;
if(count==3)
{
count=0;
num=1;
lcd_xieping(1,0,"——————————");
lcd_xieping(2,0,"您的机会已用完 ");
lcd_xieping(3,0,"对不起**无法进入");
FM=0;
delay_ms(1000);
FM=1;
}
}
}
}
//**************************************************************
// 修改密码函数
//**************************************************************
void xiugaimima()
{ uchar i,j,l,im,ib;
uchar t2[4];
uchar t3[4];
num=0;
lcd_xieping(1,0,"————————");
lcd_xieping(2,0,"请输入新密码： ");
lcd_xieping(3,0," ");
for(i=0;i<4;i++)
{
t2[i]=keyscan1();
lcd_xieping0(3,i,mima[num]);
num=0;
}
im=keyscan1();
if(im==12)//im,in,ib,同为确定键标志位
{
im=0;
num=0;
lcd_xieping(1,0,"————————");
lcd_xieping(2,0,"请再次输入新密码");
lcd_xieping(3,0," ");
for(i=0;i<4;i++)
{
t3[i]=keyscan1();
lcd_xieping0(3,i,mima[num]);
num=0;
}
}
ib=keyscan1();
if(ib==12)
{
ib=0;
num=0;
if(t2[0]==t3[0]&&t2[1]==t3[1]&&t2[2]==t3[2]&&t2[3]==t3[3])
{
t[0]=t3[0];
t[1]=t3[1];
t[2]=t3[2];
t[3]=t3[3];
lcd_xieping(1,0,"————————");
lcd_xieping(2,0," 祝贺您！ ");
lcd_xieping(3,0," 密码修改成功 ");
flag=0;
for(j=0;j<4;j++)
{
l=j+1;
write(l,t[j]);
delay_ms(10);
}//24C08写数据
delay_ms(1000);
}
else
{
lcd_xieping(2,0,"两次输入密码不同");
lcd_xieping(3,0," 密码修改失败 ");
flag=1;
delay_ms(500);
}
}
}
//**************************************************************
// 显示函数
//**************************************************************
void xianshi()
{
donetime();
tempchange();
get_temp();
s_temp=f_temp*100;
temp0[7]=(s_temp/1000)+48;
temp0[8]=(s_temp%1000/100)+48;
temp0[10]=(s_temp%100/10)+48;
temp0[11]=(s_temp%10)+48;
lcd_xieping(0,0,"**密码锁系统** ");
lcd_xieping(1,0,temp0);
lcd_xieping(2,0,day);
lcd_xieping(3,0,time);
num=0;
}
//**************************************************************
// 开锁函数
//**************************************************************
void kaisuo()
{
uchar i;
lcd_xieping(2,0," 开锁中…… ");
lcd_xieping(3,0,"——耐心等待——");
for(i=3;i>0;i--)
{
FM=0;
delay_ms(100);
FM=1;
delay_ms(100);
flag=0;
}
dianjiZZ();
delay_ms(10000);
dianji_stop();
lcd_xieping(2,0,"—开锁过程结束—");
lcd_xieping(3,0," 请开门 ");
delay_ms(5000);
dianjiFZ();
delay_ms(10000);
dianji_stop();
flag=0;
}
//**************************************************************
// 主函数
//**************************************************************
void main()
{
uchar m;
unlock_i=1;
lcd_init(); //液晶初始化
//Init1302();
kjxs(); //开机显示
for(m=0;m<4;m++)
{
t[m]=read(m+1);
delay_ms(10);
}//24C08读数据
while(1)
{
reshi();
if(!unlock_i)
{
unlock();//解密函数
}
else
{
xianshi();//时间、日期、温度显示函数
}
if(flag==1)
{
num1=0;
a=keyscan2();
if(a==1)
{
kaisuo();//开锁函数
}
if(a==2)
{
xiugaimima();//修改密码函数
}
}
}
}

Ⅳ 基于单片机的电子密码锁，复位电路的用途是什么，复位后密码会变成初始密码嘛

基于单片机的电子密码锁复位，电路液的用途是什么？复位后密码会变成初始密码吗？这个复位后肯定会变成初始密码的，因为很多的时候都会出现一些机械故障，或者是人为的故障，等等，这个肯定需要复位，不管什么样的电路也好，它都会产生一些不可抗的bug，或者是电池变小等等，产生了一些不可抗的因素，等等，肯定是需要一些复位的按钮的，复位的电路就是把初始就是原来的已经设置的密码变为初始的密码。