19.1 初学者重要提示
按键FIFO驱动扩展和移植更简单，组合键也更好用。支持按下、弹起、长按和组合键。
# p' @1 O3 m( U; M4 C
% b/ F0 c2 g  e2 \. `' A19.2 按键硬件设计
V7开发板有三个独立按键和一个五向摇杆，下面是三个独立按键的原理图：

. \8 B7 x$ @6 J* e. T

( a- l" n+ q# i* l7 F1 l! Q+ M
/ H0 l  Y- J. t$ a4 _+ K0 L注意，K1（S1）、K2(S2)和K3(S3)按键的上拉电阻是接在5V电压上，因为这三个按键被复用为PS/2键盘鼠标接口，而PS/2是需要5V供电的（注，V5和V6开发板做了PS/2复用，而V7没有使用，这里只是为了兼容之前的板子）。实际测试，K1、K2、K3按键和PS/2键盘是可以同时工作的。
/ Z! r4 \# ]+ A  D6 {, q7 T9 p
; d3 Q! {" y  C3 K" p/ n! \下面是五向摇杆的原理图：

+ B- v* I4 [9 N+ P* Q
+ u7 m+ y8 O1 E5 S* l% o% \' ]8 b通过这个硬件设计，有如下两个知识点为大家做介绍：
, }% U7 E# ?) }
19.2.1 硬件设计
9 e/ a* J+ k! d3 ?" E! H6 r% g+ K按键和CPU之间串联的电阻起保护作用。按键肯定是存在机械抖动的，开发板上面的硬件没有做硬件滤波处理，即使设计了硬件滤波电路，软件上还是需要进行滤波。

6 z4 {# X) o6 q# v: W  保护GPIO，避免软件错误将IO设置为输出，如果设置为低电平还好，如果设置输出的是高电平，按键按下会直接跟GND(低电平)连接，从而损坏MCU。
  保护电阻也起到按键隔离作用，这些GPIO可以直接用于其它实验。
19.2.2 GPIO内部结构分析按键
详细的GPIO模式介绍，请参考第15章的15.3小节，本章仅介绍输入模式。下面我们通过一张图来简单介绍GPIO的结构。
' v. |6 `! ^- o( ^

. W7 ^/ c' ^* W  l6 B红色的线条是GPIO输入通道的信号流向，作为按键检测IO，这些需要配置为浮空输入。按键已经做了5V上拉，因此GPIO内部的上下拉电阻都选择关闭状态。
( E6 g; c9 f8 b  }- {7 M0 T1 J
19.3 按键FIFO的驱动设计
* I+ z0 G+ M4 ?3 g+ s. M2 O" ^bsp_key按键驱动程序用于扫描独立按键，具有软件滤波机制，采用FIFO机制保存键值。可以检测如下事件：
5 k4 v- A1 s  Y
  按键按下。
& Z2 P, ?5 G3 w3 A, S  按键弹起。
# e/ c8 B  p6 Q3 A5 H( k" d' M  长按键。
  长按时自动连发。
) a9 W# G$ B* d+ E2 _我们将按键驱动分为两个部分来介绍，一部分是FIFO的实现，一部分是按键检测的实现。
5 w0 u  `1 K0 {+ C$ M) F9 i9 ~5 l

bsp_key.c 文件包含按键检测和按键FIFO的实现代码。

$ N7 H+ w1 L% E  Bbsp.c 文件会调用bsp_InitKey()初始化函数。
& ]7 s5 L" }# X5 W
$ D# ~; z8 z1 C, @bsp.c 文件会调用bsp_KeyScan按键扫描函数。
+ l% [9 g1 w" g/ f
+ P* D: N$ M  S' v. i" Ybsp_timer.c 中的Systick中断服务程序调用 bsp_RunPer10ms。

中断程序和主程序通过FIFO接口函数进行信息传递。

函数调用关系图：
, U4 Q& w3 a- f& \8 H8 U( Q

19.3.1 按键FIFO的原理
FIFO是First Input First Output的缩写，先入先出队列。我们这里以5个字节的FIFO空间进行说明。Write变量表示写位置，Read变量表示读位置。初始状态时，Read = Write = 0。
$ z- B1 s! n9 ^1 p8 a# s2 h% E
, V1 h( r2 S& H! x7 D

8 N& d& G4 u+ y6 Z我们依次按下按键K1，K2，那么FIFO中的数据变为：

7 W- {, F0 @# U' A6 X2 X

- F+ C0 p& j4 s# h0 s
如果Write！= Read，则我们认为有新的按键事件。

& M+ m0 i& ?" d我们通过函数bsp_GetKey读取一个按键值进行处理后，Read变量变为1。Write变量不变。
) N: A5 `' b1 y  j

. Y- A- Z* G, t! D* K3 N3 q我们继续通过函数bsp_GetKey读取3个按键值进行处理后，Read变量变为4。此时Read = Write = 4。两个变量已经相等，表示已经没有新的按键事件需要处理。

有一点要特别的注意，如果FIFO空间写满了，Write会被重新赋值为0，也就是重新从第一个字节空间填数据进去，如果这个地址空间的数据还没有被及时读取出来，那么会被后来的数据覆盖掉，这点要引起大家的注意。我们的驱动程序开辟了10个字节的FIFO缓冲区，对于一般的应用足够了。

3 t" O! Q/ C# X9 `( a设计按键FIFO主要有三个方面的好处：

1 I% U( V. K' j. P9 k7 R% k3 U' H  可靠地记录每一个按键事件，避免遗漏按键事件。特别是需要实现按键的按下、长按、自动连发、弹起等事件时。
' O" j. q1 x9 r: v  读取按键的函数可以设计为非阻塞的，不需要等待按键抖动滤波处理完毕。
6 p8 B. b0 {* d0 F; v: Y; n/ K9 Z  按键FIFO程序在嘀嗒定时器中定期的执行检测，不需要在主程序中一直做检测，这样可以有效地降低系统资源消耗。

19.3.2 按键FIFO的实现
在bsp_key.h 中定了结构体类型KEY_FIFO_T。这只是类型声明，并没有分配变量空间。
8 h2 G" J& H. }0 t% j
( w* u5 U6 e! Q0 K4 S. w

1. #define KEY_FIFO_SIZE        10
   
2. typedef struct
   
3. {
   ! M( d7 U: @6 Q6 W
4.         uint8_t Buf[KEY_FIFO_SIZE];                /* 键值缓冲区 */
   , S& K* K/ ^6 D( W; T! c7 h" H3 x* u
5.         uint8_t Read;                                        /* 缓冲区读指针1 */
   
6.         uint8_t Write;                             /* 缓冲区写指针 */
   
7.         uint8_t Read2;                             /* 缓冲区读指针2 */
   
8. }KEY_FIFO_T;

复制代码

在bsp_key.c 中定义s_tKey结构变量, 此时编译器会分配一组变量空间。
' M9 x6 l6 }  ~# L+ T$ @; l

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

复制代码

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

6 k. J1 K" M9 ]- q2 o9 a6 Q当检测到按键事件发生后，可以调用 bsp_PutKey函数将键值压入FIFO。下面的代码是函数的实现：

2 c+ V+ V6 C! A, d+ v! {: x

1. /*
   
2. *********************************************************************************************************
   % v2 v( G1 J  A7 Z
3. *        函 数 名: bsp_PutKey
   
4. *        功能说明: 将1个键值压入按键FIFO缓冲区。可用于模拟一个按键。
   6 V+ k& J, |3 ~; F
5. *        形    参: _KeyCode : 按键代码
   
6. *        返 回 值: 无
   ! N8 H2 p  G) [; J9 ?# ]
7. *********************************************************************************************************
   1 k2 A; ?" {4 r3 z( A8 u5 f
8. */
   
9. void bsp_PutKey(uint8_t _KeyCode)
   
10. {
    ; y. n8 h  U( Q6 j
11.         s_tKey.Buf[s_tKey.Write] = _KeyCode;
    
12. 
    
13.         if (++s_tKey.Write  >= KEY_FIFO_SIZE)
    ) ~; c- u5 P$ I% T) f
14.         {
    
15.                 s_tKey.Write = 0;
    
16.         }
    ' ~7 ]5 P/ b) v7 ~& q- g( i
17. }

复制代码

* D2 c# p; ~3 d; {6 y: G6 m! `) n1 `这个bsp_PutKey函数除了被按键检测函数调用外，还可以被其他底层驱动调用。比如红外遥控器的按键检测，也共用了同一个按键FIFO。遥控器的按键代码和主板实体按键的键值统一编码，保持键值唯一即可实现两套按键同时控制程序的功能。
: l7 T9 ]/ F4 w2 h' Z0 z7 v( M6 T
应用程序读取FIFO中的键值，是通过bsp_GetKey函数和bsp_GetKey2函数实现的。我们来看下这两个函数的实现：

8 y1 K' Q* K4 b- n8 ?7 Y

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_GetKey
   
4. *        功能说明: 从按键FIFO缓冲区读取一个键值。
   - n( b) s$ O. h  V' n
5. *        形    参:  无
   ' v8 l  j6 q4 \, ]9 L% K: f
6. *        返 回 值: 按键代码
   % }" Z# [! ]. u! z# ?5 k2 }
7. *********************************************************************************************************
   
8. */
   2 U' f. n1 T. D4 |3 d5 }; m, A
9. uint8_t bsp_GetKey(void)
   
10. {
    # W: V4 C% k' V: R/ D. [: e8 H
11.         uint8_t ret;
    
12. 
    
13.         if (s_tKey.Read == s_tKey.Write)
    
14.         {
    
15.                 return KEY_NONE;
    9 @  Y: c$ ?7 _. [
16.         }
    , Y" L$ o# g9 W- ~
17.         else
    5 a& e+ s- W+ G( W( c7 k  k
18.         {
    1 H* A  U- B1 }$ c  B
19.                 ret = s_tKey.Buf[s_tKey.Read];
    
20. 
    
21.                 if (++s_tKey.Read >= KEY_FIFO_SIZE)
    
22.                 {
    ( J% C) J4 z( H4 R5 l# N
23.                         s_tKey.Read = 0;
    ( X  y* U+ Z& @! w: B* E
24.                 }
    % J! u# W+ W9 O4 `' k
25.                 return ret;
    7 x! _2 p% m4 \# U# ^
26.         }
    / D# X/ _( h7 D
27. }
    
28. 
    0 P8 [) g% b7 t. H8 l. @
29. /*
    
30. *********************************************************************************************************
    
31. *        函 数 名: bsp_GetKey2
    
32. *        功能说明: 从按键FIFO缓冲区读取一个键值。独立的读指针。
    2 ]6 n, c: v1 O% G+ a8 b
33. *        形    参:  无
    
34. *        返 回 值: 按键代码
    
35. *********************************************************************************************************
    
36. */
    , Q6 C: }6 N% Q# T" C- ?
37. uint8_t bsp_GetKey2(void)
    
38. {
    . Y) q* }4 f" Y& h" Q! T; `! }
39.         uint8_t ret;
    & G; z0 b* J, R5 V; M2 L
40. 
    % u5 ?9 a9 J5 B0 ^& x0 ^
41.         if (s_tKey.Read2 == s_tKey.Write)
    
42.         {
    ! |6 D+ A# w) d8 f
43.                 return KEY_NONE;
    
44.         }
    $ N( }6 y3 H9 e$ i% Q7 I* O
45.         else
    
46.         {
    ) ~1 Q; T; ]% ^$ R. L  W+ S# H
47.                 ret = s_tKey.Buf[s_tKey.Read2];
    
48. 
    % B/ l6 x# c, C9 F4 |' p
49.                 if (++s_tKey.Read2 >= KEY_FIFO_SIZE)
    
50.                 {
    
51.                         s_tKey.Read2 = 0;
    
52.                 }
    9 C6 ~8 l6 M8 t* k& |3 h
53.                 return ret;
    
54.         }
    8 r. g$ t- c6 O5 l7 ?  M
55. }

复制代码

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

% u! T! }# h( {- S- N5 e

1. typedef enum
   4 j8 d% M7 K7 T' ?, g1 Q& j
2. {
   5 _; w( o& R2 [( o' Q& m; r# i
3.         KEY_NONE = 0,                        /* 0 表示按键事件 */
   $ Y, V8 o, f: B- j. a
4. 
   % M2 j% g- m4 L* I
5.         KEY_1_DOWN,                        /* 1键按下 */
   
6.         KEY_1_UP,                                /* 1键弹起 */
   2 }" _, _* A+ V/ u8 n
7.         KEY_1_LONG,                        /* 1键长按 */
   , \: ^% \4 ]! i8 q$ B( I" s
8. 
   8 i( z" ^. \4 \* [
9.         KEY_2_DOWN,                        /* 2键按下 */
   ( v1 S3 k' Y& J/ P2 [' r" P( g5 s
10.         KEY_2_UP,                                /* 2键弹起 */
    
11.         KEY_2_LONG,                        /* 2键长按 */
    
12. 
    
13.         KEY_3_DOWN,                        /* 3键按下 */
    
14.         KEY_3_UP,                                /* 3键弹起 */
    & @+ \# ~9 j& b+ d: s
15.         KEY_3_LONG,                        /* 3键长按 */
    1 _8 j$ @$ W* C" X
16. 
    : i3 l5 ?4 n4 H; \
17.         KEY_4_DOWN,                        /* 4键按下 */
    
18.         KEY_4_UP,                                /* 4键弹起 */
    + V; o- k7 P" z: l7 n
19.         KEY_4_LONG,                        /* 4键长按 */
    + }' K" t) c% i8 x6 Q5 E5 e
20. 
    4 \, |( Q, _6 V# N+ W4 j
21.         KEY_5_DOWN,                        /* 5键按下 */
      C3 b, T4 [4 s1 o' w; {) f7 v9 F
22.         KEY_5_UP,                                /* 5键弹起 */
    
23.         KEY_5_LONG,                        /* 5键长按 */
    
24. 
    - g) F% z! a8 |8 u$ v0 H. `7 h
25.         KEY_6_DOWN,                        /* 6键按下 */
    
26.         KEY_6_UP,                                /* 6键弹起 */
    # _1 C7 y8 W7 b" {! x0 e' ^" Y( G
27.         KEY_6_LONG,                        /* 6键长按 */
    
28. 
    
29.         KEY_7_DOWN,                        /* 7键按下 */
    
30.         KEY_7_UP,                                /* 7键弹起 */
    * |  Z2 G+ C9 I2 m, q* p' l, y
31.         KEY_7_LONG,                        /* 7键长按 */
      S5 a3 x  E$ B- Z' i& e& _
32. 
    # X6 y% U& t3 |/ t9 b
33.         KEY_8_DOWN,                        /* 8键按下 */
      J" R# V& |% H- K5 }3 I; S, u
34.         KEY_8_UP,                                /* 8键弹起 */
    : b% f& o5 b2 \8 K) ^) W- ]
35.         KEY_8_LONG,                        /* 8键长按 */
    ( i  x8 g8 S# F% P+ Q( S. Y
36. 
    
37.         /* 组合键 */
    ' M  O* W/ O. z( a' p+ t- K
38.         KEY_9_DOWN,                        /* 9键按下 */
    
39.         KEY_9_UP,                                /* 9键弹起 */
    % C7 ~; o8 \& @' {
40.         KEY_9_LONG,                        /* 9键长按 */
    8 L' G! O% p( P6 n' }+ r
41. 
    " E+ B" q# N, @  K7 D/ W/ Q" h
42.         KEY_10_DOWN,                        /* 10键按下 */
    % ^% O! [4 G/ o: T+ P3 q. O! F
43.         KEY_10_UP,                        /* 10键弹起 */
    ; e3 ~- U; Q5 W3 u1 ~5 W/ o, V
44.         KEY_10_LONG,                        /* 10键长按 */
    
45. }KEY_ENUM;

复制代码

0 w' ~  _/ |% O0 J必须按次序定义每个键的按下、弹起和长按事件，即每个按键对象（组合键也算1个）占用3个数值。我们推荐使用枚举enum, 不用#define的原因：
1 f/ J' A% S8 m0 K* S
  便于新增键值,方便调整顺序。
  使用{ } 将一组相关的定义封装起来便于理解。
  编译器可帮我们避免键值重复。
我们来看红外遥控器的键值定义，在bsp_ir_decode.h文件。因为遥控器按键和主板按键共用同一个FIFO，因此在这里我们先贴出这段定义代码，让大家有个初步印象。
# I2 r/ m4 b- E

1. /* 定义红外遥控器按键代码, 和bsp_key.h 的物理按键代码统一编码 */
   
2. typedef enum
   
3. {
   
4.         IR_KEY_STRAT         = 0x80,
   
5.         IR_KEY_POWER         = IR_KEY_STRAT + 0x45,
   
6.         IR_KEY_MENU         = IR_KEY_STRAT + 0x47,
   # v+ Y$ E$ U' F' Z. @% L) C/ {
7.         IR_KEY_TEST         = IR_KEY_STRAT + 0x44,
     }  w, n1 P0 A1 S. o) \) i5 V2 W
8.         IR_KEY_UP         = IR_KEY_STRAT + 0x40,
   / i0 ?2 l/ \7 e. {+ ^9 u' }6 E
9.         IR_KEY_RETURN        = IR_KEY_STRAT + 0x43,
   - l3 H, r( ^. s2 o: O1 r8 E8 ]
10.         IR_KEY_LEFT        = IR_KEY_STRAT + 0x07,
    1 n. s# _' t7 }1 Z+ _
11.         IR_KEY_OK                = IR_KEY_STRAT + 0x15,
    
12.         IR_KEY_RIGHT        = IR_KEY_STRAT + 0x09,
    
13.         IR_KEY_0                = IR_KEY_STRAT + 0x16,
    - a8 M* }( M0 L! a# `7 ~
14.         IR_KEY_DOWN        = IR_KEY_STRAT + 0x19,
    
15.         IR_KEY_C                = IR_KEY_STRAT + 0x0D,
    : ~, G) m( p" S( A0 T: z
16.         IR_KEY_1                = IR_KEY_STRAT + 0x0C,
    # ^/ Y( x$ \' M7 [
17.         IR_KEY_2                = IR_KEY_STRAT + 0x18,
    
18.         IR_KEY_3                = IR_KEY_STRAT + 0x5E,
    : o# J3 f( w" C
19.         IR_KEY_4                = IR_KEY_STRAT + 0x08,
    1 ~/ X/ q' e5 L- G; d7 I
20.         IR_KEY_5                = IR_KEY_STRAT + 0x1C,
    
21.         IR_KEY_6                = IR_KEY_STRAT + 0x5A,
    . d# ^) W  x  J5 R+ a$ H( T
22.         IR_KEY_7                = IR_KEY_STRAT + 0x42,
    
23.         IR_KEY_8                = IR_KEY_STRAT + 0x52,
    
24.         IR_KEY_9                = IR_KEY_STRAT + 0x4A,        
    
25. }IR_KEY_E;

复制代码

- b/ I% X% @- U# o- t( a3 D6 }% r我们下面来看一段简单的应用。这个应用的功能是：主板K1键控制LED1指示灯；遥控器的POWER键和MENU键控制LED2指示灯。
3 m+ ^7 {( h% w
/ {; b* t" u/ A3 O, ?+ x# C& K, j

1. #include "bsp.h"
   ) b8 D: ^1 B; g" A( `* b% _
2. 
   
3. int main(void)
   
4. {
   
5.         uint8_t ucKeyCode;
   
6.                         
   
7.         bsp_Init();
   $ h* w& A5 ~& ?4 C
8. 
   
9.         IRD_StartWork();        /* 启动红外解码 */
   $ w- b3 [+ q  S9 d
10. 
    * m) M& u6 R2 J$ G+ C) [
11.         while(1)
    7 T/ _! A1 V& l8 Q; I
12.         {
    
13.                 bsp_Idle();
    
14.                
    6 w+ q7 [2 U6 N. D9 }/ I& }
15.                 /* 处理按键事件 */
    1 E2 G0 `; a  O* |+ n1 u; m  ]
16.                 ucKeyCode = bsp_GetKey();
    
17.                 if (ucKeyCode > 0)
    & t4 E& v5 O, u! B6 E
18.                 {
    
19.                         /* 有键按下 */
    
20.                         switch (ucKeyCode)
    
21.                         {
    
22.                                 case KEY_DOWN_K1:                /* K1键按下 */
    
23.                                         bsp_LedOn(1);                /* 点亮LED1 */
    
24.                                         break;
    4 h% b: X* M3 K9 v2 x/ K5 O% ~, q
25. 
    
26.                                 case KEY_UP_K1:                /* K1键弹起 */
    
27.                                         bsp_LedOff(1);        /* 熄灭LED1 */
    
28.                                         break;                                       
    
29. 
    
30.                                 case IR_KEY_POWER:                /* 遥控器POWER键按下 */
    - @' \6 U% x0 {( \0 @6 ?( c
31.                                         bsp_LedOn(1);                /* 点亮LED2 */
    
32.                                         break;
    
33. 
    
34.                                 case IR_KEY_MENU:                /* 遥控器MENU键按下 */
    
35.                                         bsp_LedOff(1);        /* 熄灭LED2 */
    ; A' @7 ?, D, J7 k$ a
36.                                         break;                                       
    9 x  `& O  S% V4 n
37. 
    5 s" y; H0 h( |- C& m6 J
38.                                 case MSG_485_RX:                /* 通信程序的发来的消息 */
    
39.                                         /* 执行通信程序的指令 */
    
40.                                         break;
    
41. 
    
42.                                 default:
    / J# E0 x/ |! A( h: Y* y9 j
43.                                         break;
    
44.                         }
    
45.                 }
      ^: w$ U* l0 g1 d; }/ c
46.         }
    5 X% _8 w7 W6 t0 Y: Z) ~
47. }

复制代码

& E, f0 X& p- ^7 P0 A看到这里，想必你已经意识到bsp_PutKey函数的强大之处了，可以将不相关的硬件输入设备统一为一个相同的接口函数。

在上面的应用程序中，我们特意添加了一段红色的代码来解说更高级的用法。485通信程序收到有效的命令后通过 bsp_PutKey（MSG_485_RX）函数可以通知APP应用程序进行进一步加工处理（比如显示接收成功）。这是一种非常好的任务间信息传递方式，它不会破坏程序结构。不必新增全局变量来做这种事情，你只需要添加一个键值代码。
& }9 J. A' m  ?7 E
0 Q* B7 T! i- V7 K% v$ Z对于简单的程序，可以借用按键FIFO来进行少量的信息传递。对于复杂的应用，我们推荐使用bsp_msg专门来做这种任务间的通信。因为bsp_msg除了传递消息代码外，还可以传递参数结构。

19.3.3 按键检测程序分析
在bsp_key.h 中定了结构体类型KEY_T。

9 g# |8 G. l0 c/ f9 `. h

1. #define KEY_COUNT    10                           /* 按键个数, 8个独立建 + 2个组合键 */
   
2. 
   - Y+ C& m3 g  M8 D
3. typedef struct
   9 p) A" x- G7 \; C1 ]
4. {
   
5.         /* 下面是一个函数指针，指向判断按键手否按下的函数 */
   $ y, i  t4 K- o2 u1 {
6.         uint8_t (*IsKeyDownFunc)(void); /* 按键按下的判断函数,1表示按下 */
   
7. 
   / p. n. H. {% e9 O8 E- a
8.         uint8_t  Count;                /* 滤波器计数器 */
   
9.         uint16_t LongCount;        /* 长按计数器 */
   
10.         uint16_t LongTime;                /* 按键按下持续时间, 0表示不检测长按 */
    
11.         uint8_t  State;                /* 按键当前状态（按下还是弹起） */
    
12.         uint8_t  RepeatSpeed;        /* 连续按键周期 */
    % {1 m3 I. S: t' ]. F8 @
13.         uint8_t  RepeatCount;        /* 连续按键计数器 */
    
14. }KEY_T;

复制代码

在bsp_key.c 中定义s_tBtn结构体数组变量。

  F0 r5 h; y* M) h

1. static KEY_T s_tBtn[KEY_COUNT];
   
2. static KEY_FIFO_T s_tKey; /* 按键FIFO变量,结构体 */

复制代码

每个按键对象都分配一个结构体变量，这些结构体变量以数组的形式存在将便于我们简化程序代码行数。
' V# i& j; Q4 v+ r8 w3 m
2 Y. r. ]. \2 t7 s; k* B" I& C使用函数指针IsKeyDownFunc可以将每个按键的检测以及组合键的检测代码进行统一管理。

因为函数指针必须先赋值，才能被作为函数执行。因此在定时扫描按键之前，必须先执行一段初始化函数来设置每个按键的函数指针和参数。这个函数是 void bsp_InitKey(void)。它由bsp_Init()调用。

1. /*
   ! m! ~$ q7 I  b+ a3 Z
2. *********************************************************************************************************
   2 a& [9 I; c& A- h0 i7 u) F( O+ u
3. *        函 数 名: bsp_InitKey
   
4. *        功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
   5 y# O1 c7 {& q5 L- k% {8 R
5. *        形    参: 无
   $ ?7 P' s9 L; Q9 f2 b3 h# X0 V
6. *        返 回 值: 无
   5 x- }! X* o7 @# `; V9 t  }
7. *********************************************************************************************************
   0 S; }) Q( `, h/ Y, Y+ n
8. */
   ; Z/ b9 P0 X- ]" h' j3 t: y
9. void bsp_InitKey(void)
   8 r, l" G- n: d  Z& E
10. {
    
11.         bsp_InitKeyVar();                /* 初始化按键变量 */
    
12.         bsp_InitKeyHard();                /* 初始化按键硬件 */
      H. ?, O9 ]" v3 P$ L2 e
13. }

复制代码

6 V' {) w' D. v: d下面是bsp_InitKeyVar函数的定义：

1. /*
   
2. *********************************************************************************************************
   ! b! {) [/ Q4 \" n- c' H  j
3. *        函 数 名: bsp_InitKeyVar
   2 S1 K* q7 o! f; ~) w
4. *        功能说明: 初始化按键变量
   
5. *        形    参:  无
   + l8 Z3 R: ]! j( j' U" c
6. *        返 回 值: 无
   * a9 Q% ]$ K2 r# @: m8 f
7. *********************************************************************************************************
   , r& ^: {- g2 ]+ y1 Q
8. */
   
9. static void bsp_InitKeyVar(void)
   9 a/ f9 K. K# N0 X
10. {
    
11.         uint8_t i;
    ! m! t7 L0 A6 r0 A7 e4 J' K3 _
12. 
    . e+ W4 |7 H" R& g6 Z
13.         /* 对按键FIFO读写指针清零 */
    . Z8 l5 J5 F3 U! J, F
14.         s_tKey.Read = 0;
    
15.         s_tKey.Write = 0;
    
16.         s_tKey.Read2 = 0;
    
17. 
    
18.         /* 给每个按键结构体成员变量赋一组缺省值 */
    , C" ~& e% u) L
19.         for (i = 0; i < KEY_COUNT; i++)
    # F- F. z4 v1 ^. x* {
20.         {
    0 y3 l7 a' N% K: C0 s  v
21.                 s_tBtn<i>.LongTime = KEY_LONG_TIME;                        /* 长按时间 0 表示不检测长按键事件 */</i>
    ; O! g% _2 o) F9 W: b# W3 j
22. <span style="font-style: italic;">                s_tBtn.Count = KEY_FILTER_TIME / 2;                /* 计数器设置为滤波时间的一半 */
    # C4 ?: @- g/ d* F4 R, T
23.                 s_tBtn<span style="font-style: italic;">.State = 0;                                                /* 按键缺省状态，0为未按下 */
    2 G; a% J  k( W' E
24.                 s_tBtn<span style="font-style: italic;">.RepeatSpeed = 0;                                        /* 按键连发的速度，0表示不支持连发 */
      J0 {: k7 M* y  ^9 q
25.                 s_tBtn<i style="font-style: italic;">.RepeatCount = 0;                                        /* 连发计数器 */
    
26.      </i><span style="font-style: normal;">   }
    % O; E% M5 Z$ H
27. 
    
28.         /* 如果需要单独更改某个按键的参数，可以在此单独重新赋值 */
    - H- v( w$ j: Q3 j
29.         
    
30.         /* 摇杆上下左右，支持长按1秒后，自动连发 */
    
31.         bsp_SetKeyParam(KID_JOY_U, 100, 6);
    5 f/ }, B) ?- f# [6 c0 w+ g
32.         bsp_SetKeyParam(KID_JOY_D, 100, 6);
    2 ?5 g  W9 r$ y
33.         bsp_SetKeyParam(KID_JOY_L, 100, 6);
    1 Q8 u% s! g( i: X& N$ x
34.         bsp_SetKeyParam(KID_JOY_R, 100, 6);
    & v/ D, q0 X% J0 H  R
35. }</span></span></span></span>

复制代码

# s# B9 s/ k& a注意一下 Count 这个成员变量，没有设置为0。为了避免主板上电的瞬间，检测到一个无效的按键按下或弹起事件。我们将这个滤波计数器的初值设置为正常值的1/2。bsp_key.h中定义了滤波时间和长按时间。

1. /*
   8 E( [$ N3 V6 W" ]
2.         按键滤波时间50ms, 单位10ms。
   
3.         只有连续检测到50ms状态不变才认为有效，包括弹起和按下两种事件
   . l0 }) S2 c( m' t+ Z+ x. u, ]
4.         即使按键电路不做硬件滤波，该滤波机制也可以保证可靠地检测到按键事件
   : v( d/ Y% g7 g5 _
5. */
   6 ]- s' s5 z' Q1 O) v$ }: {6 d( n+ `
6. #define KEY_FILTER_TIME   5
   
7. #define KEY_LONG_TIME     100                        /* 单位10ms， 持续1秒，认为长按事件 */

复制代码

uint8_t KeyPinActive(uint8_t _id)（会调用函数KeyPinActive判断状态）函数就是最底层的GPIO输入状态判断函数。

! w9 Z5 E) W, z/ [, |; [( Q

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: KeyPinActive
   , g1 M* g  s  x8 C. Q
4. *        功能说明: 判断按键是否按下
   % U1 N0 c' ]' ^' |# r
5. *        形    参: 无
   
6. *        返 回 值: 返回值1 表示按下(导通），0表示未按下（释放）
   
7. *********************************************************************************************************
   
8. */
     p9 `% [# s/ d- G% B, \) J! k
9. static uint8_t KeyPinActive(uint8_t _id)
   , R6 e1 m3 V! _: L! R% d8 V, Q4 X
10. {
    
11.         uint8_t level;
    
12.         
    ! {" }/ c4 Q# z+ H8 N- B  ~
13.         if ((s_gpio_list[_id].gpio->IDR & s_gpio_list[_id].pin) == 0)
    
14.         {
    0 J: f* q! F# B& F
15.                 level = 0;
    # ?# w' D* e5 L9 R5 b4 I! L
16.         }
    " p- ]9 K8 {# U/ A
17.         else
    
18.         {
    ( V0 C6 Q. X% B) S/ \. L& }" Z! ~( {' L
19.                 level = 1;
    2 b6 Q3 @8 e  r" d
20.         }
    
21. 
    ' q4 ?+ q, e% S. }. R3 ~
22.         if (level == s_gpio_list[_id].ActiveLevel)
    
23.         {
    
24.                 return 1;
    
25.         }
    ! {  ~8 ~, o; \% g' y$ D$ j: l' w
26.         else
    
27.         {
    2 \) m  E/ `  M: j$ d1 X2 X
28.                 return 0;
    
29.         }
    
30. }
    # x" \) y4 j& _7 A1 _3 K1 ]
31. 
    * s# V) Q3 g+ L8 D2 T; X
32. /*
    
33. *********************************************************************************************************
    
34. *        函 数 名: IsKeyDownFunc
    
35. *        功能说明: 判断按键是否按下。单键和组合键区分。单键事件不允许有其他键按下。
    
36. *        形    参: 无
    $ u+ P. N5 l0 {. J; ^# U  A
37. *        返 回 值: 返回值1 表示按下(导通），0表示未按下（释放）
    
38. *********************************************************************************************************
    
39. */
    
40. static uint8_t IsKeyDownFunc(uint8_t _id)
    , c+ P8 T8 ?  l" P
41. {
    ; V! ~9 d" t% M( l* a, i4 A# Y
42.         /* 实体单键 */
    
43.         if (_id < HARD_KEY_NUM)
    ( z! x0 x, G3 ~1 u& w- n
44.         {
    
45.                 uint8_t i;
    
46.                 uint8_t count = 0;
    ' i2 Y9 X0 u9 B# Y- a
47.                 uint8_t save = 255;
    
48.                
    
49.                 /* 判断有几个键按下 */
    
50.                 for (i = 0; i < HARD_KEY_NUM; i++)
    1 P9 T' e2 i9 c2 G. k3 L
51.                 {
    : [. M( u4 t& s
52.                         if (KeyPinActive(i))
    ( U+ J+ {' X& I2 t
53.                         {
    * l# m) L. K* b8 ^- O( T9 t
54.                                 count++;
    $ x9 E7 R7 i. x# f( O; A
55.                                 save = i;
    3 n& ~- j# w! Q) A2 ~  M
56.                         }
    ' @  Z0 ?' [1 c
57.                 }
    
58.                
    : |, j* V" L0 x
59.                 if (count == 1 && save == _id)
    * B, l/ e1 e- N' y8 ?
60.                 {
    ! d9 M: A) Q; V& k# O* X! F6 C
61.                         return 1;        /* 只有1个键按下时才有效 */
    4 ]# n, J! F3 d% Q# B; g
62.                 }               
    ' T6 ~* J, _/ d; c' E# F
63. 
    9 w/ M$ t3 `( T5 s" I" ^
64.                 return 0;
    
65.         }
    
66.         
    
67.         /* 组合键 K1K2 */
    
68.         if (_id == HARD_KEY_NUM + 0)
    0 h8 b/ y! u: R" f- l+ G
69.         {
    & Y$ D* r3 V7 [! L; u) ~1 K8 G9 ]! S
70.                 if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
    
71.                 {
    
72.                         return 1;
    
73.                 }
    5 b; `' W' ^8 x3 v
74.                 else
    
75.                 {
    
76.                         return 0;
    
77.                 }
    
78.         }
    & M* k+ I2 V4 w7 q3 a. M4 Q8 z" x
79. 
    
80.         /* 组合键 K2K3 */
    3 P2 E; \. F" m$ F
81.         if (_id == HARD_KEY_NUM + 1)
    
82.         {
    0 M" Y0 l3 Q- n0 H- W4 g- F4 n
83.                 if (KeyPinActive(KID_K2) && KeyPinActive(KID_K3))
    
84.                 {
    % U+ }" A/ w6 l& U
85.                         return 1;
    , ]& g, e* ?4 A" f
86.                 }
    
87.                 else
    3 P9 \& R% D' Q/ c9 G" y$ o
88.                 {
    
89.                         return 0;
    " C9 s5 \8 H9 c/ ]& g# }- ^
90.                 }
    
91.         }
    
92. 
    6 v; G# Z6 I! e( V! K
93.         return 0;
    
94. }

复制代码

: _9 n' w; }0 @7 q* X4 {5 B$ t! b4 @2 |在使用GPIO之前，我们必须对GPIO进行配置，比如打开GPIO时钟，设置GPIO输入输出方向，设置上下拉电阻。下面是配置GPIO的代码，也就是bsp_InitKeyHard（）函数：

' F' R: [, j6 t$ q. S6 j& B% g

1. /*
   2 |2 j. c& J! h" B  l
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_InitKeyHard
   ! B6 ?4 a  B$ i1 H
4. *        功能说明: 配置按键对应的GPIO
   
5. *        形    参:  无
   
6. *        返 回 值: 无
   + m) t& i: `8 `$ V  H- u
7. *********************************************************************************************************
   
8. */
   4 H1 h2 B+ y# U$ X8 E* z5 |
9. static void bsp_InitKeyHard(void)
   
10. {        
    
11.         GPIO_InitTypeDef gpio_init;
    / C! }( ~( u: q& c
12.         uint8_t i;
    5 L( j/ o/ U) C0 n; p
13. 
    # ~+ E- T: x( u
14.         /* 第1步：打开GPIO时钟 */
    
15.         ALL_KEY_GPIO_CLK_ENABLE();
    % L  _* E( T7 [% l
16.         
    
17.         /* 第2步：配置所有的按键GPIO为浮动输入模式(实际上CPU复位后就是输入状态) */
    " h5 c# F! Q+ G- h3 @
18.         gpio_init.Mode = GPIO_MODE_INPUT;                           /* 设置输入 */
    
19.         gpio_init.Pull = GPIO_NOPULL;                 /* 上下拉电阻不使能 */
    - x1 A  G' z0 ^9 f
20.         gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;  /* GPIO速度等级 */
    + r5 g1 C* t. v# r. h" b1 A
21.         
    / o3 K& e! {6 i& O9 z/ ~! W+ H! E
22.         for (i = 0; i < HARD_KEY_NUM; i++)
    / p' L* Z. D# ]0 {1 Z: i+ s% n4 ~
23.         {
    - a1 C, b5 Q7 c1 g! s6 k
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);        
    
26.         }
    
27. }</span></span>

复制代码

$ z& l5 O3 R0 f2 @2 Z. {0 E我们再来看看按键是如何执行扫描检测的。
7 E" a9 s' _6 q( p. n" n
按键扫描函数bsp_KeyScan10ms ()每隔10ms被执行一次。bsp_RunPer10ms函数在systick中断服务程序中执行。

% b: i( t0 ^4 N1 J5 B# V

1. void bsp_RunPer10ms(void)
   + S$ F7 k  }! f# t- @
2. {
   
3.         bsp_KeyScan10ms();                /* 扫描按键 */
   5 d2 ~( m( |% ^2 L( d6 n
4. }

复制代码

bsp_KeyScan10ms ()函数的实现如下：

1. /*
   
2. *********************************************************************************************************
   / H3 @( b1 q4 U  u( q
3. *        函 数 名: bsp_KeyScan10ms
   1 B5 Q  u  |8 }; J  m& f
4. *        功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
   
5. *        形    参: 无
   7 t) K6 q; z9 O( w5 P6 H. `
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   : W6 d8 H. {( |; J# g" P2 w
8. */
   
9. void bsp_KeyScan10ms(void)
   / Y2 b8 B, u+ {/ b5 Y5 S
10. {
    $ g8 U! O4 q$ z) X( I& L/ C6 v
11.         uint8_t i;
    ; [0 n" {. Z( l
12. 
    ' y+ [. v( P4 p. b6 Q, I
13.         for (i = 0; i < KEY_COUNT; i++)
    % W8 O, Z3 N# [1 u) Q2 |
14.         {
    & F* y  b( ]- t+ `
15.                 bsp_DetectKey(i);
    
16.         }
    
17. }

复制代码

" D5 l( {8 S8 r5 H3 s每隔10ms所有的按键GPIO均会被扫描检测一次。bsp_DetectKey函数实现如下：
8 X! U' r$ M8 {# r  v, a5 d
: u% t# u- c  M' }) V4 R4 A

1. /*
   
2. *********************************************************************************************************
   8 B- y% K. \( k6 x9 Q
3. *        函 数 名: bsp_DetectKey
   
4. *        功能说明: 检测一个按键。非阻塞状态，必须被周期性的调用。
   / c' c; x  S! Z, S& q. _
5. *        形    参: IO的id， 从0开始编码
   $ w% `9 G* {; O& b  p5 L
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   2 g/ M* i8 u) [6 d6 S0 R# J6 P
9. static void bsp_DetectKey(uint8_t i)
   6 [6 u0 k4 a0 [- C5 n
10. {
    
11.         KEY_T *pBtn;
    4 A5 [  c* `9 b6 m* s$ f2 h& f4 v
12. 
    
13.         pBtn = &s_tBtn<span style="font-style: italic;"><span style="font-style: normal;">;
    $ O  ]8 |% q9 R  m# v! ^' y$ B' F
14.         if (IsKeyDownFunc(i))
    
15.         {
    
16.                 if (pBtn->Count < KEY_FILTER_TIME)
    6 n5 r3 c  |7 _- R$ ^3 V9 [) T
17.                 {
    ( @2 N  p0 ?$ l1 X# T
18.                         pBtn->Count = KEY_FILTER_TIME;
    3 H7 T$ A, i7 H8 a
19.                 }
    
20.                 else if(pBtn->Count < 2 * KEY_FILTER_TIME)
    
21.                 {
    
22.                         pBtn->Count++;
    
23.                 }
    ' `% N: |% U5 t7 ?) ]
24.                 else
    
25.                 {
    ( ^6 r0 N( a' o
26.                         if (pBtn->State == 0)
    
27.                         {
    " J" x+ W4 E8 t. P+ [0 C
28.                                 pBtn->State = 1;
    7 a  {" c4 W+ \7 I8 s: |7 @
29. 
      C9 ^3 {1 w) E
30.                                 /* 发送按钮按下的消息 */
    $ Y4 r+ c) Q# M8 U+ H/ k
31.                                 bsp_PutKey((uint8_t)(3 * i + 1));
    7 i7 O* O' O) z% U1 M
32.                         }
    * ~# S- ^- q+ b6 z" \+ q
33. 
    + E' h% Z" I$ v  I4 l
34.                         if (pBtn->LongTime > 0)
    
35.                         {
    
36.                                 if (pBtn->LongCount < pBtn->LongTime)
    : U: R, \$ n; Z5 o
37.                                 {
    8 O4 m: X& I) w. d
38.                                         /* 发送按钮持续按下的消息 */
    
39.                                         if (++pBtn->LongCount == pBtn->LongTime)
    
40.                                         {
    
41.                                                 /* 键值放入按键FIFO */
    0 j& S# _! k5 J% X& g
42.                                                 bsp_PutKey((uint8_t)(3 * i + 3));
    
43.                                         }
    
44.                                 }
    6 F* B; d* t, T) g/ s/ |
45.                                 else
    # C5 X* i: h1 F$ _
46.                                 {
    
47.                                         if (pBtn->RepeatSpeed > 0)
    
48.                                         {
    
49.                                                 if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
    
50.                                                 {
    - L4 q$ h/ g& u) l* O! [
51.                                                         pBtn->RepeatCount = 0;
    $ L( c( L" A7 c9 q
52.                                                         /* 常按键后，每隔RepeatSpeed * 10ms发送1个按键 */
    
53.                                                         bsp_PutKey((uint8_t)(3 * i + 1));
    
54.                                                 }
    & B/ G, y% b; M/ V
55.                                         }
    
56.                                 }
    
57.                         }
    
58.                 }
    4 X$ X, v) J( L) ?/ X: C& Z% g
59.         }
    + Z" z0 `* ?; G8 q4 E) x0 U
60.         else
    
61.         {
    
62.                 if(pBtn->Count > KEY_FILTER_TIME)
    
63.                 {
    
64.                         pBtn->Count = KEY_FILTER_TIME;
    + h1 f# n& {2 }* S  R: }
65.                 }
    3 j0 U; i( L3 M0 O# c( ~
66.                 else if(pBtn->Count != 0)
    8 e' ]* F* s, S7 }) @, k/ d/ O
67.                 {
    
68.                         pBtn->Count--;
    
69.                 }
    
70.                 else
    , V& `: S8 X" Y; `4 M
71.                 {
    : J' y2 H, K$ D1 t
72.                         if (pBtn->State == 1)
    
73.                         {
    
74.                                 pBtn->State = 0;
    
75. 
    * z3 O1 r" G2 e$ ~9 j' P8 u* y
76.                                 /* 发送按钮弹起的消息 */
    ; \& r) d$ d5 B3 f3 X
77.                                 bsp_PutKey((uint8_t)(3 * i + 2));
    % A* z6 @. h2 y4 ~5 J
78.                         }
    
79.                 }
    / N) ~( R% a! p: t/ n
80. 
    7 I" L2 R. a, Q! K% Y
81.                 pBtn->LongCount = 0;
    % C3 D0 @% [0 g% ]+ q
82.                 pBtn->RepeatCount = 0;
    1 R! P  U4 Y& K, d0 @! [% ?
83.         }
    
84. }</span></span>

复制代码

对于初学者，这个函数看起来比较吃力，我们拆分进行分析。

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

复制代码

& n' x% }* e6 m( D' V( }& m. S读取相应按键的结构体地址，程序里面每个按键都有自己的结构体。

2 {+ y5 B, M4 g& ]9 u

1. static KEY_T s_tBtn[KEY_COUNT];
   , {0 L" d+ E4 }5 y% U! |
2. if (IsKeyDownFunc(i))
   8 Z/ y% T( J, k5 ]! w; r& Q
3. {
   # @. W9 _, b7 x* k& c+ O
4.         这个里面执行的是按键按下的处理
   
5. }
     W# o$ Z/ F# U
6. else
   . {- Q# v3 e) I8 t5 L# t: h4 e
7. {
   
8.         这个里面执行的是按键松手的处理或者按键没有按下的处理
   . F' U/ v, ^7 H7 p% `9 K
9. }

复制代码

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

& `& g- d* k+ c9 I  v

1. /*
     F0 y2 k: ]* l+ x
2. **********************************************************************************
   
3. 下面这个if语句主要是用于按键滤波前给Count设置一个初值，前面说按键初始化的时候
   
4. 已经设置了Count = KEY_FILTER_TIME/2
   % H. @6 B7 O2 @1 D
5. **********************************************************************************
   
6. */
   9 S5 K- v/ Q- V
7. if (pBtn->Count < KEY_FILTER_TIME)
   
8. {
   
9.     pBtn->Count = KEY_FILTER_TIME;
   9 K( H, y) z( d+ Z
10. }
    8 x7 ]8 S1 ^" G! A, U9 r/ v
11. 
    
12. /*
    * u1 F5 A% Q) q6 n7 v. E
13. **********************************************************************************
    7 N; t. X$ a  [: o& H% q
14. 这里实现KEY_FILTER_TIME时间长度的延迟
      o, s" K: M# T+ y4 M/ o3 X
15. **********************************************************************************
    ; D5 p  ~* T5 k5 e& e1 ]
16. */
    
17. else if(pBtn->Count < 2 * KEY_FILTER_TIME)
    
18. {
    2 H# E) E# I! d: ^8 T' C; [* [8 S
19.     pBtn->Count++;
    
20. }
    
21. /*
    0 u3 z5 n; P. k
22. **********************************************************************************
    
23. 这里实现KEY_FILTER_TIME时间长度的延迟
    9 }* c$ m" M) k. w1 \& C1 C# a
24. **********************************************************************************
    
25. */
    ( ~: K6 u: B2 y, p) E6 E- x
26. else
    5 u& _* a# C/ h1 d
27. {
    8 u* V# N) @% A8 S8 _
28. /*
    
29. **********************************************************************************
    
30. 这个State变量是有其实际意义的，如果按键按下了，这里就将其设置为1，如果没有按下这个
    
31. 变量的值就会一直是0，这样设置的目的可以有效的防止一种情况的出现：比如按键K1在某个
    
32. 时刻检测到了按键有按下，那么它就会做进一步的滤波处理，但是在滤波的过程中，这个按键
    2 P1 Z* L( I0 h# n' j# A1 z, d
33. 按下的状态消失了，这个时候就会进入到上面第二步else语句里面，然后再做按键松手检测滤波
    
34. ，滤波结束后判断这个State变量，如果前面就没有检测到按下，这里就不会记录按键弹起。
    7 l8 ~4 ~0 ~# }, i) K* _& U7 ~
35. **********************************************************************************
    
36. */
    : s& ], P$ W9 e* X
37.     if (pBtn->State == 0)
    
38.     {
    
39.         pBtn->State = 1;
    
40. 
    
41.         /* 发送按钮按下的消息 */
    ; e! |# W( L3 Q+ n+ }$ A* l3 Z
42.         bsp_PutKey((uint8_t)(3 * i + 1));
    $ E# L( ~, Q( q1 {1 e* B
43.     }
    
44. 
    
45.     if (pBtn->LongTime > 0)
    3 L" F" ^0 x/ D
46.     {
    2 q' `' C$ B  V) f' w! _8 ?$ z4 m
47.         if (pBtn->LongCount < pBtn->LongTime)
    
48.         {
    7 g# I3 H% C* j5 b
49.             /* 发送按钮持续按下的消息 */
    6 Y" u0 U# U0 M- |3 x
50.             if (++pBtn->LongCount == pBtn->LongTime)
    2 T8 ?# n  @" P. g3 C
51.             {
    
52.                 /* 键值放入按键FIFO */
    % U/ V! S4 \8 o$ y( @% U6 |
53.                 bsp_PutKey((uint8_t)(3 * i + 3));
    % Y0 k6 {3 ~$ x
54.             }
    
55.         }
    1 o5 P; J# `5 r5 g" x
56.         else
    & s; @9 B6 N3 h1 `$ `3 ^
57.         {
    , f* ]% ^/ B9 A' J4 C& e1 `( b
58.             if (pBtn->RepeatSpeed > 0)
    
59.             {
    % T9 A; c6 S. o
60.                 if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
    
61.                 {
    
62.                     pBtn->RepeatCount = 0;
    ( N: `' h; ]* s: J, k
63.                     /* 长按键后，每隔10ms发送1个按键 */
    . O6 @5 p" a1 ?" }9 C, b: w
64.                     bsp_PutKey((uint8_t)(3 * i + 1));
    
65.                 }
    
66.             }
    
67.         }
    
68.     }
    
69. }

复制代码

3 J5 w! c8 M5 L& R4 `) u* E19.3.4 按键检测采用中断方式还是查询方式
# y' K% ?  K" I, K1 L7 Z) \" m检测按键有中断方式和GPIO查询方式两种。我们推荐大家用GPIO查询方式。
/ B" W0 M$ |8 N- }" F. j0 K9 F
  x1 m* y- [8 W' M& E" ?1 R. P2 V" E从裸机的角度分析

中断方式：中断方式可以快速地检测到按键按下，并执行相应的按键程序，但实际情况是由于按键的机械抖动特性，在程序进入中断后必须进行滤波处理才能判定是否有效的按键事件。如果每个按键都是独立的接一个IO引脚，需要我们给每个IO都设置一个中断，程序中过多的中断会影响系统的稳定性。中断方式跨平台移植困难。
3 W" o0 B# M+ n) Q( Q1 L
查询方式：查询方式有一个最大的缺点就是需要程序定期的去执行查询，耗费一定的系统资源。实际上耗费不了多大的系统资源，因为这种查询方式也只是查询按键是否按下，按键事件的执行还是在主程序里面实现。

从OS的角度分析
4 j; f/ z1 B/ \
中断方式：在OS中要尽可能少用中断方式，因为在RTOS中过多的使用中断会影响系统的稳定性和可预见性（抢占式调度的OS基本没有可预见性）。只有比较重要的事件处理需要用中断的方式。
7 V- E. g; ]/ N* E' y; i, O0 p
查询方式：对于用户按键推荐使用这种查询方式来实现，现在的OS基本都带有CPU利用率的功能，这个按键FIFO占用的还是很小的，基本都在1%以下。

19.4 按键板级支持包（bsp_key.c）
' b  ]% z- Q7 `8 L按键驱动文件bsp_key.c主要实现了如下几个API：
' S8 o& F$ L" v8 y
' `+ L. y! y- q% j: c! P; j  KeyPinActive
$ M/ Q' o, }2 |  IsKeyDownFunc
! A' t4 J7 A# G" [$ ~- C- s  bsp_InitKey
# X4 t3 H& e- [6 V; d* B$ Q  bsp_InitKeyHard
2 a8 P, h# y6 `; B- m$ J  bsp_InitKeyVar
, w6 x/ f, T. y* f  n/ \  bsp_PutKey
5 c8 h! G" W2 F" ?  bsp_GetKey
+ v$ e) d2 v/ a2 c4 l  bsp_GetKey2
* \! ~* B: q7 o! c' w! K9 N& {  bsp_GetKeyState
  bsp_SetKeyParam
  bsp_ClearKey
  bsp_DetectKey
  bsp_DetectFastIO
  bsp_KeyScan10ms
+ i3 g3 u& |9 N( H) V  bsp_KeyScan1ms
: v# a. j( ^' L
所有这些函数在本章的19.3小节都进行了详细讲解，本小节主要是把需要用户调用的三个函数做个说明。
5 h& \0 D3 E; m4 q
19.4.1 函数bsp_InitKeyHard
函数原型：

1. /*
   9 m! p3 W! @* f) Y
2. *********************************************************************************************************
   3 n8 {6 a: l1 P( Z
3. *        函 数 名: bsp_InitKey
   
4. *        功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
     S5 S- {( {7 S$ T" M  ?2 T
9. void bsp_InitKey(void)
   % F0 w2 q8 f& P
10. {
    
11.         bsp_InitKeyVar();                /* 初始化按键变量 */
    
12.         bsp_InitKeyHard();                /* 初始化按键硬件 */
    , b2 C. z9 C, U, K8 E
13. }

复制代码

" A: r1 v: r6 W函数描述：

& E" v- [" H) I' G& b: [此函数主要用于按键的初始化。

使用举例：

! b% Y, a- v. o9 B底层驱动初始化直接在bsp.c文件的函数bsp_Init里面调用即可。

3 R( X, T8 U  k# s! R/ R. x19.4.2 函数bsp_GetKey
函数原型：
2 r: G$ D( k7 \! F' V7 \
3 ?0 I3 V7 [0 m

1. /*
   
2. *********************************************************************************************************
   4 k2 _! H: J6 y9 T0 b1 w
3. *        函 数 名: bsp_GetKey
   
4. *        功能说明: 从按键FIFO缓冲区读取一个键值。
   * N1 U* r8 U4 h4 S
5. *        形    参: 无
   
6. *        返 回 值: 按键代码
   
7. *********************************************************************************************************
   8 O! j9 t' W$ b6 l) z  `' S
8. */
   
9. uint8_t bsp_GetKey(void)
   
10. {
    
11.         uint8_t ret;
    
12. 
    
13.         if (s_tKey.Read == s_tKey.Write)
    
14.         {
    % e" {5 w  I/ H" ^. z3 u* s
15.                 return KEY_NONE;
    , {2 c! x) N/ c
16.         }
    
17.         else
    
18.         {
    
19.                 ret = s_tKey.Buf[s_tKey.Read];
    
20. 
    2 O. k$ M4 E) {8 C& a$ q
21.                 if (++s_tKey.Read >= KEY_FIFO_SIZE)
    2 L5 ?5 {7 g) b
22.                 {
      I' K2 F/ R' ?% R! T
23.                         s_tKey.Read = 0;
    0 S' F& h7 h7 B( l
24.                 }
    
25.                 return ret;
    6 v/ X+ [3 A1 s6 N
26.         }
    
27. }

复制代码

函数描述：

此函数用于从FIFO中读取键值。
' M9 a% G- n# O
使用举例：
- P3 p% Y  u% B
& I! I! f8 n" S+ N' y. H# }# a调用此函数前，务必优先调用函数bsp_InitKey进行初始化。

1. /*
   " d8 y/ R7 |7 Z  V
2. *********************************************************************************************************
   % x: f& G6 P1 J2 ]: K& Y3 P$ ]
3. *        函 数 名: main
   - b' H5 ]- K% ]+ ~  N
4. *        功能说明: c程序入口
   4 |9 n* H0 e3 w9 \
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   % p- i, I9 f& C3 e* d/ e0 \; _
8. */
   
9. int main(void)
   0 c; O0 k3 l8 t- i
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    7 T4 i. z3 i& h9 d* E
12.         
    ; i7 l/ n9 X! N* _( |& E
13.         bsp_Init();                /* 硬件初始化 */
    
14.         
    9 n) [& ~8 g2 P5 }1 m
15.         /* 进入主程序循环体 */
    $ K& P( s2 q, t( e  D0 K
16.         while (1)
    . I0 c* T0 \0 O  d& P9 G
17.         {               
    
18.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    ) G1 f: A' v6 d8 t( P
19.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
20.                 if (ucKeyCode != KEY_NONE)
    + O$ F# }1 Z! K3 }+ T) F. Q) ~
21.                 {
    
22.                         switch (ucKeyCode)
    
23.                         {
    1 B5 C0 ~/ N* t9 U9 n
24.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    0 c% H+ N2 `% B" r1 b" ~3 P
25.                                         printf("K1键按下\r\n");
    
26.                                         break;
    ) X( `4 |# _7 N# O
27. 
    : x4 Y" q0 X. c% ]8 D
28.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    . T1 r8 Y; h& V7 |! Y6 T0 C: R
29.                                         printf("K2键按下\r\n");
    
30.                                         break;
    
31. 
    - a0 W; E3 G% X: \7 _
32.                                 default:
    
33.                                         /* 其它的键值不处理 */
    ' w% e' \7 W% p: B2 d
34.                                         break;
    
35.                         }
    
36.                 }
    " b( v0 S( y( U5 \5 j
37.         }
    
38. }

复制代码

19.4.3 函数bsp_KeyScan10ms
' x8 p& b. r/ x& x函数原型：

) b6 e- g7 V5 C0 q

1. /*
   # J4 {! R0 u1 R
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_KeyScan10ms
   . K( v& l- D7 l; y
4. *        功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
   
5. *        形    参: 无
   1 N. x+ _: n: t8 c  v& F; [3 T
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   ( W- Z" s9 w  p, J
9. void bsp_KeyScan10ms(void)
   5 a1 Q8 J$ l; J( v5 i
10. {
    
11.         uint8_t i;
    
12. 
    ; Q, S6 ~5 d/ a
13.         for (i = 0; i < KEY_COUNT; i++)
    - v7 v* X. }: U/ {! [5 j: \! H
14.         {
    
15.                 bsp_DetectKey(i);
    
16.         }
    
17. }

复制代码

( @! U7 ]8 x9 T6 M. V函数描述：

: v4 o3 y& @1 U此函数是按键的主处理函数，用于检测和存储按下、松手、长按等状态。
0 E) J( u, p9 q
使用举例：

调用此函数前，务必优先调用函数bsp_InitKey进行初始化。

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

  如果是裸机使用，将此函数放在bsp.c文件的bsp_RunPer10ms函数里面即可，这个函数是由滴答定时器调用的，也就是说，大家要使用按键，定时器的初始化函数bsp_InitTimer一定要调用。
! E0 g$ R9 @) F% ^  如果是RTOS使用，需要开启一个10ms为周期的任务调用函数bsp_KeyScan10ms。
- w+ ?6 Y' P  i: V! a$ n6 W% b! V
19.5 按键FIFO驱动移植和使用
$ ^+ f& M. ~! `; P* ^按键移植步骤如下：

; [, k& }" l  P9 z2 H0 f  第1步：复制bsp_key.c和bsp_key.c到自己的工程。
2 Y, h% L" b) R* v  第2步：根据自己使用的独立按键个数和组合键个数，修改几个地方。

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

复制代码

  \9 X: c4 K" N  第3步：根据使用的引脚时钟，修改下面函数：
% m2 N7 I# O) M! }+ {

1. /* 使能GPIO时钟 */
   
2. #define ALL_KEY_GPIO_CLK_ENABLE() {        \
   
3.                 __HAL_RCC_GPIOB_CLK_ENABLE();        \
   
4.                 __HAL_RCC_GPIOC_CLK_ENABLE();        \
   
5.                 __HAL_RCC_GPIOG_CLK_ENABLE();        \
   
6.                 __HAL_RCC_GPIOH_CLK_ENABLE();        \
   
7.                 __HAL_RCC_GPIOI_CLK_ENABLE();        \
   
8.         };

复制代码

  O: a" U: [! g6 s( f/ u  第4步：根据使用的具体引脚，修改如下函数，第3列参数低电平表示按下或者高电平表示按下：

1. /* GPIO和PIN定义 */
   5 P* W2 O9 c) r
2. static const X_GPIO_T s_gpio_list[HARD_KEY_NUM] = {
   3 b# k" X" J$ A4 U$ A6 r7 g: j9 A* Z
3.         {GPIOI, GPIO_PIN_8, 0},                /* K1 */
   ) R# v- r) B! S2 N
4.         {GPIOC, GPIO_PIN_13, 0},        /* K2 */
   
5.         {GPIOH, GPIO_PIN_4, 0},                /* K3 */
   % s  [' P" m; i4 j4 {
6.         {GPIOG, GPIO_PIN_2, 0},                /* JOY_U */        
   * j  F7 z6 C" S' K) g4 p
7.         {GPIOB, GPIO_PIN_0, 0},                /* JOY_D */
   
8.         {GPIOG, GPIO_PIN_3, 0},                /* JOY_L */        
   
9.         {GPIOG, GPIO_PIN_7, 0},                /* JOY_R */        
   6 q6 a$ T; `3 y' @3 S, i8 s
10.         {GPIOI, GPIO_PIN_11, 0},        /* JOY_OK */
    + L+ x, _* l) E9 G, f# {& \( M6 h
11. };   

复制代码

     
  第5步：根据使用的组合键个数，在函数IsKeyDownFunc里面添加相应个数的函数：

1.         /* 组合键 K1K2 */
   : |0 B2 _+ w. X
2.         if (_id == HARD_KEY_NUM + 0)
   - [8 Y0 C$ _0 ?9 Y
3.         {
   / Z2 H9 |2 w0 V/ N! G
4.                 if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
   
5.                 {
   
6.                         return 1;
   0 G: m0 ^- G* ]' `: \
7.                 }
   ( \( s' r  ~7 }0 T. t/ c
8.                 else
     X4 \; }1 }; ^- u9 u7 e! {/ V
9.                 {
   % w2 c6 f+ J9 `: a5 P+ G  n+ w. v/ j
10.                         return 0;
      c( T8 N) s+ k  `9 [% s  x
11.                 }
    
12.         }

复制代码

第2行ID表示HARD_KEY_NUM + 0的组合键，HARD_KEY_NUM + 1表示下一个组合键，以此类推。
! L- |: q, d1 D
另外就是，函数KeyPinActive的参数是表示检测哪两个按键，设置0的时候表示第4步里面的第1组按键，设置为1表示第2组按键，以此类推。
& _4 B8 T' `( Q& m! d4 R
' D; t( P0 _( \( B3 W  第6步：主要用到HAL库的GPIO驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
5 m$ t4 O" l' s! K4 m1 \% r  第7步：移植完整，应用方法看本章节配套例子即可。
特别注意，别忘了每10ms调用一次按键检测函数bsp_KeyScan10ms。
8 ]3 w2 `" a; T! q/ ~
! C0 K2 y, v2 ~9 j5 g. `19.6 实验例程设计框架
* _* U' b3 _8 Z0 A& [) M" Q9 O通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：
2 B. e5 M2 j# E) F
3 b0 n) k2 z0 q0 {* M8 z$ V3 k

9 l% o6 }7 [9 [) V8 S2 @; O7 z
% D& A6 w6 K* J7 x7 O7 a 1、 第1阶段，上电启动阶段：
) y' P; P+ V7 h  ]9 Y7 j1 m" l( T
这部分在第14章进行了详细说明。
. B' e, A/ g/ J0 X# D0 ~% Z; H7 n) D
) }9 Y9 e' G' I6 x$ a$ ~ 2、 第2阶段，进入main函数：

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

19.7 实验例程说明（MDK）
配套例子：
V7-002_按键检测（软件滤波，FIFO机制）
1 ~5 ^) S# p  V+ D% {
! w- r, {3 V" J* m/ N; Q. S6 p实验目的：
学习按键的按下，弹起，长按和组合键的实现。
$ G; R& _8 }. }" i. e
实验内容：
( i: H  w( }: e# R' F启动一个自动重装软件定时器，每100ms翻转一次LED2。

) W; q8 Y+ r' o! R: \+ Z9 n; X! {实验操作：
$ B( y! D: p6 T0 h9 K9 h) D3个独立按键和5向摇杆按下时均有串口消息打印。
5向摇杆的左键和右键长按时，会有连发的串口消息。
独立按键K1和K2按键按下，串口打印消息。

上电后串口打印的信息：
" F% C2 k7 B2 J
波特率 115200，数据位 8，奇偶校验位无，停止位 1
. \: p! S5 ]/ ~- {; v

; C" A* D. H/ m( S
程序设计：

/ ]5 \& F9 _  t3 z  系统栈大小分配：

: e5 ?; s+ j. f2 v
/ l, L8 ~! n6 _$ D9 I, {  RAM空间用的DTCM：
: q3 U; B/ z0 c2 e

2 d1 U4 F$ y; j9 x# Y
4 N: O; J0 f0 s. m3 B. ^  硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：

1. /*
   5 O; l& l  a- ?# l; B" n+ w
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   
6. *        返 回 值: 无
   8 Q5 s; e7 @1 _. f6 `6 ^
7. *********************************************************************************************************
   
8. */
   
9. void bsp_Init(void)
   
10. {
    1 Y6 n. o8 k# b. G; I: T- z
11.     /* 配置MPU */
    
12.         MPU_Config();
    
13.         
    ' T, Z% _! S9 u4 D9 b: h
14.         /* 使能L1 Cache */
    : h  E$ C2 i5 x- x! `
15.         CPU_CACHE_Enable();
    
16. 
    
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    / u  D5 u/ n- ~$ G- ~% o- C% W3 h) l
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
      P7 G3 U$ v$ O3 O/ }
20.            - 设置NVIV优先级分组为4。
    
21.          */
    
22.         HAL_Init();
    
23. 
    ; {1 T" k7 c( v  Z
24.         /*
    4 u" R6 J$ N% |) }
25.        配置系统时钟到400MHz
    ' _/ H$ p5 M* O5 ?- A7 \
26.        - 切换使用HSE。
    ! H, w& d- k/ h; c
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.         SystemClock_Config();
    
30. 
    ( {* o! V% X. B  B
31.         /*
    ' I' B; D8 G4 A3 ]* I+ v# H6 M
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    # ?8 T  Q$ t7 \( K' P' _
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    
36. #if Enable_EventRecorder == 1  
    5 x0 a1 `6 I- @9 J
37.         /* 初始化EventRecorder并开启 */
    " I/ l/ w" x8 H/ k$ \2 ^$ V
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    
40. #endif
    . a. X* A: c7 E% y7 {0 {
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    " H& \& s+ U( L  f. u
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

  MPU配置和Cache配置：

; }: w' }* }! V1 w0 J数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
: M: r" W# v& o. `' K' e+ f

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   " S: S/ O# Z0 k+ P) F! }
4. *        功能说明: 配置MPU
   " ~! G% |- A. U7 R
5. *        形    参: 无
   3 G1 S7 k- O  T: R( @/ z
6. *        返 回 值: 无
   ( r+ C. _6 Z; x, U
7. *********************************************************************************************************
   
8. */
   
9. static void MPU_Config( void )
   
10. {
    , C! ?) [7 \3 D. Z' u
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    1 s- ]  Z' H" x, U) H: K
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;
    
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    ( u- g+ A& ^0 X* d
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    ! \+ b2 L5 a9 B" W3 _
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    , s0 T$ x, r2 `8 _: N; i& c
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    - X2 R) K+ B; X
30.         
    
31.         
    * n+ M; M6 y' ]2 [  F2 t3 j* \
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    3 s# ~9 P4 A! K3 o3 ^
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    4 m1 f% ~0 n. Z% K0 Y0 c
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    * d- ~/ t1 v1 K* T
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ; L' I3 M1 Q0 B- G* j# d
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    , Y# {  V5 a; ~8 Q* g
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    4 W3 ~3 h1 U' I/ L1 g3 s
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    ) \2 f2 w9 ]1 [- V: S. |( ~
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    # B# k5 s0 _  O4 b. N( d
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ! T2 v/ U$ q: Q* Z6 E1 Q- z" c
44.         
    ( h) E; @% b; d7 ~* O$ r
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    
47.         /*使能 MPU */
    ! A; {2 Y4 ?, P+ P7 [4 t9 Y7 N% g6 i
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    # S7 S' q0 B; o0 O9 P: z! G" l
50. 
    
51. /*
    
52. *********************************************************************************************************
    3 ~6 Y: R( U3 S/ l8 e
53. *        函 数 名: CPU_CACHE_Enable
    
54. *        功能说明: 使能L1 Cache
    
55. *        形    参: 无
    
56. *        返 回 值: 无
    $ m* M% l: d  T2 w$ e8 g
57. *********************************************************************************************************
    
58. */
    ! i! ?% B  s% I8 ~% @" c
59. static void CPU_CACHE_Enable(void)
    
60. {
    % t1 V7 M7 `3 u. Z& ~- J5 n$ a3 p$ G
61.         /* 使能 I-Cache */
    - k. Z, R; w- i  ?% n- x
62.         SCB_EnableICache();
    9 e$ X& z) [, u" Z* }
63. 
    
64.         /* 使能 D-Cache */
    8 x8 A! i  Q' }/ c
65.         SCB_EnableDCache();
    / b3 f/ r6 p. d) j5 Q8 K, |/ V
66. }

复制代码

4 e  O" _& ]4 V, M7 S$ B: O  每10ms调用一次按键检测：

按键检测是在滴答定时器中断里面实现，每10ms执行一次检测。
. `! ]0 C2 w& E, `; t
/ s$ I: N% u: c8 @5 P8 d7 B. m

1. /*
   0 x5 W- k$ y% @' S+ v* t3 q* b
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_RunPer10ms
   
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   $ w6 t) \5 S1 Y( |* @0 P& \
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *        形    参: 无
   
7. *        返 回 值: 无
   2 [' q  y+ z2 f# a7 R- x3 j7 o
8. *********************************************************************************************************
   
9. */
   & e% ]2 P8 \1 U1 V3 u; X3 |
10. void bsp_RunPer10ms(void)
    8 N8 Y6 }* w4 R$ c0 Y* R1 b
11. {
    
12.         bsp_KeyScan10ms();
    
13. }

复制代码

  主功能：

主功能的实现主要分为两部分：

6 Q; T# w+ Y" ?) U3 `0 K 启动一个自动重装软件定时器，每100ms翻转一次LED2
按键消息的读取，检测到按下后，做串口打印。

1. /*
   
2. *********************************************************************************************************
   - f3 v0 R7 T* E7 M  X' O
3. *        函 数 名: main
   2 I& R$ d9 _4 V, J7 X. }" V
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   " t0 M# J' H* D6 W5 r* r
6. *        返 回 值: 错误代码(无需处理)
   2 f$ `2 v" V" y8 |; E0 a) q% N
7. *********************************************************************************************************
   
8. */
   
9. int main(void)
   ' K6 V/ I( I+ ]3 [
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    ; \: \* |2 X, O7 n5 J4 Y
12.         
    
13.         bsp_Init();                /* 硬件初始化 */
    & w( V& R$ `% F( w
14.         
    
15.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
16.         PrintfHelp();        /* 打印操作提示 */
    ; B3 `, v# U% L4 A$ q2 C9 F7 u
17. 
    
18. 
    . [0 P2 t) T0 h" X
19.         bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 */
    0 U* D7 ]; a! h4 t) ^
20.         
    
21.         /* 进入主程序循环体 */
    # @9 H0 j: \" y  Q; ~  u' k
22.         while (1)
    
23.         {
    $ a0 c. s' j: }# B6 N! n
24.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
25. 
    0 D: b) i" w6 ?5 Z5 {, M7 o% G
26.                 /* 判断定时器超时时间 */
    " {9 i/ d0 h2 ~" c( C3 j5 g
27.                 if (bsp_CheckTimer(0))        
    ) c' L+ H" g6 l# U  @. }6 N1 T3 a& }
28.                 {
    
29.                         /* 每隔100ms 进来一次 */  
    , e6 _1 v. D  i8 j
30.                         bsp_LedToggle(2);                        
    
31.                 }
    
32.                
    
33.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
34.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    ; H+ B" ^* s5 J- @, ], m5 d+ m
35.                 if (ucKeyCode != KEY_NONE)
    
36.                 {
    
37.                         switch (ucKeyCode)
    , [% C5 O7 d9 P2 _
38.                         {
    % O: ~& C* z5 t
39.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    ) t- M% c/ {5 X0 q  ?4 j5 j
40.                                         printf("K1键按下\r\n");
    : S4 d- F; }' L4 e! s) ]& D
41.                                         break;
    
42. 
    
43.                                 case KEY_UP_K1:                                /* K1键弹起 */
    ) ?, g( w1 j, L8 s; l: b
44.                                         printf("K1键弹起\r\n");
    1 }+ l- r8 J5 _2 @- u
45.                                         break;
    
46. 
    - j- Z+ u) M# @6 ]
47.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    
48.                                         printf("K2键按下\r\n");
    ' [2 L3 J0 i+ @& ?/ j) H& u  Z
49.                                         break;
    , r1 f) [" E, k' P5 W- Z
50. 
    + s3 T8 [) u3 i! z" s% u
51.                                 case KEY_UP_K2:                                /* K2键弹起 */
    
52.                                         printf("K2键弹起\r\n");
    + ]; S& X" m$ O
53.                                         break;
    
54. 
    7 f9 L4 s) |" o) a3 L" P1 x# _2 u
55.                                 case KEY_DOWN_K3:                        /* K3键按下 */
    
56.                                         printf("K3键按下\r\n");
    
57.                                         break;
    
58. 
    
59.                                 case KEY_UP_K3:                                /* K3键弹起 */
    7 k5 R0 t4 T3 w
60.                                         printf("K3键弹起\r\n");
    
61.                                         break;
    ' C; Y2 ^& E+ k0 g/ w$ w
62. 
    
63.                                 case JOY_DOWN_U:                        /* 摇杆UP键按下 */
    
64.                                         printf("摇杆上键按下\r\n");
    % H7 A! B3 y7 Y8 [! q
65.                                         break;
    
66. 
    
67.                                 case JOY_DOWN_D:                        /* 摇杆DOWN键按下 */
    
68.                                         printf("摇杆下键按下\r\n");
    : Z; m2 [! ^# W. Y1 w# D+ N. Z
69.                                         break;
    * A2 g% G0 R. I* |& ~6 {7 W
70. 
    
71.                                 case JOY_DOWN_L:                        /* 摇杆LEFT键按下 */
    / X$ {/ G1 b# a# f! h9 r
72.                                         printf("摇杆左键按下\r\n");
    
73.                                         break;
    
74.                                 
    
75.                                 case JOY_LONG_L:            /* 摇杆LEFT键长按 */
    ! J/ C- |2 C" D! z7 l: |$ {
76.                                         printf("摇杆左键长按\r\n");
    " A7 D3 I( D" c
77.                                         break;
    2 f, K5 ~! A5 T* Q" M% J/ _7 a
78. 
    ; x4 @* d, ~. k& b
79.                                 case JOY_DOWN_R:                        /* 摇杆RIGHT键按下 */
    - Q( t$ [0 h+ F2 n" U# u" ^) r
80.                                         printf("摇杆右键按下\r\n");
    2 H4 k) r3 S+ L! ^0 t
81.                                         break;
    
82.                                 
    3 M- P9 [  `, H6 x! x
83.                                 case JOY_LONG_R:            /* 摇杆RIGHT键长按 */
    
84.                                         printf("摇杆右键长按\r\n");
    . g4 c8 Q7 K& _
85.                                         break;
    
86. 
    
87.                                 case JOY_DOWN_OK:                        /* 摇杆OK键按下 */
    
88.                                         printf("摇杆OK键按下\r\n");
    4 w. k8 h) t. J- h
89.                                         break;
    7 K0 G7 l9 g6 q2 V& U4 \
90. 
    . {) _( d' z; Y( P0 P
91.                                 case JOY_UP_OK:                        /* 摇杆OK键弹起 */
    6 [3 n/ z+ L  `5 q( [8 e' ~
92.                                         printf("摇杆OK键弹起\r\n");
    
93.                                         break;
    
94. 
    
95.                 case SYS_DOWN_K1K2:                        /* 摇杆OK键弹起 */
    
96.                                         printf("K1和K2组合键按下\r\n");
    
97.                                         break;
      L" o) q3 e% H* m$ _+ @. f
98. 
    + n% Y: V# h7 g3 g/ B
99.                                 default:
    / r, Y5 S% @' S9 d5 E, q) q
100.                                         /* 其它的键值不处理 */
     
101.                                         break;
     
102.                         }
     
103.                
     0 V  v) t- U) y, a
104.                 }
     
105.         }
     1 S6 C1 q7 {0 r' c. p
106. }

复制代码

' Q; u! D/ p. T' E& E; h19.8 实验例程说明（IAR）
配套例子：
* Y9 F/ r& w7 c1 [1 N  s& @V7-002_按键检测（软件滤波，FIFO机制）

* W$ L  X$ p) Y$ V实验目的：
学习按键的按下，弹起，长按和组合键的实现。
' w# D: I* X- p
6 N9 `$ R7 n; x) _7 d  u0 w实验内容：
启动一个自动重装软件定时器，每100ms翻转一次LED2。
' b5 {* H: Z+ l) I6 ^8 N
实验操作：
3个独立按键和5向摇杆按下时均有串口消息打印。
5向摇杆的左键和右键长按时，会有连发的串口消息。
独立按键K1和K2按键按下，串口打印消息。

6 a. Q( A0 M7 {' f2 ]上电后串口打印的信息：
% x3 D  {# N. y
波特率 115200，数据位 8，奇偶校验位无，停止位 1

, M6 B1 Y6 E' f' v6 }6 B

; Q- [+ }: S. F  z0 d6 G" h8 x程序设计：

  系统栈大小分配：
: Q! n6 O  L8 p

  RAM空间用的DTCM：

- C' Y4 i& h4 T( g$ H4 @1 B  硬件外设初始化

/ L+ B( ^# T2 d$ y9 L硬件外设的初始化是在 bsp.c 文件实现：
) f: F/ |# Z/ t5 F/ R% l
' k" k- n6 ?4 I& e5 U/ L

1. /*
   1 \7 U7 r' b  _
2. *********************************************************************************************************
   9 z7 s  r3 b1 N/ K# i
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   3 Q" q0 ]- h& `# o- A/ z  ?
5. *        形    参：无
   
6. *        返 回 值: 无
   ( f3 m0 K6 s6 d3 ]) M& D/ e
7. *********************************************************************************************************
   
8. */
   5 {/ x# n) a8 `
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    ! e% B! y: u- _% [) J
12.         MPU_Config();
    ; I+ x- v& p& v! K
13.         
    
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    
16. 
    
17.         /*
    ( K8 w# d' o7 A9 l0 ]
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    9 h' W& v" J* u4 x
20.            - 设置NVIV优先级分组为4。
    
21.          */
    
22.         HAL_Init();
    - x8 i- _% `( ^, F+ G, {
23. 
    9 F/ S$ k$ @% p$ B0 D- Z" b
24.         /*
    ' L/ T1 D* t" h& w& u9 V# k
25.        配置系统时钟到400MHz
    4 \+ L$ k- g5 \: d6 `3 r" \
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    : `5 _& c# O6 }% H9 z1 E
29.         SystemClock_Config();
    
30. 
    7 G, X! e: e" }# x: p$ |) J7 Z
31.         /*
    , M' K. W! \* m7 p
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    : u* C/ R$ \7 S# |1 `
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    + e% I8 O- P& _/ ~5 {) b- x* s
35.         */        
    
36. #if Enable_EventRecorder == 1  
    : K( x: D7 Y$ v" a& w5 E7 f
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    1 D# L6 \* c7 N- u: i% S
39.         EventRecorderStart();
    ! N3 Z: e( z8 m& P, I
40. #endif
    / k2 d; }. o; v  r( x' ?7 g& s/ G* P
41.         
    8 ?, q5 h! H- F, D, ]
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    4 a* p% H, {/ P+ W6 |- u7 C
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

  MPU配置和Cache配置：
4 F7 Z3 i6 i9 Q& ^0 l0 H4 x5 S
4 a& Z- k4 r2 x" p; k数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

1. /*
   
2. *********************************************************************************************************
   ; C& Q; f' t1 \/ x0 v
3. *        函 数 名: MPU_Config
   9 r0 r4 G& g! {. h; h
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   - ]  G7 x( I0 ?- p) H$ o7 y$ B
8. */
   
9. static void MPU_Config( void )
   
10. {
    ; r, R" p6 G& B/ L% S% `* d
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    8 |$ u) M) ~" n# Z* f1 \5 f; v$ r
15. 
    % P( \. K0 U0 h: D6 _9 i* k
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    $ h# l  ~8 ^) I+ M: h* g
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    0 a5 Z$ W% n- e. F2 l2 a
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    
31.         
    ' d3 `: m7 E; Y3 ^( T" ^/ Q: N
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    / u( R, |/ G2 q. I: K: B, k' p) M
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    + J" i0 V( I% G! S+ u
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    8 l" U2 w9 I8 }; U! h' \
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    : V. X: ~9 A( ^2 h9 n; L) E/ m
44.         
    ) j$ U1 I# K$ d8 A$ c
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    , O* k& u& g- n) D. w* V
47.         /*使能 MPU */
    
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    # u% `) W, N3 O! H
49. }
    ( m4 j" C0 x  h# b  l2 o; C
50. 
    " D; S  l: w6 R( t, U5 v
51. /*
    / X# O. K2 ~5 n1 Q
52. *********************************************************************************************************
    
53. *        函 数 名: CPU_CACHE_Enable
    5 u' t/ p3 P$ T7 A; j, J* S
54. *        功能说明: 使能L1 Cache
    1 J) `5 W: W! Q# U( u6 l9 ^
55. *        形    参: 无
    6 K" u' o5 @" M0 m) L
56. *        返 回 值: 无
    : u, d; x; K" I( b+ n+ y
57. *********************************************************************************************************
    " d: ]) ~3 f+ r- E! Z4 U+ R
58. */
    % C% ^% J9 Y2 {
59. static void CPU_CACHE_Enable(void)
    
60. {
    6 k) V; v$ Q1 z% E1 {% f& Z
61.         /* 使能 I-Cache */
    , P6 C# y, X# v' F- S6 e
62.         SCB_EnableICache();
    
63. 
    
64.         /* 使能 D-Cache */
    
65.         SCB_EnableDCache();
    $ ?; I- g1 S3 V/ x8 ~
66. }

复制代码

9 X9 j  |& d  r2 F# z/ x* U3 T  每10ms调用一次按键检测：

, `0 p4 i3 @7 n+ \5 q9 r& s4 x- s按键检测是在滴答定时器中断里面实现，每10ms执行一次检测。

/ V9 Y! ^! o( `- J" j, m  q) o

1. /*
   
2. *********************************************************************************************************
   ( v, ^/ Y* M4 h- r* q+ T- B/ W; M! _
3. *        函 数 名: bsp_RunPer10ms
     C7 x* A# S4 T5 d* ?2 B) ]% U
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *        形    参: 无
   
7. *        返 回 值: 无
   3 P; S: m7 l3 K# p8 f
8. *********************************************************************************************************
   8 N7 ^+ _# ^( J& s5 l5 y6 w1 j
9. */
   
10. void bsp_RunPer10ms(void)
    + U/ L' Y% y& F7 H3 L' M! T- ?
11. {
    4 X1 B* @( ]! `& _* k/ f
12.         bsp_KeyScan10ms();
    
13. }

复制代码

主功能：
9 B; R' r# a% F# I$ K
主功能的实现主要分为两部分：
+ ^" N+ C6 C- V8 r* _! X" ^/ H$ [
启动一个自动重装软件定时器，每100ms翻转一次LED2
1 B7 {. h; o- k 按键消息的读取，检测到按下后，做串口打印。

1. /*
   1 w( M. H7 v& L$ D5 @- i
2. *********************************************************************************************************
   
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   # R8 [" ?6 Z$ x* e* A2 |6 @$ N
5. *        形    参: 无
   - [; M* G0 g/ I0 r, s1 r+ d! P2 |
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   % j% I) W! x* g. P" s3 {0 B& m
8. */
   : o: q  h/ G% m; I$ g  m
9. int main(void)
   
10. {
      J  t# g: z# o" A( e8 X) l6 ~1 x
11.         uint8_t ucKeyCode;                /* 按键代码 */
    $ P4 r+ l7 k1 Q4 T! F$ J6 T
12.         
    $ q; \" z' j; R* R2 H; ^
13.         bsp_Init();                /* 硬件初始化 */
    % T6 }: U! n7 g7 C" O$ P
14.         
    
15.         PrintfLogo();        /* 打印例程名称和版本等信息 */
      l3 |0 ~6 |& f; t
16.         PrintfHelp();        /* 打印操作提示 */
    8 J( h( l, c# r$ P0 a2 s" e8 q  A
17. 
    
18. 
    & T& x, p1 j9 V; K+ X
19.         bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 */
    
20.         
    
21.         /* 进入主程序循环体 */
    
22.         while (1)
    
23.         {
    
24.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    ( e6 X3 k1 H7 C
25. 
    * t- @7 V( U2 ^" x, |$ H
26.                 /* 判断定时器超时时间 */
    4 c2 @* i* k+ C- A8 b& x' `
27.                 if (bsp_CheckTimer(0))        
    
28.                 {
    
29.                         /* 每隔100ms 进来一次 */  
    + f9 S% ^$ s& Z; f1 I7 Z
30.                         bsp_LedToggle(2);                        
    
31.                 }
    
32.                
    7 e  c! R1 ?% b; B: a
33.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    / @3 ?7 J0 C# j# W9 _4 Y- Z# P& F
34.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
35.                 if (ucKeyCode != KEY_NONE)
    2 |; ^0 ]: Q1 A# I$ |( O6 x
36.                 {
    6 e& x6 J& [$ w, w" z  ^
37.                         switch (ucKeyCode)
    ( G* H4 Q+ }' T% h& C- j
38.                         {
    5 C# E6 a9 J# c# c- V
39.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    
40.                                         printf("K1键按下\r\n");
    7 @$ L- [# u' e8 A/ ?& v. W# {2 m
41.                                         break;
    
42. 
    + d$ C- N8 n! R# R; m
43.                                 case KEY_UP_K1:                                /* K1键弹起 */
    $ V6 S- f& i. C2 G  G  m1 Z  C* R5 O: Y
44.                                         printf("K1键弹起\r\n");
    5 C9 _: |( Q* F, I' P9 |+ }
45.                                         break;
    
46. 
    
47.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    : `. U) B2 U7 u3 ]1 ]& Z
48.                                         printf("K2键按下\r\n");
    
49.                                         break;
    
50. 
    
51.                                 case KEY_UP_K2:                                /* K2键弹起 */
    
52.                                         printf("K2键弹起\r\n");
    
53.                                         break;
    # ]0 D( ~" @3 g( W' D- }/ L$ H
54. 
    
55.                                 case KEY_DOWN_K3:                        /* K3键按下 */
    
56.                                         printf("K3键按下\r\n");
    
57.                                         break;
    " H7 X7 b' }7 W/ d/ k4 g) @; z
58. 
    
59.                                 case KEY_UP_K3:                                /* K3键弹起 */
    
60.                                         printf("K3键弹起\r\n");
    
61.                                         break;
    ; I" r% j$ C. `6 n/ N4 L
62. 
    4 d) B0 ]( p, q  y7 y' y
63.                                 case JOY_DOWN_U:                        /* 摇杆UP键按下 */
    1 j9 h" k2 F7 t  w8 r7 |
64.                                         printf("摇杆上键按下\r\n");
    
65.                                         break;
    
66. 
    6 I2 ]$ p! t$ K
67.                                 case JOY_DOWN_D:                        /* 摇杆DOWN键按下 */
    ' b6 v% S4 ?+ E+ J: k8 J9 x! F
68.                                         printf("摇杆下键按下\r\n");
    
69.                                         break;
      n5 P* k8 k4 D3 C3 [
70. 
    
71.                                 case JOY_DOWN_L:                        /* 摇杆LEFT键按下 */
    ( K3 K9 Q/ h1 Q# {5 b
72.                                         printf("摇杆左键按下\r\n");
    ( J* K" J- i. b* v& e! z
73.                                         break;
    
74.                                 
    
75.                                 case JOY_LONG_L:            /* 摇杆LEFT键长按 */
      A% J/ ?" e& Z" N- }# r
76.                                         printf("摇杆左键长按\r\n");
    7 D- L. ]4 r% v# d4 M
77.                                         break;
    
78. 
    
79.                                 case JOY_DOWN_R:                        /* 摇杆RIGHT键按下 */
    # _# G+ o( V% u: R( S
80.                                         printf("摇杆右键按下\r\n");
    
81.                                         break;
    5 Q0 x0 Q" A; Q2 |4 u
82.                                 
    . W# M& e: ]3 \0 P
83.                                 case JOY_LONG_R:            /* 摇杆RIGHT键长按 */
    
84.                                         printf("摇杆右键长按\r\n");
    
85.                                         break;
    
86. 
    . E3 Y) P- I& f4 X2 P( J
87.                                 case JOY_DOWN_OK:                        /* 摇杆OK键按下 */
    
88.                                         printf("摇杆OK键按下\r\n");
    & Z. s( p8 P$ ~2 P8 Y4 P/ e
89.                                         break;
    
90. 
    
91.                                 case JOY_UP_OK:                        /* 摇杆OK键弹起 */
    
92.                                         printf("摇杆OK键弹起\r\n");
    
93.                                         break;
      H) k7 n& Q! o( V; o8 [8 @* K# F
94. 
    
95.                 case SYS_DOWN_K1K2:                        /* 摇杆OK键弹起 */
    / q) o! J; ~/ }; [) p4 n* X
96.                                         printf("K1和K2组合键按下\r\n");
    1 g% j  a4 x+ q, v  a
97.                                         break;
    
98. 
    
99.                                 default:
    
100.                                         /* 其它的键值不处理 */
     
101.                                         break;
     ; s7 |. A) K  P; A, u2 \  ]
102.                         }
     ) v2 d1 m8 q' F- d; m% r
103.                
     
104.                 }
     1 w1 h# h" p( C( t& `
105.         }
     
106. }

复制代码

19.9 总结
这个方案在实际项目中已经经过千锤百炼，大家可以放心使用。建议熟练掌握其用法。
: T( U0 o- ]" S/ W: u
' C" K. Z) D  s% X
8 Z- V& X- B0 `0 Q