单片机---多功能按键处理

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

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

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

正文：

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

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

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

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

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

首先看一张时序图：

注：

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

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

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

2. 按键程序的架构

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

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

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

  1. #define KEY_INPUT P1.0 //按键IO
  3. #define KEY_STATE_0 0 //按键状态
  4. #define KEY_STATE_1 1
  5. #define KEY_STATE_2 2
  6. #define KEY_STATE_3 3
  8. #define LONG_KEY_TIME 300 //LONG_KEY_TIME*10MS = 3S
  9. #define SINGLE_KEY_TIME 3 //SINGLE_KEY_TIME*10MS = 30MS
  11. #define KEY_NONE 0     //no click
  12. #define KEY_SHORT 1     //single click
  13. #define KEY_LONG 10     //long press
  15. //10MS
  16. void key_driver(void)
  17. {
  18.     static char key_state;                          //按键状态变量
  19.     static int key_time;                            //按键计时变量
  20.     char key_press, key_return;
  22.     key_return = KEY_NONE;        // 清除 返回按键值
  23.     key_press = KEY_INPUT;    // 读取当前键值
  25.     switch (key_state)
  26.     {
  27.         case KEY_STATE_0:                       // 按键状态0：判断有无按键按下
  28.             if (!key_press)                     // 有按键按下
  29.             {
  30.                 key_time = 0;                   // 清零时间间隔计数
  31.                 key_state = KEY_STATE_1;        // 然后进入 按键状态1
  32.             }
  33.             break;
  35.         case KEY_STATE_1:                       // 按键状态1：软件消抖（确定按键是否有效，而不是误触）。按键有效的定义：按键持续按下超过设定的消抖时间。
  36.             if (!key_press)
  37.             {
  38.                 key_time++;                     // 一次10ms
  39.                 if (key_time >= SINGLE_KEY_TIME)   // 消抖时间为：SINGLE_KEY_TIME*10ms = 30ms;
  40.                 {
  41.                     key_state = KEY_STATE_2;    // 如果按键时间超过 消抖时间，即判定为按下的按键有效。按键有效包括两种：单击或者长按，进入 按键状态2， 继续判定到底是那种有效按键
  42.                 }
  43.             }
  44.             else
  45.                 key_state = KEY_STATE_0;       // 如果按键时间没有超过，判定为误触，按键无效，返回 按键状态0，继续等待按键
  46.             break;
  48.         case KEY_STATE_2:                       // 按键状态2：判定按键有效的种类：是单击，还是长按
  49.             if (key_press)                       // 如果按键在 设定的长按时间 内释放，则判定为单击
  50.             {
  51.                 key_return = KEY_SHORT;        // 返回 有效按键值：单击
  52.                 key_state = KEY_STATE_0;       // 返回 按键状态0，继续等待按键
  53.             }
  54.             else
  55.             {
  56.                 key_time++;
  58.                 if (key_time >= LONG_KEY_TIME)   // 如果按键时间超过 设定的长按时间（LONG_KEY_TIME*10ms=200*10ms=2000ms）, 则判定为 长按
  59.                 {
  60.                     key_return = KEY_LONG;         // 返回 有效键值值：长按
  61.                     key_state = KEY_STATE_3;    // 去状态3，等待按键释放
  62.                 }
  63.             }
  64.             break;
  66.         case KEY_STATE_3:                         // 等待按键释放
  67.             if (key_press)
  68.             {
  69.                 key_state = KEY_STATE_0;          // 按键释放后，进入 按键状态0 ，进行下一次按键的判定
  70.             }
  71.             break;
  73.         default:                                // 特殊情况：key_state是其他值得情况，清零key_state。这种情况一般出现在 没有初始化key_state，第一次执行这个函数的时候
  74.             key_state = KEY_STATE_0;
  75.             break;
  76.     }
  77.     return key_return;              // 返回 按键值
  78. }

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

4. 按键程序的使用实例

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

  1. #include "reg51.h"
  2. #include "key.c"
  4. sbit LED1 = P2.0;       //定义LEDIO口
  6. unsigned char g_u8_KeyValue;        //按键值
  7. unsigned char g_flag_10ms_key;      //10ms 计时标志
  10. //timer0，初始化函数 ，定时时间为 10ms
  11. void T0_Init_10ms(void)
  12. {
  13.     TMOD |= 0x01;
  14.     TH0 = (65535 - 10000)/256;
  15.     TL0 = (65535 - 10000)%256;
  17.     ET0 = 1;
  18.     TR0 = 1;
  19.     EA = 1;
  20. }
  22. //主函数
  23. void main(void)
  24. {
  25.     P1.0 = 1;           //P1.0 拉高
  26.     T0_Init_10ms();     //定时器0，初始化，定时10ms
  28.     while(1)
  29.     {
  30.         if(g_flag_10ms_key)                     //等待10ms,定时完成
  31.         {
  32.             g_flag_10ms_key = 0;                //清零10ms定时标志
  34.             g_u8_KeyValue = key_driver();       //读取按键值
  36.             switch(g_u8_KeyValue)
  37.             {
  38.                 case S_Key: LED1 = 1; break;    //单击 点亮LED1
  39.                 case L_Key: LED1 = 1; break;    //长按 熄灭LED1
  40.             }
  42.         }
  43.     }
  44. }
  46. //timer0 中断服务程序
  47. void IRQ_T0(void) interrupt 1
  48. {
  49.     g_flag_10ms_key = 1;                        //置位 10ms 定时标志
  50. }

二、 [双击]程序

1.双击介绍

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

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

2.按键程结构

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

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

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

  1. #define KEY_INPUT P1.0 // 按键IO
  3. #define KEY_STATE_0 0 // 按键状态
  4. #define KEY_STATE_1 1
  5. #define KEY_STATE_2 2
  6. #define KEY_STATE_3 3
  8. #define SINGLE_KEY_TIME 3 // SINGLE_KEY_TIME*10MS = 30MS 判定单击的时间长度，软件消抖
  9. #define KEY_INTERVAL 30 // KEY_INTERVAL*10MS = 300MS 判定双击的时间间隔
  10. #define LONG_KEY_TIME 300 // LONG_KEY_TIME*10MS = 3S 判定长按的时间长度
  12. #define KEY_NONE 0     // no click
  13. #define KEY_SHORT 1     // single click
  14. #define KEY_DOUBLE 2     // double click
  15. #define KEY_LONG 10     // long press
  17. // ----------------------------------- key_driver --------------------------
  18. unsigned char key_driver(void)
  19. {
  20.     static unsigned char key_state = 0;
  21.     static unsigned int key_time = 0;
  22.     unsigned char key_press, key_return;
  24.     key_return = KEY_NONE;                         // 清除 返回按键值
  25.     key_press = KEY_INPUT;                          // 读取当前键值
  27.     switch (key_state)
  28.     {
  29.         case KEY_STATE_0:                       // 按键状态0：判断有无按键按下
  30.             if (!key_press)                         // 有按键按下
  31.             {
  32.                 key_time = 0;                          // 清零时间间隔计数
  33.                 key_state = KEY_STATE_1;            // 然后进入 按键状态1
  34.             }
  35.             break;
  37.         case KEY_STATE_1:                       // 按键状态1：软件消抖（确定按键是否有效，而不是误触）。按键有效的定义：按键持续按下超过设定的消抖时间。
  38.             if (!key_press)
  39.             {
  40.                 key_time++;                             // 一次10ms
  41.                 if (key_time >= SINGLE_KEY_TIME)   // 消抖时间为：SINGLE_KEY_TIME*10ms = 30ms;
  42.                 {
  43.                     key_state = KEY_STATE_2;    // 如果按键时间超过 消抖时间，即判定为按下的按键有效。按键有效包括两种：单击或者长按，进入 按键状态2， 继续判定到底是那种有效按键
  44.                 }
  45.             }
  46.             else
  47.                 key_state = KEY_STATE_0;       // 如果按键时间没有超过，判定为误触，按键无效，返回 按键状态0，继续等待按键
  48.             break;
  50.         case KEY_STATE_2:                       // 按键状态2：判定按键有效的种类：是单击，还是长按
  51.             if (key_press)                       // 如果按键在 设定的长按时间 内释放，则判定为单击
  52.             {
  53.                 key_return = KEY_SHORT;            // 返回 有效按键值：单击
  54.                 key_state = KEY_STATE_0;       // 返回 按键状态0，继续等待按键
  55.             }
  56.             else
  57.             {
  58.                 key_time++;
  60.                 if (key_time >= LONG_KEY_TIME)   // 如果按键时间超过 设定的长按时间（LONG_KEY_TIME*10ms=300*10ms=3000ms）, 则判定为 长按
  61.                 {
  62.                     key_return = KEY_LONG;         // 返回 有效键值值：长按
  63.                     key_state = KEY_STATE_3;    // 去状态3，等待按键释放
  64.                 }
  65.             }
  66.             break;
  68.         case KEY_STATE_3:                         // 等待按键释放
  69.             if (key_press)
  70.             {
  71.                 key_state = KEY_STATE_0;          // 按键释放后，进入 按键状态0 ，进行下一次按键的判定
  72.             }
  73.             break;
  75.         default:                                // 特殊情况：key_state是其他值得情况，清零key_state。这种情况一般出现在 没有初始化key_state，第一次执行这个函数的时候
  76.             key_state = KEY_STATE_0;
  77.             break;
  78.     }
  80.     return key_return;                         // 返回 按键值
  81. }
  83. // ----------------------------------- key_read --------------------------------
  84. void key_read(void)
  85. {
  86.     static unsigned char key_state1 = 0, key_time1 = 0;
  87.     unsigned char key_return, key_temp;
  89.     key_return = KEY_NONE;                         // 清零 返回按键值
  90.     key_temp = key_driver();                    // 读取键值
  92.     switch (key_state1)
  93.     {
  94.         case KEY_STATE_0:                           // 按键状态0：等待有效按键（通过 key_driver 返回的有效按键值）
  95.             if (key_temp == KEY_SHORT)             // 如果是[单击]，不马上返回单击按键值，先进入 按键状态1，判断是否有[双击]的可能
  96.             {
  97.                 key_time1 = 0;                                 // 清零计时
  98.                 key_state1 = KEY_STATE_1;
  99.             }
  100.             else                                        // 如果不是[单击]，直接返回按键值。这里的按键值可能是：[长按]，[无效按键]
  101.             {
  102.                 key_return = key_temp;                     // 返回 按键值
  103.             }
  104.             break;
  106.         case KEY_STATE_1:                       // 按键状态1：判定是否有[双击]
  107.             if (key_temp == KEY_SHORT)            // 有[单击]后，如果在 设定的时间间隔（KEY_INTERVAL*10ms=30*10ms=300ms） 内，再次有[单击]，则为[双击]，但是不马上返回 有效按键值为[双击]，先进入 按键状态2，判断是否有[三击]
  108.             {
  109.                 key_return = KEY_DOUBLE;            // 返回 有效按键：[双击]
  110.                 key_state1 = KEY_STATE_0;      // 返回 按键状态0，等待新的有效按键
  111.             }
  112.             else                                // 有[单击]后，如果在 设定的时间间隔（KEY_INTERVAL*10ms=30*10ms=300ms）内，没有[单击]出现，则判定为 [单击]
  113.             {
  114.                 key_time1++;                    // 计数 时间间隔
  115.                 if (key_time1 >= KEY_INTERVAL)   // 超过 时间间隔
  116.                 {
  117.                     key_return = KEY_SHORT;       // 返回 有效按键：[单击]
  118.                     key_state1 = KEY_STATE_0; // 返回 按键状态0，等待新的有效按键
  119.                 }
  120.             }
  121.             break;
  123.         default:                                // 特殊情况：key_state是其他值得情况，清零key_state。这种情况一般出现在 没有初始化key_state，第一次执行这个函数的时候
  124.             key_state1 = KEY_STATE_0;
  125.             break;
  126.     }
  127.     return key_return;                        // 返回 按键值
  128. }

使用注意：

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 源代码:

  1. // =========================== key.c ======================
  3. #include "reg51.h"
  4. #include "key.c"
  6. sbit LED1 = P2.0;                   // 定义LEDIO口
  8. unsigned char g_u8_KeyValue;        // 按键值
  9. unsigned char g_flag_10ms_key;      // 10ms 计时标志
  12. void key_read();                    // 声明读取按键函数
  15. void T0_Init_10ms(void)             // timer0，初始化函数 ，定时时间为 10ms
  16. {
  17.     TMOD |= 0x01;
  18.     TH0 = (65535 - 10000)/256;
  19.     TL0 = (65535 - 10000)%256;
  21.     ET0 = 1;
  22.     TR0 = 1;
  23.     EA = 1;
  24. }
  26. // 主函数
  27. void main(void)
  28. {
  29.     P1.0 = 1;                                   // P1.0 拉高
  30.     T0_Init_10ms();                             // 定时器0，初始化，定时10ms
  32.     while(1)
  33.     {
  34.         if(g_flag_10ms_key)                     // 等待10ms,定时完成
  35.         {
  36.             g_flag_10ms_key = 0;                // 清零10ms定时标志
  38.             g_u8_KeyValue = key_read();         // 读取按键值
  40.             switch(g_u8_KeyValue)
  41.             {
  42.                 case S_Key: LED1 = 1; break;    // 单击 点亮LED1
  43.                 case D_Key: LED1 = 0; break;    // 单击 熄灭LED1
  44.                 case L_Key: LED1 = 0; break;    // 长按 熄灭LED1
  45.             }
  46.         }
  47.     }
  48. }
  50. // timer0 中断服务程序
  51. void IRQ_T0(void) interrupt 1
  52. {
  53.     g_flag_10ms_key = 1;                        // 置位 10ms 定时标志
  54. }

三、 [三击]程序

1.三击介绍

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

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

2.按键程序结果

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

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

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

  1. #define KEY_INPUT P1.0 // 按键IO
  3. #define KEY_STATE_0 0 // 按键状态
  4. #define KEY_STATE_1 1
  5. #define KEY_STATE_2 2
  6. #define KEY_STATE_3 3
  8. #define SINGLE_KEY_TIME 3 // SINGLE_KEY_TIME*10MS = 30MS 判定单击的时间长度，软件消抖
  9. #define KEY_INTERVAL 30 // KEY_INTERVAL*10MS = 300MS 判定双击的时间间隔
  10. #define LONG_KEY_TIME 300 // LONG_KEY_TIME*10MS = 3S 判定长按的时间长度
  12. #define N_KEY 0 // no click
  13. #define S_KEY 1 // single click
  14. #define D_KEY 2 // double click
  15. #define T_KEY 3 // Triple click
  16. #define L_KEY 10 // long press
  18. // ----------------------------------- key_driver --------------------------
  19. unsigned char key_driver(void)
  20. {
  21.     static unsigned char key_state = 0;
  22.     static unsigned int key_time = 0;
  23.     unsigned char key_press, key_return;
  25.     key_return = N_KEY;                         // 清除 返回按键值
  27.     key_press = KEY_INPUT;                      // 读取当前键值
  29.     switch (key_state)
  30.     {
  31.         case KEY_STATE_0:                       // 按键状态0：判断有无按键按下
  32.             if (!key_press)                     // 有按键按下
  33.             {
  34.                 key_time = 0;                   // 清零时间间隔计数
  35.                 key_state = KEY_STATE_1;        // 然后进入 按键状态1
  36.             }
  37.             break;
  39.         case KEY_STATE_1:                       // 按键状态1：软件消抖（确定按键是否有效，而不是误触）。按键有效的定义：按键持续按下超过设定的消抖时间。
  40.             if (!key_press)
  41.             {
  42.                 key_time++;                     // 一次10ms
  43.                 if (key_time >= SINGLE_KEY_TIME)   // 消抖时间为：SINGLE_KEY_TIME*10ms = 30ms;
  44.                 {
  45.                     key_state = KEY_STATE_2;    // 如果按键时间超过 消抖时间，即判定为按下的按键有效。按键有效包括两种：单击或者长按，进入 按键状态2， 继续判定到底是那种有效按键
  46.                 }
  47.             }
  48.             else
  49.                 key_state = KEY_STATE_0;       // 如果按键时间没有超过，判定为误触，按键无效，返回 按键状态0，继续等待按键
  50.             break;
  52.         case KEY_STATE_2:                       // 按键状态2：判定按键有效的种类：是单击，还是长按
  53.             if (key_press)                       // 如果按键在 设定的长按时间 内释放，则判定为单击
  54.             {
  55.                 key_return = S_KEY;            // 返回 有效按键值：单击
  56.                 key_state = KEY_STATE_0;       // 返回 按键状态0，继续等待按键
  57.             }
  58.             else
  59.             {
  60.                 key_time++;
  62.                 if (key_time >= LONG_KEY_TIME)   // 如果按键时间超过 设定的长按时间（LONG_KEY_TIME*10ms=300*10ms=3000ms）, 则判定为 长按
  63.                 {
  64.                     key_return = L_KEY;         // 返回 有效键值值：长按
  65.                     key_state = KEY_STATE_3;    // 去状态3，等待按键释放
  66.                 }
  67.             }
  68.             break;
  70.         case KEY_STATE_3:                         // 等待按键释放
  71.             if (key_press)
  72.             {
  73.                 key_state = KEY_STATE_0;          // 按键释放后，进入 按键状态0 ，进行下一次按键的判定
  74.             }
  75.             break;
  77.         default:                                // 特殊情况：key_state是其他值得情况，清零key_state。这种情况一般出现在 没有初始化key_state，第一次执行这个函数的时候
  78.             key_state = KEY_STATE_0;
  79.             break;
  80.     }
  82.     return key_return;                         // 返回 按键值
  83. }
  85. void key_read(void)
  86. {
  87.     static unsigned char key_state1 = 0, key_time1 = 0;
  88.     unsigned char key_return, key_temp;
  90.     key_return = N_KEY;                         // 清零 返回按键值
  91.     key_temp = key_driver();                    // 读取键值
  93.     switch (key_state1)
  94.     {
  95.         case KEY_STATE_0:                       // 按键状态0：等待有效按键（通过 key_driver 返回的有效按键值）
  96.             if (key_temp == S_KEY)             // 如果是[单击]，不马上返回单击按键值，先进入 按键状态1，判断是否有[双击]的可能
  97.             {
  98.                 key_time1 = 0;                 // 清零计时
  99.                 key_state1 = KEY_STATE_1;
  100.             }
  101.             else                                // 如果不是[单击]，直接返回按键值。这里的按键值可能是：[长按]，[无效按键]
  102.             {
  103.                 key_return = key_temp;         // 返回 按键值
  104.             }
  105.             break;
  107.         case KEY_STATE_1:                       // 按键状态1：判定是否有[双击]
  108.             if (key_temp == S_KEY)            // 有[单击]后，如果在 设定的时间间隔（KEY_INTERVAL*10ms=30*10ms=300ms） 内，再次有[单击]，则为[双击]，但是不马上返回 有效按键值为[双击]，先进入 按键状态2，判断是否有[三击]
  109.             {
  110.                 key_time1 = 0;                  // 清零 时间间隔
  111.                 key_state1 = KEY_STATE_2;       // 改变 按键状态值
  112.             }
  113.             else                                // 有[单击]后，如果在 设定的时间间隔（KEY_INTERVAL*10ms=30*10ms=300ms）内，没有[单击]出现，则判定为 [单击]
  114.             {
  115.                 key_time1++;                    // 计数 时间间隔
  116.                 if (key_time1 >= KEY_INTERVAL)   // 超过 时间间隔
  117.                 {
  118.                     key_return = S_KEY;         // 返回 有效按键：[单击]
  119.                     key_state1 = KEY_STATE_0;   // 返回 按键状态0，等待新的有效按键
  120.                 }
  121.             }
  122.             break;
  124.         case KEY_STATE_2:                       // 按键状态2：判定是否有[三击]
  125.             if (key_temp == S_KEY)              // 有[双击]后，如果在 设定的时间间隔（KEY_INTERVAL*10ms=30*10ms=300ms） 内，再次有[单击]，则为[三击]，由于这里只扩展到[三击]，所以马上返回 有效按键值为[三击]
  126.             {
  127.                 key_return = T_KEY;            // 返回 有效按键：[三击]
  128.                 key_state1 = KEY_STATE_0;      // 返回 按键状态0，等待新的有效按键
  129.             }
  130.             else                                // 有[双击]后，如果在 设定的时间间隔（KEY_INTERVAL*10ms=30*10ms=300ms）内，没有[单击]，则判定为 [双击]
  131.             {
  132.                 key_time1++;                    // 计数 时间间隔
  133.                 if (key_time1 >= KEY_INTERVAL)   // 超过 时间间隔
  134.                 {
  135.                     key_return = D_KEY;       // 返回 有效按键：[双击]
  136.                     key_state1 = KEY_STATE_0; // 返回 按键状态0，等待新的有效按键
  137.                 }
  138.             }
  139.             break;
  141.         default:                                // 特殊情况：key_state是其他值得情况，清零key_state。这种情况一般出现在 没有初始化key_state，第一次执行这个函数的时候
  142.             key_state1 = KEY_STATE_0;
  143.             break;
  144.     }
  146.     return key_return;                        // 返回 按键值
  147. }

使用注意：

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 ：长按的时间，修改这个即可，值越大，时间越长。





posted @ 2016-09-21 15:58  mcumagic  阅读(8187)  评论(2)  编辑  收藏  举报