## 前言
/ _0 X  u' x  ~% I0 |# |
' l/ e0 {+ H; y- d( v3 M正好工作中用到按键处理，需要处理单击、长按等按键事件，然后就造了这么一个轮子，为了以后更方便地加入其它的项目中使用，遂将其开源到 GitHub 中。
% z4 k' a1 @' |' I% u# j* A) Y
后面发现 RT-Thread 软件包里也有一个开源的按键库 [MultiButton](http://github.com/liu2guang/MultiButton)，看到这个按键库的时候，心想，完了，又重复造轮子了，好伤心 :joy:。想想，既然按键处理方式不同，而且时间已经花出去了，那就把轮子圆一圆，放到 GitHub 中，给有缘人用吧，然后就有了这个不太圆的轮子 [FlexibleButton](http://github.com/zhaojuntao/FlexibleButton)。
. D& B" d! E/ F0 k8 V$ X
  |; C! |8 u& X$ h& P## 概述
: j. y& R2 |0 |: m& V7 q/ B& l, J5 E
2 ~$ s7 z: h2 s! \FlexibleButton 是一个基于 C 语言的小巧灵活的按键处理库。该按键库解耦了具体的按键硬件结构，理论上支持轻触按键与自锁按键，并可以无限扩展按键数量。另外，FlexibleButton 使用扫描的方式一次性读取所有所有的按键状态，然后通过事件回调机制上报按键事件。

该按键库使用 C 语言编写，驱动与应用程序解耦，便于灵活应用，比如用户可以方便地在应用层增加按键中断、处理按键功耗、定义按键事件处理方式，而无需修改 FlexibleButton 库中的代码。
/ y+ }. i: t; K6 [2 w$ D
  C* e& m2 _0 O另外，使用 C 语言标准库 API 编写，也使得该按键库可以无缝兼容任意的处理器平台，并且支持任意 OS 和 non-OS（裸机程序）。

另外，该按键库核心的按键扫描代码仅有三行，没错，就是经典的**三行按键扫描算法**，出自哪位大神之手就无从得知了，也欢迎知道此高人的读者文后留言哈。算法介绍可以去搜索引擎里查找，这里就不作介绍了。
9 @8 G% _, e% x1 {3 i  K8 K- }" @& x
## 获取

5 C  H) q9 u8 A! M6 e% r3 p& y. V```SHELL
8 K3 w) l- ~- n! h7 g2 Bgit clone http://github.com/zhaojuntao/FlexibleButton.git
$ k- _& D2 K) ]5 ~  B4 Z8 y; D```
. c/ Z+ ?$ J6 u+ `( b& S
## 测试
* M, N$ p) ^% p/ I2 I* I
) r# f$ o. ~5 J6 _1 _FlexibleButton 库中提供了一个 DEMO `flexible_button_demo.c`，这里基于 RT-Thread OS 进行测试，当然你可以选择使用其他的 OS，或者使用裸机测试，只需要移除 OS 相关的特性即可。

6 L7 V, {1 N) _8 Z& a4 s将 FlexibleButton 库放到 RT-Thread BSP 下即可使用 scons 进行编译构建。

## DEMO 程序说明
5 R" `4 b9 d- \: f
. ^) P5 S! O: m. }( R, t! s$ D### 程序入口
+ C% N- {; a. B7 f+ `/ S
```C
int flex_button_main(void)
{
    rt_thread_t tid = RT_NULL;
, J  n6 |6 b0 q( ]% m6 @    user_button_init();
    /* Create background ticks thread */
& P& ~  u* g8 u# u% E3 \- C    tid = rt_thread_create("flex_btn", button_scan, RT_NULL, 1024, 10, 10);
# ?) b6 i- Q0 H9 F    if(tid != RT_NULL)
    {
- g4 d" e8 B" K; ^- N        rt_thread_startup(tid);
# F  M2 V" F% g4 F; }  v    }
    return 0;
}
INIT_APP_EXPORT(flex_button_main);
. l) {$ Y" E* ?" w6 y: ^```

( N, o. L) e' M+ }如上所示，首先使用 `user_button_init();` 初始化用户按键硬件，并挂载到 FlexibleButton库。然后，使用了 RT-Thread 的 `INIT_APP_EXPORT` 接口导出为上电自动初始化，创建了一个 “flex_btn” 名字的按键扫描线程，线程里扫描检查按键事件。
& r! n8 [8 J+ k7 l9 m7 d
### 用户初始化代码
6 {* u, }2 _4 Y" T0 {' \7 |
`user_button_init();` 初始化代码如下所示：
! K6 l0 D; q7 H0 P' b, I2 |
```C
1 k( k4 x1 n+ R5 hstatic void user_button_init(void)
{
- }2 a% M" A& H+ f) P, x  B1 w    int i;
  o5 w' U# g& ^3 U" a    rt_memset(&user_button[0], 0x0, sizeof(user_button));
    user_button[USER_BUTTON_0].usr_button_read = button_key0_read;
    user_button[USER_BUTTON_0].cb = (flex_button_response_callback)btn_0_cb;
    user_button[USER_BUTTON_1].usr_button_read = button_key1_read;
' D2 f- G$ A3 E" j0 x    user_button[USER_BUTTON_1].cb = (flex_button_response_callback)btn_1_cb;
% q5 ~0 \! F  c5 A. \. n6 e    user_button[USER_BUTTON_2].usr_button_read = button_key2_read;
    user_button[USER_BUTTON_3].usr_button_read = button_keywkup_read;
  ~6 ^% R2 f1 D( F    rt_pin_mode(PIN_KEY0, PIN_MODE_INPUT); /* set KEY pin mode to input */
: b  G" R; g) O    rt_pin_mode(PIN_KEY1, PIN_MODE_INPUT); /* set KEY pin mode to input */
* t! n+ T" ~3 M( j. ]5 C: P    rt_pin_mode(PIN_KEY2, PIN_MODE_INPUT); /* set KEY pin mode to input */
    rt_pin_mode(PIN_WK_UP, PIN_MODE_INPUT); /* set KEY pin mode to input */
# T# j9 z9 s' ^# i- M    for (i = 0; i < USER_BUTTON_MAX; i ++)
" |8 i; e" }8 m. f    {
        user_button.status = 0;
' V+ r8 E/ J( u  U0 h8 d+ ?7 |        user_button.pressed_logic_level = 0;
        user_button.click_start_tick = 20;
        user_button.short_press_start_tick = 100;
        user_button.long_press_start_tick = 200;
        user_button.long_hold_start_tick = 300;
        if (i == USER_BUTTON_3)
& f7 `8 \, s  n* r/ M        {
            user_button[USER_BUTTON_3].pressed_logic_level = 1;
        }
, C7 a$ E( j: Y+ t        flex_button_register(&user_button);
    }
}
9 C0 g3 g. X4 ~5 D' R$ z```

) b: R6 E# `2 V2 g `user_button_init();` 主要用于初始化按键硬件，设置按键长按和短按的 tick 数（RT-Thread上面默认一个 tick 为 1ms），然后注册按键到 FlexibleButton 库。

2 p  ^7 J8 m" [. p5 I4 N7 d# v8 _% |4 @' H### 事件处理代码
- _: [+ K% S" V9 a. p+ p6 f; \
- d; K7 }1 O/ t6 Y/ |```C
static void btn_0_cb(flex_button_t *btn)
8 e4 s# k9 c' C' R8 J& R1 }6 h{
    rt_kprintf("btn_0_cb\n");
    switch (btn->event)
    {
4 Z) T! F( ]% w; `        case FLEX_BTN_PRESS_DOWN:
$ u$ @* B# x' M7 R) A! [            rt_kprintf("btn_0_cb [FLEX_BTN_PRESS_DOWN]\n");
            break;
        case FLEX_BTN_PRESS_CLICK:
- x+ m  o/ s0 `4 K/ Y+ U3 O            rt_kprintf("btn_0_cb [FLEX_BTN_PRESS_CLICK]\n");
/ [& V/ n6 A0 \: v) @* p            break;
        case FLEX_BTN_PRESS_DOUBLE_CLICK:
5 G; u7 g/ v; e% w+ \3 \- |            rt_kprintf("btn_0_cb [FLEX_BTN_PRESS_DOUBLE_CLICK]\n");
            break;
        case FLEX_BTN_PRESS_SHORT_START:
2 S" g. M( e6 s+ ]            rt_kprintf("btn_0_cb [FLEX_BTN_PRESS_SHORT_START]\n");
2 S* K# O+ c' C- B+ B9 X2 T            break;
        case FLEX_BTN_PRESS_SHORT_UP:
! Z4 L; |3 \! G! n            rt_kprintf("btn_0_cb [FLEX_BTN_PRESS_SHORT_UP]\n");
* u, f- }+ c) `% k            break;
. r( t$ U6 q7 F9 A( j! K5 i        case FLEX_BTN_PRESS_LONG_START:
            rt_kprintf("btn_0_cb [FLEX_BTN_PRESS_LONG_START]\n");
. B* Q% r5 Q1 ]' C) y            break;
        case FLEX_BTN_PRESS_LONG_UP:
            rt_kprintf("btn_0_cb [FLEX_BTN_PRESS_LONG_UP]\n");
3 J+ k' @& u! ]; i4 V$ M$ ?            break;
) b& x7 n% t; f# \1 E- J9 t/ _        case FLEX_BTN_PRESS_LONG_HOLD:
            rt_kprintf("btn_0_cb [FLEX_BTN_PRESS_LONG_HOLD]\n");
            break;
, ]( t, y6 U8 f! j        case FLEX_BTN_PRESS_LONG_HOLD_UP:
            rt_kprintf("btn_0_cb [FLEX_BTN_PRESS_LONG_HOLD_UP]\n");
            break;
1 i6 @& C/ X) j& M, L    }
  `( ]# g9 [; |5 _  J4 u}
9 n, X. [2 ]' d# \+ Z) S  }```
& E" @+ ]  m, P6 S; j* N9 Z
## FlexibleButton 代码说明

### 按键事件定义

按键事件的定义并没有使用 Windows 驱动上的定义，主要是方便嵌入式设备中的应用场景（也可能是我理解的偏差），按键事件定义如下：

```C
typedef enum
' s( q" c) q+ Q% i. P9 Z{
% M  ^- ?, |$ U    FLEX_BTN_PRESS_DOWN = 0,        // 按下事件
    FLEX_BTN_PRESS_CLICK,           // 单击事件
    FLEX_BTN_PRESS_DOUBLE_CLICK,    // 双击事件
7 `+ f# c& i2 i6 S; @5 S1 w    FLEX_BTN_PRESS_SHORT_START,     // 短按开始事件
; d7 T0 N9 J( m# p" r    FLEX_BTN_PRESS_SHORT_UP,        // 短按抬起事件
' {3 n, c; a4 b, S1 i4 r6 b    FLEX_BTN_PRESS_LONG_START,      // 长按开始事件
    FLEX_BTN_PRESS_LONG_UP,         // 长按抬起事件
8 H$ V. T8 T. S* s$ d* y% r    FLEX_BTN_PRESS_LONG_HOLD,       // 长按保持事件
0 j1 y; \, ~) x: I1 B/ {    FLEX_BTN_PRESS_LONG_HOLD_UP,    // 长按保持的抬起事件
    FLEX_BTN_PRESS_MAX,
# S: d, j7 {7 P# O2 E. j5 K    FLEX_BTN_PRESS_NONE,
' p- x$ g# F! L# o} flex_button_event_t;
/ e7 @' s* k: a```

$ i* e# h: ^' N4 |% \2 U5 ~### 按键注册接口
  l1 t! L/ O) k, S
使用该接口注册一个用户按键，入参为一个 flex_button_t 结构体实例的地址。
  e0 d, r( ?0 ^, ~- n
```C
int8_t flex_button_register(flex_button_t *button);
5 R/ Q' I# X9 h  X: N) p```

### 按键事件读取接口
9 |/ i5 ?# Y, g
使用该接口获取指定按键的事件。
4 u9 Z$ _# J; D
  y# @0 }4 H: a5 r```C
4 [0 P& c" m6 D7 f/ i4 Hflex_button_event_t flex_button_event_read(flex_button_t* button);
* P1 Y. E% _( k) y5 {````
6 n  j5 s9 `  [) r4 D
### 按键扫描接口

按键扫描的核心函数，需要放到应用程序中定时扫描间隔 5-20ms 即可。

! `/ q% @$ @+ k! M```C
5 N1 G" i4 s& S% W( P, ovoid flex_button_scan(void);
```
" i+ G- y) l/ v+ W$ ?- p
4 [4 V, P) x0 ^8 _## 问题和建议

如果您在应用的时候遇到了问题，或者有好的想法和建议，欢迎到这个 [issue](http://github.com/zhaojuntao/FlexibleButton/issues/1) 上讨论，谢谢。
. j6 S' B. V) K# P3 `
1 A( u" a2 X( r' u# ?

编辑器不支持 markdown 格式