多功能按键

阅读目录

• 正文：
• 一、[单击]、[长按]程序
• 二、 [双击]程序
• 三、 [三击]程序

最近自己在琢磨按键程序，之前弄了，按键单击程序，程序可以实现读取按键的几个状态，然后根据需求使用。单击按键的几个状态如下：

• 单击后，马上返回按键值
• 单击后，释放之后，返回按键值
• 单击后，按住不放，多次返回按键值

但是在其上面扩展双击和三击以及多击程序时，遇到了麻烦（其实就是不会啦），于是在网上看了某个老师的经典按键程序，里面讲了单击和双击，拿着源程序理解了半天，终于一知半解了（一知半解的状态就是能读懂思想，但是闭卷完全自己写，写不出）。但是个人觉得其中的消抖部分还有按键释放的部分还可以改善，还有根据其思路扩展了三击以及N击，于是写了这篇博客供自己以后遗忘时参考以及跟大家分享。

---

回到顶部

正文：

此按键程序的实现的功能是单个独立按键的[单击]，[长按]，[双击]，[三击]以及[多击]。本文分为三个部分，

• 第一个部分是说[单击]，[长按]的程序；
• 第二部分是讲[双击]；
• 第三部分是讲[三击]，[多击]；

回到顶部

一、[单击]、[长按]程序

1. 简单介绍本按键程序的单击和长按

首先说一下单击，长按的响应情况，就是按多久算单击或者长按，按下按键马上返回有效键值，还是释放之后返回有效键值等等，下面说下它在什么情况下返回有效的【单击】和【长按】。

首先看一张时序图： 

注：

T1：是单击的按键消抖时长，这里预设的是30ms，也可以根据需求自行定义； 
T2：是单击时，按键释放的有效时间段，提前或者超过这个时间段释放的按键都不再是单击了。提前释放则是无效键值，超过后释放则是长按。 
T3：是长按时长，按键超过此时长，则为长按。这里的预设值是3s，同样可根据需求自行更改。

【单击】：按键按下超过消抖时长T1(30ms)，并且在T2时间段内释放按键，按键一释放，马上返回有效按键值—【单击】。 
注意：单击是释放后，才返回有效按键值，不释放时，是无效按键值。

【长按】：按键按下的时间超过预设的长按时长T3(3s) ，马上返回有效按键值—【长按】； 
注意：长按是只要按下的时间超过预设的长按时长，马上返回有效键值。但是，如果按键一直按着不释放，则只返回一次有效按键值，不重复返回，直到释放之后，才开始重新读取键值。

2. 按键程序的架构

按键程序可以分为四个部分，第一部分：判断有无按键按下；第二部分：按键是否有效（按键消抖）；第三部分：确定有效按键的种类（单击还是长按）；第四部分：等待按键释放。

3. 按键程序的源代码以及注释

程序的注释写的很详细，应该是可以读懂的，如果有疑问可以留言讨论。 
以下是key.c 的源代码：

#define KEY_INPUT P1.0 //按键IO
#define KEY_STATE_0 0 //按键状态
#define KEY_STATE_1 1
#define KEY_STATE_2 2
#define KEY_STATE_3 3
#define LONG_KEY_TIME 300 //LONG_KEY_TIME*10MS = 3S
#define SINGLE_KEY_TIME 3 //SINGLE_KEY_TIME*10MS = 30MS
#define KEY_NONE 0     //no click
#define KEY_SHORT 1     //single click
#define KEY_LONG 10     //long press
//10MS
void key_driver(void)
{
    static char key_state;                          //按键状态变量
    static int key_time;                            //按键计时变量
    char key_press, key_return;
    key_return = KEY_NONE;        // 清除 返回按键值
    key_press = KEY_INPUT;    // 读取当前键值
    switch (key_state)
    {
        case KEY_STATE_0:                       // 按键状态0：判断有无按键按下
            if (!key_press)                     // 有按键按下
            {
                key_time = 0;                   // 清零时间间隔计数
                key_state = KEY_STATE_1;        // 然后进入 按键状态1
            }
            break;
        case KEY_STATE_1:                       // 按键状态1：软件消抖（确定按键是否有效，而不是误触）。按键有效的定义：按键持续按下超过设定的消抖时间。
            if (!key_press)
            {
                key_time++;                     // 一次10ms
                if (key_time >= SINGLE_KEY_TIME)   // 消抖时间为：SINGLE_KEY_TIME*10ms = 30ms;
                {
                    key_state = KEY_STATE_2;    // 如果按键时间超过 消抖时间，即判定为按下的按键有效。按键有效包括两种：单击或者长按，进入 按键状态2， 继续判定到底是那种有效按键
                }
            }
            else
                key_state = KEY_STATE_0;       // 如果按键时间没有超过，判定为误触，按键无效，返回 按键状态0，继续等待按键
            break;
        case KEY_STATE_2:                       // 按键状态2：判定按键有效的种类：是单击，还是长按
            if (key_press)                       // 如果按键在 设定的长按时间 内释放，则判定为单击
            {
                key_return = KEY_SHORT;        // 返回 有效按键值：单击
                key_state = KEY_STATE_0;       // 返回 按键状态0，继续等待按键
            }
            else
            {
                key_time++;
                if (key_time >= LONG_KEY_TIME)   // 如果按键时间超过 设定的长按时间（LONG_KEY_TIME*10ms=200*10ms=2000ms）, 则判定为 长按
                {
                    key_return = KEY_LONG;         // 返回 有效键值值：长按
                    key_state = KEY_STATE_3;    // 去状态3，等待按键释放
                }
            }
            break;
        case KEY_STATE_3:                         // 等待按键释放
            if (key_press)
            {
                key_state = KEY_STATE_0;          // 按键释放后，进入 按键状态0 ，进行下一次按键的判定
            }
            break;
        default:                                // 特殊情况：key_state是其他值得情况，清零key_state。这种情况一般出现在 没有初始化key_state，第一次执行这个函数的时候
            key_state = KEY_STATE_0;
            break;
    }
    return key_return;              // 返回 按键值
}

使用注意： 
1）硬件：按键的一端接地（GND），另一端接IO口。IO为输入，一定要有上拉电阻。 
2）定时器：这里为了精确的定时，所以使用了定时器，定时器的时间是10ms。 
3）扫描周期：调用此函数时，一定确保”扫描周期“要小于10ms。不然按键内所涉及的时间就会不准，会偏大。所涉及的时间包括消抖时长，按键长按时长等。

4. 按键程序的使用实例

这里以C51位硬件平台进行实例讲解 
1）实例程序的功能： 
单击：点亮LED1 
长按：熄灭LED1 
2）硬件： 
按键IO：P1.0 
LED1 ：P2.0 
以下是 main.c 源代码:

#include "reg51.h"
#include "key.c"
sbit LED1 = P2.0;       //定义LEDIO口
unsigned char g_u8_KeyValue;        //按键值
unsigned char g_flag_10ms_key;      //10ms 计时标志
//timer0，初始化函数 ，定时时间为 10ms
void T0_Init_10ms(void)
{
    TMOD |= 0x01;
    TH0 = (65535 - 10000)/256;
    TL0 = (65535 - 10000)%256;
    ET0 = 1;
    TR0 = 1;
    EA = 1;
}
//主函数
void main(void)
{
    P1.0 = 1;           //P1.0 拉高
    T0_Init_10ms();     //定时器0，初始化，定时10ms
    while(1)
    {
        if(g_flag_10ms_key)                     //等待10ms,定时完成
        {
            g_flag_10ms_key = 0;                //清零10ms定时标志
            g_u8_KeyValue = key_driver();       //读取按键值
            switch(g_u8_KeyValue)
            {
                case S_Key: LED1 = 1; break;    //单击 点亮LED1
                case L_Key: LED1 = 1; break;    //长按 熄灭LED1
            }
        }
    }
}
//timer0 中断服务程序
void IRQ_T0(void) interrupt 1
{
    g_flag_10ms_key = 1;                        //置位 10ms 定时标志
}

---

回到顶部

二、 [双击]程序

1.双击介绍

双击的判定 
在完成第一次【单击】之后，在一定的时间间隔内（本程序使用的是300ms），接着完成第二次【单击】,及判定为【双击】。 
双击的响应 
1）在预设的时间间隔内完成第二次【单击】，按键释放后，响应返回有效键值【双击】。 
2）如果第二次按下键并一直按住，当按住的时间超过设定的时间间隔（300ms）后，会响应第一个【单击】，并返回有效键值【单击】。 
注：【单击】是包括按下和释放按键的过程，判定方式沿用上文所说的，如果忘了，可以参考上文。 
双击响应时序图 

注： 
T1：是单击判定的时间，范围：30ms < T1 < 3000ms 
T2：是判定双击的时间间隔，是个定值 300ms。在完成第一次【单击】后（释放按键后开始计时），在这个时间间隔内，如果再一次完成【单击】（释放按键后结束计时），则判定为【双击】。 
T3：与T1相同。

2.按键程结构

按键程序可以分为四个部分，第一部分：判断有无单击按键；第二部分：判断双击即是在预设的时间间隔内，有无第二次【单击】；第三部分：等待按键释放。

3.双击程序的源代码以及注释

程序的注释写的很详细，应该是可以读懂的，如果有疑问可以留言讨论。 
上文的【单击】函数作为这次【双击】程序的子函数 
以下是key.c 的源代码：

#define KEY_INPUT P1.0 // 按键IO
#define KEY_STATE_0 0 // 按键状态
#define KEY_STATE_1 1
#define KEY_STATE_2 2
#define KEY_STATE_3 3
#define SINGLE_KEY_TIME 3 // SINGLE_KEY_TIME*10MS = 30MS 判定单击的时间长度，软件消抖
#define KEY_INTERVAL 30 // KEY_INTERVAL*10MS = 300MS 判定双击的时间间隔
#define LONG_KEY_TIME 300 // LONG_KEY_TIME*10MS = 3S 判定长按的时间长度
#define KEY_NONE 0     // no click
#define KEY_SHORT 1     // single click
#define KEY_DOUBLE 2     // double click
#define KEY_LONG 10     // long press
// ----------------------------------- key_driver --------------------------
unsigned char key_driver(void)
{
    static unsigned char key_state = 0;
    static unsigned int key_time = 0;
    unsigned char key_press, key_return;
    key_return = KEY_NONE;                         // 清除 返回按键值
    key_press = KEY_INPUT;                          // 读取当前键值
    switch (key_state)
    {
        case KEY_STATE_0:                       // 按键状态0：判断有无按键按下
            if (!key_press)                         // 有按键按下
            {
                key_time = 0;                          // 清零时间间隔计数
                key_state = KEY_STATE_1;            // 然后进入 按键状态1
            }
            break;
        case KEY_STATE_1:                       // 按键状态1：软件消抖（确定按键是否有效，而不是误触）。按键有效的定义：按键持续按下超过设定的消抖时间。
            if (!key_press)
            {
                key_time++;                             // 一次10ms
                if (key_time >= SINGLE_KEY_TIME)   // 消抖时间为：SINGLE_KEY_TIME*10ms = 30ms;
                {
                    key_state = KEY_STATE_2;    // 如果按键时间超过 消抖时间，即判定为按下的按键有效。按键有效包括两种：单击或者长按，进入 按键状态2， 继续判定到底是那种有效按键
                }
            }
            else
                key_state = KEY_STATE_0;       // 如果按键时间没有超过，判定为误触，按键无效，返回 按键状态0，继续等待按键
            break;
        case KEY_STATE_2:                       // 按键状态2：判定按键有效的种类：是单击，还是长按
            if (key_press)                       // 如果按键在 设定的长按时间 内释放，则判定为单击
            {
                key_return = KEY_SHORT;            // 返回 有效按键值：单击
                key_state = KEY_STATE_0;       // 返回 按键状态0，继续等待按键
            }
            else
            {
                key_time++;
                if (key_time >= LONG_KEY_TIME)   // 如果按键时间超过 设定的长按时间（LONG_KEY_TIME*10ms=300*10ms=3000ms）, 则判定为 长按
                {
                    key_return = KEY_LONG;         // 返回 有效键值值：长按
                    key_state = KEY_STATE_3;    // 去状态3，等待按键释放
                }
            }
            break;
        case KEY_STATE_3:                         // 等待按键释放
            if (key_press)
            {
                key_state = KEY_STATE_0;          // 按键释放后，进入 按键状态0 ，进行下一次按键的判定
            }
            break;
        default:                                // 特殊情况：key_state是其他值得情况，清零key_state。这种情况一般出现在 没有初始化key_state，第一次执行这个函数的时候
            key_state = KEY_STATE_0;
            break;
    }
    return key_return;                         // 返回 按键值
}
// ----------------------------------- key_read --------------------------------
void key_read(void)
{
    static unsigned char key_state1 = 0, key_time1 = 0;
    unsigned char key_return, key_temp;
    key_return = KEY_NONE;                         // 清零 返回按键值
    key_temp = key_driver();                    // 读取键值
    switch (key_state1)
    {
        case KEY_STATE_0:                           // 按键状态0：等待有效按键（通过 key_driver 返回的有效按键值）
            if (key_temp == KEY_SHORT)             // 如果是[单击]，不马上返回单击按键值，先进入 按键状态1，判断是否有[双击]的可能
            {
                key_time1 = 0;                                 // 清零计时
                key_state1 = KEY_STATE_1;
            }
            else                                        // 如果不是[单击]，直接返回按键值。这里的按键值可能是：[长按]，[无效按键]
            {
                key_return = key_temp;                     // 返回 按键值
            }
            break;
        case KEY_STATE_1:                       // 按键状态1：判定是否有[双击]
            if (key_temp == KEY_SHORT)            // 有[单击]后，如果在 设定的时间间隔（KEY_INTERVAL*10ms=30*10ms=300ms） 内，再次有[单击]，则为[双击]，但是不马上返回 有效按键值为[双击]，先进入 按键状态2，判断是否有[三击]
            {
                key_return = KEY_DOUBLE;            // 返回 有效按键：[双击]
                key_state1 = KEY_STATE_0;      // 返回 按键状态0，等待新的有效按键
            }
            else                                // 有[单击]后，如果在 设定的时间间隔（KEY_INTERVAL*10ms=30*10ms=300ms）内，没有[单击]出现，则判定为 [单击]
            {
                key_time1++;                    // 计数 时间间隔
                if (key_time1 >= KEY_INTERVAL)   // 超过 时间间隔
                {
                    key_return = KEY_SHORT;       // 返回 有效按键：[单击]
                    key_state1 = KEY_STATE_0; // 返回 按键状态0，等待新的有效按键
                }
            }
            break;
        default:                                // 特殊情况：key_state是其他值得情况，清零key_state。这种情况一般出现在 没有初始化key_state，第一次执行这个函数的时候
            key_state1 = KEY_STATE_0;
            break;
    }
    return key_return;                        // 返回 按键值
}

使用注意：

1）硬件：按键的一端接地（GND），另一端接IO口。IO为输入，一定要有上拉电阻。 
2）定时器：这里为了精确的定时，所以使用了定时器，定时器的时间是10ms。 
3）扫描周期：调用此函数时，一定确保”扫描周期“要小于10ms。不然按键内所涉及的时间就会不准，会偏大。所涉及的时间包括消抖时长，按键长按时长等。 
扫描周期定义：从 第一次进入按键扫描程序 开始，到第二次进入按键扫描程序时 结束，之间所用的时间。 
测量扫描周期的方法：可以在按键扫描程序的第一句，添加IO口取反函数，然后用示波器查看改IO口，其IO口周期的一般就是扫描周期了。 
4）特别注意以上程序的3个关于时间的宏，相当的重要。如果想更改按键的单击的灵敏度，双击的速度，或者长按的时间，只需要修改这些宏的值即可。 
比如：针对于老人的使用的按键，就需要将双击的速度调节的慢一点，就可以将KEY_INTERVAL的值增大。 
SINGLE_KEY_TIME：单击的灵敏度，值越小，越灵敏。 
KEY_INTERVAL ：双击的点击速度，修改这个值，值越小，速度越快。同时这个值也决定了单击的响应时间，因为单击之后，还需要判断在这个时间间隔内没有第二次单击，如果没有才是真正的单击，所以单击响应的时间为：SINGLE_KEY_TIME+KEY_INTERVAL； 
LONG_KEY_TIME ：长按的时间，修改这个即可，值越大，时间越长。

4.按键程序的使用实例

这里以C51位硬件平台进行实例讲解 
1）实例程序的功能： 
单击：点亮LED1 
双击：熄灭LED1 
长按：熄灭LED1 
2）硬件： 
按键IO：P1.0 
LED1 ：P2.0 
以下是 main.c 源代码:

// =========================== key.c ======================
#include "reg51.h"
#include "key.c"
sbit LED1 = P2.0;                   // 定义LEDIO口
unsigned char g_u8_KeyValue;        // 按键值
unsigned char g_flag_10ms_key;      // 10ms 计时标志
void key_read();                    // 声明读取按键函数
void T0_Init_10ms(void)             // timer0，初始化函数 ，定时时间为 10ms
{
    TMOD |= 0x01;
    TH0 = (65535 - 10000)/256;
    TL0 = (65535 - 10000)%256;
    ET0 = 1;
    TR0 = 1;
    EA = 1;
}
// 主函数
void main(void)
{
    P1.0 = 1;                                   // P1.0 拉高
    T0_Init_10ms();                             // 定时器0，初始化，定时10ms
    while(1)
    {
        if(g_flag_10ms_key)                     // 等待10ms,定时完成
        {
            g_flag_10ms_key = 0;                // 清零10ms定时标志
            g_u8_KeyValue = key_read();         // 读取按键值
            switch(g_u8_KeyValue)
            {
                case S_Key: LED1 = 1; break;    // 单击 点亮LED1
                case D_Key: LED1 = 0; break;    // 单击 熄灭LED1
                case L_Key: LED1 = 0; break;    // 长按 熄灭LED1
            }
        }
    }
}
// timer0 中断服务程序
void IRQ_T0(void) interrupt 1
{
    g_flag_10ms_key = 1;                        // 置位 10ms 定时标志
}

---

回到顶部

三、 [三击]程序

1.三击介绍

三击判定：在完成第一次【单击】之后，在一定的时间间隔内（本程序使用的是300ms），接着完成第二次【单击】,时间间隔重新计时，然后又在这个时间间隔内，完成第三次【单击】，及判定为【三击】。 
注：【单击】是包括按下和释放按键的过程，判定方式沿用上文所说的，如果忘了，可以参考上文。 
三击响应时序图 

注： 
T1：是单击判定的时间，范围：30ms < T1 < 3000ms。 
T2：是判定双击的时间间隔，是个定值 300ms。这个时间间隔的计算，是从第一次【单击】释放后开始计时，直到第二次【单击】释放按键后结束。在完成第一次【单击】后（释放按键后开始计时），在这个时间间隔内，如果再一次完成【单击】 
T3：是判定三击的时间间隔，双击之后，在这个时间内，再一次有【单击】，击判定为【三击】。其实质与T2一样。

2.按键程序结果

按键程序结构可以分为三个部分： 
第一部分：判断有无单击按键； 
第二部分：判断双击，即是在预设的时间间隔内，有无第二次【单击】； 
第三部分：判断三击，即是在【双击】后，在预设的时间间隔内，有无再一次的【单击】。

3.三击程序的源代码以及注释

程序的注释写的很详细，应该是可以读懂的，如果有疑问可以留言讨论。 
以下是key.c 的源代码：

#define KEY_INPUT P1.0 // 按键IO
#define KEY_STATE_0 0 // 按键状态
#define KEY_STATE_1 1
#define KEY_STATE_2 2
#define KEY_STATE_3 3
#define SINGLE_KEY_TIME 3 // SINGLE_KEY_TIME*10MS = 30MS 判定单击的时间长度，软件消抖
#define KEY_INTERVAL 30 // KEY_INTERVAL*10MS = 300MS 判定双击的时间间隔
#define LONG_KEY_TIME 300 // LONG_KEY_TIME*10MS = 3S 判定长按的时间长度
#define N_KEY 0 // no click
#define S_KEY 1 // single click
#define D_KEY 2 // double click
#define T_KEY 3 // Triple click
#define L_KEY 10 // long press
// ----------------------------------- key_driver --------------------------
unsigned char key_driver(void)
{
    static unsigned char key_state = 0;
    static unsigned int key_time = 0;
    unsigned char key_press, key_return;
    key_return = N_KEY;                         // 清除 返回按键值
    key_press = KEY_INPUT;                      // 读取当前键值
    switch (key_state)
    {
        case KEY_STATE_0:                       // 按键状态0：判断有无按键按下
            if (!key_press)                     // 有按键按下
            {
                key_time = 0;                   // 清零时间间隔计数
                key_state = KEY_STATE_1;        // 然后进入 按键状态1
            }
            break;
        case KEY_STATE_1:                       // 按键状态1：软件消抖（确定按键是否有效，而不是误触）。按键有效的定义：按键持续按下超过设定的消抖时间。
            if (!key_press)
            {
                key_time++;                     // 一次10ms
                if (key_time >= SINGLE_KEY_TIME)   // 消抖时间为：SINGLE_KEY_TIME*10ms = 30ms;
                {
                    key_state = KEY_STATE_2;    // 如果按键时间超过 消抖时间，即判定为按下的按键有效。按键有效包括两种：单击或者长按，进入 按键状态2， 继续判定到底是那种有效按键
                }
            }
            else
                key_state = KEY_STATE_0;       // 如果按键时间没有超过，判定为误触，按键无效，返回 按键状态0，继续等待按键
            break;
        case KEY_STATE_2:                       // 按键状态2：判定按键有效的种类：是单击，还是长按
            if (key_press)                       // 如果按键在 设定的长按时间 内释放，则判定为单击
            {
                key_return = S_KEY;            // 返回 有效按键值：单击
                key_state = KEY_STATE_0;       // 返回 按键状态0，继续等待按键
            }
            else
            {
                key_time++;
                if (key_time >= LONG_KEY_TIME)   // 如果按键时间超过 设定的长按时间（LONG_KEY_TIME*10ms=300*10ms=3000ms）, 则判定为 长按
                {
                    key_return = L_KEY;         // 返回 有效键值值：长按
                    key_state = KEY_STATE_3;    // 去状态3，等待按键释放
                }
            }
            break;
        case KEY_STATE_3:                         // 等待按键释放
            if (key_press)
            {
                key_state = KEY_STATE_0;          // 按键释放后，进入 按键状态0 ，进行下一次按键的判定
            }
            break;
        default:                                // 特殊情况：key_state是其他值得情况，清零key_state。这种情况一般出现在 没有初始化key_state，第一次执行这个函数的时候
            key_state = KEY_STATE_0;
            break;
    }
    return key_return;                         // 返回 按键值
}
void key_read(void)
{
    static unsigned char key_state1 = 0, key_time1 = 0;
    unsigned char key_return, key_temp;
    key_return = N_KEY;                         // 清零 返回按键值
    key_temp = key_driver();                    // 读取键值
    switch (key_state1)
    {
        case KEY_STATE_0:                       // 按键状态0：等待有效按键（通过 key_driver 返回的有效按键值）
            if (key_temp == S_KEY)             // 如果是[单击]，不马上返回单击按键值，先进入 按键状态1，判断是否有[双击]的可能
            {
                key_time1 = 0;                 // 清零计时
                key_state1 = KEY_STATE_1;
            }
            else                                // 如果不是[单击]，直接返回按键值。这里的按键值可能是：[长按]，[无效按键]
            {
                key_return = key_temp;         // 返回 按键值
            }
            break;
        case KEY_STATE_1:                       // 按键状态1：判定是否有[双击]
            if (key_temp == S_KEY)            // 有[单击]后，如果在 设定的时间间隔（KEY_INTERVAL*10ms=30*10ms=300ms） 内，再次有[单击]，则为[双击]，但是不马上返回 有效按键值为[双击]，先进入 按键状态2，判断是否有[三击]
            {
                key_time1 = 0;                  // 清零 时间间隔
                key_state1 = KEY_STATE_2;       // 改变 按键状态值
            }
            else                                // 有[单击]后，如果在 设定的时间间隔（KEY_INTERVAL*10ms=30*10ms=300ms）内，没有[单击]出现，则判定为 [单击]
            {
                key_time1++;                    // 计数 时间间隔
                if (key_time1 >= KEY_INTERVAL)   // 超过 时间间隔
                {
                    key_return = S_KEY;         // 返回 有效按键：[单击]
                    key_state1 = KEY_STATE_0;   // 返回 按键状态0，等待新的有效按键
                }
            }
            break;
        case KEY_STATE_2:                       // 按键状态2：判定是否有[三击]
            if (key_temp == S_KEY)              // 有[双击]后，如果在 设定的时间间隔（KEY_INTERVAL*10ms=30*10ms=300ms） 内，再次有[单击]，则为[三击]，由于这里只扩展到[三击]，所以马上返回 有效按键值为[三击]
            {
                key_return = T_KEY;            // 返回 有效按键：[三击]
                key_state1 = KEY_STATE_0;      // 返回 按键状态0，等待新的有效按键
            }
            else                                // 有[双击]后，如果在 设定的时间间隔（KEY_INTERVAL*10ms=30*10ms=300ms）内，没有[单击]，则判定为 [双击]
            {
                key_time1++;                    // 计数 时间间隔
                if (key_time1 >= KEY_INTERVAL)   // 超过 时间间隔
                {
                    key_return = D_KEY;       // 返回 有效按键：[双击]
                    key_state1 = KEY_STATE_0; // 返回 按键状态0，等待新的有效按键
                }
            }
            break;
        default:                                // 特殊情况：key_state是其他值得情况，清零key_state。这种情况一般出现在 没有初始化key_state，第一次执行这个函数的时候
            key_state1 = KEY_STATE_0;
            break;
    }
    return key_return;                        // 返回 按键值
}

使用注意：

1）硬件：按键的一端接地（GND），另一端接IO口。IO为输入，一定要有上拉电阻。 
2）定时器：这里为了精确的定时，所以使用了定时器，定时器的时间是10ms。 
3）扫描周期：调用此函数时，一定确保”扫描周期“要小于10ms。不然按键内所涉及的时间就会不准，会偏大。所涉及的时间包括消抖时长，按键长按时长等。 
扫描周期定义：从 第一次进入按键扫描程序 开始，到第二次进入按键扫描程序时 结束，之间所用的时间。 
测量扫描周期的方法：可以在按键扫描程序的第一句，添加IO口取反函数，然后用示波器查看改IO口，其IO口周期的一般就是扫描周期了。 
4）特别注意以上程序的3个关于时间的宏，相当的重要。如果想更改按键的单击的灵敏度，双击(三击)的速度，或者长按的时间，只需要修改这些宏的值即可。 
比如：针对于老人的使用的按键，就需要将双击的速度调节的慢一点，就可以将KEY_INTERVAL的值增大。

SINGLE_KEY_TIME：单击的灵敏度，值越小，越灵敏。 
KEY_INTERVAL ：双击的点击速度，修改这个值，值越小，速度越快。同时这个值也决定了单击的响应时间，因为单击之后，还需要判断在这个时间间隔内没有第二次单击，如果没有才是真正的单击，所以单击响应的时间为：SINGLE_KEY_TIME+KEY_INTERVAL； 
LONG_KEY_TIME ：长按的时间，修改这个即可，值越大，时间越长。