一、输入配置
) w  V! `  _$ I( h- y5 C为了灵活使用，我们将输入的有效电平设置成可配置。同样是列表表示所有IO口。

3 q+ h& B2 m0 x  W5 u

1. // 配置有效电平
   
2. typedef enum
   
3. {
   
4.   KEY_INIT_IS_ACTIVE = 0,
   8 u  Q$ V0 \; i: g" `
5.   KEY_LOW_IS_ACTIVE  = 1,
   
6.   KEY_HIGH_IS_ACTIVE = 2,
   2 e, Y0 t% ^. y+ b- R
7. } key_active_t;
   
8. 
   4 K; E1 ^" C4 d. J- l. U" x0 `
9. 
   ) A( P" f0 E  g% f: r* q* d% H; s
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)
    ' U" R/ w  n: G
12. 
    
13. #define KEY1_PORT                 GPIOH
    : C* e* o5 |9 A9 s& y
14. #define KEY1_PIN                  GPIO_PIN_3
    
15. 
    # o( s5 {3 m9 I- g( y3 N
16. #define KEY2_PORT                 GPIOH
    3 d$ d# {1 U' O) s4 W- O2 B2 |3 D
17. #define KEY2_PIN                  GPIO_PIN_2
    & `' r' h- Y. W8 M' l3 h3 E4 s
18. 
    * S2 A% g3 ]0 c' n; s
19. #define KEY3_PORT                 GPIOC
    - C* P0 q  Q1 K
20. #define KEY3_PIN                  GPIO_PIN_13

复制代码

1. // demo代码 只传递思想
   5 V6 z0 F3 x" ]; A  P$ E$ {
2. 
   7 Y( n& n* z( u
3. static void key_gpio_config(GPIO_TypeDef *gpio, uint16_t pin)
   
4. {
   # S0 b, ?7 t: m
5.   KEY_CONFIG(gpio, pin);
   0 Y& ~! C) ~7 f8 i" D
6. }
   
7. 
   , @' g# t0 V; _5 j$ ], v8 o+ P
8. typedef struct
   * f$ E: k5 X5 p1 a) j
9. {
   % a8 S: Y* |2 o: b
10.   GPIO_TypeDef *gpio;
    
11.   uint16_t pin;
    
12. } key_port_t;
    
13. 
    
14. static key_port_t key_entries[] =
    . O1 {' l% A2 R/ B7 y8 J
15. {
    
16.   {KEY1_PORT, KEY1_PIN},
    
17.   {KEY2_PORT, KEY2_PIN},
    ( H2 j3 Y' t; t* \  q! m7 w* N# Y" j
18.   {KEY3_PORT, KEY3_PIN},
    
19. };
    4 ]  }# A2 W. J$ j7 N. d! G5 d
20. 
    , w/ S! U1 A: n
21. void KeyInit(void)
    : b/ s, b1 Y% F- T
22. {
    4 f1 j& |9 P5 D6 ]
23.   uint32_t i, mask = 1;
    & B, J4 r" F& f1 J( J  W; I9 J
24. 
    ! ^& M! n2 n5 [* _$ {; L! w  s1 a- I
25.   for(i = 0; i < ARRAY_SIZE(key_entries); ++i)
    7 a9 y% C( e5 B6 P5 C
26.   {
    
27.     if(0xFFFFFFFF & mask)
    
28.     {
    $ k& w" `# ?6 ]2 A# S* ^
29.       key_gpio_config(key_entries<span style="font-style: italic;">.gpio, key_entries.pin);
    2 L/ L  H0 F3 [
30. 
    ) c- i8 H+ ~2 h
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;
    2 K# [+ `$ T7 ]7 ^# r' e# N. B
35. #endif
    
36.     }
    # `: C- ~" |7 n$ S
37. 
    
38.     mask <<= 1;
    % [& {6 D6 Q" H- ]- k5 E! I
39.   }
    ! r4 i0 n" I2 ]0 [/ G$ e
40. }
    6 q% U3 W9 A" p' y2 B0 C- g
41. 
    
42. // 输入是否可用
    / ?. s5 b+ U) G7 ^3 Q3 o
43. static uint8_t key_is_enable(uint8_t index)
    
44. {
    
45.   // 这里可以写成可配置 配置IO口可用或者不可用（类似一个总开关）
    
46.   return 1;
    ' o: D' p6 M0 `2 f( O1 }, X
47. }
    # l$ G" |. y6 ]) u8 L2 k) P; F
48. 
    
49. // 有输入到来
    
50. static uint8_t key_is_pressed(uint8_t index)
    # a5 i9 B1 I1 x
51. {
    ) Z" n3 b  g- N7 Y3 t
52.   if(key_is_enable(index))
    
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)
    
57.       {
    
58.         return 1;
    8 v  {  o  l% J4 i! W# [
59.       }
    , e4 W5 Z3 E: f+ W3 ^' J7 Z1 U
60.     }
    / y4 z, i, E3 d/ U9 h
61.     else if(KEY_HIGH_IS_ACTIVE == config.key.active_tag[index])
    
62.     {
    * D$ k0 p" K; K8 B& w
63.       if(KEY_READ(key_entries[index].gpio, key_entries[index].pin) == 1)
    ; O% S# C. R9 I' W( n; C- w
64.       {
    0 v. e" R0 [+ s' B
65.         return 1;
    # E3 h* S1 w3 J
66.       }
    : m% P$ U8 i9 h9 E% A7 V
67.     }
    ; I$ s3 I7 @' ~0 y: r) D
68.   }
    , u7 a& Z/ J6 i3 t& j" C
69. 
    # E  z, i- V% x( Y, r9 T6 L2 O  K
70.   return 0;
    
71. }
    
72. 
    * ?) Z/ U  v9 Z$ V
73. // 按键被按下
    1 @- j# u/ w4 y6 P6 |; d- ^, W
74. uint8_t Key1IsDown(void)
    - [; A' p. d. C& i8 \3 H# f
75. {
    
76.   return key_is_pressed(0);
    
77. }
    
78. 
    % t7 Q5 A# O2 q1 f8 i
79. uint8_t Key2IsDown(void)
    , q3 R/ @1 s  H, F+ n3 P
80. {
    ( C: A8 j2 ]) }& l: j: n& B( L1 f1 y0 G
81.   return key_is_pressed(1);
    
82. }
    
83. 
    / x$ X4 f; z9 C6 d# ?' z
84. uint8_t Key3IsDown(void)
    6 z3 v/ r6 o7 C! S1 F5 E. H4 P. @
85. {
    ) \% w/ `7 p; D' a
86.   return key_is_pressed(2);
    8 q# b. [: y& H) B7 N9 b: z
87. }</span></span>

复制代码

二、输入扫描
" h  u2 r0 b0 ?$ M" }) l

1. // 按键的状态机结构定义
   6 d& }! n* M1 ~7 t! J
2. // 按键状态
   
3. typedef enum
   , f1 Y% n: K. N3 e
4. {
   
5.   KEY_STATE_INIT, // 缺省按键状态
   
6.   KEY_STATE_UP,   // 按键弹起状态
   
7.   KEY_STATE_DOWN, // 按键按下状态
   
8.   KEY_STATE_LONG, // 按键长按状态
   * f4 z6 F6 i! y0 h
9.   KEY_STATE_AUTO, // 按键自动连发状态
   
10. } key_state_t;
    
11. 
    
12. // 按键滤波时间20ms, 单位10ms。
    
13. // 只有连续检测到20ms状态不变才认为有效，包括弹起和按下两种事件
    
14. // 即使按键电路不做硬件滤波，该滤波机制也可以保证可靠地检测到按键事件
    ' q0 G+ E7 l/ \
15. #define KEY_FILTER_TIME 2   // 滤波消抖
    . E- S) @$ D  _& Y2 S! x
16. #define KEY_LONG_TIME   100 // 单位10ms    持续1秒，认为长按事件
    * {9 c5 S3 e; i; c; q
17. #define KEY_REPEAT_TIME 100 // 单位10ms    持续1秒，自动连发
    * Q4 |1 f' B- k/ s
18. 
    * I$ h, r1 y+ d- h3 l2 H
19. typedef uint8_t (*key_cb)(void);
    
20. typedef struct
    3 X! N4 ]' B8 s4 S2 b# O
21. {
    * G; u+ N: X: R- u+ @& f0 c2 a
22.   uint8_t state;        // 按键当前状态(按下还是弹起)
    
23.   uint8_t last;         // 上一次按键的状态
    
24.   uint8_t count;        // 滤波消抖计数器
      ?) g8 j3 S; Y& y: J5 L/ k
25.   uint16_t long_time;   // 按键按下持续时间, 0表示不检测长按
    
26.   uint16_t long_count;  // 长按计数器
    : U# i0 R7 W+ g9 [, r! V
27.   uint8_t repeat_speed; // 连续按键周期
    % `& y5 c/ k3 p5 u" j. P
28.   uint8_t repeat_count; // 连续按键计数器
    
29.   key_cb is_down_func;  // 按键按下的判断函数,1表示按下
    2 B2 o" g% o3 o. v+ [$ S
30. } key_t;
    
31. 
    
32. static key_t key_items[] =
    . I3 `! l' j( W- G
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},
    
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)
   2 L3 ]5 V7 X& c( m
4. {
   
5.   switch(entry->state)
   1 [# t; |( }/ g* `( k' S
6.   {
   - T' \; p" P! ~/ h/ }* t6 S2 }. s
7.   case KEY_STATE_INIT:
   
8.   case KEY_STATE_UP:
   9 M5 }4 n) H% F6 R
9.   {
   2 M7 I& n, I8 f2 Z
10.     entry->state = KEY_STATE_DOWN; // 按键被按下
    . o8 j5 j5 V* q/ j& t; t& U4 c! e
11.     break;
    / b! S7 M" {" z* z" {4 w+ z
12.   }
    
13. 
    
14.   case KEY_STATE_DOWN:
    
15.   {
    
16.     if(entry->long_time > 0)
    
17.     {
    0 U% r8 p1 D. F6 V' S3 Z
18.       if(entry->long_count < entry->long_time)
    
19.       {
    5 q. A; J2 [4 p! H- M4 s
20.         if(++entry->long_count >= entry->long_time)
    % A! Y) {: }4 c1 S: I( w( M$ t1 W% O: a
21.         {
    4 u9 Z; ^9 D6 F. Y
22.           entry->state = KEY_STATE_LONG;
    
23.         }
    
24.       }
    5 f; w& G- f1 N& f/ O5 E
25.     }
    
26. 
    
27.     break;
    
28.   }
    ' \! |2 w+ e1 f2 x2 v1 T5 ^
29. 
    
30.   case KEY_STATE_LONG:
    
31.   {
    
32.     if(entry->repeat_speed > 0) // 自动连发时间到  自动连发事件
    . x3 H3 K& {# D* C7 O$ N$ p0 w
33.     {
    
34.       if(++entry->repeat_count >= entry->repeat_speed)
    
35.       {
    4 d, v/ }0 Y* ^4 ~, i
36.         entry->repeat_count = 0;
    
37.         // 长按触发
    
38.       }
    & C( I$ a8 d8 P, F0 [: H) \/ i3 o
39.     }
    
40. 
    + M, ~# I$ a8 N8 C
41.     break;
    
42.   }
    - D; _5 j: t  i/ o1 }$ Q+ f
43.   }
    - k% n6 d$ X9 z  J. u
44. 
    
45.   entry->last = entry->state; // 最新的按键状态
    
46. }
    
47. 
    
48. static void key_scan(uint8_t i)
    
49. {
    
50.   key_t *entry = &key_items<span style="font-style: italic;"><span style="font-style: normal;">;
    ' k; Y5 p5 u# B. p! l3 G
51.         uint8_t key;
    
52. 
    
53.   if(entry->is_down_func())
    2 X/ T0 N; P, t
54.   {
    7 W  U  Y# F( h2 H8 X! ~: ]7 P
55.     if(entry->count < KEY_FILTER_TIME) // 消抖
    5 J9 ?( h7 @, b/ G; N) @+ v5 q
56.     {
    . i$ w- @) I9 e* h- a5 w
57.       ++entry->count;
    
58.     }
    
59.     else
    
60.     {
    
61.       key_scan_ext(entry, i); // 按键扫描状态机
    
62.     }
    ; z. I+ L& D6 P/ j5 b
63.   }
    
64.   else
    
65.   {
    # I. ~: {1 Y! b  V$ E6 w
66.     if(entry->count > KEY_FILTER_TIME)
    : Y& j1 t1 o, V* T) n3 O$ _. r
67.     {
    2 B; V( {: I* \
68.       entry->count = KEY_FILTER_TIME;
    
69.     }
    0 K- O  B2 h! \; B: T4 A
70.     else if(entry->count > 0)
    
71.     {
    
72.       --entry->count;
    2 ?1 c- u: I0 v- W' D
73.     }
    
74.     else
    
75.     {
    
76.       if(KEY_STATE_DOWN == entry->last) // 一次完整的按键到这里就弹起了
    
77.       {
    ; p  L- [" {9 j* j" p
78.        // 按键按下之后可以加入到队列中，这里的队列可以自己写；如果带系统可以使用系统的消息队列等方式。
    % x3 P9 c- j% ]6 T
79.        // key = i + 1;
    
80.        // xQueueSend(os_key_queue, &key, 10);
    ! c: [# @: u7 ~! F# u" \1 @
81.       }
    
82.       entry->last  = KEY_STATE_UP;
    
83.       entry->state = KEY_STATE_UP; // 按键弹起状态
    
84.     }
    
85. 
    
86.     entry->long_count = 0;
    " {# C: K* w2 _# Z. F
87.     entry->repeat_count = 0; // 清空计数器
    : m; x; \  Q6 H8 [! y  L& J' h, S7 T8 L, f
88.   }
    
89. }</span></span>

复制代码

三、输入处理

1. // 按键按下之后，会将值加入到队列中，我们读取队列数据，然后扫描列表匹配功能
   . t3 o2 c% W4 y% x* e* q" \. t" W
2. static void key1_cb(void);
   
3. static void key2_cb(void);
   - ^4 G6 I" b8 }
4. static void key3_cb(void);
   " O( Z9 e& n. m: K& a& B
5. 
   
6. #define KEY1_CMD         1
   
7. #define KEY2_CMD         2
   
8. #define KEY3_CMD         3
   6 C7 r) q; o6 D( ]
9. 
   . U& M4 q0 l5 C6 v. `) Z6 w- v  R
10. typedef struct
    # C. ]/ q: h# E4 a! D
11. {
    3 I5 {- r6 a. U
12.   uint8_t cmd;
    
13.   void (* key_handle_cb)(void);
    
14. } key_handle_t;
    4 o3 t* n- u! ~
15. 
    
16. static const key_handle_t key_entries[] =
    - q; t- ?3 r( x# D/ Y1 W
17. {
    : _: a. R; l9 v
18.   {KEY1_CMD, key1_cb},
    
19.   {KEY2_CMD, key2_cb},
    
20.   {KEY3_CMD, key3_cb},
    6 H+ v2 j2 c! W* Y
21.   {0xFF, NULL  },
    ( `4 z1 H" v% b0 v+ L
22. };
    
23. 
    ; [1 B7 u5 M7 B3 a# W
24. // 按键的通用功能
    * O6 Q1 F) U# w. D+ a6 R( k
25. static void key_func(uint8_t func)
    
26. {
    $ `7 T# {# c- _4 O1 n/ K6 H; W/ ?
27. 
    / y* q- w% q9 p# w
28. }
    
29. 
    
30. static void key1_cb(void)
    
31. {
    
32. 
    1 ~* d4 H2 O$ Y9 i: e3 _
33. }
    
34. 
    8 J7 ~; \: {( s4 |
35. static void key2_cb(void)
    % @6 F2 ]* U- n
36. {
    
37. 
    # |: I' ~- f. A( R' g# v8 N5 b
38. }
    # K6 d2 Z3 G+ J" w2 Y
39. 
    
40. static void key3_cb(void)
    & w2 g7 I+ Y* q- E2 u
41. {
    
42. 
    
43. }
    
44. 
    2 a$ ]* @9 @$ Q' H1 o
45. static void key_process(uint8_t event)
    9 s/ h- }6 {8 o) V7 r: s
46. {
    9 }- I  O# ]7 {" {- ~
47.   const key_handle_t *entry;
    
48. 
    
49.   for(entry = key_entries; entry->key_handle_cb; ++entry)
    
50.   {
    2 v: g% Q% s+ \) q& h3 j+ m
51.     if(event == entry->cmd)
    : K4 s* Z; t% [7 ?6 F0 |( c/ T
52.     {
    , {! p9 P( Q7 J6 [
53.       entry->key_handle_cb();
    , ^. }$ f/ I$ C% g" [% K
54.       break;
    ! z6 x' j. Z' P4 v( R, @; ]
55.     }
    
56.   }
    
57. }

复制代码

1 K$ l, _, B+ P3 U裸机：按键扫描20ms执行一次，按键处理直接丢在主函数中。（自己写队列）
" F( i, @% R! R5 f; U4 J
" h6 ^" M( g6 u( w2 G7 Z" q0 N系统：在任务中执行按键扫描和按键处理。（系统自带队列或者邮箱）

2 _# e. v+ m) n, y