: m0 |4 `: Z: s6 ~* d% i- t" a
## 前言
1 Z4 a0 N) S+ X
; {" m8 `3 i4 I正好工作中用到按键处理，需要处理单击、长按等按键事件，然后就造了这么一个轮子，为了以后更方便地加入其它的项目中使用，遂将其开源到 GitHub 中。
% q5 F) Q4 r" ]8 {& x0 \- [) Y; E
! i( t8 u" k9 Z4 I4 q' n9 o后面发现 RT-Thread 软件包里也有一个开源的按键库 [MultiButton](http://github.com/liu2guang/MultiButton)，看到这个按键库的时候，心想，完了，又重复造轮子了，好伤心 :joy:。想想，既然按键处理方式不同，而且时间已经花出去了，那就把轮子圆一圆，放到 GitHub 中，给有缘人用吧，然后就有了这个不太圆的轮子 [FlexibleButton](http://github.com/zhaojuntao/FlexibleButton)。

; e4 X$ o0 J! y( T; Y$ N" a## 概述
5 j4 v) H8 I- m  m% t! }: c
" ]4 f( A2 A$ y) y1 ^$ WFlexibleButton 是一个基于 C 语言的小巧灵活的按键处理库。该按键库解耦了具体的按键硬件结构，理论上支持轻触按键与自锁按键，并可以无限扩展按键数量。另外，FlexibleButton 使用扫描的方式一次性读取所有所有的按键状态，然后通过事件回调机制上报按键事件。

该按键库使用 C 语言编写，驱动与应用程序解耦，便于灵活应用，比如用户可以方便地在应用层增加按键中断、处理按键功耗、定义按键事件处理方式，而无需修改 FlexibleButton 库中的代码。

另外，使用 C 语言标准库 API 编写，也使得该按键库可以无缝兼容任意的处理器平台，并且支持任意 OS 和 non-OS（裸机程序）。
  t) Q+ B. }* K# D# }8 E  q! X
另外，该按键库核心的按键扫描代码仅有三行，没错，就是经典的**三行按键扫描算法**，出自哪位大神之手就无从得知了，也欢迎知道此高人的读者文后留言哈。算法介绍可以去搜索引擎里查找，这里就不作介绍了。
3 U+ J- M; g1 P  C, D* Z
## 获取
, Y) L: X& H5 t/ X3 d; n" s" p
```SHELL
git clone http://github.com/zhaojuntao/FlexibleButton.git
```
- ~  ]5 Z# r2 u9 f3 ?! u  K
## 测试
" e- R0 T, T2 n9 i/ S
) x- o$ ]# G7 L) t# DFlexibleButton 库中提供了一个 DEMO `flexible_button_demo.c`，这里基于 RT-Thread OS 进行测试，当然你可以选择使用其他的 OS，或者使用裸机测试，只需要移除 OS 相关的特性即可。

将 FlexibleButton 库放到 RT-Thread BSP 下即可使用 scons 进行编译构建。

% e( k% X4 H2 k## DEMO 程序说明
1 [* ~$ o/ {, ^6 f3 d$ H' v
### 程序入口
' K4 ~1 K  \( B2 M  h
7 V* j: J- P2 g$ A```C
int flex_button_main(void)
{
    rt_thread_t tid = RT_NULL;
; G; X- U. r3 A' K' T3 B: V& R' i    user_button_init();
    /* Create background ticks thread */
& B- Y5 n5 D7 N' Y3 O6 T    tid = rt_thread_create("flex_btn", button_scan, RT_NULL, 1024, 10, 10);
! C( |: X% g- ~* V0 `' w% g    if(tid != RT_NULL)
. p- R4 L! e0 ~7 N6 g- c3 @5 w    {
        rt_thread_startup(tid);
0 f$ T4 [* d# Z3 X; _    }
    return 0;
}
INIT_APP_EXPORT(flex_button_main);
```

如上所示，首先使用 `user_button_init();` 初始化用户按键硬件，并挂载到 FlexibleButton库。然后，使用了 RT-Thread 的 `INIT_APP_EXPORT` 接口导出为上电自动初始化，创建了一个 “flex_btn” 名字的按键扫描线程，线程里扫描检查按键事件。
# Z. o' ?1 R" D% n
### 用户初始化代码
, ^' F. a8 l8 N5 |3 d7 M& M
`user_button_init();` 初始化代码如下所示：

```C
- c: Q, z" a2 K2 E3 ?static void user_button_init(void)
7 y7 i/ m) D4 C) ?; l/ I{
    int i;
' N2 N! R4 ?0 V    rt_memset(&user_button[0], 0x0, sizeof(user_button));
) k$ k1 `- i& ]- q    user_button[USER_BUTTON_0].usr_button_read = button_key0_read;
# E- P+ C- i5 ]# [9 b4 F    user_button[USER_BUTTON_0].cb = (flex_button_response_callback)btn_0_cb;
    user_button[USER_BUTTON_1].usr_button_read = button_key1_read;
    user_button[USER_BUTTON_1].cb = (flex_button_response_callback)btn_1_cb;
1 v% q; M1 L$ n" V. G    user_button[USER_BUTTON_2].usr_button_read = button_key2_read;
9 \1 e+ j4 W4 I" b- c6 O( {    user_button[USER_BUTTON_3].usr_button_read = button_keywkup_read;
    rt_pin_mode(PIN_KEY0, PIN_MODE_INPUT); /* set KEY pin mode to input */
    rt_pin_mode(PIN_KEY1, PIN_MODE_INPUT); /* set KEY pin mode to input */
    rt_pin_mode(PIN_KEY2, PIN_MODE_INPUT); /* set KEY pin mode to input */
1 s. N8 f# z0 B" H2 `    rt_pin_mode(PIN_WK_UP, PIN_MODE_INPUT); /* set KEY pin mode to input */
    for (i = 0; i < USER_BUTTON_MAX; i ++)
    {
        user_button.status = 0;
, T9 e$ H, L4 N5 J% G        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;
5 P" @* i7 q" t        if (i == USER_BUTTON_3)
        {
            user_button[USER_BUTTON_3].pressed_logic_level = 1;
        }
$ E6 O& v6 e5 f        flex_button_register(&user_button);
    }
}
```
6 p1 N: m3 u! j) X. ~+ p& F, L! J
`user_button_init();` 主要用于初始化按键硬件，设置按键长按和短按的 tick 数（RT-Thread上面默认一个 tick 为 1ms），然后注册按键到 FlexibleButton 库。
- e5 D4 q  @9 k- s2 |7 V7 \. M5 W
2 B0 s7 M. ^' d( @### 事件处理代码

```C
static void btn_0_cb(flex_button_t *btn)
  r5 O. i  S0 [: _2 j{
    rt_kprintf("btn_0_cb\n");
& c( g+ C3 `3 y! \2 Z    switch (btn->event)
    {
        case FLEX_BTN_PRESS_DOWN:
            rt_kprintf("btn_0_cb [FLEX_BTN_PRESS_DOWN]\n");
( V, R  |- I& E            break;
        case FLEX_BTN_PRESS_CLICK:
% ~) c- x; U9 Y            rt_kprintf("btn_0_cb [FLEX_BTN_PRESS_CLICK]\n");
" Q; m! P4 k/ e6 d1 D            break;
        case FLEX_BTN_PRESS_DOUBLE_CLICK:
) i9 w8 e  L- H' t& q$ l: D            rt_kprintf("btn_0_cb [FLEX_BTN_PRESS_DOUBLE_CLICK]\n");
            break;
        case FLEX_BTN_PRESS_SHORT_START:
            rt_kprintf("btn_0_cb [FLEX_BTN_PRESS_SHORT_START]\n");
; w0 Q$ U7 Q4 K, P            break;
        case FLEX_BTN_PRESS_SHORT_UP:
! ^8 F/ _) N0 R  L8 q            rt_kprintf("btn_0_cb [FLEX_BTN_PRESS_SHORT_UP]\n");
            break;
        case FLEX_BTN_PRESS_LONG_START:
            rt_kprintf("btn_0_cb [FLEX_BTN_PRESS_LONG_START]\n");
: E9 k2 Y. b$ q" {, A            break;
* |% [' F  l* _! g8 q5 w1 N7 e( `        case FLEX_BTN_PRESS_LONG_UP:
            rt_kprintf("btn_0_cb [FLEX_BTN_PRESS_LONG_UP]\n");
            break;
* z( x" Z5 H$ \& \        case FLEX_BTN_PRESS_LONG_HOLD:
) G! i% A/ `- u) \, `            rt_kprintf("btn_0_cb [FLEX_BTN_PRESS_LONG_HOLD]\n");
            break;
        case FLEX_BTN_PRESS_LONG_HOLD_UP:
            rt_kprintf("btn_0_cb [FLEX_BTN_PRESS_LONG_HOLD_UP]\n");
            break;
    }
6 }2 a4 L$ a) w) A2 w}
- `* I% p: @2 {2 q```
5 G7 U, Y; s& U$ g$ W4 q  r0 d. X, n
## FlexibleButton 代码说明

### 按键事件定义
6 z6 O) V( l' @/ C
' i# s4 Z9 t5 x1 R" D3 M, @7 W" F按键事件的定义并没有使用 Windows 驱动上的定义，主要是方便嵌入式设备中的应用场景（也可能是我理解的偏差），按键事件定义如下：

% t7 |4 q8 {2 U8 n% _( a8 }9 w```C
8 `, n. i# o' {# K/ @typedef enum
{
* U, E# \9 B1 L& R) G    FLEX_BTN_PRESS_DOWN = 0,        // 按下事件
6 g: P% _+ n7 o! n8 P3 o    FLEX_BTN_PRESS_CLICK,           // 单击事件
    FLEX_BTN_PRESS_DOUBLE_CLICK,    // 双击事件
    FLEX_BTN_PRESS_SHORT_START,     // 短按开始事件
    FLEX_BTN_PRESS_SHORT_UP,        // 短按抬起事件
7 I0 F. t2 \2 \3 j    FLEX_BTN_PRESS_LONG_START,      // 长按开始事件
    FLEX_BTN_PRESS_LONG_UP,         // 长按抬起事件
" h% r% D' R* \    FLEX_BTN_PRESS_LONG_HOLD,       // 长按保持事件
  S5 k; [1 A9 l    FLEX_BTN_PRESS_LONG_HOLD_UP,    // 长按保持的抬起事件
" ^. P% u& r- \    FLEX_BTN_PRESS_MAX,
    FLEX_BTN_PRESS_NONE,
} flex_button_event_t;
+ I; m3 e2 A# f  n. q1 O```

' ~1 x+ ^' g" M7 ]8 n### 按键注册接口
# G+ P/ X5 {( d
  K" y. S: G' v" U( P# ^使用该接口注册一个用户按键，入参为一个 flex_button_t 结构体实例的地址。

```C
+ Y+ w' a& x" W  ~/ gint8_t flex_button_register(flex_button_t *button);
```
0 V& w: g! M0 K7 {# K( k$ a1 [
### 按键事件读取接口
2 D& |$ Q2 f8 p1 O
7 U0 v* ?$ ~$ `, Y9 E' T, V: g使用该接口获取指定按键的事件。

: U. L8 n4 u6 [8 u```C
flex_button_event_t flex_button_event_read(flex_button_t* button);
- R+ x& C* M' U* k````

& K0 e, M# i+ @% l1 G( s### 按键扫描接口
. O4 r9 U" f: Y3 J. w0 r
按键扫描的核心函数，需要放到应用程序中定时扫描间隔 5-20ms 即可。

```C
& U, u* m% `6 h( Z* T" M( pvoid flex_button_scan(void);
```
+ F& |& \9 a9 f) F* K: M
/ I3 v2 k: k4 h* N7 Q## 问题和建议

如果您在应用的时候遇到了问题，或者有好的想法和建议，欢迎到这个 [issue](http://github.com/zhaojuntao/FlexibleButton/issues/1) 上讨论，谢谢。
/ D( {# I1 l" R; g+ h
1 c/ r/ h; L. o. U9 o

编辑器不支持 markdown 格式