4X4矩阵式键盘输入程序
4*4键盘程序
readkeyboard:
begin: acall key_on
jnz delay
ajmp readkeyboard delay:acall delay10ms
acall key_on
jnz key_num
ajmp begin
key_num:acall key_p
anl a,#0FFh
jz begin
acall key_ccode
push a
key_off:acall key_on
jnz key_off
pop a
ret
key_on: mov a,#00h
orl a,#0fh
mov p1,a
mov a,p1
orl a,#0f0h
cpl a
ret
key_p: mov r7,#0efh
l_loop:mov a,r7
mov p1,a
mov a,p1
orl a,#0f0h
mov r6,a
cpl a
jz next
ajmp key_c
next: mov a,r7
jnb acc.7,error
rl a
mov r7,a
ajmp l_loop
error:mov a,#00h
ret
key_c:mov r2,#00h
mov r3,#00h
mov a,r6
mov r5,#04h
again1:jnb acc.0,out1
rr a
inc r2
djnz r5, again1
out1: inc r2
mov a,r7
mov r5,#04h
again2:jnb acc.4,out2
rr a
inc r3
djnz r5,again2
out2: inc r3
mov a, r2
swap a
add a,r3
ret
key_ccode:push a
swap a
anl a,#0fh
dec a
rl a ;行号乘
4
rl a
mov r7,a
pop a
anl a,#0fh
dec a
add a,r7
ret
delay10ms:
anl tmod,#0f0h
orl tmod,#01h
mov th0,#0d8h
mov tl0,#0f0h
setb tr0
wait:jbc tf0,over
ajmp wait
clr tr0
over:ret
单片机键盘设计
（二）从电路或软件的角度应解决的问题
软件消抖：如果按键较多，硬件消抖将无法胜任，常采用软件消抖。通常采用软件延时的方法：在第一次检测到有键按下时，执行一段延时10ms的子程序后，再确认电平是否仍保持闭合状态电平，如果保持闭合状态电平，则确认真正有键按下，进行相应处理工作，消除了抖动的影响。（这种消除抖动影响的软件措施是切实可行的。）
2.采取串键保护措施。串键：是指同时有一个以上的键按下，串键会引起CPU错误响应。
通常采取的策略：单键按下有效，多键同时按下无效。
3.处理连击。连击：是一次按键产生多次击键的效果。要有对按键释放的处理，为了消除连击，使得一次按键只产生一次键功能的执行（不管一次按键持续的时间多长，仅采样一个数据）。否则的话，键功能程序的执行次数将是不可预知，由按键时间决定。连击是可以利用的。连击对于用计数法设计的多功能键特别有效。
三、键盘工作方式
单片及应用系统中，键盘扫描只是CPU的工作内容之一。CPU忙于各项任务时，如何兼顾键盘的输入，取决于键盘的工作方式。考虑仪表系统中CPU任务的份量，来确定键盘的工作方式。
键盘的工作方式选取的原则是：既要保证能及时响应按键的操作，又不过多的占用CPU的工作时间。
键盘的工作方式有：查询方式（编程扫描，定时扫描方式）、中断扫描方式。
四、键盘电路结构
（一）独立式按键接口设计
优点：电路配置灵活，软件结构简单。此键盘是用于按键较少或操作速度较高的场合。
也可以用扩展I/O口搭接独立式按键接口电路，可采用8255扩展I/O口，用三态缓冲器扩展。这两种配接方式，都是把按键当作外部RAM某一工作单元的位来对待，通过读片外RAM 的方法，识别按键的工作状态。
上电路中独立式按键电路，各按键开关均采用了上拉电阻，是为了保证在按键断开时，各I/O有确定的高电平。如输入口线内部已有上拉电阻，则外电路的上拉电阻可省去。
（二）矩阵式键盘接口设计
矩阵式键盘适用于按键数量较多的场合，由行线和列线组成，按键位于行列的交叉点上。节省I/O口。
矩阵键盘工作原理：行线通过上拉电阻接到+5V上。无按键，行线处于高电平状态，有键按下，行线电平状态将由与此行线相连的列线电平决定。列线电平为低，则行线电平为低；列线电平为高，则行线电平为高。
五、双功能及多功能键设计
在单片机应用系统中，为简化硬件线路，缩小整个系统的规模，总希望设置最少的按键，获得最多的控制功能。
矩阵键盘与独立式按键键盘相比，硬件电路大大节省。可通过软件的方法让一键具有多功能。方法：选择一个RAM工作单元，对某一个按键进行按键计数，根据不同计数值，转到子程序。这种计数多功能键最好与显示器结合用，以便知道当前计数值，同时配合一个启动键。
复合键是使用软件实现一键多功能的另一个途径。所谓复合键，就是两个或两个以上的键的联合，当这些键同时按下时，才能执行相应的功能程序。实际情况做不到“同时按下”，他们的时间差别可以长到50ms，解决策略是：定义一个或两个引导键，这些引导键按下时没什么意义，执行空操作。引导键的例子：微机键盘上的CTRL、SHIFT、ALT。
缺点：一是操作变得复杂，二是操作时间变长。
多功能键的利用，应具体情况具体分析。要求速度的场合最好做一键一功能。如果系统功能很多，一键一功能不现实，可采取一键多功能。
六、功能开关及拨码盘接口设计
设计原因：键盘输入灵活性大，操纵方便。但某些重要功能或数据由键盘输入，误操作将产生一些不良后果。因此常设定静态开关的方法来执行这些功能或输入数据。静态开关一经设定，将不再改变，一直维持设定的开关状态。通常这些开关状态是在单片机系统加电时由CPU读入内存RAM的，以后CPU将不再关注这些开关的状态，因此，即使加电后，这些开关的状态发生变化，也不会影响CPU的正常工作，只有在下一次加电时，这些新状态才能生效。
第一，功能开关：主要是根据开关的状态执行一些重要的功能。
第二，拨码盘：单片机应用系统中，有时要输入一些控制参数，这些参数一经设定，将维持不变，除非给系统断电后重新设定。这时使用数字拨码盘既简单直观，又方便可靠。
七、按键介绍
常用的按键有三种：机械触点式按键、导电橡胶式和柔性按键（又称触摸式键盘）。
机械触点式按键是利用弹性使键复位，手感明显，连线清晰，工艺简单，适合单件制造。但是触点处易侵入灰尘而导致接触不良，体积相对较大。
导电橡胶按键是利用橡胶的弹性来复位，通过压制的方法把面板上所有的按键制成一块，体积小，装配方便，适合批量生产。但是时间长了，橡胶老化而使弹力下降，同时易侵入灰尘。
柔性按键是近年来迅速发展的一种新型按键，可以分为凸球型和平面型两种。凸球型动作幅度触感明显，富有立体感，但制造工艺相对复杂；平面型幅度微小，触感较弱，但工艺简单，寿命长。柔性按键最大特点是防尘、防潮、耐蚀，外形美观，装嵌方便。而且外形和面板的布局、色彩、键距可按照整机的要求来设计。
八、单片机系统键盘设计实例
键盘工作方式采用定时扫描方式。采用定时器T0定时，CPU每隔200ms扫描键盘一次，即通过读取573的输出数据，识别按键的工作状态。
对于重键（串键：指同时有一个以上的键按下），采用软件提供保护，当判断为一个以上的键按下，则不处理，返回重新进行监测。只有监测到一个键按下时，才判断键值，执行相应键处理工作。
键盘对液晶显示的控制是通过显示画面的页码作为接口参数来完成的。在每一页中，键盘对数据的修改是通过对按键次数的计算作为接口参数来实现的。具体例程如下：
void keyscan() /*键盘扫描*/
{ucher data newz ，temp，pat；
if(time_out)
{ACC=MJP; /*读取573数据*/
temp=ACC&0x0f， /*取低四位*/
if(temp！=0x0f) /*有键按下*/
{msec(10); / *延时10MS*/
ACC=MJP； /*读取573数据*/
temp=ACC&0x0f
if(temp=0x0f)
{newz=temp; /*读取新键值*/
pat=newz^old; /*键值有无变化*/
if(pat)>0) /*有变化*/
{old=newz; /*原键值等于新键值*/
keymana(); /*调键散转程序*/
}
else;
}
else;
}
elsr;
old=temp; /*原键值不变*/
time_out=0 /*标志位置零*/
}
esel;
}
4*4键盘程序
; 0 1 2 3 --P30 ; 4 5 6 7 --P31 ; 8 9 A B --P32 ; C D E F --P33 ; P34 P35 P36 P37 ORG 0000h
LJMP MAIN
ORG 0030h
MAIN:
MOV DPTR,#TAB
LCALL KEY
MOVC A,@A+DPTR MOV P0,A CLR P1.3
LJMP MAIN
KEY: LCALL KS
JNZ K1
LCALL DELAY2 AJMP KEY K1: LCALL DELAY2
LCALL KS
JNZ K2
AJMP KEY
K2: MOV R2,#0EFH
MOV R4,#00H
K3: MOV P3,R2
L6: JB P3.0,L1
MOV A,#00H
AJMP LK
L1: JB P3.1,L2
MOV A,#04H
AJMP LK
L2: JB P3.2,L3
MOV A,#08H
AJMP LK
L3: JB P3.3,NEXT
MOV A,#0cH
LK: ADD A,R4
PUSH ACC
K4: LCALL DELAY2
LCALL KS
JNZ K4
POP ACC
RET
NEXT:INC R4
MOV A,R2
JNB ACC.7,KEY
RL A
MOV R2,A
AJMP K3
KS: MOV P3,#0FH
MOV A,P3
XRL A,#0FH
RET
DELAY2: MOV R5,#08H
L7: MOV R6,#0FAH
L8: DJNZ R6,L8
DJNZ R5,L7
RET
TAB:DB 0C0H;0
DB 0F9H;1
DB 0A4H;2
DB 0B0H;3
DB 099H;4
DB 092H;5
DB 082H;6
DB 0F8H;7
DB 080H;8
DB 090H;9
DB 088H;A
DB 083H;b
DB 0C6H;C
DB 0A1H;d
DB 086H;E
DB 08EH;F
END
4X4矩阵键盘扫描汇编程序
PROC KEYCHK
KEYNAME DATA
40H
;(b7-b5纪录按键状态，b4位为有效位， ;b3-b0纪录按键)
KEYRTIME DATA 43H SIGNAL DATA 50H KEY EQU P3
KEYPL EQU P0.6
RTIME EQU 30
KEYCHK: MOV KEY,#0FH
MOV A,KEY
CJNE A,#0FH,NE XT1
; CLR C
NEXT1:
; SETB C
MOV A,KEYNAM E
ANL KEYNAME, #1FH
RRC A
ANL A,#0E0H
ORL KEYNAME, A
CJNE A,#0C0H,N EXT2
SJMP KEYSCAN NEXT2: CJNE A,#0E0H,NEXT3
SJMP WAIT NEXT3:CJNE A,#0A0H,EXIT
ORL KEYNAME,
#0E0H
WAIT: MOV A,KEYRTIME
JNZ EXIT
KEYSCAN:
MOV R1,#0
MOV R3,#11110111B
LOOP: MOV A,R3
RL A
MOV R3,A
MOV KEY,A
MOV A,KEY
ORL A,#0F0H
CJNE A,#0FFH,NEXT31
INC R1
CJNE R1,#4,LOOP
SJMP EXIT
NEXT31: JB ACC.0,NEXT32
MOV R2,#0
SJMP NEXT5
NEXT32:JB ACC.1,NEXT33
MOV R2,#1
SJMP NEXT5
NEXT33:JB ACC.2,NEXT34
MOV R2,#2
SJMP NEXT5
NEXT34:MOV R2,#3
NEXT5: MOV A,R1
RL A
RL A
ADD A,R2
MOV DPTR,#KE
YTAB
MOVC A,@A+DPTR
ANL KEYNAME,
#0E0H
ORL KEYNAME,
A
MOV KEYRTIME
,#RTIME
CLR KEYPL
MOV SIGNAL,#
10
EXIT: MOV KEY,#0FFH
RET
KEYTAB: ;//=按键名称表=
DB 1AH ;扫描码0，对应A
DB 1BH ;扫描码1，对应B
DB 1CH ;扫描码2，对应C
DB 1DH ;扫描码3，对应D
DB 11H ;扫描码4，对应1
DB 14H ;扫描码5，对应4
DB 17H ;扫描码6，对应7
DB 1EH ;扫描码7，对应E
DB 12H ;扫描码8，对应2
DB 15H ;扫描码9，对应5
DB 18H ;扫描码A，对应8
DB 10H ;扫描码B，对应0
DB 13H ;扫描码C，对应3
DB 16H ;扫描码D，对应6
DB 19H ;扫描码E，对应9
DB 1FH ;扫描码F，对应F
END
4×4矩阵式键盘
org 0000h ljmp start org 0030h
start:mov dptr,#table
mov r3,#4
mov p2,#00h
lcall keyscan
response:movc
a,@a+dptr
mov p0,a
setb p2.1
keyscan:lcall keypress; jnz k1
jmp keyscan
k1: lcall delay
lcall keypress
jnz k2
jmp keyscan
k2: mov r0,#00h
mov r1,#00h
mov p1,#0efh
mov a,p1
anl a,#0fh;
mov r2,a
xrl a,#0fh
jnz k3
mov p1,#0dfh
mov r0,#01h
mov a,p1
anl a,#0fh
mov r2,a
xrl a,#0fh
jnz k3 mov p1,#0bfh;
mov r0,#02h
mov a,p1
anl a,#0fh;
mov r2,a
xrl a,#0fh
jnz k3
mov p1,#07fh;
mov r0,#03h;
mov a,p1
anl a,#0fh;
mov r2,a
xrl a,#0fh
jnz k3
jmp keyscan
k3: mov a,r2
rrc a ;
jnc k4 ;
rrc a
jnc k5 ;
rrc a
jnc k6 ;
jnb p1.3,$
mov r1,#03h
mov a,r0
mov b,r3
mul ab
add a,r1
jmp response
k4: jnb p1.0,$ ;
mov r1,#00h
mov a,r0
mov b,#4
mul ab
add a,r1
jmp response
k5: jnb p1.1,$
mov r1,#01h
mov a,r0
mov b,#4
mul ab
add a,r1
jmp response
k6: jnb p1.2,$
mov r1,#02h
mov a,r0
mov b,#4
mul ab
add a,r1
jmp response
keypress:mov p1,#0fh
mov a,p1
xrl a,#0fh
ret
delay: mov r7,#50
d1: mov r6,#248
djnz r6,$
djnz r7,d1
ret
table: db
3fh,06h,5bh,4fh;0 1 2 3
66h,6dh,7dh,07h;4 5 6 7
7fh,6fh,77h,7ch;8 9 a b
39h,5eh,79h,71h;c d e f
end ********* 4×4矩阵式键盘
KEYNAME DATA 40H
ORG 0000H
LJMP MAIN
ORG 0030H
MAIN:MOV SP, #80H
CLR F0
LOOP:LCALL KEYCHK
LCALL KEYSCAN
SJMP LOOP
KEYCHK:MOV P1, #0F0H
MOV A, P1
CJNE A, #0F0H, $+3
LCALL DELAY_10MS
MOV A, P1
CJNE A, #0F0H, NEXT11
CLR F0
SJMP EXIT1
NEXT11:SETB F0
EXIT1:RET
KEYSCAN:
JNB F0, EXIT2
MOV R7, #4
MOV R5, #0
MOV R6, #01111111B
LOOP1:MOV A, R6
RL A
MOV R6, A
MOV P1, A
MOV A, P1
ANL A, #0F0H
XRL A, #0F0H
JNZ NEXT21
INC R5
DJNZ R7, LOOP1
SJMP EXIT2
NEXT21:
JNB Acc.4, NEXT22
MOV R4, #0
SJMP NEXT25
NEXT22:
JNB Acc.5, NEXT23
MOV R4, #1
SJMP NEXT25
NEXT23:
JNB Acc.6, NEXT24
MOV R4, #2
SJMP NEXT25
NEXT24:MOV R4, #3
NEXT25:MOV A, R5
RL A
RL A
ADD A, R4
MOV DPTR, #KEYTAB
MOVC A, @A+DPTR
MOV KEYNAME, A
EXIT2:RET
DELAY_10MS:SETB RS1
SETB RS0
MOV R2,#20
DELAY0:MOV R3,#250
DJNZ R3,$
DJNZ R2,DELAY0
RET
KEYTAB:DB 0,1,2,3,4,5,6,
7,8,9,10,11, 12,13,14,15 END
4X4键盘输入数码管移位显示1
#include
#include
#include
uchar num,num1,temp;
sbit dula=P2^6;
sbit wela=P2^7;
uchar code table[]={0x3f,0x06,0x5b,0x4f, 0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c, 0x39,0x5e,0x79,0x71,0x00};
uchar keyscan();
void delay(uchar z)
{ //10MS延时
uint x;
for(z;z!=0;z--)
for(x=1250;x!=0;x--);
}
void main()
{
wela=1;
dula=0;
P0=0xc0;
num=17;
P0=0;
wela=0; //所有数码管不亮
dula=1;
while(1)
{
num1=keyscan();
P0=table[num1-1];
}
}
uchar keyscan()
{
P3=0xf0;
temp=P3;
while(temp!=0xf0)
{
delay(1);
temp=P3;
while(temp!=0xf0)
{
P3=0xfe; temp=P3&0xf0;
if(temp!=0xf0)
{
temp=P3;
switch(temp)
{
case 0xee:num=1,temp=0xf0; break; case 0xde:num=2,temp=0xf0; break; case 0xbe:num=3,temp=0xf0; break; case 0x7e:num=4,temp=0xf0; break;
// default:temp=0xf0;
}
}
P3=0xfd;
temp=P3&0xf0;
while(temp!=0xf0)
{
temp=P3;
switch(temp)
{
case 0xed:num=5,temp=0xf0;break;
case 0xdd:num=6,temp=0xf0;break;
case 0xbd:num=7,temp=0xf0;break;
case 0x7d:num=8,temp=0xf0;break;
// default:temp=0xf0;
}
}
P3=0xfb;
temp=P3&0xf0;
while(temp!=0xf0)
{
temp=P3;
switch(temp)
{
case 0xeb:num=9,temp=0xf0;break; case 0xdb:num=10,temp=0xf0;break; case 0xbb:num=11,temp=0xf0;break; case 0x7b:num=12,temp=0xf0;break;
// default:temp=0xf0;
}
}
P3=0xf7;
temp=P3;
temp&=0xf0;
while(temp!=0xf0)
{
temp=P3;
switch(temp)
{
case 0xe7:num=13,temp=0xf0;break; case 0xd7:num=14,temp=0xf0;break;
case 0xb7:num=15,temp=0xf0;break;
case 0x77:num=16,temp=0xf0;break;
// default:temp=0xf0;
}
}
}
}
return (num);
}
4X4键盘输入数码管移位显示2
#include
#include
#include
uchar num,num1,num2,temp;
uchar a,b,c,d,e,f;
sbit dula=P2^6;
sbit wela=P2^7;
uchar code table[]={0x3f,0x06,0x5b,0x4f, 0x66,0x6d,0x7d,0x07, 0x7f,0x6f,0x77,0x7c, 0x39,0x5e,0x79,0x71,0x00};
uchar code table1[]={0xdf,0xef,0xf7,0xfb, 0xfd,0xfe} ;
uchar keyscan();
void display();
void delay(uchar z)
{
uint x;
for(z;z!=0;z--)
for(x=625;x!=0;x--);
}
void inti()
{
num1=0;
a=b=c=d=e=f=16;
wela=0;
dula=0;
}
void main()
{
inti();
while(1)
{
keyscan();
switch(num1)
{
case 1:a=num-1;break;
case 2:b=num-1;break;
case 3:c=num-1;break;
case 4:d=num-1;break;
case 5:e=num-1;break;
case 6:f=num-1;break;
// default:;
}
display();
}
}
uchar keyscan()
{
P3=0xf0;
temp=P3;
while(temp!=0xf0)
{
delay(1);
temp=P3;
while(temp!=0xf0)
{
P3=0xfe;
temp=P3&0xf0;
if(temp!=0xf0)
{
temp=P3;
switch(temp)
{
case 0xee:num=1,temp=0xf0; break;
case 0xde:num=2,temp=0xf0; break;
case 0xbe:num=3,temp=0xf0; break;
case 0x7e:num=4,temp=0xf0; break;
// default:temp=0xf0;
}
}
P3=0xfd; //
temp=P3&0xf0;
while(temp!=0xf0)
{
temp=P3;
switch(temp)
{
case 0xed:num=5,temp=0xf0;break; case 0xdd:num=6,temp=0xf0;break; case 0xbd:num=7,temp=0xf0;break; case 0x7d:num=8,temp=0xf0;break; // default:temp=0xf0;
}
}
P3=0xfb;
temp=P3&0xf0;
while(temp!=0xf0)
{
temp=P3;
switch(temp)
{
case 0xeb:num=9,temp=0xf0;break; case 0xdb:num=10,temp=0xf0;break; case 0xbb:num=11,temp=0xf0;break; case 0x7b:num=12,temp=0xf0;break; // default:temp=0xf0;
}
}
P3=0xf7;
temp=P3;
temp&=0xf0;
while(temp!=0xf0)
{
temp=P3;
switch(temp)
{
case 0xe7:num=13,temp=0xf0;break; case 0xd7:num=14,temp=0xf0;break; case 0xb7:num=15,temp=0xf0;break; case 0x77:num=16,temp=0xf0;break; // default:temp=0xf0;
}
}
P3=0xf0;
while(P3!=0xf0);
delay(1);
while(P3!=0xf0);
}
if(num1==6)
{num1=0;}
num1++;
}
return (num);
}
void display()
{ //最右第1个数码管，下同。
P0=table[a];
dula=1;
dula=0;
num2=num1;
switch(num2)
{
case 1:num2=0;break;
case 2:num2=1;break;
case 3:num2=2;break;
case 4:num2=3;break;
case 5:num2=4;break;
case 6:num2=5;break;
}
P0=table1[num2];
wela=1;
delay(1);
P0=0xff;
wela=0;
P0=table[b]; //2
dula=1;
dula=0;
num2=num1;
switch(num2)
{
case 1:num2=5;break;
case 2:num2=0;break;
case 3:num2=1;break;
case 4:num2=2;break;
case 5:num2=3;break;
case 6:num2=4;break;
}
P0=table1[num2];
wela=1;
delay(1);
P0=0xff;
wela=0;
P0=table[c]; //3
dula=1;
dula=0;
num2=num1;
switch(num2)
{
case 1:num2=4;break;
case 2:num2=5;break;
case 3:num2=0;break;
case 4:num2=1;break;
case 5:num2=2;break;
case 6:num2=3;break; }
P0=table1[num2];
wela=1;
delay(1);
P0=0xff;
wela=0;
P0=table1[num2];
wela=1;
delay(1);
P0=0xff;
wela=0;
P0=table[d]; //4
dula=1;
dula=0;
num2=num1;
switch(num2)
{
case 1:num2=3;break;
case 2:num2=4;break;
case 3:num2=5;break;
case 4:num2=0;break;
case 5:num2=1;break;
case 6:num2=2;break; }
P0=table1[num2];
wela=1; delay(1);
P0=0xff;
wela=0;
P0=table1[num2];
wela=1;
delay(1);
P0=0xff;
wela=0;
P0=table[e]; //5
dula=1;
dula=0;
num2=num1;
switch(num2)
{
case 1:num2=2;break;
case 2:num2=3;break;
case 3:num2=4;break;
case 4:num2=5;break;
case 5:num2=0;break;
case 6:num2=1;break; }
P0=table1[num2];
wela=1;
delay(1);
P0=0xff;
wela=0;
P0=table1[num2];
wela=1;
delay(1);
P0=0xff;
wela=0;
P0=table[f]; //6
dula=1;
dula=0;
num2=num1;
switch(num2)
{
case 1:num2=1;break;
case 2:num2=2;break;
case 3:num2=3;break;
case 4:num2=4;break;
case 5:num2=5;break;
case 6:num2=0;break; }
P0=table1[num2]; wela=1;
delay(1);
P0=0xff;
wela=0;
}
C51矩阵键盘
＃i nclude
＃i nclude
void delay(unsigned int i);
const unsigned char leddigit[12]={0x28,0x7e,0xa2,0x62, 0x74,0x61,0x21,0x7a,0x20,0x60,0xff,0xdf}; /* 字符0-9 编码,0xff为关显示，0xdf为小数点 */
#define disp(a,b) P2=~(1<<(a));P0=leddigit[b]
#define uchar unsigned char
#define uint unsigned int
void key()
{
uchar k;
P1 = 0xf0;//低位置○，准备查询按键
k = P1;//取得当前P1口的状态
if(k != 0xf0)
{//如果有变化则表示有键按下
k = 0xfe;
do{//循环扫描每一行
P1 = k;
if(k != P1)
{
switch(P1)
{
//第一行
case 0x77:{disp(1,1);break;}
case 0xb7:{disp(1,2);break;}
case 0xd7:{disp(1,3);break;}
case 0xe7:{disp(1,4);break;}
//第二行
case 0x7b:{disp(1,5);break;}
case 0xbb:{disp(1,6);break;}
case 0xdb:{disp(1,7);break;}
case 0xeb:{disp(1,8);break;}
//第三行
case 0x7d:{disp(1,9);break;}
case 0xbd:{disp(1,10);break;}
case 0xdd:{disp(1,11);break;}
case 0xed:{disp(4,11);break;}
//第四行
case 0x7e:{disp(2,1);break;}
case 0xbe:{disp(2,2);break;}
case 0xde:{disp(3,3);break;}
case 0xee:{disp(4,4);break;}
}
}
k = _crol_(k,1);//移位，进入下一行扫描 }while(k !=0xef);//超过范围退出
}
}
main()
{
while(1)
{
key();
}
}
简单矩阵键盘扫描程序
key:mov p0,#00001111b; jmp k10;
goend:jmp kend;
k10:jb p0.0,k20;
k11:mov p0,#11101111b; jb p0.0,k12;
mov r1,#1;
k12:mov p0,#11011111b jb p0.0,k13
mov r1,#2;
k13:mov p0,#10111111b jb p0.0,k14
mov r1,#3;
k14:mov p0,#01111111b
jb p0.0,kend;
mov r1,#4
jmp kend;
k20:jb p0.1,k30;
k21:mov p0,#11101111b;
jb p0.1,k22;
mov r1,#5;
k22:mov p0,#11011111b
jb p0.1,k23
mov r1,#6
k23:mov p0,#10111111b
jb p0.1,k24
mov r1,#7
k24:mov p0,#01111111b
jb p0.1,kend
mov r1,#8
jmp kend;
）
k30:jb p0.2,k40
k31:mov p0,#11101111b jb p0.2,k32 mov r1,#9
k32:mov p0,#11011111b jb p0.2,k33 mov r1,#10
k33:mov p0,#10111111b jb p0.2,k34 mov r1,#11
k34:mov p0,#01111111b jb p0.2,kend mov r1,#12 jmp kend k40:jb p0.3,kend k41:mov p0,#11101111b jb p0.3,k42 mov r1,#13
k42:mov p0,#11011111b
jb p0.3,k43 mov r1,#14
k43:mov p0,#10111111b jb p0.3,k44 mov r1,#15
k44:mov p0,#01111111b jb p0.3,kend mov r1,#16
kend: ret
每个键的扫描码都为8位，高4位中有一个0，这个0的位置恰好就是该键在键盘矩阵中的坐标，低四位中也有一个0，这个0在低四位中的位置刚好是这个键在键盘矩阵中的行坐标，所以一只键的扫描码就代表这只键在键盘矩阵中所处的物理位置，如果在键盘中给每一只键定义了一个名字，即代码 。比如在我们这个系统中，16只键的代码分别为十六进制中的16个数，由于每只键的代码和它的物理坐标，即扫描码是一一对应的，所以当程序识别出用户所按键的扫描码，也就相当于得到了用户所按键的代码。假如单片机片内数据存储器的20H-23H 单元为键盘缓冲区，用于存放用户的四次击键的代码，每次用户击键后，显示缓冲区中的内容前移一位，而把用户击键的代码放入最后一个单元中，即将21H 的内容放入20H 中，22H 的内容放入21H 中，23H 的内容放入22H 中，用户击键放入23H 中。
精简[4X4]键盘C51程序设计
#include
unsigned char led[17]={0x3F,0x06,0x5B,0x4F,0x66, 0x6D,0x7D,0x07,0x7F,0x6F}; void delay() {
unsigned char i,j; for(i=0;i<80;i++)
for(j=0;j<100;j++); }
void delay1() {
unsigned char i,j; for(i=0;i<10;i++)
for(j=0;j<100;j++); }
key_scan() {
unsigned char k=0,p1_h=0,p1_l=0; P1=0XF0; k=P1;
if(k!=0XF0) {
delay();
k=P1; if(k!=0XF0) {
p1_h=P1; P1=0X0f; p1_l=P1; k=p1_h | p1_l; switch(k) {
case 238: return(key=1);break; case 237: return(key=2);break; case 235: return(key=3);break;
case 231: return(key=4);break;
case 222: return(key=5);break;
case 221: return(key=6);break;
case 219: return(key=7);break;
case 215: return(key=8);break;
case 190: return(key=9);break;
case 189: return(key=10);break;
case 187: return(key=11);break;
case 183: return(key=12);break;
case 126: return(key=13);break;
case 125: return(key=14);break;
case 123: return(key=15);break;
case 119: return(key=16);break;
default: return(key=0);break;
}
}
else
return(0);
}
else
return(0);
}
void main()
{
while(1)
{
key_scan();
P2=0xfe;
P0=led[key%10];
delay1();
P2=0xff;
P2=0xfd;
P0=led[key/10];
delay1();
P2=0xff;
}
}
行列式键盘程序
#include
#include "xwj_hlkey.h"
//#include "xwj_bp.h" //峰鸣器
#define KEYDELAY 25
#define KEYLOOP 10
unsigned char key_bak;
unsigned char key_temp;
unsigned char key_old;
unsigned char key_data;
bit key_ok;
unsigned char code Tab_key[]=
{0x00, //无键按下
'7','8','9','/',
'4','5','6','*',
'1','2','3','-',
'C','0','=','+',
//下面为按'C'同时再按的键:
'7','8','9','/',
'4','5','6','*',
'1','2','3','-',
'0','=','+',};
#define KEYPIN_L P1
#define KEYPIN_H P1
unsigned char fnKeyCode(unsigned char key); void KeyScan(void) //键扫描
{
unsigned char sccode,recode;
KEYPIN_L = KEYPIN_L|0x0f;
KEYPIN_H = KEYPIN_H&0x0f;
if ((KEYPIN_L&0x0f) != 0x0f)
{ //有键按下
key_temp = 0;
sccode = 0xef; //逐行扫描码初值//
while(sccode != 0xff) //将扫描4次//
{
KEYPIN_H = sccode; // 输出行扫描码//
if ((KEYPIN_L&0x0f) != 0x0f) //有键按下//
{
recode = (KEYPIN_L&0x0f)|0xf0;
//只要低位,高位置1//
key_temp
|= (~sccode)+(~recode);
//特征码(高位为列P3,低位为行KEYPIN_H) //
}
sccode = (sccode << 1)|0x01;
// 扫描码0向高位移动 //
}
if (key_temp == key_bak)
{
key_old++;
if (key_old==KEYDELAY)
//连续键,不要则把此if屏蔽
{
key_ok=1;
key_data=fnKeyCode(key_temp) ;
//键解码
key_old=KEYDELAY-KEYLOOP;
}
}
else
{
key_old=0;
key_bak=key_temp;
}
}
else //键抬起
{
if (key_old)
{
key_ok=1;
key_data=fnKeyCode(key_temp);//键解码
/* if (key_old==100)
//加上时间,不同时间不同功能,与连续键冲突
{
bp(1);
key_data +=
0x10;
}
if (key_old==200)
{
bp(2);
key_data +=
0x20;
}
*/
}
key_old=0;
}
KEYPIN_H = KEYPIN_H|0xf0; }
unsigned char fnKeyCode(unsigned char key)
// 根据键盘映射表输出顺序键值 //
{ //由于我的键盘要考虑多键同时按下，所以这个地方较繁琐，无必要则不必这样解码//
switch(key)
{
case 0x11: // 1 键 //
key = 0x01; break;
case 0x21: // 2 键 //
key = 0x02; break;
case 0x41: // 3 键 //
key = 0x03; break;
case 0x81: // 4 键 //
key = 0x04; break;
case 0x12: // 5 键 //
key = 0x05; break;
case 0x22: // 6 键 //
key = 0x06; break;
case 0x42: // 7 键 //
key = 0x07; break;
case 0x82: // 8 键 //
key = 0x08; break;
case 0x14: // 9 键 //
key = 0x09; break;
case 0x24: // 10 键 //
key = 0x0A; break;
case 0x44: // 11 键 //
key = 0x0B; break;
case 0x84: // 12 键 //
key = 0x0C; break;
case 0x18: // 13 键 //
key = 0x0D; break;
case 0x28: // 14 键 //
key = 0x0E; break;
case 0x48: // 15 键 //
key = 0x0F; break;
case 0x88: // 16 键 //
key = 0x10; break;
//以下为功能键//
case 0x19: // 'C' +1 键 //
key = 0x11; break;
case 0x29: // 'C' +2
键 //
key = 0x12; break;
case 0x49: // 'C' +3 键 //
key = 0x13; break;
case 0x89: // 'C' +4 键 //
key = 0x14; break;
case 0x1A: // 'C' +5 键 //
key = 0x15; break;
case 0x2A: // 'C' +6 键 //
key = 0x16; break;
case 0x4A: // 'C' +7 键 //
key = 0x17; break;
case 0x8A: // 'C' +8 键 //
key = 0x18; break;
case 0x1C: // 'C' +9 键 //
key = 0x19; break;
case 0x2C: // 'C' +10 键 //
key = 0x1A; break;
case 0x4C: // 'C' +11 键 //
key = 0x1B; break;
case 0x8C: // 'C' +12 键 //
key = 0x1C; break;
// case 0x18: // 'C' +13 键 //
// key = 0x1D; break;
case 0x38: // 'C' +14 键 //
key = 0x1D; break;
case 0x58: // 'C' +15 键 //
key = 0x1E; break;
case 0x98: // 'C' +16 键 //
key = 0x1F; break;
default : // 无键 //
key = 0x00; break;
}
return(Tab_key[key]);
}
unsigned char KeyGetCode(void) //返回按键码
{
key_ok=0;
return(key_data);
}
bit KeyTest(void) //检查有无按键
{
KeyScan(); //键扫描
return(key_ok);
}
键盘扫描0-F数码管显示
#include
sbit beep=P2^3;
sbit dula=P2^6;
sbit wela=P2^7;
unsigned char i=100;
unsigned char j,k,temp,key;
void delay(unsigned char i)
{ //当i=10时大约为10毫秒
for(j=i;j>0;j--)
for(k=125;k>0;k--);
}
unsigned char code table[]={0x3f,0x06,0x5b,0x4f, 0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x77,0x7c,0x39,
0x5e,0x79,0x71};
display(unsigned char num)
{ P0=table[num]; dula=1;
dula=0;
P0=0xc0;
wela=1;
wela=0;
}
void main()
{
dula=0;
wela=0;
while(1)
{
P3=0xfe;
temp=P3;
temp=temp&0xf0;
if(temp!=0xf0)
{
delay(10);
if(temp!=0xf0)
{
temp=P3;
switch(temp)
{
case 0xee: key=0; break;
case 0xde: key=1; break; case 0xbe: key=2; break; case 0x7e: key=3; break; }
while(temp!=0xf0)
{
temp=P3;
temp=temp&0xf0;
beep=0;
}
beep=1;
display(key);
P1=0xfe;
}
}
P3=0xfd;
temp=P3;
temp=temp&0xf0;
if(temp!=0xf0)
{
delay(10);
if(temp!=0xf0)
{
temp=P3;
switch(temp)
{
case 0xed: key=4; break; case 0xdd: key=5; break; case 0xbd: key=6; break; case 0x7d: key=7; break; }
while(temp!=0xf0)
{
temp=P3;
temp=temp&0xf0; beep=0;
}
beep=1;
display(key);
P1=0xfc;
}
}
P3=0xfb;
temp=P3;
temp=temp&0xf0;
if(temp!=0xf0)
{
delay(10);
if(temp!=0xf0)
{
temp=P3;
switch(temp)
{
case 0xeb: key=8; break; case 0xdb: key=9; break; case 0xbb: key=10; break; case 0x7b: key=11; break; }
while(temp!=0xf0)
{
temp=P3;
temp=temp&0xf0;
beep=0;
}
beep=1;
display(key);
P1=0xf8;
}
}
P3=0xf7;
temp=P3;
temp=temp&0xf0;
if(temp!=0xf0)
{
delay(10);
if(temp!=0xf0)
{
temp=P3;
switch(temp)
{
case 0xe7: key=12; break; case 0xd7: key=13; break; case 0xb7: key=14; break; case 0x77: key=15; break; }
while(temp!=0xf0)
{
temp=P3;
temp=temp&0xf0;
beep=0;
}
beep=1;
display(key);
P1=0xf0;
}
}
}
}
4*4键盘
UPDOWN EQU 00H
STARTEND EQU 01H
LAMPCODE EQU 21H
ORG 0000H
AJMP MAIN
ORG 30H
;K1 OPEN
MAIN:MOV SP,#60H ;K2 CLOSE MOV P1,#0FFH;K3 LEFT
CLR UPDOWN ;K4 RIGHT
CLR STARTEND
;K1 =0 K3=0 LEFT
MOV LAMPCODE,#0FEH
; K4=0 RIGHT
LOOP: ACALL KEY
JNB F0,LNEXT;K2=0 CLOSE
LCALL KEYPROC LNEXT: ACALL LAMP
AJMP LOOP
DELAY: MOV R7,#100
D1: MOV R6,#100
DJNZ R6,$
DJNZ R7,D1
RET
KEYPROC:MOV A,B
JB ACC.2,KEYSTART
JB ACC.3,KEYOVER
JB ACC.4,KEYUP
JB ACC.5,KEYDOWN
AJMP KEYRET KEYSTART:SETB STARTEND
AJMP KEYRET
KEYOVER:CLR STARTEND
AJMP KEYRET
KEYUP: SETB UPDOWN
AJMP KEYRET
KEYDOWN:CLR UPDOWN
KEYRET: RET
KEY: CLR F0
ORL P3,#00111100B
MOV A,P3
ORL A,#11000011B
CPL A
JZ KRET
ACALL DELAY
ORL P3,#00111100B
MOV A,P3
ORL A,#11000011B
CPL A
JZ KRET
MOV B,A
SETB F0
KRET: ORL P3,#00111100B
MOV A,P3
ORL A,#11000011B
CPL A
JZ KRET1
AJMP KRET
KRET1: RET
DEL500M:PUSH PSW
SETB RS0
MOV R7,#200
D51: MOV R6,#250
D52: NOP
NOP
NOP
NOP
DJNZ R6,D52
DJNZ R7,D51
POP PSW
RET
LAMP:JB STARTEND,LAMPSTART
MOV P1,#0FFH
AJMP LAMPRET
LAMPSTART:
JB UPDOWN,LAMPUP
MOV A,LAMPCODE
RL A
MOV LAMPCODE,A
MOV P1,A
LCALL DEL500M
AJMP LAMPRET
LAMPUP: MOV A,LAMPCODE
RR A
MOV LAMPCODE,A
MOV P1,A
LCALL DEL500M
LAMPRET:RET
END****************
**************** LED1 EQU P1.0
LED2 EQU P1.1 LED3 EQU P1.2
LED4 EQU P1.3
LED5 EQU P1.4
LED6 EQU P1.5
LED7 EQU P1.6
LED8 EQU P1.7
S1 BIT P0.0
S2 BIT P0.1
S3 BIT P0.2
S4 BIT P0.3
S5 BIT P0.4
S6 BIT P0.5
S7 BIT P0.6
S8 BIT P0.7
LDAT EQU P2
KEY1 BIT P3.5
KEY2 BIT P3.6
KEY3 BIT P3.7
KEY EQU 46H
ORG 00H
AJMP MAN
ORG 30H
MAN:MOV SP,#5FH
LCALL REST
LP:LCALL PROKEY
LCALL KEYPR
JMP LP
REST:MOV A,#00H
MOV B,#00H
MOV P0,#0
MOV P1,#0FFH
MOV P2,#0
MOV KEY,#00H
MOV P2,#255
CLR BEEP
RET
KEYPR:
MOV A,KEY
JZ PROEND
CJNE A,#1,K1
MOV A,#1
MOV DPTR,#TAB
MOVC A,@A+DPTR
MOV LDAT,A
SETB S1
CLR S2
CLR S3
JMP PROEND
K1: CJNE A,#2,K2
MOV A,#2
MOV DPTR,#TAB
MOVC A,@A+DPTR
MOV LDAT,A
CLR S1
SETB S2
CLR S3
JMP PROEND
K2: CJNE A,#3,PROEND
MOV A,#3
MOV DPTR,#TAB
MOVC A,@A+DPTR
MOV LDAT,A
CLR S1
CLR S2
SETB S3
PROEND: RET
DEL:
D1: MOV R6,#20
D2:MOV R7,#248
DJNZ R7,$
DJNZ R6,D2
RET
TAB:DB db 0c0h, 0f9h, 0a4h, 0b0h, 99h , 92h , 82h, 0f8h ;数字0-7 不带小数点代码 db 80h , 90h, 88h , 83h , 0c6h, 0a1h, 86h, 8eh ;数字8-f 不带小数点代码
db 40h , 79h, 24h , 30h , 19h , 12h , 02h, 78h ;数字0-7 带小数点代码
db 00h , 10h, 08h , 03h , 46h , 21h , 06h, 0eh
END **********************
KEYNAME DATA 40H KEYRTIME DATA 43H SIGNAL DATA 50H KEY EQU P3 KEYPL EQU P0.6 RTIME EQU 30 KEYCHK:
MOV KEY,#0FH
MOV A,KEY
CJNE A,#0FH,NEXT1
CLR C
NEXT1:SETB C
MOV A,KEYNAME
ANL KEYNAME,#1FH
RRC A
ANL A,#0E0H
ORL KEYNAME,A
CJNE A,#0C0H,NEXT2
SJMP KEYSCAN
NEXT2:
CJNE A,#0E0H,NEXT3
SJMP WAIT
NEXT3:CJNE A,#0A0H,EXIT
ORL KEYNAME,#0E0H
WAIT:
MOV A,KEYRTIME
JNZ EXIT
KEYSCAN:
MOV R1,#0
MOV R3,#11110111B
LOOP:MOV A,R3
RL A
MOV R3,A
MOV KEY,A
MOV A,KEY
ORL A,#0F0H
CJNE A,#0FFH,NEXT31
INC R1
CJNE R1,#4,LOOP
SJMP EXIT
NEXT31:
JB ACC.0,NEXT32
MOV R2,#0
SJMP NEXT5
NEXT32:
JB ACC.1,NEXT33
MOV R2,#1
SJMP NEXT5
NEXT33:
JB ACC.2,NEXT34
MOV R2,#2
SJMP NEXT5 NEXT34:
MOV R2,#3 NEXT5:
MOV A,R1
RL A
RL A ADD A,R2
MOV DPTR,#KEYTAB
MOVC A,@A+DPTR
ANL KEYNAME,#0E0H
ORL KEYNAME,A
MOV KEYRTIME,#RTIME
CLR KEYPL
MOV SIGNAL,#10
EXIT:MOV KEY,#0FFH
RET
KEYTAB: DB 1AH ,1BH,1CH,1DH,
11H,14H,17H,1EH,112H,15H,18H,
10H,13H,16H,00H
END ****************
************************* ORG 00H
LJMP START
ORG 30H
START:MOV DPTR,#TAB
MOV R3,#4
MOV P2,#00H
LCALL KEYSCAN RES: MOVC A,@A+DPTR
MOV P0,A
SETB P2.1 KEYSCAN:LCALL KEYPRE
JNZ K1
JMP KEYSCAN
K1: LCALL DEL
LCALL KEYPRE
JNZ K2
JMP KEYSCAN
K2: MOV R0,#00H
MOV R1,#00H
MOV P1,#0EFH
MOV A,P1
ANL A,#0FH
MOV R2,A
XRL A,#0FH
JNZ K3
MOV P1,#0DFH
MOV R0,#01H
MOV A,P1
ANL A,#0FH
MOV R2,A
XRL A,#0FH
JNZ K3
MOV P1,#0BFH
MOV R0,#02H
MOV A,P1
ANL A,#0FH
MOV R2,A
XRL A,#0FH
JNZ K3
MOV P1,#07FH
MOV R0,#03H
MOV A,P1
ANL A,#0FH
MOV R2,A
XRL A,#0FH
JNZ K3
JMP KEYSCAN
K3: MOV A,R2
RRC A
JNC K4
RRC A
JNC K5
RRC A
JNC K6
JNB P1.3,$
MOV R1,#03H
MOV A,R0
MOV B,R3
MUL AB
ADD A,R1
JMP RES
K4: JNB P1.0,$
MOV R1,#00H
MOV A,R0
MOV B,#4
MUL AB
ADD A,R1
JMP RES
K5: JNB P1.1,$
MOV R1,#01H
MOV A,R0
MOV B,#4
MUL AB
ADD A,R1
JMP RES
K6: JNB P1.2,$
MOV R1,#02H
MOV A,R0
MOV B,#4
MUL AB
ADD A,R1
JMP RES
KEYPRE: MOV P1,#0FH
MOV A,P1
XRL A,#0FH
RET
DEL: MOV R7,#50
D1: MOV R6,#248
DJNZ R6,$
DJNZ R7,D1
RET
TAB:DB 3FH,06H,5BH,4FH,66H,
6DH,7DH,07H,7FH,6FH,7FH,7CH,
39H,5EH,79H,71H
END *************
**************** ORG 00H
LJMP MAIN
ORG 03H
LJMP SUB1 KCODE: DB 0EEH,0DEH,0BEH,07EH
DB 0EDH,0DDH,0BDH,07DH
DB 0EBH,0DBH,0BBH,07BH
DB 0E7H,0D7H,0B7H,077H
MAIN: MOV P2,#0F0H
SETB IT0
MOV IE,#81H
LJMP $
SUB1: MOV A,#0FEH
LA3: MOV P2,A
MOV R0,P2
CJNE R0,ACC,LA1
LJMP LA2
LA1: RL A
LJMP LA3
LA2: MOV DPTR,#KCODE
MOV A,#0
MOV R1,#0
LA6: MOVC A,@A+DPTR
CJNE R0,ACC,LA4
LJMP LA5
LA4: INC R1
MOV A,R1
LJMP LA6
LA5: MOV 20H,21H
MOV 21H,22H
MOV 22H,23H,
MOV 23H,R1
RETI
END ************
************************ BUF EQU 30H
ORG 00H
SJMP STA
ORG 30H ; ;;;;RUN OK STA:MOV BUF,#2H
WIT:MOV P1,#0FFH
CLR P1.4
MOV A,P1
ANL A,#0FH
XRL A,#0FH
JZ NOKEY1
LCALL DEL
MOV A,P1
ANL A,#0FH
XRL A,#0FH
JZ NOKEY1
MOV A,P1
ANL A,#0FH
CJNE A,#0EH,NK1
MOV BUF,#0
LJMP DK1
NK1:CJNE A,#0DH,NK2
MOV BUF,#1
LJMP DK1
NK2:CJNE A,#0BH,NK3
MOV BUF,#2
LJMP DK1
NK3:CJNE A,#07H,NK4
MOV BUF,#3
LJMP DK1
NK4:NOP
DK1A:MOV A,P1
ANL A,#0FH
XRL A,#0FH
JNZ DK1A
NOKEY1:
MOV P1,#0FFH
CLR P1.5
MOV A,P1
ANL A,#0FH
XRL A,#0FH
JZ NOKEY2
CALL DEL
MOV A,P1
ANL A,#0FH
XRL A,#0FH
JZ NOKEY2
MOV A,P1
ANL A,#0FH
CJNE A,#0EH,NK5
MOV BUF,#4
LJMP DK1
NK5:CJNE A,#0DH,NK6
MOV BUF,#5
LJMP DK1
NK6:CJNE A,#0BH,NK7
MOV BUF,#6
LJMP DK1
NK7:CJNE A,#07H,NK8
MOV BUF,#7
LJMP DK1
NK8:NOP
DK2A:MOV A,P1
ANL A,#0FH
XRL A,#0FH
JNZ DK2A
NOKEY2:
MOV P1,#0FFH
CLR P1.6
MOV A,P1
ANL A,#0FH
XRL A,#0FH
JZ NOKEY3
CALL DEL
MOV A,P1
ANL A,#0FH
XRL A,#0FH
JZ NOKEY3
MOV A,P1
ANL A,#0FH
CJNE A,#0EH,NK9
MOV BUF,#8
LJMP DK1
NK9:CJNE A,#0DH,NK10
MOV BUF,#9
LJMP DK1
NK10:CJNE A,#0BH,NK11
MOV BUF,#10
LJMP DK1
NK11:CJNE A,#07H,NK12
MOV BUF,#11
LJMP DK1
NK12:NOP
DK3A:MOV A,P1
ANL A,#0FH
XRL A,#0FH
JNZ DK3A
;SJMP WIT
NOKEY3:
MOV P1,#0FFH
CLR P1.7
MOV A,P1
ANL A,#0FH
XRL A,#0FH
JZ NOKEY4
LCALL DEL
MOV A,P1
ANL A,#0FH
XRL A,#0FH
JZ NOKEY4
MOV A,P1
ANL A,#0FH
CJNE A,#0EH,NK13
MOV BUF,#12
LJMP DK1
NK13:CJNE A,#0DH,NK14 MOV BUF,#13
LJMP DK1
NK14:CJNE A,#0BH,NK15 MOV BUF,#14
LJMP DK1
NK15:CJNE A,#07H,NK16 MOV BUF,#15
LJMP DK1
NK16:NOP
DK4A:MOV A,P1
ANL A,#0FH
XRL A,#0FH
JNZ DK4A
NOKEY4:
LJMP WIT
DK1:;MOV DPTR,#TAB
MOV A,BUF
MOV DPTR,#TAB
MOVC A,@A+DPTR
; CPL A
MOV P0,A
CLR P2.0
LJMP WIT
DEL:MOV R5,#08H
L7:MOV R6,#0FAH
L8:DJNZ R6,L8
DJNZ R5,L7
RET
TAB:DB
0C0H,0F9H,0A4H,0B0H,99H,92H,82
H,0f8h,80h,90h,88h,83h,0c6h,0a
1h,86h,8eh
END ***************
****************** ORG 00H
LJMP STA
ORG 30H ;;RUN OK STA:MOV DPTR,#TAB
MOV R3,#4
MOV P0,#00H
LCALL KEY
RES:MOVC A,@A+DPTR
; CPL A
MOV P0,A
CLR P2.0
KEY:LCALL KS
JNZ K1
LJMP KEY
K1: LCALL DEL
LCALL KS
JNZ K2
LJMP KEY
K2:MOV R2,#0EFH
MOV R3,#00H
MOV R4,#00H
K3: MOV P1,R2
L6: JB P1.0,L1
MOV A,#00H
AJMP LK
L1: JB P1.1,L2
MOV A,#04H
AJMP LK
L2: JB P1.2,L3
MOV A,#08H
AJMP LK
L3:JB P1.3,NEXT
MOV A,#0CH
LK: ADD A,R4
MOV 34H,A
K4: LCALL RES
LCALL KS
JNZ K4
RET
NEXT:INC R4
MOV A,R2
JNB ACC.7,KEY
RL A
MOV R2,A
AJMP K3
KS:MOV P1,#0FH
MOV A,P1
XRL A,#0FH
RET
DEL:MOV R5,#08H
L7:MOV R6,#0FAH
L8:DJNZ R6,L8
DJNZ R5,L7
RET
TAB:DB 0C0H,0F9H,0A4H,0B0H,
99H,92H,82H,0f8h,80h,90h,88h,8
3h,0c6h,0a1h,86h,8eh
END ****************
***************** ORG 00H
SJMP MAIN
ORG 30H;RUN OK MAIN:
; MOV P1,#0FFH
K1: MOV P1,#0FH
MOV A,P1
ANL A,#0FH
CJNE A,#0FH,K1 K2: ACALL DEL
MOV A,P1
ANL A,#0FH
CJNE A,#0FH,OVER
SJMP K2
OVER:ACALL DEL
MOV A,P1
ANL A,#0FH
CJNE A,#0FH,OVER1
SJMP K2
OVER1:MOV P1,#0EFH
MOV A,P1
ANL A,#0FH
CJNE A,#0FH,ROW0
MOV P1,#0DFH
MOV A,P1
ANL A,#0FH
CJNE A,#0FH,ROW1
MOV P1,#0BFH
MOV A,P1
ANL A,#0FH
CJNE A,#0FH,ROW2
MOV P1,#07FH
电子琴C程序代码,四乘四矩阵键盘输入
电子琴C程序代码，四乘四矩阵键盘输入#include
unsigned char STH0; unsigned char STL0; unsigned int code tab[]={ //63625, 63833, 64019, 64104, 64260, 64400, 64524 ,// 低音区:1 2 3 4 64580, 64685, 64778, 64820, 64898, 64968, 65030 ,// 中音区:1 2 3 4 5 65058, 65110, 65157, 65178, 65217, 65252, 65283 ,// 高音区:1 2 3 4 5 65297 ,// 超高音:1 }; // 音调数据表可改 void delay(uchar x) uchar y,z; for(y=x;y>0;y--) for(z=0;z<110;z++); void init() TMOD=0x01; ET0=1; EA=1; void display() { for(i=0;i<2;i++)
4乘4矩阵键盘输入数码管显示四位数
综合课程设计三相步进电机控制器电路的设计 学生姓名__________
指导教师_________ 课程设计任务书 一、设计说明 步进电机是工业过程控制及仪表控制中的主控元件之一，作为执行元件其特点为能够快速起启停、精度高且能直接接收数字量，由于这些特点使其在定位场合得到了广泛的应用。 设计一个三相步进电机控制器，使其能够控制步进电机的工作状态，如步进电机正、反转，步进电机的工作方式等。 用键盘设定步进电机的工作频率，工作方式，并用数码管显示设定值，可以通过按键来更换显示内容。用示波器观测三相的输出波形，并用数码管显示电路的工作状态。 二、技术指标 步进电机的工作频率为：<10kHz 三、设计要求 1．进行方案论证，提出一个合理的设计方案并进行理论设计； 2．对所设计的方案部分进行调试； 3．在选择器件时，应考虑成本。 4．设计测量调试电路。 四、实验要求 1．根据技术指标制定实验方案；验证所设计的电路。 2．进行实验数据处理和分析。 五、推荐参考资料 1?谢自美?电子线路设计?实验?测试.[M]武汉：华中理工大学出版社，2000 年 2. 阎石. 数字电子技术基础. [M] 北京：高等教育出版社，2006年 3. 童诗白、华成英.模拟电子技术基础. [M] 北京：高等教育出版社，2006年 4..付家才. 电子实验与实践. [M] 北京：高等教育出版社，2004年 5．沙占友、李学芝著.中外数字万用表电路原理与维修技术. [M] 北京：人民 邮电出版社，1993年
六、按照要求撰写课程设计报告成绩评定表
一、概述 本次毕设的题目是：三相步进电机控制电路的设计。本次毕设使用80C51单片机作为主控芯片，利用ULN2003A集成电路作为三相步进电机的驱动电路，采用单极性驱动方式，使三相步进电机能在（1）三相单三拍，（2）三相双三拍， （3）三相六拍三种工作方式下正常工作；能实现的功能有：启动/停止控制、方向控制；速度控制；用LED数码管显示工作方式。键盘输入工作频率。本次课程设计采用80C51单片机作为主控芯片，程序采用C语言来编写，驱动电路采用ULN2003A集成电路，显示采用 7SEG-MPX4-CC卩四位共阴数码管，P0接段码，并用8只1K欧左右电阻上拉。P2的4位10 口接位选码。正转，数码管显示1。反转，数码管显示2.不转，数码管显示0.采用Proteus软件进行仿真。在Keil uVsuon3编程环境下编程和编译生成HEX文件，导入到 80C51单片机，实现对各个模块的控制，实现我们所需要的功能。 本次课程是对毕业设计的基础设计，即实现4x4键盘输入，数码管显示输入数字的设计。 二、方案论证 1步进电机驱动方案选择 方案1 :使用功率三极管等电子器件搭建成功率驱动电路来驱动电机的运行。这种方案的驱动电路的优点是使用电子器件联接，电路比较简单，但容易受 干扰，信号不够稳定，缺点是器件较大而不便电路的集成，使用时很不方便，联接时容易出错误。 方案2:使用专门的电机驱动芯片ULN2003A来驱动电机运行。驱动芯片的优点是便于电路的集成，且驱动电路简单，驱动信号很稳定，不易受外界环境的干扰，因而设计的三相步进电机控制系统性能更好。 通过对两种方案的比较，我选择方案2使用ULN2003A S机驱动芯片来作为驱动。 2数码管显示方案选择 方案1：把所需要显示的数据通过专用的七段显示译码器（例如7448）的转换输出给LED显示屏。优点是输出比较简单，可以简化程序，但增加了芯片的费用，电路也比较复杂。 方案2:通过程序把所要的数据转化为七段显示的数据，直接通过单片机接 口来显示，其优点是简化了电路，但增加了软件编写的负担。 通过对两种方案进行比较，我选择通过软件编写来输出显示信号，即单片机直接和显示器相连。 3控制状态的读取 方案1:把按键接到单片机的中断口，若有按键按下，单片机接收到中断信 号，再通过软件编写的中断程序来执行中断，优点是接线简单，简化了电路，但软件编写较为复杂，不易掌握。
4X4扫描式矩阵键盘课程设计
4X4扫描式矩阵键盘课程设计 课程设计名称: 4_4扫描式矩阵键盘设计 姓名：DUKE 班级：电子1008班 学号：10086 成绩： 日期：2014年1月6日
摘要 随着21世纪的到来，电子信息行业将是人类社会的高科技行业之一，式设施现代化的基础，也是人类通往科技巅峰的直通路。电子行业的发展从长远来看很重要，但最主要的还是科技问题。 矩阵式键盘提高效率进行按键操作管理有效方法，它可以提高系统准确性，有利于资源的节约，降低对操作者本身素质的要求。是它能准时、实时、高效地显示按键信息，以提高工作效率和资源利用率。 矩阵式键盘乃是当今使用最为广泛的键盘模式，该系统以N个端口连接控制N*N个按键，显示在LED数码管上。单片机控制依据这是键盘显示系统，该系统可以对不同的按键进行实时显示，其核心是单片机和键盘矩阵电路部分，主要对按键与显示电路的关系、矩阵式技术及设备系统的硬件、软件等各个部分进行实现。 4*4矩阵式键盘采用AT89C51单片机为核心，主要由矩阵式键盘电路、译码电路、显示电路等组成，软件选用C语言编程。单片机将检测到的按键信号转换成数字量，显示于LED显示器上。该系统灵活性强，易于操作，可靠性高，将会有更广阔的开发前景。
目录 第一章：系统功能要求-------------------------------------------------------- 1.1 4*4 矩阵式键盘系统概述------------------------------------------------ 1.2 本设计任务和主要内容--------------------------------------------------- 第二章：方案论证--------------------------------------------------------------- 第三章：系统硬件电路的设计------------------------------------------------ 3.1 单片机控制系统原理----------------------------------------------------- 3.2 原理图绘制说明---------------------------------------------------------- 3.3 画出流程图---------------------------------------------------------------- 3.4 原理图绘制--------------------------------------------------------------- 第四章：系统程序的设计------------------------------------------------------ 4.1 程序的编写步骤----------------------------------------------------------- 4.2 编写的源程序-------------------------------------------------------------- 第五章：调试及性能分析------------------------------------------------------ 第六章：心得体会--------------------------------------------------------------- 参考文献----------------------------------------------------------------------------
STM32_4x4矩阵键盘
/*--------------------------------------------------------------------------------------* 矩阵键盘驱动 * 文件: keyboard.c * 编写人：LiuHui * 描述：扫描4x4 矩阵键盘输入，并返回键值 * 适用范围：驱动采用ST3.5 库编写，适用于STM32F10x 系列单片机 * 所用引脚：PA0-PA7 * 编写时间：2013 年11 月22 日 * 版本：1.0 --------------------------------------------------------------------------------------*/ #include "stm32f10x.h" #include "keyboard.h" #include "dealy.h" /*--------------------------------矩阵键盘初始化----------------------------------------* 功能：初始化stm32 单片机GPIO //PA0-PA7 * 参数传递： * 输入：无 * 返回值：无 --------------------------------------------------------------------------------------*/ void KeyBoard_Init(void) { GPIO_InitTypeDef GPIO_InitStructure; GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; GPIO_Init(GPIOA, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD; GPIO_Init(GPIOA, &GPIO_InitStructure); GPIO_SetBits(GPIOA, GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3); GPIO_ResetBits(GPIOA, GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7); } /*------------------------------矩阵键盘扫描--------------------------------------------* 功能：扫描矩阵键盘，并返回键值 * 参数： * 输入：无 * 返回：有键按下返回该键值 * 无键按下时则返回0 --------------------------------------------------------------------------------------*/ u8 Read_KeyV alue(void) { u8 KeyV alue=0; if((GPIO_ReadInputData(GPIOA)&0xff)!=0x0f) {
单片机课程设计4X4矩阵键盘显示要点
长沙学院 《单片机原理及应用》 课程设计说明书 题目液晶显示4*4矩阵键盘按键号 程序设计 系(部) 电子与通信工程系 专业(班级) 电气1班 姓名龙程 学号2011024109 指导教师刘辉、谢明华、王新辉、马凌 云 起止日期2014.5.19—2014.5.30
长沙学院课程设计鉴定表
《单片机技术及应用》课程设计任务书系(部)：电子与电气工程系专业：11级电子一班指导教师：谢明华、刘辉
目录 前言 (5) 一、课程设计目的 (6) 二、设计内容及原理 (6) 2.1 单片机控制系统原理 (6) 2.2阵键盘识别显示系统概述 (6) 2.3键盘电路 (7) 2.4 12864显示器 (8) 2.5整体电路图 (9) 2.6仿真结果 (9) 三、实验心得与体会 (10) 四、实验程序 (10) 参考文献 (18)
前言 单片机，全称单片微型计算机（英语：Single-Chip Microcomputer），又称微控制器 应（不用外接硬件）和节约成本。它的最大优点是体积小，可放在仪表内部，但存储量小，输入输出接口简单，功能较低。由于其发展非常迅速，旧的单片机的定义已不能满足，所以在很多应用场合被称为范围更广的微控制器；从上世纪80年代，由当时的4位、8位单片机，发展到现在的32位300M的高速单片机。现代人类生活中所用的几乎每件有电子器件的产品中都会集成有单片机。手机、电话、计算器、家用电器、电子玩具、掌上电脑以及鼠标等电子产品中都含有单片机。汽车上一般配备40多片单片机，复杂的工业控制系统上甚至可能有数百片单片机在同时工作!单片机的数量不仅远超过PC机和其他计算机的总和，甚至比人类的数量还要多。 是以电流刺激液晶分子产生点、线、面配合背部灯管构成画面。由一定数量的彩色或黑白像素组成，放置于光源或者反射面前方。液晶显示器功耗低，因此倍受工程师青睐，适用于使用电池的电子设备。英国科学家在上世纪制造了第一块液晶显示器即LCD。而第一台可操作的LCD基于动态散射模式(Dynamic Scattering Mode,DSM)，是RCA公司乔治·海尔曼带领的小组开发的。 LED点阵屏通过LED(发光二极管）组成，以灯珠亮灭来显示文字、图片、动画、视频等，是各部分组件都模块化的显示器件，通常由显示模块、控制系统及电源系统组成。LED点阵显示屏制作简单，安装方便，被广泛应用于各种公共场合，如汽车报站器、广告屏以及公告牌等。 交叉处不直接连通，而是通过一个按键加以连接。这样，一个端口（如P1口）就可以构成4*4=16个按键， 键盘是合理的。
数码管显示4×4矩阵键盘的键盘号程序解释好了大作业.doc
《单片机原理及应用课程设计》报告 ——数码管显示4×4矩 阵键盘的键盘号 专业：电子信息科学与技术 班级： 姓名： 学号： 指导教师： 2012年5月15日
1、课程设计目的 1.1巩固和加深对单片机原理和接口技术知识的理解； 1.2培养根据课题需要选学参考书籍、查阅手册和文献资料的能力； 1.3学会方案论证的比较方法，拓宽知识，初步掌握工程设计的基本方法； 1.4掌握常用仪器、仪表的正确使用方法，学会软、硬件的设计和调试方法； 1.5能按课程设计的要求编写课程设计报告，能正确反映设计和实验成果，能用计算机绘制电路图和流程图。 2、课程设计要求 单片机的P1口的P1.0～P1.7连接4×4矩阵键盘，P0口控制一只数码管，当4×4矩阵键盘中的某一按键按下时，数码管上显示对应的键号。例如，1号键按下时，数码管显示“1”， 14号键按下时，数码管显示“E”等等。 3、硬件设计 3.1 设计思想 分析本任务的要求，在课程设计的基础上，添加要求，使设计能够完成当4×4矩阵键盘中的某一按键按下时，数码管上显示对应的键号。 3.2主要元器件介绍： AT89C51单片机 LED数码管 4X4矩阵键盘 3.3 功能电路介绍 AT89C51单片机：控制器。程序中将单片机的引脚置高电平低电平，单片机通过读取IO引脚的电平，在根据读取的数据去查找数组中相应的按键值，然后在送到数码管也就是P0口去显示.(51单片机通过IO口来读取键盘的电平，再通过程序来查找对应的数值，在送到数码管去显示) LED数码管 :输出设备 4X4矩阵键盘：输入设备
4、软件设计 4.1 设计思想 通过对矩阵键盘的逐行扫描，来获得所按下键的键盘号，最终通过数码管显示出来。 4.2软件流程图
扫描式矩阵键盘课程设计
扫描式矩阵键盘课程设 计 Company number【1089WT-1898YT-1W8CB-9UUT-92108】
4X4扫描式矩阵键盘课程设计课程设计名称: 4_4扫描式矩阵键盘设计 姓名： DUKE 班级：电子1008班 学号： 10086 成绩： 日期： 2014年1月6日 摘要 随着21世纪的到来，电子信息行业将是人类社会的高科技行业之一，式设施现代化的基础，也是人类通往科技巅峰的直通路。电子行业的发展从长远来看很重要，但最主要的还是科技问题。 矩阵式键盘提高效率进行按键操作管理有效方法，它可以提高系统准确性，有利于资源的节约，降低对操作者本身素质的要求。是它能准时、实时、高效地显示按键信息，以提高工作效率和资源利用率。 矩阵式键盘乃是当今使用最为广泛的键盘模式，该系统以N个端口连接控制N*N个按键，显示在LED数码管上。单片机控制依据这是键盘显示系统，该系统可以对不同的按键进行实时显示，其核心是单片机和键盘矩阵电路部分，主要对按键与显示电路的关系、矩阵式技术及设备系统的硬件、软件等各个部分进行实现。 4*4矩阵式键盘采用AT89C51单片机为核心，主要由矩阵式键盘电路、译码电路、显示电路等组成，软件选用C语言编程。单片机将检测到的按键信号
转换成数字量，显示于LED显示器上。该系统灵活性强，易于操作，可靠性高，将会有更广阔的开发前景。 目录 第一章：系统功能要求-------------------------------------------------------- 1.1 4*4 矩阵式键盘系统概述------------------------------------------------ 1.2 本设计任务和主要内容--------------------------------------------------- 第二章：方案论证--------------------------------------------------------------- 第三章：系统硬件电路的设计------------------------------------------------ 3.1 单片机控制系统原理----------------------------------------------------- 3.2 原理图绘制说明---------------------------------------------------------- 3.3 画出流程图---------------------------------------------------------------- 3.4 原理图绘制---------------------------------------------------------------
4X4矩阵式键盘输入程序
4*4键盘程序readkeyboard: begin: acall key_on jnz delay ajmp readkeyboard delay:acall delay10ms acall key_on jnz key_num ajmp begin key_num:acall key_p anl a,#0FFh jz begin acall key_ccode push a key_off:acall key_on jnz key_off pop a ret key_on: mov a,#00h orl a,#0fh mov p1,a mov a,p1 orl a,#0f0h cpl a ret key_p: mov r7,#0efh l_loop:mov a,r7 mov p1,a mov a,p1 orl a,#0f0h mov r6,a cpl a jz next ajmp key_c next: mov a,r7 jnb acc.7,error rl a mov r7,a ajmp l_loop error:mov a,#00h ret key_c:mov r2,#00h mov r3,#00h mov a,r6
mov r5,#04h again1:jnb acc.0,out1 rr a inc r2 djnz r5, again1 out1: inc r2 mov a,r7 mov r5,#04h again2:jnb acc.4,out2 rr a inc r3 djnz r5,again2 out2: inc r3 mov a, r2 swap a add a,r3 ret key_ccode:push a swap a anl a,#0fh dec a rl a ;行号乘4 rl a mov r7,a pop a anl a,#0fh dec a add a,r7 ret delay10ms: anl tmod,#0f0h orl tmod,#01h mov th0,#0d8h mov tl0,#0f0h setb tr0 wait:jbc tf0,over ajmp wait clr tr0 over:ret 单片机键盘设计 （二）从电路或软件的角度应解决的问题 软件消抖：如果按键较多，硬件消抖将无法胜任，常采用软件消抖。通常采用软件延时的方法：在第一次检测到有键按下时，执行一段延时10ms的子程序后，再确认电平是否仍保持闭合状态电平，如果保持闭合状态电平，则确认真正有键按下，进行相应处理工作，消除了抖动的影响。（这种消除抖动影响的软件措施是切实可行的。）
4X4扫描式矩阵键盘课程设计讲解
4x4矩阵键盘识别设计班级：1221201 专业：测控技术与仪器 姓名：涂勇 学号：2012 2012 0110 指导老师：钟念兵 东华理工大学 2016年1月1日
摘要 随着21世纪的到来，电子信息行业将是人类社会的高科技行业之一，电子式设施现代化的基础，也是人类通往科技巅峰的直通路。电子行业的发展从长远来看很重要，但最主要的还是科技问题。 矩阵式键盘提高效率进行按键操作管理有效方法，它可以提高系统准确性，有利于资源的节约，降低对操作者本身素质的要求。是它能准时、实时、高效地显示按键信息，以提高工作效率和资源利用率。 矩阵式键盘乃是当今使用最为广泛的键盘模式，该系统以N个端口连接控制N*N 个按键，显示在LED数码管上。单片机控制依据这是键盘显示系统，该系统可以对不同的按键进行实时显示，其核心是单片机和键盘矩阵电路部分，主要对按键与显示电路的关系、矩阵式技术及设备系统的硬件、软件等各个部分进行实现。 4*4矩阵式键盘采用STM32嵌入式微处理器为核心，主要由矩阵式键盘电路、硬件电路、显示电路等组成，软件选用C语言编程。STM32将检测到的按键信号转换成数字量，显示于LED显示器上。该系统灵活性强，易于操作，可靠性高，将会有更广阔的开发前景。
目录 第一章：系统功能要求--------------------------------------------------------4*4 矩阵式键盘系统概述------------------------------------------------ 本设计任务和主要内容--------------------------------------------------- 第二章：系统硬件电路的设计------------------------------------------------硬件系统主要思路和电路原理图- -------------------------------------- 硬件上键盘规划- --------------------------------------------------------- 第三章：系统程序的设计------------------------------------------------------程序的编写步骤----------------------------------------------------------- 编写的源程序-------------------------------------------------------------- 第四章：心得体会---------------------------------------------------------------
课程设计-制作单片机的4X4矩阵键盘
课程设计-制作单片机的4X4矩阵键盘
目录 摘要.............................................. 错误!未定义书签。第一章硬件部分 (5) 第一节AT89C51 (5) 第二节4*4矩阵式键盘 (8) 第三节LED数码管 (11) 第四节硬件电路连接 (13) 第二章软件部分 (15) 第一节所用软件简介 (15) 第二节程序流程图 (18) 第三节程序 (20) 第三章仿真结果 (23) 心得体会 (26) 参考文献 (27)
第一章硬件部分 第一节AT89C51 AT89C51是一种带4K字节FLASH存储器（FPEROM—Flash Programmable and Erasable Read Only Memory）的低电压、高性能CMOS 8位微处理器，俗称单片机。AT89C51单片机为很多嵌入式控制系统提供了一种灵活性高且价廉的方案。引脚如图所示 AT89C5 图1 AT89C51管脚 图 AT89C51其具有以下特性： 与MCS-51 兼容 4K字节可编程FLASH存储器 寿命：1000写/擦循环 数据保留时间：10年
全静态工作：0Hz-24MHz 三级程序存储器锁定 128×8位内部RAM 32可编程I/O线 两个16位定时器/计数器 5个中断源 可编程串行通道 低功耗的闲置和掉电模式 片内振荡器和时钟电路 特性概述: AT89C51 提供以下标准功能：4k 字节Flash 闪速存储器，128字节内部RAM，32 个I/O 接口，两个16位定时/计数器，一个5向量两级中断结构，一个全双工串行通信口，片内振荡器及时钟电路。同时，AT89C51可降至0Hz的静态逻辑操作，并支持两种软件可选的节电工作模式。空闲方式停止CPU的工作，但允许RAM，定时/计数器，串行通信口及中断系统继续工作。掉电方式保存RAM中的内容，但振荡器停止工作并禁止其它所有部件工作直到下一个硬件复位。 管脚说明： VCC：供电电压。 GND：接地。 P0口：P0口为一个8位漏级开路双向I/O口，每脚可吸收8TTL门电流。当P0口的管脚第一次写1时，被定义为高阻输入。P0能够用于外部程序数据存储器，它可以被定义为数据/地址的低八位。在FIASH编程时，P0 口作为原码输入口，当FIASH进行校验时，P0输出原码，此时P0外部必须接上拉电阻。 P1口：P1口是一个内部提供上拉电阻的8位双向I/O口，P1口缓冲器能接收输出4TTL门电流。P1口管脚写入1后，被内部上拉为高，可用作输入，P1口被外部下拉为低电平时，将输出电流，这是由于内部上拉的缘故。在FLASH编程和校验时，P1口作为低八位地址接收。
4X4矩阵键盘
题目名称:4×4矩阵式键盘 队员：伍星刘晓峰陈仁凤 摘要： 本系统采用AT89S52为控制核心。采用4X4键盘，通过8位数码管显示动态扫描0—F 16个数字。 关键词： AT89S52键盘数码管显示 Abstract: This system USES AT89S52 devices as control https://www.360docs.net/doc/43554262.html,ing 4X4 keyboard, through eight digital tube display dynamic scan 0-16 F. Keyword: AT89S52 Keyboard LED Display
目录 1 方案论证与比较 (3) 1.1采样方法方案论证 (3) 1.2处理器的选择方案论证................................................. 错误！未定义书签。 1.3周期性判别与测量方法方案论证................................. 错误！未定义书签。 2 系统设计 (3) 2.1总体设计 (3) 2.2单元电路设计 (5) 2.2.1 前级阻抗匹配和放大电路设计 (5) 2.2.2 AD转换及控制模块电路设计 (6) 2.2.3 功率谱测量单元电路设计 (6) 3 软件设计 (7) 4系统测试 (8) 5 结论 (9) 参考文献： (9) 附录： (9) 附1：元器件明细表： (9) 附2：仪器设备清单 (9) 附3：电路图图纸 (10) 附4：程序清单 (11)
1.方案论证与比较 1.1采样方法比较与选择 方案一：采用FPGA作为系统主控器。FPGA可实现各种复杂逻辑功能，规模大，集成度高，体积小，稳定性好，IO资源丰富、易于进行功能扩展，处理速度快，但适用于大规模实时性要求较高的系统，价格高，编程实现难度大。用液晶显示器进行键盘扫描，价格偏高，程序复杂，故不选择此方案 方案二: 采用Atmel公司的AT89S52单片机作为主控制器。AT89S52是一个低功耗、高性能8位单片机，片内含8 KB Flash片内程序存储器，256 Bytes RAM，32个外部双向输入/输出（I/O）口，5个中断优先级，2层中断嵌套中断等。价格便宜，使用方便，编程实现难度低，适合用来实现本系统的控制功能。 P0.0-P0.7端口作为数码管段选，P2.0-P2.7端口作为数码管位选，P3.0-P3.7作为键盘输入端口。8位LED数码管进行动态显示。 综上分析，本设计选择方案二。 2 系统设计 2.1 总体设计 16个键盘通过AT89S52进行动态扫描，在8位数码管可以动态显示0-F 16个数字。手动复位键可以达到清零的效果。
4乘4矩阵键盘总结
9
39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 // | // | // P X.0 ----------|------|-----|-----| // //************************************************************ // 扫描方法二： 06.8.15 添加 4X4矩阵键盘线翻转识别法函数 // 硬件连接 : // | | | | // / | / | / | / | // P X.7 -------/--|---/--|--/--|--/--| 每个按键对应的识别码是：0x77,0x7b,0x7d,0x7e // | | | | // / | / | / | / | // P X.6 -------/--|---/--|--/--|--/--| 0xb7,0xbb,0xbd,0xbe // | | | | // / | / | / | / | // P X.5 -------/--|---/--|--/--|--/--| 0xd7,0xdb,0xdd,0xde // | | | | // / | / | / | / | // P X.4 -------/--|---/--|--/--|--/--| 0xe7,0xeb,0xed,0xee // | | | | // | | | | // P X.3 ----------| | | | // | | | // | | | // P X.2 ----------|------| | | // | | // | | // P X.1 ----------|------|-----| | // | // | // P X.0 ----------|------|-----|-----| // //***************************************************************** // 扫描方法三： 06.8.16 添加 4X4矩阵键盘行扫描识别法函数（只返回4个识别码） // 硬件连接 : // | | | |
4x4矩阵键盘电路连接图和快速扫描完整程序
4*4矩阵键盘电路连接图和快速扫描完整程序 #include
P0=wei[x]; while(b--); LE1=0; } //////////////////////////////////////////////////////////////////// //4*4矩阵扫描，键值保存在key中 void key_4x4() { P1=temp; //初值uchar temp=0xfe; sm=P1; sm=sm&0xf0; //取P1口高四位的值，如果为0就表示无键按下if(sm!=0xf0) { switch(sm) { case 0x70:{key=0+4*beis;break;} case 0xb0:{key=1+4*beis;break;} case 0xd0:{key=2+4*beis;break;} case 0xe0:{key=3+4*beis;break;} default :{key=10+4*beis;break;} } } else { if(temp==0xf7) { temp=0xfe; } else { temp=_crol_(temp,1); } beis++; if(beis==4)beis=0; } } ////////////////////////////////////////////////////////////////////
4X4矩阵式键盘输入程序
4*4键盘程序 readkeyboard: begin: acall key_on jnz delay ajmp readkeyboard delay:acall delay10ms acall key_on jnz key_num ajmp begin key_num:acall key_p anl a,#0FFh jz begin acall key_ccode push a key_off:acall key_on jnz key_off pop a ret key_on: mov a,#00h orl a,#0fh mov p1,a mov a,p1 orl a,#0f0h cpl a ret key_p: mov r7,#0efh l_loop:mov a,r7 mov p1,a mov a,p1 orl a,#0f0h mov r6,a cpl a jz next ajmp key_c next: mov a,r7 jnb acc.7,error rl a mov r7,a ajmp l_loop error:mov a,#00h ret key_c:mov r2,#00h mov r3,#00h mov a,r6 mov r5,#04h again1:jnb acc.0,out1 rr a inc r2 djnz r5, again1 out1: inc r2 mov a,r7 mov r5,#04h again2:jnb acc.4,out2 rr a inc r3 djnz r5,again2 out2: inc r3 mov a, r2 swap a add a,r3 ret key_ccode:push a swap a anl a,#0fh dec a rl a ;行号乘 4 rl a mov r7,a pop a anl a,#0fh dec a add a,r7 ret delay10ms: anl tmod,#0f0h orl tmod,#01h mov th0,#0d8h mov tl0,#0f0h setb tr0 wait:jbc tf0,over ajmp wait clr tr0 over:ret 单片机键盘设计 （二）从电路或软件的角度应解决的问题 软件消抖：如果按键较多，硬件消抖将无法胜任，常采用软件消抖。通常采用软件延时的方法：在第一次检测到有键按下时，执行一段延时10ms的子程序后，再确认电平是否仍保持闭合状态电平，如果保持闭合状态电平，则确认真正有键按下，进行相应处理工作，消除了抖动的影响。（这种消除抖动影响的软件措施是切实可行的。） 2.采取串键保护措施。串键：是指同时有一个以上的键按下，串键会引起CPU错误响应。 通常采取的策略：单键按下有效，多键同时按下无效。 3.处理连击。连击：是一次按键产生多次击键的效果。要有对按键释放的处理，为了消除连击，使得一次按键只产生一次键功能的执行（不管一次按键持续的时间多长，仅采样一个数据）。否则的话，键功能程序的执行次数将是不可预知，由按键时间决定。连击是可以利用的。连击对于用计数法设计的多功能键特别有效。 三、键盘工作方式 单片及应用系统中，键盘扫描只是CPU的工作内容之一。CPU忙于各项任务时，如何兼顾键盘的输入，取决于键盘的工作方式。考虑仪表系统中CPU任务的份量，来确定键盘的工作方式。 键盘的工作方式选取的原则是：既要保证能及时响应按键的操作，又不过多的占用CPU的工作时间。 键盘的工作方式有：查询方式（编程扫描，定时扫描方式）、中断扫描方式。
MSP430单片机的4X4矩阵键盘C语言程序
MSP430单片机的4X4矩阵键盘C语言程序 #include #define uchar unsigned char#define uint unsigned int uchar table[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f}; void delay(unsigned int i) //延时子程序{while(i--);} uchar keyvalue(){ uchar key; uchar np10,np11,np12,np13; P1DIR=0x0f;//第一排P1OUT=~BIT3; delay(10); np10=P1IN&BIT4; if(np10==0) { key=0; } np11=P1IN&BIT5; if(np11==0) { key=1; } np12=P1IN&BIT6; if(np12==0) { key=2; } np13=P1IN&BIT7; if(np13==0) { key=3; } //第二行P1OUT=~BIT2; delay(10); np10=P1IN&BIT4; if(np10==0) { key=4; } np11=P1IN&BIT5; if(np11==0) { key=5; } np12=P1IN&BIT6; if(np12==0) { key=6; } np13=P1IN&BIT7; if(np13==0) { key=7; } //第三行P1OUT=~BIT1; delay(10); np10=P1IN&BIT4; if(np10==0) { key=8; } np11=P1IN&BIT5; if(np11==0) { key=9; } np12=P1IN&BIT6; if(np12==0) { key=10; } np13=P1IN&BIT7; if(np13==0) { key=11; } //第四行P1OUT=~BIT0; delay(10); np10=P1IN&BIT4; if(np10==0) { key=12; } np11=P1IN&BIT5; if(np11==0) { key=13; } np12=P1IN&BIT6; if(np12==0) { key=14; } np13=P1IN&BIT7; if(np13==0) { key=15; } P1OUT=0X00; return key; while(1) { if((P1IN&0X0F)==0x0f) break; }} void main(){ uchar key_value; WDTCTL=WDTPW+WDTHOLD; P1DIR=0X0F; P2DIR=0XFF; P2OUT=0XFF; while(1) { if((P1IN&0XF0)!=0XF0) { delay(100); if((P1IN&0XF0)!=0XF0) { delay(100); if((P1IN&0XF0)!=0XF0) { key_value=keyvalue(); } } } P2OUT=~key_value; }} tips:感谢大家的阅读，本文由我司收集整编。仅供参阅！