19.1 初学者重要提示
4 \; [1 x3 z9 X( y( ~( r$ K0 c! j 按键FIFO驱动扩展和移植更简单，组合键也更好用。支持按下、弹起、长按和组合键。
: `( _: l7 }1 P* S; _
  J0 v' [1 H. r19.2 按键硬件设计
V7开发板有三个独立按键和一个五向摇杆，下面是三个独立按键的原理图：

4 M9 M# ?" y- H. s! O
$ `$ e7 ^4 F+ R" q! @" z注意，K1（S1）、K2(S2)和K3(S3)按键的上拉电阻是接在5V电压上，因为这三个按键被复用为PS/2键盘鼠标接口，而PS/2是需要5V供电的（注，V5和V6开发板做了PS/2复用，而V7没有使用，这里只是为了兼容之前的板子）。实际测试，K1、K2、K3按键和PS/2键盘是可以同时工作的。

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

2 l% `6 N+ R% V$ q" q# |* u

) ?  x; _- [5 j: S" x3 J9 {, b6 q( ], {通过这个硬件设计，有如下两个知识点为大家做介绍：
& S# r. b! P! Y
19.2.1 硬件设计
按键和CPU之间串联的电阻起保护作用。按键肯定是存在机械抖动的，开发板上面的硬件没有做硬件滤波处理，即使设计了硬件滤波电路，软件上还是需要进行滤波。

  保护GPIO，避免软件错误将IO设置为输出，如果设置为低电平还好，如果设置输出的是高电平，按键按下会直接跟GND(低电平)连接，从而损坏MCU。
  保护电阻也起到按键隔离作用，这些GPIO可以直接用于其它实验。
19.2.2 GPIO内部结构分析按键
0 T9 ]& [0 ~0 e# |$ @' r1 p' r$ v4 W% E详细的GPIO模式介绍，请参考第15章的15.3小节，本章仅介绍输入模式。下面我们通过一张图来简单介绍GPIO的结构。

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

  按键按下。
3 a5 F- I0 f" w7 w! B, h; g  按键弹起。
8 [, ~8 B+ O8 a( a0 R/ S  长按键。
4 C- r9 _9 G# D& w  长按时自动连发。
# s, G; O: }. p( y9 S我们将按键驱动分为两个部分来介绍，一部分是FIFO的实现，一部分是按键检测的实现。
8 H7 {. K9 X' r  I; f

: N5 M' m, ~) C, hbsp_key.c 文件包含按键检测和按键FIFO的实现代码。

, @! V: j- \6 K* Z% Ubsp.c 文件会调用bsp_InitKey()初始化函数。

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

' b% G7 k3 x/ }( z  L5 zbsp_timer.c 中的Systick中断服务程序调用 bsp_RunPer10ms。

: {4 j/ o4 v9 [1 U  j5 X中断程序和主程序通过FIFO接口函数进行信息传递。
- h6 x1 D& C1 G7 N$ z3 H& F
函数调用关系图：

19.3.1 按键FIFO的原理
FIFO是First Input First Output的缩写，先入先出队列。我们这里以5个字节的FIFO空间进行说明。Write变量表示写位置，Read变量表示读位置。初始状态时，Read = Write = 0。

+ d0 N* O0 K, `我们依次按下按键K1，K2，那么FIFO中的数据变为：

, ~+ q% {2 \/ ?. X

4 H4 A/ f6 Y" F: e  b, ^; ^
% U7 Q; p3 F  g# b如果Write！= Read，则我们认为有新的按键事件。

+ v% l# A$ y5 E) o$ K5 o2 {1 X* h我们通过函数bsp_GetKey读取一个按键值进行处理后，Read变量变为1。Write变量不变。
+ m( P% `5 a7 B" c2 I

2 d4 n6 M+ ^1 ]' L1 _, _
, ?6 N' p* u  ~1 |. f5 o+ k: R我们继续通过函数bsp_GetKey读取3个按键值进行处理后，Read变量变为4。此时Read = Write = 4。两个变量已经相等，表示已经没有新的按键事件需要处理。
2 \) `5 h9 M" E# p- h  r
有一点要特别的注意，如果FIFO空间写满了，Write会被重新赋值为0，也就是重新从第一个字节空间填数据进去，如果这个地址空间的数据还没有被及时读取出来，那么会被后来的数据覆盖掉，这点要引起大家的注意。我们的驱动程序开辟了10个字节的FIFO缓冲区，对于一般的应用足够了。
3 f4 y: P5 q, R0 S6 J
% s* U7 W  Z( g% Q) V+ G3 X设计按键FIFO主要有三个方面的好处：

' }& H/ N8 d. I. J( U  可靠地记录每一个按键事件，避免遗漏按键事件。特别是需要实现按键的按下、长按、自动连发、弹起等事件时。
4 |, @6 |3 q1 o9 T# K  读取按键的函数可以设计为非阻塞的，不需要等待按键抖动滤波处理完毕。
$ K6 i( t5 @* S9 k6 Q  按键FIFO程序在嘀嗒定时器中定期的执行检测，不需要在主程序中一直做检测，这样可以有效地降低系统资源消耗。
. h9 g( S/ j+ L) i$ R
7 t9 Y; h* r1 r7 N19.3.2 按键FIFO的实现
9 K4 K' M8 l0 x7 M7 L$ ^在bsp_key.h 中定了结构体类型KEY_FIFO_T。这只是类型声明，并没有分配变量空间。

1. #define KEY_FIFO_SIZE        10
   / \) R: c' j' T  }2 l
2. typedef struct
   
3. {
   
4.         uint8_t Buf[KEY_FIFO_SIZE];                /* 键值缓冲区 */
   , ]" A: D7 Y7 X* y# T$ d' {
5.         uint8_t Read;                                        /* 缓冲区读指针1 */
   " n; k5 M( {/ L- }
6.         uint8_t Write;                             /* 缓冲区写指针 */
   : `. x. m' ?3 O2 P: J
7.         uint8_t Read2;                             /* 缓冲区读指针2 */
   8 L2 h. u. r) {, Q4 z- L* j9 ]
8. }KEY_FIFO_T;

复制代码

在bsp_key.c 中定义s_tKey结构变量, 此时编译器会分配一组变量空间。
- W  l; A! t5 G! s8 x6 {
/ u% u: k2 Q6 c. ]2 W

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

复制代码

9 Z7 G  s: h1 ]+ h一般情况下，只需要一个写指针Write和一个读指针Read。在某些情况下，可能有两个任务都需要访问按键缓冲区，为了避免键值被其中一个任务取空，我们添加了第2个读指针Read2。出厂程序在bsp_Idle()函数中实现的按K1K2组合键截屏的功能就使用的第2个读指针。
, s' ?9 i8 J% Z! I8 h
# a9 w) ~1 }7 P# t7 R! H+ c% h当检测到按键事件发生后，可以调用 bsp_PutKey函数将键值压入FIFO。下面的代码是函数的实现：

$ g! h. |& W7 S7 n! [+ q  v

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_PutKey
   
4. *        功能说明: 将1个键值压入按键FIFO缓冲区。可用于模拟一个按键。
   ) ^& J) T5 a$ `3 [# O" b) i
5. *        形    参: _KeyCode : 按键代码
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   4 b' p. H; k( @: m# G4 G- C
9. void bsp_PutKey(uint8_t _KeyCode)
   $ k: h& e7 W7 E6 ?1 u
10. {
    * O& c: O1 I* X. G% H% Z; j
11.         s_tKey.Buf[s_tKey.Write] = _KeyCode;
    
12. 
    
13.         if (++s_tKey.Write  >= KEY_FIFO_SIZE)
    6 K9 j' \7 J7 {
14.         {
    + F1 H" P2 j# }& Z6 E- g8 S
15.                 s_tKey.Write = 0;
    
16.         }
    
17. }

复制代码

这个bsp_PutKey函数除了被按键检测函数调用外，还可以被其他底层驱动调用。比如红外遥控器的按键检测，也共用了同一个按键FIFO。遥控器的按键代码和主板实体按键的键值统一编码，保持键值唯一即可实现两套按键同时控制程序的功能。
: _- d# I$ U; R# R" f* X
应用程序读取FIFO中的键值，是通过bsp_GetKey函数和bsp_GetKey2函数实现的。我们来看下这两个函数的实现：
% c( ^5 w) i: s/ u

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_GetKey
   
4. *        功能说明: 从按键FIFO缓冲区读取一个键值。
   
5. *        形    参:  无
   
6. *        返 回 值: 按键代码
   " V) e  B3 S  p: U
7. *********************************************************************************************************
   , v9 E9 ~8 ~2 Z
8. */
   % o1 e; [) K3 ~
9. uint8_t bsp_GetKey(void)
   
10. {
    
11.         uint8_t ret;
    
12. 
      F* z. s, @$ x  ?  T- B9 x
13.         if (s_tKey.Read == s_tKey.Write)
    - }% Y) J1 }7 R6 H
14.         {
    8 L, m2 r. {4 W7 D. T& p! S7 C
15.                 return KEY_NONE;
    ( c8 d9 |9 K" L& }0 c! q8 @
16.         }
    7 ~5 y0 r- J0 \% ^' F3 Z1 v
17.         else
    7 p) w, {- W9 j% a/ @$ p2 m# @
18.         {
    0 v- x, w: L( h) q
19.                 ret = s_tKey.Buf[s_tKey.Read];
    4 t# L  `- a9 \2 J  ]) U) I2 G' W
20. 
    
21.                 if (++s_tKey.Read >= KEY_FIFO_SIZE)
    
22.                 {
    ! T& O/ Z7 X3 W8 y; ^+ E% T
23.                         s_tKey.Read = 0;
    + K  c' J, p- k; M- m! c9 \) ]( n! a
24.                 }
    ' D, o+ o. }% i. s
25.                 return ret;
    $ A  H+ x4 a) V* u8 O! ]
26.         }
    
27. }
    
28. 
    ( G5 d& \, t+ b9 C  n! J+ W
29. /*
    8 P# S* s! b: W3 R3 g; u
30. *********************************************************************************************************
    9 ?. {, y; ]" s1 F* {$ j2 x: q, }
31. *        函 数 名: bsp_GetKey2
    5 {( r; h& p9 ^, B9 n
32. *        功能说明: 从按键FIFO缓冲区读取一个键值。独立的读指针。
    
33. *        形    参:  无
    9 o  M6 _2 f; Y
34. *        返 回 值: 按键代码
    
35. *********************************************************************************************************
    
36. */
    0 E8 y% ?5 D1 C9 N
37. uint8_t bsp_GetKey2(void)
    
38. {
    1 L8 R( R# O3 f; {" y
39.         uint8_t ret;
    
40. 
    , e  L2 t, y( V% |, V* k
41.         if (s_tKey.Read2 == s_tKey.Write)
    9 [4 J0 o- h, t% B, z
42.         {
    
43.                 return KEY_NONE;
    
44.         }
    ; `2 n% _* B# t. D8 z% b( p
45.         else
    , u  l3 _2 w+ L4 i' S
46.         {
    
47.                 ret = s_tKey.Buf[s_tKey.Read2];
    
48. 
    8 D9 x5 H& F+ M/ J( k& L  l" q2 p7 @
49.                 if (++s_tKey.Read2 >= KEY_FIFO_SIZE)
    
50.                 {
    
51.                         s_tKey.Read2 = 0;
    
52.                 }
    
53.                 return ret;
    8 ~( W$ \2 k0 W+ {2 ?
54.         }
    , d9 y/ X/ F- g; |1 I( n  j
55. }

复制代码

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

% d( ]% x! N3 @

1. typedef enum
   ( N3 y; D- P) F- N6 @+ R8 ?3 L( G6 }
2. {
   
3.         KEY_NONE = 0,                        /* 0 表示按键事件 */
   5 ~, H+ M5 t* D
4. 
   ) w# t8 ^. {$ }6 L
5.         KEY_1_DOWN,                        /* 1键按下 */
   , [! E9 l6 E( P' A
6.         KEY_1_UP,                                /* 1键弹起 */
   
7.         KEY_1_LONG,                        /* 1键长按 */
   % d/ r/ Y/ o1 p, j/ \" U
8. 
   
9.         KEY_2_DOWN,                        /* 2键按下 */
   $ L. t' i; B/ o. V, C, l
10.         KEY_2_UP,                                /* 2键弹起 */
    ; S& o8 y6 [2 n8 h" k1 Y, M
11.         KEY_2_LONG,                        /* 2键长按 */
    0 H* \$ A+ g/ U1 F+ g; Q
12. 
    / D. Q* B) I' T, A1 n1 R
13.         KEY_3_DOWN,                        /* 3键按下 */
    
14.         KEY_3_UP,                                /* 3键弹起 */
    " x7 Y! [. {- |8 c% X. l6 e" _+ r2 _% Q
15.         KEY_3_LONG,                        /* 3键长按 */
    & u* F( G1 G$ Z$ s% |5 X6 b* {1 F6 e
16. 
    . D5 i. q* K, b6 {6 ~  _
17.         KEY_4_DOWN,                        /* 4键按下 */
    % Z. c  g: m9 U2 j# ~
18.         KEY_4_UP,                                /* 4键弹起 */
    
19.         KEY_4_LONG,                        /* 4键长按 */
    0 M6 N( `# F2 M$ t9 }
20. 
    
21.         KEY_5_DOWN,                        /* 5键按下 */
    
22.         KEY_5_UP,                                /* 5键弹起 */
    ( m( O( V5 e; C& O* g+ x
23.         KEY_5_LONG,                        /* 5键长按 */
    
24. 
    
25.         KEY_6_DOWN,                        /* 6键按下 */
    $ @, _% q) `! Q- [* a( S6 E
26.         KEY_6_UP,                                /* 6键弹起 */
    , Z4 \3 T! Z. H1 b4 A
27.         KEY_6_LONG,                        /* 6键长按 */
    
28. 
    
29.         KEY_7_DOWN,                        /* 7键按下 */
    7 F$ O% w" K) t, g/ I" S
30.         KEY_7_UP,                                /* 7键弹起 */
    + ]& b1 m$ d+ [! l4 J
31.         KEY_7_LONG,                        /* 7键长按 */
    
32. 
    3 S' A6 {0 J; G  n5 H
33.         KEY_8_DOWN,                        /* 8键按下 */
    ) m$ q5 I3 g* U; E
34.         KEY_8_UP,                                /* 8键弹起 */
    
35.         KEY_8_LONG,                        /* 8键长按 */
    * D  y# ]0 U" |9 K- w4 y
36. 
    + u* p7 w1 t. _  O$ _, [
37.         /* 组合键 */
    
38.         KEY_9_DOWN,                        /* 9键按下 */
    
39.         KEY_9_UP,                                /* 9键弹起 */
    
40.         KEY_9_LONG,                        /* 9键长按 */
    
41. 
    8 a4 y( U$ v& J. K% q$ ^. D! U; y
42.         KEY_10_DOWN,                        /* 10键按下 */
    
43.         KEY_10_UP,                        /* 10键弹起 */
    5 @0 e% i) W' |# U/ @# M# O. J
44.         KEY_10_LONG,                        /* 10键长按 */
    
45. }KEY_ENUM;

复制代码

必须按次序定义每个键的按下、弹起和长按事件，即每个按键对象（组合键也算1个）占用3个数值。我们推荐使用枚举enum, 不用#define的原因：
: T2 d8 e1 x0 m6 r
* c# I- ~; r" E+ H  便于新增键值,方便调整顺序。
6 O- o8 T" v# x1 \  使用{ } 将一组相关的定义封装起来便于理解。
  编译器可帮我们避免键值重复。
我们来看红外遥控器的键值定义，在bsp_ir_decode.h文件。因为遥控器按键和主板按键共用同一个FIFO，因此在这里我们先贴出这段定义代码，让大家有个初步印象。

1. /* 定义红外遥控器按键代码, 和bsp_key.h 的物理按键代码统一编码 */
   
2. typedef enum
   
3. {
   0 R3 V+ \) J( m7 Q
4.         IR_KEY_STRAT         = 0x80,
   
5.         IR_KEY_POWER         = IR_KEY_STRAT + 0x45,
   " D- |# ?* w( x
6.         IR_KEY_MENU         = IR_KEY_STRAT + 0x47,
   7 \8 M- j4 N; n
7.         IR_KEY_TEST         = IR_KEY_STRAT + 0x44,
   
8.         IR_KEY_UP         = IR_KEY_STRAT + 0x40,
   
9.         IR_KEY_RETURN        = IR_KEY_STRAT + 0x43,
   
10.         IR_KEY_LEFT        = IR_KEY_STRAT + 0x07,
    7 c8 s* J0 h. V8 ?( X/ }
11.         IR_KEY_OK                = IR_KEY_STRAT + 0x15,
    
12.         IR_KEY_RIGHT        = IR_KEY_STRAT + 0x09,
    
13.         IR_KEY_0                = IR_KEY_STRAT + 0x16,
    
14.         IR_KEY_DOWN        = IR_KEY_STRAT + 0x19,
    
15.         IR_KEY_C                = IR_KEY_STRAT + 0x0D,
    
16.         IR_KEY_1                = IR_KEY_STRAT + 0x0C,
    7 K# p$ \/ o7 P1 e: ]
17.         IR_KEY_2                = IR_KEY_STRAT + 0x18,
    
18.         IR_KEY_3                = IR_KEY_STRAT + 0x5E,
    4 G/ q' f8 x, m# {5 E
19.         IR_KEY_4                = IR_KEY_STRAT + 0x08,
    / M4 {5 s3 N, j( w8 v0 e6 ?
20.         IR_KEY_5                = IR_KEY_STRAT + 0x1C,
    
21.         IR_KEY_6                = IR_KEY_STRAT + 0x5A,
    
22.         IR_KEY_7                = IR_KEY_STRAT + 0x42,
    
23.         IR_KEY_8                = IR_KEY_STRAT + 0x52,
    
24.         IR_KEY_9                = IR_KEY_STRAT + 0x4A,        
    
25. }IR_KEY_E;

复制代码

3 x, r$ L; n+ l$ [) j; r我们下面来看一段简单的应用。这个应用的功能是：主板K1键控制LED1指示灯；遥控器的POWER键和MENU键控制LED2指示灯。

* ^8 D- w+ Z9 x

1. #include "bsp.h"
   - D! R3 L5 q* i) ]! I
2. 
   6 b! u2 d9 D1 `2 X- }# W
3. int main(void)
   
4. {
   
5.         uint8_t ucKeyCode;
   8 k4 s) w# [6 h" N/ o0 Z* l* ?7 y
6.                         
   
7.         bsp_Init();
   + B+ T! C* }" Q7 A; d1 r
8. 
   
9.         IRD_StartWork();        /* 启动红外解码 */
   
10. 
    
11.         while(1)
    
12.         {
    
13.                 bsp_Idle();
    
14.                
    ! O  P3 J. t2 ]( P( m# ?' u  {
15.                 /* 处理按键事件 */
    - P. n, i& E: b9 A) d  P
16.                 ucKeyCode = bsp_GetKey();
    3 F( C  ^5 M, \( [/ K7 r
17.                 if (ucKeyCode > 0)
    
18.                 {
    
19.                         /* 有键按下 */
    ! b+ v8 K* R9 V4 Z' E
20.                         switch (ucKeyCode)
    
21.                         {
      W6 n# j& F9 B2 c
22.                                 case KEY_DOWN_K1:                /* K1键按下 */
    & ^9 b5 c( q- ~( d: I% b" T9 k
23.                                         bsp_LedOn(1);                /* 点亮LED1 */
    
24.                                         break;
    # y, r$ A& v" y# c' _9 ^5 f
25. 
    
26.                                 case KEY_UP_K1:                /* K1键弹起 */
    
27.                                         bsp_LedOff(1);        /* 熄灭LED1 */
    
28.                                         break;                                       
    
29. 
    
30.                                 case IR_KEY_POWER:                /* 遥控器POWER键按下 */
    1 Z' Q  s) O9 R* I7 M0 d
31.                                         bsp_LedOn(1);                /* 点亮LED2 */
    
32.                                         break;
    # q$ {8 T. Q, U3 V2 J, F' g
33. 
    " w3 u) I  l9 V% X+ C
34.                                 case IR_KEY_MENU:                /* 遥控器MENU键按下 */
    . y: h0 O5 x4 s& L2 F0 Z4 m
35.                                         bsp_LedOff(1);        /* 熄灭LED2 */
    0 }0 n* u& M! X; B8 q
36.                                         break;                                       
    0 A7 h' X. x; n2 L; X
37. 
    
38.                                 case MSG_485_RX:                /* 通信程序的发来的消息 */
    
39.                                         /* 执行通信程序的指令 */
    
40.                                         break;
    / c3 o$ V( B9 B% K0 j
41. 
    
42.                                 default:
    
43.                                         break;
    1 K( W; w* q9 u3 \  v
44.                         }
    
45.                 }
    5 h! e# y9 C, r) S! i5 g$ {
46.         }
    & X8 }& z. ]8 b3 r, |
47. }

复制代码

9 m, Z9 U: {0 d" y) R9 w; `看到这里，想必你已经意识到bsp_PutKey函数的强大之处了，可以将不相关的硬件输入设备统一为一个相同的接口函数。

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

0 T# }! [' C% _- l1 U" G对于简单的程序，可以借用按键FIFO来进行少量的信息传递。对于复杂的应用，我们推荐使用bsp_msg专门来做这种任务间的通信。因为bsp_msg除了传递消息代码外，还可以传递参数结构。
) K/ J+ H2 e) r2 r1 t$ D! `
19.3.3 按键检测程序分析
+ J, Q! Y7 _! w2 Z3 s: |6 C( t在bsp_key.h 中定了结构体类型KEY_T。

" E5 R  r0 b* M1 R; x. l7 n& ?4 g

1. #define KEY_COUNT    10                           /* 按键个数, 8个独立建 + 2个组合键 */
   8 D. Q4 J0 B6 m  Y+ B
2. 
   
3. typedef struct
   6 x, b* C" B" ]' X1 V4 H' {
4. {
   
5.         /* 下面是一个函数指针，指向判断按键手否按下的函数 */
   / B  i) C4 H8 w8 W  _
6.         uint8_t (*IsKeyDownFunc)(void); /* 按键按下的判断函数,1表示按下 */
   
7. 
   
8.         uint8_t  Count;                /* 滤波器计数器 */
   
9.         uint16_t LongCount;        /* 长按计数器 */
   
10.         uint16_t LongTime;                /* 按键按下持续时间, 0表示不检测长按 */
    6 h3 B* W4 L* o) g. e
11.         uint8_t  State;                /* 按键当前状态（按下还是弹起） */
    * ?( a6 v& l: j+ M3 O6 U! }2 k
12.         uint8_t  RepeatSpeed;        /* 连续按键周期 */
    
13.         uint8_t  RepeatCount;        /* 连续按键计数器 */
      v" c/ |! I" ^1 g; B7 U
14. }KEY_T;

复制代码

* j6 n6 H7 d# {( y+ }0 v在bsp_key.c 中定义s_tBtn结构体数组变量。
/ V2 I+ |8 J( r- t+ A

1. static KEY_T s_tBtn[KEY_COUNT];
   & i3 W, t( V9 ]  U* [( b/ E
2. static KEY_FIFO_T s_tKey; /* 按键FIFO变量,结构体 */

复制代码

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

$ m! b3 M- \4 z8 E3 t使用函数指针IsKeyDownFunc可以将每个按键的检测以及组合键的检测代码进行统一管理。

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

+ {6 w1 I* y) X2 ~% q6 @+ ]

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_InitKey
   6 q+ u8 j7 h; O# y
4. *        功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
   7 N3 t5 k4 w. L. s6 ]% w2 @
5. *        形    参: 无
   
6. *        返 回 值: 无
   " K5 E! Z; p3 A2 [4 ?; I$ T
7. *********************************************************************************************************
   
8. */
   9 J' Q$ l* g8 D- J8 N
9. void bsp_InitKey(void)
   , _: q+ M/ A- A2 u- h
10. {
    * f) f, k- u( N
11.         bsp_InitKeyVar();                /* 初始化按键变量 */
    
12.         bsp_InitKeyHard();                /* 初始化按键硬件 */
    
13. }

复制代码

. k+ J& y, m9 F下面是bsp_InitKeyVar函数的定义：

7 C& T- m: P% C7 x1 p" n

1. /*
   6 X) s6 W- C8 k! a; r; q% C. A
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_InitKeyVar
   
4. *        功能说明: 初始化按键变量
   
5. *        形    参:  无
   6 T9 r+ z" i0 g9 }1 t1 b
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void bsp_InitKeyVar(void)
   ' q! A8 D, }4 e3 Q# G
10. {
    . v- \5 b" I  V9 p4 y. S- }
11.         uint8_t i;
    
12. 
    
13.         /* 对按键FIFO读写指针清零 */
    ; q! m3 P6 x, Y5 T0 m
14.         s_tKey.Read = 0;
    
15.         s_tKey.Write = 0;
    # W& H1 l1 f# ]+ W
16.         s_tKey.Read2 = 0;
    
17. 
    
18.         /* 给每个按键结构体成员变量赋一组缺省值 */
    
19.         for (i = 0; i < KEY_COUNT; i++)
    
20.         {
    + I. }* ^" C6 q5 l  v; u6 I
21.                 s_tBtn<i>.LongTime = KEY_LONG_TIME;                        /* 长按时间 0 表示不检测长按键事件 */</i>
    
22. <span style="font-style: italic;">                s_tBtn.Count = KEY_FILTER_TIME / 2;                /* 计数器设置为滤波时间的一半 */
    6 f+ w% S# F1 A' o* n* R8 M
23.                 s_tBtn<span style="font-style: italic;">.State = 0;                                                /* 按键缺省状态，0为未按下 */
    
24.                 s_tBtn<span style="font-style: italic;">.RepeatSpeed = 0;                                        /* 按键连发的速度，0表示不支持连发 */
    
25.                 s_tBtn<i style="font-style: italic;">.RepeatCount = 0;                                        /* 连发计数器 */
    ; B+ f9 N; t0 o  R
26.      </i><span style="font-style: normal;">   }
    & h6 e7 G: y5 u$ J
27. 
    " V6 s$ j7 ~0 U& h
28.         /* 如果需要单独更改某个按键的参数，可以在此单独重新赋值 */
    
29.         
    , B1 y1 W1 q+ `& `* M  ]! d, R
30.         /* 摇杆上下左右，支持长按1秒后，自动连发 */
    
31.         bsp_SetKeyParam(KID_JOY_U, 100, 6);
    
32.         bsp_SetKeyParam(KID_JOY_D, 100, 6);
    
33.         bsp_SetKeyParam(KID_JOY_L, 100, 6);
    6 b9 o0 U- E5 S) q' Q: ]/ V
34.         bsp_SetKeyParam(KID_JOY_R, 100, 6);
    
35. }</span></span></span></span>

复制代码

2 `3 U# L+ z  C: H; `) d7 h注意一下 Count 这个成员变量，没有设置为0。为了避免主板上电的瞬间，检测到一个无效的按键按下或弹起事件。我们将这个滤波计数器的初值设置为正常值的1/2。bsp_key.h中定义了滤波时间和长按时间。
" b; D( i. h* r. }2 ?

1. /*
   , X5 I- J% a1 |# F3 r3 h
2.         按键滤波时间50ms, 单位10ms。
   
3.         只有连续检测到50ms状态不变才认为有效，包括弹起和按下两种事件
   ! |5 E; Q& v* y8 T  }$ F
4.         即使按键电路不做硬件滤波，该滤波机制也可以保证可靠地检测到按键事件
   ; e& N9 W3 A9 y. \$ H- p+ G( j
5. */
   $ Y; k6 Q% z7 I; c- _6 K5 n
6. #define KEY_FILTER_TIME   5
   : ]5 ]9 w- _/ o* v
7. #define KEY_LONG_TIME     100                        /* 单位10ms， 持续1秒，认为长按事件 */

复制代码

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

0 V. t: w9 B/ f9 A  O7 B& E; c

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: KeyPinActive
   1 m, [7 ^$ y" c4 j6 y1 Y, u
4. *        功能说明: 判断按键是否按下
   5 f2 [: V' r3 N
5. *        形    参: 无
   1 P' D0 w; v3 K
6. *        返 回 值: 返回值1 表示按下(导通），0表示未按下（释放）
   & o. {% a) Y/ o9 i; H9 f/ _6 d  ^9 n
7. *********************************************************************************************************
   
8. */
   $ J# u/ [1 U2 Q% q2 V
9. static uint8_t KeyPinActive(uint8_t _id)
   
10. {
    
11.         uint8_t level;
    
12.         
    / f( p* v1 \5 n9 y( d5 |- T8 H4 c
13.         if ((s_gpio_list[_id].gpio->IDR & s_gpio_list[_id].pin) == 0)
    
14.         {
    3 a9 K* m9 k# F; W- `" c% m
15.                 level = 0;
    / @2 Z6 `9 k8 U8 X
16.         }
    
17.         else
    . [) l. ?4 t/ x1 E8 E0 v/ p9 G
18.         {
    
19.                 level = 1;
    
20.         }
    
21. 
    
22.         if (level == s_gpio_list[_id].ActiveLevel)
    ' u0 d' l" ?; x4 _5 [: h/ J- U" U
23.         {
    
24.                 return 1;
    5 v4 ?0 h: A8 i1 z: A3 V9 R+ Q  T
25.         }
    
26.         else
    
27.         {
    % u: g9 v0 o$ D3 b( P
28.                 return 0;
    & o! x$ K8 x' _" p
29.         }
    
30. }
    6 C. Z2 c2 j8 ]; q. g7 z
31. 
    
32. /*
    
33. *********************************************************************************************************
    
34. *        函 数 名: IsKeyDownFunc
    0 p  t) T+ k* t
35. *        功能说明: 判断按键是否按下。单键和组合键区分。单键事件不允许有其他键按下。
    ; S$ {8 w( X" M2 k5 H, B+ I
36. *        形    参: 无
    
37. *        返 回 值: 返回值1 表示按下(导通），0表示未按下（释放）
    
38. *********************************************************************************************************
    ' X2 E+ I% h& D  i" v! ]2 W
39. */
    $ b" F! d/ F* l3 U7 K
40. static uint8_t IsKeyDownFunc(uint8_t _id)
    
41. {
    6 X8 N8 `3 D# K1 M3 E7 _
42.         /* 实体单键 */
    ( V+ N- I& l3 s, p) T
43.         if (_id < HARD_KEY_NUM)
    
44.         {
    
45.                 uint8_t i;
    - R; v/ m. O8 N& L2 n
46.                 uint8_t count = 0;
    
47.                 uint8_t save = 255;
    
48.                
    ) ~( ~; `0 e* D
49.                 /* 判断有几个键按下 */
    6 L2 g. ^8 ]& E% d% A  a* y$ _
50.                 for (i = 0; i < HARD_KEY_NUM; i++)
    . t5 B1 ?  t5 M! m* C& N
51.                 {
    
52.                         if (KeyPinActive(i))
    ( R1 T0 Q' z5 W1 d: B6 g
53.                         {
    / z+ W+ Y; q7 M) I
54.                                 count++;
    
55.                                 save = i;
    1 z- F# T; P- H/ a" C% M
56.                         }
    % ^! Y+ r, Q0 c
57.                 }
    
58.                
    
59.                 if (count == 1 && save == _id)
    
60.                 {
    " R2 J1 L) |7 F. o
61.                         return 1;        /* 只有1个键按下时才有效 */
    
62.                 }               
    
63. 
    
64.                 return 0;
    
65.         }
    
66.         
    , `) ~9 z, j' f4 u
67.         /* 组合键 K1K2 */
    
68.         if (_id == HARD_KEY_NUM + 0)
    
69.         {
    : @. x) R6 f2 Z0 ^- i
70.                 if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
    * f' P0 c9 Q" @( m
71.                 {
    9 N+ K9 x. S0 z) m3 t
72.                         return 1;
    6 k2 q* l+ ?" c; ?
73.                 }
    
74.                 else
    
75.                 {
    , U+ S7 w, u+ ~7 y9 F& [* b
76.                         return 0;
    
77.                 }
    * W- M  E) O( h4 P
78.         }
    , p, i/ n+ F# G" t0 |
79. 
    6 J# w% G7 g  y  w, j1 e* f; \
80.         /* 组合键 K2K3 */
    0 a7 m: q8 J3 q
81.         if (_id == HARD_KEY_NUM + 1)
    , u6 G' H( ~+ g/ H1 _
82.         {
    & q/ \0 t& q  I+ n" B
83.                 if (KeyPinActive(KID_K2) && KeyPinActive(KID_K3))
    5 R7 j4 {1 @: ~, ]# |, ~# M. s2 a
84.                 {
    - r" i) K0 A: y& L. _
85.                         return 1;
    ) o  R, n0 p" b( g9 e3 n7 r" Z; f/ r
86.                 }
    , C& R5 T1 Y6 y
87.                 else
    
88.                 {
    6 l6 X# V5 o! [0 K8 A
89.                         return 0;
    . y" T. k/ T1 e+ ^9 G  q) X
90.                 }
    
91.         }
    
92. 
    / ?4 D% y+ S/ w
93.         return 0;
    
94. }

复制代码

) K) W% u4 |6 e4 U/ G; V在使用GPIO之前，我们必须对GPIO进行配置，比如打开GPIO时钟，设置GPIO输入输出方向，设置上下拉电阻。下面是配置GPIO的代码，也就是bsp_InitKeyHard（）函数：
5 ~5 O6 O# U) e+ |9 c
  S- j3 O0 [% ?- v9 }* g

1. /*
   
2. *********************************************************************************************************
   9 b$ }; `" `, ^$ J
3. *        函 数 名: bsp_InitKeyHard
   + @0 I+ Z. @% I9 h  d
4. *        功能说明: 配置按键对应的GPIO
   
5. *        形    参:  无
   
6. *        返 回 值: 无
   ) G2 [  V, [+ d# e
7. *********************************************************************************************************
   
8. */
   7 K6 A# m! ?) F2 `) `. y
9. static void bsp_InitKeyHard(void)
   
10. {        
    , L$ N: J- Q7 e9 A4 u1 |% @
11.         GPIO_InitTypeDef gpio_init;
    7 ^" _2 E3 v2 y5 P
12.         uint8_t i;
    * X3 C; {% h0 [0 r! M, f+ G
13. 
    
14.         /* 第1步：打开GPIO时钟 */
    # D+ g% z% }+ K. ]5 i
15.         ALL_KEY_GPIO_CLK_ENABLE();
    
16.         
    
17.         /* 第2步：配置所有的按键GPIO为浮动输入模式(实际上CPU复位后就是输入状态) */
    
18.         gpio_init.Mode = GPIO_MODE_INPUT;                           /* 设置输入 */
    3 \1 z/ Q( s" A) L, X' l# x4 T' J
19.         gpio_init.Pull = GPIO_NOPULL;                 /* 上下拉电阻不使能 */
    8 E( r) z( K9 n1 ~. n4 D) r
20.         gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;  /* GPIO速度等级 */
    
21.         
    : {+ O0 [0 R7 G; _9 g
22.         for (i = 0; i < HARD_KEY_NUM; i++)
    
23.         {
      V. q9 |' D  h. e
24.                 gpio_init.Pin = s_gpio_list<span style="font-style: italic;"><span style="font-style: normal;">.pin;
    : s2 S3 A4 F4 e2 h6 A0 y
25.                 HAL_GPIO_Init(s_gpio_list</span><span style="font-style: normal;">.gpio, &gpio_init);        
    
26.         }
    - R! Q3 t* y) f& u0 N  \# m, o
27. }</span></span>

复制代码

; U+ ^/ A, m9 X+ b/ Z我们再来看看按键是如何执行扫描检测的。

0 f) P( _+ Y# e$ |' w按键扫描函数bsp_KeyScan10ms ()每隔10ms被执行一次。bsp_RunPer10ms函数在systick中断服务程序中执行。

2 L: N% O; K" m/ {' \2 o7 s

1. void bsp_RunPer10ms(void)
   
2. {
   
3.         bsp_KeyScan10ms();                /* 扫描按键 */
   
4. }

复制代码

bsp_KeyScan10ms ()函数的实现如下：
" B: x4 A* g4 Y$ T. \

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_KeyScan10ms
   
4. *        功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
   
5. *        形    参: 无
   & A: g9 k# d, S1 f/ w3 i9 A$ f& H1 R
6. *        返 回 值: 无
   9 ?" y1 F$ J3 K
7. *********************************************************************************************************
   ( q7 b2 {  [" n% P9 `$ q) a
8. */
   3 Y+ W" S. m, E* \8 y( J
9. void bsp_KeyScan10ms(void)
   " t) i# Y9 a/ g) M* h
10. {
    6 `5 _2 W3 j* t! U* O$ j: A6 [
11.         uint8_t i;
    
12. 
    
13.         for (i = 0; i < KEY_COUNT; i++)
    
14.         {
    
15.                 bsp_DetectKey(i);
    
16.         }
    
17. }

复制代码

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

9 @5 A  c4 S/ V7 V5 q" {

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_DetectKey
   , z  P! Z5 i* J) x+ m4 }
4. *        功能说明: 检测一个按键。非阻塞状态，必须被周期性的调用。
   # g2 F0 z# ?, r) h! }7 y6 Q
5. *        形    参: IO的id， 从0开始编码
   ) ^/ a( i3 ]4 G! ]( }& `" n; M
6. *        返 回 值: 无
   ! G7 Q( G, h) _! j9 [
7. *********************************************************************************************************
   ; ^2 T" J% m' s
8. */
   , u8 |$ Y+ g: C5 ]
9. static void bsp_DetectKey(uint8_t i)
   4 W# W) ^. Q4 x! p2 a1 k  F* I! i
10. {
    
11.         KEY_T *pBtn;
    5 ]+ Z5 \2 m+ t! [4 ~' r
12. 
    
13.         pBtn = &s_tBtn<span style="font-style: italic;"><span style="font-style: normal;">;
    
14.         if (IsKeyDownFunc(i))
    $ o) V( c! y" v* a) @4 C
15.         {
    4 A0 @( K* z" a4 f; ?0 [( g- k1 F
16.                 if (pBtn->Count < KEY_FILTER_TIME)
    
17.                 {
    
18.                         pBtn->Count = KEY_FILTER_TIME;
    0 Q& c4 V& N  J3 W/ o
19.                 }
    2 b3 b- j( l2 P1 H6 G1 o; q
20.                 else if(pBtn->Count < 2 * KEY_FILTER_TIME)
    
21.                 {
    
22.                         pBtn->Count++;
    0 x* Y1 N* O6 [0 A0 p, }3 {
23.                 }
    : i' g1 Z4 e! z1 Z4 Z- @
24.                 else
    
25.                 {
    
26.                         if (pBtn->State == 0)
    
27.                         {
    
28.                                 pBtn->State = 1;
    
29. 
    2 M* F6 A6 @& d: w
30.                                 /* 发送按钮按下的消息 */
    ( P) `* K5 g) M" E
31.                                 bsp_PutKey((uint8_t)(3 * i + 1));
    8 j2 _* H) K/ b2 _: M7 G+ C" ?
32.                         }
    
33. 
    5 w7 p, b( V7 L  m% o9 \. i
34.                         if (pBtn->LongTime > 0)
    / e1 L5 c4 l3 y; Y
35.                         {
    % v- ^  A5 r* A' @2 b
36.                                 if (pBtn->LongCount < pBtn->LongTime)
    
37.                                 {
    
38.                                         /* 发送按钮持续按下的消息 */
    3 f1 o( |9 h# ?( U% t
39.                                         if (++pBtn->LongCount == pBtn->LongTime)
    
40.                                         {
    & o2 A8 K+ z# f! U4 h
41.                                                 /* 键值放入按键FIFO */
    
42.                                                 bsp_PutKey((uint8_t)(3 * i + 3));
    
43.                                         }
    
44.                                 }
    9 ~# w6 c; h2 c* @  ^( K" |
45.                                 else
    2 L7 C" w% H5 B' {7 @
46.                                 {
      T* o1 I' h. E' U5 X
47.                                         if (pBtn->RepeatSpeed > 0)
    
48.                                         {
    
49.                                                 if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
    6 h( k# }4 Z7 b0 D+ e5 D
50.                                                 {
    
51.                                                         pBtn->RepeatCount = 0;
    5 a2 z* T5 o! r+ k
52.                                                         /* 常按键后，每隔RepeatSpeed * 10ms发送1个按键 */
    6 S" K8 h# G3 k5 h
53.                                                         bsp_PutKey((uint8_t)(3 * i + 1));
    
54.                                                 }
    
55.                                         }
    % `/ a5 Z7 c% X1 b; |8 B
56.                                 }
    ( c  [2 \  p* i1 }6 |
57.                         }
    3 C) X/ ?% [+ ~1 W
58.                 }
    
59.         }
    
60.         else
    5 i8 j% Y! q8 c/ `5 C! `! q# ?0 }
61.         {
    
62.                 if(pBtn->Count > KEY_FILTER_TIME)
    & k, k" c" s* E% ?  f1 b: G# \3 {. C
63.                 {
    
64.                         pBtn->Count = KEY_FILTER_TIME;
    8 a6 t2 j3 @4 w7 Z. k: y) a
65.                 }
    
66.                 else if(pBtn->Count != 0)
    
67.                 {
    3 Z# ?3 z3 F. A
68.                         pBtn->Count--;
      D, o$ [; k- d8 s
69.                 }
    
70.                 else
    : N+ ]) r) W, l* }/ h& O* @
71.                 {
    
72.                         if (pBtn->State == 1)
    
73.                         {
    
74.                                 pBtn->State = 0;
    $ p- W& {: ?5 D
75. 
    
76.                                 /* 发送按钮弹起的消息 */
    
77.                                 bsp_PutKey((uint8_t)(3 * i + 2));
    , a+ H( L! ]0 n
78.                         }
    
79.                 }
    ; U" K: n5 M  Q; w
80. 
    3 Y4 X2 k5 @% v. E
81.                 pBtn->LongCount = 0;
    
82.                 pBtn->RepeatCount = 0;
    ! h2 `0 L, g3 a: _" E
83.         }
    ! e* I# M" A2 Q+ ], P5 X! j
84. }</span></span>

复制代码

0 M2 X. c7 b  W1 [& V! H对于初学者，这个函数看起来比较吃力，我们拆分进行分析。
* V' h, q- Z9 x! p6 K5 x7 N) k' L
' v) k1 _/ ]/ h* a; O

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

复制代码

, P3 ]5 q9 o' a: ?6 p读取相应按键的结构体地址，程序里面每个按键都有自己的结构体。
: f. t/ y- c& v, H6 t7 a

1. static KEY_T s_tBtn[KEY_COUNT];
   
2. if (IsKeyDownFunc(i))
   2 |' r& C8 ]& p( e3 l
3. {
   0 T8 u9 s" }8 e; ~) U3 G
4.         这个里面执行的是按键按下的处理
   + J5 l+ ?' w# _2 G
5. }
   
6. else
   6 ~/ O4 F0 y% B7 r
7. {
   
8.         这个里面执行的是按键松手的处理或者按键没有按下的处理
   
9. }

复制代码

# W$ j$ P( G! K2 V0 z8 s执行函数IsKeyDownFunc(i)做按键状态判断。

8 }! H% y8 ^, e3 q  n2 Z) h

1. /*
   ; w6 u$ s' q4 Y8 U6 B4 ^1 y
2. **********************************************************************************
   
3. 下面这个if语句主要是用于按键滤波前给Count设置一个初值，前面说按键初始化的时候
   9 Q3 A6 E3 ]3 g; {1 G
4. 已经设置了Count = KEY_FILTER_TIME/2
   
5. **********************************************************************************
   5 Y+ Z) v: |- `% R% O& b* H) I$ u
6. */
   
7. if (pBtn->Count < KEY_FILTER_TIME)
   
8. {
   ! c: C/ j( V/ E2 F  i* D
9.     pBtn->Count = KEY_FILTER_TIME;
   # |; ]$ N: S) [2 m0 U% {
10. }
    $ P  ?- Q  C& a2 P7 J+ y
11. 
    
12. /*
    4 c9 r! a0 i0 q! x3 A. G2 r1 J2 q
13. **********************************************************************************
    
14. 这里实现KEY_FILTER_TIME时间长度的延迟
    + s% g) }/ g& V
15. **********************************************************************************
    / Z  o$ d& B* v) f) b% Q
16. */
    3 ~: H# V6 e3 q
17. else if(pBtn->Count < 2 * KEY_FILTER_TIME)
    
18. {
    
19.     pBtn->Count++;
    $ m' m& Y/ ?- Q
20. }
    
21. /*
    
22. **********************************************************************************
    6 [( ?: g% l) \8 y# J) p
23. 这里实现KEY_FILTER_TIME时间长度的延迟
    
24. **********************************************************************************
    : x0 J( ?& M! T. _  U; m
25. */
    
26. else
    1 a" i6 ]5 n$ E. [* S
27. {
    " I0 q2 i: F2 b6 J1 S
28. /*
    9 [3 A. h) K' b' R9 M" R
29. **********************************************************************************
    , W8 H& X. c2 n* m% v3 i) u
30. 这个State变量是有其实际意义的，如果按键按下了，这里就将其设置为1，如果没有按下这个
    
31. 变量的值就会一直是0，这样设置的目的可以有效的防止一种情况的出现：比如按键K1在某个
    
32. 时刻检测到了按键有按下，那么它就会做进一步的滤波处理，但是在滤波的过程中，这个按键
    6 u; R, q; x5 r' \
33. 按下的状态消失了，这个时候就会进入到上面第二步else语句里面，然后再做按键松手检测滤波
    5 \" @3 m" H, h5 F- }1 _
34. ，滤波结束后判断这个State变量，如果前面就没有检测到按下，这里就不会记录按键弹起。
    8 r( M& U4 \: e, C5 |- X
35. **********************************************************************************
    $ f$ |$ o7 i  G4 K/ t
36. */
    + _* Y' E* q3 F) v6 B7 S! R
37.     if (pBtn->State == 0)
    
38.     {
    ' e/ G/ J% q, A) j9 g, N
39.         pBtn->State = 1;
    * b4 m' |: F' I# ]" K. b# R
40. 
    
41.         /* 发送按钮按下的消息 */
    ' @) h' l' {) P& M
42.         bsp_PutKey((uint8_t)(3 * i + 1));
    : ]5 j1 S4 G9 [2 p, ]
43.     }
    ' G4 j) w' w) V6 k6 g
44. 
    
45.     if (pBtn->LongTime > 0)
    , J# y( {$ l! G
46.     {
    ) w% I1 {! N2 a0 o
47.         if (pBtn->LongCount < pBtn->LongTime)
    
48.         {
    
49.             /* 发送按钮持续按下的消息 */
    
50.             if (++pBtn->LongCount == pBtn->LongTime)
    + b* S, k  _& x3 h0 g; z+ _  K& s
51.             {
    
52.                 /* 键值放入按键FIFO */
    
53.                 bsp_PutKey((uint8_t)(3 * i + 3));
    
54.             }
    # x  R  Z) _! P# ^
55.         }
    
56.         else
    . I- W# k" D- \1 J8 p) i" R, s4 u
57.         {
    ) m9 x6 ?% ~( s/ G7 B
58.             if (pBtn->RepeatSpeed > 0)
    
59.             {
    5 U+ J; s. e" A. p* ~
60.                 if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
    4 V3 k7 \+ `8 w& D
61.                 {
    
62.                     pBtn->RepeatCount = 0;
    . y1 v$ X; |. _( ~" e8 D$ o
63.                     /* 长按键后，每隔10ms发送1个按键 */
    $ Y6 B2 _7 D0 d! Y. g
64.                     bsp_PutKey((uint8_t)(3 * i + 1));
    5 Q% I0 J& q. }/ O  T
65.                 }
    1 w6 V0 G2 @& C% c9 M+ B  n; h
66.             }
    
67.         }
    : b0 b9 T( |; C1 F' N; A1 `
68.     }
    
69. }

复制代码

" W+ g- v6 T1 \, B( x19.3.4 按键检测采用中断方式还是查询方式
" m5 A9 F+ m' {# k6 C检测按键有中断方式和GPIO查询方式两种。我们推荐大家用GPIO查询方式。

' J% j  E! W9 j从裸机的角度分析

' H6 I, O' I; C8 F3 Z3 N中断方式：中断方式可以快速地检测到按键按下，并执行相应的按键程序，但实际情况是由于按键的机械抖动特性，在程序进入中断后必须进行滤波处理才能判定是否有效的按键事件。如果每个按键都是独立的接一个IO引脚，需要我们给每个IO都设置一个中断，程序中过多的中断会影响系统的稳定性。中断方式跨平台移植困难。
+ E* x$ l4 r2 j1 |0 n& n
+ o4 J( H! G. N2 [6 c查询方式：查询方式有一个最大的缺点就是需要程序定期的去执行查询，耗费一定的系统资源。实际上耗费不了多大的系统资源，因为这种查询方式也只是查询按键是否按下，按键事件的执行还是在主程序里面实现。
( q/ O! s' \' {3 p  Q7 K3 n6 D
' R8 i4 u3 c9 C, o从OS的角度分析

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

19.4 按键板级支持包（bsp_key.c）
按键驱动文件bsp_key.c主要实现了如下几个API：
" W% |* y& z; ^7 @5 V
  KeyPinActive
  IsKeyDownFunc
  bsp_InitKey
  D5 b, t8 X$ `  bsp_InitKeyHard
( ]. @( b* c7 R3 m. a( e2 }# h  bsp_InitKeyVar
& `! P; @/ n+ H0 `+ r6 i7 y, W1 z' V  bsp_PutKey
  bsp_GetKey
  bsp_GetKey2
) Y9 c; c2 E" J* A3 U6 }+ A  bsp_GetKeyState
  bsp_SetKeyParam
' M* q. K8 E/ d3 \* m8 [  bsp_ClearKey
  bsp_DetectKey
  bsp_DetectFastIO
$ j) b7 i6 m4 q+ Y  Z& j0 n  bsp_KeyScan10ms
' M% `, ?: M" K' `2 d3 |, Q9 U9 ^  bsp_KeyScan1ms
3 R% n6 S) K# {! Q0 I! `
' M: Z  c- u3 F2 \所有这些函数在本章的19.3小节都进行了详细讲解，本小节主要是把需要用户调用的三个函数做个说明。

: c: c6 p* q! k2 q+ s19.4.1 函数bsp_InitKeyHard
函数原型：
; {2 ^- ?) R* l. }$ B

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_InitKey
   
4. *        功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
   ! ~  X% e5 ]8 J+ T
5. *        形    参: 无
   ( O: W) H! H" P2 v. P- _
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   . q0 n4 P8 G5 }5 O' f5 B* U
9. void bsp_InitKey(void)
   
10. {
    + u: M% k2 o. X: m$ m* O
11.         bsp_InitKeyVar();                /* 初始化按键变量 */
    ! k5 F) W9 A. U% ]6 R% r
12.         bsp_InitKeyHard();                /* 初始化按键硬件 */
    , b& s1 p/ ~4 F9 t' Y3 t* b
13. }

复制代码

8 U# s/ f% d9 B  D0 I  a" p函数描述：
7 x4 I2 l. @, n
( n5 n7 X6 a: d3 S0 f: ?: n- J( Q4 f此函数主要用于按键的初始化。
5 i7 l; l7 m3 s1 A* a
使用举例：
* t7 k4 C" J+ P$ b( X5 F
底层驱动初始化直接在bsp.c文件的函数bsp_Init里面调用即可。
0 m9 U2 u& D9 R% G2 u8 E
& m! ~. L1 q. `% T0 k& S19.4.2 函数bsp_GetKey
' }2 }/ v/ B$ V8 C函数原型：
# C. z5 \7 F6 h0 I

1. /*
   3 i. {4 |& k1 ^* g- ^: ]
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_GetKey
   
4. *        功能说明: 从按键FIFO缓冲区读取一个键值。
   
5. *        形    参: 无
   
6. *        返 回 值: 按键代码
   & }# h& J* V( J. f5 |5 J
7. *********************************************************************************************************
   # t1 t% \  c3 T2 H- ^
8. */
   $ Q5 t' G. ]8 N5 B
9. uint8_t bsp_GetKey(void)
   
10. {
    % l6 p: _% u$ i/ ~- E
11.         uint8_t ret;
    
12. 
    
13.         if (s_tKey.Read == s_tKey.Write)
    4 q- l* ^- C. _  i/ D. v
14.         {
    
15.                 return KEY_NONE;
    
16.         }
    3 e3 R& {; }' s& M" ?8 y
17.         else
    
18.         {
    , K. e" w- V/ n( f! ~
19.                 ret = s_tKey.Buf[s_tKey.Read];
    
20. 
    
21.                 if (++s_tKey.Read >= KEY_FIFO_SIZE)
    6 F. B: e( N  ]$ v. H  N
22.                 {
      \$ ?8 B6 a& O# n" }. j9 b7 D
23.                         s_tKey.Read = 0;
    # D0 x4 K( Y! i, t
24.                 }
    " C& s0 X1 ~$ e3 Q- P3 C2 M
25.                 return ret;
    
26.         }
    " h# ~  ^$ P) |* F
27. }

复制代码

, h+ q- I) j" p; K0 z9 F函数描述：

此函数用于从FIFO中读取键值。
7 g1 O& L& `; u7 j3 L* y
( C7 e" ]# E7 V' L$ S使用举例：

' a% U% i7 X; I( c& V5 X# Q/ U* n调用此函数前，务必优先调用函数bsp_InitKey进行初始化。

" X4 J) h- v9 U

1. /*
   : C* @% `2 Y7 S; R% P4 c
2. *********************************************************************************************************
   ; m9 L& N# \6 n$ U1 k
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   $ o1 Y3 F. o, Y3 e$ F
5. *        形    参: 无
   ) D3 x, L4 C$ T
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   2 J) I( X+ w2 n4 m) W
8. */
   ' N; q# L- H2 l# }3 X7 |7 @& f
9. int main(void)
   " o8 Z& U$ A! `, w0 G3 @; Y
10. {
    " _* K9 r( E6 b
11.         uint8_t ucKeyCode;                /* 按键代码 */
    
12.         
    : o  I$ y' t5 g/ z
13.         bsp_Init();                /* 硬件初始化 */
    
14.         
    
15.         /* 进入主程序循环体 */
    
16.         while (1)
    7 ]$ ]- g! W$ ?3 W( n; o  S
17.         {               
    
18.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    / h! F/ C6 Z/ ~* p
19.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    # {  E5 `4 r$ k& d- R! p
20.                 if (ucKeyCode != KEY_NONE)
    - P2 a2 C5 S1 G% ?2 j2 ^
21.                 {
    9 z5 L6 ]# A# ?" n
22.                         switch (ucKeyCode)
    
23.                         {
    
24.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    
25.                                         printf("K1键按下\r\n");
    
26.                                         break;
    
27. 
    ; W3 h1 B& v1 p. S0 m( b
28.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    
29.                                         printf("K2键按下\r\n");
    
30.                                         break;
    
31. 
    $ l+ ~' j( ^1 I8 E
32.                                 default:
    
33.                                         /* 其它的键值不处理 */
    8 C% b9 w" q) B
34.                                         break;
    
35.                         }
    
36.                 }
    
37.         }
    
38. }

复制代码

19.4.3 函数bsp_KeyScan10ms
9 B; F- f" g5 g! {) [4 _  z2 J函数原型：
3 W# c0 Q: i' q

1. /*
   3 P( _% d- \& f4 d2 h; O' B$ \0 {
2. *********************************************************************************************************
   $ x, C: v" T: \' U" ~* W* \
3. *        函 数 名: bsp_KeyScan10ms
   ' I; X8 m( W0 a; ^
4. *        功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
   ) F7 N' z/ x, J1 K  _
5. *        形    参: 无
   + q! U2 x5 E' u2 e4 L. H, w4 f+ B
6. *        返 回 值: 无
   3 E- B6 o: w; R: ^% A/ v! y
7. *********************************************************************************************************
   " u9 t: z# L, c  [
8. */
   . p7 I4 c1 V4 r2 O$ N. @& Q0 [
9. void bsp_KeyScan10ms(void)
   9 V* {9 S/ h% |1 ]) G
10. {
    2 l6 P) F) c- O7 g0 }/ a. N+ s
11.         uint8_t i;
    
12. 
    
13.         for (i = 0; i < KEY_COUNT; i++)
    
14.         {
    - A; w4 G+ g! g% l) w6 c
15.                 bsp_DetectKey(i);
    
16.         }
    
17. }

复制代码

( ^6 K. `0 D. N' p. k% y' @# u函数描述：

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

使用举例：

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

另外，此函数需要周期性调用，每10ms调用一次。
+ ?5 Z  E2 Z) ^4 E
0 O* F/ R4 w$ u) b$ j  如果是裸机使用，将此函数放在bsp.c文件的bsp_RunPer10ms函数里面即可，这个函数是由滴答定时器调用的，也就是说，大家要使用按键，定时器的初始化函数bsp_InitTimer一定要调用。
  如果是RTOS使用，需要开启一个10ms为周期的任务调用函数bsp_KeyScan10ms。

19.5 按键FIFO驱动移植和使用
# g( }/ a% Q4 ]* l* \按键移植步骤如下：

  第1步：复制bsp_key.c和bsp_key.c到自己的工程。
5 J( o! a  J9 t( c! k( x  第2步：根据自己使用的独立按键个数和组合键个数，修改几个地方。

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

复制代码

0 W1 m* {9 W) W# }5 u  第3步：根据使用的引脚时钟，修改下面函数：

1. /* 使能GPIO时钟 */
   
2. #define ALL_KEY_GPIO_CLK_ENABLE() {        \
   % P. [) q1 Y8 Z0 Z
3.                 __HAL_RCC_GPIOB_CLK_ENABLE();        \
   
4.                 __HAL_RCC_GPIOC_CLK_ENABLE();        \
   
5.                 __HAL_RCC_GPIOG_CLK_ENABLE();        \
   . M- P' A, E, f6 J$ Q) M/ `+ A! h' U
6.                 __HAL_RCC_GPIOH_CLK_ENABLE();        \
   
7.                 __HAL_RCC_GPIOI_CLK_ENABLE();        \
   
8.         };

复制代码

  第4步：根据使用的具体引脚，修改如下函数，第3列参数低电平表示按下或者高电平表示按下：
; w. b9 r2 Z+ I8 K7 O

1. /* GPIO和PIN定义 */
   # i" U; w7 x2 s* e' T
2. static const X_GPIO_T s_gpio_list[HARD_KEY_NUM] = {
   ' D; i6 i5 h. `$ S/ r1 S  Z& F
3.         {GPIOI, GPIO_PIN_8, 0},                /* K1 */
   " c+ n) m/ s" `, i
4.         {GPIOC, GPIO_PIN_13, 0},        /* K2 */
   3 h1 e7 h+ o) n
5.         {GPIOH, GPIO_PIN_4, 0},                /* K3 */
   . k0 I6 F9 P0 M1 g! {
6.         {GPIOG, GPIO_PIN_2, 0},                /* JOY_U */        
   
7.         {GPIOB, GPIO_PIN_0, 0},                /* JOY_D */
   % b8 k( T# T' ^' I, ^+ _0 |; g) W! @
8.         {GPIOG, GPIO_PIN_3, 0},                /* JOY_L */        
   ! S4 y) C; t- }' u! O' [
9.         {GPIOG, GPIO_PIN_7, 0},                /* JOY_R */        
   
10.         {GPIOI, GPIO_PIN_11, 0},        /* JOY_OK */
    5 u- e% l! E6 ~% \& W
11. };   

复制代码

     
  第5步：根据使用的组合键个数，在函数IsKeyDownFunc里面添加相应个数的函数：
- f6 @( s5 S1 x) m7 N* D

1.         /* 组合键 K1K2 */
   " [( f- l! E# k* v5 f
2.         if (_id == HARD_KEY_NUM + 0)
   4 m$ F* d. }/ A% _: H8 F
3.         {
   
4.                 if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
   . ]. G4 D! p6 y, @  p4 K
5.                 {
   ( N- I' r5 x# t' Z! R! E
6.                         return 1;
   0 Z  b! ?2 z+ {& s$ s: R
7.                 }
   
8.                 else
   
9.                 {
   . P& _: s, v4 z: p: Z9 {$ N  q9 ]: x
10.                         return 0;
    
11.                 }
    
12.         }

复制代码

第2行ID表示HARD_KEY_NUM + 0的组合键，HARD_KEY_NUM + 1表示下一个组合键，以此类推。
: i, P$ `, D/ I+ J7 U; H
另外就是，函数KeyPinActive的参数是表示检测哪两个按键，设置0的时候表示第4步里面的第1组按键，设置为1表示第2组按键，以此类推。
8 m- U3 j' B$ F& c/ z7 W/ x' M% X& u
2 K9 a; w: h; L0 Z+ q2 {  第6步：主要用到HAL库的GPIO驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
8 V+ X2 _4 v9 ?' [+ Y* J: G0 a4 P5 `  第7步：移植完整，应用方法看本章节配套例子即可。
8 W8 f) E, Q% R/ t3 x特别注意，别忘了每10ms调用一次按键检测函数bsp_KeyScan10ms。

# D' W2 {0 x& i# B19.6 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：
  t$ w3 g* o* P8 ]

9 h8 x# q. c  A6 g. G
1、 第1阶段，上电启动阶段：
3 o4 f* {) [$ J- V* R
/ {( j0 t9 u3 v& O, G1 t+ y) B4 v这部分在第14章进行了详细说明。
% |; Q* B3 X' W' ~1 y5 A
2、 第2阶段，进入main函数：

  第1部分，硬件初始化，主要是MPU、Cache、HAL库、系统时钟、滴答定时器、按键等。
  第2部分，应用程序设计部分，实现了一个按键应用。
  第3部分，按键扫描程序每10ms在滴答定时中断执行一次。
8 j5 Q2 j/ P+ ~8 o
19.7 实验例程说明（MDK）
配套例子：
$ N) }7 C% W% d2 `: m# ~! x2 [+ |; ?V7-002_按键检测（软件滤波，FIFO机制）
2 n8 W* k5 }6 f) N- l" R
5 ^, j, K  }7 v' B2 E, B实验目的：
学习按键的按下，弹起，长按和组合键的实现。

! r$ @' y- F: t5 `实验内容：
, L: D% L- G3 w启动一个自动重装软件定时器，每100ms翻转一次LED2。

- ?" k7 ]3 A* s5 e实验操作：
/ {( q, Y, K; c1 p3个独立按键和5向摇杆按下时均有串口消息打印。
, m4 U" V7 r5 @% y2 i* h5向摇杆的左键和右键长按时，会有连发的串口消息。
5 G9 E  e7 g+ l( j$ w, }$ K独立按键K1和K2按键按下，串口打印消息。

上电后串口打印的信息：

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

9 ?2 n4 G: `2 e& n# [0 k7 Z
程序设计：

2 t- ]) z" q: Z1 w2 E4 W3 z  系统栈大小分配：
3 m6 v% A7 X% M) b: ~: p- l( ?

' u+ N4 Z( F1 k* t" A) o+ V
  RAM空间用的DTCM：
1 U0 B" U3 x$ |

  B' J  M& X' {" b: c8 N  硬件外设初始化

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

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   / {" p) H# c0 U0 R3 ?. v: {; r0 z
5. *        形    参：无
   ' p5 K# h& o8 h# U
6. *        返 回 值: 无
   # k: O2 a! b( }3 U' y/ K
7. *********************************************************************************************************
   9 K& W6 ^; V$ e2 E3 `# i4 w
8. */
   
9. void bsp_Init(void)
   * x6 U: l( j( n* _: l
10. {
    
11.     /* 配置MPU */
    
12.         MPU_Config();
    
13.         
    
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    
16. 
    9 f" h) N( n' i' Y; S+ u: k
17.         /*
    . b% m/ R8 Q: P/ H  k
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    - H! {! d  p, f1 v9 _) T/ v, q/ h
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    6 h. \1 C% l7 k# \3 H% {. S5 c7 S
20.            - 设置NVIV优先级分组为4。
    
21.          */
    
22.         HAL_Init();
    
23. 
    
24.         /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
      G6 k! z, O, o& c
29.         SystemClock_Config();
    
30. 
    & }) i) D7 X$ M5 G0 b3 k
31.         /*
    6 S- l' g0 q" c1 z
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    , ~7 }" T5 [9 Y
40. #endif
    / I! ?. Y# n3 u" ]9 }) I2 o" {9 p
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    * u; S& X9 n. g" C; k* O% r
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    
46.         bsp_InitLed();            /* 初始化LED */        
    0 ]+ l! q4 S9 |% c! g9 e
47. }

复制代码

5 ]+ y& a/ x/ v2 S; N  MPU配置和Cache配置：
& j& [* D! S5 E5 q9 v
5 J( m* }9 ?2 I9 a4 F数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   # d2 r" U- [6 s: D  R7 |& u
4. *        功能说明: 配置MPU
   , H, c4 P7 F( m& Y( q- M
5. *        形    参: 无
   - b& l- ^- l  t0 F; L0 b4 A; I2 r3 a
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   7 z! [6 _8 w( ~; Q
9. static void MPU_Config( void )
   
10. {
    2 Z5 ]; C1 E  ^0 V. |7 B1 r# J  G
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    2 G/ D% }7 |$ S, \3 l! f
12. 
    
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
      Z. d; L% c- F8 D; b5 w; I8 h( h! x
15. 
    9 |) H/ \+ D4 t$ V0 J5 G
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ' ]# M0 P* ~  ^2 u" f
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    3 A$ m8 ], D5 x0 @! M
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    3 O; g7 ~6 B5 z' T  S
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    * e7 ^% C* @- _, z! j7 N% g4 ]
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    9 t) f4 C, J9 n" o
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    $ S8 O/ ]- n+ g  m* Z' y8 O
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    # L  x  n! N! X
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    4 x8 }  k* {/ q* z( r$ t2 \/ f0 i, e
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    ' y: a( C6 B. t/ y
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    " k" {1 g) ?) V4 V$ O) Q
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    # h5 p& k9 o0 Y! {* T8 G* P
28. 
    ; T! O: x$ K- X) V
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    " T7 ]4 s, P% R5 [5 p! v4 ^( E) u& h
30.         
    
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    5 L4 B0 g) C7 ~5 g
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    $ f$ Z' P  B. u5 C, B9 j
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    7 t4 N4 ^6 D# D% b( k( d8 A
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    ; _) ^. M5 s( ~4 u2 M' _
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    : K* b) m: r0 @5 n
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    9 e" D6 ^& A- a+ X+ q8 E
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    3 r" v1 ]0 a, ~/ x) e9 @3 G: z! ~
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    ! s- c8 f: C9 M2 K) B* r
44.         
    : s2 P6 Z. X$ l( R# z; ?$ p
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ( e$ f5 X2 O6 X3 j
46. 
    
47.         /*使能 MPU */
    
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    ' q- R, ^+ Q6 F3 N8 A# y5 k
50. 
    8 A+ [4 D/ G" `( w7 ?
51. /*
    
52. *********************************************************************************************************
    , h& w) D: {5 T) m% t* V
53. *        函 数 名: CPU_CACHE_Enable
    
54. *        功能说明: 使能L1 Cache
    
55. *        形    参: 无
    4 [7 T4 l* C: f* T
56. *        返 回 值: 无
    
57. *********************************************************************************************************
    5 i/ J+ j- k+ m' n
58. */
    
59. static void CPU_CACHE_Enable(void)
    
60. {
    
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    
63. 
    9 }6 n0 {1 F# u  E* i) v
64.         /* 使能 D-Cache */
    , h6 b! b7 e1 a2 \2 x$ P
65.         SCB_EnableDCache();
    
66. }

复制代码

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

8 g4 E& ~2 M0 U6 A按键检测是在滴答定时器中断里面实现，每10ms执行一次检测。
/ J$ q9 I0 ^1 z
( g6 e. @7 f1 Y$ L

1. /*
   2 V  ], I) n# Z3 w
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_RunPer10ms
   
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   . j7 N( l* _4 M% ]- c
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *        形    参: 无
   $ k8 E. Y+ k  [; a1 R) p
7. *        返 回 值: 无
   $ H' D& `+ V. q! {: x3 h3 W
8. *********************************************************************************************************
   
9. */
   $ e; n# T4 X* e; s9 y2 j" U! i
10. void bsp_RunPer10ms(void)
    * r4 `& T7 ~7 F% Y: A& k; W
11. {
    . C8 _9 l5 L3 G1 T; ^
12.         bsp_KeyScan10ms();
    1 U: s: G& N4 w7 W6 ^3 Y
13. }

复制代码

0 W5 q  B& K0 A4 e3 r6 ?) H  主功能：

主功能的实现主要分为两部分：
) @) q/ O. B! |" _" i
启动一个自动重装软件定时器，每100ms翻转一次LED2
按键消息的读取，检测到按下后，做串口打印。
' w3 K* w; Z: C1 O

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   6 ~/ R( a* }% ^$ i' i# [
7. *********************************************************************************************************
   
8. */
   
9. int main(void)
   
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    $ v6 d  M3 x' ^/ k- y) M7 f0 l
12.         
    + ~0 @. W  o) L% ^' J
13.         bsp_Init();                /* 硬件初始化 */
    
14.         
    
15.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
16.         PrintfHelp();        /* 打印操作提示 */
    2 M! u; q, y( {! J3 B1 j( B
17. 
    , g1 R' F: o" G( G$ ]2 b% e: r
18. 
    * N& t9 D: l- H9 \. C
19.         bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 */
    
20.         
    
21.         /* 进入主程序循环体 */
    
22.         while (1)
    1 I, l! ^% N9 d$ z6 Z
23.         {
    
24.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
25. 
    2 ]' x! d- x$ x) Y+ t
26.                 /* 判断定时器超时时间 */
    
27.                 if (bsp_CheckTimer(0))        
    
28.                 {
    
29.                         /* 每隔100ms 进来一次 */  
    / I9 A% Y$ ~9 _4 U2 z  ~
30.                         bsp_LedToggle(2);                        
    
31.                 }
    
32.                
    
33.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    1 T4 O' @, V# ]8 N/ y  r% m4 Y
34.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
35.                 if (ucKeyCode != KEY_NONE)
    
36.                 {
    ; C8 L$ j" n, W  I
37.                         switch (ucKeyCode)
    
38.                         {
    : U0 E2 Z5 `0 i: B& L
39.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    " X# _' L+ g. B
40.                                         printf("K1键按下\r\n");
    
41.                                         break;
    
42. 
    
43.                                 case KEY_UP_K1:                                /* K1键弹起 */
    # }4 f: M6 O9 Z
44.                                         printf("K1键弹起\r\n");
    ' U* H4 |7 E3 d" R1 M
45.                                         break;
    ; v6 S1 v7 f1 x
46. 
    
47.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    & ?2 t! E1 v/ H$ c: ]7 R# J
48.                                         printf("K2键按下\r\n");
    + ?# I8 o1 t3 q. X1 z4 Y. V: _2 v
49.                                         break;
    4 b! k9 f* v9 \
50. 
    
51.                                 case KEY_UP_K2:                                /* K2键弹起 */
    + Y3 p8 Q% \  k( L3 _
52.                                         printf("K2键弹起\r\n");
    
53.                                         break;
    
54. 
    
55.                                 case KEY_DOWN_K3:                        /* K3键按下 */
    
56.                                         printf("K3键按下\r\n");
    * z' K) Y* m5 a4 j. v0 |
57.                                         break;
    
58. 
    
59.                                 case KEY_UP_K3:                                /* K3键弹起 */
      U( P5 d3 ^2 \  N2 u; t4 ^/ x
60.                                         printf("K3键弹起\r\n");
    
61.                                         break;
    
62. 
    
63.                                 case JOY_DOWN_U:                        /* 摇杆UP键按下 */
    
64.                                         printf("摇杆上键按下\r\n");
    + p& K- @" |  F
65.                                         break;
    3 R9 J4 }- E6 q
66. 
    
67.                                 case JOY_DOWN_D:                        /* 摇杆DOWN键按下 */
    
68.                                         printf("摇杆下键按下\r\n");
    
69.                                         break;
    ; x0 \/ P  Z" a- i
70. 
    $ I8 q8 l$ W( q/ Z  _8 j1 W
71.                                 case JOY_DOWN_L:                        /* 摇杆LEFT键按下 */
    ; p% o; ^% K; q% i( x9 U' |
72.                                         printf("摇杆左键按下\r\n");
    
73.                                         break;
    ' V% w3 E( v- ^8 g8 ~4 G
74.                                 
    . b; ]5 ]( D5 |) i1 w- r
75.                                 case JOY_LONG_L:            /* 摇杆LEFT键长按 */
    
76.                                         printf("摇杆左键长按\r\n");
    * ^/ D3 [8 f2 O" x1 \( o
77.                                         break;
      y* A4 a/ k# r, \/ J4 _
78. 
      j. P' l; k& p1 m& C
79.                                 case JOY_DOWN_R:                        /* 摇杆RIGHT键按下 */
    5 _' b) g) X" t- j& t7 k
80.                                         printf("摇杆右键按下\r\n");
    5 L" O5 O6 i+ ?9 s7 X
81.                                         break;
    
82.                                 
    7 M6 Z9 ]; H: C: N8 L: U
83.                                 case JOY_LONG_R:            /* 摇杆RIGHT键长按 */
    8 J; Z' y& O, V1 r2 ?
84.                                         printf("摇杆右键长按\r\n");
    8 w* v8 x) S" s% V8 \7 o# v
85.                                         break;
    ! d5 ^* Z- E9 l7 T9 f6 @
86. 
    
87.                                 case JOY_DOWN_OK:                        /* 摇杆OK键按下 */
    
88.                                         printf("摇杆OK键按下\r\n");
    1 ]. ~$ R; m1 c2 s" F
89.                                         break;
    ( R& ]( F- M9 k% g4 h' R" m0 P
90. 
    
91.                                 case JOY_UP_OK:                        /* 摇杆OK键弹起 */
    5 u1 l  l$ A3 d- r3 r( X% r  J
92.                                         printf("摇杆OK键弹起\r\n");
    + ]9 G2 B' _- l& C" s
93.                                         break;
    
94. 
    ' h4 `5 b. p$ U: r4 A6 g0 o
95.                 case SYS_DOWN_K1K2:                        /* 摇杆OK键弹起 */
    & g) s" A) d  N! \/ N
96.                                         printf("K1和K2组合键按下\r\n");
    ! X( r& X! M9 R  Y8 A
97.                                         break;
    ; _* }  O0 m& q9 J
98. 
    ' m7 y  W" Q/ X
99.                                 default:
    
100.                                         /* 其它的键值不处理 */
     
101.                                         break;
     - o1 ^, R6 H5 T! O# |7 u
102.                         }
     
103.                
     ( R) O# A; q  C3 l9 ^
104.                 }
     
105.         }
     9 l: Z! W) e/ L; A& J8 H- a; b, o
106. }

复制代码

19.8 实验例程说明（IAR）
配套例子：
, Z* x5 x8 C: p4 y( D) t  q# @1 WV7-002_按键检测（软件滤波，FIFO机制）
9 q0 A/ w6 h  r$ x& S' X( I, G
实验目的：
/ a6 C+ V; h7 E; }学习按键的按下，弹起，长按和组合键的实现。

9 {, Y- V, h3 s3 @. W+ x9 h) l2 D实验内容：
启动一个自动重装软件定时器，每100ms翻转一次LED2。

5 P5 k2 Y4 [/ x) K6 x实验操作：
4 Q3 H* O; N. {, `3个独立按键和5向摇杆按下时均有串口消息打印。
2 ]0 ^6 F3 L4 W+ H# G0 F5向摇杆的左键和右键长按时，会有连发的串口消息。
独立按键K1和K2按键按下，串口打印消息。

上电后串口打印的信息：

" n& z5 e: A* y9 k! v& q波特率 115200，数据位 8，奇偶校验位无，停止位 1
' W/ m2 O( X* }' P9 K2 Z# Y3 \  f

: J; Z7 a% @9 ?0 z* N2 c! E" K1 x: ?程序设计：
" T3 t7 v% `: o- c$ k; ^& G2 U
0 @7 J# g8 s4 D! f4 k  系统栈大小分配：

0 K0 C4 I/ v/ F' w8 B* L- H
  RAM空间用的DTCM：

8 X$ I; m  W) Q8 n+ H

  硬件外设初始化
- G3 p( _: L& X9 n) S. m: O
硬件外设的初始化是在 bsp.c 文件实现：
  u  l) @2 H. e- v3 h6 L
# X' f; p" N6 j$ `4 l6 }2 J8 ]

1. /*
   
2. *********************************************************************************************************
   6 {+ _$ i' V! R' n" e
3. *        函 数 名: bsp_Init
   # y  r  y+ x! l' P
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   % K# p- L  L% S6 f0 G: ~/ p
5. *        形    参：无
   
6. *        返 回 值: 无
   ( w; N. E" k" L1 l# O/ c0 b
7. *********************************************************************************************************
   , @6 h" q$ b* k! k- b7 q$ E
8. */
   7 d0 x/ K4 Z1 `; W
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    
12.         MPU_Config();
    ; X$ r; o; h- F0 f* Q6 M, @
13.         
    , I3 O7 l3 {2 P! z3 t$ x2 r
14.         /* 使能L1 Cache */
    6 u0 u3 @" I) L. ^' J
15.         CPU_CACHE_Enable();
    
16. 
      N% j; o2 R0 v# V
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    2 c* \' v/ K5 x7 ?' b) i  H
20.            - 设置NVIV优先级分组为4。
    
21.          */
    5 R% e  O, k; g9 y+ b8 @
22.         HAL_Init();
    
23. 
    9 A5 |1 B4 j1 T% p7 |7 ~
24.         /*
    
25.        配置系统时钟到400MHz
    , n4 w6 @% |$ ~% B6 D5 D  U4 R
26.        - 切换使用HSE。
    . O0 H! v) E! j
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    + Y2 ]5 p6 R0 I8 K% N
29.         SystemClock_Config();
    
30. 
    ; g: ]$ w- J# U- {. l" q/ g
31.         /*
    
32.            Event Recorder：
    + D4 n, B4 B. @- P6 r- U( s# u" N% w
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    : Z6 c% B$ Z9 c1 ?8 ]! m2 L& i' l% `
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    
36. #if Enable_EventRecorder == 1  
    ' n% p0 a- m, _" i+ K1 h
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    8 S0 |/ X; g; [+ X: W1 |& a* {
39.         EventRecorderStart();
      y+ b3 E. [3 f8 X* _" q
40. #endif
    
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    4 N2 n) e5 m# y  f5 k
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    ( \, V% k% v, X, O5 X; N( O8 G
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    9 u* m/ ~/ P; ~; Q) y
46.         bsp_InitLed();            /* 初始化LED */        
    " P& V/ q2 H2 R8 J4 ^* Z- b
47. }

复制代码

+ k, ?* j4 W9 D4 [6 m  MPU配置和Cache配置：

9 w% l# N+ R0 O9 J3 z# e* }" O* j; w数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
8 i7 G9 ~, j7 v  V/ |9 q4 K& I6 p$ r

1. /*
     k1 v; _. p- w  `
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   , F4 \/ A: N7 [+ Y) ~
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   . l) z/ W" }5 E* k4 Y6 I
9. static void MPU_Config( void )
   ' [- K* Y0 j# f
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.         /* 禁止 MPU */
    ) q% |) G# Q4 E* _
14.         HAL_MPU_Disable();
    
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    ; w! V% m( S) ]$ _9 B( v- s
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
      O0 n! b2 |* x, k' r
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    ) A# w- o1 I+ W; I
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    6 D' P) @( \1 {" r" O
28. 
    , W0 V! p2 [% l( Q* w
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    , ]( b  x2 ^- i" k0 O: M$ B
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    1 H7 B4 L7 }/ T$ ~1 w( Q
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
      h% _' J! e; l# w
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    5 A, v; H! K9 L4 P+ ^& \- D
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
      t' R+ f. u, L7 g+ Q  w% Z
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    " d) |/ G# r/ \6 e9 w. F
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    # \  }4 f7 C8 D7 c. \% U5 }) o
46. 
    
47.         /*使能 MPU */
    # Q+ ~: C! ^- A( T' \; O
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    * k( w# W. h! _1 A; p( ]: h
49. }
    " X' J5 j+ {3 r7 J2 ^( j
50. 
    5 v% r& _0 `. z9 \; W5 `& q3 k0 Y
51. /*
    
52. *********************************************************************************************************
    + y  L& y: P+ }& A* S* w, {
53. *        函 数 名: CPU_CACHE_Enable
    
54. *        功能说明: 使能L1 Cache
    ) [" I2 C1 A5 V; a9 Y7 J. @2 X
55. *        形    参: 无
    
56. *        返 回 值: 无
    
57. *********************************************************************************************************
    
58. */
    
59. static void CPU_CACHE_Enable(void)
    1 Y( Q8 a3 z" h. X+ p
60. {
    
61.         /* 使能 I-Cache */
    - \$ h& M2 ]4 K) }
62.         SCB_EnableICache();
    
63. 
    % S( f, S' e3 C
64.         /* 使能 D-Cache */
    
65.         SCB_EnableDCache();
    
66. }

复制代码

  每10ms调用一次按键检测：
0 s7 T9 D2 _& p0 C7 v: H* ~  n
$ n& y* j8 K, |* }8 [: T& Y按键检测是在滴答定时器中断里面实现，每10ms执行一次检测。

* i9 [. S4 e" G+ l$ `  I  K5 a

1. /*
   
2. *********************************************************************************************************
   ) B/ y1 Q  R! t/ @
3. *        函 数 名: bsp_RunPer10ms
   2 {" u* z/ [' H
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   * M/ x7 g% k8 e/ |' ^
6. *        形    参: 无
   0 f9 o7 D+ [2 d( E! _
7. *        返 回 值: 无
   9 q* G: d$ S6 k% ~$ V5 g5 N3 C
8. *********************************************************************************************************
   - }7 O4 H4 e6 p2 n- W$ F2 c
9. */
   ! _6 v6 N4 M. I, l
10. void bsp_RunPer10ms(void)
    
11. {
    
12.         bsp_KeyScan10ms();
    5 E6 z- l4 J- g0 _2 c0 H7 {: R
13. }

复制代码

主功能：

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

  ]2 s/ p: E1 ~$ H' O. B 启动一个自动重装软件定时器，每100ms翻转一次LED2
按键消息的读取，检测到按下后，做串口打印。

1. /*
   
2. *********************************************************************************************************
   # D& T7 l" h3 g8 T2 k5 b  V! e
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   # h7 K& l: q7 ^) K
6. *        返 回 值: 错误代码(无需处理)
   ' U' k' O2 ]  Y- q4 K: }4 T- j
7. *********************************************************************************************************
   * p* D; }) C% Y2 n9 }) X
8. */
   , {7 a1 q1 o; O" A# S- P
9. int main(void)
   
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    : u3 S+ W1 A! G
12.         
    3 d. [* Q& B) j' X8 K4 g/ T$ y
13.         bsp_Init();                /* 硬件初始化 */
    
14.         
      G9 l4 H# o: |- y
15.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    ( P) E$ i* d  x4 Q
16.         PrintfHelp();        /* 打印操作提示 */
    
17. 
    % N% A. p# v+ v9 \- Q- [7 j/ T
18. 
    
19.         bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 */
    . ~+ u/ d# P) A" s+ m- n
20.         
    
21.         /* 进入主程序循环体 */
    
22.         while (1)
    + Z" T( J" k. g* K1 k
23.         {
    $ \% C6 v% q! r8 n: m0 G5 C# ~
24.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
25. 
    8 S9 v3 h- `; V- L
26.                 /* 判断定时器超时时间 */
    
27.                 if (bsp_CheckTimer(0))        
    
28.                 {
    7 G6 M: }  {5 U# ]. c
29.                         /* 每隔100ms 进来一次 */  
    
30.                         bsp_LedToggle(2);                        
    , a* v! o% `1 @# v# H
31.                 }
    
32.                
    " N) u: ~# P0 s: i! h
33.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    ! a6 m" g! x/ x# L0 s
34.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
35.                 if (ucKeyCode != KEY_NONE)
    6 f) O, ~# v9 v3 [, E1 q" ?
36.                 {
    * C" k# r3 }& b. n. l! Q+ V- U7 w
37.                         switch (ucKeyCode)
    
38.                         {
      S: ~; G/ G+ O1 u7 I! f) D
39.                                 case KEY_DOWN_K1:                        /* K1键按下 */
      _* U7 U! S5 s8 A' z" h& s; {8 l
40.                                         printf("K1键按下\r\n");
    3 Z. h+ f: e& U$ p' z; p2 }
41.                                         break;
    5 `& u& c$ U$ x  c5 {- o. ^3 I" B
42. 
    5 m8 s' H; D: @/ U/ \2 S" l1 Z; F
43.                                 case KEY_UP_K1:                                /* K1键弹起 */
    : x5 o$ ]' j( s( T. C9 r) d
44.                                         printf("K1键弹起\r\n");
      q; O) z$ I2 ~; A- {# ~
45.                                         break;
    & @  {9 m  m7 E+ f1 ^2 g
46. 
    
47.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    . p0 `: O7 @+ I, K) O0 W
48.                                         printf("K2键按下\r\n");
    3 q( V4 y" Q- k6 I; q; g( l
49.                                         break;
    
50. 
    . B4 b. D( I! g+ d5 Z5 g
51.                                 case KEY_UP_K2:                                /* K2键弹起 */
    
52.                                         printf("K2键弹起\r\n");
    
53.                                         break;
    
54. 
    7 X. x8 O4 z8 W9 Z! V4 w
55.                                 case KEY_DOWN_K3:                        /* K3键按下 */
    
56.                                         printf("K3键按下\r\n");
    
57.                                         break;
    
58. 
    7 d* q" f9 P3 k( D* A
59.                                 case KEY_UP_K3:                                /* K3键弹起 */
    
60.                                         printf("K3键弹起\r\n");
    
61.                                         break;
    
62. 
    * v& @$ H4 n5 ~0 k7 u: ]
63.                                 case JOY_DOWN_U:                        /* 摇杆UP键按下 */
    ) U% C) p# ]0 T* s) \8 K7 p
64.                                         printf("摇杆上键按下\r\n");
    
65.                                         break;
    8 |, M: P' ?9 v3 u
66. 
    4 w% f* p$ b; r$ U7 s
67.                                 case JOY_DOWN_D:                        /* 摇杆DOWN键按下 */
    
68.                                         printf("摇杆下键按下\r\n");
    + q  L  g, Z6 L4 M- T" e
69.                                         break;
    
70. 
    & g2 j! v& a+ {' T1 g
71.                                 case JOY_DOWN_L:                        /* 摇杆LEFT键按下 */
    
72.                                         printf("摇杆左键按下\r\n");
    
73.                                         break;
    8 ]' i3 M4 i) y
74.                                 
    / i1 v8 s2 n4 |: I
75.                                 case JOY_LONG_L:            /* 摇杆LEFT键长按 */
    
76.                                         printf("摇杆左键长按\r\n");
    
77.                                         break;
    
78. 
    0 W" x, z& a1 g( t& B* t- q
79.                                 case JOY_DOWN_R:                        /* 摇杆RIGHT键按下 */
    ( w* w( S# M& M( C# o
80.                                         printf("摇杆右键按下\r\n");
    
81.                                         break;
    0 ~4 G$ Q1 L  |1 K! P9 t8 h5 J
82.                                 
    ( r% D0 s! {4 ~; O
83.                                 case JOY_LONG_R:            /* 摇杆RIGHT键长按 */
    # r  r1 |  ]9 w. [1 c% Q
84.                                         printf("摇杆右键长按\r\n");
    & Q, x9 Z5 g+ l
85.                                         break;
    
86. 
    % Z1 k$ K9 v* f. g& X5 Y
87.                                 case JOY_DOWN_OK:                        /* 摇杆OK键按下 */
    7 x" ?$ Y( E  Y) T
88.                                         printf("摇杆OK键按下\r\n");
    
89.                                         break;
    
90. 
    
91.                                 case JOY_UP_OK:                        /* 摇杆OK键弹起 */
    
92.                                         printf("摇杆OK键弹起\r\n");
    
93.                                         break;
    
94. 
    0 V2 u% o5 L9 x+ i: V* c
95.                 case SYS_DOWN_K1K2:                        /* 摇杆OK键弹起 */
    % F' v: r( \4 |& X1 n  i' ~& [! L/ K5 J
96.                                         printf("K1和K2组合键按下\r\n");
    
97.                                         break;
    ' w1 G, R. Q; `& p% k
98. 
    
99.                                 default:
    
100.                                         /* 其它的键值不处理 */
     4 e; B2 _, o" M0 N+ W; Q3 ?, E
101.                                         break;
     6 C9 G) r4 I& I5 E* I
102.                         }
     # h3 e% }, k) @+ c; d2 s
103.                
     
104.                 }
     
105.         }
     & }1 L! ~- L/ ]. ?# W. G; D
106. }

复制代码

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

+ u- S& C- |, U, e' _
- U! G' D" l( O6 H- w+ f: |0 v
; Y/ Z* J2 Y  ]! t: u