一、输入配置
, f3 C) I& S2 g! i, l* g0 B! J& F为了灵活使用，我们将输入的有效电平设置成可配置。同样是列表表示所有IO口。

/ ]8 k* B/ ?. `0 T/ @" C8 E

1. // 配置有效电平
   5 b% K, y+ W7 {" b
2. typedef enum
   
3. {
   
4.   KEY_INIT_IS_ACTIVE = 0,
   1 i. ~. A) W2 y, w2 D
5.   KEY_LOW_IS_ACTIVE  = 1,
   # t0 E- k7 N  e/ y5 y! M; {
6.   KEY_HIGH_IS_ACTIVE = 2,
   
7. } key_active_t;
   
8. 
   
9. 
   
10. #define KEY_CONFIG(gpio, pin)     GPIOConfig(gpio, pin, GPIO_MODE_INPUT, GPIO_PULLUP)
    
11. #define KEY_READ(gpio, pin)       HAL_GPIO_ReadPin(gpio, pin)
    
12. 
    9 f' H* S) U7 C7 X( y$ ~6 i" H9 X1 A. Y
13. #define KEY1_PORT                 GPIOH
    ) _4 T' X, U; M3 g5 W, j0 z$ J, D; z
14. #define KEY1_PIN                  GPIO_PIN_3
    - G! F. ^+ m  u+ G% b
15. 
    " X$ x4 y- f8 V. @" n# T
16. #define KEY2_PORT                 GPIOH
    
17. #define KEY2_PIN                  GPIO_PIN_2
    5 n( S4 w7 x& B& C. M7 c' L
18. 
    ( L) x0 X+ u# n0 t" z
19. #define KEY3_PORT                 GPIOC
    ' Q. [6 O9 d' Y" ?0 t7 @8 Y  Y
20. #define KEY3_PIN                  GPIO_PIN_13

复制代码

1. // demo代码 只传递思想
   
2. 
   2 N! `# W+ X$ L5 @4 @2 N: o
3. static void key_gpio_config(GPIO_TypeDef *gpio, uint16_t pin)
   # ]9 d5 r  T. L- y
4. {
   % X; e" {) _2 Y0 R" R
5.   KEY_CONFIG(gpio, pin);
   / B& r' X7 j/ J- N$ F% F( g
6. }
   
7. 
   ' T1 m9 w' o% m( p) y
8. typedef struct
   
9. {
   
10.   GPIO_TypeDef *gpio;
    
11.   uint16_t pin;
    * B, L3 R! {) x; \1 C* O
12. } key_port_t;
      D' p4 l$ C0 o( n+ l7 s
13. 
    , w+ V( W% v2 ^
14. static key_port_t key_entries[] =
    1 B$ D0 n9 d0 S6 H; s
15. {
    9 C  u  g8 [* e1 R8 }1 M7 T9 @
16.   {KEY1_PORT, KEY1_PIN},
    $ U! v4 {' S8 U! c
17.   {KEY2_PORT, KEY2_PIN},
    ' Q! s) x' Q" C% E7 i' R! x" ?
18.   {KEY3_PORT, KEY3_PIN},
    5 }! G: Y; X: i8 m& `
19. };
    % q% `7 \7 M5 W% G; M1 j8 b
20. 
    0 K4 I$ ~2 [, W" K0 g. R
21. void KeyInit(void)
    
22. {
    
23.   uint32_t i, mask = 1;
    
24. 
    
25.   for(i = 0; i < ARRAY_SIZE(key_entries); ++i)
    $ j5 }* X; b. X% {2 _/ C/ Z
26.   {
    
27.     if(0xFFFFFFFF & mask)
    
28.     {
    ) v& O% o9 d) Y1 P
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) // 测试时使用      
    
32.       //config.key.total_switch  = KEY_MODE_OPEN;
    & ?" c7 m% {2 D
33.       //config.key.sub_switch = KEY_MODE_OPEN;
      }8 W+ E5 M$ m# G/ K
34.       config.key.active_tag = KEY_LOW_IS_ACTIVE;
    6 |9 e1 W& r  [) S2 Q& a
35. #endif
    
36.     }
    
37. 
    
38.     mask <<= 1;
    
39.   }
    " @6 f# D$ N; |% r* A3 X- k
40. }
    . c+ z4 b4 }, n$ ^/ P) b2 P
41. 
    ) S# y+ D$ n7 T6 d. V% j
42. // 输入是否可用
    1 c" N+ l0 T6 {) w
43. static uint8_t key_is_enable(uint8_t index)
    4 O+ d3 v% |- j1 ]4 L& [0 p- N
44. {
    $ R4 T$ s" M) g; K( Q
45.   // 这里可以写成可配置 配置IO口可用或者不可用（类似一个总开关）
    
46.   return 1;
    
47. }
    
48. 
    8 v3 V& W. x) M! V( C
49. // 有输入到来
    
50. static uint8_t key_is_pressed(uint8_t index)
    * ^6 k# M0 l/ L, B/ e  V" a: Z
51. {
    ' _& b- S$ j# ?0 l) F( a
52.   if(key_is_enable(index))
    
53.   {
    0 x( u" _9 F- F
54.     if(KEY_LOW_IS_ACTIVE == config.key.active_tag[index])
    1 R4 P* `, E9 b$ [2 [1 J
55.     {
    
56.       if(KEY_READ(key_entries[index].gpio, key_entries[index].pin) == 0)
      ^0 |2 c  U7 |/ Y& C" N9 j
57.       {
    8 r0 q: w' [5 H' i5 w
58.         return 1;
    4 s" t; |$ N" J  d+ r
59.       }
    
60.     }
    / n" V* Z: {6 v! X- x
61.     else if(KEY_HIGH_IS_ACTIVE == config.key.active_tag[index])
    
62.     {
    5 Z' [5 r& Z; x! B8 [
63.       if(KEY_READ(key_entries[index].gpio, key_entries[index].pin) == 1)
    
64.       {
    ( ]: e! P. C0 f  B8 I5 j
65.         return 1;
    
66.       }
    
67.     }
    5 F, K6 V! G% o4 c" s8 H! e5 R) K
68.   }
    
69. 
    & W) l9 o' a2 c5 ^% c. ?
70.   return 0;
    
71. }
    
72. 
    
73. // 按键被按下
    , d7 L5 N, z" i% w9 z
74. uint8_t Key1IsDown(void)
    " K* ^, C% U6 V& J2 v# m! l
75. {
    
76.   return key_is_pressed(0);
    4 E2 e) r# A2 L* \2 n% ]) w7 n
77. }
    6 n: [' e/ M3 j/ L
78. 
    1 A2 G' |$ Y5 M. X& P1 |+ e
79. uint8_t Key2IsDown(void)
    
80. {
    9 F9 h% D, v) \% m) Z# U
81.   return key_is_pressed(1);
    ' W+ B! R# H6 {' G+ Q
82. }
    & H7 m5 Q: y# i  w- z
83. 
    
84. uint8_t Key3IsDown(void)
    % q7 e8 C6 j8 X* @, [; ~0 P
85. {
    
86.   return key_is_pressed(2);
    
87. }</span></span>

复制代码

& M5 f( I) `9 j9 ~7 N二、输入扫描
& n: h* Q; |* F6 C$ R6 ?

1. // 按键的状态机结构定义
   
2. // 按键状态
   & d3 v  L+ X) `5 W7 C' J
3. typedef enum
   ( k1 O9 K1 Z' v: S9 D9 g
4. {
   / T: ^' F* U/ i, C) X* {
5.   KEY_STATE_INIT, // 缺省按键状态
   - @3 q1 U" k. O& O+ ?- b# I6 K
6.   KEY_STATE_UP,   // 按键弹起状态
   & i  Q& Y8 b! H# W' R
7.   KEY_STATE_DOWN, // 按键按下状态
   * D, O$ N' K1 Q4 c- ~, b( I5 S, v
8.   KEY_STATE_LONG, // 按键长按状态
   
9.   KEY_STATE_AUTO, // 按键自动连发状态
   % N0 A& \, Q4 t1 x
10. } key_state_t;
    
11. 
    
12. // 按键滤波时间20ms, 单位10ms。
    
13. // 只有连续检测到20ms状态不变才认为有效，包括弹起和按下两种事件
    + c8 ~: t7 H) j! H* [/ Y  X
14. // 即使按键电路不做硬件滤波，该滤波机制也可以保证可靠地检测到按键事件
    
15. #define KEY_FILTER_TIME 2   // 滤波消抖
    2 m% I/ h: Q6 y9 o0 Z. x2 T2 ^
16. #define KEY_LONG_TIME   100 // 单位10ms    持续1秒，认为长按事件
    4 E, e  Y" t  c% I3 O, Z: A
17. #define KEY_REPEAT_TIME 100 // 单位10ms    持续1秒，自动连发
    
18. 
    
19. typedef uint8_t (*key_cb)(void);
    
20. typedef struct
    
21. {
    ) \% n7 ]/ q5 U% u
22.   uint8_t state;        // 按键当前状态(按下还是弹起)
    
23.   uint8_t last;         // 上一次按键的状态
    
24.   uint8_t count;        // 滤波消抖计数器
    
25.   uint16_t long_time;   // 按键按下持续时间, 0表示不检测长按
    0 B+ p9 b1 @) ~, x) y. S( y& g
26.   uint16_t long_count;  // 长按计数器
    / p9 g, V# E, R& c8 N' z
27.   uint8_t repeat_speed; // 连续按键周期
    ' o* D* y/ }0 X* p5 X
28.   uint8_t repeat_count; // 连续按键计数器
    
29.   key_cb is_down_func;  // 按键按下的判断函数,1表示按下
    
30. } key_t;
    ) f' ~9 H$ @: z. D
31. 
    3 x; Q, ^. o4 Q0 u* X) i) a  Q
32. static key_t key_items[] =
    3 q% ~# Q& j0 p! Z+ P8 M
33. {
    . Z7 g0 w$ _$ @) ^" q) P
34.   {KEY_STATE_INIT, KEY_STATE_INIT, KEY_FILTER_TIME, KEY_LONG_TIME, 0, KEY_REPEAT_TIME, 0, Key1IsDown},
    9 i, k& `% S8 `. M- V: l
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},
    
37. };

复制代码

1. // 按键状态机key_scan
   % k% ^$ {1 \8 m  X/ ~
2. // 配置限制条件在这个函数里面加
   
3. static void key_scan_ext(key_t *entry, uint8_t i)
   2 p" @7 M' r, x
4. {
   
5.   switch(entry->state)
   
6.   {
   
7.   case KEY_STATE_INIT:
   
8.   case KEY_STATE_UP:
   2 ]5 `( N* D9 }. l9 {9 u
9.   {
   0 t1 M5 r2 g6 V$ {# \' }
10.     entry->state = KEY_STATE_DOWN; // 按键被按下
    8 _0 g8 ?% G* @2 p/ p1 ~8 k8 h" J- P8 f7 y
11.     break;
    & a4 T4 z( g+ [& Q2 B
12.   }
    2 U; @& \. k6 W$ G( z
13. 
    
14.   case KEY_STATE_DOWN:
    
15.   {
    ) x& C% a; R$ _8 n1 j
16.     if(entry->long_time > 0)
    & ?# X1 M3 p! s+ ?+ F
17.     {
    
18.       if(entry->long_count < entry->long_time)
    
19.       {
    
20.         if(++entry->long_count >= entry->long_time)
    1 t7 S% u. C0 ~* \
21.         {
    
22.           entry->state = KEY_STATE_LONG;
    3 R9 H0 r9 `- z7 D9 j
23.         }
    
24.       }
    3 y' @) y- I% k
25.     }
    
26. 
    
27.     break;
    . W7 O+ _; Q  h5 ~+ Y" d
28.   }
    
29. 
    
30.   case KEY_STATE_LONG:
    , K  ]0 P/ X% I: e
31.   {
    
32.     if(entry->repeat_speed > 0) // 自动连发时间到  自动连发事件
    
33.     {
    6 s7 u' G# t3 N; o- @9 `
34.       if(++entry->repeat_count >= entry->repeat_speed)
    
35.       {
    
36.         entry->repeat_count = 0;
    : p+ q+ [5 e0 A  q3 v' Z
37.         // 长按触发
    5 V1 O- y9 K/ X: S
38.       }
    
39.     }
    * @5 }7 x- \7 x
40. 
    3 }. v$ a. ]( z+ [1 p
41.     break;
    
42.   }
    . b, I; C* x! u
43.   }
    6 x. r5 r* q, ^
44. 
    1 m6 k, j0 d  ^- S3 [% N
45.   entry->last = entry->state; // 最新的按键状态
    . f+ o) \/ n- u& v
46. }
    0 }8 F( [: M9 B% S% Y
47. 
    & c  y$ V+ w/ v* M% h8 M7 E
48. static void key_scan(uint8_t i)
    " Q4 n6 Y( j$ n- x
49. {
    7 \' N$ f4 E# L% d
50.   key_t *entry = &key_items<span style="font-style: italic;"><span style="font-style: normal;">;
    + Y0 ]4 Z6 j+ k9 V
51.         uint8_t key;
    , W# G" U4 E% O
52. 
    
53.   if(entry->is_down_func())
    " Z' Z9 S* @' i/ w: A
54.   {
    : ]+ `- ~& o* V8 N  m: G6 c( i3 V
55.     if(entry->count < KEY_FILTER_TIME) // 消抖
    
56.     {
    ; g- t; V1 d, P6 Z
57.       ++entry->count;
    
58.     }
    9 m: ]) e" g9 @1 Z  {; n
59.     else
    7 ]8 W% t6 B, h
60.     {
    
61.       key_scan_ext(entry, i); // 按键扫描状态机
    
62.     }
    
63.   }
    4 i% n: e; A* o5 H
64.   else
    # Q+ ^8 H3 N' R$ }" N% n* x. K6 m
65.   {
    
66.     if(entry->count > KEY_FILTER_TIME)
    
67.     {
    ! ?+ O9 @/ g$ n
68.       entry->count = KEY_FILTER_TIME;
    $ ^# k$ m3 y7 o8 p) }# A" t
69.     }
    
70.     else if(entry->count > 0)
    2 U1 M8 R& {  m8 u: q( W
71.     {
    
72.       --entry->count;
    
73.     }
      \$ f% G  }! M6 f) x$ J) p/ y5 y
74.     else
    7 B4 A9 h. s$ y/ r
75.     {
    
76.       if(KEY_STATE_DOWN == entry->last) // 一次完整的按键到这里就弹起了
    
77.       {
    . }& Y8 ~9 c0 i/ ]" I0 z2 Q$ h
78.        // 按键按下之后可以加入到队列中，这里的队列可以自己写；如果带系统可以使用系统的消息队列等方式。
    
79.        // key = i + 1;
    
80.        // xQueueSend(os_key_queue, &key, 10);
    7 g; G0 ?8 i. q: n: K# r
81.       }
    
82.       entry->last  = KEY_STATE_UP;
    - t: X) K+ {: T- z7 s
83.       entry->state = KEY_STATE_UP; // 按键弹起状态
    - I* A: H) H1 m0 a3 s7 @( n
84.     }
    7 w+ K  d5 B% X
85. 
    
86.     entry->long_count = 0;
    ( ~) H& M! F9 l+ [0 P4 A8 b
87.     entry->repeat_count = 0; // 清空计数器
    
88.   }
    
89. }</span></span>

复制代码

三、输入处理

1. // 按键按下之后，会将值加入到队列中，我们读取队列数据，然后扫描列表匹配功能
   ( F2 J: z) g& U) B" z
2. static void key1_cb(void);
   
3. static void key2_cb(void);
   1 Q' \' A6 H; k) }8 V: Y
4. static void key3_cb(void);
   
5. 
   2 k/ K& ~0 k/ n/ k
6. #define KEY1_CMD         1
   
7. #define KEY2_CMD         2
   
8. #define KEY3_CMD         3
   * e+ p% |( Y2 ^9 e/ P& F
9. 
   ) D: _1 Z, T5 i# @5 F* w
10. typedef struct
    % y" [/ Z" T7 T) k6 {, Q- ]) v
11. {
    6 e3 S% m# y4 D" G. J2 i  e8 `) ^
12.   uint8_t cmd;
    5 ?: Y& C; T' {8 N0 `2 B
13.   void (* key_handle_cb)(void);
    
14. } key_handle_t;
    
15. 
    
16. static const key_handle_t key_entries[] =
    * Z0 @, c$ f) I. w* Y1 Z; t
17. {
    
18.   {KEY1_CMD, key1_cb},
    
19.   {KEY2_CMD, key2_cb},
    
20.   {KEY3_CMD, key3_cb},
    * R4 T1 y0 {$ o  a. E/ O
21.   {0xFF, NULL  },
      Q! t$ o& F9 ^5 Z5 |( ~
22. };
    - n3 L* t# W% K9 o% ~" t7 l
23. 
    3 f$ M7 K" s9 _) R5 m$ B0 R6 C  |
24. // 按键的通用功能
    
25. static void key_func(uint8_t func)
    
26. {
    
27. 
    2 V0 `; e+ _9 d& w0 ]+ X; f) s$ y5 Q* M
28. }
    
29. 
    5 \4 i/ ~3 h8 i8 v+ E
30. static void key1_cb(void)
    0 s7 ~. A7 ^& j: c; d
31. {
    ' y( J  Q9 N: c" s0 g
32. 
    " t) y4 \& s, A, M# J8 x
33. }
    
34. 
    
35. static void key2_cb(void)
    ( d3 I. R$ b. X( j
36. {
    
37. 
    ( H( T! d& M* t5 U. b! C
38. }
    7 Z9 n, T. B! W, _& J. f, K
39. 
    3 S( j7 ^0 U" w1 h
40. static void key3_cb(void)
    
41. {
    ) {! w2 {% c- j& `/ F$ @" Z$ j
42. 
    * `; w% a7 Z2 t+ |) v
43. }
    
44. 
    
45. static void key_process(uint8_t event)
    
46. {
    1 c6 O* {: E. }3 |" `2 J7 ^
47.   const key_handle_t *entry;
    
48. 
    5 J$ h; ^. G8 T; c0 m1 @7 W
49.   for(entry = key_entries; entry->key_handle_cb; ++entry)
    
50.   {
    
51.     if(event == entry->cmd)
    
52.     {
    ; P5 h: }& K+ K9 q( q
53.       entry->key_handle_cb();
    ( ^' A; G7 z2 p2 E6 H) [& b. I
54.       break;
    
55.     }
    $ _: J: w/ \/ @; `3 l6 O
56.   }
    
57. }

复制代码

% M5 {2 |/ k% c3 r8 Q0 r裸机：按键扫描20ms执行一次，按键处理直接丢在主函数中。（自己写队列）
& H2 |) p+ S+ Y
系统：在任务中执行按键扫描和按键处理。（系统自带队列或者邮箱）


) ^, I! [, n6 |/ r5 s