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

1. // 配置有效电平
   
2. typedef enum
   . u2 |" j% T! m4 D& Q6 `) h! I
3. {
   ) N3 I1 U$ W  j+ Q& F2 s/ b
4.   KEY_INIT_IS_ACTIVE = 0,
   1 a, I+ ~8 x7 t: L. c
5.   KEY_LOW_IS_ACTIVE  = 1,
   $ {( d& }4 h/ L, v0 |* G- C
6.   KEY_HIGH_IS_ACTIVE = 2,
   $ d7 O0 x- m3 l4 N+ @
7. } key_active_t;
   , M' a- s! t1 V5 ~" w" F! k
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)
      z" z3 [4 `/ b# U( m
12. 
    
13. #define KEY1_PORT                 GPIOH
      M1 w  ]: q. b8 |/ v& D
14. #define KEY1_PIN                  GPIO_PIN_3
    
15. 
    0 h6 q, u/ }1 f: P/ W. W; Y
16. #define KEY2_PORT                 GPIOH
    * U4 C$ p1 d( Q  v) ^% A1 d. O
17. #define KEY2_PIN                  GPIO_PIN_2
    
18. 
    $ n3 f8 g+ A& x; H% `
19. #define KEY3_PORT                 GPIOC
    * C+ _( k1 k+ c
20. #define KEY3_PIN                  GPIO_PIN_13

复制代码

1. // demo代码 只传递思想
   * F' y6 X6 ^! p( K
2. 
   
3. static void key_gpio_config(GPIO_TypeDef *gpio, uint16_t pin)
   
4. {
   
5.   KEY_CONFIG(gpio, pin);
   
6. }
   ; e, ~* z5 q: v2 n
7. 
   ! I" `3 |8 o7 \- C5 P# v2 R% t! W
8. typedef struct
   3 ]7 {& }/ k! h4 p/ R
9. {
   * I7 y; C+ m: {9 L3 Z
10.   GPIO_TypeDef *gpio;
    8 Q. N9 ~  _8 B! E* ~
11.   uint16_t pin;
    
12. } key_port_t;
    
13. 
    
14. static key_port_t key_entries[] =
    
15. {
    
16.   {KEY1_PORT, KEY1_PIN},
    / N* F( N$ u0 h) ^
17.   {KEY2_PORT, KEY2_PIN},
    . x+ ?+ S$ J. H5 t: w/ L
18.   {KEY3_PORT, KEY3_PIN},
    % [! g4 W# O+ A" O' j) E
19. };
    6 m: u' A& G4 ~  \) ]  x
20. 
    
21. void KeyInit(void)
    ' [: P* F5 X1 U& x
22. {
    : A8 Z, }! ~3 X
23.   uint32_t i, mask = 1;
    7 x+ m5 `) r0 M( O* i8 V
24. 
    
25.   for(i = 0; i < ARRAY_SIZE(key_entries); ++i)
    * m! s) ]8 u9 i2 ?0 g. r  p
26.   {
    : O( W) e# v9 z* \
27.     if(0xFFFFFFFF & mask)
    9 y- P1 i& v6 j9 P& z9 R1 f
28.     {
    : C' x4 T, i! G5 D
29.       key_gpio_config(key_entries<span style="font-style: italic;">.gpio, key_entries.pin);
    , u. N( r/ t2 Q3 @" u6 v
30. 
    
31. <span style="font-style: normal;">#if(CONFIG_KEY_TEST == 1) // 测试时使用      
    
32.       //config.key.total_switch  = KEY_MODE_OPEN;
    ; V2 L( j- T! l. q8 R2 C- t
33.       //config.key.sub_switch = KEY_MODE_OPEN;
    
34.       config.key.active_tag = KEY_LOW_IS_ACTIVE;
    
35. #endif
    . m4 c4 H% x. f0 w9 J
36.     }
    * N/ v, @! x# [2 |5 @
37. 
    1 u6 k: ]1 X* E* r- e7 T8 o5 \
38.     mask <<= 1;
    
39.   }
    
40. }
    
41. 
    
42. // 输入是否可用
    
43. static uint8_t key_is_enable(uint8_t index)
    
44. {
    ) _9 W6 b' P$ L
45.   // 这里可以写成可配置 配置IO口可用或者不可用（类似一个总开关）
    3 E% r* d% B% g/ }4 J( @) M
46.   return 1;
    ( L+ n# h5 B+ C$ x/ T+ x$ W3 S8 ~
47. }
    8 k% l! z9 R& M
48. 
    
49. // 有输入到来
    * ]) u8 q9 l) [8 G) X) |  D
50. static uint8_t key_is_pressed(uint8_t index)
    
51. {
    
52.   if(key_is_enable(index))
    
53.   {
    + {( }: B1 _- w& X
54.     if(KEY_LOW_IS_ACTIVE == config.key.active_tag[index])
    
55.     {
    ( z5 }2 D& c! p% K3 l
56.       if(KEY_READ(key_entries[index].gpio, key_entries[index].pin) == 0)
    ! l7 m8 |" j' M" g# F: G  r4 f
57.       {
    9 C' o* J: i9 w: N. b! G' i
58.         return 1;
    ) b6 k' W! Y) P1 q% M% L
59.       }
    - L5 N3 i! ^, h$ ^, d
60.     }
    7 c, p9 F) @# g8 ~( d5 {7 P
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)
    ; _0 i* R- I. ~1 `
64.       {
    0 Y7 |& c% s% t, e- g( b! _9 f
65.         return 1;
    
66.       }
    # C% r+ z( L) Q3 d8 d  i" I
67.     }
    
68.   }
    
69. 
    
70.   return 0;
    
71. }
    : E3 }) N, r& Q. X6 z
72. 
    
73. // 按键被按下
    
74. uint8_t Key1IsDown(void)
    
75. {
    5 O# S3 p" q# X, Q" ]8 ~
76.   return key_is_pressed(0);
    7 a, ?; x1 Z  Y
77. }
    2 v( E5 G8 n( z4 |! A) ]
78. 
    ; [: j# [8 w3 m3 g8 H
79. uint8_t Key2IsDown(void)
    ; Z$ Y+ `5 t. E+ K/ X( o% ]
80. {
    8 t. a, u/ a$ n
81.   return key_is_pressed(1);
    
82. }
    
83. 
    
84. uint8_t Key3IsDown(void)
    
85. {
    
86.   return key_is_pressed(2);
    & g5 u0 B3 |! V+ D$ p8 I
87. }</span></span>

复制代码

8 ~0 {5 v" b" g$ U5 O& k+ u二、输入扫描

1. // 按键的状态机结构定义
   ' X* G: g& V* C% K% f0 d1 I
2. // 按键状态
   . l/ E6 H% R4 j# J7 Q9 n1 t8 P' E% J
3. typedef enum
   
4. {
   ! R# e8 d5 v0 R
5.   KEY_STATE_INIT, // 缺省按键状态
   ; @/ R3 S9 y: d* p( k) y$ j
6.   KEY_STATE_UP,   // 按键弹起状态
   
7.   KEY_STATE_DOWN, // 按键按下状态
   : x( b/ T# P$ i+ B7 l6 m! F9 O
8.   KEY_STATE_LONG, // 按键长按状态
   ( F9 ~* I8 z; o
9.   KEY_STATE_AUTO, // 按键自动连发状态
   6 Q( M2 b+ }9 K8 r
10. } key_state_t;
    5 O) w# E; \, F6 `* n* S- d
11. 
    
12. // 按键滤波时间20ms, 单位10ms。
    
13. // 只有连续检测到20ms状态不变才认为有效，包括弹起和按下两种事件
    ) H: K. T8 ^- C9 |+ h
14. // 即使按键电路不做硬件滤波，该滤波机制也可以保证可靠地检测到按键事件
    
15. #define KEY_FILTER_TIME 2   // 滤波消抖
    ; g( O5 \" G0 d) p# I0 o- ~
16. #define KEY_LONG_TIME   100 // 单位10ms    持续1秒，认为长按事件
    
17. #define KEY_REPEAT_TIME 100 // 单位10ms    持续1秒，自动连发
    1 |7 ~! T5 A+ x; O( F. L2 [( {" v
18. 
    / u3 Q) A0 v$ V' P, Y8 X  ?
19. typedef uint8_t (*key_cb)(void);
    
20. typedef struct
    
21. {
    , j6 a/ E; w4 a
22.   uint8_t state;        // 按键当前状态(按下还是弹起)
    
23.   uint8_t last;         // 上一次按键的状态
    0 z' }. d5 q+ }! C: m
24.   uint8_t count;        // 滤波消抖计数器
    , [5 Z) l6 h' @6 {3 F" e4 U
25.   uint16_t long_time;   // 按键按下持续时间, 0表示不检测长按
    0 O* M& \( R4 ^9 D
26.   uint16_t long_count;  // 长按计数器
    
27.   uint8_t repeat_speed; // 连续按键周期
    
28.   uint8_t repeat_count; // 连续按键计数器
    
29.   key_cb is_down_func;  // 按键按下的判断函数,1表示按下
    
30. } key_t;
    + A% t! e8 b" }  p
31. 
    $ A8 _6 ~; ]; n% @& d
32. static key_t key_items[] =
    
33. {
    7 J# P0 F9 G  \/ Y
34.   {KEY_STATE_INIT, KEY_STATE_INIT, KEY_FILTER_TIME, KEY_LONG_TIME, 0, KEY_REPEAT_TIME, 0, Key1IsDown},
    ) I5 a- u% ^: T, }+ d4 P4 f1 H
35.   {KEY_STATE_INIT, KEY_STATE_INIT, KEY_FILTER_TIME, KEY_LONG_TIME, 0, KEY_REPEAT_TIME, 0, Key2IsDown},
    ( S. W( B6 M0 m- K# l3 `# m
36.   {KEY_STATE_INIT, KEY_STATE_INIT, KEY_FILTER_TIME, KEY_LONG_TIME, 0, KEY_REPEAT_TIME, 0, Key3IsDown},
    
37. };

复制代码

1. // 按键状态机key_scan
   3 r4 _! Y" A  O3 {+ ]* i- e
2. // 配置限制条件在这个函数里面加
   % B& ^4 ~" n& W3 k
3. static void key_scan_ext(key_t *entry, uint8_t i)
   6 u4 p0 n0 E5 h7 I/ D
4. {
   8 O. U  S/ d! c! o& _
5.   switch(entry->state)
   
6.   {
   
7.   case KEY_STATE_INIT:
   . P  e6 Z$ O/ r9 I# }
8.   case KEY_STATE_UP:
   2 N3 X* {' C3 x- f' u# x
9.   {
   
10.     entry->state = KEY_STATE_DOWN; // 按键被按下
    2 n" R* @% G/ q
11.     break;
    4 t& A0 x9 j" t# w: q
12.   }
    8 o' G! N; V' ^+ v
13. 
    & v8 |" n. S" e: v% U
14.   case KEY_STATE_DOWN:
    ' a% ]" c: g! C0 ^
15.   {
    1 p- M9 I) {/ Z7 D! ?, |1 H, t
16.     if(entry->long_time > 0)
    
17.     {
    4 ~% Q' N0 c* ^; U0 |$ N
18.       if(entry->long_count < entry->long_time)
    
19.       {
    
20.         if(++entry->long_count >= entry->long_time)
    % T! U1 s+ {+ K7 F" p  e% K) M$ U
21.         {
    # O! {9 g. f  S& g( |9 w- w
22.           entry->state = KEY_STATE_LONG;
    
23.         }
    
24.       }
    # Q% {- r& e2 Q  A
25.     }
    
26. 
      z) G$ k4 d% q8 u7 q- H  J
27.     break;
    # P: S( q+ f1 M/ j  R
28.   }
    ! I) i3 q! \: g& O- r9 [0 u& R
29. 
    
30.   case KEY_STATE_LONG:
    
31.   {
    - T5 o4 m0 W* \2 r& B" M( ?7 z' D
32.     if(entry->repeat_speed > 0) // 自动连发时间到  自动连发事件
    ! z/ o$ h5 P; T& {1 q" Q
33.     {
    + R4 H$ @) `+ p, ?3 p
34.       if(++entry->repeat_count >= entry->repeat_speed)
    
35.       {
    
36.         entry->repeat_count = 0;
    & ?* H2 f3 ^4 I( g
37.         // 长按触发
    ! z8 p2 H1 w8 E" Z# w  Q
38.       }
    
39.     }
    5 i- F! A2 l. Q: z0 Y
40. 
    
41.     break;
    
42.   }
    
43.   }
    
44. 
    
45.   entry->last = entry->state; // 最新的按键状态
    
46. }
    
47. 
    " C% q7 `9 t) h& d8 \
48. static void key_scan(uint8_t i)
    : F: c$ i* K3 K* x, f7 F
49. {
    $ q* g' x& i1 W3 X7 P! A4 Z% A, b3 A7 U
50.   key_t *entry = &key_items<span style="font-style: italic;"><span style="font-style: normal;">;
    & {5 j  F+ G! d# z4 T3 ]5 Y
51.         uint8_t key;
    ( R. K0 A. l, ^1 ~2 f% f$ r5 Q8 R
52. 
    
53.   if(entry->is_down_func())
    
54.   {
    ) t' |3 N# _) A% C# T: g
55.     if(entry->count < KEY_FILTER_TIME) // 消抖
    
56.     {
    
57.       ++entry->count;
    
58.     }
    
59.     else
    
60.     {
    $ [' @# u- z; e
61.       key_scan_ext(entry, i); // 按键扫描状态机
    6 V3 @. r+ x7 R* C& _
62.     }
    
63.   }
    ) h6 }2 j' S6 D& b! Z
64.   else
    
65.   {
    5 ?, w2 n* x0 C/ `. ]& c: Q# S" [7 ^' O
66.     if(entry->count > KEY_FILTER_TIME)
    
67.     {
    + j& P( N" _/ S+ v" K, Z( y
68.       entry->count = KEY_FILTER_TIME;
    9 z$ ~9 h, U7 F6 F- G
69.     }
    
70.     else if(entry->count > 0)
    3 x/ J% z7 z* F& G$ P
71.     {
    
72.       --entry->count;
    8 F! `/ ^" v2 i  D( a% c5 K
73.     }
    
74.     else
    
75.     {
    
76.       if(KEY_STATE_DOWN == entry->last) // 一次完整的按键到这里就弹起了
    . M. v& g- Q0 G7 Y7 ?4 f
77.       {
    7 a9 l/ f$ y' S/ [
78.        // 按键按下之后可以加入到队列中，这里的队列可以自己写；如果带系统可以使用系统的消息队列等方式。
    
79.        // key = i + 1;
    
80.        // xQueueSend(os_key_queue, &key, 10);
    
81.       }
    
82.       entry->last  = KEY_STATE_UP;
    / e. Q4 i$ T$ A2 o4 w2 X4 b+ p* T2 Y
83.       entry->state = KEY_STATE_UP; // 按键弹起状态
    4 W% S) t# J9 [3 [
84.     }
    9 g1 b2 D. o% n; a) Q% w! _# e
85. 
    
86.     entry->long_count = 0;
    
87.     entry->repeat_count = 0; // 清空计数器
      O+ F% q0 R" c0 J5 v4 b9 N' S
88.   }
    
89. }</span></span>

复制代码

0 d# B0 a9 r4 G三、输入处理
$ U! w) y, N6 l, v

1. // 按键按下之后，会将值加入到队列中，我们读取队列数据，然后扫描列表匹配功能
   ! s5 Y' \- a/ k" C7 S3 q! a; @4 q: z
2. static void key1_cb(void);
   6 J& ]8 B$ P) L7 Y& q
3. static void key2_cb(void);
   
4. static void key3_cb(void);
   
5. 
   
6. #define KEY1_CMD         1
   2 P3 ]7 P3 P5 N7 {; {
7. #define KEY2_CMD         2
   5 Q: z" X0 g" _) d# [
8. #define KEY3_CMD         3
   9 m3 x; l/ m* M5 s
9. 
   
10. typedef struct
    , Z/ Q+ x! w+ D: [( W
11. {
    
12.   uint8_t cmd;
    
13.   void (* key_handle_cb)(void);
    # R5 |0 U4 v9 H% R- [
14. } key_handle_t;
    
15. 
    
16. static const key_handle_t key_entries[] =
    3 D3 Z: N, d, v, X$ t4 G- H) |, n# s
17. {
    
18.   {KEY1_CMD, key1_cb},
    
19.   {KEY2_CMD, key2_cb},
    8 l5 M4 Q7 U3 F
20.   {KEY3_CMD, key3_cb},
    
21.   {0xFF, NULL  },
    
22. };
    8 U$ H# z  n2 J  e
23. 
    * D. [& y) v+ ?& `
24. // 按键的通用功能
    3 D# s+ \7 c! ]' T
25. static void key_func(uint8_t func)
    
26. {
    
27. 
    
28. }
    0 f- o7 g0 H$ r. b3 u" F- r& c5 c0 U1 F
29. 
    
30. static void key1_cb(void)
      m% h6 ?' s$ _: e. r
31. {
    ! D0 o7 g7 w4 `
32. 
    
33. }
    & g+ X# e0 U5 Y( j$ N+ @
34. 
    
35. static void key2_cb(void)
    2 `( z8 b3 ~. q( ]  m8 m3 g) F
36. {
    % i" o% k, W2 _$ i
37. 
    . s* y' J4 x' e
38. }
    7 T+ @3 u) [0 d: R7 L
39. 
    
40. static void key3_cb(void)
    
41. {
    $ T) d; v: |4 {4 N
42. 
    
43. }
    7 q6 ^' F7 O  Y
44. 
    9 D5 I1 y( |) W9 `1 k
45. static void key_process(uint8_t event)
      V2 y6 _; b1 g
46. {
    
47.   const key_handle_t *entry;
      K) E0 ]& v: w
48. 
    
49.   for(entry = key_entries; entry->key_handle_cb; ++entry)
    9 W, T0 U" I2 [; m
50.   {
    ; m$ W  ~  @. V% S# A
51.     if(event == entry->cmd)
    ( B. ?& J7 n5 m- v
52.     {
    - \7 t; s5 V5 Y4 e$ ]
53.       entry->key_handle_cb();
    4 M. ^) F9 M: w$ @) b# l( D
54.       break;
    
55.     }
    
56.   }
    ( i2 [5 Y+ T3 |' C# Q, ^
57. }

复制代码

, t; Z( [; v6 S5 T7 x裸机：按键扫描20ms执行一次，按键处理直接丢在主函数中。（自己写队列）
, j6 P, x0 U' G, ~' h
系统：在任务中执行按键扫描和按键处理。（系统自带队列或者邮箱）

9 E$ c; R8 d3 `, o4 F
7 n% z4 ?& K9 `% R/ `