单片机密码输入_单片机电子密码锁设计采用4×4键盘实现密码的输入功能当密码输入正确之后锁就打开如果输入的密码

❶ 用单片机设计一个简易的密码锁，用键盘输入0~9三位数的密码.密码输入正确显示“P”约3s，并通过P3.0端口将

你这个问题内容量太大，不可能有谁那么多时间给你开发，我这边有个做过的类似的，代码送你了。

#include<msp430x14x.h>
#include"Delay.h"
#include"x24c02.h"
#include"LCD1602.h"

ucharLCD_ID_1[16]={"Password:------"};
ucharLCD_ID_2[16]={"OldCode:------"};
ucharLCD_ID_3[16]={""};
ucharLCD_ID_4[16]={"NewCode:------"};

#defineJI_OPENP3OUT|=BIT6
#defineJI_CLOSEP3OUT&=~BIT6

uchara=10,b=10+0x40,c=0,i=0,j=0,k=0,super=0;

ucharflag=0;

uchartable1[6]={1,2,3,4,5,6};
uchartable2[6]={0,0,0,0,0,0};
uchartable3[6]={0,0,0,0,0,0};
ucharsupercode[6]={8,8,8,8,8,8};
//SCL时钟线
#defineSCO_SETP1OUT|=BIT3//输出高
#defineSCO_RESETP1OUT&=(~BIT3)//输出低
#defineSCO_IN(P1IN&BIT3)//输出
#defineSCOINP1DIR&=(~BIT3)//设置输入
#defineSCOOUTP1DIR|=BIT3//设置输出
//SDA数据线
#defineSDO_SETP1OUT|=BIT2
#defineSDO_RESETP1OUT&=(~BIT2)
#defineSDO_IN(P1IN&BIT2)
#defineSDOINP1DIR&=(~BIT2)
#defineSDOOUTP1DIR|=BIT2

voidshuru(void);
voidshe(void);
voidbijiao(void);

ucharchumo_read(void)
{
uchari,dat;
SCOOUT;//设置输出
SCO_RESET;//输出低

SDOOUT;
SDO_SET;
delay_us(93);
SDO_RESET;
delay_us(10);
SDOIN;

for(i=0;i<16;i++)
{
SCO_SET;
delay_us(5);

if(SDO_IN!=0)
{
dat=i+1;
}

SCO_RESET;
delay_us(5);
}
delay_ms(2);
returndat;
}

voidOPEN(void)
{
P1OUT|=BIT4;
P3OUT&=~BIT5;
delay_ms(1000);delay_ms(1000);
P3OUT&=~BIT5;
P1OUT&=~BIT4;
}
voidCLOSE(void)
{
P3OUT|=BIT5;
P1OUT&=~BIT4;
delay_ms(1000);delay_ms(1000);
P3OUT&=~BIT5;
P1OUT&=~BIT4;
}
voidmain(void)
{
//系统初始化
WDT_Init();//STOPWDT
MCLK_Init();//MCLK=8M
Port_Init();//CLOSEALLPORT

P3DIR|=BIT5;
P1DIR|=BIT4;
P3OUT&=~BIT5;
P1OUT&=~BIT4;
d24c_init();

L1602_Init();
L1602_string(1,1,LCD_ID_1);

P3DIR|=BIT6;
P3DIR&=~BIT7;
P6DIR|=BIT2;
JI_CLOSE;

delay_ms(10);
table1[0]=d24c_read(1);
delay_ms(20);
table1[1]=d24c_read(2);
delay_ms(20);
table1[2]=d24c_read(3);
delay_ms(20);
table1[3]=d24c_read(4);
delay_ms(20);
table1[4]=d24c_read(5);
delay_ms(20);
table1[5]=d24c_read(6);
delay_ms(500);

while(1)
{
delay_ms(100);

shuru();
she();
bijiao();
}
}

voidshuru(void)
{
wcmd(0x80+a+c);
wcmd(0x0f);

if((chumo_read()!=0)&&(chumo_read()<11))
{
delay_ms(10);
if(chumo_read()!=0)
{
table2[c]=chumo_read();
L1602_char(1,a+c+1,(chumo_read()%10)+0X30);
c++;
delay_ms(500);
if(c==6)
{
c=0;
L1602_string(1,1,LCD_ID_1);
}
}
}

j=0;
for(i=0;i<6;i++)
{
if(table1[i]!=table2[i])
{
j=1;
break;
}
}

if(chumo_read()==13)
{
delay_ms(10);
if(chumo_read()==13)
{
c=0;
L1602_string(1,1,LCD_ID_1);
delay_ms(1000);
}
}
}

voidshe(void)
{
if(chumo_read()==16)
{
delay_ms(10);
if(chumo_read()==16)
{
L1602_string(1,1,LCD_ID_3);
L1602_string(2,1,LCD_ID_2);
flag=1;
c=0;
delay_ms(500);
}
}
while(flag==1)
{
wcmd(0x80+0x40+a+c);
wcmd(0x0f);

if((chumo_read()!=0)&&(chumo_read()<11))
{
delay_ms(10);
if(chumo_read()!=0)
{
table2[c]=chumo_read();
L1602_char(2,a+c+1,(chumo_read()%10)+0X30);
c++;
delay_ms(500);
if(c==6)
{
c=0;
L1602_string(2,1,LCD_ID_2);
super=1;
for(i=0;i<6;i++)
{
if(supercode[i]!=table2[i])
{
super=0;
break;
}
}
}
}
}

k=1;
for(i=0;i<6;i++)
{
if(table1[i]!=table2[i])
{
k=0;
break;
}
}

if(chumo_read()==13)
{
delay_ms(10);
if(chumo_read()==13)
{
c=0;
L1602_string(2,1,LCD_ID_2);
delay_ms(1000);
}
}

if(k==1||super==1)
{
L1602_string(2,1,LCD_ID_4);
}
while(k==1||super==1)
{
wcmd(0x80+0x40+a+c);
wcmd(0x0f);

if((chumo_read()!=0)&&(chumo_read()<11))
{
delay_ms(10);
if(chumo_read()!=0)
{
table1[c]=chumo_read();
L1602_char(2,a+c+1,(chumo_read()%10)+0X30);
c++;
if(c==6)
{
delay_ms(1000);
c=0;
flag=0;
k=0;
super=0;
d24c_write(1,table1[0]);
delay_ms(30);
d24c_write(2,table1[1]);
delay_ms(30);
d24c_write(3,table1[2]);
delay_ms(30);
d24c_write(4,table1[3]);
delay_ms(30);
d24c_write(5,table1[4]);
delay_ms(30);
d24c_write(6,table1[5]);
delay_ms(30);

L1602_string(1,1,LCD_ID_1);
L1602_string(2,1,LCD_ID_3);
}
}
delay_ms(400);
}
delay_ms(100);
if(chumo_read()==13)
{
delay_ms(10);
if(chumo_read()==13)
{
c=0;
L1602_string(2,1,LCD_ID_2);
delay_ms(500);
}
}
}
}
}
voidbijiao()
{
if((j==0)||((P3IN&BIT7)!=0))
{
JI_OPEN;
P6OUT&=~BIT2;
OPEN();
delay_ms(2000);
L1602_string(1,1,LCD_ID_1);
for(i=0;i<6;i++)
{
table2[i]=0;
}
JI_CLOSE;
CLOSE();
}
else
{
P6OUT|=BIT2;
}
}

❷ proteus使用芯片时要输密码是啥意思

Proteus是英国Labcenter公司开发的EDA工具软件，它集合了原理图设计、电路分析与仿真、单片机代码级调试与仿真、系统测试与功能验证以及PCB设计完整的电子设计过程。Proteus ISIS是智能原理图输入系统，利用该系统既可以进行智能原理图设计、绘制和编辑，又可以进行电路分析与实物仿真。尤为突出的是，它是到目前为止最适合单片机系统开发使用的设计与仿真平台。
1.一个密码锁必须有密码，所以最开始我们点击SETKEY开始设置密码，点击输入准备READY开始输入密码，DELETE可回退,输入完成后点击SURE保存密码然后点击CLOSE
2.每次要输入密码时都需点击READY准备输入然后进行输入密码开锁
3.当密码正确小灯会亮,数码管显示ON即密码锁打开,并且可以点击MODIFY进行修改密码
4.当密码错误时数码管显示err，并且单独的数码管显示错误次数，当错误达到三次则会进行倒计时报警

❸ 51单片机C语言简易的密码输入

#include<reg52.h> //包含头文件，一般情况不需要改动，头文件包含特殊功能寄存器的定义

#define DataPort P0 //定义数据端口程序中遇到DataPort 则用P0 替换
#define CtrlPort P1
#define KeyPort P2

unsigned char code DuanMa[]={0xc0,0xf9,0xa4,0xb0,
0x99,0x92,0x82,0xf8,
0x80,0x90,0x88,0x83,
0xa7,0xa1,0x86,0x8e};// 显示段码值0~F
unsigned char code WeiMa[]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};//分别对应相应的数码管点亮,即位码
unsigned char TempData[8]; //存储显示值的全局变量
unsigned char code password[8]={1,2,3,4,5,6,7,8};
//可以更改此密码做多组测试

void DelayUs2x(unsigned char t);//us级延时函数声明
void DelayMs(unsigned char t); //ms级延时
void Display(unsigned char FirstBit,unsigned char Num);//数码管显示函数
unsigned char KeyScan(void);//键盘扫描
unsigned char KeyPro(void);
void Init_Timer0(void);//定时器初始化
/*------------------------------------------------
主函数
------------------------------------------------*/
void main (void)
{
unsigned char num,i,j;
unsigned char temp[8];
bit Flag;
Init_Timer0();

while (1) //主循环
{

CtrlPort = 0;
num=KeyPro();
if(num!=0xff)
{
if(i==0)
{
for(j=0;j<8;j++)//清屏
TempData[j]=0;
}
if(i<8)
{
temp[i]=DuanMa[num];//把按键值输入到临时数组中
for(j=0;j<=i;j++) //通过一定顺序把临时数组中
//的值赋值到显示缓冲区，从右往左输入
TempData[7-i+j]=temp[j];
}
i++; //输入数值累加
if(i==9)//正常等于8即可，由于我们需要空一个用于清屏，
//清屏时的按键不做输入值
{
i=0;
Flag=1;//先把比较位置1
for(j=0;j<8;j++)//循环比较8个数值，
//如果有一个不等则最终Flag值为0
Flag=Flag&&(temp[j]==DuanMa[password[j]]);
//比较输入值和已有密码
for(j=0;j<8;j++)//清屏
TempData[j]=0;
if(Flag)//如果比较全部相同，标志位置1
{
TempData[0]=~0x3f; // "o"
TempData[1]=~0x73; // "p"
TempData[2]=~0x79; // "E"
TempData[3]=~0x54; // "n"
//说明密码正确，输入对应操作显示"open"
}
else
{
TempData[0]=~0x79; // "E"
TempData[1]=~0x50; // "r"
TempData[2]=~0x50; // "r"
//否则显示"Err"
}

}
}
}
}
/*------------------------------------------------
uS延时函数，含有输入参数 unsigned char t，无返回值
unsigned char 是定义无符号字符变量，其值的范围是
0~255 这里使用晶振12M，精确延时请使用汇编,大致延时
长度如下 T=tx2+5 uS
------------------------------------------------*/
void DelayUs2x(unsigned char t)
{
while(--t);
}
/*------------------------------------------------
mS延时函数，含有输入参数 unsigned char t，无返回值
unsigned char 是定义无符号字符变量，其值的范围是
0~255 这里使用晶振12M，精确延时请使用汇编
------------------------------------------------*/
void DelayMs(unsigned char t)
{

while(t--)
{
//大致延时1mS
DelayUs2x(245);
DelayUs2x(245);
}
}
/*------------------------------------------------
显示函数，用于动态扫描数码管
输入参数 FirstBit 表示需要显示的第一位，如赋值2表示从第三个数码管开始显示
如输入0表示从第一个显示。
Num表示需要显示的位数，如需要显示99两位数值则该值输入2
------------------------------------------------*/
void Display(unsigned char FirstBit,unsigned char Num)
{
static unsigned char i=0;

DataPort=0; //清空数据，防止有交替重影

CtrlPort=WeiMa[i+FirstBit]; //取位码

DataPort=TempData[i]; //取显示数据，段码

i++;
if(i==Num)
i=0;

}
/*------------------------------------------------
定时器初始化子程序
------------------------------------------------*/
void Init_Timer0(void)
{
TMOD |= 0x01; //使用模式1，16位定时器，使用"|"符号可以在使用多个定时器时不受影响
//TH0=0x00; //给定初值
//TL0=0x00;
EA=1; //总中断打开
ET0=1; //定时器中断打开
TR0=1; //定时器开关打开
}
/*------------------------------------------------
定时器中断子程序
------------------------------------------------*/
void Timer0_isr(void) interrupt 1
{
TH0=(65536-2000)/256; //重新赋值 2ms
TL0=(65536-2000)%256;

Display(0,8); // 调用数码管扫描

}

/*------------------------------------------------
按键扫描函数，返回扫描键值
------------------------------------------------*/
unsigned char KeyScan(void) //键盘扫描函数，使用行列反转扫描法
{
unsigned char cord_h,cord_l;//行列值中间变量
KeyPort=0x0f; //行线输出全为0
cord_h=KeyPort&0x0f; //读入列线值
if(cord_h!=0x0f) //先检测有无按键按下
{
DelayMs(10); //去抖
if((KeyPort&0x0f)!=0x0f)
{
cord_h=KeyPort&0x0f; //读入列线值
KeyPort=cord_h|0xf0; //输出当前列线值
cord_l=KeyPort&0xf0; //读入行线值

while((KeyPort&0xf0)!=0xf0);//等待松开并输出

return(cord_h+cord_l);//键盘最后组合码值
}
}return(0xff); //返回该值
}
/*------------------------------------------------
按键值处理函数，返回扫键值
------------------------------------------------*/
unsigned char KeyPro(void)
{
switch(KeyScan())
{
case 0xee:return 0;break;//0 按下相应的键显示相对应的码值
case 0xde:return 1;break;//1
case 0xbe:return 2;break;//2
case 0x7e:return 3;break;//3
case 0xed:return 4;break;//4
case 0xdd:return 5;break;//5
case 0xbd:return 6;break;//6
case 0x7d:return 7;break;//7
case 0xeb:return 8;break;//8
case 0xdb:return 9;break;//9
case 0xbb:return 10;break;//a
case 0x7b:return 11;break;//b
case 0xe7:return 12;break;//c
case 0xd7:return 13;break;//d
case 0xb7:return 14;break;//e
case 0x77:return 15;break;//f
default:return 0xff;break;
}
}

❹ 单片机电子密码锁设计，采用4×4键盘实现密码的输入功能，当密码输入正确之后，锁就打开，如果输入的密码

#include <reg52.h>
#define uint unsigned int
#define uchar unsigned char
#define KEY P3 //键盘输入端口
#define No_key 20 //无按键时的返回值
#define lcddata P2 //1602的数据输入端口
sbit lcden= P1^2;
sbit lcdrs= P1^0;
sbit lcdrw= P1^1;
sbit light= P1^3;
sbit light1= P1^4;
uchar j ; //用来统计输入个数的全局变量
uchar aa; //用来在定时器中计数的全局变量

uchar code table[]= " Hello!";
uchar code table1[]=" OK! " ;
uchar code table2[]="Enter please:" ;
uchar code key_table[16] =
{
1,2,3,10,
4,5,6,11,
7,8,9,12,
0,13,14,15
};
uchar password[]={2,0,1,0,9,3} ; //设定初始密码
uchar save[6]; //保存输入的数据
uchar conflag ; //确认标志
uchar lockflag; //锁键盘标志
uchar startflag; //开始标志

void delay(uint z); //延时子函数
void wright_com(uchar com); //写指令函数
void wright_data(uchar date) ; //写数据函数
void init(); //初始化
void display_OK(); // 显示OK
void delete(); //删除输入的最后一个数

uchar keyscan() ; //带返回值的键盘扫描程序

void enter_code(uchar t); //输入密码函数，把输入的数据存入数组中并在屏幕上显示相应的东西,
void confirm(); //确认密码对不对，把输入的数据与密码逐一对比，完全一样刚正确，
void succeed_an(); //输入密码成功时的响应,
void fail_an(); //输入密码失败时响应
void lockkey(); //锁键盘三秒
void alarm(); //发出警报声
void reset(); //复位函数
void display_enter(); //显示输入
void main(void)
{
uchar temp;
init();
while(1)
{

if(lockflag)
{
temp=keyscan(); // 锁键期间也要进行键盘扫描
if(temp!=No_key) //重新记时三秒
{
aa=0; //重新在定时器中计数
}

}
else
{
temp=keyscan(); //反复扫描输入，等待随时输入

if(temp!=No_key) //有按键按下才进行下面的操作
{
if(temp==10)
{
reset();
startflag=1; //开始标志置位
}
if(startflag)
{
enter_code(temp); //每扫描一次键盘就要进行一次处理，保存输入的数值

if(temp==13) //按下确认键盘就要进行密码确认
{
confirm(); //进行确认判断
if(conflag) //密码确认为正确
{
succeed_an(); //密码正确，作出相应的反应
}
else
{
fail_an(); //密码错误，作相应反应
}
}

if(temp==14)
{
delete(); //作删除操作
}
}
}
}

}
}
/****** 显示enter********/
void display_enter()
{
uchar num;
wright_com(0x80);
for(num=0;num<13;num++)
{
wright_data(table2[num]);
}
}
/****** 显示OK********/
void display_OK()
{
uchar num;
wright_com(0x80);
for(num=0;num<13;num++)
{

wright_data(table1[num]);
}
}
/****** 删除最后一个********/
void delete()
{
wright_com(0x80+0x40+j); //确定删除对象
wright_data(' '); //显示空格即为删除
save[--j]=0; //删除后数据清零
wright_com(0x80+0x40+j); //为下次输入数据时写好位置，必须是在最后一个后面
}
/****** 对各种变量进行复位********/
void reset()
{
uchar num;
display_enter();
wright_com(0x80+0x40); //擦除屏幕上的显示
for(num=0;num<6;num++)
{
save[num]=0; //对输入的数值进行清零
wright_data(' '); //显示的是空格
}
wright_com(0x80+0x40); //下次再输入时可以又从起始位置输入
lockflag=0; //各种变量要清零回起始状态
conflag=0;
j=0;
}
/****** 输入密码正确进行响应********/
void succeed_an()
{

light=0; //灯亮
display_OK(); //显示成功
delay(1000);
light=1; //灯灭
}
/****** 输入密码错误进行响应********/
void fail_an()
{
alarm();
lockkey();
}
/****** 发出警报声**********/
void alarm() //这个以后再扩展它
{

}
/******锁键盘三秒************/
void lockkey()
{
lockflag=1;
}
/******输入密码并在屏幕上显示星号******/
void enter_code(uchar t)
{

if(t>=0&&t<10)
{

if(j==0)
{
wright_com(0x80+0x40) ; //第一输入时要先写入地址指令，否则无法显示
wright_data('*') ;
}
else
{
wright_data('*') ;//不是第一个输入则不用再写地址
}
save[j++]=t; //保存输入的数据
}
}

/******校对密码以确定是不是正确的**********/
void confirm()
{
uchar k;
for(k=0;k<6;k++)
{
if(password[k]!=save[k]) //对数组中的内容进行逐一比较，一旦有数据不对马上退出循环
{
break;
}
}
if(k==6) //要是条件退出的话说明六个数全对密码
{
conflag=1; // 进行标志密码正确
}

}

/******中断服务程序**********/
void timer0() interrupt 1
{

TH0=(65536-50000)/256;
TL0=(65536-50000)%256; //重装初值
if(lockflag)
{
aa++;
light1=0;
if(aa>=60) //三秒到了
{
aa=0; //清零可以方便下次再使用
light1=1; //关闭警报
lockflag=0; //标志清零解除键锁，方便下次使用

}
}

}
/******初始化***********/
void init()
{
uchar num;
/*****定时器初始化****/
TMOD=1;
TH0=(65536-50000)/256;
TL0=(65536-50000)%256;
ET0=1;
EA=1; //开启总中断
TR0=1;//把定时器关闭

/****1602初始化******/
lcdrw=0; //这个必须要置零，否则无法正常显示
lcden=0;
wright_com(0x38) ; //初始化
wright_com(0x0c) ; //打开光标 0x0c不显示光标 0x0e光标不闪，0x0f光标闪
wright_com(0x01) ; //清显示
wright_com(0x80) ;
for(num=0;num<9;num++)
{
wright_data(table[num]);
delay(1);
}
}
/******1602写入指令************/
void wright_com(uchar com)
{
lcdrs=0;
lcddata=com;
delay(1);
lcden=1;
delay(1);
lcden=0;
}
/******1602写入数据***********/
void wright_data(uchar date)
{
lcdrs=1;
lcddata=date;
delay(1);
lcden=1;
delay(1);
lcden=0;
}
/******延时函数************/
void delay(uint z)
{
uint x,y;
for(x=z;x>0;x--)
for(y=110;y>0;y--) ;
}

/**********4x4矩阵键盘扫描函数*********/
uchar keyscan()
{
uchar temp,num=No_key; //num的初值要为无键盘按下时的返回值
/*********扫描第一行****************/
KEY=0xfe;
temp=KEY;
temp=temp&0xf0; //读出高四位
while(temp!=0xf0)
{

delay(5); //延时消抖
temp=KEY;
temp=temp&0xf0;
while(temp!=0xf0) //确认确实有按键按下
{

temp=KEY;
switch(temp) //根据这八个电平可以确定是哪个按键按下
{
case 0xee:num=1;
break;
case 0xde:num=2;
break;
case 0xbe:num=3;
break;
case 0x7e:num=10;
break;
}
while(temp!=0xf0) //等待松手
{
temp=KEY;
temp=temp&0xf0;
}

}
}
/*********扫描第二行***************/
KEY=0xfd;
temp=KEY;
temp=temp&0xf0;
while(temp!=0xf0)
{
delay(5);
temp=KEY;
temp=temp&0xf0;
while(temp!=0xf0)
{

temp=KEY;
switch(temp)
{
case 0xed:num=4;
break;
case 0xdd:num=5;
break;
case 0xbd:num=6;
break;
case 0x7d:num=11;
break;
}
while(temp!=0xf0)
{
temp=KEY;
temp=temp&0xf0;
}

}
}
/*********扫描第三行****************/
KEY=0xfb;
temp=KEY;
temp=temp&0xf0;
while(temp!=0xf0)
{
delay(5);
temp=KEY;
temp=temp&0xf0;
while(temp!=0xf0)
{
temp=KEY;
switch(temp)
{
case 0xeb:num=7;
break;
case 0xdb:num=8 ;
break;
case 0xbb:num=9;
break;
case 0x7b:num=12;
break;
}
while(temp!=0xf0)
{
temp=KEY;
temp=temp&0xf0;
}

}
}
/*********扫描第四行****************/
KEY=0xf7;
temp=KEY;
temp=temp&0xf0;
while(temp!=0xf0)
{
delay(5);
temp=KEY;
temp=temp&0xf0;
while(temp!=0xf0)
{
temp=KEY;
switch(temp)
{
case 0xe7:num=0;
break;
case 0xd7:num=13;
break;
case 0xb7:num=14;
break;
case 0x77:num=15;
break;
}
while(temp!=0xf0)
{
temp=KEY;
temp=temp&0xf0;
}

}
}

return num;
}

❺ 单片机在输入密码时能用的加密算法

我认为单片机在输入密码的时候，能够加入密算说法是非常正确的，而且它的算数的结果是非常正确的。

❻ 基于51单片机的密码锁

基于51单片机的密码锁的话其实我是不知道是什么意思的所以说不好意思咯(๑ó﹏ò๑)

❼ 单片机电子密码锁设置

我发了

❽ 51单片机C语言，电子密码的验证输入程序，矩阵键盘用作输入，密码正确时，向串口送1,否则送0

#include<reg51.h>
#defineucharunsignedchar
ucharkeyval,keynum=0;
voidt1isr()interrupt3
{
	ucharsccode,recode;
	TH0=(65536-10000)/256;
	TL0=(65536-10000)%256;
	P3=0x0f;//发0扫描,列线输入
	if((P3&0x0f)!=0x0f)keynum++;//有键按下
		elsekeynum=0;
		if(keynum>5)	//按键保持在5次中断以上
			{
			keynum=0;
			sccode=0xef;//逐行扫描初值
			while((sccode&0x01)!=0)
			{
			P3=sccode;
				if((P3&0x0f)!=0x0f)
				{
				recode=(P3&0x0f)|0xf0;
					getkey((~sccode)+(~recode));
				}
		else
				sccode=(sccode<<1)|0x01;
			}
		}
		getkey(0);
}

voidgetkey(ucharkey)
{
	if(key==0){keyval=0xff;return;}
		switch(key)
		{
		case0x11:keyval=7;break;
		case0x12:keyval=4;break;
		case0x14:keyval=1;break;
		case0x18:keyval=10;break;
		case0x21:keyval=8;break;
		case0x22:keyval=5;break;
		case0x24:keyval=2;break;
		case0x28:keyval=0;break;
		case0x41:keyval=9;break;
		case0x42:keyval=6;break;
		case0x44:keyval=3;break;
		case0x48:keyval=11;break;
		case0x81:keyval=12;break;
		case0x82:keyval=13;break;
		case0x84:keyval=14;break;
		case0x88:keyval=15;break;
		default:keyval=0xff;break;
		}
}
main()
{
ucharmima[]="12345678";
ucharmmins[8];
uchari,num,sc;
	TMOD=0x21;
	TH0=(65536-10000)/256;
	TL0=(65536-10000)%256;
	TR0=1;
	ET0=1;
	TH1=0xfd;
	TL1=0xfd;
	TR1=1;
	SCON=0x40;
	EA=1;
	num=0;
	while(1)
	{
	if(keyval!=0xff){mmins[num]=keyval;num++;}
	if(num>=8)
	{
	num=0;
	sc=1;
	for(i=0;i<8;i++)
	{
	if(mmins[i]!=mima[i]){sc=0;break;}
	SBUF=sc;
	while(TI==0);
	TI=0;
	}
	}
	}
	
}

❾ 51单片机C语言简易的密码输入

这样子当然是不行的，首先按键没有消抖，再者代码根本就不对。I大于4我没看懂是干嘛的，像这样子子基本就是只要在I>4的时候按下P1_7，就解锁成功了。密码锁形同虚设。

这样子改看看，不行再追问，我这边没得编译运行。：

下面的代码没有消抖，如需要楼主自己加吧。

uchartmp;
for(i=0;i<6;i++)
{
while((tmp=P1)!=0）;//如果按键按下是0的话就不用改，如果按键按下是1的话改成0XFF。这句是先检测是否有按键按下。
if(P1==tab[i])continue;
else
{
i=0;
continue;
}
if(P1_7==0&&i=5)
ledg=~ledg,ledr=~ledr;
else...
}

❿ VB显示单片机输入的密码（电子密码锁设计）

1。
根据实验任务来设置一个好的密码，采用二个按键实现输入功能，输入正确的密码，当密码，锁就打开，如果输入了不正确的密码三次，锁按钮3秒钟，同时发现报警声，没有任何按键按下，直到三种后，只要打开按键锁定功能;否则仍按钮三秒钟内按下时，它重新锁定按键3秒和报警。

2。原理

图4.32.1

3。系统硬件电路板连接

（1）。在“单片机系统”区域P0.0/AD0线连接到“音频放大模块”区域中的SPK IN端子;

（2）。 “音频放大模块”区域中的SPK OUT端子的扬声器和;

（3）。在“单片机系统”区域P2.0/A8-P2.7/A15与连接到任何一个ABCDEFGH终端“四个静态数码显示”区域8芯电缆;

（4）。在“单片机系统”区域中的P1.0用导线连接到“八发光二极管模块”区域中的L1端子;

（5）。在“单片机系统”区域P3.6/WR，P3.7/RD连接到SP1和SP2终端的“独立式键盘”区域中的线？？;

4。节目内容

（1）。设置一个密码，这个程序中的密码是固定在程序存储器ROM，假设默认密码是五个密码“12345”。

（2）。输入密码问题：感谢，那么关键之一，功能键，数字键的另一个关键。在输入过程中，先输入密码的长度，再根据密码的位数输入密码，该密码，直到所有的长度已输入;功能键或输入后确认即可完成密码的输入过程。入比较处理，以确定密码的状态和相应的过程。

（3）。键禁止功能：初始化，允许当按钮被按下时，开始进入键来标识状态的键输入密码，按键锁定功能被激活，但一个国家的开始发生在一个不正确的密码输入了三个倍的情况下。

5 C语言源代码

＃包括

无符号的字符代码PS [] = {1,2,3,4,5};

无符号的字符代码dispcode [] = {的0x3F，0X06，为0x5B，0X4F，0x66，

0x6d，0x7d，0X07，到0x7f，0x6f，为0x00，0X40};

无符号字符pslen = 9;

无符号字符templen;

无符号字符型位数;

无符号字符funcount;

无符号字符digitcount;

unsigned char型psbuf [9];

位cmpflag;

位hibitflag;

位读ErrorFlag;

位rightflag;

无符号整型秒3;

无符号整型AA;

无符号整型BB;

位alarmflag;

位exchangeflag;

无符号整型立方厘米;

无符号整型日;

位okflag;

无符号字符冈;

无符号字符OKB;

无效的主要（无效）

{

unsigned char型I，J;

P2 = dispcode [digitcount];

TMOD = 0X01;

TH0 =（65536-500）/ 256;

TL0 =（65536-500）％256;

TR0 = 1;

ET0 = 1;

EA = 1;

而（1）

{

如果（cmpflag == 0）

{

如果（P3_6 == 0）/ /功能键 {

就（i = 10，I> 0，I - ）

为（J = 248; J> 0;的J - ）;

如果（P3_6 == 0）

{

如果（hibitflag == 0）/ /如果按键被锁定

funcount + +; （funcount == pslen +2）/ /前

如果有按功能键1，然后按数字键1，完成密码长度的输入

{

funcount = 0;

cmpflag = 1;

P1 = dispcode [funcount]; / /你可以决定是否按下灯按钮，

}

{

秒3 = 0;

同时（P3_6 == 0）;

如果（P3_7 == 0）/ /数字键

{

就（i = 10;> 0;我 - ）

为（J = 248; J> 0;的J - ）;

如果（P3_7 == 0）

{

如果（hibitflag == 0）

{

digitcount + +;

如果（digitcount == 10）

{

digitcount = 0;

P2 = dispcode [digitcount];

如果（funcount == 1）/ /按功能键，键入密码长度

{

pslen = digitcount;

templen = pslen;

否则，如果（funcount> 1）/ /开始记录你的密码

{

psbuf [funcount-2] = digitcount;

{

秒3 = 0;

同时（P3_7 == 0）;

} / /原这个“}”

其他/ /比较

{

cmpflag = 0;

就（i = 0;我<pslen，我+ +）

{

如果（！PS [I] = psbuf [I]）

{

hibitflag = 1; / /密码输入不正确，按键锁定功能被激活

I = pslen;

读ErrorFlag = 1;

rightflag = 0;

cmpflag = 0;

秒3 = 0;

转到一个;

CC = 0;

读ErrorFlag = 0;

rightflag = 1;

hibitflag = 0;

一：cmpflag = 0;

}

T0无效（无效）中断1使用0

=（65536-500）/ 256 ;

TL0 =（65536-500）％256;

如果（（读ErrorFlag == 1）&&（rightflag == 0））

{

BB +;

如果（BB == 800）

{

BB = 0;

alarmflag =alarmflag;

}

如果（alarmflag == 1）

{

P0_0 =P0_0; / /报警声

}

AA +;

如果（AA == 800）

{

AA = 0;

P0_1 =P0_1; / / LED2发光二极管闪光灯

}

秒3 +;

如果（秒3 == 6400）/ /闪四次（8转换），自动复位到以前的按ENTER键状态

{

秒3 = 0;

hibitflag = 0;

读ErrorFlag = 0;

rightflag = 0;

cmpflag = 0;

P0_1 = 1;

alarmflag = 0;

BB = 0;

AA = 0;

如果（（读ErrorFlag == 0）&&（rightflag == 1））/ /发出“叮咚”声

{ BR /> P0_1 = 0; / / LED2 LED灯

CC + +;

如果（CC <1000）

{

okflag = 1;

否则，如果（CC <2000）

{

okflag = 0;

其他/ /自动复位到国家新闻

{

读ErrorFlag = 0之前ENTER;

rightflag = 0;

hibitflag = 0;

cmpflag = 0;

P0_1 = 1; / / LED2发光二极管消除

CC = 0;

冈= 0;

OKB = 0;

okflag = 0;

P0_0 = 1;

}

如果（okflag == 1）

{

冈+ +;

如果（OKA == 2）

{

丘= 0;

P0_0 =P0_0;

{

OKB + +;

如果（OKB == 3）

{

OKB = 0;
P0_0 =P0_0;

导航:首页 > 操作系统 > 单片机密码输入

单片机密码输入

与单片机密码输入相关的资料