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

19.2 按键硬件设计
V7开发板有三个独立按键和一个五向摇杆，下面是三个独立按键的原理图：
  z& P, n: Y6 a- m% w
0 `) U; H* S  k1 u# k4 D/ F

注意，K1（S1）、K2(S2)和K3(S3)按键的上拉电阻是接在5V电压上，因为这三个按键被复用为PS/2键盘鼠标接口，而PS/2是需要5V供电的（注，V5和V6开发板做了PS/2复用，而V7没有使用，这里只是为了兼容之前的板子）。实际测试，K1、K2、K3按键和PS/2键盘是可以同时工作的。
; B, D$ L4 M! P
8 J; i8 c) |6 G: U2 c下面是五向摇杆的原理图：
9 w- g% U4 p6 v) w. I) H( u

; Z8 d) m  s% @
通过这个硬件设计，有如下两个知识点为大家做介绍：

19.2.1 硬件设计
按键和CPU之间串联的电阻起保护作用。按键肯定是存在机械抖动的，开发板上面的硬件没有做硬件滤波处理，即使设计了硬件滤波电路，软件上还是需要进行滤波。
( L1 F4 g, i' H7 I8 s+ t9 ]! @
7 \+ t" n/ ~! o2 |$ o  保护GPIO，避免软件错误将IO设置为输出，如果设置为低电平还好，如果设置输出的是高电平，按键按下会直接跟GND(低电平)连接，从而损坏MCU。
  保护电阻也起到按键隔离作用，这些GPIO可以直接用于其它实验。
1 F& T  A, N2 q9 R$ k0 O6 v9 C19.2.2 GPIO内部结构分析按键
详细的GPIO模式介绍，请参考第15章的15.3小节，本章仅介绍输入模式。下面我们通过一张图来简单介绍GPIO的结构。
& ^, p! J: z5 R/ [% x9 u9 \: n

5 u: Z* o! j, m2 b* T; K3 q. O3 t, c
红色的线条是GPIO输入通道的信号流向，作为按键检测IO，这些需要配置为浮空输入。按键已经做了5V上拉，因此GPIO内部的上下拉电阻都选择关闭状态。

9 T) u0 ^$ b4 n$ C0 l19.3 按键FIFO的驱动设计
bsp_key按键驱动程序用于扫描独立按键，具有软件滤波机制，采用FIFO机制保存键值。可以检测如下事件：

1 L, j, T, \; n( {1 z& z7 g% n" S8 `  按键按下。
" Y! Y9 B. Q' P  按键弹起。
  长按键。
* ^( [8 n* s0 P# n0 D  长按时自动连发。
我们将按键驱动分为两个部分来介绍，一部分是FIFO的实现，一部分是按键检测的实现。
8 \4 P4 U" M! i8 H
! E4 J  J6 b7 T( x' x: ^

  H; D" W% a. B% bbsp_key.c 文件包含按键检测和按键FIFO的实现代码。
* q+ Z* i, z. K$ ]4 h6 o
1 h1 O; K9 B! z  p+ ubsp.c 文件会调用bsp_InitKey()初始化函数。
7 g3 J: r: ~" g! Q$ @, D3 n- S
bsp.c 文件会调用bsp_KeyScan按键扫描函数。

bsp_timer.c 中的Systick中断服务程序调用 bsp_RunPer10ms。

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

函数调用关系图：

19.3.1 按键FIFO的原理
FIFO是First Input First Output的缩写，先入先出队列。我们这里以5个字节的FIFO空间进行说明。Write变量表示写位置，Read变量表示读位置。初始状态时，Read = Write = 0。
( `1 N; V0 c; f* x  m8 l* b# W
/ [/ ~6 w$ {" q* W& G

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

( Y/ G( A1 [  G" F

6 Y( P& E# |2 V/ Z
如果Write！= Read，则我们认为有新的按键事件。

! h* b  C, \3 H4 ?我们通过函数bsp_GetKey读取一个按键值进行处理后，Read变量变为1。Write变量不变。
. y& k' q+ p4 W8 ]

# _* {6 \( h& b8 H! c6 r4 e我们继续通过函数bsp_GetKey读取3个按键值进行处理后，Read变量变为4。此时Read = Write = 4。两个变量已经相等，表示已经没有新的按键事件需要处理。

有一点要特别的注意，如果FIFO空间写满了，Write会被重新赋值为0，也就是重新从第一个字节空间填数据进去，如果这个地址空间的数据还没有被及时读取出来，那么会被后来的数据覆盖掉，这点要引起大家的注意。我们的驱动程序开辟了10个字节的FIFO缓冲区，对于一般的应用足够了。
% }# ~6 o$ A0 ]9 C% Y* |& @
设计按键FIFO主要有三个方面的好处：
, w' j) S: w  P) W% s  i6 f
  可靠地记录每一个按键事件，避免遗漏按键事件。特别是需要实现按键的按下、长按、自动连发、弹起等事件时。
/ A% ^, X9 E& f% d( ~$ ]1 \% |  读取按键的函数可以设计为非阻塞的，不需要等待按键抖动滤波处理完毕。
7 u& e  J: m8 ~9 d" h  按键FIFO程序在嘀嗒定时器中定期的执行检测，不需要在主程序中一直做检测，这样可以有效地降低系统资源消耗。

19.3.2 按键FIFO的实现
在bsp_key.h 中定了结构体类型KEY_FIFO_T。这只是类型声明，并没有分配变量空间。
" g. q0 J  u2 g. O. x0 N+ v2 [

1. #define KEY_FIFO_SIZE        10
     _: k$ i0 G" N7 C
2. typedef struct
   
3. {
   . a4 E( q7 e* d7 E
4.         uint8_t Buf[KEY_FIFO_SIZE];                /* 键值缓冲区 */
   
5.         uint8_t Read;                                        /* 缓冲区读指针1 */
   5 l" A& B! B/ P+ L
6.         uint8_t Write;                             /* 缓冲区写指针 */
   4 R$ m! o( b, v. [! X
7.         uint8_t Read2;                             /* 缓冲区读指针2 */
   
8. }KEY_FIFO_T;

复制代码

9 f2 n* r: ?1 V在bsp_key.c 中定义s_tKey结构变量, 此时编译器会分配一组变量空间。

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

复制代码

一般情况下，只需要一个写指针Write和一个读指针Read。在某些情况下，可能有两个任务都需要访问按键缓冲区，为了避免键值被其中一个任务取空，我们添加了第2个读指针Read2。出厂程序在bsp_Idle()函数中实现的按K1K2组合键截屏的功能就使用的第2个读指针。
+ G. l$ E6 U5 K/ U6 v
; C0 g' x( x3 h9 ~6 w当检测到按键事件发生后，可以调用 bsp_PutKey函数将键值压入FIFO。下面的代码是函数的实现：
* [9 g/ N; F& g* t$ J9 @

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_PutKey
   
4. *        功能说明: 将1个键值压入按键FIFO缓冲区。可用于模拟一个按键。
   
5. *        形    参: _KeyCode : 按键代码
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. void bsp_PutKey(uint8_t _KeyCode)
   5 B% ^3 s; T9 A. {3 }) z) d2 y3 q
10. {
    
11.         s_tKey.Buf[s_tKey.Write] = _KeyCode;
    
12. 
    9 {* {0 b; F; V0 W& W  r2 {$ D
13.         if (++s_tKey.Write  >= KEY_FIFO_SIZE)
    
14.         {
    
15.                 s_tKey.Write = 0;
    
16.         }
    
17. }

复制代码

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

; K+ y- J$ q: n# Z应用程序读取FIFO中的键值，是通过bsp_GetKey函数和bsp_GetKey2函数实现的。我们来看下这两个函数的实现：
# U2 ~% z* j3 m1 V4 J

1. /*
   & s& N4 ]: @7 c
2. *********************************************************************************************************
   ! N. A: w( {5 ?: k) w5 |# }! j( u% N, z; q
3. *        函 数 名: bsp_GetKey
   
4. *        功能说明: 从按键FIFO缓冲区读取一个键值。
   ' a8 @/ a, u4 f( |+ n
5. *        形    参:  无
   
6. *        返 回 值: 按键代码
   ' G  J% ~1 I, o
7. *********************************************************************************************************
   " V+ n+ e4 x; `, o$ x4 P
8. */
   & t* C( [4 T+ Y3 U% f; b
9. uint8_t bsp_GetKey(void)
   
10. {
    7 y3 E) b1 v7 r
11.         uint8_t ret;
    
12. 
    
13.         if (s_tKey.Read == s_tKey.Write)
    
14.         {
    
15.                 return KEY_NONE;
    
16.         }
    8 J) f  h; Q  }9 p( t- F) ?. _: p) C
17.         else
    / |5 ~! w2 I2 u3 l6 L7 a
18.         {
    
19.                 ret = s_tKey.Buf[s_tKey.Read];
    
20. 
    
21.                 if (++s_tKey.Read >= KEY_FIFO_SIZE)
    
22.                 {
    
23.                         s_tKey.Read = 0;
    
24.                 }
    
25.                 return ret;
    
26.         }
    / k9 K2 Z3 O  {$ w
27. }
    
28. 
    ; c0 }" _, h5 `( [, w
29. /*
    
30. *********************************************************************************************************
    
31. *        函 数 名: bsp_GetKey2
    
32. *        功能说明: 从按键FIFO缓冲区读取一个键值。独立的读指针。
    
33. *        形    参:  无
    
34. *        返 回 值: 按键代码
    
35. *********************************************************************************************************
    
36. */
    
37. uint8_t bsp_GetKey2(void)
    
38. {
    4 X6 I4 X1 {2 V; S* B8 M% E
39.         uint8_t ret;
    
40. 
    5 v9 y, y/ l  m/ d" b3 |8 K. k
41.         if (s_tKey.Read2 == s_tKey.Write)
    
42.         {
    
43.                 return KEY_NONE;
    
44.         }
    / U  f$ @3 T. d3 m% i
45.         else
    3 H: J, |/ l! Z' g
46.         {
    
47.                 ret = s_tKey.Buf[s_tKey.Read2];
    2 Q) O/ t7 n8 l5 E' k0 U* a
48. 
    
49.                 if (++s_tKey.Read2 >= KEY_FIFO_SIZE)
    
50.                 {
    . U0 v/ I9 o, _1 c; i* Q
51.                         s_tKey.Read2 = 0;
    
52.                 }
    6 U- i% E9 b% @2 _0 d  E
53.                 return ret;
    
54.         }
    
55. }

复制代码

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

1. typedef enum
   
2. {
   7 x. i' f% ]' q, y8 U, L
3.         KEY_NONE = 0,                        /* 0 表示按键事件 */
   
4. 
   
5.         KEY_1_DOWN,                        /* 1键按下 */
   3 l! D2 C2 x( A" n( ~, x; K) V
6.         KEY_1_UP,                                /* 1键弹起 */
   & e$ [3 R# k6 Y* \" Z
7.         KEY_1_LONG,                        /* 1键长按 */
   
8. 
   * U. V9 S) t$ F
9.         KEY_2_DOWN,                        /* 2键按下 */
   6 R: X% z" f6 n6 g9 j
10.         KEY_2_UP,                                /* 2键弹起 */
    
11.         KEY_2_LONG,                        /* 2键长按 */
    
12. 
    5 w# z, X0 [( V6 ?
13.         KEY_3_DOWN,                        /* 3键按下 */
    + K2 W( `" `3 n3 P1 i8 b
14.         KEY_3_UP,                                /* 3键弹起 */
    
15.         KEY_3_LONG,                        /* 3键长按 */
    : g) l& U, P. i( K( y% g
16. 
    7 g4 r. Y" ]( u, Z8 ~, C1 b
17.         KEY_4_DOWN,                        /* 4键按下 */
    # r8 Q  @- s4 s1 e6 o4 D* ]- N
18.         KEY_4_UP,                                /* 4键弹起 */
    . N8 N) ?$ Z& j/ Q8 m. f- s
19.         KEY_4_LONG,                        /* 4键长按 */
    # L: w3 h- y  U8 a! B7 M9 u) {( F& s
20. 
    # T, X" E6 m. \$ N
21.         KEY_5_DOWN,                        /* 5键按下 */
    
22.         KEY_5_UP,                                /* 5键弹起 */
    
23.         KEY_5_LONG,                        /* 5键长按 */
    
24. 
    & t/ O. E9 G; |5 `1 @
25.         KEY_6_DOWN,                        /* 6键按下 */
    6 k4 G0 x  H( ~" p. Z
26.         KEY_6_UP,                                /* 6键弹起 */
    ! ^6 n: X$ W$ d; f% A3 h3 w
27.         KEY_6_LONG,                        /* 6键长按 */
    9 a; O1 n/ ]# o' [8 ?) v
28. 
    
29.         KEY_7_DOWN,                        /* 7键按下 */
    
30.         KEY_7_UP,                                /* 7键弹起 */
    
31.         KEY_7_LONG,                        /* 7键长按 */
    
32. 
    % r) i: [0 A, N
33.         KEY_8_DOWN,                        /* 8键按下 */
    " a3 B; g% E/ T8 k# t7 _
34.         KEY_8_UP,                                /* 8键弹起 */
    0 t8 k: D0 B' M. I% w4 P
35.         KEY_8_LONG,                        /* 8键长按 */
    2 d' i: B% {/ Q8 s" b. W7 p
36. 
    
37.         /* 组合键 */
    
38.         KEY_9_DOWN,                        /* 9键按下 */
    
39.         KEY_9_UP,                                /* 9键弹起 */
    
40.         KEY_9_LONG,                        /* 9键长按 */
    
41. 
    
42.         KEY_10_DOWN,                        /* 10键按下 */
    / |9 V3 f% S; T7 [
43.         KEY_10_UP,                        /* 10键弹起 */
    
44.         KEY_10_LONG,                        /* 10键长按 */
    
45. }KEY_ENUM;

复制代码

必须按次序定义每个键的按下、弹起和长按事件，即每个按键对象（组合键也算1个）占用3个数值。我们推荐使用枚举enum, 不用#define的原因：

  便于新增键值,方便调整顺序。
  使用{ } 将一组相关的定义封装起来便于理解。
  编译器可帮我们避免键值重复。
% |, _, M9 m3 \+ _& K8 L我们来看红外遥控器的键值定义，在bsp_ir_decode.h文件。因为遥控器按键和主板按键共用同一个FIFO，因此在这里我们先贴出这段定义代码，让大家有个初步印象。

1. /* 定义红外遥控器按键代码, 和bsp_key.h 的物理按键代码统一编码 */
   
2. typedef enum
   
3. {
   * l, c8 p" v2 P
4.         IR_KEY_STRAT         = 0x80,
   1 y/ P) d% ~* V1 I! o
5.         IR_KEY_POWER         = IR_KEY_STRAT + 0x45,
   
6.         IR_KEY_MENU         = IR_KEY_STRAT + 0x47,
   ' i5 v: L: c9 b
7.         IR_KEY_TEST         = IR_KEY_STRAT + 0x44,
   
8.         IR_KEY_UP         = IR_KEY_STRAT + 0x40,
   
9.         IR_KEY_RETURN        = IR_KEY_STRAT + 0x43,
   ' @4 G+ L* _; s: U2 L* X9 c
10.         IR_KEY_LEFT        = IR_KEY_STRAT + 0x07,
    
11.         IR_KEY_OK                = IR_KEY_STRAT + 0x15,
    " U2 \1 ]% ?; G. H
12.         IR_KEY_RIGHT        = IR_KEY_STRAT + 0x09,
    
13.         IR_KEY_0                = IR_KEY_STRAT + 0x16,
    
14.         IR_KEY_DOWN        = IR_KEY_STRAT + 0x19,
    7 `1 D" A- n" Y; x1 K
15.         IR_KEY_C                = IR_KEY_STRAT + 0x0D,
    
16.         IR_KEY_1                = IR_KEY_STRAT + 0x0C,
    
17.         IR_KEY_2                = IR_KEY_STRAT + 0x18,
    8 d8 I7 R6 Y+ k/ _/ F& J
18.         IR_KEY_3                = IR_KEY_STRAT + 0x5E,
    - I! P8 I* b9 d$ B" S
19.         IR_KEY_4                = IR_KEY_STRAT + 0x08,
    1 l4 X. O4 |8 s! n3 M& b
20.         IR_KEY_5                = IR_KEY_STRAT + 0x1C,
    6 j. V3 s* m2 s. f
21.         IR_KEY_6                = IR_KEY_STRAT + 0x5A,
    # e" R# l: c& M
22.         IR_KEY_7                = IR_KEY_STRAT + 0x42,
    , f; S1 g1 g3 J, G1 Q: C
23.         IR_KEY_8                = IR_KEY_STRAT + 0x52,
    
24.         IR_KEY_9                = IR_KEY_STRAT + 0x4A,        
      G3 E3 _5 m# q1 E; x& ^
25. }IR_KEY_E;

复制代码

3 v( c  \5 L, _4 Z5 y: `我们下面来看一段简单的应用。这个应用的功能是：主板K1键控制LED1指示灯；遥控器的POWER键和MENU键控制LED2指示灯。

1. #include "bsp.h"
   
2. 
   
3. int main(void)
   + G" B7 q6 Y% T0 F
4. {
   + j( D8 s# z" H: j0 \! b% o
5.         uint8_t ucKeyCode;
   9 u/ P, u3 G$ N9 p" c5 G% g
6.                         
   , b& ^$ K" E5 b1 @9 @8 C
7.         bsp_Init();
   # d8 \  Q2 x6 F7 L
8. 
   
9.         IRD_StartWork();        /* 启动红外解码 */
   8 \7 Q. x6 \# e5 D$ E
10. 
    ( c4 ^8 O! e. X' o& B2 A
11.         while(1)
    2 X6 B2 u$ e7 q4 I6 p$ S
12.         {
    
13.                 bsp_Idle();
    * K. H6 j  j( ?( ]
14.                
    
15.                 /* 处理按键事件 */
    . c/ l  K$ s. W
16.                 ucKeyCode = bsp_GetKey();
    9 Q+ }5 P- y4 T; S+ d, }
17.                 if (ucKeyCode > 0)
    ; l( b# F/ `% b' [
18.                 {
    5 t/ `) P0 q/ Z9 j# T! K9 U
19.                         /* 有键按下 */
    
20.                         switch (ucKeyCode)
      t+ T5 Z; Y, H
21.                         {
    ! I4 q4 a# g8 @7 D7 \. S3 ?) e6 i1 G
22.                                 case KEY_DOWN_K1:                /* K1键按下 */
    : W9 b' @. g' l+ o3 E# _
23.                                         bsp_LedOn(1);                /* 点亮LED1 */
    , Z9 w) Z0 b" O3 i% E8 m
24.                                         break;
      z2 [1 B5 ?* U! G( J
25. 
    
26.                                 case KEY_UP_K1:                /* K1键弹起 */
    : o( f  A3 u4 d% l7 Q" \
27.                                         bsp_LedOff(1);        /* 熄灭LED1 */
    ( e, l. `' r* E  R" r& t
28.                                         break;                                       
    
29. 
    & Q' f  _* [! V3 U0 N
30.                                 case IR_KEY_POWER:                /* 遥控器POWER键按下 */
    6 X- d: a' W( s) r
31.                                         bsp_LedOn(1);                /* 点亮LED2 */
    ; S2 s( T2 v% J  w( ?" Q7 O* ?
32.                                         break;
    
33. 
    
34.                                 case IR_KEY_MENU:                /* 遥控器MENU键按下 */
    
35.                                         bsp_LedOff(1);        /* 熄灭LED2 */
    
36.                                         break;                                       
    2 u3 k: {/ n! l1 |
37. 
    & X- h: e2 Q  \
38.                                 case MSG_485_RX:                /* 通信程序的发来的消息 */
    
39.                                         /* 执行通信程序的指令 */
    ! y! k) a" {3 Z" N: ], u
40.                                         break;
    - B$ I" o7 H" a- {1 `, L
41. 
    
42.                                 default:
    
43.                                         break;
    0 f/ n4 b# D% y: e, j' c
44.                         }
    7 V+ M* G6 |$ L1 M4 n
45.                 }
    ) d, ~1 X: q  k3 p6 b! [
46.         }
    ) r1 T% p8 a0 H: Y0 U0 C. u
47. }

复制代码

* Q8 p# r5 o: W0 p: |看到这里，想必你已经意识到bsp_PutKey函数的强大之处了，可以将不相关的硬件输入设备统一为一个相同的接口函数。

在上面的应用程序中，我们特意添加了一段红色的代码来解说更高级的用法。485通信程序收到有效的命令后通过 bsp_PutKey（MSG_485_RX）函数可以通知APP应用程序进行进一步加工处理（比如显示接收成功）。这是一种非常好的任务间信息传递方式，它不会破坏程序结构。不必新增全局变量来做这种事情，你只需要添加一个键值代码。

对于简单的程序，可以借用按键FIFO来进行少量的信息传递。对于复杂的应用，我们推荐使用bsp_msg专门来做这种任务间的通信。因为bsp_msg除了传递消息代码外，还可以传递参数结构。
7 E; \' w% T/ E. O, K. c
19.3.3 按键检测程序分析
在bsp_key.h 中定了结构体类型KEY_T。

1. #define KEY_COUNT    10                           /* 按键个数, 8个独立建 + 2个组合键 */
     i- k5 L& d; f8 N
2. 
   
3. typedef struct
   ; ]% y3 g; b! }! \, Z7 I
4. {
   
5.         /* 下面是一个函数指针，指向判断按键手否按下的函数 */
   $ P6 a# r* ^. u3 P% H
6.         uint8_t (*IsKeyDownFunc)(void); /* 按键按下的判断函数,1表示按下 */
   
7. 
   
8.         uint8_t  Count;                /* 滤波器计数器 */
   
9.         uint16_t LongCount;        /* 长按计数器 */
   
10.         uint16_t LongTime;                /* 按键按下持续时间, 0表示不检测长按 */
    ) ]: W! z# p6 r, l/ q# O
11.         uint8_t  State;                /* 按键当前状态（按下还是弹起） */
    
12.         uint8_t  RepeatSpeed;        /* 连续按键周期 */
    8 w& u8 s) ]: N8 h% B  p
13.         uint8_t  RepeatCount;        /* 连续按键计数器 */
    
14. }KEY_T;

复制代码

* e+ P) }, S& P9 e! {" m在bsp_key.c 中定义s_tBtn结构体数组变量。

1. static KEY_T s_tBtn[KEY_COUNT];
   # j% Q4 |0 g' I  B/ K: D
2. static KEY_FIFO_T s_tKey; /* 按键FIFO变量,结构体 */

复制代码

每个按键对象都分配一个结构体变量，这些结构体变量以数组的形式存在将便于我们简化程序代码行数。
6 {* w: `$ e/ b) b
使用函数指针IsKeyDownFunc可以将每个按键的检测以及组合键的检测代码进行统一管理。

8 c" {- M; x, ?& S- Y. U. m因为函数指针必须先赋值，才能被作为函数执行。因此在定时扫描按键之前，必须先执行一段初始化函数来设置每个按键的函数指针和参数。这个函数是 void bsp_InitKey(void)。它由bsp_Init()调用。
. x3 x" S$ |3 p9 Y. ?' C
' C8 q" O7 H! n! B8 N1 F

1. /*
   # S" k  L' `9 D2 `/ _
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_InitKey
   6 ?& s, O3 j/ _7 e0 I
4. *        功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
   ) E8 O9 d7 u8 H1 w: o( }
5. *        形    参: 无
   8 C2 V% m' {9 r1 g4 f0 [$ g7 R
6. *        返 回 值: 无
   9 P/ d: l1 F5 K7 i7 T
7. *********************************************************************************************************
   
8. */
   ! L  ~' H" \% g7 i- j! a
9. void bsp_InitKey(void)
   
10. {
    + S0 k& y: B# a  \5 Q& P, d
11.         bsp_InitKeyVar();                /* 初始化按键变量 */
    3 `* \: }/ r5 z4 e0 T
12.         bsp_InitKeyHard();                /* 初始化按键硬件 */
    : J: ?" m+ f( N: {6 J  M
13. }

复制代码

下面是bsp_InitKeyVar函数的定义：

7 T( ~; V2 E& ]- U. b

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_InitKeyVar
   5 D  e% t0 w6 M4 }! A# r. [
4. *        功能说明: 初始化按键变量
   / m+ c9 H1 \& _( X
5. *        形    参:  无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void bsp_InitKeyVar(void)
   ) T+ E# F2 P6 |% K
10. {
    + q; f7 }$ @8 d
11.         uint8_t i;
    . b' {/ o" q1 ]/ ^7 J$ x
12. 
    
13.         /* 对按键FIFO读写指针清零 */
    : o* c  m/ G* d9 w4 ^5 C6 M6 w
14.         s_tKey.Read = 0;
    
15.         s_tKey.Write = 0;
    3 q+ a5 `  d; n  o5 c# }( \4 @
16.         s_tKey.Read2 = 0;
    & s6 x- P- J! D$ p. l
17. 
    
18.         /* 给每个按键结构体成员变量赋一组缺省值 */
    
19.         for (i = 0; i < KEY_COUNT; i++)
    
20.         {
    * K0 _. J) A4 {/ O% b
21.                 s_tBtn<i>.LongTime = KEY_LONG_TIME;                        /* 长按时间 0 表示不检测长按键事件 */</i>
    & P$ m% K3 |; V/ q6 b& X
22. <span style="font-style: italic;">                s_tBtn.Count = KEY_FILTER_TIME / 2;                /* 计数器设置为滤波时间的一半 */
    
23.                 s_tBtn<span style="font-style: italic;">.State = 0;                                                /* 按键缺省状态，0为未按下 */
    0 Y( r: y. U" p( Y
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. 
    
28.         /* 如果需要单独更改某个按键的参数，可以在此单独重新赋值 */
    3 O; ]3 \& ]/ ]8 ]4 V0 Q$ ^; I2 W
29.         
    & S; ?+ Y2 _" |- B0 X4 j
30.         /* 摇杆上下左右，支持长按1秒后，自动连发 */
    
31.         bsp_SetKeyParam(KID_JOY_U, 100, 6);
    
32.         bsp_SetKeyParam(KID_JOY_D, 100, 6);
    & S( w* \' Z& i! {' o
33.         bsp_SetKeyParam(KID_JOY_L, 100, 6);
    1 Z+ ?, R, A" Q9 [9 {. Y# ^
34.         bsp_SetKeyParam(KID_JOY_R, 100, 6);
    & B% q9 u2 d( `2 g
35. }</span></span></span></span>

复制代码

注意一下 Count 这个成员变量，没有设置为0。为了避免主板上电的瞬间，检测到一个无效的按键按下或弹起事件。我们将这个滤波计数器的初值设置为正常值的1/2。bsp_key.h中定义了滤波时间和长按时间。
* y  f$ m) r+ v0 ^
8 I6 K8 G  T; A2 i: B# d

1. /*
   
2.         按键滤波时间50ms, 单位10ms。
   
3.         只有连续检测到50ms状态不变才认为有效，包括弹起和按下两种事件
   " V; M( Z( e7 b3 [- |
4.         即使按键电路不做硬件滤波，该滤波机制也可以保证可靠地检测到按键事件
   
5. */
   3 Y# X  ?% f; w' f3 ^; @
6. #define KEY_FILTER_TIME   5
   6 \! C6 l* G/ l* {
7. #define KEY_LONG_TIME     100                        /* 单位10ms， 持续1秒，认为长按事件 */

复制代码

* E2 T. k% b. M3 G$ }/ yuint8_t KeyPinActive(uint8_t _id)（会调用函数KeyPinActive判断状态）函数就是最底层的GPIO输入状态判断函数。
) }6 ]. B. q& w, R( c& p! w% N; w# {

1. /*
   
2. *********************************************************************************************************
   # w- q' \/ m+ ]5 n
3. *        函 数 名: KeyPinActive
   
4. *        功能说明: 判断按键是否按下
   3 {; ~" @( l2 K2 U$ i
5. *        形    参: 无
   ( Z+ D( X* `; R$ {0 ^. y
6. *        返 回 值: 返回值1 表示按下(导通），0表示未按下（释放）
   
7. *********************************************************************************************************
   5 m$ c9 M9 e3 T# g! u( z) {
8. */
   
9. static uint8_t KeyPinActive(uint8_t _id)
   5 d  l0 I% z& \' l( D
10. {
    
11.         uint8_t level;
    5 d* y1 F# R% a' Q2 E$ h
12.         
    
13.         if ((s_gpio_list[_id].gpio->IDR & s_gpio_list[_id].pin) == 0)
    
14.         {
    
15.                 level = 0;
    
16.         }
    
17.         else
    $ D# F, W; i2 z0 n- k0 d
18.         {
    8 j# Y( g( Z" s, G: ~  E" ^; _
19.                 level = 1;
    - |/ m- ~; ?) Q1 i
20.         }
    
21. 
    $ l- ?" \8 W7 j# N) m3 ?! s) n
22.         if (level == s_gpio_list[_id].ActiveLevel)
    
23.         {
    % t, |5 L* Y& i. G6 |
24.                 return 1;
    9 u8 x$ k8 ]7 c; u
25.         }
    : v% I4 I) G; I: I# f# t! w' ?2 }! I5 e- M
26.         else
    + G6 C: m! v# b9 F- H* N+ j6 M% [; P
27.         {
    / ?8 l5 n0 L! P: }) D
28.                 return 0;
    # O' G) p: H, n4 b4 q1 u
29.         }
    , G. Z. @# r+ o5 z  }: ^! e' O' Y- D
30. }
    
31. 
    
32. /*
    & Q3 X2 z+ l6 U7 g2 [
33. *********************************************************************************************************
    5 a( o" R$ I, B1 R7 z
34. *        函 数 名: IsKeyDownFunc
    
35. *        功能说明: 判断按键是否按下。单键和组合键区分。单键事件不允许有其他键按下。
    
36. *        形    参: 无
    
37. *        返 回 值: 返回值1 表示按下(导通），0表示未按下（释放）
    
38. *********************************************************************************************************
    ) g# }+ N# v" J* Y1 S
39. */
    
40. static uint8_t IsKeyDownFunc(uint8_t _id)
    - B/ Y$ T+ U& @' u: x+ y4 H
41. {
    
42.         /* 实体单键 */
    
43.         if (_id < HARD_KEY_NUM)
    2 d& O2 o; K; d4 o
44.         {
    
45.                 uint8_t i;
    
46.                 uint8_t count = 0;
    
47.                 uint8_t save = 255;
    # K" d% C! L4 G, z% s: W
48.                
    
49.                 /* 判断有几个键按下 */
    1 J9 Z! {& F6 j4 v/ M- }9 p' z0 c
50.                 for (i = 0; i < HARD_KEY_NUM; i++)
    9 S3 {& ^8 p! r2 g7 b. ?
51.                 {
    ! |5 h0 }3 m. R: d; Y! b
52.                         if (KeyPinActive(i))
    
53.                         {
    
54.                                 count++;
    6 z  a5 V- s7 R1 ^2 |3 o  C
55.                                 save = i;
    2 A- M: `' U0 ]! I! w! e
56.                         }
    
57.                 }
    
58.                
    
59.                 if (count == 1 && save == _id)
    
60.                 {
    
61.                         return 1;        /* 只有1个键按下时才有效 */
    1 U5 G- p2 G( O1 [2 W1 R8 W) z
62.                 }               
    ; m! M% x3 H  l
63. 
    
64.                 return 0;
    
65.         }
    
66.         
    2 y; J& t" H+ N6 H. e+ L4 }
67.         /* 组合键 K1K2 */
    ' }( v. V- L1 t3 g' I
68.         if (_id == HARD_KEY_NUM + 0)
    / X- }7 [( H6 g6 h  J( V
69.         {
    - H( a1 D' v7 R( N4 G" c4 ?
70.                 if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
    
71.                 {
    
72.                         return 1;
    9 G. z9 l! {# @( C4 P# ?
73.                 }
    
74.                 else
    % k. c( ]/ m& ^- ]8 b8 x
75.                 {
    , p$ M0 U) g9 [: W7 X& {1 G
76.                         return 0;
    
77.                 }
    
78.         }
    
79. 
    3 M% B! [/ E' D2 x* H1 t5 C$ @3 @( g
80.         /* 组合键 K2K3 */
    
81.         if (_id == HARD_KEY_NUM + 1)
    " V8 t1 ~9 u; ~$ ?7 N
82.         {
    
83.                 if (KeyPinActive(KID_K2) && KeyPinActive(KID_K3))
    - D" s+ v: }0 z7 P9 B  C$ H' v
84.                 {
    ( R, R( o; u# Z9 i* p1 d( n+ a
85.                         return 1;
    & s( m6 ^6 b" Y' @8 I
86.                 }
    
87.                 else
    
88.                 {
    
89.                         return 0;
    % ]9 D' k: a  L4 F4 p! ^
90.                 }
    2 w& X  N5 f" ~+ T! z5 c
91.         }
    
92. 
    1 }' o7 K7 H; |9 U' v, |
93.         return 0;
    & \9 w! }+ e7 p) f
94. }

复制代码

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

# W( R0 _- [' T

1. /*
   
2. *********************************************************************************************************
   0 J8 K' a! m" a0 g! `6 ?
3. *        函 数 名: bsp_InitKeyHard
   
4. *        功能说明: 配置按键对应的GPIO
   ( w; X8 w# ], u7 t& j% f! l4 D; b+ j
5. *        形    参:  无
   9 r! T5 Z# n& l1 f- {
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   " o3 B4 S* y% K4 X; i4 X/ t0 b. b
8. */
   
9. static void bsp_InitKeyHard(void)
   0 i# d$ x+ K, l: m" x. J1 E
10. {        
    
11.         GPIO_InitTypeDef gpio_init;
    
12.         uint8_t i;
    
13. 
    1 {# s9 C9 b- E2 I; |6 |% O; s
14.         /* 第1步：打开GPIO时钟 */
    
15.         ALL_KEY_GPIO_CLK_ENABLE();
    
16.         
    
17.         /* 第2步：配置所有的按键GPIO为浮动输入模式(实际上CPU复位后就是输入状态) */
    0 l- j0 f1 v# ~$ B2 X% t
18.         gpio_init.Mode = GPIO_MODE_INPUT;                           /* 设置输入 */
    7 G' Q/ c! c/ A
19.         gpio_init.Pull = GPIO_NOPULL;                 /* 上下拉电阻不使能 */
    9 D: O2 a: r8 ~5 p, }& y+ X0 C' |( m
20.         gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;  /* GPIO速度等级 */
    & T1 r+ |5 L4 E
21.         
    
22.         for (i = 0; i < HARD_KEY_NUM; i++)
    
23.         {
    ( z$ X5 @" _# o8 g5 |, E& }
24.                 gpio_init.Pin = s_gpio_list<span style="font-style: italic;"><span style="font-style: normal;">.pin;
    7 H, C. g2 |  p+ Q2 d( h
25.                 HAL_GPIO_Init(s_gpio_list</span><span style="font-style: normal;">.gpio, &gpio_init);        
    
26.         }
    
27. }</span></span>

复制代码

我们再来看看按键是如何执行扫描检测的。
' A* d& ~& K# |( y
9 @5 p9 [1 I$ ?) v) p* }5 |& u按键扫描函数bsp_KeyScan10ms ()每隔10ms被执行一次。bsp_RunPer10ms函数在systick中断服务程序中执行。

" V* J+ Q1 z- e

1. void bsp_RunPer10ms(void)
   
2. {
   0 f' c+ S9 L! e  W. r2 x
3.         bsp_KeyScan10ms();                /* 扫描按键 */
   
4. }

复制代码

bsp_KeyScan10ms ()函数的实现如下：

1. /*
   6 R7 p/ g4 V* t1 d5 G) k1 V
2. *********************************************************************************************************
   : m. S9 g! L9 D" Q. M+ `2 w
3. *        函 数 名: bsp_KeyScan10ms
   5 g1 {: B& t" q. R' @) s  K
4. *        功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
   
5. *        形    参: 无
   ( L5 Z" L' j+ N! {
6. *        返 回 值: 无
   & L1 [/ p1 Q" q1 {' j9 E. z' Y
7. *********************************************************************************************************
   - D# l+ ]/ t+ u5 I6 W9 G' N  f
8. */
   - t" D" X6 ]* ~
9. void bsp_KeyScan10ms(void)
     e) j3 e  Q& p- V
10. {
    * q* Y8 B9 O. F. }7 y/ \
11.         uint8_t i;
    
12. 
    
13.         for (i = 0; i < KEY_COUNT; i++)
    
14.         {
    8 E4 o0 @% L; N& L6 }
15.                 bsp_DetectKey(i);
    2 B; x$ e0 p- D* E; |- A  Q
16.         }
    & k& t. k( |8 g
17. }

复制代码

每隔10ms所有的按键GPIO均会被扫描检测一次。bsp_DetectKey函数实现如下：

1. /*
   . U/ ?9 R$ B% i. ~( r* I9 ]
2. *********************************************************************************************************
   4 ~9 \$ s- {! O- }7 r! D2 X. k
3. *        函 数 名: bsp_DetectKey
   & e2 M, H4 H2 a, L; `
4. *        功能说明: 检测一个按键。非阻塞状态，必须被周期性的调用。
     L. l5 E- |( E# x. q: O
5. *        形    参: IO的id， 从0开始编码
   / N  U5 c! \; \8 Y$ m+ f
6. *        返 回 值: 无
   0 G, W* `1 Q* \* F
7. *********************************************************************************************************
   
8. */
   
9. static void bsp_DetectKey(uint8_t i)
   0 ~! r- I) d$ ^. W8 T/ {( w! ^' K& O
10. {
    
11.         KEY_T *pBtn;
    % `% H, H% ?1 `
12. 
    
13.         pBtn = &s_tBtn<span style="font-style: italic;"><span style="font-style: normal;">;
    1 K$ U& g; x. v% O
14.         if (IsKeyDownFunc(i))
    6 m( f- s: |0 M0 n- v& D
15.         {
    
16.                 if (pBtn->Count < KEY_FILTER_TIME)
    ' V* I/ Q5 P* H# n
17.                 {
    9 n2 G$ S  ^% e( C* }) ]
18.                         pBtn->Count = KEY_FILTER_TIME;
    
19.                 }
    
20.                 else if(pBtn->Count < 2 * KEY_FILTER_TIME)
    
21.                 {
    1 F; M0 {. \4 N+ F7 T; ]* ]8 B
22.                         pBtn->Count++;
    
23.                 }
    
24.                 else
    
25.                 {
    
26.                         if (pBtn->State == 0)
    
27.                         {
    6 o; M7 z: d$ K" h- n0 M0 @& O
28.                                 pBtn->State = 1;
    $ V2 t9 x- {1 o( ~% r' A
29. 
    : o) }' ]4 D( Y' @
30.                                 /* 发送按钮按下的消息 */
    9 {: A1 |9 l' S; x4 Z
31.                                 bsp_PutKey((uint8_t)(3 * i + 1));
    6 K0 z$ j+ o! `5 ~6 F0 e7 }& y
32.                         }
    / c. K  T7 T. `9 ^4 q. i
33. 
    1 y* I, m2 I; a! y3 q7 R
34.                         if (pBtn->LongTime > 0)
    
35.                         {
    
36.                                 if (pBtn->LongCount < pBtn->LongTime)
    
37.                                 {
    $ s& Q! _. G/ X& w4 J
38.                                         /* 发送按钮持续按下的消息 */
    
39.                                         if (++pBtn->LongCount == pBtn->LongTime)
    * \: ^' z' G( g. _$ I8 U
40.                                         {
    & D. V  w9 g' G0 q4 }) J
41.                                                 /* 键值放入按键FIFO */
    ' H4 T& x% n- ]5 M$ i: g0 r* ]
42.                                                 bsp_PutKey((uint8_t)(3 * i + 3));
    0 l9 D; m4 H1 ~% C# q  ]
43.                                         }
    
44.                                 }
    
45.                                 else
    . Y4 L6 p# @/ S
46.                                 {
    
47.                                         if (pBtn->RepeatSpeed > 0)
    6 v$ f. P, d5 X
48.                                         {
    ( K$ e" C, q5 x' n: c* A; k/ r
49.                                                 if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
    * L$ X( h  c5 S7 A; g
50.                                                 {
    
51.                                                         pBtn->RepeatCount = 0;
    
52.                                                         /* 常按键后，每隔RepeatSpeed * 10ms发送1个按键 */
    : u# X& h0 p$ b1 Z9 P8 s
53.                                                         bsp_PutKey((uint8_t)(3 * i + 1));
    4 ^9 F+ s( P. N& T  |/ P$ V% J1 W
54.                                                 }
    - W; H* [! _5 w7 c. x
55.                                         }
    : _6 I( U" u/ n1 U9 n
56.                                 }
    
57.                         }
    
58.                 }
    
59.         }
    0 p+ ?1 N# X; w) C
60.         else
    
61.         {
    
62.                 if(pBtn->Count > KEY_FILTER_TIME)
    
63.                 {
    0 q$ F4 P7 S* P+ ~( k3 Y
64.                         pBtn->Count = KEY_FILTER_TIME;
    2 I; I2 o' q" i; S
65.                 }
    
66.                 else if(pBtn->Count != 0)
    6 g% C6 ~, t! F2 |
67.                 {
    
68.                         pBtn->Count--;
    / h( o  g7 Q( h) V
69.                 }
    
70.                 else
    % _% `$ ^4 V8 ?5 C: u
71.                 {
    7 P  Q9 H, \9 ~/ z9 R" I" _
72.                         if (pBtn->State == 1)
    
73.                         {
    
74.                                 pBtn->State = 0;
    
75. 
    " r  s: [; J' [  G& g
76.                                 /* 发送按钮弹起的消息 */
    
77.                                 bsp_PutKey((uint8_t)(3 * i + 2));
    
78.                         }
    
79.                 }
    $ |6 _; u# [5 \% i; C" H% {
80. 
    
81.                 pBtn->LongCount = 0;
    ) E8 n* ^) X1 x1 e
82.                 pBtn->RepeatCount = 0;
    ; B; h5 h$ S8 I, f! G3 {
83.         }
    
84. }</span></span>

复制代码

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

/ H$ [  U2 g, t3 O' e9 D7 Z9 S

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

复制代码

. I6 o  Z% R, m' F读取相应按键的结构体地址，程序里面每个按键都有自己的结构体。

' H" F8 [( u0 t7 U: y

1. static KEY_T s_tBtn[KEY_COUNT];
   9 X/ D  s, `' m
2. if (IsKeyDownFunc(i))
   3 K( i: x! k' {( P
3. {
   ' Y$ S# X, O) e  b% W, U
4.         这个里面执行的是按键按下的处理
   
5. }
   # \) d+ t- o& {; O8 d! l
6. else
   
7. {
   
8.         这个里面执行的是按键松手的处理或者按键没有按下的处理
   ) q5 z$ ^& L4 c. x& F9 Y
9. }

复制代码

执行函数IsKeyDownFunc(i)做按键状态判断。
$ X" O2 @* ~1 @+ D9 h8 g
# r0 }" r% ~9 m- r  t& |* a2 s6 E

1. /*
   
2. **********************************************************************************
   
3. 下面这个if语句主要是用于按键滤波前给Count设置一个初值，前面说按键初始化的时候
   
4. 已经设置了Count = KEY_FILTER_TIME/2
   9 a7 F' G5 O. u* [& b5 G
5. **********************************************************************************
   ' K( b% _; P& l; w
6. */
   
7. if (pBtn->Count < KEY_FILTER_TIME)
   
8. {
   
9.     pBtn->Count = KEY_FILTER_TIME;
     {# @) l6 s' y1 ^9 }1 Z
10. }
    , g" W, G. F/ f' P% w: y
11. 
    
12. /*
    2 g# Z; G9 F' p' e) l' B5 o
13. **********************************************************************************
    2 `# d' `7 q$ i
14. 这里实现KEY_FILTER_TIME时间长度的延迟
    
15. **********************************************************************************
    ; D9 o' A3 F6 N
16. */
    ; s* G7 w9 s0 E6 v
17. else if(pBtn->Count < 2 * KEY_FILTER_TIME)
    ! k  J$ Q' R1 u- u
18. {
    
19.     pBtn->Count++;
    
20. }
    
21. /*
    2 U( c5 o5 |; f- E" B( |, M; s7 J
22. **********************************************************************************
    ; f, c1 N3 C. n3 m$ }7 e7 u7 `
23. 这里实现KEY_FILTER_TIME时间长度的延迟
    
24. **********************************************************************************
    
25. */
    % T/ n9 [2 a" e2 U# j, l* T
26. else
    ) r  A. ~; L" v, F" d) d: E5 e7 v
27. {
    + T" E) y' T/ g1 L6 F8 f  h
28. /*
    / e6 z, o5 z1 R/ ?% {  N' l( D( o5 X
29. **********************************************************************************
    
30. 这个State变量是有其实际意义的，如果按键按下了，这里就将其设置为1，如果没有按下这个
    
31. 变量的值就会一直是0，这样设置的目的可以有效的防止一种情况的出现：比如按键K1在某个
    * _/ ^, l( M4 L
32. 时刻检测到了按键有按下，那么它就会做进一步的滤波处理，但是在滤波的过程中，这个按键
    
33. 按下的状态消失了，这个时候就会进入到上面第二步else语句里面，然后再做按键松手检测滤波
    
34. ，滤波结束后判断这个State变量，如果前面就没有检测到按下，这里就不会记录按键弹起。
    
35. **********************************************************************************
    
36. */
    / x7 C0 p* `, t$ F; y6 j! h
37.     if (pBtn->State == 0)
    
38.     {
    
39.         pBtn->State = 1;
    
40. 
    
41.         /* 发送按钮按下的消息 */
    
42.         bsp_PutKey((uint8_t)(3 * i + 1));
    0 ]  D& F% s) ?3 {$ i8 @! l# `1 A
43.     }
    
44. 
    " u2 ]3 g- h+ d. a$ a
45.     if (pBtn->LongTime > 0)
    
46.     {
    
47.         if (pBtn->LongCount < pBtn->LongTime)
    
48.         {
    
49.             /* 发送按钮持续按下的消息 */
    
50.             if (++pBtn->LongCount == pBtn->LongTime)
    . D! m7 Y) D* t' F; k- Y
51.             {
    4 F# q' f! M& h
52.                 /* 键值放入按键FIFO */
    9 s% n: J. {. c4 e# @$ z, K4 z
53.                 bsp_PutKey((uint8_t)(3 * i + 3));
    3 m# A5 P" {' H1 U# V" U& y8 X  b
54.             }
    5 K+ c6 @: V; Y3 w$ x0 `% U, t
55.         }
    ) n" Y" f% ?1 R8 `/ W' L) l
56.         else
    
57.         {
    7 l; q" w7 M  C- m8 o
58.             if (pBtn->RepeatSpeed > 0)
    
59.             {
    ) B2 {; C. W; V  h! i# G/ d: W
60.                 if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
    
61.                 {
    
62.                     pBtn->RepeatCount = 0;
    
63.                     /* 长按键后，每隔10ms发送1个按键 */
    
64.                     bsp_PutKey((uint8_t)(3 * i + 1));
    
65.                 }
    
66.             }
    
67.         }
    
68.     }
    8 t: @6 }+ K9 Y& `
69. }

复制代码

) r  B4 c- s- i, ?19.3.4 按键检测采用中断方式还是查询方式
检测按键有中断方式和GPIO查询方式两种。我们推荐大家用GPIO查询方式。
) x8 Y/ B2 m4 {0 j' _# g" x
从裸机的角度分析

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

查询方式：查询方式有一个最大的缺点就是需要程序定期的去执行查询，耗费一定的系统资源。实际上耗费不了多大的系统资源，因为这种查询方式也只是查询按键是否按下，按键事件的执行还是在主程序里面实现。

# V- \! O7 M6 C' c& u从OS的角度分析

中断方式：在OS中要尽可能少用中断方式，因为在RTOS中过多的使用中断会影响系统的稳定性和可预见性（抢占式调度的OS基本没有可预见性）。只有比较重要的事件处理需要用中断的方式。
' e& Y0 `7 X# ]6 W8 Q
, l: c8 p# L2 N! I查询方式：对于用户按键推荐使用这种查询方式来实现，现在的OS基本都带有CPU利用率的功能，这个按键FIFO占用的还是很小的，基本都在1%以下。
  R5 K$ e2 K# M" `) j
19.4 按键板级支持包（bsp_key.c）
按键驱动文件bsp_key.c主要实现了如下几个API：
" i8 `& z* A1 @& y) y
  KeyPinActive
* k; J" x" h8 z0 Z  IsKeyDownFunc
  bsp_InitKey
" e/ C" p9 s' `1 ?0 u  bsp_InitKeyHard
, x+ x" M1 N3 X: ?' R& r- H; K  bsp_InitKeyVar
  bsp_PutKey
7 f+ H9 i: H8 m2 o  bsp_GetKey
  bsp_GetKey2
  bsp_GetKeyState
; N0 P: u! J; X) p3 O* W( j: @  bsp_SetKeyParam
  bsp_ClearKey
$ ?% i( M/ y. d/ e- h$ x" o  bsp_DetectKey
  bsp_DetectFastIO
  bsp_KeyScan10ms
  bsp_KeyScan1ms
& _5 J* S7 D! F+ `2 }6 M- U" U4 d
) ]9 A* D( N) A所有这些函数在本章的19.3小节都进行了详细讲解，本小节主要是把需要用户调用的三个函数做个说明。
$ p) }' o0 ]5 K8 ]9 l, J4 ^2 [
$ A& E% v5 l% ]% j; Z5 ?; z, N19.4.1 函数bsp_InitKeyHard
2 {0 ]) S) O& ^1 S函数原型：
. W; `6 c# @/ p, |* O. }' q
2 u8 }7 W+ d& Z! j1 f$ I

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_InitKey
   2 m. B8 g; I8 x3 [) f
4. *        功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
   : g2 G" ?: |2 o
5. *        形    参: 无
   
6. *        返 回 值: 无
   . _- Z2 V( N# A6 f4 C
7. *********************************************************************************************************
   # p* U/ M, H9 _+ I
8. */
   
9. void bsp_InitKey(void)
   
10. {
    
11.         bsp_InitKeyVar();                /* 初始化按键变量 */
    
12.         bsp_InitKeyHard();                /* 初始化按键硬件 */
    
13. }

复制代码

函数描述：

: _! l5 s) t/ c' Y  N. O( t# d此函数主要用于按键的初始化。
+ K: K+ \1 ]" t3 Q" @' J
1 i# h' r; h8 g& Z; W使用举例：
/ p/ c2 W6 Z3 p3 [9 y
底层驱动初始化直接在bsp.c文件的函数bsp_Init里面调用即可。
' N; M: E6 \0 n- F* Y
3 p1 V6 G, O- K19.4.2 函数bsp_GetKey
' ]+ c& Q! o& `6 [- s4 a/ M函数原型：

1. /*
   , q% H2 Q! r; I" r4 R6 ]$ I
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_GetKey
   8 {# T6 @2 G& [) b( |' ?
4. *        功能说明: 从按键FIFO缓冲区读取一个键值。
   
5. *        形    参: 无
   
6. *        返 回 值: 按键代码
   % h+ m' ]2 T* g3 Q0 r- L$ _  I
7. *********************************************************************************************************
   
8. */
   
9. uint8_t bsp_GetKey(void)
   7 t' A5 V9 k5 k& [2 x! P9 p: w
10. {
    
11.         uint8_t ret;
    
12. 
    4 ?0 z  r6 G3 r  y5 E
13.         if (s_tKey.Read == s_tKey.Write)
    
14.         {
    
15.                 return KEY_NONE;
    
16.         }
    
17.         else
    
18.         {
    1 a. d+ Z% m3 y
19.                 ret = s_tKey.Buf[s_tKey.Read];
    2 W1 `# O1 v3 a6 P2 C
20. 
    , w8 {( P1 L  W4 U3 t
21.                 if (++s_tKey.Read >= KEY_FIFO_SIZE)
      j5 W8 c$ r& b( O5 c8 ^3 Y* A
22.                 {
    
23.                         s_tKey.Read = 0;
    * l5 [1 R1 X( k& w: |
24.                 }
    9 W* F9 p3 t' v
25.                 return ret;
    ( u* F# G& p! j/ n) W
26.         }
    
27. }

复制代码

/ K/ _3 b4 \* k函数描述：
9 f. h  D$ ?- J: r$ L7 h
此函数用于从FIFO中读取键值。

使用举例：
' R7 o4 y/ l* j0 ~0 k
调用此函数前，务必优先调用函数bsp_InitKey进行初始化。
7 W  A3 l* v0 v. [' X9 r0 \
8 v( v- {# J2 U4 A1 S' P

1. /*
   " O" C8 }5 h. M# g5 A
2. *********************************************************************************************************
   8 K2 B: x9 Z" t& s, O1 t
3. *        函 数 名: main
   * [+ t9 U) u/ P; N6 u* @( K
4. *        功能说明: c程序入口
   - i4 A  \% d9 B/ W3 x+ u! W
5. *        形    参: 无
   . a8 V* ?7 R  b' @: u
6. *        返 回 值: 错误代码(无需处理)
   - I6 _$ b! @8 h4 v, k
7. *********************************************************************************************************
   
8. */
   
9. int main(void)
     j' u1 S7 ~3 X* x. F5 p1 V
10. {
    ! S+ e. C9 {. i6 H( b8 v
11.         uint8_t ucKeyCode;                /* 按键代码 */
    1 J' w. g' r0 o3 }$ k
12.         
    
13.         bsp_Init();                /* 硬件初始化 */
    & w5 F9 c' v. x% Z6 e( ^; d
14.         
    
15.         /* 进入主程序循环体 */
    " ^/ `0 I) r1 M" s. N7 ], D
16.         while (1)
    " o1 c. T* h( q3 h) R5 T* i
17.         {               
    
18.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    ( a, t3 J) y# O- Y$ n# X& }
19.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    ; J& I9 |: x0 [
20.                 if (ucKeyCode != KEY_NONE)
    9 f, p9 O0 x. Y" h# _
21.                 {
    
22.                         switch (ucKeyCode)
    
23.                         {
    
24.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    
25.                                         printf("K1键按下\r\n");
    ) o- t0 N; J4 w; `
26.                                         break;
    
27. 
    " ^! R- q2 H& f3 Y' d/ d  [7 i5 x
28.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    : P7 z  Q8 c& p6 E$ b% g
29.                                         printf("K2键按下\r\n");
    0 C: P7 \9 U5 J5 D* X
30.                                         break;
    
31. 
    9 J1 |' B3 k, D$ f# J$ ?! Y+ m
32.                                 default:
    
33.                                         /* 其它的键值不处理 */
    
34.                                         break;
    : E6 n0 Q9 e: A% f
35.                         }
    7 \% _; V8 a8 V2 |
36.                 }
    # i4 q9 q3 r, X, P
37.         }
    - T- @" T( }' D" q8 F" W
38. }

复制代码

19.4.3 函数bsp_KeyScan10ms
$ N* n/ U- p8 ~函数原型：
, t) W1 J% \$ |% ]/ b( }- `) p, W

1. /*
   ' _1 ~$ }4 j3 W* T6 `$ d0 u
2. *********************************************************************************************************
     @% f4 D! n5 f8 L5 ?& S3 U
3. *        函 数 名: bsp_KeyScan10ms
   5 z4 r. ?& k- f
4. *        功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. void bsp_KeyScan10ms(void)
   ! Y  C& V- o& J: p# K
10. {
    
11.         uint8_t i;
    
12. 
    * q2 a: }; N, W1 D" B
13.         for (i = 0; i < KEY_COUNT; i++)
    & B/ ?/ F- W' P2 x
14.         {
    
15.                 bsp_DetectKey(i);
    % f& a$ x" _& m1 x6 v6 t' y
16.         }
    8 G! e5 j* H. G$ Y
17. }

复制代码

函数描述：
: G7 s  U- J6 J( [  D4 V
* ^( P7 u$ h* x0 s0 Y此函数是按键的主处理函数，用于检测和存储按下、松手、长按等状态。

( o1 y$ I+ @- d$ o& m使用举例：

' r( n* \# ?9 O7 }$ |. i8 _- G8 J/ u- Y调用此函数前，务必优先调用函数bsp_InitKey进行初始化。
8 W% s: d5 P9 B, y2 D* l4 |: x
& e4 [) X9 x: A7 S; T% x另外，此函数需要周期性调用，每10ms调用一次。
+ \  u( F5 \9 s. K1 E
  如果是裸机使用，将此函数放在bsp.c文件的bsp_RunPer10ms函数里面即可，这个函数是由滴答定时器调用的，也就是说，大家要使用按键，定时器的初始化函数bsp_InitTimer一定要调用。
  如果是RTOS使用，需要开启一个10ms为周期的任务调用函数bsp_KeyScan10ms。
, i+ c( R6 [0 a5 O
: y% [( n2 r0 A' u. D! d$ ]- M19.5 按键FIFO驱动移植和使用
3 G4 ?. p" J$ g; u按键移植步骤如下：
& R# I  Z1 R0 q, A" T( W+ d
  第1步：复制bsp_key.c和bsp_key.c到自己的工程。
  第2步：根据自己使用的独立按键个数和组合键个数，修改几个地方。

1. #define HARD_KEY_NUM        8                     /* 实体按键个数 */
   0 I5 F" E- e( {4 k: W
2. #define KEY_COUNT   (HARD_KEY_NUM + 2)   /* 8个独立建 + 2个组合按键 */

复制代码

' ^! x# A4 q( g$ R8 F  第3步：根据使用的引脚时钟，修改下面函数：
( H8 z) r  ~. U% \- Q0 _3 W

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();        \
   , D8 ^. F0 x7 J2 A9 C, g
7.                 __HAL_RCC_GPIOI_CLK_ENABLE();        \
   
8.         };

复制代码

  第4步：根据使用的具体引脚，修改如下函数，第3列参数低电平表示按下或者高电平表示按下：
2 D" Y, v% m6 Y7 p: s% W" [2 p

1. /* GPIO和PIN定义 */
   4 w7 k" O, k6 t7 {" H
2. static const X_GPIO_T s_gpio_list[HARD_KEY_NUM] = {
   6 q1 T5 I+ g# T6 m
3.         {GPIOI, GPIO_PIN_8, 0},                /* K1 */
   2 d, }, e* y2 P9 V1 m, [7 A: R
4.         {GPIOC, GPIO_PIN_13, 0},        /* K2 */
   0 P. B; G! P1 F
5.         {GPIOH, GPIO_PIN_4, 0},                /* K3 */
   ( P/ r* c9 _& F1 Q+ A5 W, w$ s% P! V
6.         {GPIOG, GPIO_PIN_2, 0},                /* JOY_U */        
   
7.         {GPIOB, GPIO_PIN_0, 0},                /* JOY_D */
   - h+ Q7 @/ l3 \' {  P' {
8.         {GPIOG, GPIO_PIN_3, 0},                /* JOY_L */        
   9 g  Y# Y+ E* `+ P7 B4 V3 D
9.         {GPIOG, GPIO_PIN_7, 0},                /* JOY_R */        
   ' s, u0 J  R% R- h" a
10.         {GPIOI, GPIO_PIN_11, 0},        /* JOY_OK */
    ) ?+ b( L) t+ v( T
11. };   

复制代码

     
9 D4 V, b# I, T  Y3 A  第5步：根据使用的组合键个数，在函数IsKeyDownFunc里面添加相应个数的函数：
2 D0 q3 W" U/ H! o. X

1.         /* 组合键 K1K2 */
   
2.         if (_id == HARD_KEY_NUM + 0)
   ( L7 I9 _/ o# C/ O) z$ N
3.         {
   & n1 \9 j7 O% q6 q2 h6 C! R
4.                 if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
   ( }+ Y$ E" i, g5 W6 \
5.                 {
   - F, g% X9 Z5 c  |( q
6.                         return 1;
   
7.                 }
   
8.                 else
   
9.                 {
   
10.                         return 0;
    " }, ?* }) h0 C6 [% n& v! g
11.                 }
    
12.         }

复制代码

第2行ID表示HARD_KEY_NUM + 0的组合键，HARD_KEY_NUM + 1表示下一个组合键，以此类推。

3 P: I' l2 x3 l) J8 k另外就是，函数KeyPinActive的参数是表示检测哪两个按键，设置0的时候表示第4步里面的第1组按键，设置为1表示第2组按键，以此类推。
) m/ g1 l, |! h
! X8 r* B: D# [7 V& N+ ?) n& S  第6步：主要用到HAL库的GPIO驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
  第7步：移植完整，应用方法看本章节配套例子即可。
+ b0 L! d! L# K特别注意，别忘了每10ms调用一次按键检测函数bsp_KeyScan10ms。
5 @) w  ^5 o5 N: W" u+ ^" b7 d7 W, G# u
19.6 实验例程设计框架
" e$ c( e1 I& q: G+ H通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：
/ f& [: ]7 j$ `! Z  J0 R+ P
; b: t# w; y0 N$ L

6 X3 H& ^/ @$ n  H  g4 @0 ~: c
1、 第1阶段，上电启动阶段：
& E1 d" ~# ^7 f, }6 J
这部分在第14章进行了详细说明。
0 E$ P0 r! T" c: W$ ~, ]- v
2、 第2阶段，进入main函数：

  第1部分，硬件初始化，主要是MPU、Cache、HAL库、系统时钟、滴答定时器、按键等。
' j: P' S7 @3 b/ q8 I/ V  第2部分，应用程序设计部分，实现了一个按键应用。
" ^% @8 _3 a% \8 g! Y1 C( B  第3部分，按键扫描程序每10ms在滴答定时中断执行一次。

+ @) [" k9 L# n, p; p19.7 实验例程说明（MDK）
配套例子：
V7-002_按键检测（软件滤波，FIFO机制）
8 U$ V) m) p6 X/ V& V4 B/ |8 C1 ~
实验目的：
学习按键的按下，弹起，长按和组合键的实现。
. D5 q) Y/ r( ?) a0 M
实验内容：
8 \9 Z5 X+ \: O/ Y启动一个自动重装软件定时器，每100ms翻转一次LED2。
- T- V0 {) _3 O
实验操作：
3个独立按键和5向摇杆按下时均有串口消息打印。
* l, O5 h% d3 j0 X9 E" d5向摇杆的左键和右键长按时，会有连发的串口消息。
0 H6 Y, V8 {8 E' m! e7 L独立按键K1和K2按键按下，串口打印消息。
+ K! `9 I$ X7 X2 g
8 ]+ t* c8 b$ m* c9 D* e上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1

程序设计：

  系统栈大小分配：
" `3 E& U2 Q7 R2 U5 w  B0 t) n

) G; V2 o- E3 z, z1 F  RAM空间用的DTCM：
3 s) a+ g/ L+ P

2 V0 I: R6 X) S% V3 E( g
- w+ ~4 \" t: T% F  硬件外设初始化

8 D$ S, q3 i+ |  D2 ~硬件外设的初始化是在 bsp.c 文件实现：
- {) X3 }; f, K% J; Y5 @

1. /*
   8 l+ A5 d9 E& o0 G. h- R- B5 s
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   * j% C! z  J# Q( C: A9 v
5. *        形    参：无
   
6. *        返 回 值: 无
   ; C- t# t2 a* C) f' a+ l
7. *********************************************************************************************************
   
8. */
   
9. void bsp_Init(void)
   ; N( T* z! f- H
10. {
    
11.     /* 配置MPU */
    
12.         MPU_Config();
    4 p2 |* N; x3 h
13.         
    
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    : Z) W- s: o; }2 k0 @3 Q
16. 
    
17.         /*
    & \% t1 Q4 O& B5 M* a% N
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    5 E8 }- p, Z- S: @5 W4 V) z7 O# b
21.          */
    ( |& N3 w* e  o8 J- w
22.         HAL_Init();
    
23. 
    
24.         /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
      q$ Y" t* D4 h$ C1 f
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    " J) _8 m6 c# ]5 X$ A
28.     */
    3 V- P: f7 G& E
29.         SystemClock_Config();
    
30. 
    
31.         /*
    8 @: K# G2 Z: z- x) n. N
32.            Event Recorder：
    ; w) X! R* f* W2 ?+ W3 [
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    * p# d& X. Y2 K( `4 x- X
35.         */        
    , ?6 q' h. E- ]# |; e" g  P$ l2 `
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    
40. #endif
    ; a' Z1 \2 g3 C8 n) }
41.         
      f- `! D7 |- |0 x, P$ w
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    " e4 N$ ^5 v; S# K
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    : L- ?% @- @- @* L3 C2 X
46.         bsp_InitLed();            /* 初始化LED */        
    ! [0 j* s0 X; S3 ^
47. }

复制代码

4 c$ A# j& ]( X9 K! M. k$ Q  MPU配置和Cache配置：
" q  u' `3 N9 n7 l
* P4 J* `$ o9 q  h$ j数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

$ [3 \8 q. n5 a# M. z

1. /*
   ; I9 e4 I5 M0 W7 g' W
2. *********************************************************************************************************
   ; O, Y7 ~9 N* Q" Y& V1 ], o
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   8 J" t+ x0 L$ A( |5 G
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   7 K1 J3 e! X, X, V/ L
9. static void MPU_Config( void )
   2 H, v1 D# i$ ?) {1 s. d% |
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    2 U) l+ O, r; D5 r1 v
12. 
    ) v# t) P+ M: }, g
13.         /* 禁止 MPU */
    ; e9 S4 `' J+ @3 m5 p7 ~2 ]: U# t5 \
14.         HAL_MPU_Disable();
    ; F% }; z$ A: q* ~3 B
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    8 Z: V4 m* t  u
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;
    
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    1 j% h. ]( d3 }0 T
30.         
    
31.         
    + G5 ^' ]' O" N0 g$ t
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    3 U% ]# L) p( W
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    + c' [. ]3 u& J5 w; [1 U* N
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    1 Z$ E3 \, P$ s/ }1 H; J
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ! ]$ H7 |5 r6 A9 B
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    9 M7 M) `/ Q+ Y6 `: i1 }% H
46. 
    " [. ?4 D* c% c9 `
47.         /*使能 MPU */
    
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    , z, ~: B2 l3 A. z+ \1 j; y4 T2 X
50. 
    % C  p3 o) e$ `- A  Z' {- E& S/ |
51. /*
    
52. *********************************************************************************************************
    3 O- h0 D; H5 e" D& o6 L
53. *        函 数 名: CPU_CACHE_Enable
    
54. *        功能说明: 使能L1 Cache
    ' W2 w2 ]. g! w& l, d) m
55. *        形    参: 无
    ) w4 O# ^# E% P$ l8 ]& ?5 I. n
56. *        返 回 值: 无
    : X6 d$ C5 D3 x4 r( h7 }
57. *********************************************************************************************************
    
58. */
    
59. static void CPU_CACHE_Enable(void)
    " a6 |. l% u, U- _
60. {
    
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    
63. 
    
64.         /* 使能 D-Cache */
    
65.         SCB_EnableDCache();
    
66. }

复制代码

* k5 d1 ?' K2 {  h- z  i% r0 j  每10ms调用一次按键检测：

$ v' U. [( a" H/ D* h按键检测是在滴答定时器中断里面实现，每10ms执行一次检测。

1. /*
   + z- J) Y0 G' ?4 _8 C7 J" {
2. *********************************************************************************************************
   , x  K' w$ j4 X* k+ Z
3. *        函 数 名: bsp_RunPer10ms
   
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   8 }; L/ I4 S. H8 S
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   , Q+ g9 w4 ~# Y. a% X9 j3 r9 s
6. *        形    参: 无
   
7. *        返 回 值: 无
   
8. *********************************************************************************************************
   / Y  o8 Q2 G; V7 P. a4 |- B0 @
9. */
   
10. void bsp_RunPer10ms(void)
    
11. {
    
12.         bsp_KeyScan10ms();
    
13. }

复制代码

' [; f; U$ @- G6 M) a( }  主功能：

主功能的实现主要分为两部分：
3 c, R4 C! T4 l! J: a( F
启动一个自动重装软件定时器，每100ms翻转一次LED2
按键消息的读取，检测到按下后，做串口打印。
* [, o" b4 J, b8 o3 e  w

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: main
   & B% u" S) e+ a  @& D. b3 O6 D, x
4. *        功能说明: c程序入口
   0 M  q. Q' ]" p0 j  g
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   , k  g  \) b1 A; h& T3 E0 Q7 e
7. *********************************************************************************************************
   
8. */
   ( E  G6 q) I1 h- b2 B
9. int main(void)
   
10. {
    : }. v# W9 m3 g3 T" b: Q7 c
11.         uint8_t ucKeyCode;                /* 按键代码 */
    
12.         
    ' H: v- N$ K3 \7 E9 ^$ i
13.         bsp_Init();                /* 硬件初始化 */
    
14.         
    - ~/ u! r4 f- J3 R* r
15.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
16.         PrintfHelp();        /* 打印操作提示 */
    
17. 
    
18. 
    
19.         bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 */
    
20.         
    
21.         /* 进入主程序循环体 */
    9 i4 e- u' X9 h$ T: |
22.         while (1)
    5 W" f1 |( K0 l( g  _- b$ x
23.         {
    0 W# e1 Y2 u* G& f& s
24.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
25. 
    
26.                 /* 判断定时器超时时间 */
    : T) o0 s2 x9 [& w  N
27.                 if (bsp_CheckTimer(0))        
    ( h4 q( q9 Y) |+ X+ d$ s
28.                 {
    8 B/ A! d9 P+ K( _3 u
29.                         /* 每隔100ms 进来一次 */  
    
30.                         bsp_LedToggle(2);                        
    % C3 Z9 g: Z% t: s' x: Y: ]
31.                 }
    
32.                
    
33.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
34.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
35.                 if (ucKeyCode != KEY_NONE)
    , E0 U- c, g4 d5 R; J+ g/ J8 k! c" l
36.                 {
    ! v4 R* h1 f; N
37.                         switch (ucKeyCode)
    0 M% c+ o) y7 P# J/ f
38.                         {
    
39.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    " W1 K$ ^' b/ ]7 _) B: d, A$ {
40.                                         printf("K1键按下\r\n");
    7 ^% R+ N" }1 ]. ]$ G* v* r" L4 G
41.                                         break;
    
42. 
    
43.                                 case KEY_UP_K1:                                /* K1键弹起 */
    + ~, I; n0 l6 \4 x! O3 [
44.                                         printf("K1键弹起\r\n");
    ( y. o. \; n* v
45.                                         break;
    ' s. A; {0 ^3 C
46. 
    0 s! H! ^5 z' G7 v! z
47.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    
48.                                         printf("K2键按下\r\n");
    
49.                                         break;
    $ X% x5 `; S. X" Y: v  _
50. 
    , r$ Q. ~0 O6 K  A
51.                                 case KEY_UP_K2:                                /* K2键弹起 */
    2 g" I) \8 ~0 Q; b& C8 g  ~
52.                                         printf("K2键弹起\r\n");
    6 {7 T1 w! Y' T
53.                                         break;
    
54. 
    
55.                                 case KEY_DOWN_K3:                        /* K3键按下 */
    
56.                                         printf("K3键按下\r\n");
    
57.                                         break;
    
58. 
    / C$ W' _8 u4 n2 H$ I; A
59.                                 case KEY_UP_K3:                                /* K3键弹起 */
    
60.                                         printf("K3键弹起\r\n");
    
61.                                         break;
    $ w8 S: u3 T2 X/ ]2 ^" H
62. 
    8 ]/ Y' U7 Q/ t% F! T
63.                                 case JOY_DOWN_U:                        /* 摇杆UP键按下 */
    
64.                                         printf("摇杆上键按下\r\n");
    
65.                                         break;
    
66. 
    % f5 ~- |- E. b  Y" t% N$ A1 T
67.                                 case JOY_DOWN_D:                        /* 摇杆DOWN键按下 */
    
68.                                         printf("摇杆下键按下\r\n");
    1 F+ B5 k& u/ \
69.                                         break;
    2 W* ], `0 k6 |
70. 
    / Z" D  }! d1 L4 E! ~, P
71.                                 case JOY_DOWN_L:                        /* 摇杆LEFT键按下 */
    
72.                                         printf("摇杆左键按下\r\n");
    
73.                                         break;
    
74.                                 
    
75.                                 case JOY_LONG_L:            /* 摇杆LEFT键长按 */
    ' u! }9 T# `/ u
76.                                         printf("摇杆左键长按\r\n");
    
77.                                         break;
    % r) K8 S- \5 n  j( \
78. 
    . F' u4 i, M0 p/ f! O6 f; k; t
79.                                 case JOY_DOWN_R:                        /* 摇杆RIGHT键按下 */
    / j& \* d9 l; Q/ L, @" p  r
80.                                         printf("摇杆右键按下\r\n");
    . U- ]3 Z5 L: E3 s* o7 W
81.                                         break;
    
82.                                 
    
83.                                 case JOY_LONG_R:            /* 摇杆RIGHT键长按 */
    
84.                                         printf("摇杆右键长按\r\n");
    ' L) q, m. ^7 _. Q! ]# @) d
85.                                         break;
    
86. 
    
87.                                 case JOY_DOWN_OK:                        /* 摇杆OK键按下 */
    
88.                                         printf("摇杆OK键按下\r\n");
    
89.                                         break;
    
90. 
    
91.                                 case JOY_UP_OK:                        /* 摇杆OK键弹起 */
    9 o& O/ ], ?/ n* n1 ~. E! Z# x
92.                                         printf("摇杆OK键弹起\r\n");
    
93.                                         break;
    
94. 
    9 K: a1 G5 e: e% \3 ~' \
95.                 case SYS_DOWN_K1K2:                        /* 摇杆OK键弹起 */
    
96.                                         printf("K1和K2组合键按下\r\n");
    
97.                                         break;
    
98. 
    3 x/ @1 W" e4 N
99.                                 default:
      v& i) ^- e& X5 D4 H% i
100.                                         /* 其它的键值不处理 */
     # @+ o% d. r: Z9 T* n. ^+ a
101.                                         break;
     " Q1 n0 P0 l: T0 B1 X* n1 H, V; J- ]
102.                         }
     
103.                
     6 K6 X' [. n' I# t
104.                 }
     : n4 o! _* [% f5 C+ @
105.         }
     
106. }

复制代码

19.8 实验例程说明（IAR）
& G! D! \' u; z配套例子：
% `& I9 X/ h" B, p  z5 y7 [& W3 JV7-002_按键检测（软件滤波，FIFO机制）
8 }# o; Q: u6 x! j
实验目的：
& [3 Z) y5 t8 W' p学习按键的按下，弹起，长按和组合键的实现。
0 k& ~& f" d; W! q0 e* I2 p
+ s+ V: @  r0 q  j实验内容：
2 z- _. s$ l: R: Q3 p启动一个自动重装软件定时器，每100ms翻转一次LED2。

实验操作：
- x6 c% ~8 |$ R. ]% e' K3个独立按键和5向摇杆按下时均有串口消息打印。
% ~" [. \/ I* z- c; H  F5向摇杆的左键和右键长按时，会有连发的串口消息。
独立按键K1和K2按键按下，串口打印消息。

1 n8 A1 m+ B$ G) U, _上电后串口打印的信息：
9 j: w$ C3 I1 {/ {" R
波特率 115200，数据位 8，奇偶校验位无，停止位 1
3 P# T% X% t8 H
! Q2 q: x2 p4 S

程序设计：

5 A  v) O7 A" ?( @6 ~1 e( P  系统栈大小分配：

, Q' \  P) V9 y% t& y
# s3 k9 i* T, y! [; l  RAM空间用的DTCM：

5 i# d: @0 ^: W# H" V5 O, b: x/ M

  硬件外设初始化

7 o7 J# m3 N0 Z' O* w硬件外设的初始化是在 bsp.c 文件实现：
9 F& _) j$ M# R

1. /*
   1 m/ W& N0 x8 `7 r
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   ( S4 o8 a3 a. z/ o5 O+ ~
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   3 t2 A5 l- \2 B: f. d
5. *        形    参：无
   " O+ ?$ Z+ g( l
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   & n& F5 K2 _$ u# v8 G/ f2 s
8. */
   
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    
12.         MPU_Config();
    
13.         
    ! i) N0 K4 p: G) ]7 w
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
      {  Y3 Y4 w: v; c% z
16. 
    
17.         /*
    ! A: F7 j4 n6 c* e+ v- |
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    
21.          */
    9 Y3 S, m* \: A! C1 P
22.         HAL_Init();
    5 u. I7 B2 B$ a/ l$ L8 F
23. 
    & u( C% S; s4 Y& ^
24.         /*
    / ~5 S. @8 k, _% w8 V3 h5 ^  q
25.        配置系统时钟到400MHz
    % H* e7 C+ T9 r$ l, \. A
26.        - 切换使用HSE。
    1 ]0 f% `2 S& v8 H; c
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    ' Z) I& t1 `5 I* K: K! `, l
29.         SystemClock_Config();
    
30. 
    5 g! u1 b* {" _# M' t, Y; I  ~
31.         /*
    
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    - u- S+ m3 ~) Z/ a
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    ; n& }$ Z5 Z, {0 D
35.         */        
    
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    2 u1 ~; q! k3 P8 i: _' Y/ m. H8 H+ }4 S1 v
38.         EventRecorderInitialize(EventRecordAll, 1U);
    9 w1 F/ Q' K; k, H9 z  R/ R$ ~
39.         EventRecorderStart();
    
40. #endif
    
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    $ Y3 F! W$ B9 i. o" }) D2 |& ?
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    " w3 g- t! `2 d) _& ^- K
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    0 E  c- Y4 h. ?" Z2 J1 W" c
46.         bsp_InitLed();            /* 初始化LED */        
    ! ?* p4 Z$ y6 D! S; S
47. }

复制代码

  MPU配置和Cache配置：
& z8 D+ m2 _. D+ L5 r! u" K
数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

1. /*
   
2. *********************************************************************************************************
   * ?3 f. A$ ^# d
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   - E" I8 K" X( U; t3 K& A
7. *********************************************************************************************************
   
8. */
   
9. static void MPU_Config( void )
   ; L* }1 {1 m' s; m6 C# I
10. {
    : B; ~( z9 h# \9 Y
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    / B% G) W* c0 l1 ~. T% a( Y
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    $ p4 r1 W/ M- v+ K
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    0 s4 c: g% P, l! t* }! H
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    0 [& V6 W3 W1 L+ P
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
      m2 K( ~( c) \3 R9 ~5 K
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    ; h! L  y+ [# [" I8 @- z6 Z. `' U
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    ' a4 e% [3 O( I9 c# _! k2 F2 h, a
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    7 y6 u# `4 m1 |1 o/ O
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    2 C; O7 ]5 a5 z; v/ J; Q
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    , E! L5 F, A3 i1 `* y4 b
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    0 Z8 c. p- z, ~, ]
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    " ]9 n1 J( z1 j* _- H5 b' Z1 E
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    8 F# }2 p6 c6 q
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    1 Z, {- f4 x% F4 M) P- Q+ x! w& C
46. 
    
47.         /*使能 MPU */
    + F0 C  V5 b$ I
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    , s, U8 n" S& s  U
49. }
    " ?' g) w- c. ]# d; F
50. 
    & {) G3 k, e1 ~% P5 C8 g
51. /*
    2 v; ?- Q# ]  x
52. *********************************************************************************************************
    ( M+ S) i+ [8 Y# z" c
53. *        函 数 名: CPU_CACHE_Enable
    8 u& \$ z" V8 B( S# _
54. *        功能说明: 使能L1 Cache
    
55. *        形    参: 无
    2 X$ S" U" ]% N- d
56. *        返 回 值: 无
    
57. *********************************************************************************************************
    
58. */
    , I5 e% ^* M" q
59. static void CPU_CACHE_Enable(void)
    
60. {
    0 u7 M4 \+ x- ~. B; M4 T0 L
61.         /* 使能 I-Cache */
    4 n3 |! L4 D+ S% R
62.         SCB_EnableICache();
    / ~" K, e( U5 d; @- k5 q
63. 
    
64.         /* 使能 D-Cache */
    ) _  K  G" z) z6 o) i7 |
65.         SCB_EnableDCache();
    
66. }

复制代码

  每10ms调用一次按键检测：
4 e3 H# Y1 k* @% v
按键检测是在滴答定时器中断里面实现，每10ms执行一次检测。

7 |" G; x, e; ]& d& {' T

1. /*
     R" k) |8 c; q% h8 p1 Q
2. *********************************************************************************************************
   * J+ t4 E2 f" j' _2 [
3. *        函 数 名: bsp_RunPer10ms
   
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *        形    参: 无
   
7. *        返 回 值: 无
   
8. *********************************************************************************************************
   . z  F0 D! \4 x( s: _* w
9. */
   
10. void bsp_RunPer10ms(void)
    3 `* H8 s& B! j& W% D" A# `
11. {
    
12.         bsp_KeyScan10ms();
    ) g- z, b# s: P3 ]6 P, I& n, X0 q
13. }

复制代码

9 b: r. M6 S  N% A& s, P$ I 主功能：
, _# g* v$ C) f4 v
) c+ N8 I2 ~9 Q主功能的实现主要分为两部分：

启动一个自动重装软件定时器，每100ms翻转一次LED2
按键消息的读取，检测到按下后，做串口打印。

1. /*
   ( D  K( }6 {9 W( ~. |
2. *********************************************************************************************************
   
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   " ]& m. W% K7 q$ h
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   
9. int main(void)
   
10. {
    ! ^: d, |7 E) u
11.         uint8_t ucKeyCode;                /* 按键代码 */
    ' F0 ~2 }  W3 O
12.         
    
13.         bsp_Init();                /* 硬件初始化 */
    
14.         
    6 H$ z+ r, ?& n  T
15.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    9 f/ R/ ~  c. _# ^" O' k/ v( J
16.         PrintfHelp();        /* 打印操作提示 */
    7 }& ?4 L  b2 k5 o0 T) c
17. 
    , Y! D: ]2 b5 C. F
18. 
    * X) L9 h! C6 {0 r1 d
19.         bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 */
    
20.         
    
21.         /* 进入主程序循环体 */
    
22.         while (1)
    
23.         {
    
24.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
25. 
    
26.                 /* 判断定时器超时时间 */
    * L7 M9 _: e  q  z0 }
27.                 if (bsp_CheckTimer(0))        
    
28.                 {
    $ U; y, E  ~* ^6 k8 t* l- i
29.                         /* 每隔100ms 进来一次 */  
    ' ^+ i( u7 |* A; O9 A3 h; ]& `* F
30.                         bsp_LedToggle(2);                        
    
31.                 }
    
32.                
    
33.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
34.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    # S4 Y9 X: a$ o0 g2 |8 m/ B
35.                 if (ucKeyCode != KEY_NONE)
    3 ]0 ?# y: }0 R
36.                 {
    
37.                         switch (ucKeyCode)
    3 _; o1 T# K7 J. E4 ^
38.                         {
    
39.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    5 X- `8 [7 `2 V+ q2 P0 m# \
40.                                         printf("K1键按下\r\n");
    
41.                                         break;
    6 F- D6 g% G6 Q, a  j; P$ ~
42. 
    & S: q& h3 Y' `5 k3 [/ w1 v
43.                                 case KEY_UP_K1:                                /* K1键弹起 */
    
44.                                         printf("K1键弹起\r\n");
    
45.                                         break;
    
46. 
    
47.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    / Z: g; p2 S- r
48.                                         printf("K2键按下\r\n");
    
49.                                         break;
    " Y( t# ?3 z1 O# y
50. 
    1 J% b7 q0 U# b7 K
51.                                 case KEY_UP_K2:                                /* K2键弹起 */
    / X( J1 R' _! p1 k7 U* {8 |
52.                                         printf("K2键弹起\r\n");
    
53.                                         break;
    
54. 
    ( v1 A6 S, ]8 J8 ?
55.                                 case KEY_DOWN_K3:                        /* K3键按下 */
    8 I2 }( J  {$ v# i7 ]% h
56.                                         printf("K3键按下\r\n");
    ; q4 [' O3 e6 v
57.                                         break;
    - |) a2 P4 y% b' h5 b9 c/ X
58. 
    1 \$ n% X' a3 e
59.                                 case KEY_UP_K3:                                /* K3键弹起 */
      }: G* c1 {; k7 _9 I) B) ^% H
60.                                         printf("K3键弹起\r\n");
    
61.                                         break;
    0 x; h' {  [- M9 L; e" E5 Y) K8 h$ G
62. 
    * E: Z$ ]" A+ a
63.                                 case JOY_DOWN_U:                        /* 摇杆UP键按下 */
      P8 [1 `& X( O# S8 \6 Z
64.                                         printf("摇杆上键按下\r\n");
    
65.                                         break;
    2 F& M5 h  c8 Y3 `' e3 x
66. 
    
67.                                 case JOY_DOWN_D:                        /* 摇杆DOWN键按下 */
    1 f  V' C3 U6 H. H) [4 |+ t- {
68.                                         printf("摇杆下键按下\r\n");
    7 v* x, S7 i2 N  E8 o- I
69.                                         break;
    
70. 
    
71.                                 case JOY_DOWN_L:                        /* 摇杆LEFT键按下 */
    
72.                                         printf("摇杆左键按下\r\n");
    ( K2 t2 c2 {8 P: h+ G
73.                                         break;
    
74.                                 
    
75.                                 case JOY_LONG_L:            /* 摇杆LEFT键长按 */
    7 P/ f" T. s) S# T* X1 r
76.                                         printf("摇杆左键长按\r\n");
    
77.                                         break;
    + P8 E, c+ {9 O
78. 
    5 r. ?. i4 R, x/ u/ B5 S7 u( u4 y
79.                                 case JOY_DOWN_R:                        /* 摇杆RIGHT键按下 */
    * o7 E2 U0 j$ y
80.                                         printf("摇杆右键按下\r\n");
    
81.                                         break;
    , j" `4 J( S2 E, y2 Q
82.                                 
    " x: f4 V+ v3 ]# W# x
83.                                 case JOY_LONG_R:            /* 摇杆RIGHT键长按 */
    6 E: ^& l1 V  f1 w) E4 j' y
84.                                         printf("摇杆右键长按\r\n");
    ! Y3 J9 P$ ]* J% a5 D% e( F0 l' r
85.                                         break;
    ' l. ]9 z) J) u! F# z4 L
86. 
    
87.                                 case JOY_DOWN_OK:                        /* 摇杆OK键按下 */
    % e! C. [9 ^& M& o1 \5 m. d
88.                                         printf("摇杆OK键按下\r\n");
    . p% V0 K- c3 t7 {
89.                                         break;
    . I* _( K" Q. q- k: X+ V( E- X6 \
90. 
    
91.                                 case JOY_UP_OK:                        /* 摇杆OK键弹起 */
    
92.                                         printf("摇杆OK键弹起\r\n");
    * g% ~' T( T+ d) }1 x
93.                                         break;
    
94. 
    
95.                 case SYS_DOWN_K1K2:                        /* 摇杆OK键弹起 */
    
96.                                         printf("K1和K2组合键按下\r\n");
    
97.                                         break;
    
98. 
    
99.                                 default:
    ( G2 C( W3 E+ u* K
100.                                         /* 其它的键值不处理 */
     
101.                                         break;
     
102.                         }
     - j) n" [# q* Q6 ?. ~+ f
103.                
     ! U. ?+ E  ]/ u" j/ o# F8 u
104.                 }
     
105.         }
     
106. }

复制代码

/ ~! l; H+ E0 T) f+ q& I7 }19.9 总结
这个方案在实际项目中已经经过千锤百炼，大家可以放心使用。建议熟练掌握其用法。


4 p) w6 v7 n6 v' s5 ?