一、输入配置
7 `0 L( x- K: g" J2 k为了灵活使用，我们将输入的有效电平设置成可配置。同样是列表表示所有IO口。
. v$ R; Z% ~  d/ a

1. // 配置有效电平
   # x, e2 e" ^+ G* N1 t. K
2. typedef enum
   8 u% q5 G# i# _* T- B+ O! B
3. {
   5 N1 p( d: a7 W% ]% U3 r9 x, m
4.   KEY_INIT_IS_ACTIVE = 0,
   6 W% D( b/ r: i& J3 g, X2 W
5.   KEY_LOW_IS_ACTIVE  = 1,
   
6.   KEY_HIGH_IS_ACTIVE = 2,
   / Z4 K" ?- ]8 l
7. } key_active_t;
   
8. 
   
9. 
   
10. #define KEY_CONFIG(gpio, pin)     GPIOConfig(gpio, pin, GPIO_MODE_INPUT, GPIO_PULLUP)
      ?8 \' w' i4 g0 V
11. #define KEY_READ(gpio, pin)       HAL_GPIO_ReadPin(gpio, pin)
    
12. 
    * \  C) \4 P! n; Y' D) N! D9 X) e1 L
13. #define KEY1_PORT                 GPIOH
    
14. #define KEY1_PIN                  GPIO_PIN_3
    
15. 
    
16. #define KEY2_PORT                 GPIOH
    : L9 w" j# R7 U* n" h7 M
17. #define KEY2_PIN                  GPIO_PIN_2
    
18. 
    
19. #define KEY3_PORT                 GPIOC
    0 G# k- k# l( `  o' C
20. #define KEY3_PIN                  GPIO_PIN_13

复制代码

1. // demo代码 只传递思想
   1 ^7 w+ N1 l7 U
2. 
   + [. u7 G+ v0 W' h! N9 d
3. static void key_gpio_config(GPIO_TypeDef *gpio, uint16_t pin)
   ; a" n% u- ~' S' I
4. {
   
5.   KEY_CONFIG(gpio, pin);
   
6. }
   , M/ c* V" a5 k4 U% ]" O0 j
7. 
   
8. typedef struct
   
9. {
   ' B6 ]3 _& j: M0 E# X
10.   GPIO_TypeDef *gpio;
    / J( s$ {/ ^" Q- ?  W$ H
11.   uint16_t pin;
    
12. } key_port_t;
      B" b' k4 k& d) p
13. 
    
14. static key_port_t key_entries[] =
    
15. {
    
16.   {KEY1_PORT, KEY1_PIN},
    . M- K, a, v# C
17.   {KEY2_PORT, KEY2_PIN},
    
18.   {KEY3_PORT, KEY3_PIN},
    
19. };
    ( P3 m8 P2 f' w# v9 o
20. 
    2 Q% n: ]) [! Y3 `8 \2 }. k
21. void KeyInit(void)
    , G' `/ R. [7 c$ T
22. {
    % |( h' m/ J" ?2 q+ d1 W; _
23.   uint32_t i, mask = 1;
    $ p* e* ^5 T1 _! I
24. 
    % ^$ [' |( Y- j5 f, y% t6 l
25.   for(i = 0; i < ARRAY_SIZE(key_entries); ++i)
    / ~! q" Z1 l- L& g; \
26.   {
    
27.     if(0xFFFFFFFF & mask)
    # J% S& d8 J5 _0 i' R, L+ Z3 n
28.     {
    
29.       key_gpio_config(key_entries<span style="font-style: italic;">.gpio, key_entries.pin);
    $ Y1 z$ D: i9 S- i& L  F
30. 
    + c& f3 [: E& h0 P. f, H
31. <span style="font-style: normal;">#if(CONFIG_KEY_TEST == 1) // 测试时使用      
    - D8 J2 u: k9 ?/ q7 d' K% ]- h* e' n
32.       //config.key.total_switch  = KEY_MODE_OPEN;
    
33.       //config.key.sub_switch = KEY_MODE_OPEN;
    * ~& ]6 O& _% E' A) }6 d
34.       config.key.active_tag = KEY_LOW_IS_ACTIVE;
    
35. #endif
    7 r. t! _1 L$ }& U3 e6 E; V
36.     }
    - {- \, F# `, ^7 J/ x, s
37. 
    / N5 U( ~! u" i4 @* i7 h' u
38.     mask <<= 1;
    
39.   }
    
40. }
    
41. 
    
42. // 输入是否可用
    
43. static uint8_t key_is_enable(uint8_t index)
    
44. {
    
45.   // 这里可以写成可配置 配置IO口可用或者不可用（类似一个总开关）
    
46.   return 1;
    
47. }
    ; T4 U4 i2 j/ X* C! c- \
48. 
    1 ]2 G5 q/ l( J3 Q0 P3 g
49. // 有输入到来
    
50. static uint8_t key_is_pressed(uint8_t index)
    ; a! T& \6 h# A9 \/ g  H: Z7 n3 c
51. {
    
52.   if(key_is_enable(index))
    2 m9 i$ V7 G- h/ e, [
53.   {
    0 c3 u3 r9 t8 j
54.     if(KEY_LOW_IS_ACTIVE == config.key.active_tag[index])
    , ~3 f  [# j( G+ K& J
55.     {
    
56.       if(KEY_READ(key_entries[index].gpio, key_entries[index].pin) == 0)
    
57.       {
    
58.         return 1;
    
59.       }
    
60.     }
    
61.     else if(KEY_HIGH_IS_ACTIVE == config.key.active_tag[index])
    
62.     {
    
63.       if(KEY_READ(key_entries[index].gpio, key_entries[index].pin) == 1)
    - p* I; t, n) [2 z& V
64.       {
    
65.         return 1;
    5 o/ e8 d4 f  a. d; s$ y: C
66.       }
    ' \5 \  D$ }5 g, @( e; L- Y
67.     }
    . Z6 Y4 O* E8 R" g
68.   }
    * \. O1 L# k: U! x
69. 
    8 e& O0 s1 ^6 F
70.   return 0;
    
71. }
    
72. 
    6 ~3 N+ ?) w% l1 e0 i& j- b
73. // 按键被按下
    7 S' p" s5 G* J5 L0 z9 e
74. uint8_t Key1IsDown(void)
    
75. {
    ! w+ W7 H2 c+ h$ L* M8 T
76.   return key_is_pressed(0);
    ' V/ Z- i; M4 w% a
77. }
    
78. 
    + p4 a, y3 z- v4 \
79. uint8_t Key2IsDown(void)
    " h4 G1 s( E& }6 H5 o( }& h' E
80. {
    - E( M0 ~' i& o0 N/ t4 u
81.   return key_is_pressed(1);
    % y; F6 X  u/ K
82. }
    # z9 C2 ~9 m, Z  Z( v) |$ w
83. 
    
84. uint8_t Key3IsDown(void)
    
85. {
    / i% P( O8 j' m/ o" S3 W  u
86.   return key_is_pressed(2);
    
87. }</span></span>

复制代码

! j. U" v  ^0 {二、输入扫描

1. // 按键的状态机结构定义
   
2. // 按键状态
   
3. typedef enum
   $ {: L. k: S' ?7 |
4. {
   ' A$ l% }, J3 M$ a! W
5.   KEY_STATE_INIT, // 缺省按键状态
   / P. Y* ]2 s  j$ t1 G6 A
6.   KEY_STATE_UP,   // 按键弹起状态
   ' L0 d6 o! o' H/ b
7.   KEY_STATE_DOWN, // 按键按下状态
   
8.   KEY_STATE_LONG, // 按键长按状态
   
9.   KEY_STATE_AUTO, // 按键自动连发状态
   
10. } key_state_t;
    
11. 
    ) Z4 p  u+ u" Z% S7 L7 {5 i
12. // 按键滤波时间20ms, 单位10ms。
    5 q1 L# i6 |3 d5 |: X9 m1 p$ k
13. // 只有连续检测到20ms状态不变才认为有效，包括弹起和按下两种事件
    
14. // 即使按键电路不做硬件滤波，该滤波机制也可以保证可靠地检测到按键事件
    . c' I5 k$ g, v( @% X3 N* U
15. #define KEY_FILTER_TIME 2   // 滤波消抖
    , d0 q" @: `0 z0 w, k+ i0 }! u
16. #define KEY_LONG_TIME   100 // 单位10ms    持续1秒，认为长按事件
    
17. #define KEY_REPEAT_TIME 100 // 单位10ms    持续1秒，自动连发
    
18. 
    
19. typedef uint8_t (*key_cb)(void);
    
20. typedef struct
    
21. {
    - F# @) n0 A7 `: I6 @7 f$ S/ F
22.   uint8_t state;        // 按键当前状态(按下还是弹起)
    
23.   uint8_t last;         // 上一次按键的状态
    9 U! N/ Y5 `" x; x4 F
24.   uint8_t count;        // 滤波消抖计数器
    
25.   uint16_t long_time;   // 按键按下持续时间, 0表示不检测长按
    - t- E( W2 O4 C# Z
26.   uint16_t long_count;  // 长按计数器
    
27.   uint8_t repeat_speed; // 连续按键周期
    
28.   uint8_t repeat_count; // 连续按键计数器
    2 ~7 ]* p# O! K/ t/ y
29.   key_cb is_down_func;  // 按键按下的判断函数,1表示按下
    ) q# @/ f2 @6 o  I2 A/ P4 f9 \
30. } key_t;
    : s+ H1 r3 P7 A2 n' j" }
31. 
    7 [& k; ^0 U, E' _$ m& R
32. static key_t key_items[] =
    . ~9 n$ ?' A3 x- E" j* A3 D. X) o
33. {
    
34.   {KEY_STATE_INIT, KEY_STATE_INIT, KEY_FILTER_TIME, KEY_LONG_TIME, 0, KEY_REPEAT_TIME, 0, Key1IsDown},
    1 K0 v1 l2 |! Q! B. K2 P6 ^4 G, l
35.   {KEY_STATE_INIT, KEY_STATE_INIT, KEY_FILTER_TIME, KEY_LONG_TIME, 0, KEY_REPEAT_TIME, 0, Key2IsDown},
    " e" B3 p2 X2 V: d8 `, a/ Q
36.   {KEY_STATE_INIT, KEY_STATE_INIT, KEY_FILTER_TIME, KEY_LONG_TIME, 0, KEY_REPEAT_TIME, 0, Key3IsDown},
    ( s4 ]' j/ U  K# l9 z
37. };

复制代码

1. // 按键状态机key_scan
   
2. // 配置限制条件在这个函数里面加
   
3. static void key_scan_ext(key_t *entry, uint8_t i)
   ( J$ ^) O/ o8 b) @- j
4. {
   7 A% \; d! }# R9 n9 c
5.   switch(entry->state)
   
6.   {
   2 r5 ?& w; q6 e5 O( g% J
7.   case KEY_STATE_INIT:
   
8.   case KEY_STATE_UP:
   
9.   {
   % P( N# z+ |, d, M/ f8 o; t
10.     entry->state = KEY_STATE_DOWN; // 按键被按下
    
11.     break;
    $ k# E* Z! s2 c" |/ S% ^
12.   }
    . c5 m- S, b& f3 n. k  F
13. 
    
14.   case KEY_STATE_DOWN:
    9 v3 a& ]) G; \3 o) H& I6 j
15.   {
    " l" E" X; P1 }: \. u8 i" c# N
16.     if(entry->long_time > 0)
    
17.     {
    : }9 ]' j4 U$ z: e2 z% c
18.       if(entry->long_count < entry->long_time)
    
19.       {
    
20.         if(++entry->long_count >= entry->long_time)
    ' u7 e5 A8 z0 {. ^) m' j
21.         {
    , z# D5 ~, [) V- A7 [) C1 e; h) X
22.           entry->state = KEY_STATE_LONG;
    8 X! G6 |2 E$ W. h2 P
23.         }
    
24.       }
    
25.     }
    
26. 
    
27.     break;
    
28.   }
    - |, Y5 x, a" r5 t' W
29. 
    % _% V  i- o4 M) y- W* n
30.   case KEY_STATE_LONG:
    
31.   {
    2 U; w/ ]; Q( `( I, S
32.     if(entry->repeat_speed > 0) // 自动连发时间到  自动连发事件
    : Z2 S* c; p, {/ r& a9 y
33.     {
    
34.       if(++entry->repeat_count >= entry->repeat_speed)
    
35.       {
    5 I9 l3 ~% s/ B# y& a; A
36.         entry->repeat_count = 0;
    : Q6 ~/ E; k2 a1 H8 d- \( r! Y
37.         // 长按触发
    # D& @0 a# t- p& m/ I1 U0 q
38.       }
    
39.     }
    
40. 
    7 @# H9 K' d/ P) X; N
41.     break;
    1 V: c8 t0 O9 o: T
42.   }
    
43.   }
    & g& X- y4 M5 a8 s5 d& P
44. 
    
45.   entry->last = entry->state; // 最新的按键状态
    
46. }
    5 Y+ t! N& a, j
47. 
    3 S* m$ A$ H2 m. f5 O6 a/ d
48. static void key_scan(uint8_t i)
    % c/ f" V' |& U
49. {
    
50.   key_t *entry = &key_items<span style="font-style: italic;"><span style="font-style: normal;">;
    % b& [. w/ }% N& t. `" q! y- E
51.         uint8_t key;
    ; f4 p: \2 i' P
52. 
    3 G* h6 P9 T' j/ Z
53.   if(entry->is_down_func())
    
54.   {
    # v, G$ R6 }4 o
55.     if(entry->count < KEY_FILTER_TIME) // 消抖
    % v- w% f0 H* O
56.     {
    
57.       ++entry->count;
    
58.     }
    1 I& a( o8 R+ m" Y7 t' e, ?
59.     else
    0 K6 ~/ x6 \7 a2 a1 n1 w' h
60.     {
    
61.       key_scan_ext(entry, i); // 按键扫描状态机
    
62.     }
    ( t; P, a9 z- k$ q2 v7 R
63.   }
    
64.   else
    ) b( b& F( R% d. \9 `8 U
65.   {
    
66.     if(entry->count > KEY_FILTER_TIME)
    
67.     {
    7 M+ S- X; x5 L: {- ?& K2 R
68.       entry->count = KEY_FILTER_TIME;
    7 W. Q; u9 U6 O/ y
69.     }
    / k! c, f6 N' ~* ^
70.     else if(entry->count > 0)
    3 u  u7 e1 I& X1 R
71.     {
    , u. u  U6 T7 K- o/ `; Q* p" @: I( n
72.       --entry->count;
    - y: N, X' Z2 }: B
73.     }
    
74.     else
    0 G/ ~4 j6 V! N# I+ S; ?
75.     {
    
76.       if(KEY_STATE_DOWN == entry->last) // 一次完整的按键到这里就弹起了
    ! p8 ]* j$ {( @# s$ e
77.       {
    
78.        // 按键按下之后可以加入到队列中，这里的队列可以自己写；如果带系统可以使用系统的消息队列等方式。
    . v9 Q9 h2 {% N
79.        // key = i + 1;
    
80.        // xQueueSend(os_key_queue, &key, 10);
    * g( c% d( _& Z% W0 Y# T, P
81.       }
    6 v  f9 t* r2 J; u' @- _( O& _3 s3 w
82.       entry->last  = KEY_STATE_UP;
    
83.       entry->state = KEY_STATE_UP; // 按键弹起状态
    
84.     }
    
85. 
    
86.     entry->long_count = 0;
    9 \9 Z8 u0 g+ _/ w' h" q* c
87.     entry->repeat_count = 0; // 清空计数器
    + h2 Q: |% Q) T- k
88.   }
    
89. }</span></span>

复制代码

# }% }0 G) o: t% `( S三、输入处理
8 y! p8 x& h: \1 n' Y5 O& m

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
   
7. #define KEY2_CMD         2
   9 V% l  c* c9 p% |  q) k
8. #define KEY3_CMD         3
   2 p& ], w* S; H; z% F- }% f4 |5 H
9. 
   4 T& Y- c( M6 A* I! @. N  r# W+ b' R: N
10. typedef struct
    
11. {
    
12.   uint8_t cmd;
    2 H$ D) L* K5 q2 l  q. ?( ?
13.   void (* key_handle_cb)(void);
    
14. } key_handle_t;
    
15. 
    ' r- ]4 M! ^8 \; y# r
16. static const key_handle_t key_entries[] =
    + m6 U. w, u" d  e, T( b7 f) p
17. {
    4 [6 ^) l" f9 Z0 _+ C7 {
18.   {KEY1_CMD, key1_cb},
    8 x# b5 \5 y/ a. [# N$ K$ T
19.   {KEY2_CMD, key2_cb},
    0 Q2 f) o% N; J  o- z/ v
20.   {KEY3_CMD, key3_cb},
    ) j' x, }' _% P
21.   {0xFF, NULL  },
    ! @& t3 d: f' T  N! t
22. };
    ! r8 ~0 h7 i. m/ a: v
23. 
    / Z4 }, V3 B; K% _6 a
24. // 按键的通用功能
    - w8 A! n8 v8 ~: Y
25. static void key_func(uint8_t func)
    2 |% i0 R: X3 E2 `
26. {
    
27. 
    
28. }
      j! i% b' j' b! [
29. 
    ! _6 m7 Z7 }! ]3 G8 y6 g" L/ f
30. static void key1_cb(void)
    0 I/ y6 m8 C5 u& l; D
31. {
    
32. 
    % D9 ~  A) A5 y, _/ g
33. }
    * z- J" e+ f6 `7 N$ n+ r
34. 
    
35. static void key2_cb(void)
    9 Y4 y  W' T4 a  p( i, U6 G# w
36. {
    
37. 
    7 E1 l# b2 D: D  i1 y
38. }
    ; B) Z+ k! s" s2 w
39. 
    
40. static void key3_cb(void)
    + O* i( N+ m. ?- ~' C
41. {
    * b: X0 Z2 \/ I0 s3 m$ Y
42. 
    ; T+ J4 s7 |$ k! H3 o# a& a
43. }
    7 s. W8 w) i( o# F. |& N. @# P9 p: q
44. 
    4 }! ^8 Q: N) ~% x, x# U& j8 n7 h
45. static void key_process(uint8_t event)
    ( [$ G% d  x5 [9 ^" W2 j( H; S! U
46. {
    
47.   const key_handle_t *entry;
    1 s$ C3 q* i8 F; i0 v
48. 
    . v! h- c  Y0 i2 {' O
49.   for(entry = key_entries; entry->key_handle_cb; ++entry)
    1 S1 L+ D) p4 J
50.   {
    ! m3 f* C# S/ h8 G# V8 |) V
51.     if(event == entry->cmd)
    ; V0 u* u9 u% `5 B
52.     {
    ) P( k- m7 ?4 X  l  [, i
53.       entry->key_handle_cb();
    
54.       break;
    
55.     }
    & L; C* J8 b& n
56.   }
    8 b# _4 k. T! _9 M
57. }

复制代码

/ \6 G" [$ U* ^1 n  D8 Q' `8 g裸机：按键扫描20ms执行一次，按键处理直接丢在主函数中。（自己写队列）

系统：在任务中执行按键扫描和按键处理。（系统自带队列或者邮箱）
/ _5 j* l% T$ i" l& [( M+ [
6 A9 {2 `9 I& A7 I" x( Y4 Z; }3 V( U
; Y: o+ B  t& F