基于中断方法的按键扫描（包含独立按键和矩阵按键）

一、前言

       今天介绍一种用中断处理按键的方法， 在学习这种方法之前，我们一定要认识到一个重要的问题——我们为什么要利用中断来进行按键的扫描？因为这能够帮助我们深刻体会这种方法优越性，只有深刻的体会到这点，我们才能够真正的理解并且掌握这种方法。

        提到按键的处理，我们总是避不开一个话题，那就是按键的消抖。关于按键消抖的方法有很多，硬件上我们可以加一个触发器，或者并连上一个电容，但实际应用中，这种方式的效果往往不是很好，而且还增加了成本和电路复杂度，所以实际中使用的并不多。在绝大多数情况下，我们是用软件即程序来实现消抖的。最简单的消抖原理，就是当检测到按键状态变化后，先等待20ms 左右的延时时间，让抖动消失后再进行一次按键状态检测，如果与刚才检测到的状态相同，就可以确认按键已经稳定的动作了。接下来我给大家写一个简单的程序

 if(key==0)//检测到有按键动作
{
  delay(20);//延时20ms
  if(key==0)//确认按键是按下还是抖动
   {
    //按键按下的程序
   }
}

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

二、定时中断扫描独立按键

       我们启用一个定时中断，每 2ms 进一次中断，扫描一次按键状态并且存储起来，连续扫描 8 次后，看看这连续 8 次的按键状态是否是一致的。 8 次按键的时间大概是 16ms，这 16ms 内如果按键状态一直保持一致，那就可以确定现在按键处于稳定的阶段，而非处于抖动的阶段。举个例子，比如说我现在按下了按键，然后定时器中断扫描了八次，倘若在每一次中断扫描中都检测到按键按下，那么我才认定我的按键是按下了而不是由于抖动。这样的话我们就解决了延时消抖而引起的程序停滞问题。接下来是程序的示例

#include<reg.h>
bit keysta=1;//当前的按键状态
 void main()
{
  bit backup=1;//上一次按键的扫描值
  TMOD = 0x01; //设置 T0 为模式 1
  TH0 = 0xF8; //为 T0 赋初值 0xF8CD，定时 2ms
  TL0 = 0xCD;
  ET0 = 1; //使能 T0 中断
  EA=1;//开总中断
  TR0 = 1; //启动 T0
  while (1)
 {
      if (KeySta != backup) //当前值与前次值不相等说明此时按键有动作
       {
        if (backup == 1) //如果前次值为1，则说明当前是按键按下动作
          {
            //写按键按下的程序
          }
        if (backup == 0) //如果前次值为 0，则说明当前是按键按下后弹起动作
          {
            //写按键按下弹起后的程序
          }
            backup = KeySta; //更新备份为当前值，以备进行下次比较
       }
       
  }

}

void InterruptTimer0() interrupt 1       //T0 中断服务函数，用于按键状态的扫描并消抖 
{
     static unsigned char keybuf = 0xFF; //扫描缓冲区，保存一段时间内的扫描值
     TH0 = 0xF8; //重新加载初值
     TL0 = 0xCD;
     keybuf = (keybuf<<1) | KEY4; //缓冲区左移一位，并将当前扫描值移入最低位
     if (keybuf == 0x00)
        { 
          KeySta = 0;//连续8次扫描值都为0，即16ms内都只检测到按下状态时，可认为按键已按下
        }
     else if (keybuf == 0xFF)
        { 
          KeySta = 1;//连续8次扫描值都为1，即16ms内都只检测到弹起状态时，可认为按键已弹起
        }
 
}

三、定时器中断扫描矩阵按键

   按键按下通常都会保持 100ms 以上，如果在按键扫描中断中，我们每次让矩阵按键的一个 KeyOut 输出低电平，其它三个输出高电平，判断当前所有 KeyIn 的状态，下次中断时再让下一个 KeyOut 输出低电平，其它三个输出高电平，再次判断所有 KeyIn，通过快速的中断不停的循环进行判断，就可以最终确定哪个按键按下了。至于扫描间隔时间和消抖时间，因为现在有 4 KeyOut 输出，要中断 4 次才能完成一次全部按键的 扫描，显然再采用 2ms 中断判断 8 次扫描值的方式时间就太长了（2*4*8=64ms），那么我们就改用 1ms 中断判断 4 次采样值，这样消抖时间还是 16ms(1*4*4)。

 程序示例如下

##include <reg52.h>
sbit KEY_IN_1 =     ;//就具体情况而定
sbit KEY_IN_2 =     ;
sbit KEY_IN_3 =     ;
sbit KEY_IN_4 =     ;
sbit KEY_OUT_1 =    ;
sbit KEY_OUT_2 =    ;
sbit KEY_OUT_3 =    ; 
sbit KEY_OUT_4 =    ;
unsigned char KeySta[4][4] = { {1, 1, 1, 1}, 
                               {1, 1, 1, 1}, 
                               {1, 1, 1, 1}, 
                               {1, 1, 1, 1}
                                };//全部矩阵按键的当前状态
void main()
{
 unsigned char i, j;
 unsigned char backup[4][4] = { 
                               {1, 1, 1, 1}, 
                               {1, 1, 1, 1}, 
                               {1, 1, 1, 1}, 
                               {1, 1, 1, 1}
                                };//按键值备份，保存前一次按键扫描的值
 TMOD = 0x01; //设置 T0 为模式 1
 TH0 = 0xFC; //为 T0 赋初值 0xFC67，定时 1ms
 TL0 = 0x67;
 ET0 = 1; //使能 T0 中断
 EA = 1; //开总中断
 TR0 = 1; //启动 T0
 while (1)
  {
    for (i=0; i<4; i++) //循环检测 4*4 的矩阵按键
        {
            for (j=0; j<4; j++)
                {
                  if (backup[i][j] != KeySta[i][j]) //检测按键动作
                     {
                       if (backup[i][j] = 1) //按键按下时执行动作
                          {
                            //按键按下时程序
                       if (backup[i][j] = 0) //按键按下后松手执行动作
                          {
                            //按键按下后松手时程序
                          }
                       backup[i][j] = KeySta[i][j]; //更新前一次的备份值
                     }
                }
        }
  }
}
/* T0 中断服务函数，扫描矩阵按键状态并消抖 */
void InterruptTimer0() interrupt 1
{
 unsigned char i;
 static unsigned char keyout = 0; //矩阵按键扫描输出索引
 static unsigned char keybuf[4][4] = { 
                    {0xFF, 0xFF, 0xFF, 0xFF}, {0xFF, 0xFF, 0xFF, 0xFF},
                    {0xFF, 0xFF, 0xFF, 0xFF}, {0xFF, 0xFF, 0xFF, 0xFF}
                    };//矩阵按键扫描缓冲区
 TH0 = 0xFC; //重新加载初值
 TL0 = 0x67;
 //将一行的 4 个按键值移入缓冲区
 keybuf[keyout][0] = (keybuf[keyout][0] << 1) | KEY_IN_1;
 keybuf[keyout][1] = (keybuf[keyout][1] << 1) | KEY_IN_2;
 keybuf[keyout][2] = (keybuf[keyout][2] << 1) | KEY_IN_3;
 keybuf[keyout][3] = (keybuf[keyout][3] << 1) | KEY_IN_4;
 //消抖后更新按键状态
 for (i=0; i<4; i++) //每行 4 个按键，所以循环 4 次
 {
    if ((keybuf[keyout][i] & 0x0F) == 0x00)
        {
            KeySta[keyout][i] = 0;
            //连续4次扫描值为0，即4*4ms 内都是按下状态时，可认为按键已稳定的按下
        }
    else if ((keybuf[keyout][i] & 0x0F) == 0x0F)
        { 
            KeySta[keyout][i] = 1;
            //连续4次扫描值为1，即4*4ms内都是弹起状态时，可认为按键已稳定的弹起
        }
 }
 //执行下一次的扫描输出
 keyout++; //输出索引递增
 keyout = keyout & 0x03; //索引值加到 4 即归零
 switch (keyout) //根据索引，释放当前输出引脚，拉低下次的输出引脚
 {
 case 0: KEY_OUT_4 = 1; KEY_OUT_1 = 0; break;
 case 1: KEY_OUT_1 = 1; KEY_OUT_2 = 0; break;
 case 2: KEY_OUT_2 = 1; KEY_OUT_3 = 0; break;
 case 3: KEY_OUT_3 = 1; KEY_OUT_4 = 0; break;
 default: break;
 }
}

在这个程序中我们中断每次扫描的实际是上一次输出选择的那行按键，这是为什么呢？因为任何信号从输出到稳定都需要一个时间，有时它足够快而有时却不够快， 这取决于具体的电路设计，我们这里的输入输出顺序的颠倒就是为了让输出信号有足够的时 间（一次中断间隔）来稳定，并有足够的时间来完成它对输入的影响，提高程序的适应性。