一、输入配置
为了灵活使用，我们将输入的有效电平设置成可配置。同样是列表表示所有IO口。

: _2 H, |0 k/ u0 [: h) M

1. // 配置有效电平
   
2. typedef enum
     V, a2 _  d% M+ e
3. {
   4 {, `6 e8 T* b( j" R' q/ S
4.   KEY_INIT_IS_ACTIVE = 0,
   , O7 ?2 f+ @' e8 Y( K# c% \
5.   KEY_LOW_IS_ACTIVE  = 1,
   4 `* F7 v& h6 Z6 f) _. |
6.   KEY_HIGH_IS_ACTIVE = 2,
   5 e7 S1 x$ o% a7 @, b
7. } key_active_t;
   - s+ l3 W# F  U( B+ [) a- C% T
8. 
   " l( y: N& w4 W$ o: y
9. 
   $ d* G2 E" q  C: C% B
10. #define KEY_CONFIG(gpio, pin)     GPIOConfig(gpio, pin, GPIO_MODE_INPUT, GPIO_PULLUP)
    ! Q; z3 k$ D9 N, i* [* r
11. #define KEY_READ(gpio, pin)       HAL_GPIO_ReadPin(gpio, pin)
    ( v' `/ D+ k' E; ^
12. 
    
13. #define KEY1_PORT                 GPIOH
    9 {; `' _+ `+ E" x* F  S9 ^- U
14. #define KEY1_PIN                  GPIO_PIN_3
    1 F2 t/ \3 l$ U8 u5 I0 e* g
15. 
    # |' Z3 L6 }. Q( e
16. #define KEY2_PORT                 GPIOH
    
17. #define KEY2_PIN                  GPIO_PIN_2
    
18. 
    0 w$ n( S* `4 v) Y" H" l
19. #define KEY3_PORT                 GPIOC
    3 U+ }, O; F: I4 T# z! l
20. #define KEY3_PIN                  GPIO_PIN_13

复制代码

1. // demo代码 只传递思想
   
2. 
   * C5 t2 u2 c2 c$ u3 i$ e
3. static void key_gpio_config(GPIO_TypeDef *gpio, uint16_t pin)
   ( z7 o) j) v& e5 b% A' r- D% I
4. {
     c3 E+ P" {: }. C, G8 Q6 A
5.   KEY_CONFIG(gpio, pin);
   
6. }
   
7. 
   
8. typedef struct
   
9. {
   
10.   GPIO_TypeDef *gpio;
    
11.   uint16_t pin;
    
12. } key_port_t;
    
13. 
    9 D! m5 I: G: e
14. static key_port_t key_entries[] =
    
15. {
    : W1 O! Z/ `, G/ ]8 Y* e4 J6 Y
16.   {KEY1_PORT, KEY1_PIN},
    # }! E+ o( D& f( a9 K$ m
17.   {KEY2_PORT, KEY2_PIN},
    ! p: }' S' h$ L8 q! S5 x4 T
18.   {KEY3_PORT, KEY3_PIN},
    
19. };
    
20. 
    + d5 \* |/ n2 O" h2 ^7 x5 J
21. void KeyInit(void)
    ; p: U$ S$ j4 @3 b! z! N, x: O! ?1 h+ z
22. {
    
23.   uint32_t i, mask = 1;
    ' h6 b! ]  M) j, u# g+ J3 F5 s# k
24. 
    
25.   for(i = 0; i < ARRAY_SIZE(key_entries); ++i)
    - G+ u2 A, y2 G
26.   {
    
27.     if(0xFFFFFFFF & mask)
    
28.     {
    
29.       key_gpio_config(key_entries<span style="font-style: italic;">.gpio, key_entries.pin);
    
30. 
    7 v0 Q# E3 Q+ T
31. <span style="font-style: normal;">#if(CONFIG_KEY_TEST == 1) // 测试时使用      
    ! U# M. s' a5 Y/ Z6 K& U
32.       //config.key.total_switch  = KEY_MODE_OPEN;
    
33.       //config.key.sub_switch = KEY_MODE_OPEN;
    
34.       config.key.active_tag = KEY_LOW_IS_ACTIVE;
    
35. #endif
    
36.     }
    
37. 
    
38.     mask <<= 1;
    ' A. f0 Q: D0 m3 W0 b$ ]" \( y) s
39.   }
    
40. }
    
41. 
    
42. // 输入是否可用
    ; z4 T. ~+ ~$ b" o, e, a
43. static uint8_t key_is_enable(uint8_t index)
    , m# N. r# _, k: V% K, X
44. {
    
45.   // 这里可以写成可配置 配置IO口可用或者不可用（类似一个总开关）
    / x; G* G7 p& U0 ^
46.   return 1;
    2 Z/ D  N! P8 W. T! u/ _/ r
47. }
    
48. 
    $ e, h4 Q3 Z# K# V3 ?5 r- W
49. // 有输入到来
    $ s4 v9 }$ v7 \
50. static uint8_t key_is_pressed(uint8_t index)
    
51. {
    
52.   if(key_is_enable(index))
    
53.   {
    , b& k; n' x( l' w) m( X7 Y
54.     if(KEY_LOW_IS_ACTIVE == config.key.active_tag[index])
    
55.     {
    . x0 c% y* `. R% }) h2 w
56.       if(KEY_READ(key_entries[index].gpio, key_entries[index].pin) == 0)
    ) W  Z( k6 P; G/ I' H: w, t
57.       {
    
58.         return 1;
      K! T) R( N5 B  ^8 W0 H
59.       }
    
60.     }
    
61.     else if(KEY_HIGH_IS_ACTIVE == config.key.active_tag[index])
    : Y% h* |( ^7 O$ y6 I7 d
62.     {
    
63.       if(KEY_READ(key_entries[index].gpio, key_entries[index].pin) == 1)
    
64.       {
    % J3 V8 S& k; P; w7 j
65.         return 1;
    : T' }1 y$ Y! `- f/ P, E0 C
66.       }
    
67.     }
    ' B$ K* Q( U2 D1 `. [# P
68.   }
    
69. 
    
70.   return 0;
    
71. }
    
72. 
    
73. // 按键被按下
    
74. uint8_t Key1IsDown(void)
    
75. {
    
76.   return key_is_pressed(0);
    " V- K0 |# l7 v. _7 r0 e
77. }
    0 P0 y: ]5 _6 ]; I6 q* @# J2 [* `
78. 
    
79. uint8_t Key2IsDown(void)
    - ?+ D. l( E$ M) d# J$ j  d
80. {
    
81.   return key_is_pressed(1);
    4 ?& {' N8 j8 {
82. }
    
83. 
    
84. uint8_t Key3IsDown(void)
    : ^$ {# A* Q# W4 Z) l
85. {
    
86.   return key_is_pressed(2);
    ) r" w8 _; H& B1 k# ~8 [0 `
87. }</span></span>

复制代码

二、输入扫描

1. // 按键的状态机结构定义
   
2. // 按键状态
   
3. typedef enum
   : ~5 _% Y, n& e$ K
4. {
   3 S5 D; G4 p7 C
5.   KEY_STATE_INIT, // 缺省按键状态
   ' `: _8 ?; ?! A$ d
6.   KEY_STATE_UP,   // 按键弹起状态
   
7.   KEY_STATE_DOWN, // 按键按下状态
   
8.   KEY_STATE_LONG, // 按键长按状态
   : H. h: r) O2 S: L
9.   KEY_STATE_AUTO, // 按键自动连发状态
   
10. } key_state_t;
    
11. 
    ; Y* a8 F) u. A  j% w3 l
12. // 按键滤波时间20ms, 单位10ms。
    3 c+ d" m: {/ v2 G
13. // 只有连续检测到20ms状态不变才认为有效，包括弹起和按下两种事件
      T! j9 s* ]$ e- G2 d$ X3 S" @+ e0 l
14. // 即使按键电路不做硬件滤波，该滤波机制也可以保证可靠地检测到按键事件
    & C+ l5 o0 ?5 ?8 B
15. #define KEY_FILTER_TIME 2   // 滤波消抖
    # u0 [' G; d' h4 r/ E! @
16. #define KEY_LONG_TIME   100 // 单位10ms    持续1秒，认为长按事件
    
17. #define KEY_REPEAT_TIME 100 // 单位10ms    持续1秒，自动连发
    
18. 
    5 |& u6 p& Q* F: K( ]: O" x: Y% m
19. typedef uint8_t (*key_cb)(void);
    
20. typedef struct
    
21. {
    5 r# ]4 d. G( t
22.   uint8_t state;        // 按键当前状态(按下还是弹起)
    
23.   uint8_t last;         // 上一次按键的状态
    7 q0 t8 X  U! H# i$ c
24.   uint8_t count;        // 滤波消抖计数器
    
25.   uint16_t long_time;   // 按键按下持续时间, 0表示不检测长按
    
26.   uint16_t long_count;  // 长按计数器
    * D- s* g* S- L- ^! c# G( v, f: @
27.   uint8_t repeat_speed; // 连续按键周期
    ! M. J0 O% E9 S/ N
28.   uint8_t repeat_count; // 连续按键计数器
    0 ]* {$ m- ?4 v6 a% v* j, C
29.   key_cb is_down_func;  // 按键按下的判断函数,1表示按下
    
30. } key_t;
    3 }5 K9 K) ^  c6 x
31. 
      A3 u4 F( L' _( a2 I, o% U6 b
32. static key_t key_items[] =
    
33. {
    " z3 ^& e( H8 O& r6 u' V
34.   {KEY_STATE_INIT, KEY_STATE_INIT, KEY_FILTER_TIME, KEY_LONG_TIME, 0, KEY_REPEAT_TIME, 0, Key1IsDown},
    
35.   {KEY_STATE_INIT, KEY_STATE_INIT, KEY_FILTER_TIME, KEY_LONG_TIME, 0, KEY_REPEAT_TIME, 0, Key2IsDown},
    
36.   {KEY_STATE_INIT, KEY_STATE_INIT, KEY_FILTER_TIME, KEY_LONG_TIME, 0, KEY_REPEAT_TIME, 0, Key3IsDown},
    $ ^8 k$ W- F  q: W; k) _9 }. c0 z; ?
37. };

复制代码

1. // 按键状态机key_scan
   6 h) M/ r- v! ^0 r5 `0 k+ ~
2. // 配置限制条件在这个函数里面加
   : G* C! |3 g; f+ q  f# {; O& s' J
3. static void key_scan_ext(key_t *entry, uint8_t i)
   
4. {
   
5.   switch(entry->state)
   
6.   {
   
7.   case KEY_STATE_INIT:
   
8.   case KEY_STATE_UP:
   
9.   {
   5 c# g1 }' M% i3 ^7 I! E1 V- @- y9 M
10.     entry->state = KEY_STATE_DOWN; // 按键被按下
      O; o1 u' \3 I) a( Z0 s6 q5 N
11.     break;
    
12.   }
    ' n! g$ k+ R6 K3 e* B
13. 
    * O+ V8 Y" ?6 H' y' i+ K, z6 `
14.   case KEY_STATE_DOWN:
    ' J: s4 }+ J$ M. v
15.   {
    
16.     if(entry->long_time > 0)
    
17.     {
    
18.       if(entry->long_count < entry->long_time)
    
19.       {
    " q6 e1 P7 y2 G% U: s
20.         if(++entry->long_count >= entry->long_time)
    3 t: D: |' Y+ u" I. A# j% U8 G
21.         {
    / t% n- p1 f! |; M4 C* h* Z1 ]
22.           entry->state = KEY_STATE_LONG;
    + V. f8 f% j' ?( q; \7 v; P6 |
23.         }
    4 m- [; t7 k6 `. `1 X9 ^
24.       }
    . j9 t- W' ?- E( x9 Y
25.     }
    ' Z0 _# ~: p0 @! b: W' _- a3 d
26. 
    ' F) N/ e) @  A  A, l, e
27.     break;
    
28.   }
    1 ~, Q/ A; e0 ]9 \
29. 
    . T3 J4 A. i$ r# J$ L% Z* w$ M" L9 x
30.   case KEY_STATE_LONG:
    
31.   {
    % v3 @% T: R' a
32.     if(entry->repeat_speed > 0) // 自动连发时间到  自动连发事件
    7 b4 K. I5 q! K/ D' A( ]
33.     {
    
34.       if(++entry->repeat_count >= entry->repeat_speed)
    ; Y" Q" B' p$ }% E
35.       {
    
36.         entry->repeat_count = 0;
    3 r% v2 O  q5 F- d
37.         // 长按触发
    - `; W4 n0 X1 K. V* E! J
38.       }
    
39.     }
    
40. 
    7 j- O" Q& K5 Z
41.     break;
    
42.   }
    2 Z* C$ l3 c( Y+ Z; R
43.   }
    
44. 
    
45.   entry->last = entry->state; // 最新的按键状态
    
46. }
    
47. 
    - T5 a  H# x. M' v
48. static void key_scan(uint8_t i)
    # A9 Y0 d+ g  W
49. {
    / U" u2 B$ ?, ^  V! A' g
50.   key_t *entry = &key_items<span style="font-style: italic;"><span style="font-style: normal;">;
    , B9 k7 p0 K& C
51.         uint8_t key;
    ( b5 h9 ~- F; y9 W6 ?' }% l4 {
52. 
    
53.   if(entry->is_down_func())
    - z+ c" c$ q' z
54.   {
    
55.     if(entry->count < KEY_FILTER_TIME) // 消抖
    
56.     {
    
57.       ++entry->count;
    
58.     }
    , y+ L' ?8 K( R3 |9 |6 f, L6 ~1 D- _
59.     else
    * \/ P; ]5 g. _- B8 H/ O$ O
60.     {
    : G( P0 i7 ~- b: k. r/ G
61.       key_scan_ext(entry, i); // 按键扫描状态机
    
62.     }
    8 {5 n" t7 M# }4 B
63.   }
    
64.   else
    $ r& ^( E' @9 c1 |& {! i; p: c$ Y
65.   {
    
66.     if(entry->count > KEY_FILTER_TIME)
    
67.     {
    
68.       entry->count = KEY_FILTER_TIME;
    , f% J2 c' Y- y( C
69.     }
    # B) I4 H0 f- b3 ^( N+ E, @( K8 o
70.     else if(entry->count > 0)
    4 e2 Y/ \4 o; _2 _) @
71.     {
    , Y- T  f, @0 g* a% W- o) _
72.       --entry->count;
    4 v6 f+ Y* z2 [1 v! f1 l$ a! V
73.     }
    
74.     else
    0 g& y; S* j4 B+ U. x# T
75.     {
    
76.       if(KEY_STATE_DOWN == entry->last) // 一次完整的按键到这里就弹起了
    3 a9 A/ B1 N3 L2 n7 E% s( X
77.       {
    
78.        // 按键按下之后可以加入到队列中，这里的队列可以自己写；如果带系统可以使用系统的消息队列等方式。
    2 T+ ]- b0 v5 s" T( v7 D' k
79.        // key = i + 1;
    
80.        // xQueueSend(os_key_queue, &key, 10);
    ' _5 ?3 i" k8 f( w6 }: Z; B* H( o
81.       }
    6 |0 |) k6 X8 V* L
82.       entry->last  = KEY_STATE_UP;
    ) d8 U9 M# s8 _, F$ l- f* s
83.       entry->state = KEY_STATE_UP; // 按键弹起状态
    0 @( W+ ~+ X" W2 m1 Q- r: {* Y
84.     }
    1 f1 A& G3 ]2 T7 [2 @
85. 
    " A3 `: m9 n! `! k
86.     entry->long_count = 0;
    , X5 c, i. O. c1 U, J, ?+ b
87.     entry->repeat_count = 0; // 清空计数器
    % T# L; e0 O  \  v- f
88.   }
    ! B& H/ m: L- t5 f1 A+ ?
89. }</span></span>

复制代码

3 X% \4 E' S! f+ r0 [三、输入处理

1. // 按键按下之后，会将值加入到队列中，我们读取队列数据，然后扫描列表匹配功能
   
2. static void key1_cb(void);
   . i6 o) \  r4 w1 i1 k7 f# K
3. static void key2_cb(void);
   
4. static void key3_cb(void);
   . E2 o, g; j+ D% T- Z: H# `8 c  K- m
5. 
   
6. #define KEY1_CMD         1
   
7. #define KEY2_CMD         2
   
8. #define KEY3_CMD         3
   
9. 
   2 D2 U! f' N) }1 ]8 Q& s
10. typedef struct
    
11. {
    
12.   uint8_t cmd;
    
13.   void (* key_handle_cb)(void);
    8 x! p# F' F$ ]9 O: O8 @5 i
14. } key_handle_t;
    + q& l2 C# o7 V, C' w
15. 
    
16. static const key_handle_t key_entries[] =
    ' O& Y' L' V# h6 R# }& `% p$ x
17. {
    
18.   {KEY1_CMD, key1_cb},
    
19.   {KEY2_CMD, key2_cb},
    
20.   {KEY3_CMD, key3_cb},
    + D3 x% W. m1 J) i
21.   {0xFF, NULL  },
    " O) ^1 M! J6 I+ G" Q
22. };
    
23. 
    
24. // 按键的通用功能
    
25. static void key_func(uint8_t func)
    
26. {
    
27. 
      C7 l: r/ r6 L; ~* L7 \3 R
28. }
      S$ a# ?1 s2 _6 h. P
29. 
    
30. static void key1_cb(void)
    
31. {
    ! f1 W) A4 ?- R- c
32. 
    : I* d$ m" A6 ~6 m# Q  q2 m
33. }
    2 Q7 t  S2 A) F2 W4 P# L) Y
34. 
    
35. static void key2_cb(void)
    % J$ F. Z" {7 h# |! f6 X4 f0 v
36. {
    * w2 s, i5 H1 g  K
37. 
    , X2 h; |! E* U6 O0 d' X1 L' {1 h
38. }
    
39. 
    % c4 k- a1 q6 d8 D
40. static void key3_cb(void)
    6 {- n3 {3 a" s
41. {
    * c. q  Y3 ?/ j! n
42. 
    + e" X( E% T( c4 o/ L
43. }
    3 K' G! I+ M, p; b) {2 k+ Z8 K; t
44. 
    % |* ~, r8 R8 t7 p* m
45. static void key_process(uint8_t event)
    
46. {
    
47.   const key_handle_t *entry;
    / m% y# p% w& k3 m( q9 ]/ s' g
48. 
    
49.   for(entry = key_entries; entry->key_handle_cb; ++entry)
    
50.   {
    % p3 f8 i* Z4 Z- x# \
51.     if(event == entry->cmd)
    3 q! {% C$ y( g: ~* k
52.     {
    
53.       entry->key_handle_cb();
    
54.       break;
    
55.     }
    
56.   }
    
57. }

复制代码

1 e6 o8 j: u5 _5 _裸机：按键扫描20ms执行一次，按键处理直接丢在主函数中。（自己写队列）
1 N* O+ e1 M! I5 L) w7 E* Q6 b' ?# A0 H8 o* g
& p4 s; s1 c( K系统：在任务中执行按键扫描和按键处理。（系统自带队列或者邮箱）

4 s1 g7 z7 O3 j2 J* @2 h
/ ]0 b3 |+ G+ H+ v9 e