19.1 初学者重要提示
& r( R5 o" J1 B7 g, D  p 按键FIFO驱动扩展和移植更简单，组合键也更好用。支持按下、弹起、长按和组合键。

7 F* j& ]- J2 j( s! V! v2 m& ?2 Z19.2 按键硬件设计
* M6 B* P2 G. r9 UV7开发板有三个独立按键和一个五向摇杆，下面是三个独立按键的原理图：

. C8 m1 [6 D; I& M, d
; e9 c2 D6 }/ `' |* c+ {注意，K1（S1）、K2(S2)和K3(S3)按键的上拉电阻是接在5V电压上，因为这三个按键被复用为PS/2键盘鼠标接口，而PS/2是需要5V供电的（注，V5和V6开发板做了PS/2复用，而V7没有使用，这里只是为了兼容之前的板子）。实际测试，K1、K2、K3按键和PS/2键盘是可以同时工作的。

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

通过这个硬件设计，有如下两个知识点为大家做介绍：
: J' \8 k3 Z3 z
, Z0 U) t  A9 x( L19.2.1 硬件设计
3 [+ g1 j' z$ O0 _2 e" t& ~按键和CPU之间串联的电阻起保护作用。按键肯定是存在机械抖动的，开发板上面的硬件没有做硬件滤波处理，即使设计了硬件滤波电路，软件上还是需要进行滤波。

, P* W; d& j* J) O. A* {7 x  保护GPIO，避免软件错误将IO设置为输出，如果设置为低电平还好，如果设置输出的是高电平，按键按下会直接跟GND(低电平)连接，从而损坏MCU。
& r0 ^9 Y+ I( r5 V! Z" h$ b  保护电阻也起到按键隔离作用，这些GPIO可以直接用于其它实验。
9 Q, E( B8 S! g( v' }19.2.2 GPIO内部结构分析按键
3 Q5 I. d5 G/ O7 e, z/ y详细的GPIO模式介绍，请参考第15章的15.3小节，本章仅介绍输入模式。下面我们通过一张图来简单介绍GPIO的结构。

红色的线条是GPIO输入通道的信号流向，作为按键检测IO，这些需要配置为浮空输入。按键已经做了5V上拉，因此GPIO内部的上下拉电阻都选择关闭状态。

: K+ x& w: Z, J) u19.3 按键FIFO的驱动设计
) g: j) k4 D& ]" r" ubsp_key按键驱动程序用于扫描独立按键，具有软件滤波机制，采用FIFO机制保存键值。可以检测如下事件：
8 F' S4 o  i8 q' Q  f7 H
, e( M) n- {' w. v  按键按下。
, f# L( T+ y& J& z  O  按键弹起。
  长按键。
  长按时自动连发。
我们将按键驱动分为两个部分来介绍，一部分是FIFO的实现，一部分是按键检测的实现。
& Z' i! C  S! c8 ^- K  Q/ V) x$ P
+ U2 R# P; \- {$ K4 j8 ~; s

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

bsp.c 文件会调用bsp_InitKey()初始化函数。

bsp.c 文件会调用bsp_KeyScan按键扫描函数。

+ y2 Y8 ~5 |5 y1 g7 `  h* ^% E4 Y0 u$ Obsp_timer.c 中的Systick中断服务程序调用 bsp_RunPer10ms。
9 E0 B4 q- y" q2 s7 L
2 m0 x8 O7 }% |4 _- |9 f中断程序和主程序通过FIFO接口函数进行信息传递。
5 E- W; f5 }9 V: t0 Q9 c
函数调用关系图：

: i3 `6 o7 y1 @0 }  Y

$ ]# X# J2 e' S# R; B- A3 H2 W
+ t) ]! @, |) ]4 ^" J19.3.1 按键FIFO的原理
FIFO是First Input First Output的缩写，先入先出队列。我们这里以5个字节的FIFO空间进行说明。Write变量表示写位置，Read变量表示读位置。初始状态时，Read = Write = 0。

& c5 k% r1 q; M

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

4 ]9 ~+ z  _' D) |+ K8 E7 n7 {
$ Z& o9 J! N8 ~, ?7 y如果Write！= Read，则我们认为有新的按键事件。
" F$ |7 C5 h5 t
我们通过函数bsp_GetKey读取一个按键值进行处理后，Read变量变为1。Write变量不变。

2 A1 c+ {. f3 r$ u

) R. S2 d$ Y& L, P9 c
$ Z  |6 r, u, f! _  a7 `8 }" t我们继续通过函数bsp_GetKey读取3个按键值进行处理后，Read变量变为4。此时Read = Write = 4。两个变量已经相等，表示已经没有新的按键事件需要处理。

; M: ?, }, S5 C" Z$ K有一点要特别的注意，如果FIFO空间写满了，Write会被重新赋值为0，也就是重新从第一个字节空间填数据进去，如果这个地址空间的数据还没有被及时读取出来，那么会被后来的数据覆盖掉，这点要引起大家的注意。我们的驱动程序开辟了10个字节的FIFO缓冲区，对于一般的应用足够了。
# q* S3 ?) v. @' x
设计按键FIFO主要有三个方面的好处：
8 w6 c0 a# B2 f6 p. z
  可靠地记录每一个按键事件，避免遗漏按键事件。特别是需要实现按键的按下、长按、自动连发、弹起等事件时。
0 w1 W. `: [" i1 Y  读取按键的函数可以设计为非阻塞的，不需要等待按键抖动滤波处理完毕。
  按键FIFO程序在嘀嗒定时器中定期的执行检测，不需要在主程序中一直做检测，这样可以有效地降低系统资源消耗。
/ P; I) S' @3 e1 t3 T. b" o) }$ H
1 j2 ?+ u( X$ J: Q% d" t19.3.2 按键FIFO的实现
在bsp_key.h 中定了结构体类型KEY_FIFO_T。这只是类型声明，并没有分配变量空间。
6 Z* @+ V$ p" e+ E$ t9 D# L2 {

1. #define KEY_FIFO_SIZE        10
   
2. typedef struct
   % l+ M7 B; D# l& d" }9 @$ L& J
3. {
   
4.         uint8_t Buf[KEY_FIFO_SIZE];                /* 键值缓冲区 */
   9 t9 {, I/ e: W" r, T
5.         uint8_t Read;                                        /* 缓冲区读指针1 */
   
6.         uint8_t Write;                             /* 缓冲区写指针 */
   
7.         uint8_t Read2;                             /* 缓冲区读指针2 */
   9 ^/ z: S  v# e5 j- S" `
8. }KEY_FIFO_T;

复制代码

在bsp_key.c 中定义s_tKey结构变量, 此时编译器会分配一组变量空间。

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

复制代码

一般情况下，只需要一个写指针Write和一个读指针Read。在某些情况下，可能有两个任务都需要访问按键缓冲区，为了避免键值被其中一个任务取空，我们添加了第2个读指针Read2。出厂程序在bsp_Idle()函数中实现的按K1K2组合键截屏的功能就使用的第2个读指针。
6 e6 |* l! x' c( R( ^- \
当检测到按键事件发生后，可以调用 bsp_PutKey函数将键值压入FIFO。下面的代码是函数的实现：

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_PutKey
   
4. *        功能说明: 将1个键值压入按键FIFO缓冲区。可用于模拟一个按键。
   
5. *        形    参: _KeyCode : 按键代码
     e; Q; A0 H7 R9 r% J
6. *        返 回 值: 无
   & s& b# R; ?2 A# ~# i8 q9 a0 X
7. *********************************************************************************************************
   3 Y9 x& ]* L: A9 v
8. */
   , M# y- O' B, H' D7 r3 X
9. void bsp_PutKey(uint8_t _KeyCode)
   
10. {
    ; m" g8 v( M! i1 ~: Z
11.         s_tKey.Buf[s_tKey.Write] = _KeyCode;
    5 F/ I" |& t& a6 w: `
12. 
    9 o, g: d8 V: `6 D) I! Z
13.         if (++s_tKey.Write  >= KEY_FIFO_SIZE)
    4 L; N# f% C7 ^1 u8 J( o: D
14.         {
    
15.                 s_tKey.Write = 0;
    
16.         }
    
17. }

复制代码

1 j  n/ |! ~  @9 x2 z" k这个bsp_PutKey函数除了被按键检测函数调用外，还可以被其他底层驱动调用。比如红外遥控器的按键检测，也共用了同一个按键FIFO。遥控器的按键代码和主板实体按键的键值统一编码，保持键值唯一即可实现两套按键同时控制程序的功能。
$ c  ]! i* k- o% q
应用程序读取FIFO中的键值，是通过bsp_GetKey函数和bsp_GetKey2函数实现的。我们来看下这两个函数的实现：
/ W* A0 K8 I. i8 j) U
0 }; W; S# t5 [) e! v8 A" w3 W

1. /*
   * f5 r/ r/ W7 |' j  @8 {, P
2. *********************************************************************************************************
     }) K. n6 M) N# |
3. *        函 数 名: bsp_GetKey
   / U4 ]1 N" p: Y
4. *        功能说明: 从按键FIFO缓冲区读取一个键值。
   
5. *        形    参:  无
   5 E; S/ w$ p$ @* e' X9 g
6. *        返 回 值: 按键代码
   
7. *********************************************************************************************************
   
8. */
   + j( k0 E. X* M  E
9. uint8_t bsp_GetKey(void)
   
10. {
    , U9 O- T$ O8 W4 F
11.         uint8_t ret;
    
12. 
    3 O1 j8 f0 l5 F9 O* c* F' k
13.         if (s_tKey.Read == s_tKey.Write)
    . f% v$ e# T* w: B9 E3 A: Q: T
14.         {
    
15.                 return KEY_NONE;
    8 z( F9 e8 Q* a
16.         }
    5 W' B7 k# @+ t9 E9 V( o
17.         else
    3 _) t( K% o. E' Y7 [2 O9 a7 x
18.         {
    ) r5 o, K/ K$ h4 }8 r' t  t" S
19.                 ret = s_tKey.Buf[s_tKey.Read];
    : u  @3 B( }# W& j
20. 
    : k4 W0 J% w7 {* o6 y
21.                 if (++s_tKey.Read >= KEY_FIFO_SIZE)
    # O9 H3 D* {! \/ C1 g+ {
22.                 {
    0 G7 d+ T; Y3 E# v" W
23.                         s_tKey.Read = 0;
    
24.                 }
    ) C8 }: c( {$ k  G: p
25.                 return ret;
    
26.         }
    2 i+ i; v% r& h3 K
27. }
    : D) `% x, T% y0 c+ L% s; E
28. 
    2 e6 H9 g9 J& U: L
29. /*
    
30. *********************************************************************************************************
    ' [% `) D5 B) ~- y6 K$ T- A7 A+ e
31. *        函 数 名: bsp_GetKey2
    
32. *        功能说明: 从按键FIFO缓冲区读取一个键值。独立的读指针。
    , ~, w& I- _% m: e2 K  h  g# k
33. *        形    参:  无
    
34. *        返 回 值: 按键代码
    
35. *********************************************************************************************************
    
36. */
    
37. uint8_t bsp_GetKey2(void)
    $ z9 F/ ~- B7 x
38. {
    
39.         uint8_t ret;
    
40. 
    
41.         if (s_tKey.Read2 == s_tKey.Write)
    # f# I1 Q: S7 _. k) N* b
42.         {
    
43.                 return KEY_NONE;
    
44.         }
    5 F4 ^" K* `# w( q$ F
45.         else
    5 n/ v8 o8 S# j+ h0 a/ D
46.         {
    
47.                 ret = s_tKey.Buf[s_tKey.Read2];
    
48. 
    8 `6 d: a4 q' E2 {6 q
49.                 if (++s_tKey.Read2 >= KEY_FIFO_SIZE)
    
50.                 {
    6 c- o  `' X( @9 r! Q& V" [
51.                         s_tKey.Read2 = 0;
    
52.                 }
    7 A+ k. a# F# M( F5 m
53.                 return ret;
    6 `0 A1 I+ e  r/ o) P3 t
54.         }
      T( F2 n. D2 g% D- c  ?1 ^5 w
55. }

复制代码

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

1. typedef enum
   3 M( e: O2 w. C  B3 r* Y- J$ w7 m) r
2. {
   
3.         KEY_NONE = 0,                        /* 0 表示按键事件 */
   
4. 
   
5.         KEY_1_DOWN,                        /* 1键按下 */
   
6.         KEY_1_UP,                                /* 1键弹起 */
   ' |. `# P8 h- n
7.         KEY_1_LONG,                        /* 1键长按 */
   * ~3 _6 o1 ^. R- c* o3 N
8. 
   
9.         KEY_2_DOWN,                        /* 2键按下 */
   5 E3 e8 |( k( C: W, ]' k
10.         KEY_2_UP,                                /* 2键弹起 */
    
11.         KEY_2_LONG,                        /* 2键长按 */
    
12. 
    
13.         KEY_3_DOWN,                        /* 3键按下 */
    8 ~3 p& P4 ~8 J' I9 ~/ o' b0 P
14.         KEY_3_UP,                                /* 3键弹起 */
    % N! B, i# p, J2 D" e9 N
15.         KEY_3_LONG,                        /* 3键长按 */
    3 f0 L9 i' H4 E
16. 
    6 [' j; Q9 V# I2 `9 \  o7 U# x
17.         KEY_4_DOWN,                        /* 4键按下 */
    
18.         KEY_4_UP,                                /* 4键弹起 */
    ' h4 T4 ^% b6 Q5 K
19.         KEY_4_LONG,                        /* 4键长按 */
    ( F1 b% C6 I5 f
20. 
    
21.         KEY_5_DOWN,                        /* 5键按下 */
    2 Z1 o% ^" z4 @
22.         KEY_5_UP,                                /* 5键弹起 */
    
23.         KEY_5_LONG,                        /* 5键长按 */
    ' e/ R" J2 B' s. X) A8 N
24. 
    + j( T* J1 q, l/ E0 w9 u
25.         KEY_6_DOWN,                        /* 6键按下 */
    
26.         KEY_6_UP,                                /* 6键弹起 */
    
27.         KEY_6_LONG,                        /* 6键长按 */
    
28. 
    + J, s' L1 t0 I; x
29.         KEY_7_DOWN,                        /* 7键按下 */
    6 m# g& Y( ?4 x/ s) L
30.         KEY_7_UP,                                /* 7键弹起 */
    
31.         KEY_7_LONG,                        /* 7键长按 */
    8 W( ?8 `: _6 t* W" U
32. 
    4 U2 d, B: q- |. t( W
33.         KEY_8_DOWN,                        /* 8键按下 */
    
34.         KEY_8_UP,                                /* 8键弹起 */
    
35.         KEY_8_LONG,                        /* 8键长按 */
    
36. 
    ! ~7 i% K( T$ M# l2 n$ p3 Q7 U6 ~
37.         /* 组合键 */
    
38.         KEY_9_DOWN,                        /* 9键按下 */
    
39.         KEY_9_UP,                                /* 9键弹起 */
    - e' d0 o1 s. E& \# v0 M' F% I( r
40.         KEY_9_LONG,                        /* 9键长按 */
    
41. 
    
42.         KEY_10_DOWN,                        /* 10键按下 */
    
43.         KEY_10_UP,                        /* 10键弹起 */
    
44.         KEY_10_LONG,                        /* 10键长按 */
    - E+ f& ]. J! V: X* J! r
45. }KEY_ENUM;

复制代码

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

8 m  |5 x+ v% d, }1 l* e# W  便于新增键值,方便调整顺序。
  使用{ } 将一组相关的定义封装起来便于理解。
  编译器可帮我们避免键值重复。
我们来看红外遥控器的键值定义，在bsp_ir_decode.h文件。因为遥控器按键和主板按键共用同一个FIFO，因此在这里我们先贴出这段定义代码，让大家有个初步印象。
) L8 z  i  \5 T" ]  T) C

1. /* 定义红外遥控器按键代码, 和bsp_key.h 的物理按键代码统一编码 */
   
2. typedef enum
   
3. {
   5 P1 f9 T6 V# I2 B
4.         IR_KEY_STRAT         = 0x80,
   % e3 C0 S0 q2 v
5.         IR_KEY_POWER         = IR_KEY_STRAT + 0x45,
   0 a6 N% o, F7 e# f  A9 R% B* ?
6.         IR_KEY_MENU         = IR_KEY_STRAT + 0x47,
   
7.         IR_KEY_TEST         = IR_KEY_STRAT + 0x44,
   " `' ?( ]0 _8 O
8.         IR_KEY_UP         = IR_KEY_STRAT + 0x40,
   
9.         IR_KEY_RETURN        = IR_KEY_STRAT + 0x43,
   , O$ e: k6 r( q( p
10.         IR_KEY_LEFT        = IR_KEY_STRAT + 0x07,
    
11.         IR_KEY_OK                = IR_KEY_STRAT + 0x15,
    
12.         IR_KEY_RIGHT        = IR_KEY_STRAT + 0x09,
    
13.         IR_KEY_0                = IR_KEY_STRAT + 0x16,
      r2 `0 Z* q  A  Q3 Q: l" k5 ]
14.         IR_KEY_DOWN        = IR_KEY_STRAT + 0x19,
    
15.         IR_KEY_C                = IR_KEY_STRAT + 0x0D,
    
16.         IR_KEY_1                = IR_KEY_STRAT + 0x0C,
    
17.         IR_KEY_2                = IR_KEY_STRAT + 0x18,
    
18.         IR_KEY_3                = IR_KEY_STRAT + 0x5E,
    
19.         IR_KEY_4                = IR_KEY_STRAT + 0x08,
    
20.         IR_KEY_5                = IR_KEY_STRAT + 0x1C,
    : d; s, r8 j2 ~) }" U3 E: n
21.         IR_KEY_6                = IR_KEY_STRAT + 0x5A,
      f" \- m3 [% r( J$ J6 r
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指示灯。
( c2 z9 K! R; J- V9 I
( l4 y5 j8 m6 [8 |$ \

1. #include "bsp.h"
   
2. 
   ' N7 p8 D  `9 S) x- Y7 t
3. int main(void)
   
4. {
   
5.         uint8_t ucKeyCode;
   
6.                         
   - l. [& e) c" C5 }) x- t" ^
7.         bsp_Init();
   
8. 
   
9.         IRD_StartWork();        /* 启动红外解码 */
   
10. 
    . x; F! E1 K- B' n2 x; s
11.         while(1)
    
12.         {
    ) c. H+ q: i0 }3 n$ X$ P
13.                 bsp_Idle();
    0 P" Y  O' [: g5 V, S' @! P8 l
14.                
    6 Q* u9 d! t7 E
15.                 /* 处理按键事件 */
    - r: H1 c( z3 D" G3 p0 Y
16.                 ucKeyCode = bsp_GetKey();
    
17.                 if (ucKeyCode > 0)
    
18.                 {
    , t' C+ F8 {' B, |7 l6 h1 `( N
19.                         /* 有键按下 */
    # i& a/ Z% c8 A$ c, n( l) b0 A
20.                         switch (ucKeyCode)
    
21.                         {
    
22.                                 case KEY_DOWN_K1:                /* K1键按下 */
    & k* M' [5 Z( o  P  A
23.                                         bsp_LedOn(1);                /* 点亮LED1 */
    1 ]& l7 p/ @0 e* \; n, D. o& Q2 L
24.                                         break;
    0 a6 i2 C3 ]: d$ e9 C9 p8 @: C
25. 
    
26.                                 case KEY_UP_K1:                /* K1键弹起 */
    
27.                                         bsp_LedOff(1);        /* 熄灭LED1 */
    
28.                                         break;                                       
    - e" T7 J& i& n- a: z
29. 
    
30.                                 case IR_KEY_POWER:                /* 遥控器POWER键按下 */
    
31.                                         bsp_LedOn(1);                /* 点亮LED2 */
    
32.                                         break;
    " B$ o  U1 ^# m
33. 
    8 [4 _4 Q  f. l6 c' \
34.                                 case IR_KEY_MENU:                /* 遥控器MENU键按下 */
    
35.                                         bsp_LedOff(1);        /* 熄灭LED2 */
    + l5 m. k0 u" k; W, [' |: c
36.                                         break;                                       
    # ?& u- u9 K6 I& m3 o* }. ^; V+ I
37. 
    6 x6 f9 a; o. \$ M! R9 {
38.                                 case MSG_485_RX:                /* 通信程序的发来的消息 */
    
39.                                         /* 执行通信程序的指令 */
    
40.                                         break;
    4 r% F! U5 B- L# n; V( _, o
41. 
    + y0 P% n+ A3 P5 Q. ]) L7 q
42.                                 default:
    
43.                                         break;
    
44.                         }
    
45.                 }
    ; |$ k2 w2 {; I4 g: x8 ?
46.         }
    1 W3 K7 u0 M7 j* G$ ~+ R6 B$ H. \
47. }

复制代码

. y' f5 |2 A& f看到这里，想必你已经意识到bsp_PutKey函数的强大之处了，可以将不相关的硬件输入设备统一为一个相同的接口函数。
  K2 x# a0 P  {' ?* b
# A7 I. v6 ]9 k# n5 a! o, s, H在上面的应用程序中，我们特意添加了一段红色的代码来解说更高级的用法。485通信程序收到有效的命令后通过 bsp_PutKey（MSG_485_RX）函数可以通知APP应用程序进行进一步加工处理（比如显示接收成功）。这是一种非常好的任务间信息传递方式，它不会破坏程序结构。不必新增全局变量来做这种事情，你只需要添加一个键值代码。
! E, f$ N- S' u6 W( M* B6 A2 ~: J; M8 b
! z6 `) U: D- c' X( M对于简单的程序，可以借用按键FIFO来进行少量的信息传递。对于复杂的应用，我们推荐使用bsp_msg专门来做这种任务间的通信。因为bsp_msg除了传递消息代码外，还可以传递参数结构。

$ Y, X2 `! q; r19.3.3 按键检测程序分析
; S8 K6 H% f* d8 d在bsp_key.h 中定了结构体类型KEY_T。

1. #define KEY_COUNT    10                           /* 按键个数, 8个独立建 + 2个组合键 */
     c, O; x/ F* s/ M% R& ]8 N
2. 
   0 r. f6 x' q+ a
3. typedef struct
   
4. {
   
5.         /* 下面是一个函数指针，指向判断按键手否按下的函数 */
   
6.         uint8_t (*IsKeyDownFunc)(void); /* 按键按下的判断函数,1表示按下 */
   7 w* b1 ]: r. ~) c! H1 n
7. 
   
8.         uint8_t  Count;                /* 滤波器计数器 */
   
9.         uint16_t LongCount;        /* 长按计数器 */
   
10.         uint16_t LongTime;                /* 按键按下持续时间, 0表示不检测长按 */
    $ g7 @$ E4 v+ d' w, B& r! X0 e
11.         uint8_t  State;                /* 按键当前状态（按下还是弹起） */
    4 f0 k% H/ N: V4 ?- ?8 d9 c' t$ o
12.         uint8_t  RepeatSpeed;        /* 连续按键周期 */
    
13.         uint8_t  RepeatCount;        /* 连续按键计数器 */
      l+ Z! J3 u  O! R: @. c4 k2 E5 C9 n" A
14. }KEY_T;

复制代码

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

1. static KEY_T s_tBtn[KEY_COUNT];
   ' ~0 u7 W* s# h/ q
2. static KEY_FIFO_T s_tKey; /* 按键FIFO变量,结构体 */

复制代码

每个按键对象都分配一个结构体变量，这些结构体变量以数组的形式存在将便于我们简化程序代码行数。

使用函数指针IsKeyDownFunc可以将每个按键的检测以及组合键的检测代码进行统一管理。
: m- {# \1 b$ {. q, A7 u
" u% M4 t2 T& }, x因为函数指针必须先赋值，才能被作为函数执行。因此在定时扫描按键之前，必须先执行一段初始化函数来设置每个按键的函数指针和参数。这个函数是 void bsp_InitKey(void)。它由bsp_Init()调用。
1 _8 y5 V8 i  z& S  ~# Q4 Q
% B  B( G, ~7 T7 z0 x1 w

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_InitKey
   
4. *        功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
   1 F2 |' m% j$ {* P  i) K
5. *        形    参: 无
   2 {8 l2 K5 a' s/ x. L7 q) R" }
6. *        返 回 值: 无
   5 e& c9 |( o! x- m) w8 t- N
7. *********************************************************************************************************
   
8. */
   
9. void bsp_InitKey(void)
   . }8 u8 y7 R, q7 B# s0 m1 ^* J" _2 B
10. {
    4 d( p- w. a: C2 p/ F9 z- Y
11.         bsp_InitKeyVar();                /* 初始化按键变量 */
    
12.         bsp_InitKeyHard();                /* 初始化按键硬件 */
    
13. }

复制代码

下面是bsp_InitKeyVar函数的定义：
+ M5 T) K$ b- r* n$ ?

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_InitKeyVar
   
4. *        功能说明: 初始化按键变量
   & \4 j: b; y5 z: a1 m7 i/ Q
5. *        形    参:  无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void bsp_InitKeyVar(void)
   
10. {
    9 m% _5 x: s2 @1 f
11.         uint8_t i;
    8 U/ w( b7 n, u1 V8 f- }5 l
12. 
    ( j9 |, z3 x: r
13.         /* 对按键FIFO读写指针清零 */
    1 c" l, o# o% E9 E" x
14.         s_tKey.Read = 0;
    
15.         s_tKey.Write = 0;
    5 N+ ~; T( K: g. g* G6 w, O
16.         s_tKey.Read2 = 0;
    
17. 
    
18.         /* 给每个按键结构体成员变量赋一组缺省值 */
    4 T; _! ~& y, o( q" l2 F, r
19.         for (i = 0; i < KEY_COUNT; i++)
    
20.         {
    , u+ U# y; @, z8 ?
21.                 s_tBtn<i>.LongTime = KEY_LONG_TIME;                        /* 长按时间 0 表示不检测长按键事件 */</i>
    
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 C% S7 i" n5 p+ O; c( y8 P( R$ J
24.                 s_tBtn<span style="font-style: italic;">.RepeatSpeed = 0;                                        /* 按键连发的速度，0表示不支持连发 */
    & N8 I3 y. `% W" A5 O' V
25.                 s_tBtn<i style="font-style: italic;">.RepeatCount = 0;                                        /* 连发计数器 */
    8 O) B( S/ C6 A. N, G% h* T
26.      </i><span style="font-style: normal;">   }
    3 y- A6 [6 e2 V' i. e
27. 
    . ^, }, _9 F5 Y6 Q! i2 @+ A/ T+ ^/ [
28.         /* 如果需要单独更改某个按键的参数，可以在此单独重新赋值 */
    
29.         
    ) U# j% t% M' Z3 Q' T2 y
30.         /* 摇杆上下左右，支持长按1秒后，自动连发 */
    ) L3 }! j$ I+ C$ l
31.         bsp_SetKeyParam(KID_JOY_U, 100, 6);
    
32.         bsp_SetKeyParam(KID_JOY_D, 100, 6);
    
33.         bsp_SetKeyParam(KID_JOY_L, 100, 6);
    + ]! a$ w2 t6 F
34.         bsp_SetKeyParam(KID_JOY_R, 100, 6);
    ( c* `' o) F2 f# C
35. }</span></span></span></span>

复制代码

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

3 K7 T! s. L' w8 c  X0 O

1. /*
   
2.         按键滤波时间50ms, 单位10ms。
     i0 a# {/ ?! \' c4 [
3.         只有连续检测到50ms状态不变才认为有效，包括弹起和按下两种事件
   
4.         即使按键电路不做硬件滤波，该滤波机制也可以保证可靠地检测到按键事件
   
5. */
   
6. #define KEY_FILTER_TIME   5
   - R) X4 X# J% y
7. #define KEY_LONG_TIME     100                        /* 单位10ms， 持续1秒，认为长按事件 */

复制代码

" R( J* M  }6 }/ I+ ^( [uint8_t KeyPinActive(uint8_t _id)（会调用函数KeyPinActive判断状态）函数就是最底层的GPIO输入状态判断函数。

1. /*
   / Y* o/ Q% M/ L( O, `/ ]5 b; Z: V
2. *********************************************************************************************************
   
3. *        函 数 名: KeyPinActive
   " S# A) U5 M& x; i/ S% y7 O0 u
4. *        功能说明: 判断按键是否按下
   0 k. y% v6 J, h/ p6 U
5. *        形    参: 无
   0 F( T( K; @; \" @) y
6. *        返 回 值: 返回值1 表示按下(导通），0表示未按下（释放）
   
7. *********************************************************************************************************
   
8. */
   5 M* L* ]) Z( k2 z9 S( ~
9. static uint8_t KeyPinActive(uint8_t _id)
   
10. {
    8 H! ]8 f( b4 h4 T4 }
11.         uint8_t level;
    . l& L- p3 d+ k0 o3 O6 i
12.         
    
13.         if ((s_gpio_list[_id].gpio->IDR & s_gpio_list[_id].pin) == 0)
    
14.         {
    
15.                 level = 0;
    
16.         }
    
17.         else
    
18.         {
    & n7 f: [4 F, T" j
19.                 level = 1;
    
20.         }
    % D; n" A/ B. b
21. 
    
22.         if (level == s_gpio_list[_id].ActiveLevel)
    3 d7 J+ L. w6 ?+ a2 n% _
23.         {
    
24.                 return 1;
    
25.         }
    
26.         else
    
27.         {
    2 h! k1 O; {/ s) L& s6 m$ p% \
28.                 return 0;
    
29.         }
    
30. }
    2 c  q/ E2 N8 Q5 w2 `
31. 
    $ U; j. h7 r  l, w0 u5 E
32. /*
    
33. *********************************************************************************************************
    
34. *        函 数 名: IsKeyDownFunc
    3 {) L5 F) l: i. r7 o+ y
35. *        功能说明: 判断按键是否按下。单键和组合键区分。单键事件不允许有其他键按下。
    
36. *        形    参: 无
    
37. *        返 回 值: 返回值1 表示按下(导通），0表示未按下（释放）
    + o8 a7 H  D% K* C+ L4 `
38. *********************************************************************************************************
    6 G' v$ z' ]: [% e; C
39. */
    + p$ r: F" `; B0 ~: H2 ^) x
40. static uint8_t IsKeyDownFunc(uint8_t _id)
    * X! t+ W1 |0 u- }. \& }
41. {
    
42.         /* 实体单键 */
    
43.         if (_id < HARD_KEY_NUM)
    ; E2 O5 M& A/ T' Z6 n- V
44.         {
    % l/ w6 U- f1 V8 Z* ^0 }
45.                 uint8_t i;
    ) t9 \8 l. X' v$ A$ w
46.                 uint8_t count = 0;
    1 l  j& d  ]: N" ^0 B- O
47.                 uint8_t save = 255;
    * F) C  t5 ?9 ?( U* G9 l9 n. J- p* ^0 w
48.                
    
49.                 /* 判断有几个键按下 */
    
50.                 for (i = 0; i < HARD_KEY_NUM; i++)
    . M0 t8 j( P/ c) j  H
51.                 {
    ' b7 e) l" ^  q2 V# ]
52.                         if (KeyPinActive(i))
    
53.                         {
    5 Y1 c3 C  T. V1 ^5 z5 s" e% `
54.                                 count++;
    - U! a4 u9 C/ C4 K
55.                                 save = i;
    . p. i& `) b; E! d
56.                         }
    
57.                 }
    
58.                
    
59.                 if (count == 1 && save == _id)
    
60.                 {
    : _2 ?$ S$ R0 q% E" N  x
61.                         return 1;        /* 只有1个键按下时才有效 */
    / }0 R9 j3 J0 r
62.                 }               
    * V0 z& E8 P8 D7 g: l5 p' J' j
63. 
      m& t+ G# m2 Y9 Z
64.                 return 0;
    ! c# N0 X& N! _% p! Z
65.         }
    
66.         
    % N$ _2 f7 y  q
67.         /* 组合键 K1K2 */
    
68.         if (_id == HARD_KEY_NUM + 0)
    8 a6 `5 {7 ^$ n  G5 ]
69.         {
      B  c/ Y7 C: P( C9 G2 }/ M; M0 l
70.                 if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
    
71.                 {
    
72.                         return 1;
    
73.                 }
    
74.                 else
    
75.                 {
    
76.                         return 0;
    
77.                 }
    
78.         }
    8 X& }! h7 c! R& c+ h# J
79. 
    
80.         /* 组合键 K2K3 */
    
81.         if (_id == HARD_KEY_NUM + 1)
    
82.         {
    
83.                 if (KeyPinActive(KID_K2) && KeyPinActive(KID_K3))
    
84.                 {
    
85.                         return 1;
    2 l# X2 t7 c" i1 _3 w- q* n
86.                 }
    $ N' {1 d6 n$ j) a' p
87.                 else
    
88.                 {
    
89.                         return 0;
    % M. h  ]' R3 e8 C3 t
90.                 }
    
91.         }
    
92. 
    
93.         return 0;
    ) W7 v) c4 q: m& e" l
94. }

复制代码

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

1. /*
   4 [4 L' N  }4 L! s
2. *********************************************************************************************************
   0 A8 Y% h: D9 D8 t. y) \/ M+ U/ A
3. *        函 数 名: bsp_InitKeyHard
   - W: b/ L0 f4 D% X' e4 X- E
4. *        功能说明: 配置按键对应的GPIO
   
5. *        形    参:  无
   
6. *        返 回 值: 无
   3 a& ]4 o" \  G0 c$ \  D
7. *********************************************************************************************************
   7 u8 E# M0 ]: A( v" J; m
8. */
   
9. static void bsp_InitKeyHard(void)
   
10. {        
    % t: m0 q+ {$ ^' I9 I7 o9 X* l6 ?
11.         GPIO_InitTypeDef gpio_init;
    
12.         uint8_t i;
    
13. 
    0 \9 h% o/ O" e1 N
14.         /* 第1步：打开GPIO时钟 */
    ' d/ t, T/ ]' d9 R& V) k
15.         ALL_KEY_GPIO_CLK_ENABLE();
    
16.         
    
17.         /* 第2步：配置所有的按键GPIO为浮动输入模式(实际上CPU复位后就是输入状态) */
    
18.         gpio_init.Mode = GPIO_MODE_INPUT;                           /* 设置输入 */
    $ W, n) K: n$ q! D* Q# w
19.         gpio_init.Pull = GPIO_NOPULL;                 /* 上下拉电阻不使能 */
    " ^' y, J: D! T6 a1 J& b
20.         gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;  /* GPIO速度等级 */
    
21.         
    4 R0 ]6 Y: E5 ?4 j, y% I6 T
22.         for (i = 0; i < HARD_KEY_NUM; i++)
    " g' P. \7 J" j+ d& X0 O
23.         {
    ) P) u. `2 v) K# }
24.                 gpio_init.Pin = s_gpio_list<span style="font-style: italic;"><span style="font-style: normal;">.pin;
    1 }# G6 [( d7 j, v! S
25.                 HAL_GPIO_Init(s_gpio_list</span><span style="font-style: normal;">.gpio, &gpio_init);        
    
26.         }
    
27. }</span></span>

复制代码

* s! F$ t+ r3 e! W# t+ @( J我们再来看看按键是如何执行扫描检测的。
" l' E1 b) W% w" ~7 x( \  ~5 e
按键扫描函数bsp_KeyScan10ms ()每隔10ms被执行一次。bsp_RunPer10ms函数在systick中断服务程序中执行。

1. void bsp_RunPer10ms(void)
   
2. {
   
3.         bsp_KeyScan10ms();                /* 扫描按键 */
   , R( T% n/ \# A& q# K
4. }

复制代码

4 X& V6 \; x7 K$ q+ t& x2 ]bsp_KeyScan10ms ()函数的实现如下：
8 W) G6 P/ ?# U* Y5 Y
& g' D3 C# c& Q, Y

1. /*
   
2. *********************************************************************************************************
   ! x& A' g7 h5 Q' _1 N+ W
3. *        函 数 名: bsp_KeyScan10ms
   ' V' _* n6 R% a  }
4. *        功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
   " P$ x0 R3 Y- s* x0 _3 d& T
5. *        形    参: 无
   
6. *        返 回 值: 无
   6 P/ f' P! }- Q4 }( o! e
7. *********************************************************************************************************
   . _  S  y  X- V+ D5 ]
8. */
   
9. void bsp_KeyScan10ms(void)
   6 h. v$ o8 m- q7 e* D, ~
10. {
    
11.         uint8_t i;
    1 S# k3 T% w* g: A) `9 a+ r7 M
12. 
    
13.         for (i = 0; i < KEY_COUNT; i++)
    " ^; G! {. `2 _# _$ X3 [8 M# V
14.         {
    / z& N/ F- _$ _% P9 U# O7 g& P4 e
15.                 bsp_DetectKey(i);
    
16.         }
    
17. }

复制代码

- M' G% t" m, U( m( g& @每隔10ms所有的按键GPIO均会被扫描检测一次。bsp_DetectKey函数实现如下：

7 a! Y; ^* \: |: l- Z1 h

1. /*
   % L+ s8 P7 B1 j( m
2. *********************************************************************************************************
   : g5 }9 X* v# _
3. *        函 数 名: bsp_DetectKey
   
4. *        功能说明: 检测一个按键。非阻塞状态，必须被周期性的调用。
   
5. *        形    参: IO的id， 从0开始编码
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void bsp_DetectKey(uint8_t i)
   & ~/ A- }' z! F) Q) e2 }
10. {
    ' j+ s- m/ R0 [: b% i6 G  r" I
11.         KEY_T *pBtn;
      z' ?8 }3 a0 l$ F
12. 
    6 N' f: D; Y& b7 p* u
13.         pBtn = &s_tBtn<span style="font-style: italic;"><span style="font-style: normal;">;
    ! }: T! p7 D- c5 x, \
14.         if (IsKeyDownFunc(i))
    
15.         {
    / E% R8 Q3 S: z6 r
16.                 if (pBtn->Count < KEY_FILTER_TIME)
    
17.                 {
    5 E- G8 o& D$ o* f
18.                         pBtn->Count = KEY_FILTER_TIME;
    
19.                 }
    % g) Z7 ~- O4 X- f% t6 E, t
20.                 else if(pBtn->Count < 2 * KEY_FILTER_TIME)
    # ^. X( L: G. u1 I' a
21.                 {
    / `6 o" C" n" P) ?
22.                         pBtn->Count++;
    
23.                 }
    
24.                 else
    % s1 k% h; `5 v8 d8 W$ Q( w* Z
25.                 {
    
26.                         if (pBtn->State == 0)
    
27.                         {
    ( w3 x6 z8 l9 Y+ J( H: q; X& ^
28.                                 pBtn->State = 1;
    
29. 
    & q1 D3 Z, U/ X+ K& U
30.                                 /* 发送按钮按下的消息 */
    7 Y; {/ V4 W7 X% p
31.                                 bsp_PutKey((uint8_t)(3 * i + 1));
    
32.                         }
    8 l: T& I( v8 t9 s; ]( A8 C9 C
33. 
    . S% _' M+ p& t  ~+ W
34.                         if (pBtn->LongTime > 0)
    1 E1 x* @) _8 R! Q
35.                         {
    8 ]# s5 _/ ^5 m: a
36.                                 if (pBtn->LongCount < pBtn->LongTime)
    
37.                                 {
    ; J; L* g/ x/ v* R3 g" g
38.                                         /* 发送按钮持续按下的消息 */
    
39.                                         if (++pBtn->LongCount == pBtn->LongTime)
    . X8 _2 d2 C% o9 l+ F1 N
40.                                         {
    ( D) v6 ^( `! ?' J, R  {5 H
41.                                                 /* 键值放入按键FIFO */
    
42.                                                 bsp_PutKey((uint8_t)(3 * i + 3));
    
43.                                         }
    
44.                                 }
    - R3 C! e6 P+ x5 ^. T8 Z$ y0 L
45.                                 else
      U0 r4 C4 f# }' ^/ ]5 \
46.                                 {
    
47.                                         if (pBtn->RepeatSpeed > 0)
    + ^, u- W- D( s! w1 o
48.                                         {
      f4 ]+ Z$ D. b, |! G# I' m
49.                                                 if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
    + \$ u. ^0 \9 |
50.                                                 {
    * D: r" R6 Q( H3 w
51.                                                         pBtn->RepeatCount = 0;
    ) w! k% F8 C$ Q5 k( Y% \; O3 y
52.                                                         /* 常按键后，每隔RepeatSpeed * 10ms发送1个按键 */
    
53.                                                         bsp_PutKey((uint8_t)(3 * i + 1));
    # M$ ~& ~5 E& U) C7 g
54.                                                 }
    ) R6 S, ]6 ~7 H+ w
55.                                         }
    
56.                                 }
    
57.                         }
    
58.                 }
    7 \* c& A+ v: @/ n1 N9 L
59.         }
    6 s; k3 m$ R$ A- R4 z/ f
60.         else
    
61.         {
    
62.                 if(pBtn->Count > KEY_FILTER_TIME)
    1 F1 e+ t& W+ C1 S' D3 p( \0 g
63.                 {
    
64.                         pBtn->Count = KEY_FILTER_TIME;
    8 o5 S! X9 Q; F5 H9 M! u- u
65.                 }
    
66.                 else if(pBtn->Count != 0)
    # E: T0 A$ M. l3 ^  g  I
67.                 {
    5 M9 [4 Q7 d0 o6 W; q
68.                         pBtn->Count--;
    # Z3 M) m% {0 R' h1 {9 |! {( ?0 W; W
69.                 }
    ( z4 w7 F$ O8 e5 I( V
70.                 else
    
71.                 {
    2 A, {/ s1 a# a# b9 r
72.                         if (pBtn->State == 1)
    
73.                         {
    
74.                                 pBtn->State = 0;
    * i3 L. t" u3 Z6 u
75. 
    
76.                                 /* 发送按钮弹起的消息 */
    
77.                                 bsp_PutKey((uint8_t)(3 * i + 2));
    % K- ^! R# L# e, _3 y7 {0 U
78.                         }
    
79.                 }
    9 `! C( E) O! t; C- E# E
80. 
    ( N$ Y( {( {1 e' y3 N0 W2 q
81.                 pBtn->LongCount = 0;
    
82.                 pBtn->RepeatCount = 0;
    : f/ F# v0 I# U; W# J
83.         }
    
84. }</span></span>

复制代码

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

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

复制代码

8 p1 I& ^# h1 @9 [' I' r读取相应按键的结构体地址，程序里面每个按键都有自己的结构体。

1. static KEY_T s_tBtn[KEY_COUNT];
   2 B* l8 I) x; a
2. if (IsKeyDownFunc(i))
   0 A# B; }7 P9 m, r  t$ \
3. {
   
4.         这个里面执行的是按键按下的处理
   9 A6 b# b  Z5 U- A& T, ?
5. }
   ; Q! u7 p) f# Y1 n8 L
6. else
   - N/ O! i+ J( ~
7. {
   1 d5 v6 R% \- N+ k1 K
8.         这个里面执行的是按键松手的处理或者按键没有按下的处理
   
9. }

复制代码

( p" @8 d0 U5 G) j执行函数IsKeyDownFunc(i)做按键状态判断。
9 d* g3 U4 b' E# _' L' L, R" v7 ?
: N/ ?7 u9 c* y, k

1. /*
   
2. **********************************************************************************
   
3. 下面这个if语句主要是用于按键滤波前给Count设置一个初值，前面说按键初始化的时候
   
4. 已经设置了Count = KEY_FILTER_TIME/2
   ' ^" s) Y& I$ f2 K6 C$ W6 J, I
5. **********************************************************************************
   : h, s9 s+ \! _" _# `. j0 p
6. */
   - X! k  k2 j' b/ m2 z3 C" W- o
7. if (pBtn->Count < KEY_FILTER_TIME)
   
8. {
   8 T# K# Y" g% G  m# d2 R
9.     pBtn->Count = KEY_FILTER_TIME;
   : q6 c; ]  t' [
10. }
    
11. 
    
12. /*
    
13. **********************************************************************************
    
14. 这里实现KEY_FILTER_TIME时间长度的延迟
    
15. **********************************************************************************
    
16. */
    
17. else if(pBtn->Count < 2 * KEY_FILTER_TIME)
    
18. {
    
19.     pBtn->Count++;
    
20. }
    
21. /*
    
22. **********************************************************************************
    ! h% X; H0 W# z( e$ e
23. 这里实现KEY_FILTER_TIME时间长度的延迟
    " C- K8 A/ S5 t# {" G
24. **********************************************************************************
    
25. */
    
26. else
    + J. w6 n5 z% G& p4 P% B
27. {
    
28. /*
    6 S8 U7 c! Z) @* d1 e6 m  A
29. **********************************************************************************
    
30. 这个State变量是有其实际意义的，如果按键按下了，这里就将其设置为1，如果没有按下这个
    
31. 变量的值就会一直是0，这样设置的目的可以有效的防止一种情况的出现：比如按键K1在某个
    ) c* \: t. B+ f
32. 时刻检测到了按键有按下，那么它就会做进一步的滤波处理，但是在滤波的过程中，这个按键
    , X$ f+ d% A6 o1 U
33. 按下的状态消失了，这个时候就会进入到上面第二步else语句里面，然后再做按键松手检测滤波
    # `0 I3 g0 n" e: Q3 E& ]* a
34. ，滤波结束后判断这个State变量，如果前面就没有检测到按下，这里就不会记录按键弹起。
    9 s1 K6 N% U' E3 k
35. **********************************************************************************
    
36. */
    1 E7 S+ i6 o: X$ L1 w
37.     if (pBtn->State == 0)
    + d" a- Z4 s7 O- }. [9 ]
38.     {
    
39.         pBtn->State = 1;
    : E# W& C! e9 J/ q4 D
40. 
    
41.         /* 发送按钮按下的消息 */
    5 z' h7 S6 l. T1 J2 t
42.         bsp_PutKey((uint8_t)(3 * i + 1));
    
43.     }
    
44. 
    
45.     if (pBtn->LongTime > 0)
    & J, T# L4 N7 V% P- Q
46.     {
    
47.         if (pBtn->LongCount < pBtn->LongTime)
    
48.         {
    " T: v3 X4 j/ I( R- |
49.             /* 发送按钮持续按下的消息 */
    8 Q5 o. E& h# n. s/ L4 e
50.             if (++pBtn->LongCount == pBtn->LongTime)
    
51.             {
    
52.                 /* 键值放入按键FIFO */
    " I( q# E3 ~8 Q- W
53.                 bsp_PutKey((uint8_t)(3 * i + 3));
    % V+ Q9 n6 w! D( y3 {* b
54.             }
    - T* `/ P! o3 J  }
55.         }
    
56.         else
    
57.         {
    4 K' F6 ]% B8 \& m2 ?# D
58.             if (pBtn->RepeatSpeed > 0)
    
59.             {
    # s9 }& K; p- t
60.                 if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
    # w7 M) z1 }! s4 h. r
61.                 {
    9 Y9 _$ e7 j0 C  s- P) l
62.                     pBtn->RepeatCount = 0;
    
63.                     /* 长按键后，每隔10ms发送1个按键 */
    ' h9 y! s3 y# Y
64.                     bsp_PutKey((uint8_t)(3 * i + 1));
    0 V% w6 ]6 `5 V  L: c# B8 Y
65.                 }
    
66.             }
    
67.         }
    
68.     }
    ( p+ U6 Q) _: t6 _3 n" O$ p) n4 A
69. }

复制代码

19.3.4 按键检测采用中断方式还是查询方式
+ t5 d9 j) s3 I( S9 ^检测按键有中断方式和GPIO查询方式两种。我们推荐大家用GPIO查询方式。

从裸机的角度分析
" V2 Y+ B8 N+ o- n$ Q- \$ s& u
" o4 ~- h8 y. F/ A% t中断方式：中断方式可以快速地检测到按键按下，并执行相应的按键程序，但实际情况是由于按键的机械抖动特性，在程序进入中断后必须进行滤波处理才能判定是否有效的按键事件。如果每个按键都是独立的接一个IO引脚，需要我们给每个IO都设置一个中断，程序中过多的中断会影响系统的稳定性。中断方式跨平台移植困难。
/ r/ H' K. Q3 T# @+ i
1 r3 R3 \6 D% d7 r查询方式：查询方式有一个最大的缺点就是需要程序定期的去执行查询，耗费一定的系统资源。实际上耗费不了多大的系统资源，因为这种查询方式也只是查询按键是否按下，按键事件的执行还是在主程序里面实现。

从OS的角度分析
2 r" G1 q, U8 {& o/ j" s0 ^
) q6 C, R* o* w" D' P7 L中断方式：在OS中要尽可能少用中断方式，因为在RTOS中过多的使用中断会影响系统的稳定性和可预见性（抢占式调度的OS基本没有可预见性）。只有比较重要的事件处理需要用中断的方式。
5 D( B4 k% R+ Q8 ]. |" w$ o
) u" b& m$ u* o1 [5 Z查询方式：对于用户按键推荐使用这种查询方式来实现，现在的OS基本都带有CPU利用率的功能，这个按键FIFO占用的还是很小的，基本都在1%以下。

; H  J5 S  F/ v4 w0 E. p" B19.4 按键板级支持包（bsp_key.c）
) o& [( K% ~7 ~6 ~) B: s% ~& s, g9 k按键驱动文件bsp_key.c主要实现了如下几个API：

$ X3 Z' R6 ^2 ]2 x# ~  KeyPinActive
7 B' v: i5 T& S! L! ~3 Q0 i" Y4 I  IsKeyDownFunc
  bsp_InitKey
  bsp_InitKeyHard
& r1 l/ H7 e+ l& Y8 [  bsp_InitKeyVar
, L; [; I) N5 ~+ l$ w8 d& L( B  bsp_PutKey
  bsp_GetKey
5 ?. o' l1 @+ k; H& R1 A3 e: G" P  bsp_GetKey2
+ ?$ v, M; E5 Y. l! `, _  bsp_GetKeyState
$ ~5 \5 S' |3 u9 Y  bsp_SetKeyParam
  bsp_ClearKey
( }! L5 b' U6 r! x% J7 I; N  bsp_DetectKey
  bsp_DetectFastIO
  bsp_KeyScan10ms
1 Q2 x% n! Q- z) E) y5 |  bsp_KeyScan1ms
% c; C8 E' t# q7 F8 p) h
9 Q- C# B( T9 \/ l9 o- O所有这些函数在本章的19.3小节都进行了详细讲解，本小节主要是把需要用户调用的三个函数做个说明。
4 O# C, N0 L% C
! ^- `3 a# C6 g8 c  U7 b19.4.1 函数bsp_InitKeyHard
1 G& V( ^& ]$ X. m: f函数原型：
0 p8 g1 P: Q4 T. d5 T# a
6 R3 p8 J- \% ]1 \

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_InitKey
   : h! {# N0 T* t
4. *        功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   + a% {3 S; K3 i
9. void bsp_InitKey(void)
   ' b+ ~- H, [& o) ]
10. {
    
11.         bsp_InitKeyVar();                /* 初始化按键变量 */
    
12.         bsp_InitKeyHard();                /* 初始化按键硬件 */
    
13. }

复制代码

' y5 ]& ]6 W  G7 S( S8 X8 N函数描述：
0 H" F" c1 j* o& h" H9 ]1 F, F0 b% _
此函数主要用于按键的初始化。

" }1 h, p) w8 W1 P5 R9 n/ Q6 K' f# N/ W使用举例：

底层驱动初始化直接在bsp.c文件的函数bsp_Init里面调用即可。
7 I" h/ U+ b: o! ^0 j* b' d, F9 m* c
19.4.2 函数bsp_GetKey
函数原型：
' A; \. B5 D; Z
4 |; M2 ?# a2 [4 Z' ^2 M* m

1. /*
   # o. }- E0 W; R
2. *********************************************************************************************************
   8 E7 x5 C+ J6 v- J1 O
3. *        函 数 名: bsp_GetKey
   
4. *        功能说明: 从按键FIFO缓冲区读取一个键值。
   + i6 N5 \+ F8 N: F& U& L: Z- x
5. *        形    参: 无
   
6. *        返 回 值: 按键代码
   
7. *********************************************************************************************************
   
8. */
   6 e+ O! G: ]9 }0 j2 p2 T
9. uint8_t bsp_GetKey(void)
   
10. {
    
11.         uint8_t ret;
    
12. 
    1 T& ]" F0 G! P5 Z9 P, y2 [4 j
13.         if (s_tKey.Read == s_tKey.Write)
    $ o9 [; I( z) k3 V" {) `
14.         {
    5 l3 P  `" d# {, o5 t
15.                 return KEY_NONE;
    
16.         }
    
17.         else
    
18.         {
    
19.                 ret = s_tKey.Buf[s_tKey.Read];
    5 }8 @0 Z$ z% g; [* t! ]
20. 
    ! E0 N; C  t7 i0 W& ?
21.                 if (++s_tKey.Read >= KEY_FIFO_SIZE)
    
22.                 {
    ' F& ]6 i1 V, i. h: y  s) o
23.                         s_tKey.Read = 0;
    9 K* Q9 n" k1 d2 |$ S4 ^% F
24.                 }
    - G  c& k, G. S( ^, i) N
25.                 return ret;
    ) B+ K' W8 `$ U8 Y
26.         }
    ) e) z/ D  q3 Z/ W3 x* Y3 F! `
27. }

复制代码

函数描述：
* T* b4 x) t1 X9 K- ~* o
1 w0 i3 S: K0 |$ I1 Y) _此函数用于从FIFO中读取键值。

使用举例：

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

1. /*
   
2. *********************************************************************************************************
   4 j( Z# A/ P9 T. v8 p& U; P7 p
3. *        函 数 名: main
   / X  P& q: p/ R8 p: o+ d: n/ A$ \$ U
4. *        功能说明: c程序入口
   / m) L  i( m& ~2 W$ z1 Y3 |
5. *        形    参: 无
   : {/ t5 M  a9 I6 a, z4 v7 W6 [$ {
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   % v0 d% @5 V0 U/ C; i" r3 g7 w4 |" b
8. */
   
9. int main(void)
   
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    
12.         
    
13.         bsp_Init();                /* 硬件初始化 */
    . u" O0 [7 V; P. [5 M$ E
14.         
    * I% S& D8 b' T/ G! N
15.         /* 进入主程序循环体 */
    ' `. E) J% c& d9 \. `1 F
16.         while (1)
      K. y* x2 s0 E
17.         {               
    8 ]  a1 d& j. O9 k
18.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
19.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
      i1 [1 P* j' J! r. h3 }/ n
20.                 if (ucKeyCode != KEY_NONE)
    6 N* y/ f2 k& w8 n4 n
21.                 {
    
22.                         switch (ucKeyCode)
    ) ~# M% K) h; R' M
23.                         {
    
24.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    # G! f# L! v2 ^. u
25.                                         printf("K1键按下\r\n");
    7 c; O- _) E" t! I6 g8 T
26.                                         break;
    3 Q, ?8 w* |2 y* H+ ?* N5 g  O
27. 
    / ?7 H5 ]$ _* w  P4 r4 x6 `
28.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    
29.                                         printf("K2键按下\r\n");
    , l: S8 x( ]: |7 v: ?' A
30.                                         break;
    
31. 
    
32.                                 default:
    
33.                                         /* 其它的键值不处理 */
    . k2 ]  \; U# C, u) V$ g/ p  `8 s
34.                                         break;
    ' M( C  K' d2 _# _1 g! ^
35.                         }
    5 @% K- n+ @% t8 g$ ~( A
36.                 }
    : ~2 {% M# e; C2 L9 V
37.         }
    ) [- U6 f0 u" B) d& \( ?; H
38. }

复制代码

19.4.3 函数bsp_KeyScan10ms
# N" L- R6 i1 ^& L/ i$ p  m函数原型：

9 B1 R6 n& h. R) }1 e. T3 e7 v

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_KeyScan10ms
   
4. *        功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   2 S4 t7 H0 I0 J
7. *********************************************************************************************************
   , g+ w7 X) t0 g7 Y
8. */
   5 D& ^5 L4 R2 O* N! t
9. void bsp_KeyScan10ms(void)
   
10. {
    
11.         uint8_t i;
    
12. 
    , X, e2 f- Q/ h2 d" B5 I
13.         for (i = 0; i < KEY_COUNT; i++)
      l8 u+ J4 `0 I+ ]1 s
14.         {
    
15.                 bsp_DetectKey(i);
    
16.         }
    
17. }

复制代码

函数描述：
0 D1 N1 k# o( o3 J
2 q/ q) P! Y7 `8 y! y9 y此函数是按键的主处理函数，用于检测和存储按下、松手、长按等状态。

7 k' M! N6 F: D3 ~+ [使用举例：

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

另外，此函数需要周期性调用，每10ms调用一次。
& \9 C: J0 W+ _: i9 L+ h( J# g
  如果是裸机使用，将此函数放在bsp.c文件的bsp_RunPer10ms函数里面即可，这个函数是由滴答定时器调用的，也就是说，大家要使用按键，定时器的初始化函数bsp_InitTimer一定要调用。
  如果是RTOS使用，需要开启一个10ms为周期的任务调用函数bsp_KeyScan10ms。

19.5 按键FIFO驱动移植和使用
) x2 D% K7 K" J  `8 w; O按键移植步骤如下：
6 r5 ]7 |( a/ X/ j0 c
5 S& G' n+ J: T  第1步：复制bsp_key.c和bsp_key.c到自己的工程。
  第2步：根据自己使用的独立按键个数和组合键个数，修改几个地方。

1. #define HARD_KEY_NUM        8                     /* 实体按键个数 */
   ! K7 c* H# B) h/ Z0 k5 v) C9 O  V3 U
2. #define KEY_COUNT   (HARD_KEY_NUM + 2)   /* 8个独立建 + 2个组合按键 */

复制代码

  第3步：根据使用的引脚时钟，修改下面函数：
# X* p3 s0 M( r6 e  T* B

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();        \
   3 q7 {+ |: w( c; I7 Z- W; m' _
6.                 __HAL_RCC_GPIOH_CLK_ENABLE();        \
   
7.                 __HAL_RCC_GPIOI_CLK_ENABLE();        \
   2 F5 J" V, e' E- i
8.         };

复制代码

. b) c8 h' d2 Y) m  第4步：根据使用的具体引脚，修改如下函数，第3列参数低电平表示按下或者高电平表示按下：
% f  ~7 ~/ c8 @) B; N. M3 {

1. /* GPIO和PIN定义 */
   8 x! p6 [& m3 i# X
2. static const X_GPIO_T s_gpio_list[HARD_KEY_NUM] = {
   & _4 X; @" ?5 {8 ^2 c3 v
3.         {GPIOI, GPIO_PIN_8, 0},                /* K1 */
   
4.         {GPIOC, GPIO_PIN_13, 0},        /* K2 */
   
5.         {GPIOH, GPIO_PIN_4, 0},                /* K3 */
   
6.         {GPIOG, GPIO_PIN_2, 0},                /* JOY_U */        
   
7.         {GPIOB, GPIO_PIN_0, 0},                /* JOY_D */
   
8.         {GPIOG, GPIO_PIN_3, 0},                /* JOY_L */        
   $ W" N% u' @% U: X$ n+ T
9.         {GPIOG, GPIO_PIN_7, 0},                /* JOY_R */        
   6 C3 X. E: W, H3 U" G
10.         {GPIOI, GPIO_PIN_11, 0},        /* JOY_OK */
    ( }5 C$ }; q8 M! d# S
11. };   

复制代码

     
  第5步：根据使用的组合键个数，在函数IsKeyDownFunc里面添加相应个数的函数：
3 S) w9 {, [! ]# U

1.         /* 组合键 K1K2 */
   9 s5 ?9 S+ U% c( v" }
2.         if (_id == HARD_KEY_NUM + 0)
   - L' k4 E6 N' c! L0 D
3.         {
   " P8 s/ s2 W9 L0 h& M
4.                 if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
   
5.                 {
   " r2 E: p) C- p
6.                         return 1;
   
7.                 }
   
8.                 else
   # N& w9 x; C6 K. \& U! o* V( M0 `
9.                 {
   " N8 r6 o5 i# ^* d" o) k
10.                         return 0;
    
11.                 }
    
12.         }

复制代码

第2行ID表示HARD_KEY_NUM + 0的组合键，HARD_KEY_NUM + 1表示下一个组合键，以此类推。
8 b4 D8 O/ d$ j) ?
5 R- U8 s1 n1 \  Z3 j另外就是，函数KeyPinActive的参数是表示检测哪两个按键，设置0的时候表示第4步里面的第1组按键，设置为1表示第2组按键，以此类推。

, c# {/ U; V# i" r  第6步：主要用到HAL库的GPIO驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
  第7步：移植完整，应用方法看本章节配套例子即可。
; o  b4 m, a' b8 Z" Y0 j特别注意，别忘了每10ms调用一次按键检测函数bsp_KeyScan10ms。

$ `1 e  \3 x1 Z- E1 b1 ]  r19.6 实验例程设计框架
  O6 ?) ?2 x) G& o! M" J通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：
5 w3 m# s. O, G4 L* _& f
6 q% v1 ]9 C9 J( K

1、 第1阶段，上电启动阶段：
" y9 P: ~, U& b7 X0 G% m
这部分在第14章进行了详细说明。

( O3 |- j3 }: ^' C( r7 a. _9 U 2、 第2阶段，进入main函数：
) O" S0 b& z. N
1 }9 ]( x) E' A8 n* q  第1部分，硬件初始化，主要是MPU、Cache、HAL库、系统时钟、滴答定时器、按键等。
2 [+ q" }' [& ]8 X' z  第2部分，应用程序设计部分，实现了一个按键应用。
* {, ]! W; u+ V; U0 }" ?8 Q' M  第3部分，按键扫描程序每10ms在滴答定时中断执行一次。
$ c; b5 U; N8 {' |  f  I
19.7 实验例程说明（MDK）
配套例子：
* U/ X4 @* _& Q; `3 i' OV7-002_按键检测（软件滤波，FIFO机制）

' K: d4 a0 P; h实验目的：
学习按键的按下，弹起，长按和组合键的实现。
  x; f) }( j  m6 b4 y2 t
. _1 p2 z; g5 ~$ A实验内容：
/ _$ V6 B9 C4 x; U- P9 v1 \启动一个自动重装软件定时器，每100ms翻转一次LED2。

实验操作：
: p) ?) q5 x7 c2 e- a) b% H3个独立按键和5向摇杆按下时均有串口消息打印。
5向摇杆的左键和右键长按时，会有连发的串口消息。
3 ~1 Q9 S1 o" D8 c  l- Q独立按键K1和K2按键按下，串口打印消息。

: t" v6 l2 F8 C0 o# e6 L% {! Z$ r; i& A上电后串口打印的信息：

* [) l& |3 Z/ W& v/ \波特率 115200，数据位 8，奇偶校验位无，停止位 1
) W) ~1 \! }: d- n; R$ ]* [
; T/ A, z4 @8 [/ j! N

) e8 n5 Y$ i+ |" ^8 d' t
. P( R) e1 y: \* n4 p( o( j程序设计：
  |- ~$ h0 I+ Z) J* ], K
( }2 L0 ]* {) @/ Q  系统栈大小分配：
# \+ }0 K6 P, W6 f4 f8 f( X+ n

' c, n, J/ ^# I  p1 R
, n& ~0 [2 e; G6 F9 Y  RAM空间用的DTCM：
; g: G( r4 `" Z

. i8 s# {' h) B# Q  硬件外设初始化
1 C8 q9 X. ^  Z. C. U$ `! C* }7 a2 d
硬件外设的初始化是在 bsp.c 文件实现：

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   ' z1 m$ a- k2 _4 |
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   * p5 z) r# j1 n- q
5. *        形    参：无
   
6. *        返 回 值: 无
   8 A: `- |; l% _
7. *********************************************************************************************************
   0 M8 \+ R6 @: V
8. */
   
9. void bsp_Init(void)
   ' r3 S0 b1 ]/ D- k5 ?
10. {
    & b7 h, C  `9 j. Y% S+ ~$ H- V# S
11.     /* 配置MPU */
    % B& x: _% s9 L* E) X) L( q
12.         MPU_Config();
    0 k) a+ Z1 U2 c& n3 t# z
13.         
    4 p, b, e0 r6 T1 l
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    , Y; c. C* ^# g, h9 S
16. 
    
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    ; G- `5 {8 ^$ f! b1 A. x) y/ j
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    
21.          */
    8 o4 Q/ ]: R4 h$ B, z
22.         HAL_Init();
    9 M0 N) s! n" O' d5 t9 o
23. 
    
24.         /*
    
25.        配置系统时钟到400MHz
    & I% J, \2 c; U, A
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    3 g0 ^# q8 q7 v+ C* P+ j
29.         SystemClock_Config();
    : z) Z. c4 r4 T1 u
30. 
    . ]6 A5 w1 e' Z" `, [1 D
31.         /*
    
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    & k0 ]: c$ ^8 j' R
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    ; x+ v( x2 j' t% R  q& F
35.         */        
    - o& Y  n; z( a; _' N7 v
36. #if Enable_EventRecorder == 1  
    7 V# V6 H' V4 ]/ Z$ B; w) K5 y
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    ! K4 U7 L- N2 l0 ]. S- q, P2 Q; K
39.         EventRecorderStart();
    " U, ?# g0 h" W) X3 C
40. #endif
    
41.         
    + @8 V; F. {" N- e6 |# h; b. o
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    5 c7 W* B# R# ?. g1 B
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    & }5 R0 S3 o5 l- D7 u( ?; q6 f
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

8 |) A& K+ a7 y0 z8 {  u  {  MPU配置和Cache配置：
9 `2 V8 l9 j; I- Y* G
数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
9 b4 F. z: }+ I7 A8 i
/ K8 e: |! y1 m5 t9 P3 q1 @( E& |4 n

1. /*
   / J9 W; X" r0 v8 Y
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   0 @% @" h3 [$ B6 N7 _, s& A
6. *        返 回 值: 无
   % L8 n) I: @+ b2 s7 I
7. *********************************************************************************************************
   " o# ?6 k9 E) p. l9 S
8. */
   & j: O6 j4 O/ n, W) k
9. static void MPU_Config( void )
   " h3 ~9 l  Q, L/ P# ?
10. {
    5 z( C6 S% ]* }9 x: Y. l
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    4 J! n# D( `5 a% A3 [. t
12. 
    
13.         /* 禁止 MPU */
    5 f5 L( s$ @! `: R' h& R# M' K
14.         HAL_MPU_Disable();
    
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    - N* p* J/ H4 o) @9 X( j1 @
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    , s: }" s- Q1 F* _$ x
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    9 q% l5 e2 J  X4 s  g5 m; s7 l
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    6 ]) b6 Q8 @3 M- z7 u+ R; e  m
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    ; j# W, L9 _9 a4 o2 R- R. l+ c
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    & |* C4 V# |$ L5 x7 Z$ Z+ F
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    8 s. S& q& G) d. B8 r
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    & m8 A. D, L. y
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    
31.         
    " A( ]; p2 n- `' ^  j
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    ' E6 I/ e3 b+ v6 T
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    * `7 k, w$ k1 _3 j& f# {/ `, F
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    " q8 y- x; k0 H" E  y
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    7 n+ c, l7 ^1 P0 G# ?2 t/ |
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ) |7 h, |, g7 d$ v) J& E
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    0 N1 w. y  v+ ]# q) C
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    % @8 c* D0 Y. W& G( J, A: _# J3 }
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    : `6 N4 T) i6 h
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    , x7 u3 t  y3 d& y
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    4 [# I- ]7 D, z7 N. t
44.         
    9 o! T) ^2 v+ s$ b5 L) W- R1 p0 F; q0 G6 o
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ; }! b$ C6 t6 w6 I% D. S1 R
46. 
    - p1 w; Z- I% F
47.         /*使能 MPU */
    
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    ' h4 V& o& R+ L4 V; p8 C: H/ a
49. }
    
50. 
    
51. /*
    
52. *********************************************************************************************************
    : e+ z4 R2 l; w3 J
53. *        函 数 名: CPU_CACHE_Enable
    
54. *        功能说明: 使能L1 Cache
    * G+ {7 G! {1 o: s5 B8 s
55. *        形    参: 无
    * q5 Z$ ~+ |, m  v; G7 g! G# w
56. *        返 回 值: 无
    
57. *********************************************************************************************************
    
58. */
    $ ^/ q& g# d% l! N! G! s2 X
59. static void CPU_CACHE_Enable(void)
    
60. {
    
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    , ]8 u6 y5 A5 l* h& N) z
63. 
    ) {' d" L  z9 {' B4 S
64.         /* 使能 D-Cache */
    ' P9 B- ~) `& ~! B5 z3 K* F
65.         SCB_EnableDCache();
    
66. }

复制代码

8 J, N4 r9 E, z  每10ms调用一次按键检测：

2 M, `1 V! D* m; c按键检测是在滴答定时器中断里面实现，每10ms执行一次检测。

& ]4 r# {& j$ z5 |. I+ }. ]

1. /*
   
2. *********************************************************************************************************
   9 j& v8 {& g6 e# W# W+ J
3. *        函 数 名: bsp_RunPer10ms
   
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   : v! c/ H7 P4 V+ i0 D' z
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   2 J5 p% O7 R$ D- {
6. *        形    参: 无
   8 U3 l3 N9 w, I' d  z: y  X
7. *        返 回 值: 无
   & n# _$ I# y8 f7 ~
8. *********************************************************************************************************
   
9. */
   
10. void bsp_RunPer10ms(void)
    * d8 _3 a: c! ^$ [# j9 a
11. {
    / a3 K3 V  N% j% [% I# ?
12.         bsp_KeyScan10ms();
    
13. }

复制代码

  主功能：

+ _* ^9 x/ }& k  u主功能的实现主要分为两部分：

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

1. /*
   0 e- d; r5 G* i/ Z
2. *********************************************************************************************************
   
3. *        函 数 名: main
   4 `5 h# ^8 ~1 u) g0 j0 U0 P- C4 {
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   $ N  `/ W! b* \" D& S9 F- _2 J
7. *********************************************************************************************************
   
8. */
   
9. int main(void)
   ( Z7 z. a: @& u5 D0 u) f
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    " Q" Y4 X6 o5 P+ S5 [" ?$ a
12.         
    
13.         bsp_Init();                /* 硬件初始化 */
    
14.         
    
15.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    . ~! O( |, V4 W& R
16.         PrintfHelp();        /* 打印操作提示 */
    ( W" h! u& L' T9 |
17. 
    
18. 
      E) Y. T+ v5 d9 m! T
19.         bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 */
    
20.         
    # ^$ ^1 ]8 V$ G- K% o, `6 ?5 p3 g
21.         /* 进入主程序循环体 */
    ' G5 n- f) y8 b* p. s% @" D
22.         while (1)
    
23.         {
    * L3 l0 e$ M" W' G- v/ `# _1 O3 Z7 h
24.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    5 h/ T  U. E1 a$ \' R3 Q# _
25. 
    
26.                 /* 判断定时器超时时间 */
    
27.                 if (bsp_CheckTimer(0))        
    7 u$ Q7 S; P6 t( q0 f  A
28.                 {
    ) L; L% O- c% @; S' @. |  v
29.                         /* 每隔100ms 进来一次 */  
    
30.                         bsp_LedToggle(2);                        
    
31.                 }
    
32.                
    : a5 d- Y3 L; H7 C/ B( a4 A/ }* N
33.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
34.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
35.                 if (ucKeyCode != KEY_NONE)
    * {% Q+ G4 p6 a+ b8 c- y
36.                 {
    2 L& M) k, [$ m
37.                         switch (ucKeyCode)
    
38.                         {
    & C+ t, L. S" x  W3 x" d
39.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    4 ~: x" x" K! C! F
40.                                         printf("K1键按下\r\n");
    
41.                                         break;
    
42. 
    
43.                                 case KEY_UP_K1:                                /* K1键弹起 */
    2 ^  P2 u6 U- ^1 B
44.                                         printf("K1键弹起\r\n");
    
45.                                         break;
    3 ?# n% Y2 Y" x- W* `
46. 
    + R7 A4 ~/ o$ p4 Q* b% q* [( @
47.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    7 J9 A1 K# |/ ~* h
48.                                         printf("K2键按下\r\n");
    + H# Z7 H4 S- P6 O3 T
49.                                         break;
    
50. 
    " A6 B, i  |) A5 _' G. c8 K0 ~' O
51.                                 case KEY_UP_K2:                                /* K2键弹起 */
    - A+ K. N) ]6 X' q# I% L
52.                                         printf("K2键弹起\r\n");
    
53.                                         break;
    
54. 
    ' f9 ~, n" V4 w' F/ p
55.                                 case KEY_DOWN_K3:                        /* K3键按下 */
    
56.                                         printf("K3键按下\r\n");
    
57.                                         break;
    5 L* K$ N' ~3 d5 ^
58. 
    
59.                                 case KEY_UP_K3:                                /* K3键弹起 */
    1 t% _; ~: G! n  n9 v8 n
60.                                         printf("K3键弹起\r\n");
    
61.                                         break;
    
62. 
    
63.                                 case JOY_DOWN_U:                        /* 摇杆UP键按下 */
    
64.                                         printf("摇杆上键按下\r\n");
    0 s1 `* q8 q% d1 B" k- a
65.                                         break;
    
66. 
    
67.                                 case JOY_DOWN_D:                        /* 摇杆DOWN键按下 */
    1 b& M0 _/ L8 p% m7 v! S
68.                                         printf("摇杆下键按下\r\n");
    " ]# P. ?' k6 U# @: L( g' ^8 U
69.                                         break;
      j- g5 j9 }, _3 u
70. 
    
71.                                 case JOY_DOWN_L:                        /* 摇杆LEFT键按下 */
    / L9 k% p6 v- B- W
72.                                         printf("摇杆左键按下\r\n");
    
73.                                         break;
    ; x, t1 K! O+ q
74.                                 
    
75.                                 case JOY_LONG_L:            /* 摇杆LEFT键长按 */
    
76.                                         printf("摇杆左键长按\r\n");
    ) C" E) }5 K2 p- g. ?5 A% }
77.                                         break;
    
78. 
    
79.                                 case JOY_DOWN_R:                        /* 摇杆RIGHT键按下 */
    4 q) q+ D. Z7 a! i% B1 S
80.                                         printf("摇杆右键按下\r\n");
    - I! i- A/ ?( D& A+ o- c! d
81.                                         break;
    * w2 h7 H; W  e
82.                                 
    $ N( ?3 T% s! L% N- W( x" U
83.                                 case JOY_LONG_R:            /* 摇杆RIGHT键长按 */
    # J3 {9 a0 }8 N1 I& v
84.                                         printf("摇杆右键长按\r\n");
    . I/ z/ N# U  [! y% g) e' X5 i
85.                                         break;
    5 @# v6 X. c; o, D8 h) Q
86. 
    
87.                                 case JOY_DOWN_OK:                        /* 摇杆OK键按下 */
    
88.                                         printf("摇杆OK键按下\r\n");
    / ~, U5 g/ I5 B' v( |
89.                                         break;
    
90. 
    3 {9 G; Q1 X6 Y+ p3 I& l# Q
91.                                 case JOY_UP_OK:                        /* 摇杆OK键弹起 */
    / t$ c- L2 \' F2 H7 }
92.                                         printf("摇杆OK键弹起\r\n");
    
93.                                         break;
    
94. 
    & C( q# y: j2 T2 m& T$ p/ X
95.                 case SYS_DOWN_K1K2:                        /* 摇杆OK键弹起 */
    
96.                                         printf("K1和K2组合键按下\r\n");
    
97.                                         break;
    9 u$ V4 e& P$ T9 s2 ~
98. 
    
99.                                 default:
    
100.                                         /* 其它的键值不处理 */
     
101.                                         break;
     + ]5 K, W" ?& A# M; K! n9 R
102.                         }
     / \7 L$ H$ f+ i$ l$ f+ ]* b
103.                
     
104.                 }
     
105.         }
     1 D/ ?, X$ ^/ V, Q) ]4 L% Y$ B
106. }

复制代码

19.8 实验例程说明（IAR）
配套例子：
" r/ Z7 E' Z' c% f  V5 X! C. GV7-002_按键检测（软件滤波，FIFO机制）

实验目的：
- I" I: Y# w# s# J3 H7 X学习按键的按下，弹起，长按和组合键的实现。

/ S' E+ ~" p. }+ Y实验内容：
启动一个自动重装软件定时器，每100ms翻转一次LED2。
1 [3 S4 i: n' k4 ]+ w4 t4 [- |, r
实验操作：
3个独立按键和5向摇杆按下时均有串口消息打印。
; h, U; r5 b7 x2 M0 p5向摇杆的左键和右键长按时，会有连发的串口消息。
独立按键K1和K2按键按下，串口打印消息。

9 E& b7 n2 }$ Y  a2 v2 l上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1
% M( a& R1 _) ?( y( E2 G0 V; ?9 ^

程序设计：
3 i- Z( e3 o2 a$ b& u% @& i( J
  系统栈大小分配：
/ ^, Z" ]* e3 O
( o% s' s* G4 E2 @1 R

  RAM空间用的DTCM：

5 O7 F) D3 h* o& a9 g  K) ?
% v. o2 j$ f  O- U7 f  硬件外设初始化
5 o; u/ y8 D' i9 L
硬件外设的初始化是在 bsp.c 文件实现：
. H" x# [, [5 G' H, U

1. /*
   + u8 x+ V" I3 n
2. *********************************************************************************************************
   9 C& \+ \2 S: o9 P! r
3. *        函 数 名: bsp_Init
   # |  C$ `! w2 B* J7 m! t, Q
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   % Y  R; @! V5 Y7 t3 ^# S' K. v
8. */
   - {% b' y; F& Z. f  f0 n
9. void bsp_Init(void)
   
10. {
    ) p3 i: G& h- I8 w
11.     /* 配置MPU */
    ; g4 }7 t) @9 d6 X7 R
12.         MPU_Config();
    
13.         
    8 B$ G' q; j& l- C
14.         /* 使能L1 Cache */
    0 Z' I& ^, M9 J
15.         CPU_CACHE_Enable();
    ' N. R7 S( G5 D/ r( ~
16. 
    4 {/ i5 h9 m4 g* t& b
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    : b+ v2 b% P. E3 M) S0 Z. T
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    4 }7 H7 ^7 \* L- l5 U+ ?3 S& y
20.            - 设置NVIV优先级分组为4。
    
21.          */
    
22.         HAL_Init();
    * e. P3 m0 w) I; X# ?; K) O
23. 
    
24.         /*
    
25.        配置系统时钟到400MHz
    , x+ Z: g& ^  w8 U8 |1 A
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    , o2 Q+ T* H7 P: F' D8 Y
29.         SystemClock_Config();
    
30. 
    ) L' r6 |$ L  V
31.         /*
    
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    & L+ l1 Q) M& V) ?
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    3 @  p: j6 u* i- P7 l8 {
35.         */        
    
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    8 |) m- y3 Y! c# T: v
39.         EventRecorderStart();
    , u6 ]/ ~6 c6 \. g: ^+ Z
40. #endif
    
41.         
    , r$ J0 ^: |4 ^5 V3 [# G
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    ) \' ~9 S. a: \' ]
44.         bsp_InitUart();        /* 初始化串口 */
    3 [) r3 I$ P3 Q$ ]' c2 f) S
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

+ {7 c$ e1 L' u+ R. K, ^/ J  MPU配置和Cache配置：

( o# h1 S5 b4 ]- c7 E0 m5 k数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

9 B0 E% x7 g+ k( b  I

1. /*
   & v: Z3 T  J) P/ t6 c; N% J/ N
2. *********************************************************************************************************
   ' K7 U: M; s! J  k# G+ ]# P
3. *        函 数 名: MPU_Config
   3 r2 h$ G. D" n% C  G7 `5 w- H8 |
4. *        功能说明: 配置MPU
   ! h1 C5 u1 p: b1 q" l
5. *        形    参: 无
   
6. *        返 回 值: 无
   . T: R0 W% Z1 v9 x( k7 \$ F$ Z1 d
7. *********************************************************************************************************
   ) A  K: D+ }$ M5 H: e- g9 t
8. */
   
9. static void MPU_Config( void )
   " z3 |6 s, u& [7 H5 p; G; m7 \( Y
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
      |+ I9 Y$ n' f- ], ~- P$ D% x
12. 
    
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    
15. 
    ; y8 H) A( c+ [6 Y
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    . z8 a( ?. m  _) `7 m* H; B
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    . ~! D2 ?- Z  ~/ x( W2 Q
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    ' b6 j$ w9 v: m, H3 s
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    7 w) g8 R; v& n, ~6 a
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;
    7 s. b3 V9 P% d% M! T. z* d' f
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    ' a6 b6 b' o5 z1 d
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    + ]3 A& m% \# \, r, ]* n% V4 f
31.         
    : l" a/ ]. u0 I9 C: F7 l, v
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;        
    : D' x, W& V2 c
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    0 B- |, G4 g2 T& W3 P3 I7 w
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    4 j+ G( w, Z* G! S5 P( ~& X2 Z
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    6 Q* F1 s* \& Q- j3 `
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    & |% c9 s; j( g3 \6 @( e9 k
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    
47.         /*使能 MPU */
    : m8 Y% O4 L- [( v; K6 X6 p
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    % R- K' i! q% V0 m/ {
50. 
    
51. /*
    
52. *********************************************************************************************************
    
53. *        函 数 名: CPU_CACHE_Enable
    ; F' p) L& |- Z5 x. H
54. *        功能说明: 使能L1 Cache
    3 t* \$ K5 p3 F7 v  V. V8 P( E2 a0 H
55. *        形    参: 无
    $ j0 ]) ^; P$ ]4 T$ Z9 _% |
56. *        返 回 值: 无
    
57. *********************************************************************************************************
    
58. */
    $ e4 z( E. Q; l
59. static void CPU_CACHE_Enable(void)
    ' L& R3 _& I1 u1 u' j5 R
60. {
    ) ?- C: L6 f4 O: c; G
61.         /* 使能 I-Cache */
    3 a3 L# Y9 F9 D, s2 i
62.         SCB_EnableICache();
    
63. 
    - H" K! _9 F5 r* |+ D7 ?9 U% a7 p- P  E
64.         /* 使能 D-Cache */
    ; }: p; [" k, H% z9 P# Y
65.         SCB_EnableDCache();
    
66. }

复制代码

& s7 H% x7 T, o+ ^  每10ms调用一次按键检测：

& I# t5 A1 n+ ~' y按键检测是在滴答定时器中断里面实现，每10ms执行一次检测。

1. /*
   . ~2 B# ?. h' N/ y1 k- Y& k
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_RunPer10ms
   
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   $ J% }2 n8 `" k' F9 Z
6. *        形    参: 无
   
7. *        返 回 值: 无
   
8. *********************************************************************************************************
   
9. */
   ' c/ h4 c3 M7 A
10. void bsp_RunPer10ms(void)
    ' c: e' W* c% @8 [9 j' l/ @
11. {
    
12.         bsp_KeyScan10ms();
    
13. }

复制代码

$ n6 O  d: ]2 I, u: \7 X 主功能：

* Y$ \9 y) |- \7 r( R  I9 `主功能的实现主要分为两部分：
$ f% p4 l2 F2 ~) ]: G1 r
+ v7 n& Q! e# z+ n: \/ U 启动一个自动重装软件定时器，每100ms翻转一次LED2
按键消息的读取，检测到按下后，做串口打印。
- I% h. e4 y/ G& X8 X

1. /*
   6 k2 G: `* z/ ]; H0 @: r$ N5 T
2. *********************************************************************************************************
   " T& ^- X4 _: P4 {6 B+ a/ j
3. *        函 数 名: main
   3 `9 A! M- j. i6 |% K
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   3 g0 h5 N- u* }! f+ k% K4 m& D
8. */
   8 q8 ]) I' T" v  Y: n* y
9. int main(void)
   $ `) Y) M  @' P
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
      q. e1 C) v/ `( @
12.         
    " `& t+ g8 r. h( ^) A
13.         bsp_Init();                /* 硬件初始化 */
    
14.         
    
15.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
16.         PrintfHelp();        /* 打印操作提示 */
    
17. 
    ( H$ e( |! D* ^4 h: V. m
18. 
    
19.         bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 */
    
20.         
    
21.         /* 进入主程序循环体 */
    
22.         while (1)
    * c; ?7 X# s4 Z2 R" w) [' A
23.         {
    5 f0 R% t: G) w& ~6 @
24.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
25. 
    : }6 x. Z- Z8 y7 o1 O! B. i. H
26.                 /* 判断定时器超时时间 */
    
27.                 if (bsp_CheckTimer(0))        
    
28.                 {
    9 [5 {; @( F% v( ^0 }2 M6 M& T( A
29.                         /* 每隔100ms 进来一次 */  
    
30.                         bsp_LedToggle(2);                        
    ! A! J8 O) p5 ~' Z; V3 q  O0 W; Z7 @
31.                 }
    
32.                
    
33.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    % i3 T  C  y9 h1 x3 V( V
34.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
35.                 if (ucKeyCode != KEY_NONE)
    ' N& I0 O% x5 r
36.                 {
    
37.                         switch (ucKeyCode)
    
38.                         {
    
39.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    
40.                                         printf("K1键按下\r\n");
    6 v$ C3 e: M( \0 V2 ]2 {. K# B
41.                                         break;
    - X' y, Q% B+ h3 M1 R
42. 
    
43.                                 case KEY_UP_K1:                                /* K1键弹起 */
    
44.                                         printf("K1键弹起\r\n");
    
45.                                         break;
    
46. 
    " d) ]. U! d1 w. m7 i
47.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    
48.                                         printf("K2键按下\r\n");
    * N7 q- }% c% Q. j- d1 ?
49.                                         break;
    % H0 s% }4 U$ A8 c% w
50. 
    
51.                                 case KEY_UP_K2:                                /* K2键弹起 */
    0 p2 P! Y4 ]- z# }- ~# R9 R
52.                                         printf("K2键弹起\r\n");
    " C2 S4 _4 y, r8 j
53.                                         break;
    
54. 
    
55.                                 case KEY_DOWN_K3:                        /* K3键按下 */
    3 o  n/ ]9 e+ ^/ d1 p8 D1 V# W+ H8 j1 x
56.                                         printf("K3键按下\r\n");
    / L9 B8 A0 q9 R- S2 Q/ a! I% D
57.                                         break;
    
58. 
    
59.                                 case KEY_UP_K3:                                /* K3键弹起 */
    2 S. g' ]/ e2 c* \
60.                                         printf("K3键弹起\r\n");
    4 w1 {( z" Y( e0 \- w9 y7 q$ D
61.                                         break;
    + s$ P" J; ~0 P. H, x( _
62. 
    
63.                                 case JOY_DOWN_U:                        /* 摇杆UP键按下 */
    / q( f7 w+ R' ^* E8 P% s
64.                                         printf("摇杆上键按下\r\n");
    , e5 N+ b) j, Y9 f) ^! R+ a. i
65.                                         break;
    7 p) `; |% n# K: a
66. 
    " A2 c6 `8 K! N7 b
67.                                 case JOY_DOWN_D:                        /* 摇杆DOWN键按下 */
    & {4 `: ]% Z: ]
68.                                         printf("摇杆下键按下\r\n");
    
69.                                         break;
    : t+ B' r! ^; B+ q# H
70. 
    
71.                                 case JOY_DOWN_L:                        /* 摇杆LEFT键按下 */
    
72.                                         printf("摇杆左键按下\r\n");
    7 a; n7 i' D' p" a& V3 u1 e9 R
73.                                         break;
    
74.                                 
    1 u( z2 W0 n+ G$ C- |- `
75.                                 case JOY_LONG_L:            /* 摇杆LEFT键长按 */
    " x! V$ N) I9 S9 N4 q
76.                                         printf("摇杆左键长按\r\n");
    ! t  A! V5 U: }/ d
77.                                         break;
    
78. 
    + |) Y7 [% A$ w" y9 Y: S" X
79.                                 case JOY_DOWN_R:                        /* 摇杆RIGHT键按下 */
    ; ^2 P/ H, T- ^4 I" r& g$ Z+ N
80.                                         printf("摇杆右键按下\r\n");
    " E  i0 ?% |2 |+ R4 F  B5 W) `7 v
81.                                         break;
    
82.                                 
    ' J4 v/ C! q; X0 @* j3 Q
83.                                 case JOY_LONG_R:            /* 摇杆RIGHT键长按 */
    
84.                                         printf("摇杆右键长按\r\n");
    
85.                                         break;
    4 n; u' G6 F0 s/ G
86. 
    ; |( `& E2 f+ c0 |: d7 e' A0 O
87.                                 case JOY_DOWN_OK:                        /* 摇杆OK键按下 */
    
88.                                         printf("摇杆OK键按下\r\n");
    5 F0 R2 X, d3 d8 K' X8 [& O, C3 I: h
89.                                         break;
    
90. 
      ]+ o9 l$ W/ o8 z( C
91.                                 case JOY_UP_OK:                        /* 摇杆OK键弹起 */
    . c+ g$ q3 P+ v* {
92.                                         printf("摇杆OK键弹起\r\n");
    
93.                                         break;
    
94. 
    # x* z" r9 z) M# n! g
95.                 case SYS_DOWN_K1K2:                        /* 摇杆OK键弹起 */
    
96.                                         printf("K1和K2组合键按下\r\n");
    
97.                                         break;
    : m5 H7 @7 m7 V6 P
98. 
    ! m% Q% f5 `; y- c" W" A. e7 y4 V
99.                                 default:
    
100.                                         /* 其它的键值不处理 */
     
101.                                         break;
     
102.                         }
     . H2 G; M9 o8 k) i+ L7 p
103.                
     
104.                 }
     6 U+ i5 e' m. o6 D9 w4 Z
105.         }
     : i- y, @- p4 s. ^$ _- G% [; O
106. }

复制代码

19.9 总结
2 L9 x' K$ {8 @7 r- |; T9 R/ e这个方案在实际项目中已经经过千锤百炼，大家可以放心使用。建议熟练掌握其用法。
" O2 J9 G" B  D% }$ ?7 ?; X
- P' V3 F) T6 x% k+ ]9 M: r) I1 q' f
8 N% e/ y9 ?- e: h