密码锁单片机

‘壹’ 求51单片机C语言编的简易密码锁程序

首先得说明我这个可是自己原创手打的，但是没去仿真了，程序可能有错误，你自己修改下吧
#include<reg52.h>
typedef unsigned char uchar;
typedef unsigned int uint;

sbit key1=P0^0;
sbit key2=P0^1;
sbit key3=P0^2;
sbit key4=P0^3;

sbit wela=P2^0;//位锁存端
#define SMG P1

sbit LED=P3^0;//低电平亮

uchar code table[]={0x8d,0x86};//共阳数码管 P,E
uchar chushi_mima[]={2,1,3};
uchar shuru_mima[3];
uchar index;//控制输入密码的位数
uchar flag_3s=0;//3s标志位
uchar keydown;//确定按键变量
#define times 15//去抖时间15Ms
uchar key1_count,key2_count,key3_count,key4_count;
void init()
{
wela=0;
SMG=0xff;
TMOD=0x01;
TH0=(65536-1000)/256;
TL0=(65536-1000)%256;
ET0=1;
EA=1;
TR0=1;
LED=1；
}
void main()
{
init();
while(1)
{
switch(keydown)
{
if(index>2)index=0;
case 1:
shuru_mima[index]=0;
index++;
break;
case 2:
shuru_mima[index]=1;
index++;
break;
case 3:
shuru_mima[index]=2;
index++;
break;
case 4:
shuru_mima[index]=3;
index++;
break;
}

flag_3s=0;
for(i=0;i<3;i++)
{
if(shuru_mima[i]==chushi_mima[i])
{
LED=0;
wela=1;
SMG=table[0];
if(flag_3s)
{
flag_3s=0;
wela=0;
}
}
else
{
LED=1;
wela=1;
SMG=table[1];
if(flag_3s)
{
flag_3s=0;
wela=0;
}
}
}
}
}
void timer0() interrupt 1
{
uchar count;
TH0=(65536-1000)/256;
TL0=(65536-1000)%256;
if(++count>=600)
{
count=0;
flag_3s=1;
}
/*********1ms中断扫描按键(包含去抖程序)********/
if(!key1&&key1_count!=0)
{
key1_count--;
if(key1_count==0)
{
keydown=1;
}
}
else if(!key1) key1_count=times;

// key2,key3,key4你自己写吧
}

‘贰’ 51单片机密码锁原理

其实没什么算法，不要想太复杂了。就是把几个按键的顺序存入2404中，修改的时候存入，键入密码的时候对比。正确了就做相应处理，错误做另外相应处理。管理员也是有密码，原理一样，可以在C代码中为管理员编一个固定的密码，也可以是根据后期输入改变的密码qq461292125不明白的再问
怎么不给分QQ也给你讲明白了！！！！！！！！！！！！！！！！！！！！！

‘叁’ 单片机的密码锁

TLOW EQU 00H
THIGH EQU 0EEH
COUN0 EQU 200 ;5ms * 200 = 1S
COUN1 EQU 3FH ;密码的位数
D_TIME EQU 3EH ;设置密码时的时间限制
SEC EQU 3DH ;秒单元

PASS_OLD EQU 30H
PASS_NEW EQU 40H

SDA EQU P3.4 ;24C01的串行数据线
SCLK24 EQU P3.3 ;24C01的串行时钟线

;20H.0 为时间限制标记
;20H.1 为按错键标记
;20H.2 为比较对错标记
;20H.3 为3秒时间标记

RS EQU P2.0
RW EQU P2.1
EN EQU P2.2
X EQU 2FH ;LCD 地址变量
BEEP EQU P3.7
;--------------------------------------------------
ORG 0000H
JMP MAIN
ORG 0BH
JMP T0_INT
;--------------------------------------------------
MAIN:
MOV SP,#60H
MOV A,#00H
MOV D_TIME,A
MOV SEC,A
MOV COUN1,A
MOV R5,#06H
MOV R0,#PASS_OLD

CLR_01: MOV @R0,A
INC R0
DJNZ R5,CLR_01
CLR EN
CLR 20H.0
CLR 20H.1
CLR 20H.2
CLR 20H.3
CALL INIT_TIMER
CALL SET_LCD
CALL MENU1
CALL PASS_READ ;读出预定密码。
LOOP1:
CALL SCAN_KEY
CALL DELAY2
CJNE A,#0fH,LOOP1 ;按F键启动进入输入密码程序
SETB TR0

LP0: CALL SCAN_KEY ;按住F键3秒以上蜂鸣器不响为止
CALL DELAY2
CJNE A,#0fH,LP3
JB 20H.3,LP1 ;3秒到，20H.3置1。
JMP LP0

LP1: CLR TR0 ;停止中断
MOV SEC,#00H ;秒单元清零
CLR 20H.3 ;清3秒标记位

LP2: MOV P1,#0F0H ;等待键释放
MOV A,P1
CJNE A,#0F0H,LP2
CALL PASS_IN
JB 20H.2,LOOP2 ;密码正确后方可转下一步
JMP LP4

LP3: CLR TR0 ;停止中断
CLR 20H.3 ;清3秒标记位
MOV SEC,#00H ;秒单元清零
LP4: CALL SYS_RST ;系统复位
RET
NOP
NOP
NOP
LJMP MAIN
LOOP2: MOV R4,#06H ;模拟输出蜂鸣器响六声
LOOP3: CALL BZ
DJNZ R4,LOOP3

MOV A,#00H

LOOP4: CALL SCAN_KEY
CJNE A,#0AH,LOOP6 ;按A键进入PASS_LOOK
CALL PASS_LOOK

LOOP5: CALL SCAN_KEY
CJNE A,#0EH,LOOP5 ;按E键退出PASS_LOOK
CALL MENU1
CALL MENU2

LOOP6: CJNE A,#0BH,LOOP8 ;按B键进入PASS_SET
CALL PASS_SET

LOOP7: CALL SCAN_KEY
CJNE A,#0EH,LOOP7 ;按E键退出PASS_SET
CALL MENU1
CALL MENU2

LOOP8: CJNE A,#0DH,LOOP4 ;按D键退出
ACALL MAIN ;PASS_LOOK和PASS_SET状态

JMP LOOP4
SYS_RST:
RST1: CALL SCAN_KEY
CJNE A,#0DH,RST1 ;"D" 键
LJMP MAIN
RET
NOP
NOP
NOP
LJMP MAIN
PASS_IN:

MOV 21H,#03H ;允许输入三次密码
P_IN1: MOV DPTR,#IN_PASS0 ;
MOV A,#1 ;
CALL LCD_SHOW
MOV DPTR,#INFO2 ;指针指到显示信息2
MOV A,#2 ;显示在第二行
CALL LCD_SHOW

MOV R0,#PASS_OLD
MOV R3,#00H
MOV R2,#09H ;设置LCD地址
MOV COUN1,#06H ;6位密码
SETB TR0

P_IN2: JB 20H.0,P_IN4
MOV P1,#0F0H
MOV A,P1
CJNE A,#0F0H,P_IN3
jmp P_IN2
P_IN3:
CALL KEY_IN
CALL SETDATA0
CALL BZ
JB 20H.1,P_IN4
DJNZ COUN1,P_IN2
CLR TR0
CLR 20H.0
CALL PASS_COMP
JNB 20H.2,P_IN4 ;比较对错标记
RET
P_IN4: CLR TR0
CLR 20H.0 ;
CLR 20H.1 ;
CALL INPUT_ERR
DJNZ 21H,P_IN1 ;
RET
IN_PASS0:
DB " INPUT PASSWORD ",0
PASS_COMP:
MOV COUN1,#06H ;比较6位数值
MOV R0,#PASS_OLD
MOV R1,#PASS_NEW
P_COMP0: MOV A,@R0
MOV B,@R1
CJNE A,B,P_COMP1
INC R0
INC R1
DJNZ COUN1,P_COMP0
CALL INPUT_OK
SETB 20H.2
RET
P_COMP1: CLR 20H.2
;CALL INPUT_ERR
RET
PASS_SET:

MOV 21H,#05H ;允许输入三次密码

P_SET1: MOV DPTR,#SET_PASS0 ;
MOV A,#1 ;
CALL LCD_SHOW
MOV DPTR,#INFO2 ;指针指到显示信息2
MOV A,#2 ;显示在第二行
CALL LCD_SHOW

MOV R3,#00H
MOV R2,#09H ;设置LCD地址
MOV R1,#PASS_NEW
MOV COUN1,#06H ;6位密码
SETB TR0

P_SET2: JB 20H.0,P_SET4
MOV P1,#0F0H
MOV A,P1
CJNE A,#0F0H,P_SET3
jmp P_SET2
P_SET3:
CALL KEY_IN
CALL SETDATA1
CALL BZ
JB 20H.1,P_SET4
;MOV R5,#04H
;CALL DELAY
DJNZ COUN1,P_SET2
CLR TR0
CLR 20H.0
CALL RESET_OK
CALL EEPW
RET
P_SET4: CLR TR0
CLR 20H.0 ;
CLR 20H.1 ;
CALL RESET_ERR
DJNZ 21H,P_SET1 ;
RET

SET_PASS0:
DB " RESET PASSWORD ",0
MENU1: ;LCD 显示工作菜单信息
MOV DPTR,#MENU01
MOV A,#1 ;在第一行显示信息
CALL LCD_SHOW
RET
MENU01: DB "PASSWORD CONTROL",0
MENU2: ;LCD 显示工作菜单信息
MOV DPTR,#MENU02
MOV A,#2 ;在第一行显示信息
CALL LCD_SHOW
RET
SETDATA1:
MOV A,R3
ANL A,#0FH ;取出低四位二进制数
PUSH ACC
CLR C
SUBB A,#0AH ;减10
POP ACC
JC ASCII3 ;该数小于10，转ASCII0
SETB 20H.1
RET
ADD A,#07H ;大于10的数加上37H
ASCII3: ADD A,#30H ;小于10的数加上30H
MOV @R1,A
MOV B,R2
CALL LCDP2
INC R2
INC R1
RET

SETDATA0:

MOV A,R3
ANL A,#0FH ;取出低四位二进制数
PUSH ACC
CLR C
SUBB A,#0AH ;减10
POP ACC
JC ASCII4 ;该数小于10，转ASCII4
SETB 20H.1
RET
ASCII4: ADD A,#30H ;小于10的数加上30H
MOV @R0,A ;保存密码值
MOV A,#2AH ;显示" * "
MOV B,R2
CALL LCDP2
INC R2
INC R0
RET
PASS_LOOK:
MOV DPTR,#LOOK1 ;指针指到显示信息1
MOV A,#1 ;显示在第一行
CALL LCD_SHOW
MOV DPTR,#LOOK2 ;指针指到显示信息2
MOV A,#2 ;显示在第二行
CALL LCD_SHOW
MOV R1,#PASS_NEW
MOV R2,#09
MOV COUN1,#06
LOOK0: MOV A,@R1
MOV B,R2
CALL LCDP2
INC R2
INC R1
DJNZ COUN1,LOOK0
RET

LOOK1: DB " LOOK PASSWORD ",0 ;LCD 第一行显示信息
LOOK2: DB "PASSWORD ------ ",0 ;LCD 第二行显示信息
SCAN_KEY:
SCAN_K: MOV P1,#0F0H
MOV A,P1
CJNE A,#0F0H,KEY_NUM0 ;有键按下转
JMP KEY_END
KEY_NUM0: CALL KEY_IN
CALL BZ
MOV R5,#04H
CALL DELAY
KEY_END: RET
KEY_IN: MOV P1,#0F0H ;置列线为0，行线为1
MOV A,P1
ANL A,#0F0H
MOV B,A
MOV P1,#0FH ;置列线为1，行线为0
MOV A,P1
ANL A,#0FH
ORL A,B ;高四位与低四位重新组合
CJNE A,#0FFH,KEY_IN1 ;0FFH为末按键
RET
KEY_IN1: MOV B,A
MOV DPTR,#KEYTABLE
MOV R3,#0FFH
KEY_IN2: INC R3
MOV A,R3
MOVC A,@A+DPTR
CJNE A,B,KEY_IN3
MOV A,R3 ;找到，取顺序码
RET
KEY_IN3: CJNE A,#0FFH,KEY_IN2 ;末完，继续查
RET ;0FFH为结束码
SET_LCD:
CLR EN
CALL INIT_LCD ;初始化 LCD
CALL DELAY1
MOV DPTR,#INFO1 ;指针指到显示信息1
MOV A,#1 ;显示在第一行
CALL LCD_SHOW
MOV DPTR,#INFO2 ;指针指到显示信息2
MOV A,#2 ;显示在第二行
CALL LCD_SHOW
RET
INFO1: DB " ",0 ;LCD 第一行显示信息
INFO2: DB "PASSWORD ------ ",0 ;LCD 第二行显示信息INIT_LCD: ;8位I/O控制 LCD 接口初始化
MOV A,#38H ;双列显示，字形5*7点阵
CALL WCOM
CALL DELAY1
MOV A,#38H ;双列显示，字形5*7点阵
CALL WCOM
CALL DELAY1
MOV A,#38H ;双列显示，字形5*7点阵
CALL WCOM
CALL DELAY1
MOV A,#0CH ;开显示，关光标，
CALL WCOM
CALL DELAY1
MOV A,#01H ;清除 LCD 显示屏
CALL WCOM
CALL DELAY1
RET
LCD_SHOW: ;在LCD的第一行或第二行显示信息字符

CJNE A,#1,LINE2 ;判断是否为第一行
LINE1: MOV A,#80H ;设置 LCD 的第一行地址
CALL WCOM ;写入命令
CALL CLR_LINE ;清除该行字符数据
MOV A,#80H ;设置 LCD 的第一行地址
CALL WCOM ;写入命令
JMP FILL
LINE2: MOV A,#0C0H ;设置 LCD 的第二行地址
CALL WCOM ;写入命令
CALL CLR_LINE ;清除该行字符数据
MOV A,#0C0H ;设置 LCD 的第二行地址
CALL WCOM
FILL: CLR A ;填入字符
MOVC A,@A+DPTR ;由消息区取出字符
CJNE A,#0,LC1 ;判断是否为结束码
RET
LC1: CALL WDATA ;写入数据
INC DPTR ;指针加1
JMP FILL ;继续填入字符
RET
CLR_LINE: ;清除该行 LCD 的字符
MOV R0,#24
CL1: MOV A,#' '
CALL WDATA
DJNZ R0,CL1
RET
ENABLE: ;写指令使能
CLR RS ;RS=L,RW=L,D0-D7=指令码，E=高脉冲
CLR RW
SETB EN
CALL DELAY0
CLR EN
RET
ENABLE1: ;写数据使能
SETB RS ;RS=H,RW=L,D0-D7=数据，E=高脉冲
CLR RW
SETB EN
CALL DELAY0
CLR EN
RET

DELAY0: MOV R7,#250 ;延时500微秒
DJNZ R7,$
RET
WCOM: ;以8位控制方式将命令写至LCD
MOV P0,A ;写入命令
CALL ENABLE
RET
WDATA: ;以8位控制方式将数据写至LCD
MOV P0,A ;写入数据
CALL ENABLE1
RET
LCDP2: ;在LCD的第二行显示字符
PUSH ACC ;
MOV A,B ;设置显示地址
ADD A,#0C0H ;设置LCD的第二行地址
CALL WCOM ;写入命令
POP ACC ;由堆栈取出A
CALL WDATA ;写入数据
RET
CONV:
MOV X,#9 ;设置显示起始位置
MOV A,R3
ANL A,#0F0H ;取出高四位二进制数
SWAP A ;高四位与低四位互换
PUSH ACC ;压入堆栈
CLR C ;C=0
SUBB A,#0AH ;减10
POP ACC ;弹出堆栈
JC ASCII0 ;该数小于10，转ASCII0
ADD A,#07H ;大于10的数加上37H
ASCII0: ADD A,#30H ;小于10的数加上30H
MOV B,X
CALL LCDP2

MOV A,R3
ANL A,#0FH ;取出低四位二进制数
PUSH ACC
CLR C
SUBB A,#0AH ;减10
POP ACC
JC ASCII1 ;该数小于10，转ASCII1
ADD A,#07H ;大于10的数加上37H
ASCII1: ADD A,#30H ;小于10的数加上30H
INC X
MOV B,X
CALL LCDP2
RET
DELAY2: MOV R5,#15H
DELAY: ;延时R5×10MS
MOV R6,#50
D1: MOV R7,#100
DJNZ R7,$
DJNZ R6,D1
DJNZ R5,DELAY
RET
DELAY1: ;延时5MS
MOV R6,#25
D2: MOV R7,#100
DJNZ R7,$
DJNZ R6,D2
RET
KEYTABLE:
DB 0EEH,0EDH,0EBH,0E7H,0DEH ;0,1,2,3,4, 顺序码
DB 0DDH,0DBH,0D7H,0BEH,0BDH ;5,6,7,8,9,
DB 0BBH,0B7H,07EH,07DH,07BH ;A,B,C,D,E,
DB 077H,0FFH ;F 0FF为结束码

DB 0DBH,0EEH,0DEH,0BEH,07EH ;0,1,2,3,4, 顺序码
DB 0EDH,0DDH,0BDH,07DH,0EBH ;5,6,7,8,9,
DB 0BBH,07BH,0E7H,0D7H,0B7H ;A,B,C,D,E,
DB 077H,067H,066H,065H,0FFH ;F,C+F,1+F,8+C
INIT_TIMER: ;初始化定时器
MOV TMOD,#01H ;设置定时器0 工作模式为模式1
MOV IE, #82H ;启用定时器0 中断产生
MOV TL0,#TLOW
MOV TH0,#THIGH
RET
T0_INT:
PUSH ACC
MOV TL0,#TLOW
MOV TH0,#THIGH
INC D_TIME
MOV A,D_TIME ;5ms 计数值加1
CJNE A,#COUN0,T0_T
MOV D_TIME,#0
INC SEC ;秒加1
MOV A,SEC
CJNE A,#03H,TO_INT0
SETB 20H.3
TO_INT0: CJNE A,#8,T0_T ;是否到8秒？
MOV SEC,#0 ;秒单元清0
SETB 20H.0
T0_T: POP ACC
RETI
PASS_READ:
CALL EEPR
RET

MOV COUN1,#06H ;6位密码数值
MOV R7,#00H
MOV R1,#PASS_NEW
P_READ: MOV A,R7
MOV DPTR,#R_TABLE
MOVC A,@A+DPTR
MOV @R1,A
INC R1
INC R7
DJNZ COUN1,P_READ
RET
R_TABLE:
DB 35H,36H,34H,34H,38H,38H
COMP_ERR:
MOV DPTR,#COMP_ERR1 ;
MOV A,#2 ;
CALL LCD_SHOW
RET
COMP_ERR1:
DB " PASSWORD ERROR ",0
COMP_OK:
MOV DPTR,#COMP_OK0 ;
MOV A,#2 ;
CALL LCD_SHOW
RET
COMP_OK0:
DB " PASSWORD RIGHT ",0
RESET_ERR:
MOV DPTR,#RESET_ERR0 ;
MOV A,#2 ;
CALL LCD_SHOW
RET
RESET_ERR0:
DB " RESET ERROR ",0
RESET_OK:
MOV DPTR,#RESET_OK0 ;
MOV A,#2 ;
CALL LCD_SHOW
RET
RESET_OK0:
DB " RESET RIGHT ",0
INPUT_ERR:
MOV DPTR,#INPUT_ERR0 ;
MOV A,#2 ;
CALL LCD_SHOW
RET
INPUT_ERR0:
DB " INPUT ERROR ",0
INPUT_OK:
MOV DPTR,#INPUT_OK0 ;
MOV A,#2 ;
CALL LCD_SHOW
RET
INPUT_OK0:
DB " INPUT RIGHT ",0
EEPW: PUSH ACC
PUSH PSW
CLR PSW.3
SETB PSW.4
MOV R1,#PASS_NEW
MOV R7,#06H ;连续写8个字节
LCALL START
MOV A,#0A0H ;送器件地址
ACALL SUBS
MOV A,#00H ;送片内字节地址
ACALL SUBS
AGAIN1:
MOV A,@R1
ACALL SUBS ;调发送单字节子程序
INC R1
DJNZ R7,AGAIN1 ;连续写8个字节
LCALL STOP ;发停止信号
POP PSW
POP ACC
RET
SUBS:
MOV R0,#08H ;发送单字节子程序
LOOP: CLR SCLK24
RLC A
MOV SDA,C
NOP
SETB SCLK24
ACALL DELAY24
DJNZ R0,LOOP ;循环8次送8个bit
CLR SCLK24
ACALL DELAY24
SETB SCLK24
REP: MOV C,SDA
JC REP ;判应答到否，未到则等待
CLR SCLK24
RET

DELAY24:
NOP
NOP
RET
EEPR: PUSH ACC
PUSH PSW
CLR PSW.3
SETB PSW.4
MOV R7,#06H
MOV R1,#PASS_NEW
LCALL START ;发开始信号
MOV A,#0A0H ;送器件地址
ACALL SUBS ;调发送单字节子程序
MOV A,#00H ;送片内字节地址
ACALL SUBS
LCALL START ;再发开始信号
MOV A,#0A1H
ACALL SUBS
MORE: ACALL SUBR
MOV @R1,A
MOV A,#00H
INC R1
DJNZ R7,MORE
LCALL STOP ;送停止信号
POP PSW
POP ACC
RET

SUBR: MOV R0,#08H ;接受单字节子程序
SUBR2: SETB SCLK24
ACALL DELAY24
MOV C,SDA
RLC A
CLR SCLK24
ACALL DELAY24
DJNZ R0,SUBR2
CJNE R7,#01H,ALOW
SETB SDA ;若是最后一个字节置SDA=1
AJMP SETOK
ALOW:
CLR SDA ;否则置SDA=0
SETOK: ACALL DELAY24
SETB SCLK24
ACALL DELAY24
CLR SCLK24
ACALL DELAY24
SETB SDA ;应答毕,SDA置1
RET
START:
CLR SDA
ACALL DELAY24
SETB SDA
SETB SCLK24
ACALL DELAY24
CLR SDA
SETB SCLK24
RET
STOP:
CLR SDA
SETB SCLK24
ACALL DELAY24
SETB SDA
ACALL DELAY24
RET
BZ: ;蜂鸣器
MOV R6,#100
B1: CALL DEX
CPL BEEP
DJNZ R6,B1
MOV R5,#20
CALL DELAY
RET
DEX: MOV R7,#180
DE1: NOP
DJNZ R7,DE1
RET
END

‘肆’ 高分求完整的单片机密码锁程序...

/*变量的定义:
show_val[6]: 显示的值
init_val[6]: 密码初始值
key_val: 返回按键的值 255-表示无按键按下
key_index: 当前按键是哪一位密码
T1_cnt: 定时器计数溢出数
cnt_val_15s: 报警计时的数值
cnt_val_5s: 待机时间计时
cnt_val_4s: 输入正确，等待4秒清除开锁信号
cnt_state: 计时状态
error_num: 错误次数
led_seg_code：数码管7段码
*/
#include "reg51.h"
/*说明key0=P1^0; key1=P1^1;key2=P1^2; key3=P1^3;key4=P1^4;key5=P1^5;enter=P1^6;esc=P1^7;*/
sbit relay_open=P3^0; //电磁锁开锁驱动
sbit pw_error=P3^1; //密码错误信号
sbit alarm_out=P3^2; //报警输出
sbit open_lock=P3^3; //已开锁指示信号
sbit audio_out=P3^4; //有源蜂鸣器
unsigned char data cnt_val_15s,cnt_val_5s,cnt_val_4s,cnt_state;
unsigned int data T1_cnt;
unsigned char data key_val,key_index,key_val_old;
unsigned char data state_val,error_num;
unsigned char data show_val[6];
char code init_val[6]={1,2,3,4,5,0};
char code led_seg_code[11]={0x3f,0x06,0x05b,0x04f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x00};
//led_seg_code[0-9]代表0-9 led_seg_code[10]=0x00数码管不显示任何内容
//--------延时程序----------------
void delay(unsigned int i)//延时
{ while(--i); }
//--------清除输入内容----------
void init_variant()
{unsigned char i;
for(i=0;i<6;i++)
show_val[i]=10; //led_seg_code[10]=0x00表示数码管不显示任何内容
key_index=0; //没有任何输入或清除所有输入时，保存当前键的位置
}
//---------按键扫描---------------
unsigned char scan_key()
{ unsigned char i,k;
i=P1;
if (i==0xff && cnt_state!=2)
{ k=255; } //无键按下
else //有键按下
{ delay(500); //延时去抖动
if(i!=P1)
{k=255;}
else
{ TR1=1; //有键按下则开定时器，启动待机计时
cnt_val_5s=0;
switch (i)
{ case 0xfe: k=0; break;
case 0xfd: k=1; break;
case 0xfb: k=2; break;
case 0xf7: k=3; break;
case 0xef: k=4; break;
case 0xdf: k=5; break;
case 0xbf: k=6; break;
case 0x7f: k=7; break;
}
}
}
return k;
}
//---------数码管显示---------------
void led_show()
{P0=led_seg_code[show_val[0]];
P2=0xdf;
delay(500);
P0=led_seg_code[show_val[1]];
P2=0xef;
delay(500);
P0=led_seg_code[show_val[2]];
P2=0xf7;
delay(500);
P0=led_seg_code[show_val[3]];
P2=0xfb;
delay(500);
P0=led_seg_code[show_val[4]];
P2=0xfd;
delay(500);
P0=led_seg_code[show_val[5]];
P2=0xfe;
delay(500);
}
//--------定时器T1中断服务程序-----------------
void timer1() interrupt 3 //T1中断
{ T1_cnt++;
if(T1_cnt>3999) //如果计数>3999, 计时1s
{ T1_cnt=0;
switch (cnt_state)
{ case 0: //待机，需要计时5s
if(cnt_val_5s<5)
{ cnt_val_5s++;}
else
{ cnt_val_5s=0;
init_variant();//待机计时到5秒时，清除输入的内容
TR1=0; //停止计时
}
break;
case 1://密码输入正确，需要计时4s
if(cnt_val_4s<4)
{ cnt_val_4s++;}
else
{ cnt_val_4s=0;
init_variant();//密码输入正确，计时到4秒时，清除输入的内容
open_lock=1; //已开锁信号清零
relay_open=1; //开锁信号清零
cnt_state=0;
TR1=0; //停止计时
}
break;
case 2: //密码输入错误3次，计时15s
if(cnt_val_15s<15)
{ cnt_val_15s++;}
else
{ cnt_val_15s=0;
init_variant();//三次密码错误时，计时15秒，清除输入的内容
open_lock=1; // 清除所有指示和报警
relay_open=1;
alarm_out=1;
pw_error=1;
cnt_state=0;
TR1=0; //停止计时
}
break;
}
}
}
//--------判断键盘输入内容与密码是否一致------
unsigned char check_input_pw()
{ unsigned char i,k;
k=1;
for(i=0;i<6;i++)
{ k=k && (show_val[i]==init_val[i]); }
return k;
}
//---------主程序----------------
main()
{ //初始化各变量
audio_out=1;
P3=0xff;
cnt_val_15s=0;
cnt_val_5s=0;
cnt_val_4s=0;
cnt_state=0;
//0-待机计时5s状态;1-密码正确，计时4s状态 ;2-三次密码错误，处于计时15秒状态。
T1_cnt=0;
error_num=0;
key_val_old=255;
init_variant();
//初始化51的寄存器
TMOD=0x20; //用T1计时 8位自动装载定时模式
TH1=0x19; //500微秒溢出一次; 250=(256-x)*12/11.0592 -> x=19
TL1=0x19;
EA=1; //开中断
ET1=1;
TR1=0; //开定时器T1
while(1)
{ key_val=scan_key(); //按键输入，有键按下key_val为0-7，无键按下key_val为255。
if (key_val!=key_val_old)
{ key_val_old=key_val;
if (key_val!=255&& cnt_state!=2)
{ audio_out=0;
delay(100); //延时去抖动
audio_out=1;
switch (key_val)
{ case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
if(key_index<6) //密码为6位，超过6位视为输入无效
{ show_val[key_index]=key_val;
key_index++; }
break;
case 6: //确认键
if(check_input_pw())
{//密码正确
error_num=0; //密码输入错误次数清零
//---------
pw_error=1; //密码错误指示灯灭
relay_open=0; //开锁驱动信号灯亮
open_lock=0; //已开锁信号灯亮
//---------
delay(50000); //两声短“滴”声
audio_out=0;
delay(50000);
audio_out=1;
delay(50000);
audio_out=0;
delay(50000);
audio_out=1;
//---------
cnt_state=1; //下一状态处于4秒计时的状态
TR0=1; //启动定时
}
else
{ if (error_num<2)
{error_num++; //输入错误次数小于3次时，没错一次error_num增一
pw_error=0; //密码错误指示灯亮
//-----------
delay(20000);//一声长“滴”声，提示错误
audio_out=0;
delay(60000);
audio_out=1;
//-----------
init_variant();//清除所有输入，等待下一次输入
}
else //输入错误次数超过3次
{ alarm_out=0; //报警灯亮
pw_error=0; //密码错误指示灯亮
error_num=0; //密码输入错误次数清零
//----------
audio_out=0; //长鸣声报警
delay(60000);
delay(60000);
delay(60000);
delay(60000);
delay(60000);
delay(60000);
delay(60000);
delay(60000);
delay(60000);
audio_out=1;
//-------------
TR1=1; //打开定时器计时
cnt_state=2; //下一状态处于15秒计时的状态
}
}
break;
case 7://取消键
init_variant();
break;
}
}
}
led_show();
}
}
//-----程序结束-----------------

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

#include <reg52.h>
#define uint unsigned int
#define uchar unsigned char
#define BIN(a,b,c,d,e,f,g,h) ((a<<7)+(b<<6)+(c<<5)+(d<<4)+(e<<3)+(f<<2)+(g<<1)+(h<<0))
//下面的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;j<125;j++){;}
}
}
//键盘子程序一,键盘值与数组值对比得到
uchar Key(void)
{uchar temp,m,n,i,j,matrix,k;
P1=0xF0; /*行线电平为高,列线为低*/
temp=P1&0xf0;
if (temp==0xf0) return(16); /*行仍为高,无按健,退出*/
else msdelay(10);
for(i=1;i<16;i=i*2)
{m=i;
for(j=1;j<16;j=j*2)
{n=(~j)&0x0f;
P1=(m<<4)|n; /*m为P1的行值由i循环得到,n为列值,由j循环并取反得到*/
temp=P1&0xf0;
if (!temp)
{do{temp=P1&0xf0;}while(!temp);
matrix=m*(n+1);/*为避免乘积重复,n+1*/
for(k=0;k<16;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=P1&0xf0;
if (temp==0xf0) return(16); /*行仍为高,无按健,退出*/
else msdelay(10);
for(i=1;i<16;i=i*2)
{m=i;
for(j=1;j<16;j=j*2)
{n=(~j)&0x0f;
P1=(m<<4)|n;/*m为P1的行值由i循环得到,n为列值,由j循环并取反得到*/
temp=P1&0xf0;
if (!temp)
{do{temp=P1&0xf0;}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=P1&0xf0;
if (temp==0xf0) return(16); /*读P1=1111 xxxx,表示行仍为高,无按健,退出(x表示不关心)?/
else msdelay(10);
P1=0x1e; /*P1=0001 1110,行一为高，列一为低，扫描第一个按键*/
temp=P1&0xf0;
if (!temp) {do{temp=P1&0xf0;}while(!temp);
return(1);}
P1=0x1d; /*P1=0001 1101,行一为高，列二为低，扫描第二个按键，下面扫描其余按键*/
temp=P1&0xf0;
if (!temp) {do{temp=P1&0xf0;}while(!temp);
return(2);}
P1=0x1b;
temp=P1&0xf0;
if (!temp) {do{temp=P1&0xf0;}while(!temp);
return(3);}
P1=0x17;
temp=P1&0xf0;
if (!temp) {do{temp=P1&0xf0;}while(!temp);
return(4);}
P1=0x2e;
temp=P1&0xf0;
if (!temp) {do{temp=P1&0xf0;}while(!temp);
return(5);}
P1=0x2d;
temp=P1&0xf0;
if (!temp) {do{temp=P1&0xf0;}while(!temp);
return(6);}
P1=0x2b;
temp=P1&0xf0;
if (!temp) {do{temp=P1&0xf0;}while(!temp);
return(7);}
P1=0x27;
temp=P1&0xf0;
if (!temp) {do{temp=P1&0xf0;}while(!temp);
return(8);}
P1=0x4e;
temp=P1&0xf0;
if (!temp) {do{temp=P1&0xf0;}while(!temp);
return(9);}
P1=0x4d;
temp=P1&0xf0;
if (!temp) {do{temp=P1&0xf0;}while(!temp);
return(0);}
P1=0x4b;
temp=P1&0xf0;
if (!temp) {do{temp=P1&0xf0;}while(!temp);
return(10);}
P1=0x47;
temp=P1&0xf0;
if (!temp) {do{temp=P1&0xf0;}while(!temp);
return(11);}
P1=0x8e;
temp=P1&0xf0;
if (!temp) {do{temp=P1&0xf0;}while(!temp);
return(12);}
P1=0x8d;
temp=P1&0xf0;
if (!temp) {do{temp=P1&0xf0;}while(!temp);
return(13);}
P1=0x8b;
temp=P1&0xf0;
if (!temp) {do{temp=P1&0xf0;}while(!temp);
return(14);}
P1=0x87;
temp=P1&0xf0;
if (!temp) {do{temp=P1&0xf0;}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语言密码锁程序

include<reg52.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;j<8;j++)//清屏
TempData[j]=0;
}
if(i<8)
{
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;j<8;j++)//循环比较8个数值，
//如果有一个不等 则最终Flag值为0
Flag=Flag&&(temp[j]==dofly_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; //清空数据，防止有交替重影
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=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 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;
}
}

‘柒’ c51单片机密码锁

STC89C52RC 之类的也可以
都是内置EEPROM的
不附加存储器是不行的，因为一般AT89C51内只有可烧写ROM和掉电丢失的RAM 而ROM是不能在单片机运行时更改的，所以你必须用24C02之类的外存储芯片
一般51实验班上都有I2C

‘捌’ 单片机密码锁

网上一搜一大把，例程很多，小伙子会知道不会网络啊

‘玖’ 51单片机 密码锁

不行，8位的数你知道是多少吗？9999 9999这么大了。51单位机是8位的。你想单片机能存放得这么大的值吗？所以还是分为两个4位的值来存放了。要不然就出错了。当然你也可以每一位每一位的来做，那么每一位数定义一个8位的变量，那样也行了。

‘拾’ 电子密码锁 用单片机实现

我博客有相关程序，包含两个单片机的通信，一个为呼叫，另一单片机为应答，当然，如果知道密码也不需要呼叫的密码锁。

说明：

1.基本部分为单片机的串口通信，包含串口通信，键盘扫描

2.程序部分有详细的注释。
/*-------------------------------------------
Project: mimasuo program (V0.1)
Filename: mimasuo.c

Prozessor: 80C51 family
Compiler: Keil Version 6.14

Autor: ********
Copyrigth: 041151**
date: 2008.3.17
------------------------------------------ */

#include<reg51.h>
#define uchar unsigned char
sbit ADCS =P3^6;
sbit ADC =P3^7;
sbit AD =P1^0;
int fafu=0;
uchar key,key1,i,count1=1,yidong=256;
uchar jgh[9]={0xff,0xfe,0xfc,0xf8,0xf0,0xe0,0xc0,0x80,0x00};//输出指示
uchar jgh1[9]; //输入键盘缓存
uchar mima[9]={0,1,2,3,4,5,6,7,8};//初始8位密码 ： 12345678 第0位未用
uchar fangjian[4]={0,2,5,2}; //初始门牌号 252 第0位未用
char count=0;

void init_serialcomm(void) //串口波特率设置
{
SCON=0x50;
TMOD=0x20;
PCON=0x80;
TH1=0x40;
TL1=0x40;//300
TR1=1;
EA=1;
TI=0;
RI=0;
}
void delay10ms(void) //10毫秒延时程序

{
unsigned char i,j,k;
for(i=5;i>0;i--)
for(j=4;j>0;j--)
for(k=248;k>0;k--);
}
uchar kbscan(void) // 键盘扫描程序
{
uchar sccode,recode;
P1=0xf0; //置所有行为低电平,行扫描，列线输入(此时)
if((P1&0xf0)!=0xf0) //判断是否有有键按下（读取列的真实状态，若第4列有键按下则P1的值会变成0111 0000），有往下执行
{
delays(); //延时去抖动（10ms）
if((P1&0xf0)!=0xf0) //再次判断列中是否是干扰信号，不是则向下执行
{
sccode=0xFE; //逐行扫描初值（即先扫描第1行）
while((sccode&0x10)!=0)//行扫描完成时（即4行已经全部扫描完成）sccode为1110 1111 停止while程序
{
P1=sccode; //输出行扫描码
if ((P1&0xf0)!=0xf0) //本行有键按下（即P1（真实的状态）的高四位不全为1）
{
recode=(P1&0xf0)|0x0f; //列
return(sccode&recode); //返回行和列
}
else //所扫描的行没有键按下，则扫描下一行，直到4行都扫描
{
sccode=(sccode<<1)|0x01;//行扫描码左移一位
}
}
}
}
else
{
return 0; //无键按下，返回0
}
}

uchar readnumber(uchar tmp) //按键扫描的结果，转换为数字，便于程序对按键数据处理
{
switch(tmp)
{
case 0x28:return 0 ;break;
case 0x14:return 1 ;break;
case 0x24:return 2 ;break;
case 0x44:return 3 ;break;
case 0x12:return 4 ;break;
case 0x22:return 5 ;break;
case 0x42:return 6 ;break;
case 0x11:return 7 ;break;
case 0x21:return 8 ;break;
case 0x41:return 9 ;break;
case 0x88:return 10 ;break;
case 0x82:return 11 ;break;
default:break;
}
}

void main(void) //主程序
{
P2=0xff;
init_serialcomm();
while(1)
{
key=kbscan();
// P2=key;
fafu++;
if(fafu==10000){
fafu=0;
ADCS = 1;
ADC = 1;}

if(RI) //呼叫应答
{
RI=0;
ADCS = 0;
// P2=~P2;
}

if(key!=0){
do{
key1=kbscan();
AD = 0;
}while(key1!=0);//等待按键释放
AD = 1;

if(readnumber(key)==10) // 密码比较
{ count1=1;
for(i=1;i<=8;i++)
{
if(mima[i]==jgh1[i])
count1++;
}
if(count1==9)
{
// P2=~P2;
ADCS = 0;
}
else ADC=0;
}

if(readnumber(key)==11) // 呼叫房间
{ count1=1;
for(i=1;i<=3;i++)
{
if(fangjian[i]==jgh1[i])
count1++;
}
if(count1==4) //发送传送码
{
SBUF=0xf0;
while(TI==0);
TI=0;
P2=~P2;
}
}

if((key!=0x88)&&(key!=0x84)&&(key!=0x82)) //数字键输入，并把输入的数据存到数组中
{ count++;
P2=jgh[count];
jgh1[count]=readnumber(key);
if(count==8)
count=0;
}
if(key==0x84)
{ //取消功能键
count--;
if(count<=0)count=0;
P2=jgh[count];
}
}
}

}
详细代码可以到我博客下载：
http://www.shenzhenwangzhanyouhua.com/seo/danpianji-key-machine.html