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

2 k, ]% ~5 A0 n; e+ D+ z

1. // 配置有效电平
   
2. typedef enum
   
3. {
   9 u! }  g  ?- a2 q* \  B
4.   KEY_INIT_IS_ACTIVE = 0,
   
5.   KEY_LOW_IS_ACTIVE  = 1,
   
6.   KEY_HIGH_IS_ACTIVE = 2,
   4 V4 e3 e5 S) T- h+ y5 k
7. } key_active_t;
   
8. 
   
9. 
     S$ k. y  c. |: \3 \
10. #define KEY_CONFIG(gpio, pin)     GPIOConfig(gpio, pin, GPIO_MODE_INPUT, GPIO_PULLUP)
    8 ^6 |! g4 R  {; Y7 ~
11. #define KEY_READ(gpio, pin)       HAL_GPIO_ReadPin(gpio, pin)
    
12. 
    
13. #define KEY1_PORT                 GPIOH
    
14. #define KEY1_PIN                  GPIO_PIN_3
    
15. 
      p' f3 s$ D6 `2 G  _
16. #define KEY2_PORT                 GPIOH
    ; W: ?# j2 j: p% a8 b* e
17. #define KEY2_PIN                  GPIO_PIN_2
    
18. 
    + s9 J, r) t- Q+ q$ E* R
19. #define KEY3_PORT                 GPIOC
    ' D  k3 y9 x8 s- o1 p
20. #define KEY3_PIN                  GPIO_PIN_13

复制代码

1. // demo代码 只传递思想
   
2. 
   4 t" U) w8 U3 E1 M! p, P/ \* x. D
3. static void key_gpio_config(GPIO_TypeDef *gpio, uint16_t pin)
   
4. {
   
5.   KEY_CONFIG(gpio, pin);
   & m; _+ e2 t4 D% U( h
6. }
   9 Z) O: N  Z. x" V
7. 
   0 a* n# E9 x1 x3 `( E
8. typedef struct
   
9. {
   # C3 s6 N$ x: G, f. P8 T% [& a9 K
10.   GPIO_TypeDef *gpio;
    
11.   uint16_t pin;
    
12. } key_port_t;
    . l: H% E+ A/ y! g# Q
13. 
      Q3 j$ L- m) ~6 {3 L0 h, I) a
14. static key_port_t key_entries[] =
    5 k; Z9 y( K0 c* X  L% k
15. {
    % x$ |! k% }+ f1 z
16.   {KEY1_PORT, KEY1_PIN},
    
17.   {KEY2_PORT, KEY2_PIN},
    0 J* g5 h- D' K4 Y% H: w
18.   {KEY3_PORT, KEY3_PIN},
    
19. };
    - S! b: B0 ^% k! c" X/ U. |# j) J
20. 
    " n7 I% R1 T$ o3 T7 _1 d
21. void KeyInit(void)
    3 G2 @$ _, F2 Q2 P+ Q
22. {
    
23.   uint32_t i, mask = 1;
    7 q3 ~) a# ?0 V+ I* Q
24. 
    
25.   for(i = 0; i < ARRAY_SIZE(key_entries); ++i)
    % [7 j3 O" ^$ b. @8 Y! |. b1 O
26.   {
    
27.     if(0xFFFFFFFF & mask)
    . u; `2 J4 f8 s) ?' N+ L
28.     {
    
29.       key_gpio_config(key_entries<span style="font-style: italic;">.gpio, key_entries.pin);
    1 N% h; z6 {8 m
30. 
    
31. <span style="font-style: normal;">#if(CONFIG_KEY_TEST == 1) // 测试时使用      
    $ h; Z- G$ N5 X2 C" P9 M2 }+ H$ @
32.       //config.key.total_switch  = KEY_MODE_OPEN;
    
33.       //config.key.sub_switch = KEY_MODE_OPEN;
    ( ]5 p) t! i; k4 c
34.       config.key.active_tag = KEY_LOW_IS_ACTIVE;
    ! Q5 h7 e) x* f! I5 o, R& X
35. #endif
    
36.     }
    
37. 
    
38.     mask <<= 1;
    
39.   }
    
40. }
    5 F8 `, l1 Q' K( f
41. 
    & L. g* K# K6 T* I8 [
42. // 输入是否可用
    
43. static uint8_t key_is_enable(uint8_t index)
    
44. {
    
45.   // 这里可以写成可配置 配置IO口可用或者不可用（类似一个总开关）
    
46.   return 1;
    6 F, Y/ \8 `0 e; u8 s1 J2 u1 Q
47. }
    ( Z  h) a8 T, @4 D
48. 
    
49. // 有输入到来
    # c; _1 r; J/ w0 X# p/ t
50. static uint8_t key_is_pressed(uint8_t index)
      v6 \: Y7 {& y. G$ t
51. {
    
52.   if(key_is_enable(index))
    
53.   {
    
54.     if(KEY_LOW_IS_ACTIVE == config.key.active_tag[index])
    
55.     {
    1 [0 l7 n# m/ Z+ [4 l0 x( H; }
56.       if(KEY_READ(key_entries[index].gpio, key_entries[index].pin) == 0)
    / u; Q! c4 m5 x  w  p) b
57.       {
    - m0 ~* n( h6 k& V* H5 @
58.         return 1;
    
59.       }
    1 c+ j  j8 p0 L: E" h, X; K% f
60.     }
    
61.     else if(KEY_HIGH_IS_ACTIVE == config.key.active_tag[index])
    
62.     {
    # v* R1 w7 D# ^/ P) i, n8 a. L; E
63.       if(KEY_READ(key_entries[index].gpio, key_entries[index].pin) == 1)
    4 A/ ~( c# j9 a
64.       {
    
65.         return 1;
    2 N: l, C5 k, X
66.       }
    
67.     }
    
68.   }
    
69. 
    4 n/ h8 |# S  T1 B
70.   return 0;
    9 \! S! o4 ], |1 j
71. }
    8 g/ L" q# K. u0 ]
72. 
    8 J7 l1 x6 _* K# t6 v
73. // 按键被按下
    , d3 w! @- `" [" x! y% B/ l3 b/ T
74. uint8_t Key1IsDown(void)
    
75. {
    
76.   return key_is_pressed(0);
    
77. }
    
78. 
    # ~0 K, F6 J( z4 g( |* u
79. uint8_t Key2IsDown(void)
    
80. {
    7 g# H/ d1 b6 s/ W: }  g0 i
81.   return key_is_pressed(1);
    : h" t( Q( D5 a! X( ]) p
82. }
    
83. 
    , }! [( i( p" w( e: O% X
84. uint8_t Key3IsDown(void)
    3 ]" M: R& G9 w! `4 c
85. {
    
86.   return key_is_pressed(2);
    
87. }</span></span>

复制代码

8 T5 }" Y5 e. r% I8 g. `& p& k二、输入扫描
( N4 S6 e* D3 x8 a

1. // 按键的状态机结构定义
   
2. // 按键状态
   7 v7 b! R# u& ~$ Y- [- H; F, |! H5 y
3. typedef enum
   + R2 ]0 I+ w$ r! O& |6 M9 h
4. {
   & j: u6 w$ g- J
5.   KEY_STATE_INIT, // 缺省按键状态
   3 W. l8 r0 n8 V$ i
6.   KEY_STATE_UP,   // 按键弹起状态
   4 ~1 T+ ^3 h% r& k
7.   KEY_STATE_DOWN, // 按键按下状态
   
8.   KEY_STATE_LONG, // 按键长按状态
   
9.   KEY_STATE_AUTO, // 按键自动连发状态
   
10. } key_state_t;
    
11. 
    
12. // 按键滤波时间20ms, 单位10ms。
    4 J) b8 c5 a! s( w) }$ T- `
13. // 只有连续检测到20ms状态不变才认为有效，包括弹起和按下两种事件
    7 h$ `  W; s) N5 l( L
14. // 即使按键电路不做硬件滤波，该滤波机制也可以保证可靠地检测到按键事件
    9 H! x. ]. a. l5 e  o: m% W6 E) q
15. #define KEY_FILTER_TIME 2   // 滤波消抖
    
16. #define KEY_LONG_TIME   100 // 单位10ms    持续1秒，认为长按事件
    
17. #define KEY_REPEAT_TIME 100 // 单位10ms    持续1秒，自动连发
    , c/ O8 m& A' c* J2 k9 B
18. 
    % E: V& n! d+ \; m+ D) X# f
19. typedef uint8_t (*key_cb)(void);
    ; ]8 \1 V6 l- d" A, M: @. F
20. typedef struct
    7 b0 f' g: L  _1 ]* X  T+ h
21. {
    
22.   uint8_t state;        // 按键当前状态(按下还是弹起)
    
23.   uint8_t last;         // 上一次按键的状态
    
24.   uint8_t count;        // 滤波消抖计数器
    ; U7 w" b0 J& V' o7 ~
25.   uint16_t long_time;   // 按键按下持续时间, 0表示不检测长按
    # U  ?  l7 g2 B! J3 l
26.   uint16_t long_count;  // 长按计数器
    
27.   uint8_t repeat_speed; // 连续按键周期
    ) a) I$ @; x3 d9 j: h
28.   uint8_t repeat_count; // 连续按键计数器
    
29.   key_cb is_down_func;  // 按键按下的判断函数,1表示按下
    ) z: @& T' I! q; T7 a. S: F$ a
30. } key_t;
    
31. 
      u- ?% Q# k+ g/ q
32. static key_t key_items[] =
    , Q5 m% E. ?. w; |: h
33. {
    ) w: T$ \. U" [$ B7 |( g
34.   {KEY_STATE_INIT, KEY_STATE_INIT, KEY_FILTER_TIME, KEY_LONG_TIME, 0, KEY_REPEAT_TIME, 0, Key1IsDown},
    % B+ I' Q. J( g- X# ?
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},
    & @+ D4 f' b9 K2 N* U; D
37. };

复制代码

1. // 按键状态机key_scan
   
2. // 配置限制条件在这个函数里面加
   
3. static void key_scan_ext(key_t *entry, uint8_t i)
   : n, t. e/ F! C1 J8 x8 m2 |6 a& L
4. {
   0 V  B# D2 T, H% O+ N
5.   switch(entry->state)
   
6.   {
   
7.   case KEY_STATE_INIT:
   
8.   case KEY_STATE_UP:
   
9.   {
   
10.     entry->state = KEY_STATE_DOWN; // 按键被按下
    9 K) P+ s, j! D: a7 v
11.     break;
    ; B8 b$ Q2 n9 l; r
12.   }
    
13. 
    : Q) z* }1 l8 P# [
14.   case KEY_STATE_DOWN:
    
15.   {
    8 w& |4 j8 P! i* t: t
16.     if(entry->long_time > 0)
    
17.     {
    
18.       if(entry->long_count < entry->long_time)
    , z8 z* D! q2 o; C& c) f
19.       {
    
20.         if(++entry->long_count >= entry->long_time)
    ; I5 I6 i8 A; p& `
21.         {
    
22.           entry->state = KEY_STATE_LONG;
    
23.         }
    
24.       }
    3 s- i, ?! G% _; i, j% |1 v
25.     }
    1 `; n, ]+ c- j9 H) T7 y1 G
26. 
    # W$ w. H. d# ^. ^
27.     break;
    : e0 Z0 u& ?# ^1 H- V0 r
28.   }
    
29. 
    
30.   case KEY_STATE_LONG:
    
31.   {
    9 E9 v. m- O7 o, @, R$ S
32.     if(entry->repeat_speed > 0) // 自动连发时间到  自动连发事件
    
33.     {
    5 h* A( d0 h% x* Z/ s
34.       if(++entry->repeat_count >= entry->repeat_speed)
    5 M: @* v. i% C8 v$ o- A: B
35.       {
    
36.         entry->repeat_count = 0;
    ! |; i, o+ Y  P
37.         // 长按触发
    ) g6 P' Z6 ~! k, P+ X) u
38.       }
    
39.     }
    / C4 [% j: s% |) K6 N2 v1 R9 L
40. 
    
41.     break;
    - h- B, [3 D# d4 b4 {
42.   }
    
43.   }
    8 G! ~) g4 `3 i6 ]5 M
44. 
    3 K5 h: V/ v! ^# g: w( O* \% Q
45.   entry->last = entry->state; // 最新的按键状态
    
46. }
    
47. 
    
48. static void key_scan(uint8_t i)
    
49. {
    7 r8 l3 P. h! Z5 z- F1 J
50.   key_t *entry = &key_items<span style="font-style: italic;"><span style="font-style: normal;">;
    
51.         uint8_t key;
    
52. 
    
53.   if(entry->is_down_func())
    7 X4 `1 f* Y1 N" h
54.   {
    9 e3 m+ H" Z" B/ S% G
55.     if(entry->count < KEY_FILTER_TIME) // 消抖
    + W# a1 T! d* \% h( E, j* m: ~
56.     {
    
57.       ++entry->count;
    ! c, A6 W& {/ X! u5 o5 [
58.     }
    1 T3 t5 `2 ~: ?$ |: m5 x: x* C: J* o
59.     else
    9 M, m$ W( Y" {+ o9 S: y+ O
60.     {
    3 _$ x9 S( d! P- E
61.       key_scan_ext(entry, i); // 按键扫描状态机
    3 q: h/ D8 O4 C5 O
62.     }
    $ F7 m* g$ f8 S7 ]# S/ v8 R7 r
63.   }
    
64.   else
    % G+ ]% K) y# O4 |
65.   {
    : N/ {9 D: F  u5 y$ j6 }
66.     if(entry->count > KEY_FILTER_TIME)
    8 K5 a8 M; ^: l: V- y9 E; @
67.     {
    ! m. [( O" W# q- A; n
68.       entry->count = KEY_FILTER_TIME;
    : p/ m/ M6 O& F- w
69.     }
    ! E! ]8 L; v2 C& f
70.     else if(entry->count > 0)
    
71.     {
    
72.       --entry->count;
    
73.     }
    5 B& I- t5 Y) k% X; t5 ^
74.     else
    
75.     {
    2 w3 c* i% G3 z
76.       if(KEY_STATE_DOWN == entry->last) // 一次完整的按键到这里就弹起了
    - a# I- [) K  o# C1 K
77.       {
    
78.        // 按键按下之后可以加入到队列中，这里的队列可以自己写；如果带系统可以使用系统的消息队列等方式。
    0 f: J* z, u4 ]4 R7 y
79.        // key = i + 1;
    
80.        // xQueueSend(os_key_queue, &key, 10);
    ( _/ r5 e3 c* |" W% W9 H; y; v
81.       }
    ; t0 u- E0 A7 H1 R
82.       entry->last  = KEY_STATE_UP;
    ) ~$ l2 E; V5 g. j! ~
83.       entry->state = KEY_STATE_UP; // 按键弹起状态
    
84.     }
    
85. 
    ( J2 F8 g* J8 e: i
86.     entry->long_count = 0;
    % p, P  x3 @9 p' b
87.     entry->repeat_count = 0; // 清空计数器
    % k# c+ c4 X, R. ^8 j# m
88.   }
    
89. }</span></span>

复制代码

, r# m3 G, R# g# T! [. ]; l三、输入处理

1. // 按键按下之后，会将值加入到队列中，我们读取队列数据，然后扫描列表匹配功能
   
2. static void key1_cb(void);
   
3. static void key2_cb(void);
   
4. static void key3_cb(void);
   
5. 
   ; i9 p4 R: D# b; ]3 U4 V; ~
6. #define KEY1_CMD         1
   / X7 A' Y! ]& @/ Y3 I" G
7. #define KEY2_CMD         2
   / K! b: @  O9 x& ~
8. #define KEY3_CMD         3
   
9. 
   
10. typedef struct
    + _# ~: f$ h; O* M
11. {
    
12.   uint8_t cmd;
    
13.   void (* key_handle_cb)(void);
    4 S5 {% U$ G; c3 l& i
14. } key_handle_t;
    # S% f  j' ?' X' M9 Q; D% {" X& u
15. 
    
16. static const key_handle_t key_entries[] =
    - {3 d$ w( E* N8 H
17. {
    $ m; S0 m" @% W# ?5 h
18.   {KEY1_CMD, key1_cb},
    
19.   {KEY2_CMD, key2_cb},
    ) ?7 @0 k4 |, @* [( e7 @
20.   {KEY3_CMD, key3_cb},
    
21.   {0xFF, NULL  },
    5 w/ l# p  O- R5 K+ }" ~- I+ M
22. };
    9 Q( J& ]& ]) \; j) E) J  l3 ]
23. 
    ; Y3 g" ?: ~; g/ t6 c4 j
24. // 按键的通用功能
    ) \9 x: c, Z; {3 d
25. static void key_func(uint8_t func)
    
26. {
    
27. 
    1 g' Z7 I1 p; j3 Q; v0 U
28. }
    0 ~; j! {* P1 b. K- P
29. 
    
30. static void key1_cb(void)
    # Q: R$ V0 l# g% N& T
31. {
    
32. 
    
33. }
    " K& D3 j$ }5 Y0 t
34. 
    
35. static void key2_cb(void)
    
36. {
    
37. 
    6 b+ J' S+ z) Y7 u3 y% L: R
38. }
    & @  L. Q$ m# i/ ~( W1 i: i, ?
39. 
    
40. static void key3_cb(void)
    ' ~1 [. H: N- i" l. U
41. {
    
42. 
    % {4 z3 R  w+ `; p# ]0 V5 \' |' `
43. }
    6 L" v* Y' P( O+ k
44. 
    5 U8 U% g3 q) Q! r& y
45. static void key_process(uint8_t event)
    5 i$ ]7 c, R9 ~( L2 P
46. {
    
47.   const key_handle_t *entry;
    
48. 
    - }% W+ V% K: Y* y8 a; H
49.   for(entry = key_entries; entry->key_handle_cb; ++entry)
    
50.   {
    
51.     if(event == entry->cmd)
    
52.     {
    + F( ?. T1 w0 \' ]' T6 J% G
53.       entry->key_handle_cb();
    
54.       break;
    + v% M/ s! e" J! O6 z
55.     }
    
56.   }
    
57. }

复制代码

裸机：按键扫描20ms执行一次，按键处理直接丢在主函数中。（自己写队列）

系统：在任务中执行按键扫描和按键处理。（系统自带队列或者邮箱）