单片机基础

26课:矩阵式键盘接口技术及程序设计

在单片机系统中键盘中按钮数量较多时，为了减少I/O口的占用，常常将按钮排列成矩阵形式，如图1所示。在矩阵式键盘中，每条水平线和垂直线在交叉处不直接连通，而是通过一个按钮加以连接。这样，一个端口（如P1口）就能组成4*4=16个按钮，比之直接将端口线用于键盘多出了一倍，而且线数越多，区别越明显，比如再多加一条线就能组成20键的键盘，而直接用端口线则只能多出一键（9键）。由此可见，在需要的键数比较多时，采用矩阵法来做键盘是合理的。

<单片机矩阵式键盘接口技术及编程接口图>

矩阵式结构的键盘显然比直接法要复杂一些，识别也要复杂一些，上图中，列线通过电阻接正电源，并将行线所接的单片机的I/O口作为输出端，而列线所接的I/O口则作为输入。这样，当按钮没有按下时，所有的输出端都是高电平，代表无键按下。行线输出是低电平，一旦有键按下，则输入线就会被拉低，这样，通过读入输入线的状态就可得知是否有键按下了。具体的识别及编程办法如下所述。 矩阵式键盘的按钮识别办法

确定矩阵式键盘上何键被按下介绍一种“行扫描法”。

行扫描法 行扫描法又称为逐行（或列）扫描查询法，是一种最常用的按钮识别办法，如上图所示键盘，介绍过程如下。

判断键盘中有无键按下 将全部行线Y0-Y3置低电平，然后检测列线的状态。只要有一列的电平为低，则表示键盘中有键被按下，而且闭合的键位于低电平线与4根行线相交叉的4个按钮之中。若所有列线均为高电平，则键盘中无键按下。

判断闭合键所在的位置 在确认有键按下后，即可进入确定具体闭合键的过程。其办法是：依次将行线置为低电平，即在置某根行线为低电平时，其它线为高电平。在确定某根行线位置为低电平后，再逐行检测各列线的电平状态。若某列为低，则该列线与置为低电平的行线交叉处的按钮就是闭合的按钮。

下面给出一个具体的例程：

图仍如上所示。8031单片机的P1口用作键盘I/O口，键盘的列线接到P1口的低4位，键盘的行线接到P1口的高4位。列线P1.0-P1.3分别接有4个上拉电阻到正电源+5V，并把列线P1.0-P1.3设置为输入线，行线P1.4-P.17设置为输出线。4根行线和4根列线形成16个相交点。

检测当前是否有键被按下。检测的办法是P1.4-P1.7输出全“0”，读取P1.0-P1.3的状态，若P1.0-P1.3为全“1”，则无键闭合，不然有键闭合。

去除键抖动。当检测到有键按下后，延时一段时间再做下一步的检测判断。

若有键被按下，应识别出是哪一个键闭合。办法是对键盘的行线进行扫描。P1.4-P1.7按下述4种组合依次输出： P1.7 1 1 1 0 P1.6 1 1 0 1 P1.5 1 0 1 1 P1.4 0 1 1 1

在每组行输出时读取P1.0-P1.3，若全为“1”，则表示为“0”这一行没有键闭合，不然有键闭合。由此得到闭合键的行值和列值，然后可采用计算法或查表法将闭合键的行值和列值转换成所定义的键值

为了保证键每闭合一次CPU仅作一次处理，必须却除键释放时的抖动。

《单片机矩阵式键盘接口技术及编程》 键盘扫描程序：

从以上分析得到单片机键盘扫描程序的流程图如图2所示。程序如下 SCAN: MOV P1,#0FH MOV A,P1 ANL A,#0FH

CJNE A,#0FH,NEXT1 SJMP NEXT3

NEXT1: ACALL D20MS MOV A,#0EFH NEXT2: MOV R1,A MOV P1,A MOV A,P1 ANL A,#0FH

CJNE A,#0FH,KCODE; MOV A,R1 SETB C

RLC A JC NEXT2

NEXT3: MOV R0,#00H RET

KCODE: MOV B,#0FBH NEXT4: RRC A INC B JC NEXT4 MOV A,R1 SWAP A NEXT5: RRC A INC B INC B INC B INC B JC NEXT5 NEXT6: MOV A,P1 ANL A,#0FH

CJNE A,#0FH,NEXT6 MOV R0,#0FFH RET

键盘处理程序就作这么一个简单的介绍，实际上，键盘、显示处理是很复杂的，它一般占到一个应用程序的大部份代码，可见其重要性，但说到，这种复杂并不来自于单片机的本身，而是来自于操作者的习惯等等问题，因此，在编写键盘处理程序之前，最好先把它从逻辑上理清，然后用适当的算法表示出来，最后再去写代码，这样，才能快速有效地写好代码。到本课为止，本站教程暂告一个段落！请继续关注http://www.51hei.com的单片机教程。感谢大家的关心和支持！教程中如果有不对之处也希望大家在评论中提出，我们会及时正更错误的.

单片机教程二十五:单片机矩阵式键盘接口技术及程序设计

键盘是由若干按钮组成的开关矩阵，它是单片机系统中最常用的输入设备，用户能通过键盘向计算机输入指令、地址和数据。一般单片机系统中采和非编码键盘，非编码键盘是由软件来识别键盘上的闭合键，它

具有结构简单，使用灵活等特点，因此被广泛应用于单片机系统。

按钮开关的抖动问题

组成键盘的按钮有触点式和非触点式两种，单片机中应用的一般是由机械触点组成的。在下图中，当开

<键盘结构图>

图1

图2

关S未被按下时，P1。0输入为高电平，S闭合后，P1。0输入为低电平。由于按钮是机械触点，当机械触点断开、闭合时，会有抖动动，P1。0输入端的波形如图2所示。这种抖动对于人来说是感觉不到的，但对计算机来说，则是完全能感应到的，因为计算机处理的速度是在微秒级，而机械抖动的时间至少是毫秒级，对计算机而言，这已是一个“漫长”的时间了。前面我们讲到中断时曾有个问题，就是说按钮有时灵，有时不灵，其实就是这个原因，你只按了一次按钮，可是计算机却已执行了多次中断的过程，如果执行的

次数正好是奇数次，那么结果正如你所料，如果执行的次数是偶数次，那就不对了。

为使CPU能正确地读出P1口的状态，对每一次按钮只作一次响应，就必须考虑如何去除抖动，常用的去抖动的办法有两种：硬件办法和软件办法。单片机中常用软件法，因此，对于硬件办法我们不介绍。软件法其实很简单，就是在单片机获得P1。0口为低的信息后，不是立即认定S1已被按下，而是延时10毫秒或更长一些时间后再次检测P1。0口，如果仍为低，说明S1的确按下了，这实际上是避开了按钮按下时的抖动时间。而在检测到按钮释放后（P1。0为高）再延时5-10个毫秒，消除后沿的抖动，然后再对键值处理。不过一般情况下，我们常常不对按钮释放的后沿进行处理，实践证明，也能满足一定的要求。当然，实际应用中，对按钮的要求也是千差万别，要根据不一样的需要来编制处理程序，但以上是消除键

抖动的原则。 键盘与单片机的连接

<键盘连接>图3

<单片机与键盘接口图> 图4

1、通过1/0口连接。将每个按钮的一端接到单片机的I/O口，另一端接地，这是最简单的办法，如图3所示是实验板上按钮的接法，四个按钮分别接到P3.2 、P3.3、P3.4和P3.5。对于这种键各程序能采用持续查询的办法，功能就是：检测是否有键闭合，如有键闭合，则去除键抖动，判断键号并转入对应的键

处理。下面给出一个例程。其功能很简单，四个键定义如下：

P3.2：开始，按此键则灯开始流动（由上而下） P3.3：停止，按此键则停止流动，所有灯为暗

P3.4：上，按此键则灯由上向下流动 P3.5：下，按此键则灯由下向上流动 UpDown EQU 00H ;上下行标志 StartEnd EQU 01H ;起动及停止标志 LAMPCODE EQU 21H ;存放流动的数据代码

ORG 0000H AJMP MAIN ORG 30H

MAIN: MOV SP,#5FH MOV P1,#0FFH

CLR UpDown ;启动时处于向上的状态 CLR StartEnd ;启动时处于停止状态 MOV LAMPCODE,#0FEH ;单灯流动的代码

LOOP:

ACALL KEY ;调用键盘程序 JNB F0,LNEXT ;如果无键按下，则继续 ACALL KEYPROC ;不然调用键盘处理程序

LNEXT:

ACALL LAMP ;调用灯显示程序 AJMP LOOP ;反复循环，主程序到此结束

DELAY: MOV R7,#100 D1: MOV R6,#100

DJNZ R6,$ DJNZ R7,D1

RET

;----------------------------------------延时程序，键盘处理中调用

KEYPROC:

MOV A,B ;从B寄存器中获取键值

JB ACC.2,KeyStart ;分析键的代码，某位被按下，则该位为1（因为在键盘程序中已取反）

JB ACC.3,KeyOver

JB ACC.4,KeyUp JB ACC.5,KeyDown AJMP KEY_RET KeyStart:

SETB StartEnd ;第一个键按下后的处理

AJMP KEY_RET KeyOver:

CLR StartEnd ;第二个键按下后的处理

AJMP KEY_RET

KeyUp: SETB UpDown ;第三个键按下后的处理

AJMP KEY_RET KeyDown:

CLR UpDown ;第四个键按下后的处理

KEY_RET:RET

KEY:

CLR F0 ;清F0，表示无键按下。

ORL P3,#00111100B ;将P3口的接有键的四位置1

MOV A,P3 ;取P3的值

ORL A,#11000011B ;将其余4位置1

CPL A ;取反

JZ K_RET ;如果为0则一定无键按下 ACALL DELAY ;不然延时去键抖

ORL P3,#00111100B

MOV A,P3

ORL A,#11000011B

CPL A JZ K_RET

MOV B,A ;确实有键按下，将键值存入B中

SETB F0 ;设置有键按下的标志

K_RET:

ORL P3,#00111100B ;此处循环等待键的释放

MOV A,P3 ORL A,#11000011B

CPL A

JZ K_RET1 ;直到读取的数据取反后为0说明键释放了，才从键盘处理程序中返回

AJMP K_RET K_RET1: RET

D500MS: ;流水灯的延迟时间

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 ;如果StartEnd=1，则启动

MOV P1,#0FFH

AJMP LAMPRET ;不然关闭所有显示，返回

LampStart:

JB UpDown,LAMPUP ;如果UpDown=1，则向上流动

MOV A,LAMPCODE RL A ;实际就是左移位而已 MOV LAMPCODE,A

MOV P1,A LCALL D500MS AJMP LAMPRET

LAMPUP: MOV A,LAMPCODE RR A ;向下流动实际就是右移

MOV LAMPCODE,A

MOV P1,A LCALL D500MS LAMPRET:

RET END

以上程序功能很简单，但它演示了一个单片机键盘处理程序的基本思路，程序本身很简单，也不很实用，实际工作中还会有好多要考虑的因素，比如主循环每次都调用灯的循环程序，会造成按钮反应“迟钝”，而如果一直按着键不放，则灯不会再流动，一直要到松开手为止，等等，大家能仔细考虑一下这些问题，再

想想有什么好的解决办法。

2、采用中断方式：如图4所示。各个按钮都接到一个与非上，当有任何一个按钮按下时，都会使与门输出为低电平，从而引起单片机的中断，它的好处是不用在主程序中持续地循环查询，如果有键按下，单片

机再去做对应的处理。

/*我写的这个计算器可以算255范围以内的整数计算，本打算再加入小数与做最后的处理工作。可是又太费时间，所以就放那里了。看见了你的提问，也懒得改一改，你看看能不能用。*/

#include

unsigned char Line,Row,Val; void delay() {

unsigned char count;

for(count=0;count<255;count++) ; }

void delay1() {

unsigned char count,rt; for(count=0;count<40;count++) for(rt=0;rt<100;rt++) ; }

void InitialCPU(void) {

P0=0xFF; P1=0x0F; P2=0xFF; P3=0xFF; }

unsigned char leddata[]={0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90}; //\

unsigned char ledbai(unsigned char dat) {

unsigned char bai; bai=dat/100; if(bai==0) return 0x00; P2=0x20; P0=leddata[bai]; delay(); P2=0x00; return 0x00; }

unsigned char ledshi(unsigned char dat) {

unsigned char shi; shi=(dat0)/10; if(shi==0) return 0x00; P2=0x40; P0=leddata[shi]; delay(); P2=0x00; return 0x00; }

void ledge(unsigned char dat) {

unsigned char ge; ge=dat; P2=0x80; P0=leddata[ge]; delay(); }

unsigned char bin=1;

void ledplay(unsigned char dat) { //LED显示函数 if(bin==1){ ledbai(dat); bin++; }

else if(bin==2){ ledshi(dat); bin++; }

else if(bin==3){

ledge(dat); bin=1; } }

unsigned char futemp=0,data1=0,data2=0; void InitialTimer0(void) {

TMOD=0x01;

TH0=(65536-1000)/256; TR0=1; //启动T0 EA=1;

ET0=1; //允许T0中断 }

void Timer0(void) interrupt 1 using 3 {

TR0=0;

if(data1==0&&futemp==0&&data2==0){ //LED显示data1，即初始值 ledplay(data1); }

else if(data1!=0&&futemp==0&&data2==0) // data1有值了，显示data1， ledplay(data1);

else if(data1==0&&futemp!=0&&data2==0) //有两种可能，1、数据data1为零；2、直接data1没有给它值。总之显示data1

ledplay(data1);

else if(data1!=0&&futemp!=0&&data2==0) //输入的是符号，接着显示data1 ledplay(data1);

else if(data1!=0&&futemp!=0&&data2!=0) //显示的是data2 ledplay(data2); TH0=(65536-100)/256; TR0=1; }

void denghou() {

data2=0; futemp=0; }

unsigned char KeyTemp,CheckValue,Key1=0x00,Key2=0x00; void Dispose() {

unsigned char Val; if(Line==0x01) Line=0;

else if(Line==0x02) Line=1;

else if(Line==0x04) Line=2;

else if(Line==0x08) Line=3; if(Row==0x10) Row=0;

else if(Row==0x20) Row=1;

else if(Row==0x40) Row=2;

else if(Row==0x80) Row=3; Val=Line*4+Row; if(Val<10){ //存数

if(futemp==0){ //存在data1中 if(data1==0) data1=Val; else

data1=data1*10+Val; }

else{ //存在data2中 if(data2==0) data2=Val; else

data2=data2*10+Val; } }

else if(Val>9&&Val<16){ if(Val!=13&&Val!=12)

futemp=Val; //存符号并进行响应处理 else if(Val==12){ data1=0; data2=0; futemp=0; }

else if(Val==13){ if(futemp==10){ data1=data1*data2; denghou(); }

else if(futemp==11){ data1=data1/data2; denghou(); }

else if(futemp==14){ data1=data1-data2; denghou(); }

else if(futemp==15){ data1=data1+data2; denghou(); } else{ while(1){ P2=0xff; P0=0x00; } } } } else while(1){ P2=0xff; P0=0x00;

} //显示错误 }

unsigned char GetKey1(void) {

P1=0x0F;

CheckValue=P1^0x0F; if(CheckValue==0x00) return 0x00;

else if(CheckValue==0x01) Line=CheckValue; else if(CheckValue==0x02) Line=CheckValue; else if(CheckValue==0x04) Line=CheckValue; else if(CheckValue==0x08) Line=CheckValue; Key1=0x0F; return Key1;

}

unsigned char GetKey2(void) {

P1=0xF0;

CheckValue=P1^0xF0; if(CheckValue==0x00) return 0x00;

else if(CheckValue==0x10) Row=CheckValue; else if(CheckValue==0x20) Row=CheckValue; else if(CheckValue==0x40) Row=CheckValue; else if(CheckValue==0x80) Row=CheckValue; delay1();

KeyTemp = P1^0xF0; if(KeyTemp==CheckValue) return 0x00; Key2=0xF0; return Key2; }

void main() {

unsigned char Key1,Key2; InitialCPU(); InitialTimer0(); while(1) {

Key1=GetKey1(); Key2=GetKey2();

if(Key1!=0x00&&Key2!=0x00) {

Dispose(); P3=0x00; } } }

一、实验目的

1.掌握4×4矩阵式键盘程序识别原理 2.掌握4×4矩阵式键盘按键的设计方法

二、设计原理

（1）如图14.2所示，用单片机的并行口P3连接4×4矩阵键盘，并以单片机的P3.0－P3.3各管脚作输入以单片机的P3.4－P3.7各管脚作输出线，在数码管上显示每个按键 “0－F”的序号 （2）键盘中对应按键的序号排列如图14.1所示 三、参考电路

740)this.width=740\

border=undefined>

图14.2 4×4矩阵式键盘识别电路原理图

740)this.width=74

border=undefined>

图14.1 4×4键盘0-F显示

740)this.width=74

border=undefined>

图14.3 4×4矩阵式键盘识别程序流程图 四、电路硬件说明

（1）在“单片机系统”区域中，把单片机的P3.0－P3.7端口通过8联拨动拨码开关JP3连接到“4×4行列式键区域中的M1－M4，N1－N4端口上

（2）在“单片机系统”区域中，把单片机的P0.0－P0.7端口连接到“静态数码显示模块”区域中的任何一个a端口上；要求：P0.0对应着a，P0.1对应着b，……，P0.7对应着h

五、程序设计内容

（1）4×4矩阵键盘识别处理

（2）每个按键都有它的行值和列值，行值和列值的组合就是识别这个按键的编码矩阵的行线和列线分别过两并行接口和CPU通信键盘的一端（列线）通过电阻接VCC，而接地是通过程序输出数字“0”实现的键盘理程序的任务是：确定有无键按下，判断哪一个键按下，键的功能是什么？还要消除按键在闭合或断开时的抖动两个并行口中，一个输出扫描码，使按键逐行动态接地；另一个并行口输入按键状态，由行扫描值和回馈信号共形成键编码而识别按键，通过软件查表，查出该键的功能 六、程序流程图(如图14.3所示) 七、汇编源程序 ;;;;;;;;;;定义单元;;;;;;;;;; COUNT EQU 30H ;;;;;;;;;;入口地址;;;;;;;;;; ORG 0000H LJMP START ORG 0003H RETI

ORG 000BH RETI

ORG 0013H RETI

ORG 001BH RETI

ORG 0023H RETI

ORG 002BH RETI

;;;;;;;;;;主程序入口;;;;;;;;;; ORG 0100H

START: LCALL CHUSHIHUA

LCALL PANDUAN LCALL XIANSHI LJMP START

;;;;;;;;;;初始化程序;;;;;;;;;;

CHUSHIHUA: MOV COUNT#00H RET

;;;;;;;;;;判断哪个按键按下程序;;;;;;;;;; PANDUAN: MOV P3#0FFH CLR P3.4 MOV AP3 ANL A#0FH XRL A#0FH JZ SW1

LCALL DELAY10MS JZ SW1 MOV AP3 ANL A#0FH

CJNE A#0EHK1 MOV COUNT#0 LJMP DK

K1: CJNE A#0DHK2 MOV COUNT#4 LJMP DK

K2: CJNE A#0BHK3 MOV COUNT#8 LJMP DK

K3: CJNE A#07HK4 MOV COUNT#12 K4: NOP LJMP DK

SW1: MOV P3#0FFH CLR P3.5 MOV AP3 ANL A#0FH XRL A#0FH JZ SW2

LCALL DELAY10MS JZ SW2 MOV AP3 ANL A#0FH

CJNE A#0EHK5 MOV COUNT#1 LJMP DK

K5: CJNE A#0DHK6

MOV COUNT#5 LJMP DK

K6: CJNE A#0BHK7 MOV COUNT#9 LJMP DK

K7: CJNE A#07HK8 MOV COUNT#13 K8: NOP LJMP DK

SW2: MOV P3#0FFH CLR P3.6 MOV AP3 ANL A#0FH XRL A#0FH JZ SW3

LCALL DELAY10MS JZ SW3 MOV AP3 ANL A#0FH

CJNE A#0EHK9 MOV COUNT#2 LJMP DK

K9: CJNE A#0DHKA MOV COUNT#6 LJMP DK

KA: CJNE A#0BHKB MOV COUNT#10 LJMP DK

KB: CJNE A#07HKC MOV COUNT#14 KC: NOP LJMP DK

SW3: MOV P3#0FFH CLR P3.7 MOV AP3 ANL A#0FH XRL A#0FH JZ SW4

LCALL DELAY10MS JZ SW4 MOV AP3 ANL A#0FH

CJNE A#0EHKD MOV COUNT#3

LJMP DK

KD: CJNE A#0DHKE MOV COUNT#7 LJMP DK

KE: CJNE A#0BHKF MOV COUNT#11 LJMP DK

KF: CJNE A#07HKG MOV COUNT#15 KG: NOP LJMP DK

SW4: LJMP PANDUAN

DK: RET

;;;;;;;;;;显示程序;;;;;;;;;;

XIANSHI: MOV ACOUNT MOV DPTR#TABLE MOVC A@A+DPTR MOV P0A LCALL DELAY SK: MOV AP3 ANL A#0FH XRL A#0FH JNZ SK RET

;;;;;;;;;;10ms延时程序;;;;;;;;;; DELAY10MS: MOV R6#20 D1: MOV R7#248 DJNZ R7$ DJNZ R6D1 RET

;;;;;;;;;;200ms延时程序;;;;;;;;;; DELAY: MOV R5#20

LOOP: LCALL DELAY10MS DJNZ R5LOOP RET

;;;;;;;;;;共阴码表;;;;;;;;;;

TABLE: DB 3FH06H5BH4FH66H6DH7DH07H DB 7FH6FH77H7CH39H5EH79H71H ;;;;;;;;;;结束标志;;;;;;;;;; END

八、C语言源程序

#include

unsigned char code table[]={0x3f0x660x7f0x39

0x060x6d0x6f0x5e 0x5b0x7d0x770x79 0x4f0x070x7c0x71}; void main(void)

{ unsigned char ijkkey; while(1)

{ P3=0xff; //给P3口置1//

P3_4=0; //给P3.4这条线送入0// i=P3;

i=i&0x0f; //屏蔽低四位//

if(i!=0x0f) //看是否有按键按下// { for(j=50;j>0;j--) //延时// for(k=200;k>0;k--);

if(i!=0x0f) //再次判断按键是否按下//

{ switch(i) //看是和P3.4相连的四个按键中的哪个// { case 0x0e: key=0; break;

case 0x0d: key=1; break;

case 0x0b: key=2; break;

case 0x07: key=3; break; }

P0=table[key]; //送数到P0口显示// } }

P3=0xff;

P3_5=0; //读P3.5这条线// i=P3;

i=i&0x0f; //屏蔽P3口的低四位//

if(i!=0x0f) //读P3.5这条线上看是否有按键按下// { for(j=50;j>0;j--) //延时// for(k=200;k>0;k--);

i=P3; //再看是否有按键真的按下// i=i&0x0f; if(i!=0x0f)

{ switch(i) //如果有显示相应的按键// { case 0x0e: key=4;

break;

case 0x0d: key=5; break;

case 0x0b: key=6; break;

case 0x07: key=7; break; }

P0=table[key]; //送入P0口显示// } }

P3=0xff;

P3_6=0; //读P3.6这条线上是否有按键按下// i=P3; i=i&0x0f; if(i!=0x0f)

{ for(j=50;j>0;j--) for(k=200;k>0;k--); i=P3; i=i&0x0f; if(i!=0x0f) { switch(i) { case 0x0e: key=8; break;

case 0x0d: key=9; break;

case 0x0b: key=10; break;

case 0x07: key=11; break; }

P0=table[key]; } }

P3=0xff;

P3_7=0; //读P3.7这条线上是否有按键按下// i=P3;

i=i&0x0f; if(i!=0x0f)

{ for(j=50;j>0;j--) for(k=200;k>0;k--); i=P3; i=i&0x0f; if(i!=0x0f) { switch(i) { case 0x0e: key=12; break;

case 0x0d: key=13; break;

case 0x0b: key=14; break;

case 0x07: key=15; break; }

P0=table[key]; } } } }

九、注意事项

在硬件电路中，要把8联拨动拨码开关JP2拨下，把8联拨动拨码开关JP3拨上去

C51矩阵键盘

在一个4乘4的矩阵键盘中，本人的基本识别程序。。。(P1口低四位对应键盘行线，高四位对应键盘列线，P2口为6个动态LED数码管）

＃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(); } }

用的是单片机的P1口, 显示是用的串口调试的. #include #define uint unsigned int #define uchar unsigned char

#define duank P1 //键盘到单片机的端口

//DB 50H,1CH,39H,16H,38H,78H,70H,0FEH,0EFH,0FFH;A B, C, D, E, ,F ,P, -, ,. ,COLSE //DB 01H,0C7H,22H,82H,0C4H,88H,08H,0C3H,00H,80H;带小数点的字形码0.,1.,-----9.

uchar code table[]={ //键盘编码\

0xD7,0x32,0x92,0xD4, 0x98,0x18,0xD1,0x10, 0x90,0x50,0x1C,0x39, 0x16,0x38,0x78,0x11}; uchar num,temp,num1;

void delay(uint z) //延时子程序 Zms

{ uint x,y; for(x=z;x>0;x--) for(y=110;y>0;y--);

}

uchar keyscan(); //键盘函数声明 void display(uchar aa);//显示函数声明

void main() //主函数

{ while(1) {

display(keyscan());

} }

void display(uchar aa) //显示子程序

{ //dula=1; //P0=table[aa-1];

//dula=0;

SBUF=\

}

uchar keyscan() //键盘扫描程序,取回一个键盘号

{

duank=\ temp=\ temp=\ while(temp!=0xf0)

{ delay(5); temp=\ temp=\ while(temp!=0xf0)

{

temp=\ switch(temp)

{

case 0xee:num=1;

break;

case 0xde:num=2;

break; case 0xbe:num=3;

break; case 0x7e:num=4;

break; }

while(temp!=0xf0)

{

temp=\ temp=\

} } } duank=\ temp=\ temp=\ while(temp!=0xf0)

{ delay(5); temp=\ temp=\ while(temp!=0xf0)

{

temp=\ switch(temp)

{

case 0xed:num=5;

break; case 0xdd:num=6;

break; case 0xbd:num=7;

break; case 0x7d:num=8;

break; }

while(temp!=0xf0)

{

temp=\ temp=\

} } } duank=\ temp=\ temp=\ while(temp!=0xf0)

{ delay(5); temp=\ temp=\ while(temp!=0xf0)

{

temp=\ switch(temp)

{

case 0xeb:num=9;

break; case 0xdb:num=10;

break;

case 0xbb:num=11;

break; case 0x7b:num=12;

break; }

while(temp!=0xf0)

{

temp=\ temp=\

} } } duank=\ temp=\ temp=\ while(temp!=0xf0)

{ delay(5); temp=\ temp=\ while(temp!=0xf0)

{

temp=\ switch(temp)

{

case 0xe7:num=13;

break; case 0xd7:num=14;

break; case 0xb7:num=15;

break; case 0x77:num=16;

break; }

while(temp!=0xf0)

{

temp=\ temp=\

} } } return num;

}

刚学C语言,今儿整理了他的一个键盘程序,用了还行,单片机能够正常工作. 用的是单片机的P1口, 显示是用的串口调试的.

#include #define uint unsigned int #define uchar unsigned char

#define duank P1 //键盘到单片机的端口

//DB 50H,1CH,39H,16H,38H,78H,70H,0FEH,0EFH,0FFH;A B, C, D, E, ,F ,P, -, ,. ,COLSE

//DB 01H,0C7H,22H,82H,0C4H,88H,08H,0C3H,00H,80H;带小数点的字形码0.,1.,-----9.

uchar code table[]={ //键盘编码\0xD7,0x32,0x92,0xD4, 0x98,0x18,0xD1,0x10, 0x90,0x50,0x1C,0x39, 0x16,0x38,0x78,0x11}; uchar num,temp,num1;

void delay(uint z) //延时子程序 Zms

{

uint x,y;

for(x=z;x>0;x--)

for(y=110;y>0;y--); }

uchar keyscan(); //键盘函数声明 void display(uchar aa);//显示函数声明 void main() //主函数 {

while(1) {

display(keyscan()); } }

void display(uchar aa) //显示子程序 {

//dula=1;

//P0=table[aa-1]; //dula=0;

SBUF=\}

uchar keyscan() //键盘扫描程序,取回一个键盘号 {

duank=\ temp=\

temp=\ while(temp!=0xf0) {

delay(5);

temp=\

temp=\ while(temp!=0xf0) {

temp=\ switch(temp) {

case 0xee:num=1;

break;

case 0xde:num=2; break;

case 0xbe:num=3; break;

case 0x7e:num=4; break; }

while(temp!=0xf0) {

temp=\

temp=\ } } }

duank=\ temp=\

temp=\ while(temp!=0xf0) {

delay(5);

temp=\

temp=\ while(temp!=0xf0) {

temp=\ switch(temp) {

case 0xed:num=5; break;

case 0xdd:num=6; break;

case 0xbd:num=7; break;

case 0x7d:num=8; break; }

while(temp!=0xf0)

{

temp=\

temp=\ } } }

duank=\ temp=\

temp=\ while(temp!=0xf0) {

delay(5);

temp=\

temp=\ while(temp!=0xf0) {

temp=\ switch(temp) {

case 0xeb:num=9; break;

case 0xdb:num=10; break;

case 0xbb:num=11; break;

case 0x7b:num=12; break; }

while(temp!=0xf0) {

temp=\

temp=\ } } }

duank=\

temp=\ temp=\ while(temp!=0xf0) {

delay(5);

temp=\

temp=\ while(temp!=0xf0) {

temp=\ switch(temp) {

case 0xe7:num=13; break;

case 0xd7:num=14; break;

case 0xb7:num=15; break;

case 0x77:num=16; break;

}

while(temp!=0xf0) {

temp=\

temp=\ } } }

return num; }

temp=\ temp=\ while(temp!=0xf0) {

delay(5);

temp=\

temp=\ while(temp!=0xf0) {

temp=\ switch(temp) {

case 0xe7:num=13; break;

case 0xd7:num=14; break;

case 0xb7:num=15; break;

case 0x77:num=16; break;

}

while(temp!=0xf0) {

temp=\

temp=\ } } }

return num; }

本文来源：https://www.bwwdw.com/article/bpe3.html