19.1 初学者重要提示
按键FIFO驱动扩展和移植更简单，组合键也更好用。支持按下、弹起、长按和组合键。
' H2 ?5 @1 o3 f0 ^3 e( T
+ N/ [0 w% f5 R$ y19.2 按键硬件设计
5 A% I4 `) l  C# G% Q+ G( g  LV7开发板有三个独立按键和一个五向摇杆，下面是三个独立按键的原理图：
3 E0 H* a( d6 @

) Y: G! n+ {" P6 ^- W* |- W' w1 H7 i注意，K1（S1）、K2(S2)和K3(S3)按键的上拉电阻是接在5V电压上，因为这三个按键被复用为PS/2键盘鼠标接口，而PS/2是需要5V供电的（注，V5和V6开发板做了PS/2复用，而V7没有使用，这里只是为了兼容之前的板子）。实际测试，K1、K2、K3按键和PS/2键盘是可以同时工作的。

下面是五向摇杆的原理图：

4 {# u! n. y$ b  T. V2 i

) Y- ~; p0 g1 J
通过这个硬件设计，有如下两个知识点为大家做介绍：
. g1 K. V( Y  i/ a8 g% |: z
5 e9 h  [! a! E$ j19.2.1 硬件设计
按键和CPU之间串联的电阻起保护作用。按键肯定是存在机械抖动的，开发板上面的硬件没有做硬件滤波处理，即使设计了硬件滤波电路，软件上还是需要进行滤波。

! `, u  y3 U( b% _  保护GPIO，避免软件错误将IO设置为输出，如果设置为低电平还好，如果设置输出的是高电平，按键按下会直接跟GND(低电平)连接，从而损坏MCU。
  保护电阻也起到按键隔离作用，这些GPIO可以直接用于其它实验。
6 P% r, ~- A3 Y+ o7 Y# O19.2.2 GPIO内部结构分析按键
详细的GPIO模式介绍，请参考第15章的15.3小节，本章仅介绍输入模式。下面我们通过一张图来简单介绍GPIO的结构。

5 P! b) j1 {  U# l% R

红色的线条是GPIO输入通道的信号流向，作为按键检测IO，这些需要配置为浮空输入。按键已经做了5V上拉，因此GPIO内部的上下拉电阻都选择关闭状态。
6 o$ l# F, l( B. Z; o' Q
# ]4 }3 I: w4 L/ w4 y19.3 按键FIFO的驱动设计
! Z5 }+ G0 n$ o5 Hbsp_key按键驱动程序用于扫描独立按键，具有软件滤波机制，采用FIFO机制保存键值。可以检测如下事件：
* G  H4 F( E* l, F+ y
  按键按下。
1 q% P' s0 D# P/ u; g0 q" S, G  按键弹起。
& t2 R3 A7 W/ L6 I  长按键。
  长按时自动连发。
7 a1 D! m; @' p4 s6 e  [我们将按键驱动分为两个部分来介绍，一部分是FIFO的实现，一部分是按键检测的实现。
( p6 i  w5 ]6 G( M/ I8 l3 C9 G

8 y* x) f9 ~  H: i* dbsp_key.c 文件包含按键检测和按键FIFO的实现代码。
' q5 N) v, {/ K, R
bsp.c 文件会调用bsp_InitKey()初始化函数。

' F' G, V/ L: |5 c4 a* }5 G" Q! x% s6 Zbsp.c 文件会调用bsp_KeyScan按键扫描函数。

bsp_timer.c 中的Systick中断服务程序调用 bsp_RunPer10ms。
- J" B& c+ r8 W0 R6 f# R
6 A, W: {& j' s: n* J中断程序和主程序通过FIFO接口函数进行信息传递。
, k7 e  G  ~/ C) ]( a/ Y' [6 A
函数调用关系图：

$ D, Q! [+ i& {6 t  Z

; X, d$ ^: C5 x' ]0 Z/ L8 k9 Q- s
, C0 t5 v. ?, k. ?* c19.3.1 按键FIFO的原理
FIFO是First Input First Output的缩写，先入先出队列。我们这里以5个字节的FIFO空间进行说明。Write变量表示写位置，Read变量表示读位置。初始状态时，Read = Write = 0。
. x# U$ G9 W. L( {

我们依次按下按键K1，K2，那么FIFO中的数据变为：

) S% {3 w  C- H8 Y. _2 @

如果Write！= Read，则我们认为有新的按键事件。

: i/ y" k* F' W) l. b9 Q. l$ P7 l我们通过函数bsp_GetKey读取一个按键值进行处理后，Read变量变为1。Write变量不变。
. g2 O# i& n% [. O7 {0 w

我们继续通过函数bsp_GetKey读取3个按键值进行处理后，Read变量变为4。此时Read = Write = 4。两个变量已经相等，表示已经没有新的按键事件需要处理。
% a1 c- k5 {# x
有一点要特别的注意，如果FIFO空间写满了，Write会被重新赋值为0，也就是重新从第一个字节空间填数据进去，如果这个地址空间的数据还没有被及时读取出来，那么会被后来的数据覆盖掉，这点要引起大家的注意。我们的驱动程序开辟了10个字节的FIFO缓冲区，对于一般的应用足够了。
; D$ j" K  [; s8 e
% {$ u! w6 z9 H/ m2 \* c1 Z2 a  F设计按键FIFO主要有三个方面的好处：

$ ^  p: _+ P9 }# Z7 l7 x0 u  可靠地记录每一个按键事件，避免遗漏按键事件。特别是需要实现按键的按下、长按、自动连发、弹起等事件时。
/ ?- I) P- B. H  读取按键的函数可以设计为非阻塞的，不需要等待按键抖动滤波处理完毕。
  按键FIFO程序在嘀嗒定时器中定期的执行检测，不需要在主程序中一直做检测，这样可以有效地降低系统资源消耗。
6 ]4 u* N5 E% ~- j) V/ i/ \: h! X
0 I2 `7 ]5 m1 W1 G$ o19.3.2 按键FIFO的实现
在bsp_key.h 中定了结构体类型KEY_FIFO_T。这只是类型声明，并没有分配变量空间。

1. #define KEY_FIFO_SIZE        10
   
2. typedef struct
   ! f5 w( y3 s( N# b, ?, `
3. {
   2 h+ q4 a/ j3 E, @9 ]  b" Q
4.         uint8_t Buf[KEY_FIFO_SIZE];                /* 键值缓冲区 */
   
5.         uint8_t Read;                                        /* 缓冲区读指针1 */
   
6.         uint8_t Write;                             /* 缓冲区写指针 */
   
7.         uint8_t Read2;                             /* 缓冲区读指针2 */
   , i% D  ]' Y+ f0 K. Q; u% h
8. }KEY_FIFO_T;

复制代码

% r  n$ E- N& E+ y" G在bsp_key.c 中定义s_tKey结构变量, 此时编译器会分配一组变量空间。
) k0 N, {& m4 M) T$ ~+ j
  T  y3 i% S" ~3 j! y

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

复制代码

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

7 y3 ^  f# B& G. t6 Y当检测到按键事件发生后，可以调用 bsp_PutKey函数将键值压入FIFO。下面的代码是函数的实现：

. Z5 [1 H" J( a! J. [: F7 m

1. /*
   
2. *********************************************************************************************************
   0 M5 Z* L' U+ J- y3 M
3. *        函 数 名: bsp_PutKey
   2 Z/ w) F+ D; @
4. *        功能说明: 将1个键值压入按键FIFO缓冲区。可用于模拟一个按键。
   4 ]7 J5 W* |+ i7 c) G9 y0 b
5. *        形    参: _KeyCode : 按键代码
   
6. *        返 回 值: 无
   # D' S8 V. e7 |
7. *********************************************************************************************************
   
8. */
   
9. void bsp_PutKey(uint8_t _KeyCode)
   
10. {
    
11.         s_tKey.Buf[s_tKey.Write] = _KeyCode;
    
12. 
    
13.         if (++s_tKey.Write  >= KEY_FIFO_SIZE)
    
14.         {
    
15.                 s_tKey.Write = 0;
    & j8 J8 y7 U3 N4 b0 z4 E$ _
16.         }
    
17. }

复制代码

5 c9 ^" }/ Y2 D6 v0 b2 @/ m/ [这个bsp_PutKey函数除了被按键检测函数调用外，还可以被其他底层驱动调用。比如红外遥控器的按键检测，也共用了同一个按键FIFO。遥控器的按键代码和主板实体按键的键值统一编码，保持键值唯一即可实现两套按键同时控制程序的功能。

* s4 X9 Z. o7 M! s5 c) B应用程序读取FIFO中的键值，是通过bsp_GetKey函数和bsp_GetKey2函数实现的。我们来看下这两个函数的实现：

9 g; s$ A; Z$ r- b' I* o

1. /*
   
2. *********************************************************************************************************
     V1 {% _0 J- _) S- l+ c* Y* a
3. *        函 数 名: bsp_GetKey
   
4. *        功能说明: 从按键FIFO缓冲区读取一个键值。
   
5. *        形    参:  无
   " g. ^% c0 l  I1 i) U) L3 M. l. B8 y1 D
6. *        返 回 值: 按键代码
   
7. *********************************************************************************************************
   
8. */
   
9. uint8_t bsp_GetKey(void)
   
10. {
    
11.         uint8_t ret;
    6 Y5 ~# p/ s. G! z0 I! U
12. 
    5 N: \- y# {% x+ G
13.         if (s_tKey.Read == s_tKey.Write)
    
14.         {
    
15.                 return KEY_NONE;
    
16.         }
    ' G* u% R7 d- r% G
17.         else
    5 P# c: M" M8 O5 O% Z( I3 ^$ q
18.         {
    
19.                 ret = s_tKey.Buf[s_tKey.Read];
    7 ^! I* f; G8 i, m; U3 m
20. 
    ! p& y. n, w) W- A' t1 A4 x
21.                 if (++s_tKey.Read >= KEY_FIFO_SIZE)
    
22.                 {
    . D6 h, K9 S* [- m+ {' f+ O
23.                         s_tKey.Read = 0;
    4 U% ?' a6 B- S( G, o: O
24.                 }
    
25.                 return ret;
    
26.         }
    
27. }
    " F# e4 G( r! `  P, H. M
28. 
    9 e4 T! j0 q% g
29. /*
    : D) n; H/ S! P3 d: l
30. *********************************************************************************************************
    
31. *        函 数 名: bsp_GetKey2
    
32. *        功能说明: 从按键FIFO缓冲区读取一个键值。独立的读指针。
    % N1 ]3 D( Q5 L7 R5 J
33. *        形    参:  无
    : j$ ^" T: F( s% p
34. *        返 回 值: 按键代码
    # y' @3 X$ V/ C! \6 m
35. *********************************************************************************************************
    
36. */
    , i( ~' M% D1 d" R2 N
37. uint8_t bsp_GetKey2(void)
    
38. {
    + E/ X# \, Z/ D( z  Z* `
39.         uint8_t ret;
    6 M0 L8 n' I% b6 ^
40. 
    - z3 @) b* i4 Q
41.         if (s_tKey.Read2 == s_tKey.Write)
    
42.         {
    8 J& e  g( Y9 o( G" S5 |
43.                 return KEY_NONE;
    
44.         }
    ' q' T# ]+ D0 l2 Z8 o2 Q! J
45.         else
    , d7 J' l# f/ x
46.         {
    0 F5 H  h! G6 [8 h7 q/ s% K3 x# _2 A
47.                 ret = s_tKey.Buf[s_tKey.Read2];
    
48. 
    & u0 O: V0 c6 }+ C
49.                 if (++s_tKey.Read2 >= KEY_FIFO_SIZE)
    7 x5 T' O  l3 u! d
50.                 {
    ' W' l0 r, R  U; O; g
51.                         s_tKey.Read2 = 0;
    
52.                 }
    
53.                 return ret;
    
54.         }
    
55. }

复制代码

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

1. typedef enum
   
2. {
   . v7 |& q, N0 h' S4 ^" C
3.         KEY_NONE = 0,                        /* 0 表示按键事件 */
   
4. 
   7 l( n! P. @! O" C
5.         KEY_1_DOWN,                        /* 1键按下 */
   7 e6 B0 g( T0 O5 X* N! y
6.         KEY_1_UP,                                /* 1键弹起 */
   : f0 T' Y+ A$ `4 \! M$ v% Z, ]# |+ r
7.         KEY_1_LONG,                        /* 1键长按 */
   
8. 
   - I6 ]" z5 o* q
9.         KEY_2_DOWN,                        /* 2键按下 */
   , Z; ^' \& H7 d4 \6 m
10.         KEY_2_UP,                                /* 2键弹起 */
    3 A! m$ z- H, o3 b
11.         KEY_2_LONG,                        /* 2键长按 */
    * @& M; v) L% q% D
12. 
    
13.         KEY_3_DOWN,                        /* 3键按下 */
    4 I- U+ ~% A! U8 I9 n4 F
14.         KEY_3_UP,                                /* 3键弹起 */
    7 [* J0 m* ^  b/ o, L; K& B5 n
15.         KEY_3_LONG,                        /* 3键长按 */
    
16. 
    ) t3 X, F  z" t
17.         KEY_4_DOWN,                        /* 4键按下 */
    
18.         KEY_4_UP,                                /* 4键弹起 */
    ; o/ _3 b- b- G7 M$ _  h* D
19.         KEY_4_LONG,                        /* 4键长按 */
    ' |/ b! B$ `' o6 T: }. Z" \
20. 
    
21.         KEY_5_DOWN,                        /* 5键按下 */
    
22.         KEY_5_UP,                                /* 5键弹起 */
    
23.         KEY_5_LONG,                        /* 5键长按 */
    
24. 
    
25.         KEY_6_DOWN,                        /* 6键按下 */
    
26.         KEY_6_UP,                                /* 6键弹起 */
    ) c: G8 g& {0 l) a: E( l
27.         KEY_6_LONG,                        /* 6键长按 */
    
28. 
    - w% T) d3 C/ }$ {; q# ~1 g
29.         KEY_7_DOWN,                        /* 7键按下 */
    - A, k# N8 \7 T4 A, h4 C6 E3 ?2 ?" H
30.         KEY_7_UP,                                /* 7键弹起 */
    
31.         KEY_7_LONG,                        /* 7键长按 */
    ' p0 d1 i8 r9 t3 B) J9 m  K
32. 
    0 Q6 j% h( M6 {+ I) j( t
33.         KEY_8_DOWN,                        /* 8键按下 */
    
34.         KEY_8_UP,                                /* 8键弹起 */
    
35.         KEY_8_LONG,                        /* 8键长按 */
    
36. 
    
37.         /* 组合键 */
    ; |" z4 n* v8 m: a
38.         KEY_9_DOWN,                        /* 9键按下 */
    
39.         KEY_9_UP,                                /* 9键弹起 */
    # S, x7 g5 k$ N
40.         KEY_9_LONG,                        /* 9键长按 */
    " h* @8 u3 Z/ P, Z/ Y
41. 
    
42.         KEY_10_DOWN,                        /* 10键按下 */
    
43.         KEY_10_UP,                        /* 10键弹起 */
    
44.         KEY_10_LONG,                        /* 10键长按 */
    
45. }KEY_ENUM;

复制代码

必须按次序定义每个键的按下、弹起和长按事件，即每个按键对象（组合键也算1个）占用3个数值。我们推荐使用枚举enum, 不用#define的原因：
: B7 l5 L' @5 y& z
  便于新增键值,方便调整顺序。
  使用{ } 将一组相关的定义封装起来便于理解。
) W6 |8 l: K1 ^4 O8 k9 {  编译器可帮我们避免键值重复。
/ ?9 \, ~2 Q* T5 Z5 ?7 m我们来看红外遥控器的键值定义，在bsp_ir_decode.h文件。因为遥控器按键和主板按键共用同一个FIFO，因此在这里我们先贴出这段定义代码，让大家有个初步印象。

1. /* 定义红外遥控器按键代码, 和bsp_key.h 的物理按键代码统一编码 */
   
2. typedef enum
   . j# f3 H  }. L) [9 H& G) U7 w: L1 o
3. {
   $ M+ R2 {) g% \8 S
4.         IR_KEY_STRAT         = 0x80,
   6 M) K* R9 {, j' Q: V3 ^( M. q
5.         IR_KEY_POWER         = IR_KEY_STRAT + 0x45,
   ; K: P" r. A8 [2 l, E  E' I. ]: i" j2 J
6.         IR_KEY_MENU         = IR_KEY_STRAT + 0x47,
   
7.         IR_KEY_TEST         = IR_KEY_STRAT + 0x44,
   ' i# @3 w' `4 h' s8 J
8.         IR_KEY_UP         = IR_KEY_STRAT + 0x40,
   , Y$ K* D0 J0 C1 J0 Q/ X5 v. m' o
9.         IR_KEY_RETURN        = IR_KEY_STRAT + 0x43,
   
10.         IR_KEY_LEFT        = IR_KEY_STRAT + 0x07,
    ! D# B& S2 _  _  o- K2 V
11.         IR_KEY_OK                = IR_KEY_STRAT + 0x15,
    1 Q" k2 w, `- w* i4 ?$ h  j% b
12.         IR_KEY_RIGHT        = IR_KEY_STRAT + 0x09,
    
13.         IR_KEY_0                = IR_KEY_STRAT + 0x16,
    
14.         IR_KEY_DOWN        = IR_KEY_STRAT + 0x19,
    , g& N) x$ U' D0 c
15.         IR_KEY_C                = IR_KEY_STRAT + 0x0D,
    
16.         IR_KEY_1                = IR_KEY_STRAT + 0x0C,
    * K2 v& V) s$ E0 M/ W( w* D% _; a
17.         IR_KEY_2                = IR_KEY_STRAT + 0x18,
    
18.         IR_KEY_3                = IR_KEY_STRAT + 0x5E,
    6 d* y! ^. B3 m' h6 p. h' ^4 q
19.         IR_KEY_4                = IR_KEY_STRAT + 0x08,
    
20.         IR_KEY_5                = IR_KEY_STRAT + 0x1C,
    
21.         IR_KEY_6                = IR_KEY_STRAT + 0x5A,
    
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;

复制代码

我们下面来看一段简单的应用。这个应用的功能是：主板K1键控制LED1指示灯；遥控器的POWER键和MENU键控制LED2指示灯。

; h. J9 p8 u3 R

1. #include "bsp.h"
   
2. 
   " N" o) V4 r1 \+ Z
3. int main(void)
   0 ^6 O' e" A  `' c3 m- P  Z; S
4. {
   + C* G1 i# D/ U2 e$ h2 q( O7 B
5.         uint8_t ucKeyCode;
   
6.                         
     l( D0 ^. q# H# e& }
7.         bsp_Init();
   " a4 X* J% O' U2 w8 D  {
8. 
   
9.         IRD_StartWork();        /* 启动红外解码 */
   
10. 
    % L' |1 j8 D$ B! y- H3 Y. x3 O
11.         while(1)
    
12.         {
    8 a- B' [* n. b# e4 m2 `
13.                 bsp_Idle();
    
14.                
    
15.                 /* 处理按键事件 */
    9 p3 b6 k; t3 M- B
16.                 ucKeyCode = bsp_GetKey();
    
17.                 if (ucKeyCode > 0)
    9 L1 u, u' y: y! _9 P, ~
18.                 {
    
19.                         /* 有键按下 */
    ( a% r- g# d0 C  c. X4 X: p5 f
20.                         switch (ucKeyCode)
    0 O3 M) v1 p7 \) o, n6 V7 |8 ?0 ]
21.                         {
    
22.                                 case KEY_DOWN_K1:                /* K1键按下 */
    
23.                                         bsp_LedOn(1);                /* 点亮LED1 */
    
24.                                         break;
    ! O5 |+ w4 A& C
25. 
    
26.                                 case KEY_UP_K1:                /* K1键弹起 */
    + {# N  Y, B9 K" s% O) D
27.                                         bsp_LedOff(1);        /* 熄灭LED1 */
    
28.                                         break;                                       
    
29. 
    
30.                                 case IR_KEY_POWER:                /* 遥控器POWER键按下 */
    
31.                                         bsp_LedOn(1);                /* 点亮LED2 */
    
32.                                         break;
    $ A( O: ^! U4 f, P9 }
33. 
    
34.                                 case IR_KEY_MENU:                /* 遥控器MENU键按下 */
    
35.                                         bsp_LedOff(1);        /* 熄灭LED2 */
    % p/ r2 I/ o; p1 c3 F5 _+ Z" d
36.                                         break;                                       
    5 U' s- C1 L1 z; q1 g# t
37. 
    
38.                                 case MSG_485_RX:                /* 通信程序的发来的消息 */
    # Z5 l2 A3 U! W' O( @3 F
39.                                         /* 执行通信程序的指令 */
    
40.                                         break;
    
41. 
    & e& \; Q  d* W3 g' v
42.                                 default:
    ' G, s8 _; s' }
43.                                         break;
    
44.                         }
      U/ B' w1 p/ H# d1 R5 w! J1 n/ @
45.                 }
    ' H4 ^# ^4 p  z2 j5 O
46.         }
    + ^: j# P: L- ?+ h! f6 M* v. T( B4 _
47. }

复制代码

. r# T, h- i; l看到这里，想必你已经意识到bsp_PutKey函数的强大之处了，可以将不相关的硬件输入设备统一为一个相同的接口函数。
8 j7 j5 _: @: l4 q
* z' ~, x5 W" v1 u在上面的应用程序中，我们特意添加了一段红色的代码来解说更高级的用法。485通信程序收到有效的命令后通过 bsp_PutKey（MSG_485_RX）函数可以通知APP应用程序进行进一步加工处理（比如显示接收成功）。这是一种非常好的任务间信息传递方式，它不会破坏程序结构。不必新增全局变量来做这种事情，你只需要添加一个键值代码。

对于简单的程序，可以借用按键FIFO来进行少量的信息传递。对于复杂的应用，我们推荐使用bsp_msg专门来做这种任务间的通信。因为bsp_msg除了传递消息代码外，还可以传递参数结构。
3 ?4 Z( d4 O' b) m& k& J9 Q
19.3.3 按键检测程序分析
4 b$ D/ ?. k6 m1 s在bsp_key.h 中定了结构体类型KEY_T。
9 {' R: u' @3 q

1. #define KEY_COUNT    10                           /* 按键个数, 8个独立建 + 2个组合键 */
   , v0 e2 p/ y0 [/ p- E& A
2. 
   
3. typedef struct
   ) F" h& f3 {. U/ s! g# m
4. {
   
5.         /* 下面是一个函数指针，指向判断按键手否按下的函数 */
   
6.         uint8_t (*IsKeyDownFunc)(void); /* 按键按下的判断函数,1表示按下 */
   
7. 
   
8.         uint8_t  Count;                /* 滤波器计数器 */
   
9.         uint16_t LongCount;        /* 长按计数器 */
   0 J/ |6 {+ N, Y+ Q. _; D) c/ t
10.         uint16_t LongTime;                /* 按键按下持续时间, 0表示不检测长按 */
    ! s! e3 ]3 [3 w- C5 a+ {! U
11.         uint8_t  State;                /* 按键当前状态（按下还是弹起） */
    
12.         uint8_t  RepeatSpeed;        /* 连续按键周期 */
    0 C, D) A" C* C0 N' Z( k
13.         uint8_t  RepeatCount;        /* 连续按键计数器 */
    
14. }KEY_T;

复制代码

1 n! Y$ G! }4 u7 {在bsp_key.c 中定义s_tBtn结构体数组变量。
- r  B) n) s0 r% s
) d# E0 N3 P  h6 m3 V6 _' H) q1 L

1. static KEY_T s_tBtn[KEY_COUNT];
   & m7 I& m) b" ?$ s" W" ?7 o
2. static KEY_FIFO_T s_tKey; /* 按键FIFO变量,结构体 */

复制代码

每个按键对象都分配一个结构体变量，这些结构体变量以数组的形式存在将便于我们简化程序代码行数。
* |& Q% Y' J) W3 k' L/ j0 p
, g2 U; m5 L% C% O  P使用函数指针IsKeyDownFunc可以将每个按键的检测以及组合键的检测代码进行统一管理。

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

$ V: o0 i5 r" S; a4 d: W2 W7 i7 b" G

1. /*
   ! O) v8 ]1 ^( ~* x. `- z4 Z+ v
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_InitKey
   8 p2 k# v, Y9 ]/ s, B( X, N# ]& v
4. *        功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
   
5. *        形    参: 无
   + l' G) l0 ~% N4 |% T5 z$ L* B1 R+ h
6. *        返 回 值: 无
   8 E$ E- q# j, Y; k/ j) C: ]( h5 _
7. *********************************************************************************************************
   2 z# p0 V* v; H0 v" x4 e/ @& n# T
8. */
   9 p" A2 ^9 d) i, r5 k! U4 g) L* x2 E
9. void bsp_InitKey(void)
   / V9 n- b. V' X* K' d, ?8 t
10. {
    7 P% x# v" I# i6 G- {2 q$ l5 f3 c. }
11.         bsp_InitKeyVar();                /* 初始化按键变量 */
    
12.         bsp_InitKeyHard();                /* 初始化按键硬件 */
    
13. }

复制代码

下面是bsp_InitKeyVar函数的定义：

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_InitKeyVar
   
4. *        功能说明: 初始化按键变量
   , }8 h4 Q% B* y$ |0 a' j9 f8 B
5. *        形    参:  无
   ( w' b" j! ~% J8 ?# {9 _' f
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void bsp_InitKeyVar(void)
   7 c$ J) R& W" f  y. P0 T- t* R
10. {
    6 ^  p( @' |% V; I0 B2 a5 O& p2 Y# A
11.         uint8_t i;
    
12. 
    # j. N% Z  ?$ c6 m
13.         /* 对按键FIFO读写指针清零 */
    
14.         s_tKey.Read = 0;
    0 B  s- R& Y- x# _
15.         s_tKey.Write = 0;
    3 \0 t; `  w2 _% @8 E" ~: T) ?
16.         s_tKey.Read2 = 0;
    - F( W- S6 d  l2 \: k% [9 Z
17. 
    
18.         /* 给每个按键结构体成员变量赋一组缺省值 */
    
19.         for (i = 0; i < KEY_COUNT; i++)
    + [/ Q, A! y$ n3 x. E8 N) h
20.         {
    
21.                 s_tBtn<i>.LongTime = KEY_LONG_TIME;                        /* 长按时间 0 表示不检测长按键事件 */</i>
    & O; A* s  b- M( j6 ^
22. <span style="font-style: italic;">                s_tBtn.Count = KEY_FILTER_TIME / 2;                /* 计数器设置为滤波时间的一半 */
    : _! X! K+ J  w- |5 ]
23.                 s_tBtn<span style="font-style: italic;">.State = 0;                                                /* 按键缺省状态，0为未按下 */
    , c; |, A6 L/ h: B
24.                 s_tBtn<span style="font-style: italic;">.RepeatSpeed = 0;                                        /* 按键连发的速度，0表示不支持连发 */
    
25.                 s_tBtn<i style="font-style: italic;">.RepeatCount = 0;                                        /* 连发计数器 */
    
26.      </i><span style="font-style: normal;">   }
    
27. 
    - Q9 j% \7 i& s6 X, V7 Q3 d0 R* q
28.         /* 如果需要单独更改某个按键的参数，可以在此单独重新赋值 */
    # p, n6 Z0 I8 [+ [
29.         
    
30.         /* 摇杆上下左右，支持长按1秒后，自动连发 */
    ; Q4 V' e3 Y0 E# X% t
31.         bsp_SetKeyParam(KID_JOY_U, 100, 6);
    # k9 x! l6 X! T9 `" G# M7 w* {
32.         bsp_SetKeyParam(KID_JOY_D, 100, 6);
    
33.         bsp_SetKeyParam(KID_JOY_L, 100, 6);
    
34.         bsp_SetKeyParam(KID_JOY_R, 100, 6);
    / A8 |" Z5 q1 _2 u
35. }</span></span></span></span>

复制代码

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

1. /*
   
2.         按键滤波时间50ms, 单位10ms。
   
3.         只有连续检测到50ms状态不变才认为有效，包括弹起和按下两种事件
   % u6 F+ H% X; j8 l' s# t
4.         即使按键电路不做硬件滤波，该滤波机制也可以保证可靠地检测到按键事件
   
5. */
   + V6 Z! R1 Y- m0 S5 l4 l+ K
6. #define KEY_FILTER_TIME   5
   * L( T2 I3 j# t/ k% Y
7. #define KEY_LONG_TIME     100                        /* 单位10ms， 持续1秒，认为长按事件 */

复制代码

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

1. /*
   ; Y% k3 c3 J. D4 U( n
2. *********************************************************************************************************
   
3. *        函 数 名: KeyPinActive
   
4. *        功能说明: 判断按键是否按下
   5 R, v* e: P' ?$ z$ t, D
5. *        形    参: 无
   
6. *        返 回 值: 返回值1 表示按下(导通），0表示未按下（释放）
   6 t! `) d- B- h" k' Q
7. *********************************************************************************************************
   / q- ^6 z! a/ R: Z$ c
8. */
   . R8 r8 ?, _/ Z2 v
9. static uint8_t KeyPinActive(uint8_t _id)
   
10. {
    
11.         uint8_t level;
    
12.         
    4 y0 W- N. O' m  O3 Y4 i
13.         if ((s_gpio_list[_id].gpio->IDR & s_gpio_list[_id].pin) == 0)
    
14.         {
    
15.                 level = 0;
    
16.         }
    , V. _/ u# D2 `  R6 }! N" e* P% x
17.         else
    
18.         {
    
19.                 level = 1;
    
20.         }
    ; Z+ F) |" Y. o
21. 
    8 o1 J, d! _1 @8 v" H9 ~9 {
22.         if (level == s_gpio_list[_id].ActiveLevel)
    
23.         {
    / W0 F# o( f0 Z" M# i
24.                 return 1;
    
25.         }
    4 B4 N5 W0 ~: Z, w
26.         else
    / q: S; u& m: X3 z
27.         {
    
28.                 return 0;
    . e5 h  L& l1 l. T2 S3 ^* w; A
29.         }
    1 C( R/ k+ X6 D) k) y' O
30. }
    
31. 
    5 }7 w: F5 y" W& k; a& _
32. /*
    # z3 a6 B6 q5 [/ }) k4 g
33. *********************************************************************************************************
    " Y! C% |2 l# y4 w
34. *        函 数 名: IsKeyDownFunc
    
35. *        功能说明: 判断按键是否按下。单键和组合键区分。单键事件不允许有其他键按下。
    0 z! Y, a$ Q. w7 P
36. *        形    参: 无
    
37. *        返 回 值: 返回值1 表示按下(导通），0表示未按下（释放）
    2 ?+ M7 u; [9 b2 j) m* ?
38. *********************************************************************************************************
    0 [  ]3 c7 h) r8 I/ {
39. */
    2 ?1 E( G+ e9 F$ a
40. static uint8_t IsKeyDownFunc(uint8_t _id)
    
41. {
    
42.         /* 实体单键 */
    0 B6 e1 [1 ~4 d/ s' v, n% @2 O$ X
43.         if (_id < HARD_KEY_NUM)
    
44.         {
    
45.                 uint8_t i;
    
46.                 uint8_t count = 0;
    
47.                 uint8_t save = 255;
    
48.                
    + W% |! b* [9 N2 j8 Q9 }* I
49.                 /* 判断有几个键按下 */
    
50.                 for (i = 0; i < HARD_KEY_NUM; i++)
    
51.                 {
    
52.                         if (KeyPinActive(i))
    + A' S+ j9 ~  ~' s- F# N6 C7 M+ J
53.                         {
    
54.                                 count++;
    
55.                                 save = i;
    1 j; r/ U- E. ?! p2 j9 p4 y: {4 U
56.                         }
    
57.                 }
    
58.                
    8 x) j: ?" {- {2 ~% c
59.                 if (count == 1 && save == _id)
    , ^1 r* K( T% S: k: `
60.                 {
    
61.                         return 1;        /* 只有1个键按下时才有效 */
    0 I; ?& F% M& i( T% V% y
62.                 }               
    ; B* g3 j; p2 d" _
63. 
    
64.                 return 0;
    & g4 |$ W1 Y1 ?6 I0 G; O0 T. J+ N
65.         }
    ) n) U' q# p' Y/ `# B, q% v
66.         
    
67.         /* 组合键 K1K2 */
    ( X* o8 _9 v0 ]  N' U0 P5 ?1 O
68.         if (_id == HARD_KEY_NUM + 0)
    8 [0 d8 ^: q, X
69.         {
    : T! x( ~/ }; q- s: X
70.                 if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
    
71.                 {
    
72.                         return 1;
    
73.                 }
    
74.                 else
    
75.                 {
    / L7 Z/ m- ~+ W# a! K
76.                         return 0;
    
77.                 }
    & E1 x9 L) L0 r+ y% q. J
78.         }
    5 u& o7 z. j# }5 |, f  T
79. 
    
80.         /* 组合键 K2K3 */
    4 z7 I' C6 Y6 T8 N) a
81.         if (_id == HARD_KEY_NUM + 1)
    
82.         {
    ( G4 H0 \, K, Z
83.                 if (KeyPinActive(KID_K2) && KeyPinActive(KID_K3))
    
84.                 {
    . c& d. `6 V. v! J: S& h5 h
85.                         return 1;
    
86.                 }
    
87.                 else
    5 c* l8 C) i! K8 w
88.                 {
    , d) K4 K" N2 a6 ]0 @  n
89.                         return 0;
    
90.                 }
    
91.         }
    
92. 
    " n- v6 W9 q0 m$ b
93.         return 0;
    5 g' y0 s$ a! S, m' a) C. B1 d
94. }

复制代码

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

3 A# j2 D5 U1 z0 t

1. /*
   ; g) s, N% S  x# |: V8 |
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_InitKeyHard
   6 i% s/ K) m/ |/ u
4. *        功能说明: 配置按键对应的GPIO
   8 f3 f+ q6 C+ K) q5 Y3 i
5. *        形    参:  无
   3 O( k# z( j/ T) m$ l  o- b! w
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   + Z$ |; k$ m! i7 G$ g: n
8. */
   
9. static void bsp_InitKeyHard(void)
   
10. {        
    
11.         GPIO_InitTypeDef gpio_init;
    
12.         uint8_t i;
    
13. 
    
14.         /* 第1步：打开GPIO时钟 */
    ' x/ K3 T& T4 N) \( F
15.         ALL_KEY_GPIO_CLK_ENABLE();
    
16.         
    . ]3 D$ Z) `8 u6 a: G! n
17.         /* 第2步：配置所有的按键GPIO为浮动输入模式(实际上CPU复位后就是输入状态) */
    - b( R( n, ~+ J% W
18.         gpio_init.Mode = GPIO_MODE_INPUT;                           /* 设置输入 */
    
19.         gpio_init.Pull = GPIO_NOPULL;                 /* 上下拉电阻不使能 */
    
20.         gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;  /* GPIO速度等级 */
    
21.         
    
22.         for (i = 0; i < HARD_KEY_NUM; i++)
    . |& N5 {0 H4 a" Q( K
23.         {
    + T8 _0 V: O' V2 d; g$ p2 \" N
24.                 gpio_init.Pin = s_gpio_list<span style="font-style: italic;"><span style="font-style: normal;">.pin;
    . ^. G" j& s$ _0 I5 l
25.                 HAL_GPIO_Init(s_gpio_list</span><span style="font-style: normal;">.gpio, &gpio_init);        
    
26.         }
    9 |  m& _& a( p
27. }</span></span>

复制代码

' J) T( k3 |7 U/ A/ B* a  a我们再来看看按键是如何执行扫描检测的。

按键扫描函数bsp_KeyScan10ms ()每隔10ms被执行一次。bsp_RunPer10ms函数在systick中断服务程序中执行。

1. void bsp_RunPer10ms(void)
   
2. {
   
3.         bsp_KeyScan10ms();                /* 扫描按键 */
   2 d, Z; U9 w7 X9 Y. n: G8 A: N
4. }

复制代码

bsp_KeyScan10ms ()函数的实现如下：
' V3 W2 t+ e; k
) v0 c  W6 \% U. D& X6 X

1. /*
     C4 y& g* o) r% R3 ]
2. *********************************************************************************************************
   * F$ C' ^5 ^/ r4 Z
3. *        函 数 名: bsp_KeyScan10ms
   8 ]  B& j* O: x7 x$ |- W
4. *        功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
   4 a/ x3 U: s4 U9 H5 k- U$ @
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   % @9 t/ b% o8 l/ L: j
9. void bsp_KeyScan10ms(void)
   - A7 r, }9 B9 W* q0 X. T$ n5 g
10. {
    / f9 W& j; H, }; W; |5 e( l
11.         uint8_t i;
    ! M3 H7 l* m5 x& I
12. 
    
13.         for (i = 0; i < KEY_COUNT; i++)
    
14.         {
    - C0 F0 i- s3 z
15.                 bsp_DetectKey(i);
    ' W( U; [4 A' _# Q" p, R! Y
16.         }
    
17. }

复制代码

每隔10ms所有的按键GPIO均会被扫描检测一次。bsp_DetectKey函数实现如下：
' y  e- ?9 d2 {
0 w) R, }* \. g: K' y7 w9 q: e

1. /*
   
2. *********************************************************************************************************
   $ }% D1 N2 x5 C' _- U0 E
3. *        函 数 名: bsp_DetectKey
   ) w; U4 Z: v3 ]! N8 f! I3 P
4. *        功能说明: 检测一个按键。非阻塞状态，必须被周期性的调用。
   
5. *        形    参: IO的id， 从0开始编码
   / O) }2 x/ j9 ]6 Q. ^2 B
6. *        返 回 值: 无
   ; H1 I: U" U( x
7. *********************************************************************************************************
   ' A3 M4 }' \- j9 \2 p) D# |
8. */
   
9. static void bsp_DetectKey(uint8_t i)
   
10. {
    
11.         KEY_T *pBtn;
    & o; t, W$ u4 S+ n
12. 
    
13.         pBtn = &s_tBtn<span style="font-style: italic;"><span style="font-style: normal;">;
    
14.         if (IsKeyDownFunc(i))
    
15.         {
    : z* E' H- d2 z+ s# F7 }9 Z
16.                 if (pBtn->Count < KEY_FILTER_TIME)
    
17.                 {
    
18.                         pBtn->Count = KEY_FILTER_TIME;
      l, v9 o1 _- h2 [/ K
19.                 }
    
20.                 else if(pBtn->Count < 2 * KEY_FILTER_TIME)
    + P5 W2 D% L% V' u* B0 @
21.                 {
    
22.                         pBtn->Count++;
    $ Q9 Q2 C5 e  L! y! E  y8 i
23.                 }
    ( m& K5 W; h  g+ g: X( G9 [+ M
24.                 else
    
25.                 {
    1 D0 ~; E* P2 I; s
26.                         if (pBtn->State == 0)
    # i$ I  }7 ]$ w+ p5 p- j3 I! C
27.                         {
    $ m$ n: u; ], [. n+ w8 w4 f
28.                                 pBtn->State = 1;
    
29. 
    
30.                                 /* 发送按钮按下的消息 */
    ( b9 H$ Q) R% R, J4 k% p
31.                                 bsp_PutKey((uint8_t)(3 * i + 1));
    2 H. j# d2 {2 n5 Y
32.                         }
    
33. 
    
34.                         if (pBtn->LongTime > 0)
    
35.                         {
    / O' |: _# ?( c$ Q' I- l  \! d/ r
36.                                 if (pBtn->LongCount < pBtn->LongTime)
    
37.                                 {
    
38.                                         /* 发送按钮持续按下的消息 */
    9 z6 H! a3 J9 a
39.                                         if (++pBtn->LongCount == pBtn->LongTime)
    
40.                                         {
    
41.                                                 /* 键值放入按键FIFO */
    
42.                                                 bsp_PutKey((uint8_t)(3 * i + 3));
    
43.                                         }
    
44.                                 }
    
45.                                 else
    9 [* V: m9 G  p4 M
46.                                 {
    6 A* ]4 l9 @5 M3 ]5 }7 ?
47.                                         if (pBtn->RepeatSpeed > 0)
    
48.                                         {
    
49.                                                 if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
    
50.                                                 {
    
51.                                                         pBtn->RepeatCount = 0;
    
52.                                                         /* 常按键后，每隔RepeatSpeed * 10ms发送1个按键 */
    1 {) W8 l5 W* A5 ~8 }$ ?+ k% B8 k5 ^1 B
53.                                                         bsp_PutKey((uint8_t)(3 * i + 1));
    ; f* J5 L3 e5 n: C1 b
54.                                                 }
    
55.                                         }
    
56.                                 }
    9 u% f& Q& b4 u/ r
57.                         }
    
58.                 }
    9 W/ k  W7 k' \2 n$ H& \: s
59.         }
    
60.         else
    
61.         {
    * t  D5 V) S! m, V2 L  s; ?
62.                 if(pBtn->Count > KEY_FILTER_TIME)
    , ~6 P$ q( k& p: c: g) c5 K: d
63.                 {
    0 B; H/ R7 X. B
64.                         pBtn->Count = KEY_FILTER_TIME;
    
65.                 }
    
66.                 else if(pBtn->Count != 0)
    5 u7 P$ N7 r; l: _! u, V3 t
67.                 {
    
68.                         pBtn->Count--;
    : z  o8 K! Z2 ?$ Z; x  E" }" A
69.                 }
    3 y, g2 O" v! t2 l; ~6 |
70.                 else
    
71.                 {
    
72.                         if (pBtn->State == 1)
    1 K) n- X& L! k
73.                         {
    
74.                                 pBtn->State = 0;
    
75. 
    
76.                                 /* 发送按钮弹起的消息 */
    
77.                                 bsp_PutKey((uint8_t)(3 * i + 2));
    
78.                         }
    
79.                 }
    - J& H. Q4 n0 U/ C/ [& s
80. 
    ; s5 p7 l% p' y7 y& j
81.                 pBtn->LongCount = 0;
    ' l. U0 g2 h# h7 _$ Q* A
82.                 pBtn->RepeatCount = 0;
    . |6 q( g- N# V1 D1 l7 U' `
83.         }
    + b0 @' d; ]$ A5 S8 A
84. }</span></span>

复制代码

对于初学者，这个函数看起来比较吃力，我们拆分进行分析。
6 r1 W! S2 ^, j7 m$ b: N! c

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

复制代码

读取相应按键的结构体地址，程序里面每个按键都有自己的结构体。
+ U( D, H8 K! R, C
" Y6 y$ {: u9 n  I0 T

1. static KEY_T s_tBtn[KEY_COUNT];
   ) F) o5 ~  I5 f
2. if (IsKeyDownFunc(i))
   
3. {
   
4.         这个里面执行的是按键按下的处理
   
5. }
   6 h5 j% |' v# X4 r- T; @( [
6. else
   0 P5 K( S( o6 S* o! Z/ u4 m! r
7. {
   
8.         这个里面执行的是按键松手的处理或者按键没有按下的处理
   
9. }

复制代码

0 L+ D. h$ Y2 I# V; N) i( T0 p执行函数IsKeyDownFunc(i)做按键状态判断。
7 D) k' k" p3 g$ z+ I: C, X0 E* U. e
4 o' Z) p* e* ~! w

1. /*
   
2. **********************************************************************************
   0 G9 k6 V% K7 R
3. 下面这个if语句主要是用于按键滤波前给Count设置一个初值，前面说按键初始化的时候
   
4. 已经设置了Count = KEY_FILTER_TIME/2
   1 ?. _4 J9 C, Z" B  f
5. **********************************************************************************
   
6. */
   
7. if (pBtn->Count < KEY_FILTER_TIME)
   & H7 @3 `. I8 n& S+ ~0 r
8. {
   
9.     pBtn->Count = KEY_FILTER_TIME;
   
10. }
    + c  T7 R, I& T6 z$ K7 ?+ F- H1 v
11. 
    
12. /*
    
13. **********************************************************************************
    
14. 这里实现KEY_FILTER_TIME时间长度的延迟
    
15. **********************************************************************************
    ' u: Z- W! K4 M4 j/ `! e
16. */
    
17. else if(pBtn->Count < 2 * KEY_FILTER_TIME)
    
18. {
    5 \6 g. F( i0 ?* B9 j* i4 n. W
19.     pBtn->Count++;
    
20. }
    
21. /*
    & |# T8 P$ i9 P" q( `
22. **********************************************************************************
    
23. 这里实现KEY_FILTER_TIME时间长度的延迟
    
24. **********************************************************************************
    6 k4 W8 p' s) D! o5 \, r
25. */
    % H& K2 ?' B4 v  {( m$ R. ?
26. else
    
27. {
    
28. /*
    / D$ r# N. ~# W$ k
29. **********************************************************************************
    6 n5 F: K" Y3 {. X* `  t6 @+ w
30. 这个State变量是有其实际意义的，如果按键按下了，这里就将其设置为1，如果没有按下这个
    
31. 变量的值就会一直是0，这样设置的目的可以有效的防止一种情况的出现：比如按键K1在某个
    
32. 时刻检测到了按键有按下，那么它就会做进一步的滤波处理，但是在滤波的过程中，这个按键
    / W; F2 G" Y2 \7 P- S2 K( D, I+ a
33. 按下的状态消失了，这个时候就会进入到上面第二步else语句里面，然后再做按键松手检测滤波
    
34. ，滤波结束后判断这个State变量，如果前面就没有检测到按下，这里就不会记录按键弹起。
    
35. **********************************************************************************
    + k5 a" S" e0 \$ E
36. */
    5 `: I# g% K/ w0 H7 C7 B/ ?" G
37.     if (pBtn->State == 0)
    
38.     {
    
39.         pBtn->State = 1;
    9 \' S! L7 }: {$ d# o9 p5 ^* n
40. 
    
41.         /* 发送按钮按下的消息 */
    ! R, a0 @( m5 T! y* {8 ?9 {
42.         bsp_PutKey((uint8_t)(3 * i + 1));
    5 H9 x' `$ T0 l. K
43.     }
    - c1 _( t9 g6 z/ `
44. 
    
45.     if (pBtn->LongTime > 0)
    
46.     {
    9 z7 n) M' c$ N6 d5 L& I1 `! z
47.         if (pBtn->LongCount < pBtn->LongTime)
    
48.         {
    
49.             /* 发送按钮持续按下的消息 */
    , b3 @6 s. h  i' Y" O* Z4 p, O1 ]# q
50.             if (++pBtn->LongCount == pBtn->LongTime)
    
51.             {
    ; w3 E. w6 W3 Q3 J, q! ]
52.                 /* 键值放入按键FIFO */
    / [3 q; s8 A+ o& p- T9 c* x4 e
53.                 bsp_PutKey((uint8_t)(3 * i + 3));
    
54.             }
    
55.         }
    
56.         else
    
57.         {
    : u, l& k7 |  O: p9 i' X9 o
58.             if (pBtn->RepeatSpeed > 0)
    
59.             {
    
60.                 if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
    1 \$ H" i) t& }( }) }' j: |
61.                 {
    ! c# \: o# h, ~
62.                     pBtn->RepeatCount = 0;
    
63.                     /* 长按键后，每隔10ms发送1个按键 */
    
64.                     bsp_PutKey((uint8_t)(3 * i + 1));
    
65.                 }
    
66.             }
    
67.         }
    
68.     }
    
69. }

复制代码

19.3.4 按键检测采用中断方式还是查询方式
检测按键有中断方式和GPIO查询方式两种。我们推荐大家用GPIO查询方式。
$ J8 ~' E4 G' X& r3 @
2 @, b& a$ k+ \  i$ E. \' x从裸机的角度分析

) q; `' H0 W  o中断方式：中断方式可以快速地检测到按键按下，并执行相应的按键程序，但实际情况是由于按键的机械抖动特性，在程序进入中断后必须进行滤波处理才能判定是否有效的按键事件。如果每个按键都是独立的接一个IO引脚，需要我们给每个IO都设置一个中断，程序中过多的中断会影响系统的稳定性。中断方式跨平台移植困难。

查询方式：查询方式有一个最大的缺点就是需要程序定期的去执行查询，耗费一定的系统资源。实际上耗费不了多大的系统资源，因为这种查询方式也只是查询按键是否按下，按键事件的执行还是在主程序里面实现。
2 Z$ o0 c: `3 _4 Z$ k
) F4 Q" Y  _/ Y从OS的角度分析

中断方式：在OS中要尽可能少用中断方式，因为在RTOS中过多的使用中断会影响系统的稳定性和可预见性（抢占式调度的OS基本没有可预见性）。只有比较重要的事件处理需要用中断的方式。
+ i1 ?. F  w+ }
查询方式：对于用户按键推荐使用这种查询方式来实现，现在的OS基本都带有CPU利用率的功能，这个按键FIFO占用的还是很小的，基本都在1%以下。

19.4 按键板级支持包（bsp_key.c）
: g. j1 e1 S$ C  y: s按键驱动文件bsp_key.c主要实现了如下几个API：

  KeyPinActive
  IsKeyDownFunc
& a4 Q; ^1 F( E5 {  bsp_InitKey
  bsp_InitKeyHard
8 M* |0 i$ G( r  bsp_InitKeyVar
  bsp_PutKey
! ]# ^& a* l) D4 l1 s7 E  bsp_GetKey
4 z  E6 D; c: i1 ]0 o  bsp_GetKey2
  bsp_GetKeyState
6 i, {4 V  Z$ \+ S1 e  bsp_SetKeyParam
  bsp_ClearKey
" i* Q: G6 ~( U  bsp_DetectKey
  bsp_DetectFastIO
  bsp_KeyScan10ms
  bsp_KeyScan1ms
2 j. R! Y6 W  {+ d- S; p
所有这些函数在本章的19.3小节都进行了详细讲解，本小节主要是把需要用户调用的三个函数做个说明。
/ i/ f. g! h3 T6 l4 _1 i
19.4.1 函数bsp_InitKeyHard
1 L) @! {& g- W8 f5 |  P函数原型：
0 K: _0 r: A! }7 J& P! z. D* [0 @

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_InitKey
   
4. *        功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   $ c3 g7 P4 f( u( W% y
7. *********************************************************************************************************
   & q; R1 d8 d$ I4 m
8. */
   
9. void bsp_InitKey(void)
   & h0 @; W- C- G' Q+ a* |% ~5 ?
10. {
    
11.         bsp_InitKeyVar();                /* 初始化按键变量 */
    
12.         bsp_InitKeyHard();                /* 初始化按键硬件 */
    
13. }

复制代码

) p- @( t$ x7 z: w- a' \" A函数描述：

; v! a; I7 t% j- W2 ?! q此函数主要用于按键的初始化。

使用举例：

底层驱动初始化直接在bsp.c文件的函数bsp_Init里面调用即可。

; d- ~. |0 D& ~19.4.2 函数bsp_GetKey
函数原型：
  j1 \: W- Z4 `% c
7 o2 M4 h$ ~- F$ v

1. /*
   4 w  a  p, n6 u1 k- ?
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_GetKey
   
4. *        功能说明: 从按键FIFO缓冲区读取一个键值。
   
5. *        形    参: 无
   
6. *        返 回 值: 按键代码
   
7. *********************************************************************************************************
   
8. */
   
9. uint8_t bsp_GetKey(void)
   
10. {
    2 U1 O) K% `- }
11.         uint8_t ret;
    ! ?- ]& l6 l" O# _, n, d% M. X4 V
12. 
    : c& `( w: k* Q1 C8 f% m" Y
13.         if (s_tKey.Read == s_tKey.Write)
    
14.         {
    
15.                 return KEY_NONE;
    ( ]+ o1 _7 Z  D
16.         }
    . p: k$ N) E6 V9 w/ _
17.         else
    6 D3 t! ^' ?- v- G
18.         {
    9 n# ?" T0 c( O4 |* N3 n
19.                 ret = s_tKey.Buf[s_tKey.Read];
    
20. 
    ) C. A, ?0 t- A& Q
21.                 if (++s_tKey.Read >= KEY_FIFO_SIZE)
    
22.                 {
    . t6 L, l% ^5 ~+ M' t! [
23.                         s_tKey.Read = 0;
    
24.                 }
    ' O, Y- _# v6 d5 ~
25.                 return ret;
    
26.         }
    
27. }

复制代码

函数描述：

* ~" |- B0 a: d此函数用于从FIFO中读取键值。

! ?  S5 U; z; E1 w2 X* U# X使用举例：

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

6 l" g) m) B. j) x* P1 \' M

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: main
   ; O$ y0 W4 Q5 Y
4. *        功能说明: c程序入口
   6 o4 z  ~" f" ^! v
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   $ X% R) y2 j/ d+ N) d
8. */
   
9. int main(void)
   * l1 _6 M& U. H( n" m1 A" t
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    
12.         
    + t" l, I8 G4 @9 d* k( `+ ?6 U4 R
13.         bsp_Init();                /* 硬件初始化 */
    
14.         
    4 P4 x! R" X4 Q5 C  s
15.         /* 进入主程序循环体 */
    ) f. P' D! d# W5 L' k3 ~* s6 `, K( b
16.         while (1)
    3 [5 `7 p- a9 r2 E1 q* B: Q
17.         {               
    5 |) Q( c" b) B+ v# T
18.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    * \' \& }7 b( e; F- H
19.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    # p* E3 o( e2 Q' y" f& Z" l* {
20.                 if (ucKeyCode != KEY_NONE)
    
21.                 {
    / C" c. Q* j- I9 u) y
22.                         switch (ucKeyCode)
    + S% l" |1 N5 y' @1 ^' s
23.                         {
    ) T9 s% H0 o' ?( O* U. a$ n; o
24.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    
25.                                         printf("K1键按下\r\n");
    
26.                                         break;
    
27. 
    3 Z  T: F0 c- W1 Q/ m* a& D
28.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    
29.                                         printf("K2键按下\r\n");
    ; w" u, C4 q0 j, t3 M6 a  G: }& B7 U
30.                                         break;
    
31. 
    
32.                                 default:
    5 J& Q7 y' {& D8 P2 K
33.                                         /* 其它的键值不处理 */
    5 E. [( U& c/ L% {: G. ~0 E$ O! d
34.                                         break;
    4 ]8 }; Q6 W1 n$ i/ o
35.                         }
    
36.                 }
    
37.         }
    6 b9 N" T) \; q  Y& B7 A1 N! ~
38. }

复制代码

19.4.3 函数bsp_KeyScan10ms
函数原型：

1. /*
   , m" v- _. o) F: M$ V
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_KeyScan10ms
   1 ~: K5 [- D/ z* M
4. *        功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
   - B- R& f2 l1 m' q3 v4 O
5. *        形    参: 无
   
6. *        返 回 值: 无
   0 w# K: X* \: ~- h' `; P1 b
7. *********************************************************************************************************
   
8. */
   5 `/ p8 V5 c1 p+ @" d% \
9. void bsp_KeyScan10ms(void)
   
10. {
    5 a2 B4 a+ m, J: m" N1 m6 P
11.         uint8_t i;
    , I8 i& q- q8 a/ `% p$ X
12. 
    
13.         for (i = 0; i < KEY_COUNT; i++)
    
14.         {
    + Z% K9 `# `- i- P8 l' C/ \
15.                 bsp_DetectKey(i);
    & l4 Z+ x/ @1 }" x7 |; E
16.         }
    3 _6 ]: B, Z- \
17. }

复制代码

函数描述：

6 E: Q) M2 }0 D此函数是按键的主处理函数，用于检测和存储按下、松手、长按等状态。
# f$ K& G% ]# z
1 M# Q* Q5 ^% K2 w. j3 |使用举例：
" ]$ n' a6 P9 s8 n" g4 m9 Y+ _
调用此函数前，务必优先调用函数bsp_InitKey进行初始化。
5 P& e3 ^2 U, m3 S* a
另外，此函数需要周期性调用，每10ms调用一次。

3 X9 h' ?/ _/ I" B8 _8 |9 n; L/ _5 ~( N  如果是裸机使用，将此函数放在bsp.c文件的bsp_RunPer10ms函数里面即可，这个函数是由滴答定时器调用的，也就是说，大家要使用按键，定时器的初始化函数bsp_InitTimer一定要调用。
  如果是RTOS使用，需要开启一个10ms为周期的任务调用函数bsp_KeyScan10ms。
- \* \7 M2 Q9 p% H: ^
& Z+ x/ V. |) Z0 U3 E: {' E19.5 按键FIFO驱动移植和使用
/ B- d1 z& ]  y5 m按键移植步骤如下：

: q  e" I1 G. p  第1步：复制bsp_key.c和bsp_key.c到自己的工程。
  第2步：根据自己使用的独立按键个数和组合键个数，修改几个地方。
* \# y9 ?" F  h) {/ S/ l

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

复制代码

  第3步：根据使用的引脚时钟，修改下面函数：
. [* F4 ^' v* d/ k' N& A( _2 S' Y" t0 Z

1. /* 使能GPIO时钟 */
   ! G1 J, f: s$ p! ?; O' q; A& I
2. #define ALL_KEY_GPIO_CLK_ENABLE() {        \
   
3.                 __HAL_RCC_GPIOB_CLK_ENABLE();        \
   , u, A% Y9 Q0 n: M
4.                 __HAL_RCC_GPIOC_CLK_ENABLE();        \
   
5.                 __HAL_RCC_GPIOG_CLK_ENABLE();        \
   / y) L' Q4 I& k  n' j  y- X
6.                 __HAL_RCC_GPIOH_CLK_ENABLE();        \
   ; r( C0 K; t* I+ E
7.                 __HAL_RCC_GPIOI_CLK_ENABLE();        \
   / `$ M* b! I: V) R3 c2 A
8.         };

复制代码

  第4步：根据使用的具体引脚，修改如下函数，第3列参数低电平表示按下或者高电平表示按下：
% D0 B7 K+ d( u& \& I' F

1. /* GPIO和PIN定义 */
   
2. static const X_GPIO_T s_gpio_list[HARD_KEY_NUM] = {
   
3.         {GPIOI, GPIO_PIN_8, 0},                /* K1 */
   
4.         {GPIOC, GPIO_PIN_13, 0},        /* K2 */
   , d  A" H# w' z: s6 e
5.         {GPIOH, GPIO_PIN_4, 0},                /* K3 */
   
6.         {GPIOG, GPIO_PIN_2, 0},                /* JOY_U */        
   - ]& l/ a! \" t$ D9 h( }
7.         {GPIOB, GPIO_PIN_0, 0},                /* JOY_D */
   6 r2 |. U; a* Y1 Y1 C
8.         {GPIOG, GPIO_PIN_3, 0},                /* JOY_L */        
   
9.         {GPIOG, GPIO_PIN_7, 0},                /* JOY_R */        
   7 {/ Z: a, X% g' P; l3 d
10.         {GPIOI, GPIO_PIN_11, 0},        /* JOY_OK */
    
11. };   

复制代码

     
0 e/ z) b" A- V, T$ r  第5步：根据使用的组合键个数，在函数IsKeyDownFunc里面添加相应个数的函数：

1.         /* 组合键 K1K2 */
   & Y- M4 r3 B. R* J9 [1 }3 P' e) \
2.         if (_id == HARD_KEY_NUM + 0)
   
3.         {
   7 c: w8 P$ K3 e
4.                 if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
   
5.                 {
   
6.                         return 1;
   7 I% V6 F3 T" D. [3 s5 |% R6 C" F! V# Q
7.                 }
   
8.                 else
   
9.                 {
   
10.                         return 0;
    
11.                 }
    9 x: k8 H! v6 ]6 G( V/ Z
12.         }

复制代码

第2行ID表示HARD_KEY_NUM + 0的组合键，HARD_KEY_NUM + 1表示下一个组合键，以此类推。
# R. G3 H5 H$ c
另外就是，函数KeyPinActive的参数是表示检测哪两个按键，设置0的时候表示第4步里面的第1组按键，设置为1表示第2组按键，以此类推。
" g  a" ]& L; ~: [/ M
  第6步：主要用到HAL库的GPIO驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
  第7步：移植完整，应用方法看本章节配套例子即可。
特别注意，别忘了每10ms调用一次按键检测函数bsp_KeyScan10ms。

19.6 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：
" ]% o" J1 r; M
) M5 I! M' d% b) ^6 s

1、 第1阶段，上电启动阶段：
* }/ g* l$ P8 d, q! P7 y- c
0 C8 f# a4 Q( w5 f. K; _这部分在第14章进行了详细说明。

2、 第2阶段，进入main函数：
( n* s5 [4 i  B) ?2 ]% c- h
, W: V0 }% |& c; d  第1部分，硬件初始化，主要是MPU、Cache、HAL库、系统时钟、滴答定时器、按键等。
  _' x0 W7 Y8 l- N  第2部分，应用程序设计部分，实现了一个按键应用。
  第3部分，按键扫描程序每10ms在滴答定时中断执行一次。
0 C* m0 b0 n" b4 I% w
3 I$ T- y; G. B5 X: C, ^% V19.7 实验例程说明（MDK）
6 L; R( l- o7 d7 [- X0 h; c2 Y; [2 r- k配套例子：
V7-002_按键检测（软件滤波，FIFO机制）
1 H( z4 g8 r3 _* |. E$ C
实验目的：
学习按键的按下，弹起，长按和组合键的实现。

实验内容：
启动一个自动重装软件定时器，每100ms翻转一次LED2。
* e5 }- `% N: A$ v- b
实验操作：
3个独立按键和5向摇杆按下时均有串口消息打印。
2 W3 A5 y" T! \' f5向摇杆的左键和右键长按时，会有连发的串口消息。
独立按键K1和K2按键按下，串口打印消息。

4 S" X" S% j/ k& _; u上电后串口打印的信息：

" l' a8 ^& T" w" r* F波特率 115200，数据位 8，奇偶校验位无，停止位 1

程序设计：

  系统栈大小分配：
" Y, m# D% t1 y( x- e' k: n& Q

  RAM空间用的DTCM：

7 _7 A: ~7 I& m' O# f' b) d

9 w: z4 E8 l  Z! X- Y
  硬件外设初始化
3 t+ c% f5 F- G' O+ ^% a- a
硬件外设的初始化是在 bsp.c 文件实现：
+ }5 d) B: w% W

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   ! O- l5 _8 W0 O3 h0 Z! o
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   4 A. V% R4 ?! y- J5 m$ |" |
8. */
   : K/ q* b8 D4 Z1 x( g
9. void bsp_Init(void)
   : g. g* l9 Q2 I( u  j  r
10. {
    
11.     /* 配置MPU */
    
12.         MPU_Config();
    
13.         
    & }) h7 R4 [8 m/ ]# K" ?8 \
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    
16. 
    1 Y1 }3 C6 b* o8 \+ K4 q" `& j
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    1 ?* I) {1 g8 @; D6 c6 |) K5 X( g
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    # J( [; ^! v% Y5 m, W4 b! T  r, K
20.            - 设置NVIV优先级分组为4。
    
21.          */
    6 k7 M  N7 B: i: ?+ l
22.         HAL_Init();
    
23. 
    
24.         /*
    8 q. x% p* l  S2 E. Y
25.        配置系统时钟到400MHz
    4 r6 F  K' W" A6 |; [5 g( B- n
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    % @4 e' K/ B  l4 u, ^& w: X0 G& U6 n; m
28.     */
    
29.         SystemClock_Config();
    
30. 
      t: K  l; H" @6 k! ?4 T
31.         /*
    ! f: P2 k" I. O& u# Z
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    : G" {! ^1 i5 c/ p1 t
36. #if Enable_EventRecorder == 1  
    1 [, P$ g9 f# X7 M  w
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    3 S- d  n: Y$ j) r. x: s2 D
39.         EventRecorderStart();
    + T$ g  c! M% s2 e2 {8 x
40. #endif
    6 c+ a7 o# p  A7 k7 r
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    9 y; x; Z, D: W5 m
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    ) g$ l. W; _7 x9 |# j* M
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

  MPU配置和Cache配置：
% {6 w/ U8 S+ G, y* |& _$ |9 H
数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
) T- ?7 C5 t7 [( y# I9 m
; o/ F! }$ Y, o3 x, t

1. /*
   
2. *********************************************************************************************************
   1 x6 `! x. Z0 [7 R, y' a! C
3. *        函 数 名: MPU_Config
   2 p& s+ w8 l, x
4. *        功能说明: 配置MPU
   + m2 `# k6 F; G) Z$ l
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   $ S# n+ h) ?5 Q7 B- W1 n
8. */
   
9. static void MPU_Config( void )
   0 `9 t  d7 t* R: ?
10. {
    2 E7 G; H9 ?: w5 f
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    ; a& @/ R) {) R+ J
12. 
    
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    6 b  @& x- n; O+ {3 U
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ; I6 x+ d5 a* ?9 L
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    9 |; p+ Q/ H; W+ W+ ]
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    9 j+ v$ ~# @/ z7 v
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    " _+ E0 B' C- L
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    * ^& T, c; w: D( v/ X" K9 f. ~% f
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    / y9 r& W5 r, a* Z
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    4 [7 N( z3 n# Q( m# O
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    6 D' R: V" a. u. f; h, ?6 p. {
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    : I& i6 _7 K" T  ?/ r! W
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    2 |: O; H2 h1 J  _* ?& Q8 ]
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    " y! x# f8 [4 q: O( E* ?( O
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    % y" ?/ }! w" i! Z( h% G& h$ I
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    6 h! E: O8 ]5 V8 D' j8 ~0 e
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    
47.         /*使能 MPU */
    
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    
50. 
    
51. /*
    
52. *********************************************************************************************************
    + @* z: j+ L2 H
53. *        函 数 名: CPU_CACHE_Enable
    
54. *        功能说明: 使能L1 Cache
    
55. *        形    参: 无
    
56. *        返 回 值: 无
    
57. *********************************************************************************************************
    1 L& q1 ?" h9 v6 h1 _8 a
58. */
    
59. static void CPU_CACHE_Enable(void)
    
60. {
    
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    
63. 
    4 @" w% S5 e* d% _( O
64.         /* 使能 D-Cache */
    
65.         SCB_EnableDCache();
    ; H$ f+ |' J( U$ ^& t; D
66. }

复制代码

  每10ms调用一次按键检测：
3 Y6 n, Z7 x3 [# u
& j' o  f( O# l/ r3 H+ K. x$ c按键检测是在滴答定时器中断里面实现，每10ms执行一次检测。

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_RunPer10ms
   0 K  Z. r- \# h/ u' e: ?. k4 T
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   6 t6 ]" h+ l! V+ A
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *        形    参: 无
   
7. *        返 回 值: 无
   
8. *********************************************************************************************************
   $ D6 {: b& c0 I0 o. u7 D% M, }
9. */
   
10. void bsp_RunPer10ms(void)
    
11. {
    ! L; a2 Z% g- h' \8 Z* i. T
12.         bsp_KeyScan10ms();
    
13. }

复制代码

& V8 o$ \3 c( |% y) f* i2 Z8 A  主功能：
6 W4 x) R/ C/ i
主功能的实现主要分为两部分：
7 z3 k. z# Q  v' E5 s6 n4 F
启动一个自动重装软件定时器，每100ms翻转一次LED2
* }/ @- ~7 N: [' z, ~. [6 f" [ 按键消息的读取，检测到按下后，做串口打印。
; l) S( Q4 o5 {1 V2 f# ?  v

1. /*
   
2. *********************************************************************************************************
   % j! p4 w( `# O" w
3. *        函 数 名: main
   & J+ q# p; Q) |' ~, H
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   . K3 X& v" c$ f. t
9. int main(void)
   3 s! }( X( b" A, F! z
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    
12.         
    $ n1 e1 B; `8 t) E! t* @. L
13.         bsp_Init();                /* 硬件初始化 */
    
14.         
    5 r+ k5 P( O8 N* I6 x# n3 q7 V
15.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
16.         PrintfHelp();        /* 打印操作提示 */
    
17. 
    
18. 
    " p' `( H: Q" J  C& Q
19.         bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 */
    
20.         
    
21.         /* 进入主程序循环体 */
    
22.         while (1)
    * Q' A' Y' f, f' c2 H! k
23.         {
    % A4 G) s7 M& S; c( c) S
24.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    ; p0 b) c) e2 r. t9 g; v
25. 
    
26.                 /* 判断定时器超时时间 */
    7 B  o" K1 H; M- b( A- o2 H
27.                 if (bsp_CheckTimer(0))        
    1 J1 b# r. d' F, I& h
28.                 {
    
29.                         /* 每隔100ms 进来一次 */  
    
30.                         bsp_LedToggle(2);                        
    
31.                 }
    
32.                
    - m5 n7 E. A& Z% S7 K, @! U
33.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
34.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
35.                 if (ucKeyCode != KEY_NONE)
    * M& ?0 X8 Y9 h7 l' W
36.                 {
    
37.                         switch (ucKeyCode)
    + A+ b% e# @. G2 H3 m
38.                         {
    
39.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    5 R! g$ {) i5 G5 R7 a
40.                                         printf("K1键按下\r\n");
    
41.                                         break;
    
42. 
      e- c% O( Y, D" Z6 _& h0 D
43.                                 case KEY_UP_K1:                                /* K1键弹起 */
    
44.                                         printf("K1键弹起\r\n");
    4 R/ ]6 q) U- T, Z9 b
45.                                         break;
    , z1 n/ p* N! \  L; E
46. 
    # M- v5 t1 F- l/ H/ a, J: j
47.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    3 L/ e$ }) U) j$ s* V$ h' O2 h- S
48.                                         printf("K2键按下\r\n");
    
49.                                         break;
    + Q" h! g* Z3 P- C! t, l
50. 
    ) Z' }+ Z+ h) e% S
51.                                 case KEY_UP_K2:                                /* K2键弹起 */
    
52.                                         printf("K2键弹起\r\n");
    ) v, K2 ]/ x) W! ]
53.                                         break;
    2 D) b; K" W- r& I; L& z' r
54. 
    4 B& Z1 X- s# x+ H
55.                                 case KEY_DOWN_K3:                        /* K3键按下 */
    : j" ?6 D8 P. p. m3 w& o3 R# c
56.                                         printf("K3键按下\r\n");
    
57.                                         break;
    
58. 
    ) L1 }( W! {+ g
59.                                 case KEY_UP_K3:                                /* K3键弹起 */
    
60.                                         printf("K3键弹起\r\n");
    
61.                                         break;
    5 k; m9 t* P- J
62. 
    1 G) m& E* g$ _. x& u
63.                                 case JOY_DOWN_U:                        /* 摇杆UP键按下 */
    8 J& J. }* w4 [- s
64.                                         printf("摇杆上键按下\r\n");
    
65.                                         break;
    
66. 
    3 @  w3 R9 ]( Y# i4 m& s' X1 u- f
67.                                 case JOY_DOWN_D:                        /* 摇杆DOWN键按下 */
    
68.                                         printf("摇杆下键按下\r\n");
    / E. V' M1 x+ H) V; i5 w& g
69.                                         break;
    
70. 
      n1 o" b% d, f0 v7 A
71.                                 case JOY_DOWN_L:                        /* 摇杆LEFT键按下 */
    
72.                                         printf("摇杆左键按下\r\n");
    ! c) o1 a/ a+ J
73.                                         break;
    
74.                                 
    
75.                                 case JOY_LONG_L:            /* 摇杆LEFT键长按 */
    
76.                                         printf("摇杆左键长按\r\n");
    
77.                                         break;
    
78. 
    7 J! j+ |' T1 }/ L; E
79.                                 case JOY_DOWN_R:                        /* 摇杆RIGHT键按下 */
    
80.                                         printf("摇杆右键按下\r\n");
    
81.                                         break;
    6 Z( \  C) Y% H" {3 Z( x
82.                                 
    
83.                                 case JOY_LONG_R:            /* 摇杆RIGHT键长按 */
    
84.                                         printf("摇杆右键长按\r\n");
    * s8 u4 d& X6 b! t2 A& C; p: G4 p
85.                                         break;
    9 Z% E& m; @6 n
86. 
    
87.                                 case JOY_DOWN_OK:                        /* 摇杆OK键按下 */
    - S& w. {3 K; B: o5 h2 \' J# {
88.                                         printf("摇杆OK键按下\r\n");
    
89.                                         break;
    
90. 
    
91.                                 case JOY_UP_OK:                        /* 摇杆OK键弹起 */
    
92.                                         printf("摇杆OK键弹起\r\n");
    0 ~+ F7 `; |  T8 l9 q1 R" @. ^1 x
93.                                         break;
    
94. 
    : ?. W6 p) ~3 |  a5 O2 S5 ?6 x
95.                 case SYS_DOWN_K1K2:                        /* 摇杆OK键弹起 */
    8 o" O+ T8 ^1 `! }* n" l
96.                                         printf("K1和K2组合键按下\r\n");
    
97.                                         break;
    . C% o0 D, W2 f( g4 a5 M5 F* i. @8 k
98. 
    
99.                                 default:
    ! o7 I/ A- O% e, w$ b: O* a- Y5 ?
100.                                         /* 其它的键值不处理 */
     
101.                                         break;
     3 Z. _5 q6 J) [% a  s- v* t
102.                         }
     
103.                
     
104.                 }
     - L6 @& T$ s' Q
105.         }
     - J$ j( ~8 [: Q: M( Q* s
106. }

复制代码

3 T/ b1 t3 m3 `& e. \) }4 g19.8 实验例程说明（IAR）
2 D7 k0 R4 P) M9 x配套例子：
* i" _8 b! }9 ^  W- ]! b+ s% |V7-002_按键检测（软件滤波，FIFO机制）
( p* Y# m5 I2 D/ d' n3 f' Y
8 @9 V& G4 S2 K实验目的：
学习按键的按下，弹起，长按和组合键的实现。

0 W- C; a) }# [/ V9 ~+ {实验内容：
/ }. h& l# @9 P# X/ R& I启动一个自动重装软件定时器，每100ms翻转一次LED2。

) _# r. H  l0 M) X. ^实验操作：
3 i; u; Y! o5 C8 D$ f3个独立按键和5向摇杆按下时均有串口消息打印。
# m3 {6 A! m$ }1 V' i( T8 ?5向摇杆的左键和右键长按时，会有连发的串口消息。
独立按键K1和K2按键按下，串口打印消息。

* `/ n/ H, G/ i; `2 u* F上电后串口打印的信息：
8 A% h* P! D, i9 q" t* a+ ?
% v" P  E! e) g波特率 115200，数据位 8，奇偶校验位无，停止位 1
  H' J2 Y# j& \% \
6 d, l4 s# T9 S5 d

程序设计：
% _& p7 X; i* J0 j) P
  系统栈大小分配：
# ?& d6 u) e$ `8 V/ N7 p

0 U. l' L- F: L% ?
  RAM空间用的DTCM：
" f3 ^$ {+ M; H2 q6 g" X$ H# ]# w
' L& x! M! L7 T8 u- y6 ~: r1 I

  硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：
" z' P: J2 f7 W6 |/ x" b* p

1. /*
   , B% `3 T6 Y$ I6 K6 i8 s
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   0 q0 ]0 [8 T; I( R' ~9 \" k
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   % S# p/ s6 L5 Z4 _
5. *        形    参：无
   . H# ^$ l% y! x+ L. X% ?# q; p
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   2 M2 M) S1 x1 P
8. */
   ' U( N4 b6 `) }$ @8 G; L2 m* Y
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    7 N3 M6 U% F! G9 t1 @: S% L' H) V
12.         MPU_Config();
    ) w, g( _) g( X( `( {
13.         
    
14.         /* 使能L1 Cache */
    : ^: S5 q; U6 N- q, L
15.         CPU_CACHE_Enable();
    
16. 
    ( b9 k, X1 U1 q3 L
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    1 f8 ?& k" n! a9 L1 k* u
21.          */
    
22.         HAL_Init();
    
23. 
    5 [% Q3 L8 C* @; x
24.         /*
    + M  z* {, P7 g. w: X* A
25.        配置系统时钟到400MHz
    $ k9 [6 ^+ j) {( q% Y
26.        - 切换使用HSE。
    " [, _7 b! T; }, w6 ], L; {
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.         SystemClock_Config();
    " v3 ?9 c' Q0 W
30. 
    
31.         /*
    
32.            Event Recorder：
    # p, o! h/ _) |" \$ l
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    $ D, p& ]/ q9 ~
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    5 \0 @0 D/ `, W/ X: }
36. #if Enable_EventRecorder == 1  
      s; E( M  {  c( ^/ N% i
37.         /* 初始化EventRecorder并开启 */
      {8 }* E& C5 @7 P( a0 y  ]
38.         EventRecorderInitialize(EventRecordAll, 1U);
    $ |7 f; y9 z8 Z( I- E% h" U
39.         EventRecorderStart();
    & K9 I  i" z5 `  u" G0 f" R
40. #endif
    
41.         
    ( V' q* t. }$ C2 d7 `" ~2 H/ g
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    & y2 J& r$ @1 U4 ?- b2 |1 P% r% q
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    0 [8 P. ~  |4 X3 N1 h! C/ y
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    7 e" P2 c. I8 l% W. w, O. r
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

  MPU配置和Cache配置：
# `0 v& Q7 c8 x- u, l8 l0 b
' W/ ?, _- g" D  m# R* T% T数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

! v: @* }) @% @4 L9 c6 P9 W6 q

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   7 {+ I5 \" Y' r" H, {6 C9 c
4. *        功能说明: 配置MPU
   % X) z3 a' J8 i; g5 z( O' B$ ]
5. *        形    参: 无
     M. z' d% J, h( v4 z0 a* B* B
6. *        返 回 值: 无
   6 Z' M; L0 g2 \3 q
7. *********************************************************************************************************
   : l3 ~( K4 s$ S# s
8. */
   
9. static void MPU_Config( void )
   
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    4 _1 f" F' F0 g% m: [5 ^
12. 
    
13.         /* 禁止 MPU */
    ( b6 q3 ]( F: E4 V
14.         HAL_MPU_Disable();
    , @6 i* I% R9 |
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    9 C2 ?" _, @/ g. b9 M1 G
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    / E* d0 e: J5 y) f2 m" F2 d
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    : U  i6 S4 R, ]  t
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;
    0 ]' r, y- S. p  t) |1 V' U8 x& |, I
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    2 n5 ^6 \6 R+ S, T! \% ~% N; P
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ; |5 q8 a: C, H
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    8 U. f6 q1 R1 U. n1 B  |, n* j
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ! K& w+ ]. ?2 t
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    6 B' S7 ^  a, A- }2 N2 C7 x% w7 S
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    & B: r* Z: y$ U/ Y% t8 [
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    , M  n* g; A+ P3 t' J
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    2 N' a. N- ?( b  y1 D6 k3 b. k
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    : W& l  U5 }1 {3 l/ p1 D( I
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    
47.         /*使能 MPU */
    1 ~( t; C) f. @1 O/ k
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    
50. 
    
51. /*
    - T3 q! ?; Y- n
52. *********************************************************************************************************
    
53. *        函 数 名: CPU_CACHE_Enable
    
54. *        功能说明: 使能L1 Cache
    
55. *        形    参: 无
    
56. *        返 回 值: 无
    
57. *********************************************************************************************************
    2 D$ x* \% r2 `" n( `
58. */
    
59. static void CPU_CACHE_Enable(void)
    . F7 |0 I5 i$ R4 _9 R, t* Y. t
60. {
    9 W: L  B0 P) V. I# f2 c
61.         /* 使能 I-Cache */
    2 X/ b, F' ]6 c$ m1 x1 s
62.         SCB_EnableICache();
    5 @) a" F% m4 A  u. c5 c0 P
63. 
    . a! G+ f* y! D$ |: j
64.         /* 使能 D-Cache */
    ; c/ q! v- \3 k% {
65.         SCB_EnableDCache();
    
66. }

复制代码

  每10ms调用一次按键检测：
' M; `- R; ]" u' H
按键检测是在滴答定时器中断里面实现，每10ms执行一次检测。
# f/ v9 F! {, a, M. a  H" t
$ t% ]: U$ q  a' z) R

1. /*
   0 \1 J8 i1 M, g- b
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_RunPer10ms
   
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   , [9 M4 W+ h, ]) L9 T2 @1 P
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   : B  e0 P$ F7 O: E
6. *        形    参: 无
   % Q% q4 n! q# o- L- X+ b
7. *        返 回 值: 无
   
8. *********************************************************************************************************
   
9. */
   
10. void bsp_RunPer10ms(void)
    8 v  p' g- r* \: q6 d9 l
11. {
    * ^3 y" s% V& r" |, o2 O
12.         bsp_KeyScan10ms();
    
13. }

复制代码

主功能：

0 q9 \) [) I' @主功能的实现主要分为两部分：
" d8 f5 L0 E5 N
启动一个自动重装软件定时器，每100ms翻转一次LED2
6 q6 U1 E/ Z3 t+ D 按键消息的读取，检测到按下后，做串口打印。
8 R% v9 C- I3 a7 i4 i

1. /*
   * U. l% ]5 v7 h; R6 P& R/ y4 H
2. *********************************************************************************************************
   
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   5 d0 Z. m, T$ F) S$ t
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   3 e- {* d0 N' A& T0 S/ G$ w  F  d2 c* h
8. */
   
9. int main(void)
   
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    3 i' ~# i$ ~1 `+ R" }
12.         
    0 n% ]; C1 l& Z7 i' Y: \2 A
13.         bsp_Init();                /* 硬件初始化 */
    
14.         
    / C8 ]6 Y- d$ b. _. O0 {8 [! b( Y
15.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    1 z1 |- h) M! f/ }  C1 V6 o+ O
16.         PrintfHelp();        /* 打印操作提示 */
    . v" A8 w* h3 l! b/ W5 o
17. 
    
18. 
    ! Y8 t9 }5 B5 i: Q3 O
19.         bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 */
    $ w( `7 {# X4 k- P7 L6 w
20.         
    
21.         /* 进入主程序循环体 */
    
22.         while (1)
    & z! O* c' R% P( l! q
23.         {
    
24.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
25. 
    
26.                 /* 判断定时器超时时间 */
    8 J) w# P/ S+ y# P
27.                 if (bsp_CheckTimer(0))        
    
28.                 {
    
29.                         /* 每隔100ms 进来一次 */  
    1 m7 D! Z8 i( ?/ J
30.                         bsp_LedToggle(2);                        
    $ I) l; ^" D) m# a; }; `7 R/ M
31.                 }
    7 A: v7 i; e9 k/ T$ r3 X
32.                
    $ R6 e( N# S6 M! |& s
33.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
34.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
35.                 if (ucKeyCode != KEY_NONE)
    ) f0 |$ o& S% q9 y5 y! G
36.                 {
    / o: ^: d- U: s, P
37.                         switch (ucKeyCode)
    : Q8 `1 i9 x1 z3 V) {# o5 t) l
38.                         {
    
39.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    ! Z- K' v/ R& x: O
40.                                         printf("K1键按下\r\n");
    5 B) M' n% h2 A5 L: B# F
41.                                         break;
    7 ^0 G, n/ i+ w% h( Z$ g
42. 
    ' J  @8 E1 m% t( d/ ]
43.                                 case KEY_UP_K1:                                /* K1键弹起 */
    5 [; T2 T2 I0 f( t1 Y- Q" P' r
44.                                         printf("K1键弹起\r\n");
    
45.                                         break;
    
46. 
    
47.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    
48.                                         printf("K2键按下\r\n");
    / d/ R4 D% `6 [  V) _3 B7 P- q
49.                                         break;
    
50. 
    
51.                                 case KEY_UP_K2:                                /* K2键弹起 */
    9 Z7 G) @% A1 w8 ]" k
52.                                         printf("K2键弹起\r\n");
    
53.                                         break;
    ! w0 V! L: a4 j. N2 S- r) t
54. 
    
55.                                 case KEY_DOWN_K3:                        /* K3键按下 */
    5 ^5 [; n" |. y: ]
56.                                         printf("K3键按下\r\n");
    
57.                                         break;
    
58. 
    
59.                                 case KEY_UP_K3:                                /* K3键弹起 */
    8 R4 c, `% l" C( l/ R# r
60.                                         printf("K3键弹起\r\n");
    0 W' N' C) D+ \7 G
61.                                         break;
    
62. 
    + _5 Q+ H$ X6 @0 p
63.                                 case JOY_DOWN_U:                        /* 摇杆UP键按下 */
    ( R, d  U8 f' b4 w
64.                                         printf("摇杆上键按下\r\n");
    
65.                                         break;
    
66. 
    ) g5 C" E' i5 a" G* G
67.                                 case JOY_DOWN_D:                        /* 摇杆DOWN键按下 */
    9 G3 x9 E. y/ V. u
68.                                         printf("摇杆下键按下\r\n");
    ! G+ ]7 T' N3 Z+ I* d, T  @
69.                                         break;
    
70. 
    
71.                                 case JOY_DOWN_L:                        /* 摇杆LEFT键按下 */
    + |! ?+ ~3 A# `5 j0 s& K) u( G7 O
72.                                         printf("摇杆左键按下\r\n");
    ! l! z4 |9 q/ S9 N
73.                                         break;
    
74.                                 
    , c& G$ P3 q7 u  D* k# L
75.                                 case JOY_LONG_L:            /* 摇杆LEFT键长按 */
    
76.                                         printf("摇杆左键长按\r\n");
    
77.                                         break;
    8 t' Y" V; D  ~- E- G, u( @
78. 
    
79.                                 case JOY_DOWN_R:                        /* 摇杆RIGHT键按下 */
    & p: a4 Q% E# x& o1 A. m" n
80.                                         printf("摇杆右键按下\r\n");
    
81.                                         break;
    2 J" d6 K, Q; d: z
82.                                 
    . G0 I& x# A- o- P% M8 h
83.                                 case JOY_LONG_R:            /* 摇杆RIGHT键长按 */
    
84.                                         printf("摇杆右键长按\r\n");
    % R( Y9 y# i# j* M3 ]# ?% I' C
85.                                         break;
    " P. b; p: r; O' h
86. 
    
87.                                 case JOY_DOWN_OK:                        /* 摇杆OK键按下 */
    6 N# _- a1 y( s1 k3 v: a+ `9 T, N
88.                                         printf("摇杆OK键按下\r\n");
    ' }; }% @% b! u0 k2 J
89.                                         break;
    : ?& _+ I% ]  R1 G8 }2 u
90. 
    
91.                                 case JOY_UP_OK:                        /* 摇杆OK键弹起 */
    
92.                                         printf("摇杆OK键弹起\r\n");
    0 e2 R0 E& V& V( V3 L
93.                                         break;
    * a4 t9 y5 ^! M& e
94. 
    
95.                 case SYS_DOWN_K1K2:                        /* 摇杆OK键弹起 */
    ( a* P& d# Y/ E* W+ R
96.                                         printf("K1和K2组合键按下\r\n");
    ' u  Q' Y( |* _: E
97.                                         break;
    / o" L! ?! e/ s0 h
98. 
    
99.                                 default:
    
100.                                         /* 其它的键值不处理 */
     6 p- U- z$ S% K) C/ }6 y! j2 _
101.                                         break;
     : ^) {( \3 P/ G
102.                         }
     9 O: J5 T! y; \7 I; b
103.                
     3 N  h& @3 s  \$ K9 [
104.                 }
     
105.         }
     / C1 I9 X; `8 g( W  a1 t/ Y
106. }

复制代码

19.9 总结
这个方案在实际项目中已经经过千锤百炼，大家可以放心使用。建议熟练掌握其用法。

# V0 W3 e: \3 |% K2 i  f* d

+ t8 f: v# F, s+ `