8.4按键
8.4.1独立按键
常用的按键电路有两种形式： 独立式按键和矩阵式按键。独立式按键比较简单，它们各自与独立的输入线相连接，如图8-6所示。   
1.png    图 8-6  独立式按键原理图

4条输入线接到单片机的IO口上，当按键K1按下时，+5V通过电阻R1然后再通过按键K1最终进入GND形成一条通路，这条线路的全部电压都加到了R1这个电阻上，KeyIn1这个引脚就是个低电平。当松开按键后，线路断开，就不会有电流通过，KeyIn1和+5V就应该是等电位，是一个高电平。我们就可以通过KeyIn1这个IO口的高低电平来判断是否有按键按下。

这个电路中按键的原理讲清楚了，但是实际上在单片机IO口内部，也有一个上拉电阻的存在。按键是接到了P2口上，P2口上电默认是准双向IO口，下面来简单了解一下准双向IO口的电路，如图8-7所示。
2.png 图 8-7  准双向 IO 口结构图

首先说明一点，就是现在绝大多数单片机的IO口都是使用MOS管而非三极管，但用在这里的MOS管其原理和三极管是一样的，因此用三极管替代它来进行原理讲解，把前面讲过的三极管的知识搬过来，一切都是适用的，有助于理解。

图8-7方框内的电路都是指单片机内部部分，方框外的就是外接的上拉电阻和按键。这个地方大家要注意一下，就是当要读取外部按键信号的时候，单片机必须先给该引脚写“1”，也就是高电平，这样才能正确读取到外部按键信号，下面来分析一下缘由。

当内部输出是高电平，经过一个反向器变成低电平，NPN三极管不会导通，单片机IO口从内部来看，由于上拉电阻R的存在，所以是一个高电平。当外部没有按键按下将电平拉低的话，VCC也是+5V，它们之间虽然有两个电阻，但是没有压差，就不会有电流，线上所有的位置都是高电平，这个时候就可以正常读取到按键的状态了。

当内部输出是个低电平，经过一个反相器变成高电平，NPN三极管导通，单片机的内部IO口就是个低电平，这个时候，外部虽然也有上拉电阻的存在，但是两个电阻是并联关系，不管按键是否按下，单片机的IO口上输入到单片机内部的状态都是低电平，就无法正常读取到按键的状态了。

这与水流其实很类似的，内部和外部，只要有一边是低电位，电流就会顺流而下，由于只有上拉电阻，下边没有电阻分压，直接到GND上了，所以不管另外一边是高还是低，那电平肯定就是低电平了。

从上面的分析可以得出一个结论，这种具有上拉的准双向IO口，如果要正常读取外部信号的状态，必须首先得保证自己内部输出的是1，如果内部输出0，则无论外部信号是1还是0，这个引脚读进来的都是0。

8.4.2矩阵按键

在某一个系统设计中，如果需要使用很多的按键时，做成独立按键会大量占用IO口，因此引入了矩阵按键的设计。如图8-8所示是KST-51开发板上的矩阵按键电路原理图，使用8个IO口来实现了16个按键。
3.png 图 8-8  矩阵按键原理图

如果独立按键理解了，矩阵按键也不难理解，下面一起来分析一下。图8-8中，一共有4组按键，我们只看其中一组，如图8-9所示。大家认真看一下，如果KeyOut1输出一个低电平，KeyOut1就相当于是GND，是否相当于4个独立按键呢。当然这时候KeyOut2、KeyOut3、KeyOut4都必须输出高电平，它们都输出高电平才能保证与它们相连的3路按键不会对这一路产生干扰，大家可以对照两张原理图分析一下。
4.png 图 8-9  矩阵按键变独立按键示意图

8.4.3独立按键的扫描

原理搞清楚了，那么下面就先编写一个独立按键的程序，把最基本的功能验证一下。
  1.     #include <reg52.h>
  2.     sbit ADDR0 = P1^0;
  3.     sbit ADDR1 = P1^1;
  4.     sbit ADDR2 = P1^2;
  5.     sbit ADDR3 = P1^3;
  6.     sbit ENLED = P1^4;
  7.     sbit LED9 = P0^7;
  8.     sbit LED8 = P0^6;
  9.     sbit LED7 = P0^5;
  10.     sbit LED6 = P0^4;
  11.     sbit KEY1 = P2^4;
  12.     sbit KEY2 = P2^5;
  13.     sbit KEY3 = P2^6;
  14.     sbit KEY4 = P2^7;
  15.     void main(){
  16.         ENLED = 0;  //选择独立 LED 进行显示
  17.         ADDR3 = 1;
  18.         ADDR2 = 1;
  19.         ADDR1 = 1;
  20.         ADDR0 = 0;
  21.         P2 = 0xF7;  //P2.3 置 0，即 KeyOut1 输出低电平
  22.       
  23.         while (1){
  24.             //将按键扫描引脚的值传递到 LED 上
  25.             LED9 = KEY1;  //按下时为 0，对应的 LED 点亮
  26.             LED8 = KEY2;
  27.             LED7 = KEY3;
  28.             LED6 = KEY4;
  29.         }
  30.     }
本程序固定在KeyOut1上输出低电平，而KeyOut2~KeyOut4保持高电平，就相当于是把矩阵按键的第一行，即K1~K4作为4个独立按键来处理，然后把这4个按键的状态直接送给LED9~LED6这4个LED小灯，那么当按键按下时，对应按键的输入引脚是0，对应小灯控制信号也是0，于是灯就亮了，这说明上述关于按键检测的理论都是可实现的。
绝大多数情况下，按键是不会一直按住的，所以通常检测按键的动作并不是检测一个固定的电平值，而是检测电平值的变化，即按键在按下和弹起这两种状态之间的变化，只要发生了这种变化就说明现在按键产生动作了。

程序上，可以把每次扫描到的按键状态都保存起来，当一次按键状态扫描进来的时候，与前一次的状态做比较，如果发现这两次按键状态不一致，就说明按键产生动作了。当上一次的状态是未按下而现在是按下，此时按键的动作就是“按下”； 当上一次的状态是按下而现在是未按下，此时按键的动作就是“弹起”。显然，每次按键动作都会包含一次“按下”和一次“弹起”，可以任选其一来执行程序，或者两个都用，以执行不同的程序也是可以的。下面就用程序来实现这个功能，程序只取按键K4为例。
  1.     #include <reg52.h>
  2.     sbit ADDR0 = P1^0;
  3.     sbit ADDR1 = P1^1;
  4.     sbit ADDR2 = P1^2;
  5.     sbit ADDR3 = P1^3;
  6.     sbit ENLED = P1^4;
  7.     sbit KEY1 = P2^4;
  8.     sbit KEY2 = P2^5;
  9.     sbit KEY3 = P2^6;
  10.     sbit KEY4 = P2^7;
  11.     unsigned char code LedChar[] = {  //数码管显示字符转换表
  12.         0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
  13.         0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
  14.     };
  15.     void main(){
  16.         bit backup = 1;  //定义一个位变量，保存前一次扫描的按键值
  17.         unsigned char cnt = 0;  //定义一个计数变量，记录按键按下的次数
  18.         ENLED = 0;  //选择数码管 DS1 进行显示
  19.         ADDR3 = 1;
  20.         ADDR2 = 0;
  21.         ADDR1 = 0;
  22.         ADDR0 = 0;
  23.         P2 = 0xF7;  //P2.3 置 0，即 KeyOut1 输出低电平
  24.         P0 = LedChar[cnt];  //显示按键次数初值
  25.         while (1){
  26.             //当前值与前次值不相等说明此时按键有动作
  27.             if (KEY4 != backup){
  28.                 //如果前次值为 0，则说明当前是由 0 变 1，即按键弹起
  29.                 if (backup == 0){
  30.                     cnt++;  //按键次数+1
  31.                     //只用 1 个数码管显示，所以加到 10 就清零重新开始
  32.                     if (cnt >= 10){
  33.                        cnt = 0;
  34.                     }
  35.                     P0 = LedChar[cnt]; //计数值显示到数码管上
  36.                 }
  37.                 backup = KEY4;  //更新备份为当前值，以备进行下次比较
  38.             }
  39.         }
  40.     }
先来介绍出现在程序中的一个新知识点，就是变量类型——bit，这个在标准C语言里边是没有的。51单片机有一种特殊的变量类型就是bit型。比如unsigned char型是定义了一个无符号的8位的数据，它占用一个字节(Byte)的内存，而bit型是1位数据，只占用1个位(bit)的内存，用法和标准C中其他的基本数据类型是一致的。它的优点就是节省内存空间，8个bit型变量才相当于1个char型变量所占用的空间。虽然它只有0和1两个值，但也已经可以表示很多东西了，比如，按键的按下和弹起、LED灯的亮和灭、三极管的导通与关断等，联想一下已经学过的内容，它是不是能用最小的内存代价来完成很多工作呢？

在这个程序中，以K4为例，按一次按键，就会产生“按下”和“弹起”两个动态的动作，选择在“弹起”时对数码管进行加1操作。理论是如此，大家可以在开发板上用K4按键做做实验试试，多按几次，是不是会发生这样一种现象： 有的时候明明只按了一下按键，但数字却加了不止1，而是2或者更多？但是程序并没有任何逻辑上的错误，这是怎么回事呢？于是就得来说说按键抖动和消抖的问题了。

8.4.4按键消抖

通常按键所用的开关都是机械弹性开关，当机械触点断开、闭合时，由于机械触点的弹性作用，一个按键开关在闭合时不会马上就稳定接通，在断开时也不会一下子彻底断开，而是在闭合和断开的瞬间伴随了一连串的抖动，如图8-10所示。
5.png 图 8-10  按键抖动状态图

按键稳定闭合时间长短是由操作人员决定的，通常都会在100ms以上，刻意快速按的话能达到40~50ms左右，很难再低了。抖动时间是由按键的机械特性决定的，一般都会在10ms以内，为了确保程序对按键的一次闭合或者一次断开只响应一次，必须进行按键的消抖处理。当检测到按键状态变化时，不是立即去响应动作，而是先等待闭合或断开稳定后再进行处理。按键消抖可分为硬件消抖和软件消抖。

硬件消抖就是在按键上并联一个电容，如图8-11所示，利用电容的充放电特性来对抖动过程中产生的电压毛刺进行平滑处理，从而实现消抖。但实际应用中，这种方式的效果往往不是很好，而且还增加了成本和电路复杂度，所以实际中使用的并不多。
6.png 图 8-11  硬件电容消抖

在绝大多数情况下是用软件即程序来实现消抖的。最简单的消抖原理，就是当检测到按键状态变化后，先等待一个10ms左右的延时时间，让抖动消失后再进行一次按键状态检测，如果与刚才检测到的状态相同，就可以确认按键已经稳定动作了。将上一个的程序稍加改动，得到新的带消抖功能的程序如下。
  1.     #include <reg52.h>
  2.     sbit ADDR0 = P1^0;
  3.     sbit ADDR1 = P1^1;
  4.     sbit ADDR2 = P1^2;
  5.     sbit ADDR3 = P1^3;
  6.     sbit ENLED = P1^4;
  7.     sbit KEY1 = P2^4;
  8.     sbit KEY2 = P2^5;
  9.     sbit KEY3 = P2^6;
  10.     sbit KEY4 = P2^7;
  11.     unsigned char code LedChar[] = { //数码管显示字符转换表
  12.         0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
  13.         0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
  14.     };
  15.     void delay();
  16.     void main(){
  17.         bit keybuf = 1; //按键值暂存，临时保存按键的扫描值
  18.         bit backup = 1; //按键值备份，保存前一次的扫描值
  19.         unsigned char cnt = 0; //按键计数，记录按键按下的次数
  20.       
  21.         ENLED = 0;  //选择数码管 DS1 进行显示
  22.         ADDR3 = 1;
  23.         ADDR2 = 0;
  24.         ADDR1 = 0;
  25.         ADDR0 = 0;
  26.         P2 = 0xF7;  //P2.3 置 0，即 KeyOut1 输出低电平
  27.         P0 = LedChar[cnt];  //显示按键次数初值
  28.         while (1){
  29.             keybuf = KEY4;  //把当前扫描值暂存
  30.             if (keybuf != backup){  //当前值与前次值不相等说明此时按键有动作
  31.                 delay();  //延时大约 10ms
  32.                 if (keybuf == KEY4){  //判断扫描值有没有发生改变，即按键抖动
  33.                     if (backup == 0){  //如果前次值为 0，则说明当前是弹起动作
  34.                         cnt++;  //按键次数+1
  35.                         //只用 1 个数码管显示，所以加到 10 就清零重新开始
  36.                         if (cnt >= 10){
  37.                            cnt = 0;
  38.                         }
  39.                         P0 = LedChar[cnt]; //计数值显示到数码管上
  40.                     }
  41.                     backup = keybuf; //更新备份为当前值，以备进行下次比较
  42.                 }
  43.             }
  44.         }
  45.     }
  46.     /* 软件延时函数，延时约 10ms */
  47.     void delay(){
  48.         unsigned int i = 1000;
  49.         while (i--);
  50.     }
大家把这个程序下载到板子上再进行试验试试，按一下按键而数字加了多次的问题是不是就这样解决了？把问题解决掉的感觉是不是很爽呢？

这个程序用了一个简单的算法实现了按键的消抖。作为这种很简单的演示程序，可以这样来写，但是实际做项目开发的时候，程序量往往很大，各种状态值也很多，while(1)主循环要不停地扫描各种状态值是否有发生变化，及时地进行任务调度，如果程序中间加了这种delay延时操作后，很可能某一事件发生了，但是程序还在进行delay延时操作中，当这个事件发生完了，程序还在delay操作中，当delay完事再去检查的时候，已经晚了，已经检测不到那个事件了。为了避免这种情况的发生，要尽量缩短while(1)循环一次所用的时间，而需要进行长时间延时的操作，必须想其他的办法来处理。

那么消抖操作所需要的延时该怎么处理呢？其实除了这种简单的延时，还有更优异的方法来处理按键抖动问题。举个例子： 如果启用一个定时中断，每2ms进一次中断，扫描一次按键状态并且存储起来，连续扫描8次后，看看这连续8次的按键状态是否一致。8次按键的时间大概是16ms，这16ms内如果按键状态一直保持一致，那就可以确定现在按键处于稳定的阶段，而非处于抖动的阶段，如图8-12所示。
7.png 图 8-12  按键连续扫描判断

假如左边时间是起始0时刻，每经过2ms左移一次，每移动一次，判断当前连续的8次按键状态是不是全1或者全0，如果是全1则判定为弹起，如果是全0则判定为按下，如果0和1交错，就认为是抖动，不做任何判定。想一下，这样是不是比简单的延时更加可靠？

利用这种方法，就可以避免通过延时消抖占用单片机执行时间，而是转化成了一种按键状态判定而非按键过程判定，我们只对当前按键的连续16ms的8次状态进行判断，而不再关心它在这16ms内都做了什么事情，下面就按照这种思路用程序实现出来，同样只以K4为例。
  1.     #include <reg52.h>
  2.     sbit ADDR0 = P1^0;
  3.     sbit ADDR1 = P1^1;
  4.     sbit ADDR2 = P1^2;
  5.     sbit ADDR3 = P1^3;
  6.     sbit ENLED = P1^4;
  7.     sbit KEY1 = P2^4;
  8.     sbit KEY2 = P2^5;
  9.     sbit KEY3 = P2^6;
  10.     sbit KEY4 = P2^7;
  11.     unsigned char code LedChar[] = {  //数码管显示字符转换表
  12.         0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
  13.         0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
  14.     };
  15.     bit KeySta = 1;  //当前按键状态
  16.     void main(){
  17.         bit backup = 1;  //按键值备份，保存前一次的扫描值
  18.         unsigned char cnt = 0;  //按键计数，记录按键按下的次数
  19.         EA = 1;  //使能总中断
  20.         ENLED = 0;  //选择数码管 DS1 进行显示
  21.         ADDR3 = 1;
  22.         ADDR2 = 0;
  23.         ADDR1 = 0;
  24.         ADDR0 = 0;
  25.         TMOD = 0x01; //设置 T0 为模式 1
  26.         TH0 = 0xF8; //为 T0 赋初值 0xF8CD，定时 2ms
  27.         TL0 = 0xCD;
  28.         ET0 = 1;  //使能 T0 中断
  29.         TR0 = 1;  //启动 T0
  30.         P2 = 0xF7;  //P2.3 置 0，即 KeyOut1 输出低电平
  31.         P0 = LedChar[cnt];  //显示按键次数初值
  32.       
  33.         while (1){
  34.             if (KeySta != backup){  //当前值与前次值不相等说明此时按键有动作
  35.                 if (backup == 0){  //如果前次值为 0，则说明当前是弹起动作
  36.                     cnt++;  //按键次数+1
  37.                     if (cnt >= 10){  //只用 1 个数码管显示，所以加到 10 就清零重新开始
  38.                         cnt = 0;
  39.                     }
  40.                     P0 = LedChar[cnt]; //计数值显示到数码管上
  41.                 }
  42.                 //更新备份为当前值，以备进行下次比较
  43.                 backup = KeySta;
  44.             }
  45.         }
  46.     }
  47.     /* T0 中断服务函数，用于按键状态的扫描并消抖 */
  48.     void InterruptTimer0() interrupt 1{
  49.         //扫描缓冲区，保存一段时间内的扫描值
  50.         static unsigned char keybuf = 0xFF;
  51.       
  52.         TH0 = 0xF8; //重新加载初值
  53.         TL0 = 0xCD;
  54.         //缓冲区左移一位，并将当前扫描值移入最低位
  55.         keybuf = (keybuf<<1) | KEY4;
  56.         //连续 8 次扫描值都为 0，即 16ms 内都只检测到按下状态时，可认为按键已按下
  57.         if (keybuf == 0x00){
  58.             KeySta = 0;
  59.         //连续 8 次扫描值都为 1，即 16ms 内都只检测到弹起状态时，可认为按键已弹起
  60.         }else if (keybuf == 0xFF){
  61.             KeySta = 1;
  62.         }
  63.         else{
  64.             //其它情况则说明按键状态尚未稳定，则不对 KeySta 变量值进行更新
  65.         }
  66.     }
这个算法在实际工程中经常使用按键所总结的一个比较好的方法，介绍给大家，今后都可以用这种方法消抖了。当然，按键消抖也还有其他的方法，程序实现更是多种多样，大家也可以再多考虑下其他的算法，拓展思路。

8.4.5矩阵按键的扫描

我们讲独立按键扫描的时候，大家已经简单认识了矩阵按键是什么样子了。矩阵按键相当于4组，每组各4个独立按键，一共是16个按键。如何区分这些按键呢？想一下我们生活所在的地球，要想确定我们所在的位置，就要借助经纬线，而矩阵按键就是通过行线和列线来确定哪个按键被按下的。那么在程序中又如何进行这项操作呢？

前边讲过，按键按下通常都会保持100ms以上，如果在按键扫描中断中，每次让矩阵按键的一个KeyOut输出低电平，其他三个输出高电平，判断当前所有KeyIn的状态，下次中断时再让下一个KeyOut输出低电平，其他三个输出高电平，再次判断所有KeyIn，通过快速的中断不停地循环进行判断，就可以最终确定哪个按键按下了，这个原理是不是跟数码管动态扫描有点类似？数码管在动态赋值，而按键在动态读取状态。至于扫描间隔时间和消抖时间，因为现在有4个KeyOut输出，要中断4次才能完成一次全部按键的扫描，显然再采用2ms中断判断8次扫描值的方式时间就太长了(2×4×8=64ms)，就改用1ms中断判断4次采样值，这样消抖时间还是16ms(1×4×4)。下面就用程序实现出来，程序循环扫描板子上的K1~K16这16个矩阵按键，分离出按键动作并在按键按下时把当前按键的编号显示在一位数码管上(用0~F表示，显示值=按键编号-1)。
  1.     #include <reg52.h>
  2.     sbit ADDR0 = P1^0;
  3.     sbit ADDR1 = P1^1;
  4.     sbit ADDR2 = P1^2;
  5.     sbit ADDR3 = P1^3;
  6.     sbit ENLED = P1^4;
  7.     sbit KEY_IN_1 = P2^4;
  8.     sbit KEY_IN_2 = P2^5;
  9.     sbit KEY_IN_3 = P2^6;
  10.     sbit KEY_IN_4 = P2^7;
  11.     sbit KEY_OUT_1 = P2^3;
  12.     sbit KEY_OUT_2 = P2^2;
  13.     sbit KEY_OUT_3 = P2^1;
  14.     sbit KEY_OUT_4 = P2^0;
  15.     unsigned char code LedChar[] = { //数码管显示字符转换表
  16.         0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
  17.         0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
  18.     };
  19.     unsigned char KeySta[4][4] = { //全部矩阵按键的当前状态
  20.         {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}
  21.     };
  22.     void main(){
  23.         unsigned char i, j;
  24.         unsigned char backup[4][4] = { //按键值备份，保存前一次的值
  25.             {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}
  26.         };
  27.       
  28.         EA = 1;  //使能总中断
  29.         ENLED = 0;  //选择数码管 DS1 进行显示
  30.         ADDR3 = 1;
  31.         ADDR2 = 0;
  32.         ADDR1 = 0;
  33.         ADDR0 = 0;
  34.         TMOD = 0x01;  //设置 T0 为模式 1
  35.         TH0 = 0xFC;  //为 T0 赋初值 0xFC67，定时 1ms
  36.         TL0 = 0x67;
  37.         ET0 = 1;  //使能 T0 中断
  38.         TR0 = 1;  //启动 T0
  39.         P0 = LedChar[0];  //默认显示 0
  40.       
  41.         while (1){
  42.             for (i=0; i<4; i++){ //循环检测 4*4 的矩阵按键
  43.                 for (j=0; j<4; j++){
  44.                     if (backup[i][j] != KeySta[i][j]){ //检测按键动作
  45.                         if (backup[i][j] != 0){ //按键按下时执行动作
  46.                             P0 = LedChar[i*4+j];  //将编号显示到数码管
  47.                         }
  48.                         backup[i][j] = KeySta[i][j]; //更新前一次的备份值
  49.                     }
  50.                 }
  51.             }
  52.         }
  53.     }
  54.     /* T0 中断服务函数，扫描矩阵按键状态并消抖 */
  55.     void InterruptTimer0() interrupt 1{
  56.         unsigned char i;
  57.         static unsigned char keyout = 0; //矩阵按键扫描输出索引
  58.         static unsigned char keybuf[4][4] = { //矩阵按键扫描缓冲区
  59.             {0xFF, 0xFF, 0xFF, 0xFF}, {0xFF, 0xFF, 0xFF, 0xFF},
  60.             {0xFF, 0xFF, 0xFF, 0xFF}, {0xFF, 0xFF, 0xFF, 0xFF}
  61.         };
  62.       
  63.         TH0 = 0xFC; //重新加载初值
  64.         TL0 = 0x67;
  65.         //将一行的 4 个按键值移入缓冲区
  66.         keybuf[keyout][0] = (keybuf[keyout][0] << 1) | KEY_IN_1;
  67.         keybuf[keyout][1] = (keybuf[keyout][1] << 1) | KEY_IN_2;
  68.         keybuf[keyout][2] = (keybuf[keyout][2] << 1) | KEY_IN_3;
  69.         keybuf[keyout][3] = (keybuf[keyout][3] << 1) | KEY_IN_4;
  70.         //消抖后更新按键状态
  71.         for (i=0; i<4; i++){ //每行 4 个按键，所以循环 4 次
  72.             //连续 4 次扫描值为 0，即 4*4ms 内都是按下状态时，可认为按键已稳定的按下
  73.             if ((keybuf[keyout][i] & 0x0F) == 0x00){
  74.                 KeySta[keyout][i] = 0;
  75.                 //连续 4 次扫描值为 1，即 4*4ms 内都是弹起状态时，可认为按键已稳定的弹起
  76.             }else if ((keybuf[keyout][i] & 0x0F) == 0x0F){
  77.                 KeySta[keyout][i] = 1;
  78.             }
  79.         }
  80.         //执行下一次的扫描输出
  81.         keyout++;  //输出索引递增
  82.         keyout = keyout & 0x03; //索引值加到 4 即归零
  83.       
  84.         //根据索引，释放当前输出引脚，拉低下次的输出引脚
  85.         switch (keyout){
  86.             case 0: KEY_OUT_4 = 1; KEY_OUT_1 = 0; break;
  87.             case 1: KEY_OUT_1 = 1; KEY_OUT_2 = 0; break;
  88.             case 2: KEY_OUT_2 = 1; KEY_OUT_3 = 0; break;
  89.             case 3: KEY_OUT_3 = 1; KEY_OUT_4 = 0; break;
  90.             default: break;
  91.         }
  92.     }
这个程序完成了矩阵按键的扫描、消抖、动作分离的全部内容，希望读者认真研究一下，彻底掌握矩阵按键的原理和应用方法。在程序中还有两点值得说明一下。
首先，可能读者已经发现了，中断函数中扫描KeyIn输入和切换KeyOut输出的顺序与前面提到的顺序不同，程序中首先对所有的KeyIn输入做了扫描、消抖，然后才切换到了下一次的KeyOut输出，也就是说中断每次扫描的实际是上一次输出选择的那行按键，这是为什么呢？因为任何信号从输出到稳定都需要一个时间，有时它足够快而有时却不够快，这取决于具体的电路设计，这里的输入输出顺序的颠倒就是为了让输出信号有足够的时间(一次中断间隔)来稳定，并有足够的时间来完成它对输入的影响，当按键电路中还有硬件电容消抖时，这样处理就是绝对必要的了，虽然这样使得程序理解起来有点绕，但它的适应性是最好的，换个说法就是，这段程序足够“健壮”，足以应对各种恶劣情况。

其次，是一点小小的编程技巧。注意看keyout = keyout & 0x03;这一行，在这里要让keyout在0~3之间变化，加到4就自动归零，按照常规可以用前面讲过的if语句轻松实现，但是现在看一下这样程序是不是同样可以做到这一点呢？因为0、1、2、3这四个数值正好占用两个二进制的位，所以把一个字节的高6位一直清零的话，这个字节的值自然就是一种到4归零的效果了。看一下，这样一句代码比if语句要更为简洁吧，而效果完全一样。

8.5简易加法计算器

学到这里，我们已经掌握了一种显示设备和一种输入设备的使用，那么是不是可以来做点综合性的实验了。好吧，下面就来做一个简易的加法计算器，用程序实现从板子上标有0~9数字的按键输入相应数字，该数字要实时显示到数码管上，用标有向上箭头的按键代替加号，按下加号后可以再输入一串数字，然后回车键计算加法结果，并同时显示到数码管上。虽然这远不是一个完善的计算器程序，但作为初学者也足够你研究一阵子了。

首先，本程序相对于之前的例程要复杂得多，需要完成的工作也多得多，所以把各个子功能都作成独立的函数，以使程序便于编写和维护。分析程序的时候就从主函数和中断函数入手，随着程序的流程进行就可以了。可以体会体会划分函数的好处，想想如果还是只有主函数和中断函数来实现的话程序会是什么样子。

其次，大家可以看到再把矩阵按键扫描分离出动作以后，并没有直接使用行列数所组成的数值作为分支判断执行动作的依据，而是把抽象的行列数转换为了一种叫作标准键盘键码(就是计算机键盘的编码)的数据，然后用得到的这个数据作为下一步分支判断执行动作的依据，为什么多此一举呢？有两层含义： 第一，尽量让自己设计的东西(包括硬件和软件)向已有的行业规范或标准看齐，这样有助于别人理解认可你的设计，也有助于你的设计与别人的设计相对接，毕竟标准就是为此而生的嘛。第二，有助于程序的层次化而方便维护与移植，比如用的按键是4×4，但如果后续又增加了一行成了4×5，那么由行列数组成的编号可能就变了，就要在程序的各个分支中查找修改，稍不留神就会出错，而采用这种转换后，则只需要维护KeyCodeMap这样一个数组表格就行了，看上去就像是把程序的底层驱动与应用层的功能实现函数分离开了，应用层不用关心底层的实现细节，底层改变后也无须在应用层中做相应修改，两层程序之间是一种标准化的接口。这就是程序的层次化，而层次化是构建复杂系统的必备条件，现在就先通过简单的示例来学习一下吧。

作为初学者针对这种程序的学习方式是，先从头到尾读一到三遍，边读边理解，然后边抄边理解，彻底理解透彻后，自己尝试独立写出来。完全采用记忆模式来学习这种例程，一两个例程你可能感觉不到什么提高，当这种例程背过上百八十个的时候，厚积薄发的感觉就来了。同时，在抄读的过程中也要注意学习编程规范，这些可都是无形的财富，可以为日后的研发工作加分。
  1.     #include <reg52.h>
  2.     sbit ADDR0 = P1^0;
  3.     sbit ADDR1 = P1^1;
  4.     sbit ADDR2 = P1^2;
  5.     sbit ADDR3 = P1^3;
  6.     sbit ENLED = P1^4;
  7.     sbit KEY_IN_1 = P2^4;
  8.     sbit KEY_IN_2 = P2^5;
  9.     sbit KEY_IN_3 = P2^6;
  10.     sbit KEY_IN_4 = P2^7;
  11.     sbit KEY_OUT_1 = P2^3;
  12.     sbit KEY_OUT_2 = P2^2;
  13.     sbit KEY_OUT_3 = P2^1;
  14.     sbit KEY_OUT_4 = P2^0;
  15.     unsigned char code LedChar[] = { //数码管显示字符转换表
  16.         0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
  17.         0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
  18.     };
  19.     unsigned char LedBuff[6] = { //数码管显示缓冲区
  20.         0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
  21.     };
  22.     unsigned char code KeyCodeMap[4][4] = { //矩阵按键编号到标准键盘键码的映射表
  23.         { 0x31, 0x32, 0x33, 0x26 }, //数字键 1、数字键 2、数字键 3、向上键
  24.         { 0x34, 0x35, 0x36, 0x25 }, //数字键 4、数字键 5、数字键 6、向左键
  25.         { 0x37, 0x38, 0x39, 0x28 }, //数字键 7、数字键 8、数字键 9、向下键
  26.         { 0x30, 0x1B, 0x0D, 0x27 } //数字键 0、ESC 键、 回车键、 向右键
  27.     };
  28.     unsigned char KeySta[4][4] = { //全部矩阵按键的当前状态
  29.         {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}
  30.     };
  31.     void KeyDriver();
  32.     void main(){
  33.         EA = 1;  //使能总中断
  34.         ENLED = 0;  //选择数码管进行显示
  35.         ADDR3 = 1;
  36.         TMOD = 0x01; //设置 T0 为模式 1
  37.         TH0 = 0xFC; //为 T0 赋初值 0xFC67，定时 1ms
  38.         TL0 = 0x67;
  39.         ET0 = 1; //使能 T0 中断
  40.         TR0 = 1; //启动 T0
  41.         LedBuff[0] = LedChar[0]; //上电显示 0
  42.       
  43.         while (1){
  44.             KeyDriver();  //调用按键驱动函数
  45.         }
  46.     }
  47.     /* 将一个无符号长整型的数字显示到数码管上，num-待显示数字 */
  48.     void ShowNumber(unsigned long num){
  49.         signed char i;
  50.         unsigned char buf[6];
  51.         //把长整型数转换为 6 位十进制的数组
  52.         for (i=0; i<6; i++){
  53.             buf[i] = num % 10;
  54.             num = num / 10;
  55.         }
  56.         //从最高位起，遇到 0 转换为空格，遇到非 0 则退出循环
  57.         for (i=5; i>=1; i--){
  58.             if (buf[i] == 0){
  59.                 LedBuff[i] = 0xFF;
  60.             }else{
  61.                 break;
  62.             }
  63.         }
  64.         for ( ; i>=0; i--){ //剩余低位都如实转换为数码管显示字符
  65.             LedBuff[i] = LedChar[buf[i]];
  66.         }
  67.     }
  68.     /* 按键动作函数，根据键码执行相应的操作，keycode-按键键码 */
  69.     void KeyAction(unsigned char keycode){
  70.         static unsigned long result = 0; //用于保存运算结果
  71.         static unsigned long addend = 0; //用于保存输入的加数
  72.       
  73.         if ((keycode>=0x30) && (keycode<=0x39)){ //输入 0-9 的数字
  74.             //整体十进制左移，新数字进入个位
  75.             addend = (addend*10)+(keycode-0x30);
  76.             ShowNumber(addend); //运算结果显示到数码管
  77.             //向上键用作加号，执行加法或连加运算
  78.         }else if (keycode == 0x26){
  79.             result += addend;  //进行加法运算
  80.             addend = 0;
  81.             ShowNumber(result);  //运算结果显示到数码管
  82.             //回车键，执行加法运算(实际效果与加号相同)
  83.         }else if (keycode == 0x0D){
  84.             result += addend;  //进行加法运算
  85.             addend = 0;
  86.             ShowNumber(result); //运算结果显示到数码管
  87.         }else if (keycode == 0x1B){ //Esc 键，清零结果
  88.             addend = 0;
  89.             result = 0;
  90.             ShowNumber(addend); //清零后的加数显示到数码管
  91.         }
  92.     }
  93.     /* 按键驱动函数，检测按键动作，调度相应动作函数，需在主循环中调用 */
  94.     void KeyDriver(){
  95.         unsigned char i, j;
  96.         static unsigned char backup[4][4] = { //按键值备份，保存前一次的值
  97.             {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}
  98.         };
  99.       
  100.         for (i=0; i<4; i++){ //循环检测 4*4 的矩阵按键
  101.             for (j=0; j<4; j++){
  102.                 if (backup[i][j] != KeySta[i][j]){ //检测按键动作
  103.                     if (backup[i][j] != 0){ //按键按下时执行动作
  104.                         KeyAction(KeyCodeMap[i][j]); //调用按键动作函数
  105.                     }
  106.                     backup[i][j] = KeySta[i][j];//刷新前一次的备份值
  107.                 }
  108.             }
  109.         }
  110.     }
  111.     /* 按键扫描函数，需在定时中断中调用，推荐调用间隔 1ms */
  112.     void KeyScan(){
  113.         unsigned char i;
  114.         //矩阵按键扫描输出索引
  115.         static unsigned char keyout = 0;
  116.       
  117.         static unsigned char keybuf[4][4] = { //矩阵按键扫描缓冲区
  118.             {0xFF, 0xFF, 0xFF, 0xFF}, {0xFF, 0xFF, 0xFF, 0xFF},
  119.             {0xFF, 0xFF, 0xFF, 0xFF}, {0xFF, 0xFF, 0xFF, 0xFF}
  120.         };
  121.         //将一行的 4 个按键值移入缓冲区
  122.         keybuf[keyout][0] = (keybuf[keyout][0] << 1) | KEY_IN_1;
  123.         keybuf[keyout][1] = (keybuf[keyout][1] << 1) | KEY_IN_2;
  124.         keybuf[keyout][2] = (keybuf[keyout][2] << 1) | KEY_IN_3;
  125.         keybuf[keyout][3] = (keybuf[keyout][3] << 1) | KEY_IN_4;
  126.         //消抖后更新按键状态
  127.         //每行 4 个按键，所以循环 4 次
  128.         for (i=0; i<4; i++){
  129.             //连续 4 次扫描值为 0，即 4*4ms 内都是按下状态时，可认为按键已稳定的按下
  130.             if ((keybuf[keyout][i] & 0x0F) == 0x00){
  131.                 KeySta[keyout][i] = 0;
  132.             //连续 4 次扫描值为 1，即 4*4ms 内都是弹起状态时，可认为按键已稳定的弹起
  133.             }else if ((keybuf[keyout][i] & 0x0F) == 0x0F){
  134.                 KeySta[keyout][i] = 1;
  135.             }
  136.         }
  137.         //执行下一次的扫描输出
  138.         keyout++; //输出索引递增
  139.         keyout = keyout & 0x03; //索引值加到 4 即归零
  140.         //根据索引，释放当前输出引脚，拉低下次的输出引脚
  141.         switch (keyout){
  142.             case 0: KEY_OUT_4 = 1; KEY_OUT_1 = 0; break;
  143.             case 1: KEY_OUT_1 = 1; KEY_OUT_2 = 0; break;
  144.             case 2: KEY_OUT_2 = 1; KEY_OUT_3 = 0; break;
  145.             case 3: KEY_OUT_3 = 1; KEY_OUT_4 = 0; break;
  146.             default: break;
  147.         }
  148.     }
  149.     /* 数码管动态扫描刷新函数，需在定时中断中调用 */
  150.     void LedScan(){
  151.         static unsigned char i = 0; //动态扫描的索引
  152.         P0 = 0xFF; //显示消隐
  153.       
  154.         switch (i){
  155.             case 0: ADDR2=0; ADDR1=0; ADDR0=0; i++; P0=LedBuff[0]; break;
  156.             case 1: ADDR2=0; ADDR1=0; ADDR0=1; i++; P0=LedBuff[1]; break;
  157.             case 2: ADDR2=0; ADDR1=1; ADDR0=0; i++; P0=LedBuff[2]; break;
  158.             case 3: ADDR2=0; ADDR1=1; ADDR0=1; i++; P0=LedBuff[3]; break;
  159.             case 4: ADDR2=1; ADDR1=0; ADDR0=0; i++; P0=LedBuff[4]; break;
  160.             case 5: ADDR2=1; ADDR1=0; ADDR0=1; i=0; P0=LedBuff[5]; break;
  161.             default: break;
  162.         }
  163.     }
  164.     /* T0 中断服务函数，用于数码管显示扫描与按键扫描 */
  165.     void InterruptTimer0() interrupt 1{
  166.         TH0 = 0xFC; //重新加载初值
  167.         TL0 = 0x67;
  168.         LedScan(); //调用数码管显示扫描函数
  169.         KeyScan(); //调用按键扫描函数
  170.     }
来源：《手把手教你学51单片机-C语言版》“按键”章节摘选