一、输入配置
2 ~! r3 P7 {; n0 r0 Y) k# E4 `为了灵活使用，我们将输入的有效电平设置成可配置。同样是列表表示所有IO口。
" H  d* }4 v, \
! c2 G) z) i" z) B6 w

1. // 配置有效电平
   
2. typedef enum
   # U) }0 u7 y) l2 X
3. {
   9 \1 ?- m% F) D' g
4.   KEY_INIT_IS_ACTIVE = 0,
   
5.   KEY_LOW_IS_ACTIVE  = 1,
   8 u# R! v/ }2 A8 v: i
6.   KEY_HIGH_IS_ACTIVE = 2,
   0 Z3 _6 i' |: D. f/ m
7. } key_active_t;
   0 w: I( L# q. |' _! h! j0 K! T
8. 
   & O- j4 [2 W) r& o
9. 
   ; t! }: J7 Y$ H/ v" }4 b
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)
    # d9 Y$ {( n0 `& p. `* l/ G$ J( k
12. 
    
13. #define KEY1_PORT                 GPIOH
    
14. #define KEY1_PIN                  GPIO_PIN_3
    / v4 E% \8 m( T
15. 
    
16. #define KEY2_PORT                 GPIOH
    
17. #define KEY2_PIN                  GPIO_PIN_2
    , w' q5 L, B1 j/ R
18. 
    
19. #define KEY3_PORT                 GPIOC
    1 ]& Q1 Q. x, }$ j) y- ~3 j
20. #define KEY3_PIN                  GPIO_PIN_13

复制代码

1. // demo代码 只传递思想
   
2. 
   
3. static void key_gpio_config(GPIO_TypeDef *gpio, uint16_t pin)
   , Y. j" v! o) m
4. {
   , f8 [% h6 M* ]+ V# A- ^
5.   KEY_CONFIG(gpio, pin);
   " U3 U# K8 _; l+ {7 |
6. }
   
7. 
   9 f  z) E$ J% f, M3 x; \; y6 D* ]
8. typedef struct
   
9. {
     ]; ^1 J9 w7 w6 w9 X* R4 c! W
10.   GPIO_TypeDef *gpio;
    9 O, P. `0 Q0 O7 P) O- b$ U
11.   uint16_t pin;
    
12. } key_port_t;
    
13. 
    
14. static key_port_t key_entries[] =
    
15. {
    ) H. a8 u1 S3 v! x7 _$ e. V9 j
16.   {KEY1_PORT, KEY1_PIN},
    : \0 P3 k8 |. {5 C. f# ~
17.   {KEY2_PORT, KEY2_PIN},
    * z- p$ }* c/ V$ ?7 l& {& O2 T0 [
18.   {KEY3_PORT, KEY3_PIN},
    & m# d0 r! k% }2 l1 P  S
19. };
    
20. 
    
21. void KeyInit(void)
    * t' Y  i( \2 k$ K/ J
22. {
      N. ^7 C% R! a! H2 g  Y$ J
23.   uint32_t i, mask = 1;
    ' J  O7 s# a4 h. }! R
24. 
    . x. O5 W( S$ V' I% h! b
25.   for(i = 0; i < ARRAY_SIZE(key_entries); ++i)
    9 a$ m7 F# `' U! [3 V! Q
26.   {
      f  l5 g& g1 Q! \; Q; D7 O
27.     if(0xFFFFFFFF & mask)
    
28.     {
    
29.       key_gpio_config(key_entries<span style="font-style: italic;">.gpio, key_entries.pin);
    
30. 
    9 C, y# @& v# j+ g8 a5 T
31. <span style="font-style: normal;">#if(CONFIG_KEY_TEST == 1) // 测试时使用      
    % L/ _$ y" K$ y9 \
32.       //config.key.total_switch  = KEY_MODE_OPEN;
      I2 u; _' k2 g* Y
33.       //config.key.sub_switch = KEY_MODE_OPEN;
    
34.       config.key.active_tag = KEY_LOW_IS_ACTIVE;
    $ d, F) m/ z- Q% t
35. #endif
    
36.     }
    ' _" Z; k$ [0 g- D/ [  C* [; \
37. 
    ) c6 y6 Q* t& O- V& Q
38.     mask <<= 1;
    * m" [* `2 N3 N7 i* v2 t# u
39.   }
    
40. }
    
41. 
    9 ^. P/ {5 t. e8 y7 ~
42. // 输入是否可用
    
43. static uint8_t key_is_enable(uint8_t index)
      _8 R9 D# P/ R. k4 D
44. {
    
45.   // 这里可以写成可配置 配置IO口可用或者不可用（类似一个总开关）
    % Z: a/ Y6 S, u
46.   return 1;
    / W' C0 r* W; l4 w: V  N
47. }
    
48. 
    
49. // 有输入到来
    ; f0 S% m+ V3 Z# ?& ], g3 _
50. static uint8_t key_is_pressed(uint8_t index)
    $ `5 Z& p0 g) ?' u
51. {
    
52.   if(key_is_enable(index))
    & r# q3 L% M% S& h$ o2 Y
53.   {
    7 ~4 X% _7 W* I6 y  S( H
54.     if(KEY_LOW_IS_ACTIVE == config.key.active_tag[index])
    " s; K8 @- i$ |5 l: J: H
55.     {
    ! F. ~! O5 \" M4 U
56.       if(KEY_READ(key_entries[index].gpio, key_entries[index].pin) == 0)
    
57.       {
    1 L: w5 E( v6 n2 H! x- |$ C! V
58.         return 1;
    3 [7 T, V+ w; O6 Z+ b3 H
59.       }
    
60.     }
    5 I7 [2 f5 ~; F3 I- I; j
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)
    
64.       {
    
65.         return 1;
    
66.       }
    
67.     }
    ; M9 ^# u( p( U: H4 A
68.   }
    
69. 
    ) `0 N9 ^! O* l
70.   return 0;
    
71. }
    
72. 
    1 x- `5 W. F+ w' @' g" |' O8 v4 O
73. // 按键被按下
    
74. uint8_t Key1IsDown(void)
    
75. {
    
76.   return key_is_pressed(0);
    6 Y3 u9 q$ w& J! l. h
77. }
    " P- K7 ~2 t  K& G  X0 P4 i. Z+ _
78. 
    
79. uint8_t Key2IsDown(void)
    
80. {
    
81.   return key_is_pressed(1);
    - ?: \0 }$ [7 V0 @5 M
82. }
    
83. 
    * u4 |7 ?! E4 l' n! Z
84. uint8_t Key3IsDown(void)
    1 B% @% L4 C- u8 W5 a9 B" }
85. {
    ' B+ h5 s  E2 ~
86.   return key_is_pressed(2);
    1 V7 J& }4 R4 q0 h3 M. i
87. }</span></span>

复制代码

3 G! W$ m1 F2 p  P  V+ g二、输入扫描

1. // 按键的状态机结构定义
   ( T! s2 O' w: f+ G
2. // 按键状态
   
3. typedef enum
   
4. {
   5 b, y) t+ C' b* w
5.   KEY_STATE_INIT, // 缺省按键状态
   
6.   KEY_STATE_UP,   // 按键弹起状态
   
7.   KEY_STATE_DOWN, // 按键按下状态
   2 g/ J7 D# w! W% f
8.   KEY_STATE_LONG, // 按键长按状态
   
9.   KEY_STATE_AUTO, // 按键自动连发状态
   
10. } key_state_t;
    
11. 
    5 ?7 C1 O2 h: p+ Z
12. // 按键滤波时间20ms, 单位10ms。
    
13. // 只有连续检测到20ms状态不变才认为有效，包括弹起和按下两种事件
    
14. // 即使按键电路不做硬件滤波，该滤波机制也可以保证可靠地检测到按键事件
    $ H5 P& `5 \* k+ w  c+ n+ d- H6 v; z
15. #define KEY_FILTER_TIME 2   // 滤波消抖
    
16. #define KEY_LONG_TIME   100 // 单位10ms    持续1秒，认为长按事件
    4 @- B# R2 a7 \6 m7 N9 e" j
17. #define KEY_REPEAT_TIME 100 // 单位10ms    持续1秒，自动连发
    
18. 
    + @. ^% T5 @  p7 n
19. typedef uint8_t (*key_cb)(void);
    ( V5 s; U2 c, V0 ]
20. typedef struct
    
21. {
    ( d- Y/ m* R2 H+ c5 o3 }
22.   uint8_t state;        // 按键当前状态(按下还是弹起)
    
23.   uint8_t last;         // 上一次按键的状态
    
24.   uint8_t count;        // 滤波消抖计数器
    $ [; q6 J4 f* g8 z, N  ^7 p6 z
25.   uint16_t long_time;   // 按键按下持续时间, 0表示不检测长按
    
26.   uint16_t long_count;  // 长按计数器
    
27.   uint8_t repeat_speed; // 连续按键周期
    
28.   uint8_t repeat_count; // 连续按键计数器
    2 u; `  ?) r4 W# t4 X9 s% K" u
29.   key_cb is_down_func;  // 按键按下的判断函数,1表示按下
    
30. } key_t;
    5 O* I+ c- J2 i/ U  k4 p( z
31. 
    
32. static key_t key_items[] =
    ) N& y- ^$ b; C$ ?+ l
33. {
    2 @  u( l! P( P0 w9 K7 ]
34.   {KEY_STATE_INIT, KEY_STATE_INIT, KEY_FILTER_TIME, KEY_LONG_TIME, 0, KEY_REPEAT_TIME, 0, Key1IsDown},
    5 M3 ?- l* \* ~7 x
35.   {KEY_STATE_INIT, KEY_STATE_INIT, KEY_FILTER_TIME, KEY_LONG_TIME, 0, KEY_REPEAT_TIME, 0, Key2IsDown},
    7 Y5 Y  m  u  I2 f
36.   {KEY_STATE_INIT, KEY_STATE_INIT, KEY_FILTER_TIME, KEY_LONG_TIME, 0, KEY_REPEAT_TIME, 0, Key3IsDown},
    7 m9 p/ \# Z& Y
37. };

复制代码

1. // 按键状态机key_scan
   ! ]+ A/ T9 e6 K$ y! g) I, |
2. // 配置限制条件在这个函数里面加
   / u6 W8 }% _& F, U3 N6 X
3. static void key_scan_ext(key_t *entry, uint8_t i)
   
4. {
   
5.   switch(entry->state)
   
6.   {
   
7.   case KEY_STATE_INIT:
   
8.   case KEY_STATE_UP:
   
9.   {
   : d8 l" {2 M. R0 k
10.     entry->state = KEY_STATE_DOWN; // 按键被按下
    
11.     break;
    
12.   }
    
13. 
      H8 j9 ^. Q/ |+ {3 Z
14.   case KEY_STATE_DOWN:
    # \: r" U$ l! {; {5 n4 o% k
15.   {
    ! H; o/ f6 T) e
16.     if(entry->long_time > 0)
    
17.     {
    
18.       if(entry->long_count < entry->long_time)
    0 r+ U( y' @# m; F
19.       {
    
20.         if(++entry->long_count >= entry->long_time)
    " O# O, K$ a9 t" w- \6 S
21.         {
    4 [" V9 u3 Q; i) E7 O; ?! H6 {& Q6 L* h
22.           entry->state = KEY_STATE_LONG;
    . y) Z2 H3 s* I9 o" o3 f: I
23.         }
    
24.       }
    
25.     }
    
26. 
    % [9 U  n% N2 l$ l1 m1 ]% @
27.     break;
    
28.   }
    
29. 
    8 r' l/ r9 R1 F( j4 j% A2 L
30.   case KEY_STATE_LONG:
      L- l5 R* I& W
31.   {
    + `: t8 f8 v, G2 n2 i* P8 W
32.     if(entry->repeat_speed > 0) // 自动连发时间到  自动连发事件
    
33.     {
    
34.       if(++entry->repeat_count >= entry->repeat_speed)
    # e( v! X+ V/ ~4 a5 V0 @; C- A$ E
35.       {
    
36.         entry->repeat_count = 0;
    1 Z* {3 ~; {7 b0 O
37.         // 长按触发
    
38.       }
    
39.     }
    
40. 
    
41.     break;
    7 g$ O& N* m" Q6 n6 m# v& A, |" T
42.   }
    9 T0 W* f; g: s* E
43.   }
    0 }% Y7 \- [3 m6 ^' ]. M
44. 
    : W8 X) T1 B" a' K
45.   entry->last = entry->state; // 最新的按键状态
    - L5 k' B' K8 G) j
46. }
    
47. 
    
48. static void key_scan(uint8_t i)
    
49. {
    . \% H  ?) k: B" o: R8 ^! O) W
50.   key_t *entry = &key_items<span style="font-style: italic;"><span style="font-style: normal;">;
    3 y2 \9 H  e4 a/ j: S  }; S3 I, j
51.         uint8_t key;
    ) `9 X) u" n8 c# F! F! G. m
52. 
    1 a/ W4 B4 Q5 V$ G2 H' @! W7 W% B+ h
53.   if(entry->is_down_func())
    
54.   {
    2 |6 w2 i1 |& m* i6 p
55.     if(entry->count < KEY_FILTER_TIME) // 消抖
    5 b. F& s' i5 J, d7 ]5 L- A
56.     {
    
57.       ++entry->count;
    
58.     }
    3 u' h9 e2 r  T- b, x2 Z
59.     else
    
60.     {
    $ w0 _) _( y' \( D% u7 C
61.       key_scan_ext(entry, i); // 按键扫描状态机
    
62.     }
    4 I/ {' U6 D  [" L+ C+ y
63.   }
    
64.   else
    
65.   {
    
66.     if(entry->count > KEY_FILTER_TIME)
    
67.     {
    . g6 u* C: D/ q. U+ K* c1 {
68.       entry->count = KEY_FILTER_TIME;
    " i2 w& Q, m8 C9 ^. n/ C1 }; S3 A0 u
69.     }
    
70.     else if(entry->count > 0)
    9 \4 G2 j/ r3 r# G1 D. O7 s/ t
71.     {
    6 S0 @+ x+ `4 {0 j+ {: Y8 ~) V" B
72.       --entry->count;
    
73.     }
    5 F+ g8 i: |$ ~6 T( a2 U
74.     else
    8 T" G- H# Y( B3 C: ^: Q: F! h1 z: T8 K
75.     {
    ! Y0 H+ D. q& Z0 n% o8 ^
76.       if(KEY_STATE_DOWN == entry->last) // 一次完整的按键到这里就弹起了
    
77.       {
    6 F' ?# u2 e5 |7 _+ G0 ^  M. I, Y
78.        // 按键按下之后可以加入到队列中，这里的队列可以自己写；如果带系统可以使用系统的消息队列等方式。
    
79.        // key = i + 1;
    5 p: t$ b, M  ~  C# e6 M+ Z
80.        // xQueueSend(os_key_queue, &key, 10);
    
81.       }
    
82.       entry->last  = KEY_STATE_UP;
    1 i3 J3 G5 e0 q
83.       entry->state = KEY_STATE_UP; // 按键弹起状态
    3 F- M* u. D, Y+ e: V* D
84.     }
    
85. 
    ' h$ `) `# c! ?: T3 T" m. q
86.     entry->long_count = 0;
    5 V9 x/ \' F" X) m# a0 V
87.     entry->repeat_count = 0; // 清空计数器
    
88.   }
    
89. }</span></span>

复制代码

三、输入处理
5 A7 n  i. m/ Q6 g' y& ]3 u

1. // 按键按下之后，会将值加入到队列中，我们读取队列数据，然后扫描列表匹配功能
   
2. static void key1_cb(void);
   0 v- |6 a$ C' Z& x. K# {' W- \
3. static void key2_cb(void);
   
4. static void key3_cb(void);
   * {) Z2 F& X9 Y5 r5 J
5. 
   - I4 E# B- }+ L8 }. P
6. #define KEY1_CMD         1
   
7. #define KEY2_CMD         2
   $ E8 U& r3 h; Z& C. }- i% L0 }
8. #define KEY3_CMD         3
   
9. 
   ' ^, }7 y( H  j) x* u7 v4 S
10. typedef struct
    
11. {
    * O+ H! O0 r' p6 [! u
12.   uint8_t cmd;
    
13.   void (* key_handle_cb)(void);
    
14. } key_handle_t;
    
15. 
    & U2 o& R- a; t
16. static const key_handle_t key_entries[] =
    $ o- f& Y# V! R7 L: N
17. {
    4 w1 M2 }' w# z3 h! d- y
18.   {KEY1_CMD, key1_cb},
    4 t' i  P/ m/ G3 D# }" k
19.   {KEY2_CMD, key2_cb},
    
20.   {KEY3_CMD, key3_cb},
    / e3 z$ g3 P! K
21.   {0xFF, NULL  },
    
22. };
    
23. 
    " ^* ^7 \+ U) L
24. // 按键的通用功能
    + @, z+ ^: [& a5 t! d
25. static void key_func(uint8_t func)
    5 c: J* D5 w) t) x0 U+ C
26. {
    6 l6 m& y* M0 T) z3 F" d
27. 
    ; {9 C2 ^" d$ b0 Y* e  i# W- k; n. m
28. }
    
29. 
    
30. static void key1_cb(void)
    
31. {
    
32. 
    ! s$ ?# m: y  P  |
33. }
      ^, N+ N+ h- M: P3 T
34. 
      C% q8 z' m! I2 N2 z4 v
35. static void key2_cb(void)
    
36. {
    
37. 
    , b; H) M1 }* y7 Z  @
38. }
    ! r# M; W& j' t1 t& F8 F! b
39. 
    
40. static void key3_cb(void)
    
41. {
    
42. 
    
43. }
    " n; ~" M/ ^! W* T$ R( i! Z! y+ {5 w4 v
44. 
    
45. static void key_process(uint8_t event)
    
46. {
    
47.   const key_handle_t *entry;
    6 u0 ^! k' ]$ D+ v8 C$ u% d7 q
48. 
    * g3 x  Y. @- F; c
49.   for(entry = key_entries; entry->key_handle_cb; ++entry)
    : f2 A, G8 o" m' U- W- U
50.   {
    
51.     if(event == entry->cmd)
    
52.     {
    
53.       entry->key_handle_cb();
    2 `1 L1 o, s3 g5 h& Z
54.       break;
    % k' r& R6 N2 k7 g% n5 N
55.     }
    7 S% Q+ `( j8 r0 h. F
56.   }
    
57. }

复制代码

裸机：按键扫描20ms执行一次，按键处理直接丢在主函数中。（自己写队列）
: U/ |% R  n2 r/ B' R( @
: r$ M2 R/ W5 l* n% x0 A系统：在任务中执行按键扫描和按键处理。（系统自带队列或者邮箱）

- C1 o4 n# n/ k! ]# L: Y
3 u3 v1 j( {+ j  `2 T