一、输入配置
6 X5 {9 I$ ?2 h! ~1 ^为了灵活使用，我们将输入的有效电平设置成可配置。同样是列表表示所有IO口。
0 {" q1 l' u" y& V0 r' I8 y$ F

1. // 配置有效电平
   
2. typedef enum
   : V$ |: ~+ p7 U" ?4 L
3. {
   3 O( f1 }1 @2 ]% _* S: J8 R% _$ B
4.   KEY_INIT_IS_ACTIVE = 0,
   ! `  t* h, D% _+ p7 n( h
5.   KEY_LOW_IS_ACTIVE  = 1,
   * `# H5 r7 O4 S4 Y) T' R) |
6.   KEY_HIGH_IS_ACTIVE = 2,
   2 g9 p5 ?1 D! A$ f! P" f
7. } key_active_t;
   ; S, R" f+ t& o7 l& P4 J$ O9 u
8. 
   
9. 
   ; b; ^5 s. n5 m, u- b& }2 Z
10. #define KEY_CONFIG(gpio, pin)     GPIOConfig(gpio, pin, GPIO_MODE_INPUT, GPIO_PULLUP)
    ! p# g0 k/ J$ I, C. H5 c
11. #define KEY_READ(gpio, pin)       HAL_GPIO_ReadPin(gpio, pin)
    
12. 
    ( `. W, l: r$ u' ]
13. #define KEY1_PORT                 GPIOH
    
14. #define KEY1_PIN                  GPIO_PIN_3
    
15. 
    5 b: t( M& B$ _/ i" u* _( i
16. #define KEY2_PORT                 GPIOH
    . G5 O( R; p; x1 A1 Q/ |6 I* N! n  {
17. #define KEY2_PIN                  GPIO_PIN_2
    
18. 
    
19. #define KEY3_PORT                 GPIOC
    : Y9 w3 f' g0 q1 P7 h0 }
20. #define KEY3_PIN                  GPIO_PIN_13

复制代码

1. // demo代码 只传递思想
   
2. 
   
3. static void key_gpio_config(GPIO_TypeDef *gpio, uint16_t pin)
   # Y* Z7 n$ S# T! e# k
4. {
   . G8 y8 z2 x  W0 l7 f* V( g
5.   KEY_CONFIG(gpio, pin);
   7 E* O+ }( o$ s( u2 _
6. }
   $ e( c. H  \, j4 X' M
7. 
   " d, \, e8 }1 w' N; N
8. typedef struct
   7 p% N/ j+ g/ W. o
9. {
   
10.   GPIO_TypeDef *gpio;
    0 v( h% F5 X, G) _# l* Z
11.   uint16_t pin;
    ( ^5 b: W8 a1 z4 _* Y, J- e
12. } key_port_t;
    
13. 
    3 p% c9 M) V9 h
14. static key_port_t key_entries[] =
    
15. {
    % X% t& q! a7 X6 p* v" ]& X! q$ F
16.   {KEY1_PORT, KEY1_PIN},
    7 X* r0 B; l8 l% Y* B5 v0 S! f1 X
17.   {KEY2_PORT, KEY2_PIN},
    
18.   {KEY3_PORT, KEY3_PIN},
    * a: T; H# N1 o& H$ a; ?) q
19. };
    
20. 
    # \. ^' A% W; g6 V! A9 [/ X+ g7 s
21. void KeyInit(void)
    
22. {
    
23.   uint32_t i, mask = 1;
    
24. 
    ( E5 |* L7 m" L' C* z
25.   for(i = 0; i < ARRAY_SIZE(key_entries); ++i)
    9 {1 j) h  `7 b, v, [
26.   {
    
27.     if(0xFFFFFFFF & mask)
    * F! w0 [2 K; O9 s! T- i
28.     {
    
29.       key_gpio_config(key_entries<span style="font-style: italic;">.gpio, key_entries.pin);
    7 K; S% S. ?9 ^1 r9 F( ~7 `0 t# z
30. 
    ! N$ _8 n) X, I+ M5 e1 V: O& G& X
31. <span style="font-style: normal;">#if(CONFIG_KEY_TEST == 1) // 测试时使用      
    
32.       //config.key.total_switch  = KEY_MODE_OPEN;
    
33.       //config.key.sub_switch = KEY_MODE_OPEN;
    
34.       config.key.active_tag = KEY_LOW_IS_ACTIVE;
    . h" Y# I* b) v' F7 M; m
35. #endif
    
36.     }
    7 q& _+ n7 J2 E
37. 
    2 B  y& Z( U) T0 u
38.     mask <<= 1;
    
39.   }
    
40. }
    0 U. P5 i# N8 c
41. 
    / ^2 p( A: O0 M
42. // 输入是否可用
    
43. static uint8_t key_is_enable(uint8_t index)
    ( ?+ O4 e$ L1 I* S# y6 b+ l9 z; F
44. {
    
45.   // 这里可以写成可配置 配置IO口可用或者不可用（类似一个总开关）
    ! L6 k1 |% _2 h, `# }' c' K; E
46.   return 1;
    / Z7 L/ C! F: b+ M+ b# b
47. }
    
48. 
    
49. // 有输入到来
    8 P8 ~+ v8 N8 B6 B) Y/ I% l& o
50. static uint8_t key_is_pressed(uint8_t index)
    9 E, ?; x* m* a; P, h* c
51. {
    1 Y4 l. V: W: R- E; j
52.   if(key_is_enable(index))
    ( \( v6 y, N* Q! C
53.   {
    
54.     if(KEY_LOW_IS_ACTIVE == config.key.active_tag[index])
    
55.     {
    
56.       if(KEY_READ(key_entries[index].gpio, key_entries[index].pin) == 0)
    7 T! u2 v. R5 N1 H9 _
57.       {
    
58.         return 1;
    
59.       }
    
60.     }
    
61.     else if(KEY_HIGH_IS_ACTIVE == config.key.active_tag[index])
    , ~9 t1 B1 ?" z1 |1 b" U
62.     {
    ; v. e8 t; Y' ~: Y
63.       if(KEY_READ(key_entries[index].gpio, key_entries[index].pin) == 1)
    / Q, E- X, Q; O% U
64.       {
    
65.         return 1;
    
66.       }
    - ?* T& G; b0 `, f
67.     }
    
68.   }
    
69. 
    
70.   return 0;
    1 X; a9 T4 i) Y( D4 \
71. }
    5 O: n- ?9 f% X
72. 
    + A3 H" p2 i. E) T1 h4 \5 I
73. // 按键被按下
    
74. uint8_t Key1IsDown(void)
    
75. {
    
76.   return key_is_pressed(0);
    
77. }
    , ^6 q9 ]' ^; p0 c+ [5 V& G& x
78. 
    
79. uint8_t Key2IsDown(void)
    
80. {
    
81.   return key_is_pressed(1);
      F2 p5 c8 o' v$ ^
82. }
    
83. 
    
84. uint8_t Key3IsDown(void)
    
85. {
    5 S' a' m/ D2 H
86.   return key_is_pressed(2);
    
87. }</span></span>

复制代码

二、输入扫描

1. // 按键的状态机结构定义
   1 l/ \0 L* [: r# P' H
2. // 按键状态
   , Q# F; Z: L# g0 r# b
3. typedef enum
   / F. o. V5 H$ H* I
4. {
   6 E) Q5 U9 ]. C+ y5 I+ K# T
5.   KEY_STATE_INIT, // 缺省按键状态
   
6.   KEY_STATE_UP,   // 按键弹起状态
   & j$ F9 G) n+ N* O( A
7.   KEY_STATE_DOWN, // 按键按下状态
   + b' ^6 g( s- [4 V: F
8.   KEY_STATE_LONG, // 按键长按状态
   - I% k$ s# j2 Z1 a9 N8 ^  \/ R
9.   KEY_STATE_AUTO, // 按键自动连发状态
   
10. } key_state_t;
    
11. 
    
12. // 按键滤波时间20ms, 单位10ms。
    
13. // 只有连续检测到20ms状态不变才认为有效，包括弹起和按下两种事件
    8 P) a1 a* o9 i! P6 Z4 S: @9 r
14. // 即使按键电路不做硬件滤波，该滤波机制也可以保证可靠地检测到按键事件
    
15. #define KEY_FILTER_TIME 2   // 滤波消抖
    ) h- c# ]4 b+ Z+ }$ V  x: s
16. #define KEY_LONG_TIME   100 // 单位10ms    持续1秒，认为长按事件
    / {$ a: y+ P# X; l
17. #define KEY_REPEAT_TIME 100 // 单位10ms    持续1秒，自动连发
    
18. 
    
19. typedef uint8_t (*key_cb)(void);
    ; m$ `7 V0 ?( J6 W7 O9 H9 {+ a7 v, D
20. typedef struct
    
21. {
    1 r4 b8 k' z1 k- U- q- Q8 X
22.   uint8_t state;        // 按键当前状态(按下还是弹起)
    7 }# o+ g, i0 m% m1 U. E
23.   uint8_t last;         // 上一次按键的状态
    0 Z- w4 P" Y5 E3 j# \; w1 {* @
24.   uint8_t count;        // 滤波消抖计数器
    # [$ n  Y- X8 J$ l( P9 |
25.   uint16_t long_time;   // 按键按下持续时间, 0表示不检测长按
    + R+ @) F" B4 }  @
26.   uint16_t long_count;  // 长按计数器
    9 N0 S. `2 u. {/ t
27.   uint8_t repeat_speed; // 连续按键周期
    6 }" U3 |) }0 V0 i7 d, u3 f4 K
28.   uint8_t repeat_count; // 连续按键计数器
    
29.   key_cb is_down_func;  // 按键按下的判断函数,1表示按下
    ) i* @" O" ^# W: G; a/ L
30. } key_t;
    4 p6 u. X  J. w# @
31. 
    5 C+ T& d# l8 h' R1 A1 a4 a
32. static key_t key_items[] =
    
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},
    & H, j9 l( q% U) C: ^
36.   {KEY_STATE_INIT, KEY_STATE_INIT, KEY_FILTER_TIME, KEY_LONG_TIME, 0, KEY_REPEAT_TIME, 0, Key3IsDown},
    
37. };

复制代码

1. // 按键状态机key_scan
   
2. // 配置限制条件在这个函数里面加
   
3. static void key_scan_ext(key_t *entry, uint8_t i)
   # ?" D' u8 C0 z/ o
4. {
   
5.   switch(entry->state)
   
6.   {
   & X: F& C5 t: M0 B
7.   case KEY_STATE_INIT:
   
8.   case KEY_STATE_UP:
   
9.   {
   
10.     entry->state = KEY_STATE_DOWN; // 按键被按下
    $ A$ T8 T2 A( H' a. H0 z0 S
11.     break;
    9 J% a6 R3 n7 K, C5 Z
12.   }
    
13. 
    
14.   case KEY_STATE_DOWN:
    
15.   {
    ( x" v# w1 C6 N8 C6 u
16.     if(entry->long_time > 0)
    
17.     {
    ; `" Y: \) A6 O& K( k0 V
18.       if(entry->long_count < entry->long_time)
    
19.       {
    8 D! S# z1 M. I; v$ E; t
20.         if(++entry->long_count >= entry->long_time)
    + i' O! I8 x! y% D
21.         {
    
22.           entry->state = KEY_STATE_LONG;
    : C) {: y' f# m" N. {, {* k' C
23.         }
    
24.       }
    
25.     }
    ' U0 W# X, X& a! N1 D$ H- A* e* w
26. 
    2 p9 s9 p* t; \- ]+ d+ U# ~) L
27.     break;
    . e* {6 X8 ^6 l
28.   }
    - J9 a( r# {0 T8 ?1 @4 }! P' }3 n
29. 
    8 z+ `- k9 j) ~. v8 Z* I
30.   case KEY_STATE_LONG:
    & D' t6 j$ O, J6 v& F* [9 ]+ J
31.   {
    
32.     if(entry->repeat_speed > 0) // 自动连发时间到  自动连发事件
    
33.     {
    # k0 H0 G* T9 i/ ]0 b+ F
34.       if(++entry->repeat_count >= entry->repeat_speed)
    
35.       {
    ; p( _# H) q4 K5 j1 G7 q# Z3 j
36.         entry->repeat_count = 0;
    1 f; m6 N" p7 }0 t5 O+ K
37.         // 长按触发
    - O, b; _' m: |8 K( @6 x- N( A
38.       }
    
39.     }
    
40. 
    7 h( k+ B: i* s' A
41.     break;
    * V; Q  P: R2 f7 G
42.   }
    
43.   }
    
44. 
    
45.   entry->last = entry->state; // 最新的按键状态
    
46. }
    9 i5 b0 ]& W* b2 |( ^
47. 
    
48. static void key_scan(uint8_t i)
    " _) D! y5 j' y( J7 g* ]0 E4 c
49. {
    6 u( b7 g" m9 x. c" Q5 w
50.   key_t *entry = &key_items<span style="font-style: italic;"><span style="font-style: normal;">;
    
51.         uint8_t key;
      l: F  d# o, V) x, |1 K1 Q  k( @, G
52. 
    
53.   if(entry->is_down_func())
    % u- G8 e8 f7 Y& ^; `0 i, p" g
54.   {
    9 T6 U# {4 o; y  r5 I
55.     if(entry->count < KEY_FILTER_TIME) // 消抖
    8 y- w4 Z7 b( y* L( g4 F: F
56.     {
    % O( w9 Q* H4 _( Q2 J' R
57.       ++entry->count;
    
58.     }
    
59.     else
    + D5 [! f% j$ }6 `6 Y2 f& o% c
60.     {
    4 {; f$ c& D6 E8 h3 d" n6 V
61.       key_scan_ext(entry, i); // 按键扫描状态机
    ; j/ K8 o0 w4 U
62.     }
    ; t! x2 F8 O! d" H" A
63.   }
    ) g0 q% @; O+ l1 X
64.   else
      Z+ n% I* K* x8 _7 Z
65.   {
    2 O& P& n7 o! _! G0 F( T9 A
66.     if(entry->count > KEY_FILTER_TIME)
    0 u4 L$ I7 I* C6 H5 n, G
67.     {
      A, A/ W! @' Q
68.       entry->count = KEY_FILTER_TIME;
    8 q* ~/ f2 `% c( w5 ~$ X
69.     }
    1 {* H9 w) K: A
70.     else if(entry->count > 0)
    
71.     {
    
72.       --entry->count;
    
73.     }
    . a2 g6 B7 @% V0 F; k2 t
74.     else
    8 z! V9 Y5 z# a0 J3 P  }
75.     {
    6 A0 ?! \# b. l4 g& K
76.       if(KEY_STATE_DOWN == entry->last) // 一次完整的按键到这里就弹起了
    ( [5 f3 w, F1 X: f3 W' \
77.       {
    
78.        // 按键按下之后可以加入到队列中，这里的队列可以自己写；如果带系统可以使用系统的消息队列等方式。
    + [- b6 B8 ~7 f- U+ Q
79.        // key = i + 1;
    ' a) R6 v; X" ]$ I1 Y1 |* t
80.        // xQueueSend(os_key_queue, &key, 10);
    
81.       }
    
82.       entry->last  = KEY_STATE_UP;
    
83.       entry->state = KEY_STATE_UP; // 按键弹起状态
    % ^1 e+ j3 m$ a" R5 Q& v' N7 g* o# y
84.     }
    
85. 
    + E. K8 o- L& v: j( [% r1 O
86.     entry->long_count = 0;
    
87.     entry->repeat_count = 0; // 清空计数器
    
88.   }
    
89. }</span></span>

复制代码

三、输入处理
0 m9 _) N5 @$ N/ A3 T9 X* N2 k

1. // 按键按下之后，会将值加入到队列中，我们读取队列数据，然后扫描列表匹配功能
   " q. w/ K5 E# Q0 L: X
2. static void key1_cb(void);
   ) {, ?( M# b) L; C" g5 ~, ]
3. static void key2_cb(void);
   . w0 n+ i, B4 ^. r) J
4. static void key3_cb(void);
   ( f7 Q5 [/ q* H9 s
5. 
   3 G& y1 U( ?& k& b6 X+ @
6. #define KEY1_CMD         1
   
7. #define KEY2_CMD         2
   : n: {3 X9 i  U  g- P" W9 F# C
8. #define KEY3_CMD         3
   
9. 
   0 h& p) h" T. |8 d& j' o+ e2 B1 b
10. typedef struct
    . t( Z5 T  G% U& \! r+ \7 U
11. {
    6 Q' b$ p6 w& Z! Q) N
12.   uint8_t cmd;
    ) N6 i4 K$ e$ s
13.   void (* key_handle_cb)(void);
    6 h1 f/ g' D. m- {
14. } key_handle_t;
    
15. 
    " F6 K6 e3 j9 \1 W% O
16. static const key_handle_t key_entries[] =
    # d9 l2 I% o  W* e9 N4 L/ M% c
17. {
    
18.   {KEY1_CMD, key1_cb},
    ! s) m2 R: a' z6 S, Z+ E
19.   {KEY2_CMD, key2_cb},
    
20.   {KEY3_CMD, key3_cb},
    ; I' C# ]3 e# c/ e# _/ J0 T* s0 N
21.   {0xFF, NULL  },
    ( G$ p! R/ T* D0 j6 u: X# G
22. };
    & }( k  W  M" _2 h' d
23. 
    
24. // 按键的通用功能
    4 ~% {/ r* S- |' f
25. static void key_func(uint8_t func)
    ; k- {8 }; f5 M$ K2 u
26. {
    
27. 
    
28. }
    
29. 
    % s& z$ Y3 Y" }) d$ y
30. static void key1_cb(void)
    # N# Z1 x% ]" ?# f
31. {
    
32. 
    
33. }
    ; q2 V# {/ N1 D7 ?( @" U% @* U
34. 
    ! v+ [4 d4 [" J* l* d9 {/ s
35. static void key2_cb(void)
    
36. {
    
37. 
    9 H" J* Z3 N4 a4 s- |* ]% h
38. }
    ; M, O: {* m( r' X) c: L9 q
39. 
    
40. static void key3_cb(void)
    
41. {
      _, o! ^* `4 U$ M4 m
42. 
    : U3 _* @8 K, x6 L' p
43. }
    
44. 
    : C& Q! |& N, c
45. static void key_process(uint8_t event)
    
46. {
    - o; M4 i$ e: M$ t9 A
47.   const key_handle_t *entry;
    
48. 
    % D, q6 F$ V8 j$ e3 W
49.   for(entry = key_entries; entry->key_handle_cb; ++entry)
    
50.   {
    8 X$ V- T: b" F/ B; a" l& Y5 h# y
51.     if(event == entry->cmd)
    
52.     {
    
53.       entry->key_handle_cb();
    
54.       break;
    
55.     }
    ) o6 n& |0 z9 G2 @6 b7 g
56.   }
    - [: [, E1 I$ t
57. }

复制代码

. L3 O5 K( Q- l& v  i$ U' v裸机：按键扫描20ms执行一次，按键处理直接丢在主函数中。（自己写队列）

" E  v  i8 ~9 t$ n/ A系统：在任务中执行按键扫描和按键处理。（系统自带队列或者邮箱）


7 u1 f( b# H0 ]8 t