关于单片机按键处理的程序 100%保证可用

ID:89632 · 发表于 2015-9-8 15:05

最近在网上看见一个不错的单片机按键处理程序。所以就和大家分享一下。这个处理程序，对长按和短按都处理的比较细腻。大家在这块不懂的都有可以参照这个程序模板进行修改，本人已经试验，100%保证可用。

单片机按键处理技巧及编程方式

在基于单片机为核心构成的应用系统中，用户输入是必不可少的一部分。输入可以分很多种情况，譬如有的系统支持PS2键盘的接口，有的系统输入是基于编码器，有的系统输入是基于串口或者USB或者其它输入通道等等。在各种输入途径中，更常见的是，基于单个按键或者由单个键盘按照一定排列构成的矩阵键盘(行列键盘)。我们这一篇章主要讨论的对象就是基于单个按键的程序设计，以及矩阵键盘的程序编写。
按键检测的原理: 它们和我们的单片机系统的I/O口连接一般如下：

对于单片机I/O内部有上拉电阻的微控制器而言，还可以省掉外部的那个上拉电阻。简单分析一下按键检测的原理。当按键没有按下的时候，单片机I/O通过上拉电阻R接到VCC，我们在程序中读取该I/O的电平的时候，其值为1(高电平);当按键S按下的时候，该I/O被短接到GND，在程序中读取该I/O的电平的时候，其值为0(低电平) 。这样，按键的按下与否，就和与该按键相连的I/O的电平的变化相对应起来。结论：我们在程序中通过检测到该I/O口电平的变化与否，即可以知道按键是否被按下，从而做出相应的响应。一切看起来很美好，是这样的吗？

在我们通过上面的按键检测原理得出上述的结论的时候，那就是现实中按键按下时候的电平变化状态。我们的结论是基于理想的情况得出来的，而实际中，由于按键的弹片接触的时候，并不是一接触就紧紧的闭合，它还存在一定的抖动，尽管这个时间非常的短暂，但是对于我们执行时间以us为计算单位的微控制器来说，
它太漫长了。因而，实际的波形图应该如下面这幅示意图一样。

这样便存在这样一个问题。假设我们的系统有这样功能需求：在检测到按键按下的时候，将某个I/O的状态取反。由于这种抖动的存在，使得我们的微控制器误以为是多次按键的按下，从而将某个I/O的状态不断取反，这并不是我们想要的效果，假如该I/O控制着系统中某个重要的执行的部件，那结果更不是我们所期待的。于是乎有人便提出了软件消除抖动的思想，道理很简单：抖动的时间长度是一定的，只要我们避开这段抖动时期，检测稳定的时候的电平不就可以了吗？听起来确实不错，而且实际应用起来效果也还可以。于是就像下面的伪代码所描述的一样。(假设按键按下时候，低电平有效)
If(0 ==io_KeyEnter)          //如果有键按下了
{
   Delayms(20);          //先延时20ms避开抖动时期
   If(0 ==io_KeyEnter)       //然后再检测，如果还是检测到有键按下
   {
      return KeyValue;          //是真的按下了，返回键值
   }
   else
{
   returnKEY_NULL       //是抖动，返回空的键值
}
   while(0 == io_KeyEnter) ;    //等待按键释放
}
乍看上去，确实挺不错，在实际的系统中，一般是不允许这么样做的。为什么呢？首先，这里的Delayms(20) ,让微控制器在这里白白等待了20 ms 的时间，啥也没干，考虑我在《学会释放CPU》一章中所提及的几点，这是不可取的。其次while(0 ==io_KeyEnter) 所以合理的分配好微控制的处理时间，是编写按键程序的基础。原本是等待按键释放，结果CPU就一直死死的盯住该按键，其它事情都不管了，那其它事情不干了吗？
消除抖动有必要吗？
的确，软件上的消抖确实可以保证按键的有效检测。但是，这种消抖确实有必要吗？抖动的出现即意味着按键已经按下，尽管这个电平还没有稳定。所以只要我们检测到按键按下，即可以返回键值，问题的关键是，在你执行完其它任务的时候，再次执行我们的按键任务的时候，抖动过程还没有结束，这样便有可能造成重复检测。所以，如何在返回键值后，避免重复检测，或者在按键一按下就执行功能函数，当功能函数的执行时间小于抖动时间时候，如何避免再次执行功能函数，就成为我们要考虑的问题了。所以消除抖动的目的是：防止按键一次按下，多次响应。
  基于状态转移的独立按键程序设计
   本章所描述的按键程序要达到的目的：检测按键按下，短按，长按，释放。即通过按键的返回值我们可以获取到如下的信息：按键按下(短按)，按键长按，按键连_发，按键释放。这样的功能到底是如何实现的呢，今天就让我们来剖析它的原理吧。下面让我们来简单的描绘一下它的状态流程转移图。

下面对上面的流程图进行简要的分析。
首先按键程序进入初始状态S1，在这个状态下，检测按键是否按下，如果有按下，则进入按键消抖状态2，在下一次执行按键程序时候，直接由按键消抖状态进入按键按下状态3，在此状态下检测按键是否按下，如果没有按键按下，则返回初始状态S1，如果有则可以返回键值，同时进入长按状态S4，在长按状态下每次进入按键程序时候对按键时间计数，当计数值超过设定阈值时候，则表明长按事件发生，同时进入按键连_发状态S5。如果按键键值为空键，则返回按键释放状态S6，否则继续停留在本状态。在按键连_发状态下，如果按键键值为空键则返回按键释放状态S6，如果按键时间计数超过连_发阈值，则返回连_发按键值，清零时间计数后继续停留在本状态。下面让我们一起来编写按键驱动程序吧。下面是我使用的硬件的连接图。

硬件连接很简单，四个独立按键分别接在P3^0------P3^3四个I/O上面。
因为51单片机I/O口内部结构的限制，在读取外部引脚状态的时候，需要向端口写1.在51单片机复位后，不需要进行此操作也可以进行读取外部引脚的操作。因此，在按键的端口没有复用的情况下，可以省略此步骤。而对于其它一些真正双向I/O口的单片机来说，将引脚设置成输入状态，是必不可少的一个步骤。
下面的程序代码初始化引脚为输入。
void KeyInit(void)
{
   io_key_1 = 1 ;
   io_key_2 = 1 ;
   io_key_3 = 1 ;
   io_key_4 = 1;
}
根据按键硬件连接定义按键键值
#defineKEY_VALUE_1             0x0e
#define KEY_VALUE_2             0x0d
#defineKEY_VALUE_3             0x0b
#defineKEY_VALUE_4             0x07
#defineKEY_NULL                   0x0f
下面我们来编写按键的硬件驱动程序。
根据第一章所描述的按键检测原理，我们可以很容易的得出如下的代码：
static uint8 KeyScan(void)
{
   if(io_key_1 == 0)return KEY_VALUE_1 ;
   if(io_key_2 == 0)return KEY_VALUE_2 ;
   if(io_key_3 == 0)return KEY_VALUE_3 ;
   if(io_key_4 == 0)return KEY_VALUE_4 ;
   return KEY_NULL ;
}
其中io_key_1等是我们按键端口的定义，如下所示：
sbit io_key_1 = P3^0 ;
sbit io_key_2 = P3^1 ;
sbit io_key_3 = P3^2 ;
sbit io_key_4 = P3^3 ;

KeyScan()作为底层按键的驱动程序，为上层按键扫描提供一个接口，这样我们编写的上层按键扫描函数可以几乎不用修改就可以拿到我们的其它程序中去使用，使得程序复用性大大提高。同时，通过有意识的将与底层硬件连接紧密的程序和与硬件无关的代码分开写，使得程序结构层次清晰，可移植性也更好。对于单片机类的程序而言，能够做到函数级别的代码重用已经足够了。
在编写我们的上层按键扫描函数之前，需要先完成一些宏定义。
//定义长按键的TICK数,以及连_发间隔的TICK数
#define KEY_LONG_PERIOD       100
#define KEY_CONTINUE_PERIOD    25
//定义按键返回值状态(按下,长按,连_发,释放)
#defineKEY_DOWN             0x80
#defineKEY_LONG                   0x40
#defineKEY_CONTINUE          0x20
#define KEY_UP    0x10       //定义按键状态
#defineKEY_STATE_INIT          0
#defineKEY_STATE_WOBBLE          1
#defineKEY_STATE_PRESS          2
#defineKEY_STATE_LONG          3
#define KEY_STATE_CONTINUE    4
#define KEY_STATE_RELEASE       5
接着我们开始编写完整的上层按键扫描函数，按键的短按，长按，连按，释放等等状态的判断均是在此函数中完成。对照状态流程转移图，然后再看下面的函数代码，可以更容易的去理解函数的执行流程。完整的函数代码如下：
void GetKey(uint8 *pKeyValue)
{
   static uint8 s_u8KeyState = KEY_STATE_INIT ;
   static uint8 s_u8KeyTimeCount = 0 ;
   static uint8 s_u8LastKey = KEY_NULL ; //保存按键释放时候的键值
   uint8 KeyTemp = KEY_NULL ;

   KeyTemp = KeyScan();       //获取键值
   switch(s_u8KeyState)
   {
      case KEY_STATE_INIT :
            {
                  if(KEY_NULL != (KeyTemp))
                  {
                     s_u8KeyState = KEY_STATE_WOBBLE ;
                  }
            }
      break ;
      case KEY_STATE_WOBBLE:    //消抖
            {
                  s_u8KeyState = KEY_STATE_PRESS ;
            }
      break ;
      case KEY_STATE_PRESS :
            {
                  if(KEY_NULL != (KeyTemp))
                  {
                     s_u8LastKey = KeyTemp ; //保存键值,以便在释放按键状态返回键值
                     KeyTemp |= KEY_DOWN ; //按键按下
                     s_u8KeyState = KEY_STATE_LONG ;
                  }
                  else
                  {
                     s_u8KeyState = KEY_STATE_INIT ;
                  }
            }
      break ;
      case KEY_STATE_LONG :
            {
                  if(KEY_NULL != (KeyTemp))
                  {
                     if(++s_u8KeyTimeCount > KEY_LONG_PERIOD)
                     {
                        s_u8KeyTimeCount = 0 ;
                        KeyTemp |= KEY_LONG ; //长按键事件发生
                        s_u8KeyState = KEY_STATE_CONTINUE ;
                     }
                  }
                  else
                  {
                     s_u8KeyState = KEY_STATE_RELEASE ;
                  }
            }
      break ;
      case KEY_STATE_CONTINUE :
            {
                  if(KEY_NULL != (KeyTemp))
                  {
                     if(++s_u8KeyTimeCount > KEY_CONTINUE_PERIOD)
                     {
                        s_u8KeyTimeCount = 0 ;
                        KeyTemp |= KEY_CONTINUE ;
                     }
                  }
                  else
                  {
                     s_u8KeyState = KEY_STATE_RELEASE ;
                  }
            }
      break ;
      case KEY_STATE_RELEASE :
            {
                  s_u8LastKey |= KEY_UP ;
                  KeyTemp = s_u8LastKey ;
                  s_u8KeyState = KEY_STATE_INIT ;
            }
      break ;
      default : break ;
   }
   *pKeyValue = KeyTemp ; //返回键值
}
关于这个函数内部的细节我并不打算花过多笔墨去讲解。对照着按键状态流程转移图，然后去看程序代码，你会发现其实思路非常清晰。最能让人理解透彻的，莫非就是将整个程序自己看懂，然后想象为什么这个地方要这样写，抱着思考的态度去阅读程序，你会发现自己的程序水平会慢慢的提高。不管怎么样，这样的一个程序已经完成了本章开始时候要求的功能：按下，长按，连按，释放。事实上，如果掌握了这种基于状态转移的思想，你会发现要求实现其它按键功能，譬如，多键按下，功能键等等，亦相当简单，在下一章，我们就去实现它。
在主程序中我编写了这样的一段代码，来演示我实现的按键功能。
void main(void)
{
   uint8 KeyValue = KEY_NULL;
   uint8 temp = 0 ;
   LED_CS11 = 1 ; //流水灯输出允许
   LED_SEG = 0 ;
   LED_DIG = 0 ;
   Timer0Init() ;
   KeyInit() ;
   EA = 1 ;
   while(1)
   {
      Timer0MainLoop() ;
      KeyMainLoop(&KeyValue) ;

      if(KeyValue == (KEY_VALUE_1 |KEY_DOWN)) P0 = ~1 ;
      if(KeyValue == (KEY_VALUE_1 |KEY_LONG)) P0 = ~2 ;
      if(KeyValue == (KEY_VALUE_1 |KEY_CONTINUE)) { P0 ^= 0xf0;}
      if(KeyValue == (KEY_VALUE_1 |KEY_UP)) P0 = 0xa5 ;
   }
}
   按住第一个键，可以清晰的看到P0口所接的LED的状态的变化。当按键按下时候，第一个LED灯亮，等待2 S后第二个LED亮，第一个熄灭，表示长按事件发生。再过500 ms 第5~8个LED闪烁，表示连按事件发生。当释放按键时候，P0口所接的LED的状态为：灭亮灭亮亮灭亮灭，这也正是P0 =0xa5这条语句的功能。

ID:89632 · 发表于 2015-9-8 18:01

真的很有用啊！

ID:98238 · 发表于 2015-12-10 11:30

为嘛我用就编译不通过

ID:82098 · 发表于 2015-12-28 13:19

hboy 发表于 2015-12-10 11:30
为嘛我用就编译不通过

把KeyMainLoop(&KeyValue) ;换成GetKey(&KeyValue);即可。

ID:304849 · 发表于 2018-5-16 13:43

汇编程序，怎么利用键值跳转到子程序呢？

ID:323951 · 发表于 2018-5-30 15:18

这个看起来不是很理解，可以发一下楼主自己改过以后的源码吗？

ID:207882 · 发表于 2018-6-20 19:49

如果执行程序的时间小于消抖的时间那不是还是进入了case KEY_STATE_PRESS ？？？？不需要设置消抖时间？

ID:66287 · 发表于 2018-7-23 16:23

实际上应该定时10mS，在定时中断中执行void GetKey(uint8 *pKeyValue)函数吧，

ID:66287 · 发表于 2018-7-24 10:21

/*********************************************
工程名：状态机按键处理
作者：

*********************************************/
//#include <reg51.h>
#include <STC15F2K60S2.H>
typedef unsigned char uint8;
typedef unsigned int  uint16;

#define KEY_VALUE_1 0x0e
#define KEY_VALUE_2 0x0d
#define KEY_VALUE_3 0x0b
#define KEY_VALUE_4 0x07
#define KEY_NULL    0x0f

//定义长按键的TICK数,以及连_发间隔的TICK数
#define KEY_LONG_PERIOD       100
#define KEY_CONTINUE_PERIOD    25
//定义按键返回值状态(按下,长按,连_发,释放)
#define KEY_DOWN             0x80
#define KEY_LONG             0x40
#define KEY_CONTINUE          0x20
#define KEY_UP    0x10       //定义按键状态
#define KEY_STATE_INIT          0
#define KEY_STATE_WOBBLE       1
#define KEY_STATE_PRESS       2
#define KEY_STATE_LONG          3
#define KEY_STATE_CONTINUE    4
#define KEY_STATE_RELEASE       5

sbit io_key_1 = P1^1 ;
sbit io_key_2 = P1^2 ;
sbit io_key_3 = P1^3 ;
sbit io_key_4 = P1^4 ;
void Timer0_Init();

void KeyInit(void)
{
   io_key_1 = 1 ;
   io_key_2 = 1 ;
   io_key_3 = 1 ;
   io_key_4 = 1;
}

static uint8 KeyScan(void)
{
   if(io_key_1 == 0) return KEY_VALUE_1;
   if(io_key_2 == 0) return KEY_VALUE_2;
   if(io_key_3 == 0) return KEY_VALUE_3;
   if(io_key_4 == 0) return KEY_VALUE_4;
   return KEY_NULL ;
}

void GetKey(uint8 *pKeyValue)
{
   static uint8 s_u8KeyState = KEY_STATE_INIT;
   static uint8 s_u8KeyTimeCount = 0 ;
   static uint8 s_u8LastKey = KEY_NULL ; //保存按键释放时候的键值
   uint8 KeyTemp = KEY_NULL ;

   KeyTemp = KeyScan();       //获取键值
   switch(s_u8KeyState)
   {
      case KEY_STATE_INIT :
            {
                  if(KEY_NULL != (KeyTemp))
                  {
                     s_u8KeyState = KEY_STATE_WOBBLE ;
                  }
            }
      break ;
      case KEY_STATE_WOBBLE:    //消抖
            {
                  s_u8KeyState = KEY_STATE_PRESS ;
            }
      break ;
      case KEY_STATE_PRESS :
            {
                  if(KEY_NULL != (KeyTemp))
                  {
                     s_u8LastKey = KeyTemp ; //保存键值,以便在释放按键状态返回键值
                     KeyTemp |= KEY_DOWN ; //按键按下
                     s_u8KeyState = KEY_STATE_LONG ;
                  }
                  else
                  {
                     s_u8KeyState = KEY_STATE_INIT ;
                  }
            }
      break ;
      case KEY_STATE_LONG :
            {
                  if(KEY_NULL != (KeyTemp))
                  {
                     if(++s_u8KeyTimeCount > KEY_LONG_PERIOD)
                     {
                        s_u8KeyTimeCount = 0 ;
                        KeyTemp |= KEY_LONG ; //长按键事件发生
                        s_u8KeyState = KEY_STATE_CONTINUE ;
                     }
                  }
                  else
                  {
                     s_u8KeyState = KEY_STATE_RELEASE ;
                  }
            }
      break ;
      case KEY_STATE_CONTINUE :
            {
                  if(KEY_NULL != (KeyTemp))
                  {
                     if(++s_u8KeyTimeCount > KEY_CONTINUE_PERIOD)
                     {
                        s_u8KeyTimeCount = 0 ;
                        KeyTemp |= KEY_CONTINUE ;
                     }
                  }
                  else
                  {
                     s_u8KeyState = KEY_STATE_RELEASE ;
                  }
            }
      break ;
      case KEY_STATE_RELEASE :
            {
                  s_u8LastKey |= KEY_UP ;
                  KeyTemp = s_u8LastKey ;
                  s_u8KeyState = KEY_STATE_INIT ;
            }
      break ;
      default : break ;
   }
   *pKeyValue = KeyTemp ; //返回键值
}

uint8 KeyValue = KEY_NULL;
void main(void)
{

   uint8 temp = 0 ;

   Timer0_Init();
   KeyInit() ;
   EA = 1 ;
   while(1)
   {
      //Timer0MainLoop() ;
      //KeyMainLoop(&KeyValue) ;

   }
}

void Timer0() interrupt 1 //定时器中断
{
                        //16位自动重装模式，无需重赋初值
   GetKey(&KeyValue);
      if(KeyValue == (KEY_VALUE_1|KEY_DOWN)) P0 = ~1 ;
      if(KeyValue == (KEY_VALUE_1 |KEY_LONG)) P0 = ~2 ;
      if(KeyValue == (KEY_VALUE_1 |KEY_CONTINUE)) { P0 ^= 0xf0;}
      if(KeyValue == (KEY_VALUE_1 |KEY_UP)) P0 = 0xa5 ;

}

void Timer0_Init()  //定时器初始化
{
   AUXR &= 0x7F; //定时器时钟12T模式，10mS
   TMOD &= 0xF0; //设置定时器模式
   TH0 = 0xDC; //设置定时初值
   TL0 = 0x00; //设置定时初值
   //TF0 = 0; //清除TF0标志
   TR0 = 1; //定时器0开始计时
      ET0 =1;
   EA = 1;
  }

ID:20672 · 发表于 2018-8-2 21:24

不错！！！

ID:377382 · 发表于 2018-8-4 13:36

不错不错

ID:330092 · 发表于 2018-8-30 03:50

学习了，谢谢分享

ID:718536 · 发表于 2020-4-17 17:58

楼主大大，如果按键进水或者卡死了，导致所有程序运行错误。要如何屏蔽掉这个卡死或者进水的按键呢？

ID:711507 · 发表于 2020-5-8 23:53

学习学习

ID:662183 · 发表于 2020-5-9 00:38

打卡学习，小白报道，感谢分享

ID:374361 · 发表于 2020-5-9 08:58

楼主有点东西

ID:771858 · 发表于 2020-6-7 14:01

感谢楼主

ID:763926 · 发表于 2020-6-7 16:20

很管用的东西啊

ID:173256 · 发表于 2020-6-8 22:35

单个按键组合好像有冲突比如KYE1要长按实现退出功能但长按动作前面肯定会经过短按（短按—长按—连击）这时短按就会被触发了

ID:771727 · 发表于 2020-6-9 03:51

多个按键同时按住，会不会发生冲突。

帐号		自动登录	找回密码
密码			立即注册

关于单片机按键处理的程序 100%保证可用

评分

相关帖子