一、输入配置
, k' u0 V) A. g8 `7 o* R6 _" O为了灵活使用，我们将输入的有效电平设置成可配置。同样是列表表示所有IO口。

# H# Y/ p3 D% g4 N) S: E+ n

1. // 配置有效电平
   $ T+ j: }, K8 `
2. typedef enum
   " q8 y6 N2 h3 l: [  G; n: h: Y
3. {
   
4.   KEY_INIT_IS_ACTIVE = 0,
   $ ^1 I" ^& v5 J" y: J
5.   KEY_LOW_IS_ACTIVE  = 1,
   
6.   KEY_HIGH_IS_ACTIVE = 2,
   ) A7 k% P; g0 O! V
7. } key_active_t;
   
8. 
   
9. 
   
10. #define KEY_CONFIG(gpio, pin)     GPIOConfig(gpio, pin, GPIO_MODE_INPUT, GPIO_PULLUP)
      r! t+ Q" g8 l1 }; z, K8 z: I4 U3 i
11. #define KEY_READ(gpio, pin)       HAL_GPIO_ReadPin(gpio, pin)
    / b; o* m3 d- Z- T% ~
12. 
    / W" ~  J' ], a/ a- V+ J
13. #define KEY1_PORT                 GPIOH
    
14. #define KEY1_PIN                  GPIO_PIN_3
    
15. 
    
16. #define KEY2_PORT                 GPIOH
    7 x$ m& z" }3 S/ P
17. #define KEY2_PIN                  GPIO_PIN_2
    # J; Q# L, e4 h; y' O
18. 
    5 L: V* W) G4 i5 J* n
19. #define KEY3_PORT                 GPIOC
    
20. #define KEY3_PIN                  GPIO_PIN_13

复制代码

1. // demo代码 只传递思想
   ' w! T) w; l' |% c
2. 
   
3. static void key_gpio_config(GPIO_TypeDef *gpio, uint16_t pin)
   / O) |" z. |" U; z% S+ y7 i3 {
4. {
   
5.   KEY_CONFIG(gpio, pin);
   
6. }
   3 @# u) g% w& \& n9 I
7. 
   
8. typedef struct
   
9. {
     n9 g$ O; ?5 q) I, D  r
10.   GPIO_TypeDef *gpio;
    8 Y1 X8 D  [5 O9 V& F& \
11.   uint16_t pin;
      j2 z$ i1 ?3 f
12. } key_port_t;
    
13. 
    : t! X5 |. D( w
14. static key_port_t key_entries[] =
    2 g3 ]0 ?1 L- o
15. {
    ' X$ C- }8 O2 A8 Q) y
16.   {KEY1_PORT, KEY1_PIN},
    
17.   {KEY2_PORT, KEY2_PIN},
    
18.   {KEY3_PORT, KEY3_PIN},
    
19. };
    0 L2 V: L: C$ O% m
20. 
      m$ p; q4 y, K; t1 [
21. void KeyInit(void)
    
22. {
    0 K+ H0 y& Q2 W1 x
23.   uint32_t i, mask = 1;
    
24. 
    ' ~4 B& G5 Q$ }' V, L3 l8 z/ u+ ~  h
25.   for(i = 0; i < ARRAY_SIZE(key_entries); ++i)
    
26.   {
    & ]4 q* o3 k. Q$ }  C0 H: W/ |; p- k
27.     if(0xFFFFFFFF & mask)
    
28.     {
    0 W+ [2 z2 x; d" M% \$ j
29.       key_gpio_config(key_entries<span style="font-style: italic;">.gpio, key_entries.pin);
    
30. 
    
31. <span style="font-style: normal;">#if(CONFIG_KEY_TEST == 1) // 测试时使用      
    7 w( w3 Q' i( z2 p
32.       //config.key.total_switch  = KEY_MODE_OPEN;
    8 B- K4 B* \& J7 s$ S
33.       //config.key.sub_switch = KEY_MODE_OPEN;
    
34.       config.key.active_tag = KEY_LOW_IS_ACTIVE;
    
35. #endif
    
36.     }
    
37. 
    $ ^0 j; _3 [, W* r( c% z% g9 {9 [
38.     mask <<= 1;
    6 {* ~2 Y" E6 E
39.   }
    
40. }
    
41. 
    
42. // 输入是否可用
    
43. static uint8_t key_is_enable(uint8_t index)
    8 y3 I4 o+ ^* d  X4 k; B
44. {
    
45.   // 这里可以写成可配置 配置IO口可用或者不可用（类似一个总开关）
    ; L' u* ?) Q& Q. h
46.   return 1;
    
47. }
    $ i2 W8 V- [, S. O  ]
48. 
    , G8 U4 X. ?# W. H9 I2 U5 I
49. // 有输入到来
    
50. static uint8_t key_is_pressed(uint8_t index)
    
51. {
    
52.   if(key_is_enable(index))
    
53.   {
    
54.     if(KEY_LOW_IS_ACTIVE == config.key.active_tag[index])
    
55.     {
    7 K' \6 }, K- c+ G' m% H% g4 d
56.       if(KEY_READ(key_entries[index].gpio, key_entries[index].pin) == 0)
    / |; S: V, a/ C, T2 ~0 W% A
57.       {
    
58.         return 1;
    
59.       }
    9 X" \5 Q, g7 F* l& X
60.     }
    
61.     else if(KEY_HIGH_IS_ACTIVE == config.key.active_tag[index])
    - [7 O9 |! B- ~% ~  g4 A3 X9 H
62.     {
    
63.       if(KEY_READ(key_entries[index].gpio, key_entries[index].pin) == 1)
    
64.       {
    
65.         return 1;
    . V5 ]6 q4 b$ a, ]! i! p
66.       }
      H* C  F6 D/ `8 v" q
67.     }
    + ]- y5 R6 P6 j6 Q) j# `
68.   }
    8 C; e0 G+ J: T
69. 
    
70.   return 0;
    
71. }
    
72. 
    
73. // 按键被按下
    1 T# U' U2 Y- I% _9 Y7 w8 Q' K
74. uint8_t Key1IsDown(void)
    
75. {
    
76.   return key_is_pressed(0);
    1 V% `$ T; C$ ?
77. }
    ) y) h/ k1 Q! T* b5 O5 a, E
78. 
    3 s! Q* @6 z! {2 ?7 E$ I
79. uint8_t Key2IsDown(void)
    
80. {
    ' X! @: M( M" U; W! x. U
81.   return key_is_pressed(1);
    ! W1 a, {8 x' u8 t4 b9 Y9 R3 n4 ~
82. }
    9 [, v+ U) s+ A) [' Y, I3 A
83. 
    
84. uint8_t Key3IsDown(void)
    0 r. t- O, z7 z) t: A7 m7 |4 @! _
85. {
    
86.   return key_is_pressed(2);
    
87. }</span></span>

复制代码

& F* x8 Q2 z% d$ |! M3 d二、输入扫描

1. // 按键的状态机结构定义
   # ?0 }. N* E) }& i
2. // 按键状态
   
3. typedef enum
   ' r( \9 V4 m! ], c' m2 b& q
4. {
     l$ |4 L0 X1 Y. `/ `5 q' \& g
5.   KEY_STATE_INIT, // 缺省按键状态
   # J% Q8 B1 J6 }( g
6.   KEY_STATE_UP,   // 按键弹起状态
   4 M: U+ P8 D6 H+ A9 ^
7.   KEY_STATE_DOWN, // 按键按下状态
   : {4 I, @! h6 W
8.   KEY_STATE_LONG, // 按键长按状态
   9 @* |  t2 \0 ?2 O4 S* ~
9.   KEY_STATE_AUTO, // 按键自动连发状态
   8 _) p9 I! R/ [
10. } key_state_t;
    1 J3 d- s& r/ B  o
11. 
    - e6 o4 k  [& d1 x
12. // 按键滤波时间20ms, 单位10ms。
    " g( V2 z! E" y( f$ i& b5 G
13. // 只有连续检测到20ms状态不变才认为有效，包括弹起和按下两种事件
    ! l0 {0 r' @2 s% Y  S% F$ _# _" }" W
14. // 即使按键电路不做硬件滤波，该滤波机制也可以保证可靠地检测到按键事件
    
15. #define KEY_FILTER_TIME 2   // 滤波消抖
    
16. #define KEY_LONG_TIME   100 // 单位10ms    持续1秒，认为长按事件
    5 R* F" Y4 a0 H/ k7 x( _* S
17. #define KEY_REPEAT_TIME 100 // 单位10ms    持续1秒，自动连发
    3 ^# Y  ?1 i1 R
18. 
    9 k% o# z1 I  ?6 u. Y
19. typedef uint8_t (*key_cb)(void);
    
20. typedef struct
    
21. {
    
22.   uint8_t state;        // 按键当前状态(按下还是弹起)
    
23.   uint8_t last;         // 上一次按键的状态
    7 r' |$ ~# w# c
24.   uint8_t count;        // 滤波消抖计数器
    
25.   uint16_t long_time;   // 按键按下持续时间, 0表示不检测长按
    
26.   uint16_t long_count;  // 长按计数器
    
27.   uint8_t repeat_speed; // 连续按键周期
    
28.   uint8_t repeat_count; // 连续按键计数器
    
29.   key_cb is_down_func;  // 按键按下的判断函数,1表示按下
    2 C  K, t' I1 ?7 A
30. } key_t;
    1 P/ ?5 I1 |- H' ?- B  A
31. 
    ( ?! C3 n' b  @* S& i. v. H
32. static key_t key_items[] =
    1 Y8 J" k9 y7 x5 Z; Q& p% t' l
33. {
    
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},
    ' @$ s- F: v3 S, n! b0 Y
37. };

复制代码

1. // 按键状态机key_scan
   , m# I  N& R8 ^6 s
2. // 配置限制条件在这个函数里面加
   
3. static void key_scan_ext(key_t *entry, uint8_t i)
   * F( F3 t0 |8 \2 P& D
4. {
   6 a1 P9 I' f( r& `- N
5.   switch(entry->state)
   
6.   {
   - P' @' W7 f1 D. X! P; _/ R
7.   case KEY_STATE_INIT:
   , {+ Y- w* i( ]8 n$ u
8.   case KEY_STATE_UP:
   
9.   {
   - @$ R! I2 }' f$ @7 G9 x
10.     entry->state = KEY_STATE_DOWN; // 按键被按下
    
11.     break;
    1 y6 ~2 ?& ^  ~( t" e8 |% s2 `# L
12.   }
    ! N$ o6 c. d' G; ^8 G1 m* k
13. 
    
14.   case KEY_STATE_DOWN:
    
15.   {
    
16.     if(entry->long_time > 0)
    3 h' Z6 I8 T1 j0 f$ a9 K
17.     {
    
18.       if(entry->long_count < entry->long_time)
    
19.       {
    , m+ G* G; F1 Y3 h, r0 ]
20.         if(++entry->long_count >= entry->long_time)
    
21.         {
    * g4 }5 Y9 a  {) S4 Y; D. ]" Z
22.           entry->state = KEY_STATE_LONG;
    
23.         }
    
24.       }
      [, U2 {- J) t) j
25.     }
    ! |/ Q7 D: f, y0 P* e/ X4 I7 m8 b
26. 
    
27.     break;
    - V5 a2 P: x+ E4 U
28.   }
    % a( q6 }- r$ k. V
29. 
    $ A! c0 D5 m7 ~3 B5 h2 o& i
30.   case KEY_STATE_LONG:
    0 d/ M2 [6 r) m# e
31.   {
    $ j. }. h7 N) u
32.     if(entry->repeat_speed > 0) // 自动连发时间到  自动连发事件
    
33.     {
    
34.       if(++entry->repeat_count >= entry->repeat_speed)
    7 T1 z% C4 h% f8 B+ ^
35.       {
    
36.         entry->repeat_count = 0;
    
37.         // 长按触发
    . ^# n2 W, \! d$ H5 L& a1 l
38.       }
    7 \8 n+ O& j* R& D( c
39.     }
    
40. 
    
41.     break;
    . J% B: p/ u5 N+ o4 M
42.   }
    8 c, i& I3 G6 `: \/ Y
43.   }
    
44. 
    # Z0 B8 r/ o' q3 I$ C, @: M
45.   entry->last = entry->state; // 最新的按键状态
    
46. }
    
47. 
    
48. static void key_scan(uint8_t i)
    
49. {
    
50.   key_t *entry = &key_items<span style="font-style: italic;"><span style="font-style: normal;">;
    ' q) F4 [  ]0 N5 `! b+ L
51.         uint8_t key;
    
52. 
    
53.   if(entry->is_down_func())
    5 [  A) v. p* H3 G# b2 d& ^& U
54.   {
    
55.     if(entry->count < KEY_FILTER_TIME) // 消抖
    
56.     {
    
57.       ++entry->count;
    
58.     }
    , O1 Q' e9 b- P  \
59.     else
    # Y& t" U- V) d& e  @6 k
60.     {
    8 V% {0 q1 {2 v/ z
61.       key_scan_ext(entry, i); // 按键扫描状态机
    7 ]7 `8 w+ r4 ^+ F
62.     }
    
63.   }
    
64.   else
    
65.   {
    . B* J9 U8 w6 N+ o. d- k
66.     if(entry->count > KEY_FILTER_TIME)
    $ L/ ^1 d# A  n3 s. s% ~6 r
67.     {
    
68.       entry->count = KEY_FILTER_TIME;
    
69.     }
    
70.     else if(entry->count > 0)
    + B6 ?& m7 u+ T7 a& f
71.     {
    # n: d% t( A# N. ]) v7 a
72.       --entry->count;
    6 `, G6 f9 Q* `2 l% B
73.     }
    
74.     else
    6 L! k. M3 u; p1 j, [
75.     {
    
76.       if(KEY_STATE_DOWN == entry->last) // 一次完整的按键到这里就弹起了
    
77.       {
    7 d8 z. _( ]. ?# ?* e9 V
78.        // 按键按下之后可以加入到队列中，这里的队列可以自己写；如果带系统可以使用系统的消息队列等方式。
    
79.        // key = i + 1;
    4 @" G# y# j" _* O: {5 l
80.        // xQueueSend(os_key_queue, &key, 10);
    % L% A7 z. R" Q
81.       }
    
82.       entry->last  = KEY_STATE_UP;
    
83.       entry->state = KEY_STATE_UP; // 按键弹起状态
    
84.     }
    5 \; Y, i6 o8 i% M7 E
85. 
    , i% z9 ]6 x3 C8 a
86.     entry->long_count = 0;
    
87.     entry->repeat_count = 0; // 清空计数器
    
88.   }
    ; L/ O) g5 _" x% u1 M4 ]. m
89. }</span></span>

复制代码

- k9 R# o- c7 N4 u: [" g三、输入处理

1. // 按键按下之后，会将值加入到队列中，我们读取队列数据，然后扫描列表匹配功能
   
2. static void key1_cb(void);
   
3. static void key2_cb(void);
   
4. static void key3_cb(void);
   
5. 
   
6. #define KEY1_CMD         1
   6 a. c0 u" I6 ~& C* E) _0 e
7. #define KEY2_CMD         2
   9 J; Q* P- G! t& o) y- r
8. #define KEY3_CMD         3
   " q( I  r0 Z' R5 E3 v
9. 
   " {! G- ?0 K* q: h
10. typedef struct
    
11. {
    
12.   uint8_t cmd;
    $ \0 Q" |  o) \. Z: B8 r4 V
13.   void (* key_handle_cb)(void);
    - O" e& @3 K( G9 c& I( w) o; }
14. } key_handle_t;
    . J$ R3 S/ Y$ Y2 F$ X2 L4 d
15. 
    7 f; B  e' O8 q( P1 D- Y
16. static const key_handle_t key_entries[] =
    4 m% G6 h2 p1 {6 }+ g# B/ f+ ]) N
17. {
    
18.   {KEY1_CMD, key1_cb},
    
19.   {KEY2_CMD, key2_cb},
    4 p/ Q3 q* [9 I( E7 A
20.   {KEY3_CMD, key3_cb},
    
21.   {0xFF, NULL  },
    2 Y8 y8 J1 T: t7 X* R: P
22. };
    & y$ K; O( W4 d1 \
23. 
    
24. // 按键的通用功能
    
25. static void key_func(uint8_t func)
    : N9 e4 U# |1 t' m! o8 f( B/ O
26. {
    7 B6 A8 P. M7 L# _( b& k
27. 
    - o$ Z- [" M+ \# U/ A- l
28. }
    
29. 
    . a$ D! ]8 j& Q; w0 V& Z& v. a9 E" V
30. static void key1_cb(void)
    ! X. h# P* s4 M8 Z2 C% b
31. {
    
32. 
    
33. }
    
34. 
    + |- v" j. [; D% G
35. static void key2_cb(void)
    / q1 M% f, r, i! e7 o( h
36. {
    1 b$ \3 b; y) W8 A% v+ ~' s
37. 
    # z. m; ?9 E' ~7 R* s8 t
38. }
    - f2 V. h$ k9 K
39. 
    
40. static void key3_cb(void)
    
41. {
    / C) B1 s( ^! ]
42. 
    
43. }
    * s  |: ]/ p3 Z
44. 
    
45. static void key_process(uint8_t event)
    
46. {
    
47.   const key_handle_t *entry;
    
48. 
    6 e/ {4 Q7 e" Y" N3 G. g1 c
49.   for(entry = key_entries; entry->key_handle_cb; ++entry)
    . e. J, v9 V0 C9 B
50.   {
    - l$ y8 x) a- t' M0 G9 m" A
51.     if(event == entry->cmd)
    
52.     {
    
53.       entry->key_handle_cb();
    
54.       break;
    
55.     }
    
56.   }
    
57. }

复制代码

& M4 t  W- M* O9 m/ a& \裸机：按键扫描20ms执行一次，按键处理直接丢在主函数中。（自己写队列）

4 f9 k+ C% p" g& E, F系统：在任务中执行按键扫描和按键处理。（系统自带队列或者邮箱）
4 S  i9 J: I1 k% P
! y% L, f" v8 F5 N
  f9 ]- T: H$ c3 ?- x, ?4 m8 ]