19.1 初学者重要提示
按键FIFO驱动扩展和移植更简单，组合键也更好用。支持按下、弹起、长按和组合键。

19.2 按键硬件设计
V7开发板有三个独立按键和一个五向摇杆，下面是三个独立按键的原理图：

$ R  n" m- x4 p# ]% s% N3 _

( x4 |$ `- b% j& E; F) S
% P! B3 F3 ~, _7 ?  t$ G注意，K1（S1）、K2(S2)和K3(S3)按键的上拉电阻是接在5V电压上，因为这三个按键被复用为PS/2键盘鼠标接口，而PS/2是需要5V供电的（注，V5和V6开发板做了PS/2复用，而V7没有使用，这里只是为了兼容之前的板子）。实际测试，K1、K2、K3按键和PS/2键盘是可以同时工作的。

; u' g5 v# Z" Q5 l5 q下面是五向摇杆的原理图：

0 E+ J( D# n8 p
通过这个硬件设计，有如下两个知识点为大家做介绍：
% {/ Q2 F9 }+ j, }
19.2.1 硬件设计
按键和CPU之间串联的电阻起保护作用。按键肯定是存在机械抖动的，开发板上面的硬件没有做硬件滤波处理，即使设计了硬件滤波电路，软件上还是需要进行滤波。

  保护GPIO，避免软件错误将IO设置为输出，如果设置为低电平还好，如果设置输出的是高电平，按键按下会直接跟GND(低电平)连接，从而损坏MCU。
  保护电阻也起到按键隔离作用，这些GPIO可以直接用于其它实验。
19.2.2 GPIO内部结构分析按键
7 Z+ e: b* \) S6 V) X6 k0 x. ?详细的GPIO模式介绍，请参考第15章的15.3小节，本章仅介绍输入模式。下面我们通过一张图来简单介绍GPIO的结构。

; p9 L. `% Z9 ^  S2 V# ?

红色的线条是GPIO输入通道的信号流向，作为按键检测IO，这些需要配置为浮空输入。按键已经做了5V上拉，因此GPIO内部的上下拉电阻都选择关闭状态。
6 e- L6 E. d- X" x. i7 H% |, V
19.3 按键FIFO的驱动设计
bsp_key按键驱动程序用于扫描独立按键，具有软件滤波机制，采用FIFO机制保存键值。可以检测如下事件：

9 Y1 F  h. p! E; [  按键按下。
  按键弹起。
  长按键。
  s5 b, w$ v, Q( Z0 B% c  长按时自动连发。
: Z) E$ N+ J5 a: v" v; i我们将按键驱动分为两个部分来介绍，一部分是FIFO的实现，一部分是按键检测的实现。
9 L# Y( w9 q2 l. p( g  _

' [" @8 ?/ p2 n% g) f. l' ~
$ c, S' j( a% H  T6 Absp_key.c 文件包含按键检测和按键FIFO的实现代码。
, h. e  x: M9 X0 Y- ^  d
4 o! e) x$ ]5 ^- ibsp.c 文件会调用bsp_InitKey()初始化函数。

bsp.c 文件会调用bsp_KeyScan按键扫描函数。
' N, c/ Q) g5 T  s1 [0 b8 F' \$ A
bsp_timer.c 中的Systick中断服务程序调用 bsp_RunPer10ms。
/ \% ~& @0 k+ m  z3 K
中断程序和主程序通过FIFO接口函数进行信息传递。

函数调用关系图：
, o5 X1 }' ~) A3 E# J, D3 J
! i7 ~. l6 f9 j: O6 ?9 J

19.3.1 按键FIFO的原理
FIFO是First Input First Output的缩写，先入先出队列。我们这里以5个字节的FIFO空间进行说明。Write变量表示写位置，Read变量表示读位置。初始状态时，Read = Write = 0。
" k7 s2 f+ D7 v
  J; i+ m# q6 r

" A; ~: u' b) B1 b; F
# R6 z: ?2 t, d1 \1 I% O% \我们依次按下按键K1，K2，那么FIFO中的数据变为：
6 E- j! v' s1 q2 u9 O; H

( \) I1 x" F& {) v如果Write！= Read，则我们认为有新的按键事件。

我们通过函数bsp_GetKey读取一个按键值进行处理后，Read变量变为1。Write变量不变。
2 }9 z/ C* H4 c5 T1 |
+ G: T/ f4 K# t5 u; y+ @2 H

9 |9 ]1 i+ P7 l/ b! p
& m- R. u  ]) T% `2 s( B我们继续通过函数bsp_GetKey读取3个按键值进行处理后，Read变量变为4。此时Read = Write = 4。两个变量已经相等，表示已经没有新的按键事件需要处理。
6 w- c2 o6 w7 o$ l1 b+ H" t
有一点要特别的注意，如果FIFO空间写满了，Write会被重新赋值为0，也就是重新从第一个字节空间填数据进去，如果这个地址空间的数据还没有被及时读取出来，那么会被后来的数据覆盖掉，这点要引起大家的注意。我们的驱动程序开辟了10个字节的FIFO缓冲区，对于一般的应用足够了。

设计按键FIFO主要有三个方面的好处：
7 S' s6 v2 x' V) D8 d" o& w4 c; s
- Z  M! P/ y5 W/ N* S  可靠地记录每一个按键事件，避免遗漏按键事件。特别是需要实现按键的按下、长按、自动连发、弹起等事件时。
  读取按键的函数可以设计为非阻塞的，不需要等待按键抖动滤波处理完毕。
  按键FIFO程序在嘀嗒定时器中定期的执行检测，不需要在主程序中一直做检测，这样可以有效地降低系统资源消耗。
; T& [; C) A% ~) j
19.3.2 按键FIFO的实现
# L2 l6 Z1 u% X; n在bsp_key.h 中定了结构体类型KEY_FIFO_T。这只是类型声明，并没有分配变量空间。

* b- `" f1 f  w' L

1. #define KEY_FIFO_SIZE        10
   
2. typedef struct
   
3. {
   
4.         uint8_t Buf[KEY_FIFO_SIZE];                /* 键值缓冲区 */
   . _8 i" w  S; R! [' s+ j
5.         uint8_t Read;                                        /* 缓冲区读指针1 */
   ; r1 a& b# O$ n5 h
6.         uint8_t Write;                             /* 缓冲区写指针 */
   
7.         uint8_t Read2;                             /* 缓冲区读指针2 */
   
8. }KEY_FIFO_T;

复制代码

在bsp_key.c 中定义s_tKey结构变量, 此时编译器会分配一组变量空间。
; Z+ |/ x! j/ s( z$ E6 V& h
# K4 E8 u, b# Z& w/ X. y1 I

1. static KEY_FIFO_T s_tKey;                /* 按键FIFO变量,结构体 */

复制代码

一般情况下，只需要一个写指针Write和一个读指针Read。在某些情况下，可能有两个任务都需要访问按键缓冲区，为了避免键值被其中一个任务取空，我们添加了第2个读指针Read2。出厂程序在bsp_Idle()函数中实现的按K1K2组合键截屏的功能就使用的第2个读指针。

2 l$ u" X# Q8 a. Z3 v3 Z2 d当检测到按键事件发生后，可以调用 bsp_PutKey函数将键值压入FIFO。下面的代码是函数的实现：

1. /*
   % n6 \2 {! C& i7 b" |" ?, |9 r
2. *********************************************************************************************************
   ) @# w) q% \+ V6 A5 e) H
3. *        函 数 名: bsp_PutKey
   
4. *        功能说明: 将1个键值压入按键FIFO缓冲区。可用于模拟一个按键。
   
5. *        形    参: _KeyCode : 按键代码
   
6. *        返 回 值: 无
   0 t# c% ?' i( W: h2 k/ B$ _
7. *********************************************************************************************************
   
8. */
   
9. void bsp_PutKey(uint8_t _KeyCode)
   
10. {
    ) u6 L1 G1 y% S6 x7 d. @$ t
11.         s_tKey.Buf[s_tKey.Write] = _KeyCode;
    
12. 
    7 C, h4 L: M) \4 q5 h/ H8 ], ^
13.         if (++s_tKey.Write  >= KEY_FIFO_SIZE)
    
14.         {
    
15.                 s_tKey.Write = 0;
    
16.         }
    & B5 ]) g" y* R; v5 M' x, z8 G
17. }

复制代码

这个bsp_PutKey函数除了被按键检测函数调用外，还可以被其他底层驱动调用。比如红外遥控器的按键检测，也共用了同一个按键FIFO。遥控器的按键代码和主板实体按键的键值统一编码，保持键值唯一即可实现两套按键同时控制程序的功能。
  S  z- i8 Z; X. R$ |/ r
应用程序读取FIFO中的键值，是通过bsp_GetKey函数和bsp_GetKey2函数实现的。我们来看下这两个函数的实现：

1. /*
   
2. *********************************************************************************************************
   - \3 l% S" o  r' Q4 R
3. *        函 数 名: bsp_GetKey
   " d! {9 G+ S) r5 T- H& y, B% `
4. *        功能说明: 从按键FIFO缓冲区读取一个键值。
   / H5 j, o; Y+ A% `
5. *        形    参:  无
   
6. *        返 回 值: 按键代码
   2 I4 ]3 a) F$ ]2 ^
7. *********************************************************************************************************
   / K  L' i9 s! y. j: i$ }( ~
8. */
   8 E$ `2 S6 q1 u% t: f8 p) H
9. uint8_t bsp_GetKey(void)
   7 ?& i8 z) ]3 @+ t4 c' s8 D
10. {
    . f  \  }' J; c/ B- _4 |8 S2 {
11.         uint8_t ret;
    * j2 h1 ~% G& U" O& y9 e
12. 
    % p8 @# r% v+ f) X3 g: Q3 t
13.         if (s_tKey.Read == s_tKey.Write)
    
14.         {
    
15.                 return KEY_NONE;
    5 j* c0 }3 R8 p3 S7 E/ ?1 A
16.         }
    
17.         else
    + S+ \2 U6 l) l) E  y0 w
18.         {
    0 I& ]) E2 v( q5 k$ i
19.                 ret = s_tKey.Buf[s_tKey.Read];
    
20. 
    
21.                 if (++s_tKey.Read >= KEY_FIFO_SIZE)
    2 w7 Y" @' z- R, @; `; k
22.                 {
    ( e+ b" @7 B& o: {
23.                         s_tKey.Read = 0;
    
24.                 }
    5 {6 }( x# t, g7 O. ]6 t1 h
25.                 return ret;
      J8 m. W7 g9 q' Z
26.         }
    : _( R4 R4 R8 r
27. }
    9 Y/ U4 a2 m4 R* }7 T, K
28. 
    
29. /*
    4 Z6 U$ ~' |5 a
30. *********************************************************************************************************
    
31. *        函 数 名: bsp_GetKey2
    
32. *        功能说明: 从按键FIFO缓冲区读取一个键值。独立的读指针。
    % `; a! o7 g# u. h) l8 z
33. *        形    参:  无
    
34. *        返 回 值: 按键代码
    
35. *********************************************************************************************************
    . i7 J/ o: R9 f& i
36. */
    
37. uint8_t bsp_GetKey2(void)
    7 y( |' d% y9 d  y+ M0 u( G6 J
38. {
    
39.         uint8_t ret;
    
40. 
    : ~" I' P4 m7 @, k1 p
41.         if (s_tKey.Read2 == s_tKey.Write)
    - G' N* @: n  J% H
42.         {
    
43.                 return KEY_NONE;
    
44.         }
    + {3 H0 q' s) S8 d8 p( A% {
45.         else
    
46.         {
    
47.                 ret = s_tKey.Buf[s_tKey.Read2];
    
48. 
    % [; ]/ T3 j9 z& W- U3 M. _
49.                 if (++s_tKey.Read2 >= KEY_FIFO_SIZE)
    1 q' T7 |2 }: D3 v0 ^* J* a: y
50.                 {
    : e2 Y: S! F3 ?, H
51.                         s_tKey.Read2 = 0;
    0 q$ J! T: @8 ?" C; z
52.                 }
    
53.                 return ret;
    
54.         }
    8 D1 ^* r2 ^- W2 u( ]9 a
55. }

复制代码

返回值KEY_NONE = 0, 表示按键缓冲区为空，所有的按键时间已经处理完毕。按键的键值定义在 bsp_key.h文件，下面是具体内容：

1. typedef enum
   3 N/ b- \; A/ A$ V( w' Q
2. {
   $ s  `7 J. }. C6 I" d
3.         KEY_NONE = 0,                        /* 0 表示按键事件 */
   
4. 
   * {7 o/ z( N- ^$ v2 l/ g) M
5.         KEY_1_DOWN,                        /* 1键按下 */
   
6.         KEY_1_UP,                                /* 1键弹起 */
   
7.         KEY_1_LONG,                        /* 1键长按 */
   " A2 _  s; j0 p7 D/ d9 M
8. 
   
9.         KEY_2_DOWN,                        /* 2键按下 */
   
10.         KEY_2_UP,                                /* 2键弹起 */
    
11.         KEY_2_LONG,                        /* 2键长按 */
    
12. 
    
13.         KEY_3_DOWN,                        /* 3键按下 */
    . A6 F; A: J; h: W' ?
14.         KEY_3_UP,                                /* 3键弹起 */
    * _( `$ z) A! p1 Z# H: M
15.         KEY_3_LONG,                        /* 3键长按 */
    $ A& e) r* X, j( y9 [2 q
16. 
    0 Y3 z) p: R( e! O
17.         KEY_4_DOWN,                        /* 4键按下 */
    
18.         KEY_4_UP,                                /* 4键弹起 */
    $ H+ t; \& s8 b( L* G# }
19.         KEY_4_LONG,                        /* 4键长按 */
    
20. 
    
21.         KEY_5_DOWN,                        /* 5键按下 */
    8 o0 x: ]8 @. w) ~
22.         KEY_5_UP,                                /* 5键弹起 */
    : \; p. n% z- p3 ]$ v
23.         KEY_5_LONG,                        /* 5键长按 */
    # B' V  i+ s* E- g) F6 Z' _& c
24. 
    & X* H  b8 ?' Z( D
25.         KEY_6_DOWN,                        /* 6键按下 */
    
26.         KEY_6_UP,                                /* 6键弹起 */
    * i- w: ?! N- Y' Q; n: r) W
27.         KEY_6_LONG,                        /* 6键长按 */
    
28. 
    
29.         KEY_7_DOWN,                        /* 7键按下 */
    8 v1 k- |$ C& K/ O6 ]; {, w, \
30.         KEY_7_UP,                                /* 7键弹起 */
    
31.         KEY_7_LONG,                        /* 7键长按 */
    ! W6 S( [  [% J& h& h; i
32. 
    ; F+ S7 ~+ ^! w* n3 \
33.         KEY_8_DOWN,                        /* 8键按下 */
    % E! j- C2 J  A7 v) k1 A/ O# Z  F
34.         KEY_8_UP,                                /* 8键弹起 */
    
35.         KEY_8_LONG,                        /* 8键长按 */
    
36. 
    
37.         /* 组合键 */
    : P2 O% |6 T( i2 o6 h$ [4 Z  z! S, @
38.         KEY_9_DOWN,                        /* 9键按下 */
    
39.         KEY_9_UP,                                /* 9键弹起 */
    4 w8 v& \4 Y8 D8 z
40.         KEY_9_LONG,                        /* 9键长按 */
    $ w4 c( a! e( J0 |: a9 I
41. 
    
42.         KEY_10_DOWN,                        /* 10键按下 */
    8 u2 w3 _& F+ q0 L# D2 `* _
43.         KEY_10_UP,                        /* 10键弹起 */
    
44.         KEY_10_LONG,                        /* 10键长按 */
    
45. }KEY_ENUM;

复制代码

必须按次序定义每个键的按下、弹起和长按事件，即每个按键对象（组合键也算1个）占用3个数值。我们推荐使用枚举enum, 不用#define的原因：
' m3 w3 D' g% R+ n# f
  便于新增键值,方便调整顺序。
  N# g  l# Q' I  M1 ?  使用{ } 将一组相关的定义封装起来便于理解。
6 p+ u0 o+ H+ D8 ]. _  编译器可帮我们避免键值重复。
我们来看红外遥控器的键值定义，在bsp_ir_decode.h文件。因为遥控器按键和主板按键共用同一个FIFO，因此在这里我们先贴出这段定义代码，让大家有个初步印象。
7 A' p6 s/ b+ b) R0 N9 M

1. /* 定义红外遥控器按键代码, 和bsp_key.h 的物理按键代码统一编码 */
   4 y; J& x. S; R5 _8 c! k, }: o
2. typedef enum
   % r/ @6 ^5 P4 Q- v4 B8 Q# v
3. {
   2 }. j9 f) M5 P5 P
4.         IR_KEY_STRAT         = 0x80,
   4 @) f" |3 Q  v" ]$ N
5.         IR_KEY_POWER         = IR_KEY_STRAT + 0x45,
   
6.         IR_KEY_MENU         = IR_KEY_STRAT + 0x47,
   
7.         IR_KEY_TEST         = IR_KEY_STRAT + 0x44,
   & Z3 U. f/ v* A
8.         IR_KEY_UP         = IR_KEY_STRAT + 0x40,
   & D! j8 q! v& G9 n1 I8 d8 M9 U
9.         IR_KEY_RETURN        = IR_KEY_STRAT + 0x43,
   & m: q6 \7 f7 Z4 B, {2 B  V% S
10.         IR_KEY_LEFT        = IR_KEY_STRAT + 0x07,
    
11.         IR_KEY_OK                = IR_KEY_STRAT + 0x15,
    3 l# b" Z: K( S- w# U& k1 H% a
12.         IR_KEY_RIGHT        = IR_KEY_STRAT + 0x09,
    
13.         IR_KEY_0                = IR_KEY_STRAT + 0x16,
    0 _% J) k( D& e* c
14.         IR_KEY_DOWN        = IR_KEY_STRAT + 0x19,
    
15.         IR_KEY_C                = IR_KEY_STRAT + 0x0D,
    
16.         IR_KEY_1                = IR_KEY_STRAT + 0x0C,
    
17.         IR_KEY_2                = IR_KEY_STRAT + 0x18,
    
18.         IR_KEY_3                = IR_KEY_STRAT + 0x5E,
    : E$ h2 A5 }% t
19.         IR_KEY_4                = IR_KEY_STRAT + 0x08,
    
20.         IR_KEY_5                = IR_KEY_STRAT + 0x1C,
    
21.         IR_KEY_6                = IR_KEY_STRAT + 0x5A,
    ! I  l7 g, b  D  K
22.         IR_KEY_7                = IR_KEY_STRAT + 0x42,
    
23.         IR_KEY_8                = IR_KEY_STRAT + 0x52,
    6 h- A4 j  X; R7 B2 Z) j
24.         IR_KEY_9                = IR_KEY_STRAT + 0x4A,        
    , `* L! i* y; X5 H4 O  q
25. }IR_KEY_E;

复制代码

) f* U8 C2 O: G) E5 Z我们下面来看一段简单的应用。这个应用的功能是：主板K1键控制LED1指示灯；遥控器的POWER键和MENU键控制LED2指示灯。
6 E: L1 B& s. E4 D% G! ~5 C
- D4 D3 |) t8 h" t  K5 w

1. #include "bsp.h"
   
2. 
   
3. int main(void)
   $ C" J0 c! c. Z
4. {
   
5.         uint8_t ucKeyCode;
   
6.                         
   % J6 c, E  C$ d# }! Q. Y4 F' _
7.         bsp_Init();
   $ H5 q1 Q% c5 `# ~, I
8. 
   
9.         IRD_StartWork();        /* 启动红外解码 */
   : a6 R& K. u' t( R& l& Y0 [+ K
10. 
    
11.         while(1)
    
12.         {
    
13.                 bsp_Idle();
    " J* `: J& j. ^; m) v4 W' J
14.                
    % v. n) i+ x8 u$ P) P: a6 F$ w0 D
15.                 /* 处理按键事件 */
    
16.                 ucKeyCode = bsp_GetKey();
    * O& F; P. p3 y4 {, p" C) R. _
17.                 if (ucKeyCode > 0)
    
18.                 {
    
19.                         /* 有键按下 */
    
20.                         switch (ucKeyCode)
    
21.                         {
    
22.                                 case KEY_DOWN_K1:                /* K1键按下 */
    
23.                                         bsp_LedOn(1);                /* 点亮LED1 */
    8 ]8 c3 ^8 B( p7 o9 z/ L3 D1 }
24.                                         break;
    
25. 
    , ?, n0 X% U! B
26.                                 case KEY_UP_K1:                /* K1键弹起 */
    3 j+ X" Q0 H7 J5 m6 j' K+ k$ r$ a
27.                                         bsp_LedOff(1);        /* 熄灭LED1 */
    + Q, L: ?9 ?# Y" j8 M1 [$ _
28.                                         break;                                       
    + l3 k' N  \. e  F1 h/ O7 O& j
29. 
    0 C) B' p$ K& r" t
30.                                 case IR_KEY_POWER:                /* 遥控器POWER键按下 */
    0 r, [' B4 k) D* X9 [) a
31.                                         bsp_LedOn(1);                /* 点亮LED2 */
    0 ]) z$ Q6 [7 E6 V- ?1 g
32.                                         break;
    
33. 
    1 z' P# n! {* ?( o! `+ S
34.                                 case IR_KEY_MENU:                /* 遥控器MENU键按下 */
    
35.                                         bsp_LedOff(1);        /* 熄灭LED2 */
    ' p( i% F0 R' U
36.                                         break;                                       
    + U# s$ w7 m8 ^# d! p8 M0 w
37. 
    
38.                                 case MSG_485_RX:                /* 通信程序的发来的消息 */
    ' c6 {" T  v9 q3 z' Z" i' ?) B
39.                                         /* 执行通信程序的指令 */
    
40.                                         break;
    % v+ ?4 e; J6 h' O- o1 d) ]; z
41. 
    7 l' t/ p: F- m$ O
42.                                 default:
    - B# c4 P) z- `
43.                                         break;
    - `: H  K$ A0 m. ~) g2 t% v$ Q
44.                         }
    
45.                 }
    ; a/ E( W# a( N2 s8 g
46.         }
    
47. }

复制代码

看到这里，想必你已经意识到bsp_PutKey函数的强大之处了，可以将不相关的硬件输入设备统一为一个相同的接口函数。
0 [6 \2 {) ?: `4 q
8 O5 O  `5 m4 ]+ z) F在上面的应用程序中，我们特意添加了一段红色的代码来解说更高级的用法。485通信程序收到有效的命令后通过 bsp_PutKey（MSG_485_RX）函数可以通知APP应用程序进行进一步加工处理（比如显示接收成功）。这是一种非常好的任务间信息传递方式，它不会破坏程序结构。不必新增全局变量来做这种事情，你只需要添加一个键值代码。
" x- J- J1 P5 ~+ f0 Y! ~
对于简单的程序，可以借用按键FIFO来进行少量的信息传递。对于复杂的应用，我们推荐使用bsp_msg专门来做这种任务间的通信。因为bsp_msg除了传递消息代码外，还可以传递参数结构。
% X+ Y/ @; F4 v. f
19.3.3 按键检测程序分析
在bsp_key.h 中定了结构体类型KEY_T。
9 G* F; O; h5 J, \

1. #define KEY_COUNT    10                           /* 按键个数, 8个独立建 + 2个组合键 */
   
2. 
   
3. typedef struct
   
4. {
   $ L. x. J$ Z' k+ x  z# Q6 y& L& P% I
5.         /* 下面是一个函数指针，指向判断按键手否按下的函数 */
   
6.         uint8_t (*IsKeyDownFunc)(void); /* 按键按下的判断函数,1表示按下 */
   
7. 
   
8.         uint8_t  Count;                /* 滤波器计数器 */
   7 L- p5 a3 J) F/ d# _6 \5 @( A
9.         uint16_t LongCount;        /* 长按计数器 */
   / ?" k. w9 P2 @0 {! F4 Y6 O
10.         uint16_t LongTime;                /* 按键按下持续时间, 0表示不检测长按 */
    & _1 t8 I4 l$ k
11.         uint8_t  State;                /* 按键当前状态（按下还是弹起） */
      n* ]1 t" ~' _6 A# m* {
12.         uint8_t  RepeatSpeed;        /* 连续按键周期 */
    
13.         uint8_t  RepeatCount;        /* 连续按键计数器 */
    8 r! v( h/ B+ F
14. }KEY_T;

复制代码

5 h5 `2 `" f+ p1 U在bsp_key.c 中定义s_tBtn结构体数组变量。
- s* h6 ~( f( s

1. static KEY_T s_tBtn[KEY_COUNT];
   ; H: E7 }( p& o9 {
2. static KEY_FIFO_T s_tKey; /* 按键FIFO变量,结构体 */

复制代码

每个按键对象都分配一个结构体变量，这些结构体变量以数组的形式存在将便于我们简化程序代码行数。
7 n: y& Z. y# m
7 i2 k0 q8 f  F3 u  O2 O: L( F+ {# x使用函数指针IsKeyDownFunc可以将每个按键的检测以及组合键的检测代码进行统一管理。

* o+ }  K# T  r0 x9 U' s因为函数指针必须先赋值，才能被作为函数执行。因此在定时扫描按键之前，必须先执行一段初始化函数来设置每个按键的函数指针和参数。这个函数是 void bsp_InitKey(void)。它由bsp_Init()调用。
! G0 F& j% B' o8 n) x
: X, R! t) g# w0 w- n) D

1. /*
   . x- K; I2 e" f1 F+ O
2. *********************************************************************************************************
   6 J; h( z5 ?5 p2 w
3. *        函 数 名: bsp_InitKey
   
4. *        功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
   ! p2 g+ `7 J8 @8 |  q- S& K
5. *        形    参: 无
   
6. *        返 回 值: 无
   * _/ Y' {; g0 _2 n+ A7 T
7. *********************************************************************************************************
   
8. */
   
9. void bsp_InitKey(void)
   0 R3 {- u2 s$ {8 c  }
10. {
    : i# o, e$ i4 N0 a' q& Z3 ?
11.         bsp_InitKeyVar();                /* 初始化按键变量 */
    ; ~9 ]" Y7 y- {- T/ @! ]- Q
12.         bsp_InitKeyHard();                /* 初始化按键硬件 */
    5 ?- s! @' n) M& ]# K
13. }

复制代码

4 P5 {5 H/ N3 y* F* ]下面是bsp_InitKeyVar函数的定义：

1. /*
   - i% L, @" m$ P6 m
2. *********************************************************************************************************
   : }! u9 q9 r! U
3. *        函 数 名: bsp_InitKeyVar
   
4. *        功能说明: 初始化按键变量
   
5. *        形    参:  无
   " D/ p9 e$ i- n& G9 G, L0 b7 v$ D
6. *        返 回 值: 无
   % [- F* `4 A* d& J4 v
7. *********************************************************************************************************
   + l7 _1 Z# Q& F: m/ l3 y2 s
8. */
   $ A, N+ x/ Z+ |; V' o$ P
9. static void bsp_InitKeyVar(void)
   
10. {
    4 O1 ~8 \8 R/ V
11.         uint8_t i;
    ) I2 z" \. r: T; k7 _/ m) C
12. 
      U! o4 s; h5 i2 ^! U- K# L
13.         /* 对按键FIFO读写指针清零 */
    1 x" D+ y7 ~1 V- _2 X: e, R
14.         s_tKey.Read = 0;
      a; `! }: i4 h
15.         s_tKey.Write = 0;
    
16.         s_tKey.Read2 = 0;
    ( s+ @. i% t, \3 l  n1 I9 K
17. 
    
18.         /* 给每个按键结构体成员变量赋一组缺省值 */
    7 s( ^) o' m: o5 b. p2 ]
19.         for (i = 0; i < KEY_COUNT; i++)
    5 a. m5 ~1 g( c
20.         {
    6 S* r* {' V5 W- w( X4 q
21.                 s_tBtn<i>.LongTime = KEY_LONG_TIME;                        /* 长按时间 0 表示不检测长按键事件 */</i>
    7 V6 b) i  l6 V2 s
22. <span style="font-style: italic;">                s_tBtn.Count = KEY_FILTER_TIME / 2;                /* 计数器设置为滤波时间的一半 */
    , K: q1 A1 Z" E  F4 s, s9 D
23.                 s_tBtn<span style="font-style: italic;">.State = 0;                                                /* 按键缺省状态，0为未按下 */
    
24.                 s_tBtn<span style="font-style: italic;">.RepeatSpeed = 0;                                        /* 按键连发的速度，0表示不支持连发 */
    
25.                 s_tBtn<i style="font-style: italic;">.RepeatCount = 0;                                        /* 连发计数器 */
    ! c  D5 s8 ~2 k& D. M$ C% k: p
26.      </i><span style="font-style: normal;">   }
    6 M* W  M% L( M' U# D
27. 
    
28.         /* 如果需要单独更改某个按键的参数，可以在此单独重新赋值 */
    
29.         
    6 G# U( ^5 h1 Q, K+ Q
30.         /* 摇杆上下左右，支持长按1秒后，自动连发 */
    # p5 J1 h; T# x
31.         bsp_SetKeyParam(KID_JOY_U, 100, 6);
    $ v! Y& S# W( I4 E$ r2 u1 f
32.         bsp_SetKeyParam(KID_JOY_D, 100, 6);
    2 l/ k, n' n8 a% Z
33.         bsp_SetKeyParam(KID_JOY_L, 100, 6);
    
34.         bsp_SetKeyParam(KID_JOY_R, 100, 6);
    
35. }</span></span></span></span>

复制代码

  o* k0 l2 G- t6 M  O/ u' [注意一下 Count 这个成员变量，没有设置为0。为了避免主板上电的瞬间，检测到一个无效的按键按下或弹起事件。我们将这个滤波计数器的初值设置为正常值的1/2。bsp_key.h中定义了滤波时间和长按时间。

4 q) q. l7 `3 P, d$ r) F- n

1. /*
   
2.         按键滤波时间50ms, 单位10ms。
   & N  u5 t8 ]2 i" @8 {. B
3.         只有连续检测到50ms状态不变才认为有效，包括弹起和按下两种事件
   ; @0 s, }" ?* e5 D% i4 h; h! Y- {
4.         即使按键电路不做硬件滤波，该滤波机制也可以保证可靠地检测到按键事件
   
5. */
   4 }/ K% Q5 i1 B8 Y: ~- v) H
6. #define KEY_FILTER_TIME   5
   % n' v: r' d+ n( M: d+ r' v
7. #define KEY_LONG_TIME     100                        /* 单位10ms， 持续1秒，认为长按事件 */

复制代码

: b3 V! B# R* a* [+ c- iuint8_t KeyPinActive(uint8_t _id)（会调用函数KeyPinActive判断状态）函数就是最底层的GPIO输入状态判断函数。

& h  I) S6 V# j7 g

1. /*
   
2. *********************************************************************************************************
   . K) ?9 N7 g) D9 N& q, g0 J+ d6 Z0 p
3. *        函 数 名: KeyPinActive
   2 R( [+ }8 ]3 B+ N
4. *        功能说明: 判断按键是否按下
   7 c* Y+ g) ~2 k- B6 l- b. c; b# B  K- ^
5. *        形    参: 无
   5 L% m; F* C1 ^4 X2 e& C
6. *        返 回 值: 返回值1 表示按下(导通），0表示未按下（释放）
   
7. *********************************************************************************************************
     y: @4 w) `: ^3 p
8. */
   % q* d/ u( ?8 D3 }3 h
9. static uint8_t KeyPinActive(uint8_t _id)
   / Q$ D8 K& X. D
10. {
    
11.         uint8_t level;
    
12.         
    + n. t' n+ F: d) f. W  }* a
13.         if ((s_gpio_list[_id].gpio->IDR & s_gpio_list[_id].pin) == 0)
    8 ?+ k' Z6 Y: @& \  |" f
14.         {
    / o' s, X* |  _# W' j7 D7 d1 i
15.                 level = 0;
    
16.         }
    , p- A, g" O" C
17.         else
    + y' F9 W3 {% h" i0 r
18.         {
    
19.                 level = 1;
    7 C3 U# ~% c) _" M& m, }( @) C( X
20.         }
    
21. 
    5 y8 s- K$ v) _! Z$ v# F7 K  ?
22.         if (level == s_gpio_list[_id].ActiveLevel)
    
23.         {
    
24.                 return 1;
    
25.         }
    
26.         else
    1 Z1 A* ^3 [% M. f  t
27.         {
    
28.                 return 0;
    
29.         }
    ' V6 R) j" Y* V/ ]/ N
30. }
    
31. 
    
32. /*
    8 t: |  @, E: D4 D, _
33. *********************************************************************************************************
    
34. *        函 数 名: IsKeyDownFunc
    
35. *        功能说明: 判断按键是否按下。单键和组合键区分。单键事件不允许有其他键按下。
    - v& g6 V8 d) r! K( ?) h  O
36. *        形    参: 无
    
37. *        返 回 值: 返回值1 表示按下(导通），0表示未按下（释放）
    " G' ]7 k# e" p; v1 C
38. *********************************************************************************************************
    7 \5 S% P5 e0 h" w; I
39. */
    3 E. d6 r: D5 f5 `- S0 b
40. static uint8_t IsKeyDownFunc(uint8_t _id)
    
41. {
    
42.         /* 实体单键 */
    
43.         if (_id < HARD_KEY_NUM)
    * O& g8 ~1 H8 w
44.         {
    # a, N( T7 o8 [0 \
45.                 uint8_t i;
    ) L! u" M# H% {& h( P/ c$ A
46.                 uint8_t count = 0;
    4 R  s; j, h& `: L
47.                 uint8_t save = 255;
    
48.                
    , d3 l4 O& M* c2 k( G4 E
49.                 /* 判断有几个键按下 */
    & j+ P% _; [& @5 C! s& }) V
50.                 for (i = 0; i < HARD_KEY_NUM; i++)
    ; W" I9 l$ e% O4 }) M5 r
51.                 {
    
52.                         if (KeyPinActive(i))
    
53.                         {
    # e7 W$ Q% y6 r# n
54.                                 count++;
    
55.                                 save = i;
    
56.                         }
    
57.                 }
    ) ^9 T  Z1 o2 ]9 e
58.                
    
59.                 if (count == 1 && save == _id)
      l6 V; L" w9 b# J, p2 D3 M7 |
60.                 {
    ! X* {9 T3 H+ ~/ V( @! v' a
61.                         return 1;        /* 只有1个键按下时才有效 */
    
62.                 }               
    
63. 
    
64.                 return 0;
    + a3 `) u: K: J
65.         }
    
66.         
    
67.         /* 组合键 K1K2 */
    
68.         if (_id == HARD_KEY_NUM + 0)
    
69.         {
    3 y# t) C5 y7 N+ m9 V' B
70.                 if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
    
71.                 {
    
72.                         return 1;
    3 R3 ]: U2 S7 H
73.                 }
    # v% D) D# F& m) [; [
74.                 else
    
75.                 {
    
76.                         return 0;
    
77.                 }
    / @* H1 k( u9 ?7 [
78.         }
    $ p5 i9 F3 s4 g
79. 
    . o2 R6 b3 [! J. D
80.         /* 组合键 K2K3 */
    $ k: L  d) l8 f; z) s# B
81.         if (_id == HARD_KEY_NUM + 1)
    ( {; c' L* R$ a
82.         {
    
83.                 if (KeyPinActive(KID_K2) && KeyPinActive(KID_K3))
    
84.                 {
    
85.                         return 1;
    
86.                 }
    7 I  `: ^, G  w/ W- h  Z0 y
87.                 else
    
88.                 {
    6 v9 x. v* b1 b# l' N
89.                         return 0;
    
90.                 }
    0 v' e- r  ?# Y
91.         }
    
92. 
    
93.         return 0;
    
94. }

复制代码

在使用GPIO之前，我们必须对GPIO进行配置，比如打开GPIO时钟，设置GPIO输入输出方向，设置上下拉电阻。下面是配置GPIO的代码，也就是bsp_InitKeyHard（）函数：

1. /*
   ( h: I/ A; b, z
2. *********************************************************************************************************
   7 b* j7 P! o) j# o
3. *        函 数 名: bsp_InitKeyHard
   ( w- f+ D  i7 j" P# a6 |
4. *        功能说明: 配置按键对应的GPIO
   
5. *        形    参:  无
   . c# N4 y7 g  ~) u! |& M
6. *        返 回 值: 无
   3 s2 W0 Z; {+ L& M$ ^- z
7. *********************************************************************************************************
   
8. */
   
9. static void bsp_InitKeyHard(void)
   
10. {        
    
11.         GPIO_InitTypeDef gpio_init;
    5 v7 _  |7 `1 t) {8 c( |
12.         uint8_t i;
    
13. 
    9 t9 C6 m3 K$ n3 f3 M1 O7 k
14.         /* 第1步：打开GPIO时钟 */
    
15.         ALL_KEY_GPIO_CLK_ENABLE();
    9 t7 W" ?' \5 w. p* q0 A
16.         
    
17.         /* 第2步：配置所有的按键GPIO为浮动输入模式(实际上CPU复位后就是输入状态) */
    
18.         gpio_init.Mode = GPIO_MODE_INPUT;                           /* 设置输入 */
    
19.         gpio_init.Pull = GPIO_NOPULL;                 /* 上下拉电阻不使能 */
    $ `( @' c! H) M5 l9 W! \
20.         gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;  /* GPIO速度等级 */
    # ?: a$ s4 {" m* a" z
21.         
      b/ U) E' ~8 E4 s
22.         for (i = 0; i < HARD_KEY_NUM; i++)
    
23.         {
    
24.                 gpio_init.Pin = s_gpio_list<span style="font-style: italic;"><span style="font-style: normal;">.pin;
    
25.                 HAL_GPIO_Init(s_gpio_list</span><span style="font-style: normal;">.gpio, &gpio_init);        
    8 N5 M5 E/ h' @% w6 m4 g2 l! U
26.         }
    
27. }</span></span>

复制代码

我们再来看看按键是如何执行扫描检测的。

5 O! |3 p0 J( s% F% `& ?* I按键扫描函数bsp_KeyScan10ms ()每隔10ms被执行一次。bsp_RunPer10ms函数在systick中断服务程序中执行。
1 g" y/ F0 o* }- r

1. void bsp_RunPer10ms(void)
   8 @2 L- G" H" j6 B" |: ^2 g) Z
2. {
   3 F- w& b1 g1 j( @+ L; O
3.         bsp_KeyScan10ms();                /* 扫描按键 */
   . Q  \- s5 m$ }0 Y% P- r  g/ e2 C: @
4. }

复制代码

& B1 a1 A  q0 absp_KeyScan10ms ()函数的实现如下：

. y6 [$ f( d7 K

1. /*
   
2. *********************************************************************************************************
   # l/ n' `3 O) |1 M1 B
3. *        函 数 名: bsp_KeyScan10ms
   8 {  J; m2 d+ h
4. *        功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
   * ?4 l/ z3 g; i# i1 u2 x
5. *        形    参: 无
   
6. *        返 回 值: 无
   / h% s5 m0 F; p8 \
7. *********************************************************************************************************
   ' e' @8 u; S% K  E3 U- D' b3 w6 |- |4 z
8. */
   + e. `) k" o3 S7 D8 k: e
9. void bsp_KeyScan10ms(void)
   
10. {
      }$ M1 y/ Y- j. P
11.         uint8_t i;
      f! T, I8 w0 m+ X$ ?* a- @
12. 
    % |$ u- V) T5 j9 v2 p# i
13.         for (i = 0; i < KEY_COUNT; i++)
    - i" n& w# u$ @% V% m8 R( x
14.         {
    " j, _; r: \$ x7 R" T* }
15.                 bsp_DetectKey(i);
    3 M# H) ]0 N/ ?  o
16.         }
    
17. }

复制代码

4 f/ \; W# r! F- E每隔10ms所有的按键GPIO均会被扫描检测一次。bsp_DetectKey函数实现如下：
" `/ R$ ]# P* q- D5 Q) r
7 L6 c4 |* y1 b- D: f: E

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_DetectKey
   
4. *        功能说明: 检测一个按键。非阻塞状态，必须被周期性的调用。
   $ ]6 ?! F$ q( N: \9 P
5. *        形    参: IO的id， 从0开始编码
   
6. *        返 回 值: 无
   1 U5 ]4 j" V* j. P
7. *********************************************************************************************************
   5 q& k6 c- A8 B- i
8. */
   
9. static void bsp_DetectKey(uint8_t i)
   ) O; |0 r3 C) A2 a* K
10. {
    % y! D/ Z4 |7 l0 m; }+ U0 X- ~) f
11.         KEY_T *pBtn;
    - G, B/ N; D: q6 y) F
12. 
    
13.         pBtn = &s_tBtn<span style="font-style: italic;"><span style="font-style: normal;">;
    
14.         if (IsKeyDownFunc(i))
    
15.         {
    
16.                 if (pBtn->Count < KEY_FILTER_TIME)
    6 W! g, n6 P# V0 c% |0 s
17.                 {
    1 D% E; v' x" Q8 \- G; {
18.                         pBtn->Count = KEY_FILTER_TIME;
    2 j* M  }6 a' G, `  N5 n# F
19.                 }
    : x' P9 h5 ~! K( ~6 d( U
20.                 else if(pBtn->Count < 2 * KEY_FILTER_TIME)
    ( c) x# B1 O4 C' D5 C# ?/ ~) g
21.                 {
    , j8 @, X) c$ m6 F% R
22.                         pBtn->Count++;
    : O9 g, A$ \1 ], t/ _7 g; ]7 y+ f
23.                 }
    . r* {4 w, C9 G9 v  ]( L
24.                 else
    
25.                 {
    
26.                         if (pBtn->State == 0)
    
27.                         {
    $ m) S3 Y$ K5 l
28.                                 pBtn->State = 1;
    8 v. q# u' t. b0 h
29. 
    : D' Y2 r: p; F+ H1 X0 F2 v
30.                                 /* 发送按钮按下的消息 */
    
31.                                 bsp_PutKey((uint8_t)(3 * i + 1));
    & v. a  f% j& Q1 @
32.                         }
    3 @4 G0 p# H7 [" y
33. 
    4 d2 _& n2 b/ a9 E4 D: x% x
34.                         if (pBtn->LongTime > 0)
    * J' A6 Q0 V+ r& Q& G
35.                         {
    : U  W! l5 V; }% s  L" f1 S- p
36.                                 if (pBtn->LongCount < pBtn->LongTime)
    
37.                                 {
    
38.                                         /* 发送按钮持续按下的消息 */
    
39.                                         if (++pBtn->LongCount == pBtn->LongTime)
    
40.                                         {
    % \) D. ~6 p0 T9 n
41.                                                 /* 键值放入按键FIFO */
    
42.                                                 bsp_PutKey((uint8_t)(3 * i + 3));
    0 E: W& V+ e5 B& k2 e. _9 q$ R: h& C
43.                                         }
    . F$ ^" u0 c' F+ r" M# @& X
44.                                 }
    ! G) R( x# g4 Y' X9 Q* ~6 K
45.                                 else
    1 q* J4 a" c% V& ~" U* w
46.                                 {
    ! v0 p8 |& K% L4 W- z
47.                                         if (pBtn->RepeatSpeed > 0)
    7 A8 G5 y: y- v& o# U; ~3 N
48.                                         {
    1 @$ ?( W& [; Z% w8 r* P
49.                                                 if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
    $ \3 [1 @; O' E3 v4 e0 U7 b
50.                                                 {
    $ |+ L( N+ \) e
51.                                                         pBtn->RepeatCount = 0;
    
52.                                                         /* 常按键后，每隔RepeatSpeed * 10ms发送1个按键 */
      N% i3 M( l' ~) D
53.                                                         bsp_PutKey((uint8_t)(3 * i + 1));
    / E6 ?" k+ a$ t; E6 n# }. t  ]' s
54.                                                 }
    
55.                                         }
    0 Q  w5 m% L' B# Z$ p8 {7 d
56.                                 }
    
57.                         }
    
58.                 }
    
59.         }
    
60.         else
    
61.         {
    
62.                 if(pBtn->Count > KEY_FILTER_TIME)
    
63.                 {
    6 e* w2 @/ Q, L2 @; _/ V! \
64.                         pBtn->Count = KEY_FILTER_TIME;
    
65.                 }
    5 Z& m, W  t2 g0 X# Q: o# v/ e
66.                 else if(pBtn->Count != 0)
    
67.                 {
    0 [6 L' O* Y: g4 P- t& H7 Y5 F8 i
68.                         pBtn->Count--;
    
69.                 }
    
70.                 else
    
71.                 {
    0 C9 s# j5 V# K7 N9 c! b! d4 O
72.                         if (pBtn->State == 1)
    # V0 ~. c. _. w; N
73.                         {
    , E, B9 ~5 T  o
74.                                 pBtn->State = 0;
    0 l6 S8 z! |3 S( W5 o. ?& U* i  F; t
75. 
    - S  A& h3 c1 U% k: u8 k9 \
76.                                 /* 发送按钮弹起的消息 */
    
77.                                 bsp_PutKey((uint8_t)(3 * i + 2));
    5 R; D8 q3 k9 z9 s7 m0 B
78.                         }
    
79.                 }
    
80. 
    3 u: d9 }$ m$ B  R0 n
81.                 pBtn->LongCount = 0;
    
82.                 pBtn->RepeatCount = 0;
    
83.         }
    ' s2 S5 M/ K) @1 U
84. }</span></span>

复制代码

对于初学者，这个函数看起来比较吃力，我们拆分进行分析。
1 K3 N4 C/ J* e( B5 ?
& J- P' f$ N/ z! t7 s: U

1. pBtn = &s_tBtn<span style="font-style: italic;"><span style="font-style: normal;">;</span></span>

复制代码

' o, j. L' u  g2 r! S5 u读取相应按键的结构体地址，程序里面每个按键都有自己的结构体。

& w& Z7 j6 t" B7 j9 [! [  O* Q6 c

1. static KEY_T s_tBtn[KEY_COUNT];
   ) Z2 N* ~) _: s% e
2. if (IsKeyDownFunc(i))
   
3. {
   & V9 _/ e  d4 y5 \
4.         这个里面执行的是按键按下的处理
   7 a" R$ A: Q" f* z
5. }
   
6. else
   " H' H, v8 \& |7 p9 L
7. {
   + _# h& y3 r% L2 b
8.         这个里面执行的是按键松手的处理或者按键没有按下的处理
   
9. }

复制代码

执行函数IsKeyDownFunc(i)做按键状态判断。

( a+ i6 {, u8 ~6 x6 U

1. /*
   6 C0 P8 ]4 u9 Y& M
2. **********************************************************************************
   - }8 z2 [6 `2 T
3. 下面这个if语句主要是用于按键滤波前给Count设置一个初值，前面说按键初始化的时候
   
4. 已经设置了Count = KEY_FILTER_TIME/2
   / |. t2 f  K3 J! E9 Z4 H
5. **********************************************************************************
   ; }9 I* _$ B) t* P* o' s! o
6. */
   
7. if (pBtn->Count < KEY_FILTER_TIME)
   
8. {
   
9.     pBtn->Count = KEY_FILTER_TIME;
   
10. }
    / i* u, M  W% m' M. l# h2 L, b/ U9 b
11. 
    . ~  z' m; _) m
12. /*
    5 h; A: I0 a% O
13. **********************************************************************************
    6 l+ @- G( e# g8 X# u( G' k
14. 这里实现KEY_FILTER_TIME时间长度的延迟
    / q2 s2 E  U* Z  @4 Y
15. **********************************************************************************
    2 W, a5 @$ k7 e
16. */
    , `9 z+ r7 d, |
17. else if(pBtn->Count < 2 * KEY_FILTER_TIME)
    
18. {
    
19.     pBtn->Count++;
    
20. }
    & c6 a( ^( b+ \; l
21. /*
    
22. **********************************************************************************
    4 M9 y' i/ A/ c8 J: `8 [; i% I
23. 这里实现KEY_FILTER_TIME时间长度的延迟
    $ x) F4 {. L- O4 Z, ^# m
24. **********************************************************************************
    
25. */
    # U) n1 o8 C  E, h) `) H
26. else
    
27. {
    
28. /*
    
29. **********************************************************************************
    
30. 这个State变量是有其实际意义的，如果按键按下了，这里就将其设置为1，如果没有按下这个
    
31. 变量的值就会一直是0，这样设置的目的可以有效的防止一种情况的出现：比如按键K1在某个
    
32. 时刻检测到了按键有按下，那么它就会做进一步的滤波处理，但是在滤波的过程中，这个按键
    + _% A; O( t/ y" e. E3 ?
33. 按下的状态消失了，这个时候就会进入到上面第二步else语句里面，然后再做按键松手检测滤波
    
34. ，滤波结束后判断这个State变量，如果前面就没有检测到按下，这里就不会记录按键弹起。
    
35. **********************************************************************************
    7 A" J- {; {; G3 _+ c
36. */
      j7 W7 t1 W5 Z( F
37.     if (pBtn->State == 0)
    
38.     {
    
39.         pBtn->State = 1;
    
40. 
    + t% X4 l) d" s8 H+ z  U6 x
41.         /* 发送按钮按下的消息 */
    % C7 J* t! s1 s5 j' E
42.         bsp_PutKey((uint8_t)(3 * i + 1));
    ' _1 g) D, e; O: k# J
43.     }
    $ j5 y4 A; f' f2 Y* C# z: g) ~
44. 
    
45.     if (pBtn->LongTime > 0)
    
46.     {
    
47.         if (pBtn->LongCount < pBtn->LongTime)
    
48.         {
    
49.             /* 发送按钮持续按下的消息 */
    
50.             if (++pBtn->LongCount == pBtn->LongTime)
    , W7 c5 D; I! _: s: ~0 q
51.             {
    
52.                 /* 键值放入按键FIFO */
    - N3 S1 }  \$ v
53.                 bsp_PutKey((uint8_t)(3 * i + 3));
    
54.             }
    , b3 |) ?; v( r- W# M+ ^0 k3 i4 |
55.         }
    
56.         else
    : v; x6 G; m6 @9 j3 B
57.         {
    1 I2 [* `& ]' K, T
58.             if (pBtn->RepeatSpeed > 0)
    
59.             {
    
60.                 if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
    
61.                 {
    
62.                     pBtn->RepeatCount = 0;
    7 G$ N% y7 ~! O8 R1 w
63.                     /* 长按键后，每隔10ms发送1个按键 */
    
64.                     bsp_PutKey((uint8_t)(3 * i + 1));
    4 [3 ]4 h( w  z4 f( _/ X
65.                 }
    8 [' M5 u) X6 t) T
66.             }
    
67.         }
    
68.     }
    4 L( n: }% |- `$ L* d$ U# G0 y, e
69. }

复制代码

19.3.4 按键检测采用中断方式还是查询方式
检测按键有中断方式和GPIO查询方式两种。我们推荐大家用GPIO查询方式。

6 s1 H! J* M0 I  |从裸机的角度分析
/ K2 m5 a! o/ }% P. x! [" V
中断方式：中断方式可以快速地检测到按键按下，并执行相应的按键程序，但实际情况是由于按键的机械抖动特性，在程序进入中断后必须进行滤波处理才能判定是否有效的按键事件。如果每个按键都是独立的接一个IO引脚，需要我们给每个IO都设置一个中断，程序中过多的中断会影响系统的稳定性。中断方式跨平台移植困难。
% z3 r0 Z9 }0 t
5 y- e7 g$ F7 b8 d5 _0 M查询方式：查询方式有一个最大的缺点就是需要程序定期的去执行查询，耗费一定的系统资源。实际上耗费不了多大的系统资源，因为这种查询方式也只是查询按键是否按下，按键事件的执行还是在主程序里面实现。
, v2 n6 p3 ?( \) G( c" G  G# A4 k
0 o" A: v5 `5 w; q* ]" T& v从OS的角度分析

中断方式：在OS中要尽可能少用中断方式，因为在RTOS中过多的使用中断会影响系统的稳定性和可预见性（抢占式调度的OS基本没有可预见性）。只有比较重要的事件处理需要用中断的方式。

. B; D2 T( K8 S3 d; u查询方式：对于用户按键推荐使用这种查询方式来实现，现在的OS基本都带有CPU利用率的功能，这个按键FIFO占用的还是很小的，基本都在1%以下。
$ }3 E0 L1 b: E* Z* b
19.4 按键板级支持包（bsp_key.c）
' [; w$ C& k5 `' M$ t按键驱动文件bsp_key.c主要实现了如下几个API：
* z& T6 _& B; H1 l
, a# e( m7 a% N8 G+ q% o, N1 W  KeyPinActive
  IsKeyDownFunc
* }4 Z' z6 f+ T" H  bsp_InitKey
  bsp_InitKeyHard
  bsp_InitKeyVar
. y, n5 ?4 N! s0 `* [( p/ G  bsp_PutKey
+ g; m1 B# \9 \2 l; L  S. z  bsp_GetKey
; ?4 f; {8 F- e$ z( S# v5 A  bsp_GetKey2
  bsp_GetKeyState
  bsp_SetKeyParam
7 W# ?8 y  ^" Q" H: N: v  bsp_ClearKey
/ D% ~/ J: I+ B# I+ f  bsp_DetectKey
1 t5 N; G0 k" M  Z1 {0 ?$ }! x2 R  bsp_DetectFastIO
  bsp_KeyScan10ms
  bsp_KeyScan1ms
& q4 v* w4 @: Y
( E! `- j/ a# q: k所有这些函数在本章的19.3小节都进行了详细讲解，本小节主要是把需要用户调用的三个函数做个说明。

19.4.1 函数bsp_InitKeyHard
# I; s" Q* _7 ]0 I+ L! S函数原型：
4 _# R& U$ L" l( x' n
& v0 r2 R& c: l2 i6 q2 V$ m' h

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_InitKey
   . `6 m+ y& g% R7 S
4. *        功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
   ! `1 o' P$ `# Q  y% \( _
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   ! T0 r: p/ d, U+ K' r. |/ m% V9 L
9. void bsp_InitKey(void)
   
10. {
    
11.         bsp_InitKeyVar();                /* 初始化按键变量 */
    
12.         bsp_InitKeyHard();                /* 初始化按键硬件 */
    $ g$ o4 x: T* p7 {
13. }

复制代码

# u4 {8 C, W9 @7 K$ }* m- o函数描述：

2 Q/ H+ h8 ^& b* k! }此函数主要用于按键的初始化。

使用举例：

0 ~* O8 J/ |8 |  ^底层驱动初始化直接在bsp.c文件的函数bsp_Init里面调用即可。

* |8 s/ Y; R: b4 \( ~  c19.4.2 函数bsp_GetKey
函数原型：

1. /*
   
2. *********************************************************************************************************
   0 s; D5 H8 k% R5 d( v! l
3. *        函 数 名: bsp_GetKey
   
4. *        功能说明: 从按键FIFO缓冲区读取一个键值。
   ; v4 W% i9 e5 X# f8 l7 @) c( V- O; z
5. *        形    参: 无
   ; H$ d! v! p8 Z6 B0 w
6. *        返 回 值: 按键代码
   
7. *********************************************************************************************************
   % e2 }5 s* _/ q/ H7 V5 q
8. */
   * D6 g7 e8 q( H$ p7 }
9. uint8_t bsp_GetKey(void)
   
10. {
    4 S: _: t7 ~0 d, y3 o2 V
11.         uint8_t ret;
    
12. 
    
13.         if (s_tKey.Read == s_tKey.Write)
    
14.         {
    , w& r* R0 H* V! t4 T
15.                 return KEY_NONE;
    
16.         }
    
17.         else
    3 H2 Q6 \4 d& ^6 N( E2 X
18.         {
    
19.                 ret = s_tKey.Buf[s_tKey.Read];
    
20. 
    
21.                 if (++s_tKey.Read >= KEY_FIFO_SIZE)
    5 H) \3 R4 h/ l7 \
22.                 {
    6 l. o( N; p* }+ }% o
23.                         s_tKey.Read = 0;
    
24.                 }
    3 C$ Q) s0 U& D( \! m( m
25.                 return ret;
    / O6 A: C/ W) J9 c" {# Z
26.         }
    6 M( w! ~( A! k9 \, Y! n5 d
27. }

复制代码

) T  M5 D  ]- R' G# s( ]  t函数描述：

' u" M1 G- k: k- `9 Y& T0 d此函数用于从FIFO中读取键值。

& a* u% o9 _4 P# q0 K) y5 ]% E使用举例：
2 ?( ], k( l) m% R8 ?& L& \( F
调用此函数前，务必优先调用函数bsp_InitKey进行初始化。

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: main
   # C; T* g" t3 @
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   0 R) Y5 U/ H7 r1 u
7. *********************************************************************************************************
   
8. */
   7 O' F0 w7 O% Y: C. P: Y
9. int main(void)
   + o9 q# ?1 r" y1 H) K* L
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    
12.         
    0 f$ J- o/ z  F& Q/ [& U$ R- r
13.         bsp_Init();                /* 硬件初始化 */
    
14.         
    
15.         /* 进入主程序循环体 */
    
16.         while (1)
    
17.         {               
    
18.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    ' L4 N2 c2 J' c4 \
19.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    2 w1 p5 ?! q& O4 K8 ?; |8 n) o
20.                 if (ucKeyCode != KEY_NONE)
    
21.                 {
    
22.                         switch (ucKeyCode)
    0 K7 p6 M  `9 X6 v3 f1 B& k. ?( q
23.                         {
    
24.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    % e9 z; w& c  V1 P
25.                                         printf("K1键按下\r\n");
    
26.                                         break;
    0 z# P6 a1 V4 D: d/ T! a* y
27. 
    & \; V$ P2 U1 R# Z4 f  p
28.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    
29.                                         printf("K2键按下\r\n");
    " B& M" i% _, V& k! c) R
30.                                         break;
    " y- }- a2 R, Q/ @
31. 
    
32.                                 default:
    9 m7 t, O9 x3 z+ _8 v# A) p" i
33.                                         /* 其它的键值不处理 */
    2 D; m% D/ |% o# s' M
34.                                         break;
    
35.                         }
    . w0 w& S- P+ p2 f
36.                 }
    8 a% u% k& K! _+ D
37.         }
    
38. }

复制代码

19.4.3 函数bsp_KeyScan10ms
函数原型：
) \, H4 H) t0 ?' f

1. /*
   
2. *********************************************************************************************************
   & D$ R1 b  @3 B9 H: p& j% `
3. *        函 数 名: bsp_KeyScan10ms
   
4. *        功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
   
5. *        形    参: 无
   , O# D2 a# e3 @% p0 L) H
6. *        返 回 值: 无
   % W# n3 k, w. P" ]! h  Y2 Y: n7 }
7. *********************************************************************************************************
   
8. */
   
9. void bsp_KeyScan10ms(void)
   
10. {
    
11.         uint8_t i;
    
12. 
    $ S/ ^/ X- d: {
13.         for (i = 0; i < KEY_COUNT; i++)
    
14.         {
    
15.                 bsp_DetectKey(i);
    : Y; Z# Q6 b; a$ r( m! A
16.         }
    
17. }

复制代码

/ D% q9 v0 w8 C$ e; h) J3 ]/ g函数描述：

此函数是按键的主处理函数，用于检测和存储按下、松手、长按等状态。

使用举例：
8 S' `& `9 j2 R! D0 B! X
调用此函数前，务必优先调用函数bsp_InitKey进行初始化。

另外，此函数需要周期性调用，每10ms调用一次。

  如果是裸机使用，将此函数放在bsp.c文件的bsp_RunPer10ms函数里面即可，这个函数是由滴答定时器调用的，也就是说，大家要使用按键，定时器的初始化函数bsp_InitTimer一定要调用。
  如果是RTOS使用，需要开启一个10ms为周期的任务调用函数bsp_KeyScan10ms。

19.5 按键FIFO驱动移植和使用
按键移植步骤如下：
- b& T6 I& V" e7 V9 {
, _4 S" k7 R6 g- {' ?8 c  F  第1步：复制bsp_key.c和bsp_key.c到自己的工程。
  第2步：根据自己使用的独立按键个数和组合键个数，修改几个地方。

1. #define HARD_KEY_NUM        8                     /* 实体按键个数 */
   
2. #define KEY_COUNT   (HARD_KEY_NUM + 2)   /* 8个独立建 + 2个组合按键 */

复制代码

( P, [& A% o7 |9 n( s/ L  第3步：根据使用的引脚时钟，修改下面函数：

1. /* 使能GPIO时钟 */
   
2. #define ALL_KEY_GPIO_CLK_ENABLE() {        \
   
3.                 __HAL_RCC_GPIOB_CLK_ENABLE();        \
   3 V  `7 T4 Q: T2 y
4.                 __HAL_RCC_GPIOC_CLK_ENABLE();        \
   
5.                 __HAL_RCC_GPIOG_CLK_ENABLE();        \
   
6.                 __HAL_RCC_GPIOH_CLK_ENABLE();        \
   
7.                 __HAL_RCC_GPIOI_CLK_ENABLE();        \
   ( c$ L3 N- A- Z4 _/ q8 e/ g
8.         };

复制代码

  第4步：根据使用的具体引脚，修改如下函数，第3列参数低电平表示按下或者高电平表示按下：
8 }" M6 K# M' S7 H% U3 C( B& S1 v0 V! s

1. /* GPIO和PIN定义 */
   ' v4 i! H/ M( g3 K, V
2. static const X_GPIO_T s_gpio_list[HARD_KEY_NUM] = {
   
3.         {GPIOI, GPIO_PIN_8, 0},                /* K1 */
   $ `8 Z8 H  Y7 p/ a  v1 O
4.         {GPIOC, GPIO_PIN_13, 0},        /* K2 */
   
5.         {GPIOH, GPIO_PIN_4, 0},                /* K3 */
   
6.         {GPIOG, GPIO_PIN_2, 0},                /* JOY_U */        
   
7.         {GPIOB, GPIO_PIN_0, 0},                /* JOY_D */
   
8.         {GPIOG, GPIO_PIN_3, 0},                /* JOY_L */        
   
9.         {GPIOG, GPIO_PIN_7, 0},                /* JOY_R */        
   
10.         {GPIOI, GPIO_PIN_11, 0},        /* JOY_OK */
    
11. };   

复制代码

     
% J. b& x" c5 C0 `, z- {  第5步：根据使用的组合键个数，在函数IsKeyDownFunc里面添加相应个数的函数：

1.         /* 组合键 K1K2 */
   
2.         if (_id == HARD_KEY_NUM + 0)
     f! W! V3 `3 J
3.         {
   
4.                 if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
   
5.                 {
   
6.                         return 1;
   
7.                 }
   
8.                 else
   $ n; ~$ Q( m8 G; h  p8 p- Q
9.                 {
   ( [* z* p; z" a2 V# p4 x, v$ E8 j8 o
10.                         return 0;
    & _; \# c7 F# T' M. l# k' N% L' B
11.                 }
    , q) i2 @8 Q* o; Q
12.         }

复制代码

% @# T3 D$ K* P) [$ S; {# {第2行ID表示HARD_KEY_NUM + 0的组合键，HARD_KEY_NUM + 1表示下一个组合键，以此类推。
7 q1 o/ L* U  i0 P; r! `
另外就是，函数KeyPinActive的参数是表示检测哪两个按键，设置0的时候表示第4步里面的第1组按键，设置为1表示第2组按键，以此类推。
) R5 [3 P1 Z. G. f1 d/ Q# H, F9 p
  第6步：主要用到HAL库的GPIO驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
# X  K2 r% \' f  _! V) Z  第7步：移植完整，应用方法看本章节配套例子即可。
; k" ]+ O' l! e, b特别注意，别忘了每10ms调用一次按键检测函数bsp_KeyScan10ms。

" K" S5 i' |6 H$ k. Y  m19.6 实验例程设计框架
: Q: r4 A# i' ]; G通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：

7 Y. B  e& d0 f, {! g

5 i, s$ S" I8 x, I
1、 第1阶段，上电启动阶段：
5 |) |9 C5 b5 z. s0 ~. J
# ?/ r# A& w# U; S这部分在第14章进行了详细说明。

2、 第2阶段，进入main函数：

  第1部分，硬件初始化，主要是MPU、Cache、HAL库、系统时钟、滴答定时器、按键等。
  第2部分，应用程序设计部分，实现了一个按键应用。
7 d4 s. U" w6 o+ w# i1 b  第3部分，按键扫描程序每10ms在滴答定时中断执行一次。

19.7 实验例程说明（MDK）
配套例子：
V7-002_按键检测（软件滤波，FIFO机制）

$ W$ M* A* c* M( W/ B0 l1 b6 A实验目的：
/ E' w) Y) B9 S/ Z/ j6 s学习按键的按下，弹起，长按和组合键的实现。
% ]! Z9 ~$ \& h3 I3 a
实验内容：
$ [& d, F1 ~" G$ }$ W  x启动一个自动重装软件定时器，每100ms翻转一次LED2。

* z- d7 {. `* s6 T- M" z5 V- _实验操作：
; X7 S/ a5 {# x, z$ ?, o4 i3个独立按键和5向摇杆按下时均有串口消息打印。
5向摇杆的左键和右键长按时，会有连发的串口消息。
& G! Y7 H+ a3 y/ R2 D% t7 O独立按键K1和K2按键按下，串口打印消息。

上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1
$ Q3 l% P# T3 ~7 r6 d9 r+ g$ B
7 D, s0 J2 e, {9 `; j- v* D

. a. w( e/ n* p1 ~/ Q9 S, j6 x5 b程序设计：
! l, a3 d6 d; j1 l" ^& x# h$ |
  系统栈大小分配：

! T, I: x4 B$ v* h* }  X  ^9 z8 ]

6 s1 C3 S- i$ L6 m, t0 d3 r+ H9 b! c  RAM空间用的DTCM：
; ]$ ~% Y$ W* L, I0 A7 Y
- S9 m' ~2 Y1 ~2 {+ {; G% Q

0 T! e5 @* J! D. C- Y2 Z  C  N
. R, g- N2 s; e% g# Y$ X9 f* ~  硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：
. o8 A: z8 z; l1 Z. ^5 [* W2 g
$ e' I% }' |' X/ r+ ]' V8 g0 s

1. /*
   ) C/ x1 s9 ~$ ]/ L8 Y3 d, w
2. *********************************************************************************************************
   2 _! G6 P0 k& y1 Z$ R
3. *        函 数 名: bsp_Init
   / r& p- }) c' R* t+ @
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   
6. *        返 回 值: 无
   % G+ G$ w+ u- |& J, C6 w
7. *********************************************************************************************************
   * P7 s' F$ d( l" Q+ E2 t+ b. t
8. */
   ( b( N/ S5 q6 \0 Q
9. void bsp_Init(void)
   " y! ?( p9 T5 i; P4 n4 K2 `$ t
10. {
    
11.     /* 配置MPU */
    ! d) d; ~( u% S: a
12.         MPU_Config();
    6 U- I0 B; L3 W8 x
13.         
    / f) K* U3 m8 B- O  ^
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    8 _$ D/ O' O, @- S
16. 
    
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    $ B2 Y- H2 d4 [5 N- E- m
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    8 @8 Q- I+ k/ E8 p: {
20.            - 设置NVIV优先级分组为4。
    6 C: }8 \, L$ N/ c3 \) ]
21.          */
    
22.         HAL_Init();
    ) S: ~0 m+ C5 V, _) t; o1 v
23. 
    
24.         /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    * g( K" W' x  R, H( y
28.     */
    
29.         SystemClock_Config();
    6 K0 B  u- \# M! P% d+ V% K- y
30. 
    
31.         /*
    
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    9 I4 ]% ?, w! O+ _9 \
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    , ^" U% S6 C) q4 S  R
35.         */        
    
36. #if Enable_EventRecorder == 1  
    3 c6 Q! H9 E# ?1 f# B8 d) S
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    $ \9 ]4 |5 J, J
39.         EventRecorderStart();
    
40. #endif
    / f6 y8 j  L# W* l8 u% ~
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    % g& s. Y3 J# y' A9 A
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    2 R5 X( v% b/ `( e4 G( h
46.         bsp_InitLed();            /* 初始化LED */        
    7 X# h4 }! `4 n0 C
47. }

复制代码

  MPU配置和Cache配置：
8 L* s1 R- l+ G# r
数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
( V- {- H& y, m7 [
) T; f2 {+ h. O0 ~

1. /*
   
2. *********************************************************************************************************
   & @+ s% C, [& A" W! s
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
     s- A4 g  c0 x; G; ^
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   ( e% A3 Y( l& a" N' T; a( D
8. */
   7 E' m+ I' Z$ S
9. static void MPU_Config( void )
   0 |9 O) j) q& P2 D5 m$ z, j; D  k' e( R+ x! i
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    % r- w- c6 R, x$ {2 v
13.         /* 禁止 MPU */
    ) n; C7 W% q% @! u% j
14.         HAL_MPU_Disable();
    
15. 
    % m0 A: u% J& d9 `! p
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    ' ~0 `- M  Q# g/ F% o
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    5 r% W5 O( c4 s1 q
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    & s- o) F9 j1 ~2 ?0 f
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    ; q2 I+ K; b" C- s& m: b
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    / j# M  n; F1 o/ Z3 p" y
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    ; Q4 \" E& ^, C  i
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    ; @( h9 a' Z! ?1 J  p
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    " c8 {, \& x- Q0 H4 \
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    3 ]8 \, ?' t  {" M% j2 ?4 r
31.         
    , B7 B0 w# y# ~0 t0 e
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    ) X( d; f  i- Z& G( r
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    : n8 S' j! N* v8 w3 }$ I! U
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    0 O5 J% v' L5 z+ A3 W
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    ( U; m. X* M5 s4 S/ a
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    , T. T! T9 t0 n* A+ t/ V- z3 b  T
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    / _$ x" d8 e; f  t! I5 o
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    1 @  E. ?3 F9 E3 g2 b
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
      o, k  O" N% n3 J# N9 A- b1 }- y9 t
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    / w% v% u. X' S+ @8 o
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    8 ~! r9 U# Y" _7 z/ Z
44.         
    4 G8 _8 x: y6 C4 ^% O  g$ d. I
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    
47.         /*使能 MPU */
    
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    & j! z5 F, q' M4 T, q8 {* Y
49. }
    ( P+ V( }- V# Z! F
50. 
    , a6 l% r2 t7 r8 {* |. c1 P& Z
51. /*
    
52. *********************************************************************************************************
    
53. *        函 数 名: CPU_CACHE_Enable
    
54. *        功能说明: 使能L1 Cache
    1 ^$ j% i0 T3 D9 S
55. *        形    参: 无
    
56. *        返 回 值: 无
    
57. *********************************************************************************************************
    1 e$ p! g& S& h+ `
58. */
    , W! O! s$ B9 t1 o% R
59. static void CPU_CACHE_Enable(void)
    
60. {
    $ W2 i- r* l$ ~0 i# x# e3 C
61.         /* 使能 I-Cache */
    % e) a; |- x8 X8 }# m
62.         SCB_EnableICache();
    
63. 
    " ?) u9 W9 D; K3 L/ I6 N( F
64.         /* 使能 D-Cache */
    
65.         SCB_EnableDCache();
    
66. }

复制代码

  每10ms调用一次按键检测：

按键检测是在滴答定时器中断里面实现，每10ms执行一次检测。
$ v: k3 e" d& @0 V% Q7 g' V( r

1. /*
   : L; T  c% H/ Q/ b2 a
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_RunPer10ms
   1 u- h" q) ~0 }
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *        形    参: 无
   ' V( }3 W2 i9 J! `# q& v- i. {
7. *        返 回 值: 无
   
8. *********************************************************************************************************
   
9. */
   
10. void bsp_RunPer10ms(void)
    
11. {
    ) W, i1 ?5 [; k$ _& h3 H5 A0 n
12.         bsp_KeyScan10ms();
    ( w; y# `; m, ~$ ]( ~( S1 w. [" E
13. }

复制代码

3 e( {" T& x# C' X9 }# G  主功能：
3 {; r, i' E" R4 v3 U" d
& F; h( q' D! G, ]8 |主功能的实现主要分为两部分：

启动一个自动重装软件定时器，每100ms翻转一次LED2
" l# f! @0 e: b 按键消息的读取，检测到按下后，做串口打印。

1. /*
   
2. *********************************************************************************************************
   : ~% G; r: d: B( _2 b1 \% G6 P4 \$ }
3. *        函 数 名: main
   ; }; F( h5 v' j+ V  |2 ?
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   6 l) M6 b  ?. _3 H2 \- ^
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   ! Q2 s' V' J  m; R' q0 p2 A
9. int main(void)
   : }8 K/ v, w" G
10. {
    5 E' _5 a) }3 s0 m7 p* q
11.         uint8_t ucKeyCode;                /* 按键代码 */
    ! y* U8 Q: D/ s7 G9 h7 c! X
12.         
    ! Q8 `9 y( n- u) H" }6 N# L
13.         bsp_Init();                /* 硬件初始化 */
      \2 g( d3 n3 `0 [
14.         
    
15.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    5 b$ I, F6 y' K5 _$ B& E+ ]
16.         PrintfHelp();        /* 打印操作提示 */
    4 o4 S: u9 q9 P% c) u5 k
17. 
    
18. 
    
19.         bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 */
    
20.         
    7 |9 _* W7 W# c* b' o
21.         /* 进入主程序循环体 */
    
22.         while (1)
    
23.         {
    
24.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
25. 
    % [8 ?. V) B- d2 w5 F  f2 E8 f
26.                 /* 判断定时器超时时间 */
    
27.                 if (bsp_CheckTimer(0))        
    3 n  X  v1 k$ j5 H5 u2 N
28.                 {
    
29.                         /* 每隔100ms 进来一次 */  
    - a) q4 c. `# U/ F& O5 }
30.                         bsp_LedToggle(2);                        
    
31.                 }
    ) L% R. _1 |0 f& Y  O. [
32.                
    
33.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    / k9 c! G, ^8 F. }, A; L# Q
34.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    * h9 Y8 [6 e% Z
35.                 if (ucKeyCode != KEY_NONE)
    
36.                 {
    , ~& b8 I, C" D% O( l" |) h# j
37.                         switch (ucKeyCode)
    
38.                         {
    ' _2 I9 t) M, W: J% f, ~2 u
39.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    0 O# Z/ N2 v' U
40.                                         printf("K1键按下\r\n");
    
41.                                         break;
    2 ]6 M3 n' |& b, M+ [2 e
42. 
      e' T& k; G/ N$ Q
43.                                 case KEY_UP_K1:                                /* K1键弹起 */
    # i/ p: i( Z5 E* v9 V, h
44.                                         printf("K1键弹起\r\n");
    
45.                                         break;
    
46. 
    6 S" N0 }, x# ?# x& c
47.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    
48.                                         printf("K2键按下\r\n");
    
49.                                         break;
    9 M6 f- U- z' r- A
50. 
    
51.                                 case KEY_UP_K2:                                /* K2键弹起 */
    
52.                                         printf("K2键弹起\r\n");
    
53.                                         break;
    
54. 
    
55.                                 case KEY_DOWN_K3:                        /* K3键按下 */
    
56.                                         printf("K3键按下\r\n");
    
57.                                         break;
    8 L( }0 ]" H7 r) [. L! _
58. 
    7 z* _* \2 P4 d
59.                                 case KEY_UP_K3:                                /* K3键弹起 */
    ( h" z$ v& s* ]+ l5 W
60.                                         printf("K3键弹起\r\n");
    
61.                                         break;
    ! e* @0 i) T$ E
62. 
    
63.                                 case JOY_DOWN_U:                        /* 摇杆UP键按下 */
    6 X4 l  y# B) m& ]; U$ t
64.                                         printf("摇杆上键按下\r\n");
    4 X8 v7 b1 x# F. k2 L( g
65.                                         break;
    : Y* ?2 G! l- c
66. 
    
67.                                 case JOY_DOWN_D:                        /* 摇杆DOWN键按下 */
    
68.                                         printf("摇杆下键按下\r\n");
    - ^+ E2 a1 ?- }
69.                                         break;
    9 S& Q/ @1 o4 z8 v
70. 
    9 w- q, |: p  [- x, q. |4 V- j
71.                                 case JOY_DOWN_L:                        /* 摇杆LEFT键按下 */
    # `* w/ r  N" F8 z) l* |+ x
72.                                         printf("摇杆左键按下\r\n");
    7 b9 V, N. x$ _/ r8 R# H
73.                                         break;
    % B2 Q. w; S& u8 ]1 |
74.                                 
    0 J+ Z  g) T; f2 |  o2 W$ z
75.                                 case JOY_LONG_L:            /* 摇杆LEFT键长按 */
    ! S) ^& {9 d% l+ J6 m7 E, f/ w7 S
76.                                         printf("摇杆左键长按\r\n");
    & s! e* X$ t, D+ @( C
77.                                         break;
    
78. 
    % m, Q6 t& b' E( c% h$ t
79.                                 case JOY_DOWN_R:                        /* 摇杆RIGHT键按下 */
    5 ^. g" S& n1 }) i: K1 x
80.                                         printf("摇杆右键按下\r\n");
    ! X% X# C, }6 R8 ~
81.                                         break;
    $ o; w* K6 P" @1 h7 v. x: B- R( C
82.                                 
    0 z4 s& j2 o( g) i9 }# I9 w
83.                                 case JOY_LONG_R:            /* 摇杆RIGHT键长按 */
    
84.                                         printf("摇杆右键长按\r\n");
    
85.                                         break;
    & X. K! N3 h0 M& N& b2 E
86. 
    
87.                                 case JOY_DOWN_OK:                        /* 摇杆OK键按下 */
    
88.                                         printf("摇杆OK键按下\r\n");
    
89.                                         break;
    / E5 ]3 v$ s5 K4 Q7 u3 y) `
90. 
    
91.                                 case JOY_UP_OK:                        /* 摇杆OK键弹起 */
      P. P+ q# Y5 m4 q" j
92.                                         printf("摇杆OK键弹起\r\n");
    ! q- I9 E; _+ j
93.                                         break;
    3 H! t( o1 a  R2 ~, K; k, A, }) o! J
94. 
    
95.                 case SYS_DOWN_K1K2:                        /* 摇杆OK键弹起 */
    
96.                                         printf("K1和K2组合键按下\r\n");
    
97.                                         break;
    
98. 
    
99.                                 default:
    ; ]8 A& C) @- M, h* k  H
100.                                         /* 其它的键值不处理 */
     
101.                                         break;
     / W. t, E7 Y. ^' o
102.                         }
     ; _# h5 z: x/ l6 r9 M
103.                
     
104.                 }
     * s8 \/ j' J! C+ X  K
105.         }
     ; j; O& j) f2 ]
106. }

复制代码

19.8 实验例程说明（IAR）
. D  e3 _) X' o: P: `$ P% u配套例子：
V7-002_按键检测（软件滤波，FIFO机制）
$ n% Z# A7 Q2 V: ^3 G
/ Y# N7 i* b/ N, s实验目的：
$ Z: L6 H" j$ o* g  L, C学习按键的按下，弹起，长按和组合键的实现。

实验内容：
0 _! I, p4 H( ?' P3 d启动一个自动重装软件定时器，每100ms翻转一次LED2。
2 Y4 W) r2 p; Y# k8 B
) q6 x/ Q1 X2 j6 I1 @* j- u实验操作：
3 _" b4 N% J% p- s, P* a7 R& ?2 p3个独立按键和5向摇杆按下时均有串口消息打印。
5向摇杆的左键和右键长按时，会有连发的串口消息。
独立按键K1和K2按键按下，串口打印消息。

上电后串口打印的信息：
- J3 J& {2 Z* s/ x; l
2 Y0 ?6 Y: t5 s( f( F, {波特率 115200，数据位 8，奇偶校验位无，停止位 1
- P& c8 [& ]3 x" H0 Q) N6 ]
  `, m7 T. Z, w" v& I- z) t" G  _

程序设计：
( M/ {  @/ j/ x* |8 p
$ s/ f! q" v9 \  系统栈大小分配：
+ w3 [2 e2 k8 H8 e4 Z
1 T8 L- i! B4 z: @" u

  RAM空间用的DTCM：

2 b8 K  Y6 g* O6 c5 `

3 m* ~( |7 A( O# B3 e  硬件外设初始化

) Q( T* ?# c5 I' Y" n0 F/ N8 g硬件外设的初始化是在 bsp.c 文件实现：
$ I: q* R3 @' y/ v% s3 l5 B
! x) |# o) }( Z* L

1. /*
   ) c+ V) x. v6 n$ M( V& c0 j+ ]6 g! F
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   5 x; w* I) q6 d" B! r4 }
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
     I: r; o" A- k6 B2 m4 u  T
5. *        形    参：无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    
12.         MPU_Config();
    
13.         
    
14.         /* 使能L1 Cache */
    $ U. V* x; C2 o, F+ N- g$ i
15.         CPU_CACHE_Enable();
    * W# Q& n% v5 u7 F$ E
16. 
    8 n! [; `8 }/ m8 j% F9 e0 H& a
17.         /*
    6 z( O7 X0 D8 u7 e( p6 E3 [
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    $ b+ l# |7 M9 F2 i* o: o
20.            - 设置NVIV优先级分组为4。
    8 }0 J. n/ Y: q/ S& k7 i5 P
21.          */
    # ?  x/ ~: Q5 U, v! m6 @( `( f/ u
22.         HAL_Init();
    
23. 
    
24.         /*
    ( ~4 C9 W( J( B
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    + A6 k) E  g4 w# [7 |! F6 L6 J1 @
28.     */
    
29.         SystemClock_Config();
    * _* U) U& g, r1 Q/ w- }
30. 
    
31.         /*
    
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    . n1 M* V- r6 l7 K9 J# I( x
35.         */        
    " z  Z* y, {9 _+ C- m2 b2 q" X
36. #if Enable_EventRecorder == 1  
    7 J' K1 h1 s; z# t8 Q% b9 K
37.         /* 初始化EventRecorder并开启 */
    8 P: i, \: D  E2 o% r
38.         EventRecorderInitialize(EventRecordAll, 1U);
    + N( b7 L  V$ l# T
39.         EventRecorderStart();
    ( j1 V5 p/ a9 F
40. #endif
    
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    0 m4 h5 W+ n4 t5 F; h8 Y2 L6 q6 S
44.         bsp_InitUart();        /* 初始化串口 */
    4 o$ A; B1 {' G. s% g0 W
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    ( _2 ]. A  x/ H4 C# r. Q2 ~# P1 Y
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

8 l1 N! Z6 I9 M, X! S  MPU配置和Cache配置：
% D+ M( ~, g) W" o& J3 b' r% P
. _* E$ E" l; f. F$ D, B; P" f0 a数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
4 R8 X3 G/ \! \" `+ s

1. /*
   
2. *********************************************************************************************************
   0 j% v% ]2 Q4 J3 \% o1 s
3. *        函 数 名: MPU_Config
   * d0 J4 P2 Q0 t( {% y
4. *        功能说明: 配置MPU
   * n* J/ z. E$ o( ?) y' ], t
5. *        形    参: 无
   " x7 s& [1 X& B3 U6 g
6. *        返 回 值: 无
   $ g# A+ ?, a9 q/ C+ \: `) I
7. *********************************************************************************************************
   2 E! M3 @- k! ]$ d  F  n. A3 _
8. */
   8 F) \2 Z* b/ Y% ^
9. static void MPU_Config( void )
   
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    3 Q  @4 p, K5 n7 J
12. 
    
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    + J  B9 r/ o. A0 D% d( S
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ; W" _) u- S! }* o3 o7 e* Z
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    : W9 i9 E2 P* Y4 n9 i% _( E
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    + a! H, V" G( [
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    / m+ [/ h& T* N% i- A) P
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    / j  K# H0 Z7 G, k0 A4 i) M% k
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    5 ]6 s' ^+ B* I2 n9 c" Y( T
30.         
    
31.         
    8 o/ g2 w$ ^* }4 i1 l% i
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    & Z4 ^9 c! P6 g! M
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    6 [) ]% e, D" l( K* G+ F
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    # `( h, U0 \1 J) p% _  Y* D
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    ! J7 c4 ?* L5 z7 d7 i/ C
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    6 w! C# B9 e* Q$ Z: _2 j1 l+ \0 k0 u0 y
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    4 E) H9 F9 V8 t" a
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
      r9 T( D9 ?+ l
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    & c% e6 N! _4 Q* H8 g0 T+ d
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    ! U) {% y, n+ J
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    9 X; Y( a2 G& o: G+ c
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    + ?, G4 B# V4 K& F# ^# {* c  `
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    8 L! ~. Z3 @! W- Z- P& }
46. 
    
47.         /*使能 MPU */
    - E( L+ b- F* L( p5 l& B& P  ~/ F
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    
50. 
    + R3 E. }) C) s; k
51. /*
    
52. *********************************************************************************************************
    
53. *        函 数 名: CPU_CACHE_Enable
    ' c. g8 i1 V5 s5 }$ z
54. *        功能说明: 使能L1 Cache
    4 n/ T! d, ^& {
55. *        形    参: 无
    
56. *        返 回 值: 无
    
57. *********************************************************************************************************
    
58. */
    / z/ l$ W+ C  i3 T1 n
59. static void CPU_CACHE_Enable(void)
    
60. {
    
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    
63. 
    ) D+ r; |* K7 F- @  F' s
64.         /* 使能 D-Cache */
    9 o5 }- U7 F9 ^; n/ X$ Q
65.         SCB_EnableDCache();
    8 X- f; U$ V1 T5 l1 `, }8 a
66. }

复制代码

; b9 `6 h& b& i8 v$ c& n( ]5 d  每10ms调用一次按键检测：
9 g& J' g7 n7 s3 l6 F1 {
按键检测是在滴答定时器中断里面实现，每10ms执行一次检测。
2 u. `2 E& i3 Q# e+ w/ b# V7 o1 D

1. /*
   : _* V2 X: h" W6 M" I3 J
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_RunPer10ms
   
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   * P# i  q3 j0 R9 W
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *        形    参: 无
   ) v* Y7 y% e( ]- l
7. *        返 回 值: 无
   7 L% Q! l8 C% M, V* y7 H! E* |
8. *********************************************************************************************************
   
9. */
   
10. void bsp_RunPer10ms(void)
    
11. {
    
12.         bsp_KeyScan10ms();
    
13. }

复制代码

; H  R* U& G/ Z" z- x4 D' q4 W$ k( v 主功能：

主功能的实现主要分为两部分：
; r% `) l& J. U4 R
启动一个自动重装软件定时器，每100ms翻转一次LED2
按键消息的读取，检测到按下后，做串口打印。

1. /*
   1 X' ?% H  U4 u
2. *********************************************************************************************************
   
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   ! |/ M9 d' f# Z- j6 I% u
5. *        形    参: 无
   $ Q! ^( p4 }( P, P8 g/ A- H
6. *        返 回 值: 错误代码(无需处理)
   0 f# S7 g) T$ I) u" D
7. *********************************************************************************************************
   * E, R  s9 u+ z) l' @  p: F
8. */
   
9. int main(void)
   3 ~7 ]/ l% X$ V( I' X. ?
10. {
    ) ?  R1 _$ a' p, h0 H' n/ b
11.         uint8_t ucKeyCode;                /* 按键代码 */
      g  ~9 h4 c8 ~) _3 }
12.         
    
13.         bsp_Init();                /* 硬件初始化 */
    
14.         
    
15.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
16.         PrintfHelp();        /* 打印操作提示 */
    % X/ {) ^  `1 [$ j1 m$ Y5 f# k
17. 
    
18. 
    
19.         bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 */
    
20.         
    # \) Z. \" I  ~3 j
21.         /* 进入主程序循环体 */
    
22.         while (1)
    ; [5 X0 T3 [8 a7 g
23.         {
    
24.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
25. 
    
26.                 /* 判断定时器超时时间 */
    
27.                 if (bsp_CheckTimer(0))        
    
28.                 {
    . J8 H8 N7 ]# h0 W$ p
29.                         /* 每隔100ms 进来一次 */  
    
30.                         bsp_LedToggle(2);                        
    & E4 g# @# u. s
31.                 }
    3 x7 ~) ]5 {1 h4 C. F, s7 s" W
32.                
    
33.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    , d; x) p4 c% B9 q) _
34.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    8 y2 V' A9 l3 A( ?; ^
35.                 if (ucKeyCode != KEY_NONE)
    5 _1 O, r( B4 \0 s2 H1 x( J. k7 Y5 t
36.                 {
    
37.                         switch (ucKeyCode)
    
38.                         {
    - M9 c  L, K6 ^3 V
39.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    * G" e+ h2 h7 m9 H: N9 m3 [5 v7 }
40.                                         printf("K1键按下\r\n");
    * ~( q- s: I, j$ V
41.                                         break;
    % B8 B$ R- N9 X, N
42. 
    7 X: h3 G* v5 V7 a
43.                                 case KEY_UP_K1:                                /* K1键弹起 */
    5 K$ `4 p: e7 c8 y  m! Q* e
44.                                         printf("K1键弹起\r\n");
    
45.                                         break;
    8 i+ E* O% L1 a
46. 
    8 V( i. |/ L. G: e+ R+ \( t
47.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    
48.                                         printf("K2键按下\r\n");
    
49.                                         break;
    
50. 
    
51.                                 case KEY_UP_K2:                                /* K2键弹起 */
    
52.                                         printf("K2键弹起\r\n");
    
53.                                         break;
    
54. 
    4 _( o8 F4 R. [8 f* I5 _
55.                                 case KEY_DOWN_K3:                        /* K3键按下 */
    & U7 A0 l3 f& A$ p3 ~9 u
56.                                         printf("K3键按下\r\n");
      x/ V% {* H0 a; i
57.                                         break;
    2 \+ ?0 g% N8 E& M: u
58. 
    
59.                                 case KEY_UP_K3:                                /* K3键弹起 */
    * D- p5 G) {: {8 x9 F* Z9 K) F4 G# x
60.                                         printf("K3键弹起\r\n");
    / d4 m1 U3 p: ?, U& u
61.                                         break;
    ( O  x  T' l9 D( p
62. 
    ! E7 H# g. W0 Z  H! w  L
63.                                 case JOY_DOWN_U:                        /* 摇杆UP键按下 */
    
64.                                         printf("摇杆上键按下\r\n");
    
65.                                         break;
    ) [4 E  i7 z" I' H2 C' a* q
66. 
    
67.                                 case JOY_DOWN_D:                        /* 摇杆DOWN键按下 */
    4 ~9 I( {% K3 \9 d( V7 c% q
68.                                         printf("摇杆下键按下\r\n");
    
69.                                         break;
    6 b4 h* L6 {7 J" x
70. 
    0 I3 P$ r$ [" y" \5 W2 e: q! u# h3 v2 _
71.                                 case JOY_DOWN_L:                        /* 摇杆LEFT键按下 */
    
72.                                         printf("摇杆左键按下\r\n");
    + G7 D' S/ r1 ^- d: P
73.                                         break;
    
74.                                 
    & [8 u$ @4 M" q
75.                                 case JOY_LONG_L:            /* 摇杆LEFT键长按 */
    / q0 |8 `; @& ^1 X# `+ r
76.                                         printf("摇杆左键长按\r\n");
    0 V4 z0 q  z- g4 e- I, h9 Y5 Y
77.                                         break;
    0 J* C) z3 }; P1 ~7 x# t
78. 
    1 V9 ]5 z$ f" D. P+ x* Y
79.                                 case JOY_DOWN_R:                        /* 摇杆RIGHT键按下 */
    ) B) {( n  F; l0 s- ^
80.                                         printf("摇杆右键按下\r\n");
    
81.                                         break;
    ! B& i; O0 V6 ^9 J" q2 D2 [
82.                                 
    . T# \( f3 j* g
83.                                 case JOY_LONG_R:            /* 摇杆RIGHT键长按 */
    - |% B: k$ w2 m! v( `
84.                                         printf("摇杆右键长按\r\n");
    
85.                                         break;
    ( F0 t$ o: I) V
86. 
    
87.                                 case JOY_DOWN_OK:                        /* 摇杆OK键按下 */
    1 {6 Q5 U( w+ V, P! f9 W- D
88.                                         printf("摇杆OK键按下\r\n");
    
89.                                         break;
    
90. 
    
91.                                 case JOY_UP_OK:                        /* 摇杆OK键弹起 */
    
92.                                         printf("摇杆OK键弹起\r\n");
    
93.                                         break;
    
94. 
    
95.                 case SYS_DOWN_K1K2:                        /* 摇杆OK键弹起 */
    6 ~- Y/ b' ]( D0 t9 V+ J
96.                                         printf("K1和K2组合键按下\r\n");
    2 ^0 Y) F! l) X
97.                                         break;
    4 o" c! `+ ^( j& g- @$ i# t5 K
98. 
    8 @4 q: }1 i. Z
99.                                 default:
    
100.                                         /* 其它的键值不处理 */
     9 B  s- ~9 \" c0 `9 V
101.                                         break;
     6 F5 p% v- B% r! @8 F1 `
102.                         }
     
103.                
     
104.                 }
     
105.         }
     
106. }

复制代码

19.9 总结
) M0 f& A& I* Y这个方案在实际项目中已经经过千锤百炼，大家可以放心使用。建议熟练掌握其用法。
1 g1 J% S2 ^9 h1 S0 ]- c- J+ w
6 w* R" _: m* L! z' |9 i