电子密码锁的程序代码（电子密码锁程序汇编语言）[20240425更新]

今天给各位分享电子密码锁的程序代码的知识，其中也会对电子密码锁程序汇编语言进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、数字密码锁C语言编程
• 2、51单片机的电子密码锁程序，用KEIL C写的
• 3、求51单片机C语言编的密码锁程序
• 4、单片机c语言密码锁程序
• 5、能给一下4*4矩阵与数码管的电子密码锁的代码吗？
• 6、基于单片机的电子密码锁设计

数字密码锁C语言编程

近年来，随着生活水平的不断改善，个人财富日益增长，人们对安全防盗的要求也逐渐提高。安全可靠、使用方便的电子密码锁成了人们防盗的首选。以Max +PlusⅡ(Multiple Array Matrix and ProgrammingLogic User SystemⅡ，多阵列矩阵及可编程逻辑用户系统Ⅱ)为工作平台，使用PLD可编程器件和VHDL语言设计的带音乐的电子密码锁具有密码预置，误码锁死及开锁音乐提示等功能。这种设计不仅简化了系统结构，降低了成本，更提高了系统的可靠和保密性。采用PLD可编程逻辑器件开发的数字系统，可以方便地升级和改进。

1 设计思路

密码锁电路由键盘控制、密码设置和音乐演奏三大功能模块组成，原理如图1所示。Count，Keyvalue，Contrl，Smdisplay构成键盘控制模块，Songer是音乐演奏模块，Set是密码设置模块。

1．1 键盘控制

键盘主要完成向系统输入数据，传送命令等功能。它是一个机械弹性按键开关的集合，利用机械触点的合、断作用产生高、低电平。通过对电平高低状态的检测，以确认按键按下与否。一个电压信号通过机械触点的断开、闭合过程的波形如图2所示。

在该键盘电路中，Count模块提供键盘的行扫描信号Q[3．．0]。在没有按键按下时，信号EN为高电平，行扫描输出信号Q[3．．0]的循环变化顺序为0001 OO100100 1000 0001(依次扫描4行按键)；当有按键按下时，信号EN为低电平，行扫描输出信号Q[3．．0]停止扫描，并锁存当前的行扫描值。例如按下第一行的按键，那么Q[3．．O]＝0001。

Keyvalue模块的主要功能是对输入按键的行信号Q[3．．0]和列信号14[3．．0]的当前组合值进行判断来确定输入按键的键值。

Contrl模块的主要功能是实现按键的消抖，判断是否有按键按下。确保对按键的提取处于图2所示的闭合稳定时间范围内，这就对本模块的输入时钟信号有一定的要求，在本设计中该模块输入的时钟信号频率为64 Hz。Smdisplay模块主要是完成数码管动态扫描和七段译码显示的功能。

1．2 音乐演奏电路Songer

根据声乐学知识，组成乐曲的每个音符的发音频率值及其持续的时间是乐曲能连续演奏所需的两个基本要素。获得这两个要素所对应的数值以及通过纯硬件的手段来利用这些数值实现所希望乐曲的演奏效果是关键。如图3所示，该电路需要由NOTETABS(音调发生器)、TONETABA、SPEAKER(数控分频器)三个模块组成，分别实现了声音产生、节拍控制、音调控制的功能。

1．3 密码设置

Set模块是实现密码锁功能的核心模块。其主要作用是设置密码，Set为设置密码的有效信号，可以实现修改密码的功能。En为输入密码确认信号，当输入完六位密码后确认输入，一旦输入的密码跟所设置的密码一致时，则输出信号OP有效(高电平)；OP控制演奏音乐，此时音乐响起。若密码不正确，则指示输入错误及输入次数，输完三次无效后密码锁锁死，必须由RESET信号(启动信号，给一个低电平)重新打开密码锁功能。

2 电路的VHDL描述

键盘控制电路，音乐演奏电路以及密码设置模块均使用硬件描述语言VHSIC Hardware Description Lan-guage(VHDL)设计而成。例如：TONETABA的VHDL模型如下：

VHDL语言具有很强的电路描述和建模能力，能从多个层次对数字系统进行建模和描述，支持各种模式的设计方法：自顶向下与自底向上或混合方法，从而大大简化了硬件的设计任务，提高了设计效率和可靠性。它同时具有与具体硬件电路无关和与设计平台无关的特性，所以用VHDL进行电子系统设计，设计者可以专心致力于其功能的实现，而不需要对其他相关因素花费过多的时间和精力。

设计步骤

3．1 设计输入

首先在合适的路径下建立本设计的文件夹，然后用VHDL语言编辑Count，Keyvalue，Contrl，Smdisplay等电路，并在Max+PlusⅡ软件中使用文本编辑器输入上述各电路模块的VHDL程序，编译生成各模块；最后在Max+PlusⅡ软件中使用图形编辑器以自底向上的方法编辑原理图。先编辑图3电路，以Singer．gdf命名，其次使用“Create default Symbol”生成Songer模块，然后再编辑如图1所示原理电路图。

3．2 仿真测试及编程下载配置

将设计好的项目存盘，并将其设置成Project。选择目标器件为ACEX系列中的EP1K30QC208-2，启动编译，如果发现编译出现错误，修正后再次编译。编译后即可对波形文件进行仿真，并进行测试和波形分析。分析完成后进行编程下载配置。

3．3 硬件测试

在高电平时，通过键盘的0～F号键进行6位密码输入，密码输入完毕后通过单击确认键进行密码设置确认。当输入的密码与设置的密码一致时，扬声器开始循环演奏乐曲，且数码管SM8显示输入密码的次数，数码管SM7显示密码输入是否正确。如果密码正确，则SM7显示‘0’；如果密码错误，则SM7显示‘E’。数码管SM6～SM1显示输入的6位密码。在密码输入正确开始演奏乐曲时，如果将拨位开关KD4拨向上，则数码管SM8显示乐曲的音符，而此时若将拨位开关KD3拨向上则停止演奏乐曲。发光二极管LED1～LED4显示输入按键的键值，LED16监控是否有按键按下。

4 结 语

使用Max+PlusⅡ软件和VHDL语言设计电路，思路简单，功能明了；不仅可以进行逻辑仿真，还可以进行时序仿真；使用PLD器件不仅省去了电路制作的麻烦，还可以反复多次进行硬件实验，非常方便地修改设计，且设计的电路保密性很强。总之，采用Max+PlusⅡ软件和VHDL语言使得复杂的电子系统的设计变得简单容易，大大提高了设计效率。

如果对您有帮助，请记得采纳为满意答案，谢谢！祝您生活愉快！

51单片机的电子密码锁程序，用KEIL C写的

以前帮别人做过一个类似的

#includereg52.h

#include def.h

#include"lcd.c"

uchar key;

uchar num;

sbit alarm=P2^4;

sbit open=P2^1;

uchar code table[]={' ','1','2','3',

'4','5','6','7',

'8','9','0'};

void keyscan();

uchar hptable[10];

uchar password[6];

uchar wordbuf[6];

uchar fom[]="input password:";

uchar change[]="set mask:";

uchar state1[]="right";

uchar state2[]="error";

uchar sflag;

uchar dflag,cnt;

uchar setf,fset;

uchar flag;

void main ()

{

uchar hp;

alarm=0;

flag=0;

setf=0;

fset=0;

dflag=0;

lcden=0;

lcdrw=1;

lcdrs=1;

P3=0x0f;

for(hp=0;hp6;hp++)

{

password[hp]='8';

}

write(0x38,0);  //0为写命令

delay(9);

write(0x08,0);

write(0x01,0);

write(0x06,0);

write(0x0c,0);

write(0x80,0);

for(hp=0;hp15;hp++)

{

write(fom[hp],1);

}

while(1)

{

// alarm=!alarm;

keyscan();

if(setf==0)

{

if(num=1num=10)

{

write(0x80+0x40+cnt,0);

write('*',1);

wordbuf[cnt]=table[num];

cnt++;

num=0;

}

}

else

{

write(0x01,0);

write(0x80,0);

for(hp=0;hp9;hp++)

{

write(change[hp],1);

}

fset=1;

cnt=0;

while(fset)

{

keyscan();

if(num=1num=10)

{

write(0x80+0x40+cnt,0);

write('*',1);

password[cnt]=table[num];

cnt++;

num=0;

}

if(num==11)

{

write(0x80+0x40+cnt-1,0);

write('\0',1);

cnt--;

num=0;

}

if(num==13)

{

flag=1;

num=0;

fset=0;

setf=0;

// goto chuz;

}

}

cnt=0;

}

if(flag==1)

{

write(0x01,0);

write(0x80,0);

for(hp=0;hp15;hp++)

{

write(fom[hp],1);

}

flag=0;

}

if(num==11)

{

write(0x80+0x40+cnt-1,0);

write('\0',1);

cnt--;

num=0;

}

if(num==12)

{

if(dflag==1)

setf=1;

num=0;

}

if(num==13)

{

num=0;

write(0x80+0x40+10,0);

if(wordbuf[0]==password[0]wordbuf[1]==password[1]wordbuf[2]==password[2]wordbuf[3]==password[3]wordbuf[4]==password[4]wordbuf[5]==password[5])

{

for(hp=0;hp5;hp++)

{

write(state1[hp],1);

}

sflag=0;

dflag=1;

}

else

{

for(hp=0;hp5;hp++)

{

write(state2[hp],1);

}

sflag++;

}

}

if(sflag==3)

{

alarm=!alarm;

//delay(9);

}

if(num==14)

{

num=0;

cnt=0;

write(0x01,0);

write(0x80,0);

for(hp=0;hp15;hp++)

{

write(fom[hp],1);

}

}

if(num==15)

{

if(dflag==1)

{

open=0;

dflag=0;

}

}

}

}

void keyscan ()

{

uchar tem,temp;

P3=0xfe;

temp=P3;

tem=temp0xf0;

if (tem!=0xf0) //没有键按下时它的值是不变的，即仍为0XF0，而有键接下时要变

{

delay(5); //延时消抖

temp=P3;

tem=temp0xf0;

if (tem!=0xf0) //确认有键按下

{

temp=P3;

tem=temp0xf0;   //这里也可以不要这一步，但下面的case里的值也要变

switch (tem)

{

case 0xe0: num=0; break;

case 0xd0: num=1; break;

case 0xb0: num=2; break;

case 0x70: num=3; break;

default :  ; break ;

}

while(tem!=0xf0) //等待松手

{

temp=P3;

tem=temp0xf0;

}

}

}

P3=0xfd;

temp=P3;

tem=temp0xf0;

if (tem!=0xf0)

{

delay(5);

temp=P3;

tem=temp0xf0;

if (tem!=0xf0)

{

temp=P3;

tem=temp0xf0;

switch (tem)

{

case 0xe0: num=4; break;

case 0xd0: num=5; break;

case 0xb0: num=6; break;

case 0x70: num=7; break;

default :  ; break ;

}

while(tem!=0xf0)

{

temp=P3;

tem=temp0xf0;

}

}

}

P3=0xfb;

temp=P3;

tem=temp0xf0;

if (tem!=0xf0)

{

delay(5);

temp=P3;

tem=temp0xf0;

if (tem!=0xf0)

{

temp=P3;

tem=temp0xf0;

switch (tem)

{

case 0xe0: num=8; break;

case 0xd0: num=9; break;

case 0xb0: num=10; break;

case 0x70: num=11; break;

default :  ; break ;

}

while(tem!=0xf0)

{

temp=P3;

tem=temp0xf0;

}

}

}

P3=0xf7;

temp=P3;

tem=temp0xf0;

if (tem!=0xf0)

{

delay(5);

temp=P3;

tem=temp0xf0;

if (tem!=0xf0)

{

temp=P3;

tem=temp0xf0;

switch (tem)

{

case 0xe0: num=12; break;

case 0xd0: num=13; break;

case 0xb0: num=14; break;

case 0x70: num=15; break;

default :  ; break ;

}

while(tem!=0xf0)

{

temp=P3;

tem=temp0xf0;

}

}

}

}

求51单片机C语言编的密码锁程序

#include reg52.h

#define uint unsigned int

#define uchar unsigned char

#define BIN(a,b,c,d,e,f,g,h) ((a7)+(b6)+(c5)+(d4)+(e3)+(f2)+(g1)+(h0))

//下面的code表示数组存放在ROM中，因为这个数组的值不需要改写

uchar code KeyCode[16]={15,14,12,8,30,28,24,16,60,56,48,32,120,112,96,64};//值为m*(n+1)的乘积，用于Key()

uchar dis[6];

msdelay(uint x)//延时子函数

{uchar j;

while(x--)

{for(j=0;j125;j++){;}

}

}

//键盘子程序一,键盘值与数组值对比得到

uchar Key(void)

{uchar temp,m,n,i,j,matrix,k;

P1=0xF0; /*行线电平为高,列线为低*/

temp=P10xf0;

if (temp==0xf0) return(16); /*行仍为高,无按健,退出*/

else msdelay(10);

for(i=1;i16;i=i*2)

{m=i;

for(j=1;j16;j=j*2)

{n=(~j)0x0f;

P1=(m4)|n; /*m为P1的行值由i循环得到,n为列值,由j循环并取反得到*/

temp=P10xf0;

if (!temp)

{do{temp=P10xf0;}while(!temp);

matrix=m*(n+1);/*为避免乘积重复,n+1*/

for(k=0;k16;k++){if (matrix==KeyCode[k]) return(k);} //KeyCode：见前

return(16);

} //if loop

}//j loop

}//i loop

}//Key end

//用Switch...case语句得到键盘值*/

uchar Key1(void)

{uchar temp,m,n,i,j,matrix;

P1=0xF0; /*行线电平为高,列线为低*/

temp=P10xf0;

if (temp==0xf0) return(16); /*行仍为高,无按健,退出*/

else msdelay(10);

for(i=1;i16;i=i*2)

{m=i;

for(j=1;j16;j=j*2)

{n=(~j)0x0f;

P1=(m4)|n;/*m为P1的行值由i循环得到,n为列值,由j循环并取反得到*/

temp=P10xf0;

if (!temp)

{do{temp=P10xf0;}while(!temp);

matrix=m*(n+1);

switch(matrix) //此方法的基本思路：

{case 15:return(1); break; //由循环得到的m,n值赋于P1端口实现逐个键扫描

case 14:return(2); break; //同时由m,n+1的值相乘得到对应键点de的积

case 12:return(3); break; //m*(n+1)值扫描键点对应而得出键值

case 8:return(4); break; //

case 30:return(5); break; //

case 28:return(6); break; //

case 24:return(7); break; //

case 16:return(8); break;

case 60:return(9); break;

case 56:return(0); break;

case 48:return(10); break;

case 32:return(11); break;

case 120:return(12); break;

case 112:return(13); break;

case 96:return(14); break;

case 64:return(15); break;

default:return(16);

} //switch end

} //if loop

}//j loop

}//i loop

}//Key end

//依次扫描16个按键

uchar Key2(void)

{uchar temp;

P1=0xF0; /*使P1=1111 0000,行线电平为高,列线为低*/

temp=P10xf0;

if (temp==0xf0) return(16); /*读P1=1111 xxxx,表示行仍为高,无按健,退出(x表示不关心)?/

else msdelay(10);

P1=0x1e; /*P1=0001 1110,行一为高，列一为低，扫描第一个按键*/

temp=P10xf0;

if (!temp) {do{temp=P10xf0;}while(!temp);

return(1);}

P1=0x1d; /*P1=0001 1101,行一为高，列二为低，扫描第二个按键，下面扫描其余按键*/

temp=P10xf0;

if (!temp) {do{temp=P10xf0;}while(!temp);

return(2);}

P1=0x1b;

temp=P10xf0;

if (!temp) {do{temp=P10xf0;}while(!temp);

return(3);}

P1=0x17;

temp=P10xf0;

if (!temp) {do{temp=P10xf0;}while(!temp);

return(4);}

P1=0x2e;

temp=P10xf0;

if (!temp) {do{temp=P10xf0;}while(!temp);

return(5);}

P1=0x2d;

temp=P10xf0;

if (!temp) {do{temp=P10xf0;}while(!temp);

return(6);}

P1=0x2b;

temp=P10xf0;

if (!temp) {do{temp=P10xf0;}while(!temp);

return(7);}

P1=0x27;

temp=P10xf0;

if (!temp) {do{temp=P10xf0;}while(!temp);

return(8);}

P1=0x4e;

temp=P10xf0;

if (!temp) {do{temp=P10xf0;}while(!temp);

return(9);}

P1=0x4d;

temp=P10xf0;

if (!temp) {do{temp=P10xf0;}while(!temp);

return(0);}

P1=0x4b;

temp=P10xf0;

if (!temp) {do{temp=P10xf0;}while(!temp);

return(10);}

P1=0x47;

temp=P10xf0;

if (!temp) {do{temp=P10xf0;}while(!temp);

return(11);}

P1=0x8e;

temp=P10xf0;

if (!temp) {do{temp=P10xf0;}while(!temp);

return(12);}

P1=0x8d;

temp=P10xf0;

if (!temp) {do{temp=P10xf0;}while(!temp);

return(13);}

P1=0x8b;

temp=P10xf0;

if (!temp) {do{temp=P10xf0;}while(!temp);

return(14);}

P1=0x87;

temp=P10xf0;

if (!temp) {do{temp=P10xf0;}while(!temp);

return(15);}

return(16); //扫描all按键都未按下，则输出16

}//Key2 end.

////////时钟中断显示子程序

void T0_int() interrupt 1

{static uchar i;

if (i==6){i=0;}

P0=5-i;

P0=P0|(dis[i]4);

i++;

TL0=0;

TH0=252;}

void distri(uint disnum)

{uint temp;

dis[0]=0;

dis[1]=disnum/10000;

temp=disnum%10000;

dis[2]=temp/1000;

temp=temp%1000;

dis[3]=temp/100;

temp=temp%100;

dis[4]=temp/10;

dis[5]=temp%10;

}

Main()

{uchar KeyVal,i=0;

TMOD=0x01;

IE=0x82;

TH0=252;

TL0=0;

TR0=1;

distri(0);

do{

KeyVal=Key();

if (KeyVal!=16) dis[1]=KeyVal; //注意：当有按键时才赋于显示位dis[1]，否则出错，请分析！

}while(1);

}

单片机c语言密码锁程序

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

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

#define KeyPort P1

sbit LATCH1=P2^2;//定义锁存使能端口 段锁存

sbit LATCH2=P2^3;// 位锁存

unsigned char code dofly_DuanMa[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,

0x77,0x7c,0x39,0x5e,0x79,0x71};// 显示段码值0~F

unsigned char code dofly_WeiMa[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};//分别对应相应的数码管点亮,即位码

unsigned char TempData[10]; //存储显示值的全局变量

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) //主循环

{

num=KeyPro();

if(num!=0xff)

{

if(i==0)

{

for(j=0;j8;j++)//清屏

TempData[j]=0;

}

if(i8)

{

temp[i]=dofly_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;j8;j++)//循环比较8个数值，

//如果有一个不等 则最终Flag值为0

Flag=Flag(temp[j]==dofly_DuanMa[password[j]]);

//比较输入值和已有密码

for(j=0;j8;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; //清空数据，防止有交替重影

LATCH1=1; //段锁存

LATCH1=0;

DataPort=dofly_WeiMa[i+FirstBit]; //取位码

LATCH2=1; //位锁存

LATCH2=0;

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

LATCH1=1; //段锁存

LATCH1=0;

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=KeyPort0x0f; //读入列线值

if(cord_h!=0x0f) //先检测有无按键按下

{

DelayMs(10); //去抖

if((KeyPort0x0f)!=0x0f)

{

cord_h=KeyPort0x0f; //读入列线值

KeyPort=cord_h|0xf0; //输出当前列线值

cord_l=KeyPort0xf0; //读入行线值

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

return(cord_h+cord_l);//键盘最后组合码值

}

}return(0xff); //返回该值

}

/*------------------------------------------------

按键值处理函数，返回扫键值

------------------------------------------------*/

unsigned char KeyPro(void)

{

switch(KeyScan())

{

case 0x7e:return 0;break;//0 按下相应的键显示相对应的码值

case 0x7d:return 1;break;//1

case 0x7b:return 2;break;//2

case 0x77:return 3;break;//3

case 0xbe:return 4;break;//4

case 0xbd:return 5;break;//5

case 0xbb:return 6;break;//6

case 0xb7:return 7;break;//7

case 0xde:return 8;break;//8

case 0xdd:return 9;break;//9

case 0xdb:return 10;break;//a

case 0xd7:return 11;break;//b

case 0xee:return 12;break;//c

case 0xed:return 13;break;//d

case 0xeb:return 14;break;//e

case 0xe7:return 15;break;//f

default:return 0xff;break;

}

}

能给一下4*4矩阵与数码管的电子密码锁的代码吗？

C语言源代码程序

#include 《AT89X52.H》

unsigned char ps［］={1，2，3，4，5};

unsigned char code dispbit［］={0xfe，0xfd，0xfb，0xf7，

0xef，0xdf，0xbf，0x7f};

unsigned char code dispcode［］={0x3f，0x06，0x5b，0x4f，0x66，

0x6d，0x7d，0x07，0x7f，0x6f，

0x77，0x7c，0x39，0x5e，0x79，0x71，

0x00，0x40，0x73，0xff};

unsigned char dispbuf［8］={18，16，16，16，16，16，16，16};

unsigned char dispcount;

unsigned char flashcount;

unsigned char temp;

unsigned char key;

unsigned char keycount;

unsigned char pslen=5;

unsigned char getps［6］;

bit keyoverflag;

bit errorflag;

bit rightflag;

unsigned int second3;

unsigned int aa，bb;

unsigned int cc;

bit okflag;

bit alarmflag;

bit hibitflag;

unsigned char oka，okb;

void main（void）

{

unsigned char i，j;

TMOD=0x01;

TH0=（65536-500）/256;

TL0=（65536-500）%6;

TR0=1;

ET0=1;

EA=1;

while（1）

{

P3=0xff;

P3_4=0;

temp=P3;

temp=temp 0x0f;

if （temp！=0x0f）

{

for（i=10;i》0;i--）

for（j=248;j》0;j--）;

temp=P3;

temp=temp 0x0f;

if （temp！=0x0f）

{

temp=P3;

temp=temp 0x0f;

switch（temp）

{

case 0x0e：

key=7;

break;

case 0x0d：

key=8;

break;

case 0x0b：

key=9;

break;

case 0x07：

key=10;

break;

}

temp=P3;

P1_1=~P1_1;

if（（key》=0） （key《10））

{

if（keycount《6）

{

getps［keycount］=key;

dispbuf［keycount+2］=19;

}

keycount++;

if（keycount==6）

{

keycount=6;

}

else if（keycount》6）

{

keycount=6;

keyoverflag=1;//key overflow

}

}

else if（key==12）//delete key

{

if（keycount》0）

{

keycount--;

getps［keycount］=0;

dispbuf［keycount+2］=16;

}

else

{

keyoverflag=1;

}

}

else if（key==15）//enter key

{

if（keycount！=pslen）

{

errorflag=1;

rightflag=0;

second3=0;

}

else

{

for（i=0;i《keycount;i++）

{

if（getps［i］！=ps［i］）

{

i=keycount;

errorflag=1;

rightflag=0;

second3=0;

goto a;

}

}

errorflag=0;

rightflag=1;

a： i=keycount;

}

}

temp=temp 0x0f;

while（temp！=0x0f）

{

temp=P3;

temp=temp 0x0f;

}

keyoverflag=0;//？？？？？？？？？

}

}

P3=0xff;

P3_5=0;

temp=P3;

temp=temp 0x0f;

if （temp！=0x0f）

{

for（i=10;i》0;i--）

for（j=248;j》0;j--）;

temp=P3;

temp=temp 0x0f;

if （temp！=0x0f）

{

temp=P3;

temp=temp 0x0f;

switch（temp）

{

case 0x0e：

key=4;

break;

case 0x0d：

key=5;

break;

case 0x0b：

key=6;

break;

case 0x07：

key=11;

break;

}

temp=P3;

P1_1=~P1_1;

if（（key》=0） （key《10））

{

if（keycount《6）

{

getps［keycount］=key;

dispbuf［keycount+2］=19;

}

keycount++;

if（keycount==6）

{

keycount=6;

}

else if（keycount》6）

{

keycount=6;

keyoverflag=1;//key overflow

}

}

else if（key==12）//delete key

{

if（keycount》0）

{

keycount--;

getps［keycount］=0;

dispbuf［keycount+2］=16;

}

else

{

keyoverflag=1;

}

}

else if（key==15）//enter key

{

if（keycount！=pslen）

{

errorflag=1;

rightflag=0;

second3=0;

}

else

{

for（i=0;i《keycount;i++）

{

if（getps［i］！=ps［i］）

{

i=keycount;

errorflag=1;

rightflag=0;

second3=0;

goto a4;

}

}

errorflag=0;

rightflag=1;

a4： i=keycount;

}

}

temp=temp 0x0f;

while（temp！=0x0f）

{

temp=P3;

temp=temp 0x0f;

}

keyoverflag=0;//？？？？？？？？？

}

}

P3=0xff;

P3_6=0;

temp=P3;

temp=temp 0x0f;

if （temp！=0x0f）

{

for（i=10;i》0;i--）

for（j=248;j》0;j--）;

temp=P3;

temp=temp 0x0f;

if （temp！=0x0f）

{

temp=P3;

temp=temp 0x0f;

switch（temp）

{

case 0x0e：

key=1;

break;

case 0x0d：

key=2;

break;

case 0x0b：

key=3;

break;

case 0x07：

key=12;

break;

}

temp=P3;

P1_1=~P1_1;

if（（key》=0） （key《10））

{

if（keycount《6）

{

getps［keycount］=key;

dispbuf［keycount+2］=19;

}

keycount++;

if（keycount==6）

{

keycount=6;

}

else if（keycount》6）

{

keycount=6;

keyoverflag=1;//key overflow

}

}

else if（key==12）//delete key

{

if（keycount》0）

{

keycount--;

getps［keycount］=0;

dispbuf［keycount+2］=16;

}

else

{

keyoverflag=1;

}

}

else if（key==15）//enter key

{

if（keycount！=pslen）

{

errorflag=1;

rightflag=0;

second3=0;

}

else

{

for（i=0;i《keycount;i++）

{

if（getps［i］！=ps［i］）

{

i=keycount;

errorflag=1;

rightflag=0;

second3=0;

goto a3;

}

}

errorflag=0;

rightflag=1;

a3： i=keycount;

}

}

temp=temp 0x0f;

while（temp！=0x0f）

{

temp=P3;

temp=temp 0x0f;

}

keyoverflag=0;//？？？？？？？？？

}

}

P3=0xff;

P3_7=0;

temp=P3;

temp=temp 0x0f;

if （temp！=0x0f）

{

for（i=10;i》0;i--）

for（j=248;j》0;j--）;

temp=P3;

temp=temp 0x0f;

if （temp！=0x0f）

{

temp=P3;

temp=temp 0x0f;

switch（temp）

{

case 0x0e：

key=0;

break;

case 0x0d：

key=13;

break;

case 0x0b：

key=14;

break;

case 0x07：

key=15;

break;

}

temp=P3;

P1_1=~P1_1;

if（（key》=0） （key《10））

{

if（keycount《6）

{

getps［keycount］=key;

dispbuf［keycount+2］=19;

}

keycount++;

if（keycount==6）

{

keycount=6;

}

else if（keycount》6）

{

keycount=6;

keyoverflag=1;//key overflow

}

}

else if（key==12）//delete key

{

if（keycount》0）

{

keycount--;

getps［keycount］=0;

dispbuf［keycount+2］=16;

}

else

{

keyoverflag=1;

}

}

else if（key==15）//enter key

{

if（keycount！=pslen）

{

errorflag=1;

rightflag=0;

second3=0;

}

else

{

for（i=0;i《keycount;i++）

{

if（getps［i］！=ps［i］）

{

i=keycount;

errorflag=1;

rightflag=0;

second3=0;

goto a2;

}

}

errorflag=0;

rightflag=1;

a2： i=keycount;

}

}

temp=temp 0x0f;

while（temp！=0x0f）

{

temp=P3;

temp=temp 0x0f;

}

keyoverflag=0;//？？？？？？？？？

}

}

}

}

void t0（void） interrupt 1 using 0

{

TH0=（65536-500）/256;

TL0=（65536-500）%6;

flashcount++;

if（flashcount==8）

{

flashcount=0;

P0=dispcode［dispbuf［dispcount］］;

P2=dispbit［dispcount］;

dispcount++;

if（dispcount==8）

{

dispcount=0;

}

}

if（（errorflag==1） （rightflag==0））

{

bb++;

if（bb==800）

{

bb=0;

alarmflag=~alarmflag;

}

if（alarmflag==1）//sound alarm signal

{

P1_7=~P1_7;

}

aa++;

if（aa==800）//light alarm signal

{

aa=0;

P1_0=~P1_0;

}

second3++;

if（second3==6400）

{

second3=0;

errorflag=0;

rightflag=0;

alarmflag=0;

bb=0;

aa=0;

}

}

else if（（errorflag==0） （rightflag==1））

{

P1_0=0;

cc++;

if（cc《1000）

{

okflag=1;

}

else if（cc《2000）

{

okflag=0;

}

else

{

errorflag=0;

rightflag=0;

P1_7=1;

cc=0;

oka=0;

okb=0;

okflag=0;

P1_0=1;

}

if（okflag==1）

{

oka++;

if（oka==2）

{

oka=0;

P1_7=~P1_7;

}

}

else

{

okb++;

if（okb==3）

{

okb=0;

P1_7=~P1_7;

}

}

}

if（keyoverflag==1）

{

P1_7=~P1_7;

}

}

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

功能键

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关闭密码锁---输入新的密码打开密码锁

*******************************************************************************/

#includereg52.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 dula=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;nm;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;i8;i++)

{

temp=temp1;

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;i8;i++)

{

nop(); scl=1; nop();

if(sda==1)

j=1;

else

j=0;

k=(k1)|j;

scl=0;

}

nop();

return(k);

}

void clock() //I2C总线时钟

{

unsigned char i=0;

scl=1;

nop();

while((sda==1)(i255))

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;j0;j--)

for(k=125;k0;k--);

}

void display(uchar a,uchar b,uchar c,uchar d,uchar e,uchar f)

{

dula=0;

P0=table[a];

dula=1;

dula=0;

wela=0;

P0=0xfe;

wela=1;

wela=0;

delay(5);

P0=table[b];

dula=1;

dula=0;

P0=0xfd;

wela=1;

wela=0;

delay(5);

P0=table[c];

dula=1;

dula=0;

P0=0xfb;

wela=1;

wela=0;

delay(5);

P0=table[d];

dula=1;

dula=0;

P0=0xf7;

wela=1;

wela=0;

delay(5);

P0=table[e];

dula=1;

dula=0;

P0=0xef;

wela=1;

wela=0;

delay(5);

P0=table[f];

dula=1;

dula=0;

P0=0xdf;

wela=1;

wela=0;

delay(5);

}

void keyscan()

{

{

P3=0xfe;

temp=P3;

temp=temp0xf0;

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=temp0xf0;

beep=0;

}

beep=1;

}

}

P3=0xfd;

temp=P3;

temp=temp0xf0;

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=temp0xf0;

beep=0;

}

beep=1;

}

}

P3=0xfb;

temp=P3;

temp=temp0xf0;

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=temp0xf0;

beep=0;

}

beep=1;

}

}

P3=0xf7;

temp=P3;

temp=temp0xf0;

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=temp0xf0;

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); //实时显示

}

}

对着代码自己做吧，，要是还做不出来，，那我就不说什么了，，

关于电子密码锁的程序代码和电子密码锁程序汇编语言的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。