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

9 }5 `$ |5 _* A  b19.2 按键硬件设计
. F, [# C4 G# m/ ?V7开发板有三个独立按键和一个五向摇杆，下面是三个独立按键的原理图：
( E3 c9 N- O: ~( ~5 o6 C

7 Z( W% e# u0 g0 T4 q
! ]. }: Y9 p! F: Z# M注意，K1（S1）、K2(S2)和K3(S3)按键的上拉电阻是接在5V电压上，因为这三个按键被复用为PS/2键盘鼠标接口，而PS/2是需要5V供电的（注，V5和V6开发板做了PS/2复用，而V7没有使用，这里只是为了兼容之前的板子）。实际测试，K1、K2、K3按键和PS/2键盘是可以同时工作的。

下面是五向摇杆的原理图：
. c# E) p( Z9 X: M! K

' I/ b+ H/ r9 i( g/ {
1 u1 f) K8 T' V8 }5 T- q8 M, @! e通过这个硬件设计，有如下两个知识点为大家做介绍：

19.2.1 硬件设计
; W5 |! n( V1 {, }' ~; U. M0 k按键和CPU之间串联的电阻起保护作用。按键肯定是存在机械抖动的，开发板上面的硬件没有做硬件滤波处理，即使设计了硬件滤波电路，软件上还是需要进行滤波。

  保护GPIO，避免软件错误将IO设置为输出，如果设置为低电平还好，如果设置输出的是高电平，按键按下会直接跟GND(低电平)连接，从而损坏MCU。
, I- A* c7 H( @# {) N6 S2 G7 F  保护电阻也起到按键隔离作用，这些GPIO可以直接用于其它实验。
+ Z$ b0 Z. k, @3 M$ g19.2.2 GPIO内部结构分析按键
( f; \8 l' B. q; Q$ N" F2 R& F详细的GPIO模式介绍，请参考第15章的15.3小节，本章仅介绍输入模式。下面我们通过一张图来简单介绍GPIO的结构。

& y$ O2 d! x/ S# _4 ?! m$ }

9 |/ u& i% d/ K
红色的线条是GPIO输入通道的信号流向，作为按键检测IO，这些需要配置为浮空输入。按键已经做了5V上拉，因此GPIO内部的上下拉电阻都选择关闭状态。
3 k0 K; j9 J3 }  [- r
! M/ J. T- C( i& p7 O19.3 按键FIFO的驱动设计
  W+ c  O. i& n1 s3 G8 W0 tbsp_key按键驱动程序用于扫描独立按键，具有软件滤波机制，采用FIFO机制保存键值。可以检测如下事件：
+ B% Z& y# t/ U
) v1 A8 u, W6 H' {9 U9 k4 j  按键按下。
  按键弹起。
5 j5 s( A( `3 c6 i  长按键。
4 B: V, _3 m& \  长按时自动连发。
. s( ?; y9 M/ i9 r; r7 h$ s2 m我们将按键驱动分为两个部分来介绍，一部分是FIFO的实现，一部分是按键检测的实现。

- V: Y7 f. F$ F# N. n: T- G) y

! f& R4 ]! |- N" j3 t
" |, l1 |6 ?0 gbsp_key.c 文件包含按键检测和按键FIFO的实现代码。
2 h' ?% ?) w( Z: m$ `0 L. i" n/ O
" m0 W4 }0 }% f% Ybsp.c 文件会调用bsp_InitKey()初始化函数。
- E1 n: S6 X3 y7 ?6 m0 P/ @
0 ^9 q& r4 x7 ^& B8 S) V! ~bsp.c 文件会调用bsp_KeyScan按键扫描函数。
5 g* }; B" M% o, I! F% D
bsp_timer.c 中的Systick中断服务程序调用 bsp_RunPer10ms。
, m1 ~* \6 V$ d* r8 X/ ?% e
! s8 g1 q5 i4 g, G中断程序和主程序通过FIFO接口函数进行信息传递。

; l. s3 y; u( `1 V0 i; t函数调用关系图：
6 c5 j! Y( W9 x  K6 w0 b5 C8 a
# V/ k- S; N& P8 B) j

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

5 `1 A& H2 D9 q5 T: k3 J: J
我们依次按下按键K1，K2，那么FIFO中的数据变为：

3 |1 s5 `. k/ R
$ n2 r3 W+ _# z/ E$ _2 c如果Write！= Read，则我们认为有新的按键事件。
& c3 N+ b% r# [8 ?7 [5 f
$ M* I! @9 u9 F2 [3 |$ y5 w我们通过函数bsp_GetKey读取一个按键值进行处理后，Read变量变为1。Write变量不变。

7 r! k  \) h9 d/ O, h
6 i/ ~- J4 m6 m' \我们继续通过函数bsp_GetKey读取3个按键值进行处理后，Read变量变为4。此时Read = Write = 4。两个变量已经相等，表示已经没有新的按键事件需要处理。
) y0 t' Q. [" Q. ?' J# J
% X; @0 n: _( J" j: X1 h有一点要特别的注意，如果FIFO空间写满了，Write会被重新赋值为0，也就是重新从第一个字节空间填数据进去，如果这个地址空间的数据还没有被及时读取出来，那么会被后来的数据覆盖掉，这点要引起大家的注意。我们的驱动程序开辟了10个字节的FIFO缓冲区，对于一般的应用足够了。
& v- y3 ?4 l) g
3 J9 p  ?+ e5 z* [设计按键FIFO主要有三个方面的好处：

/ I+ ?; y: p1 T) [1 a  可靠地记录每一个按键事件，避免遗漏按键事件。特别是需要实现按键的按下、长按、自动连发、弹起等事件时。
  读取按键的函数可以设计为非阻塞的，不需要等待按键抖动滤波处理完毕。
5 M+ l0 R* n# H  按键FIFO程序在嘀嗒定时器中定期的执行检测，不需要在主程序中一直做检测，这样可以有效地降低系统资源消耗。
% C, Q- }6 t& O7 x0 n
19.3.2 按键FIFO的实现
在bsp_key.h 中定了结构体类型KEY_FIFO_T。这只是类型声明，并没有分配变量空间。
' b) l' e2 I1 ^8 j

1. #define KEY_FIFO_SIZE        10
   
2. typedef struct
   
3. {
   
4.         uint8_t Buf[KEY_FIFO_SIZE];                /* 键值缓冲区 */
   9 Y3 h! a- [# W5 O
5.         uint8_t Read;                                        /* 缓冲区读指针1 */
   
6.         uint8_t Write;                             /* 缓冲区写指针 */
   8 P, ?. z( ?- J7 b4 `/ w/ _
7.         uint8_t Read2;                             /* 缓冲区读指针2 */
   7 S* {' A3 s8 o! M. p$ e
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个读指针。
! r0 \) y0 w7 v6 p
! p* R1 t8 M  ^& Q/ ]当检测到按键事件发生后，可以调用 bsp_PutKey函数将键值压入FIFO。下面的代码是函数的实现：
3 N( z' [4 ^3 b

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_PutKey
   
4. *        功能说明: 将1个键值压入按键FIFO缓冲区。可用于模拟一个按键。
   
5. *        形    参: _KeyCode : 按键代码
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   % b0 |# I7 i1 ]0 I$ _/ C
8. */
   ! A, d5 S& b2 `6 C8 ?3 v' K% U% r
9. void bsp_PutKey(uint8_t _KeyCode)
   
10. {
    ' x  G& Y6 p- `% \3 a
11.         s_tKey.Buf[s_tKey.Write] = _KeyCode;
    
12. 
    7 u: Z3 }+ Z& D- i
13.         if (++s_tKey.Write  >= KEY_FIFO_SIZE)
    
14.         {
    
15.                 s_tKey.Write = 0;
    
16.         }
      S) n( u- g$ y/ \1 k! X
17. }

复制代码

: g$ v, b4 g3 _2 p- g" ^5 f% i这个bsp_PutKey函数除了被按键检测函数调用外，还可以被其他底层驱动调用。比如红外遥控器的按键检测，也共用了同一个按键FIFO。遥控器的按键代码和主板实体按键的键值统一编码，保持键值唯一即可实现两套按键同时控制程序的功能。
( u. M  M5 E( g; U. K4 J
应用程序读取FIFO中的键值，是通过bsp_GetKey函数和bsp_GetKey2函数实现的。我们来看下这两个函数的实现：
$ t% q3 f$ N; b2 `* W9 a% x- w. _

1. /*
   8 M- F' L# i2 j9 ^5 ~
2. *********************************************************************************************************
   ' O* m# ?* M% Z( O' \+ b
3. *        函 数 名: bsp_GetKey
   
4. *        功能说明: 从按键FIFO缓冲区读取一个键值。
   ) \8 R5 `* N5 O; ?) [; A
5. *        形    参:  无
   % z; k2 \# Q* U% H6 B$ Y* _0 c
6. *        返 回 值: 按键代码
   
7. *********************************************************************************************************
   . `; h5 L+ e$ q# h, j+ m  `. S8 X1 Z
8. */
   
9. uint8_t bsp_GetKey(void)
   ( D0 S8 M3 {- h% U. ?0 \/ K
10. {
    & |& E' z" X# l; @1 n
11.         uint8_t ret;
    
12. 
    
13.         if (s_tKey.Read == s_tKey.Write)
    
14.         {
    
15.                 return KEY_NONE;
    
16.         }
    % s" i% r: f1 v2 ?9 n2 d! i
17.         else
    . c5 w! ?( ?; B0 |/ R$ |; Q4 @0 c- q
18.         {
    
19.                 ret = s_tKey.Buf[s_tKey.Read];
    0 i: m- s2 i9 G! ?& D/ K
20. 
    / _% f4 @$ W$ ^5 k0 Z1 I3 B
21.                 if (++s_tKey.Read >= KEY_FIFO_SIZE)
    ' S  ~( D1 v9 p9 b0 Y, m
22.                 {
    
23.                         s_tKey.Read = 0;
    
24.                 }
    
25.                 return ret;
    
26.         }
    + I. ^8 h4 C  b! \$ m6 Z
27. }
    
28. 
    
29. /*
    
30. *********************************************************************************************************
    
31. *        函 数 名: bsp_GetKey2
    
32. *        功能说明: 从按键FIFO缓冲区读取一个键值。独立的读指针。
    
33. *        形    参:  无
    
34. *        返 回 值: 按键代码
    
35. *********************************************************************************************************
    * g* V' ~6 [3 U3 ?2 ]0 p
36. */
    6 x/ s0 f0 Q; C4 `$ `, U  [* q
37. uint8_t bsp_GetKey2(void)
    
38. {
    
39.         uint8_t ret;
    # z9 _- i; Z$ x7 K
40. 
    
41.         if (s_tKey.Read2 == s_tKey.Write)
    
42.         {
    6 n; n/ A# J6 o: k* C( o
43.                 return KEY_NONE;
    7 F# ~) M7 x/ |4 Z. X" t
44.         }
    & y* V/ G* \/ Z7 `+ O, i8 U$ {. R
45.         else
    
46.         {
    
47.                 ret = s_tKey.Buf[s_tKey.Read2];
    
48. 
    " ]$ r8 q" l( s2 P8 t4 i
49.                 if (++s_tKey.Read2 >= KEY_FIFO_SIZE)
    - m$ i( d1 _! h' k2 @( K
50.                 {
    ' c" m. Q  _- E2 x9 \6 @% g
51.                         s_tKey.Read2 = 0;
    
52.                 }
    9 g. z$ |  K2 H: Q- n/ z2 e
53.                 return ret;
    
54.         }
    . g2 S5 r$ e( l& M: {
55. }

复制代码

8 E2 O& q, m, i4 T, \; J, [返回值KEY_NONE = 0, 表示按键缓冲区为空，所有的按键时间已经处理完毕。按键的键值定义在 bsp_key.h文件，下面是具体内容：
  r5 O0 r  ~# r  G0 A% U! P
" H  @3 q& T+ u- j3 X' ?

1. typedef enum
   
2. {
     @  y  O0 ^# e% b
3.         KEY_NONE = 0,                        /* 0 表示按键事件 */
   
4. 
   , ^# P2 S& K# `* q2 y9 N
5.         KEY_1_DOWN,                        /* 1键按下 */
   5 Z# u; }* u0 q" ]! ~4 h( _$ \7 u
6.         KEY_1_UP,                                /* 1键弹起 */
   
7.         KEY_1_LONG,                        /* 1键长按 */
   4 Y/ f) T6 {+ |+ C/ A* M7 B
8. 
   7 @* O9 i  D2 Z$ z' [3 N& c) R
9.         KEY_2_DOWN,                        /* 2键按下 */
   
10.         KEY_2_UP,                                /* 2键弹起 */
    
11.         KEY_2_LONG,                        /* 2键长按 */
    
12. 
    ) o3 e5 ~3 A5 A/ `& J$ l- L/ |
13.         KEY_3_DOWN,                        /* 3键按下 */
    ) b3 O( j. _! f# F1 d. }
14.         KEY_3_UP,                                /* 3键弹起 */
    
15.         KEY_3_LONG,                        /* 3键长按 */
    
16. 
    8 s. W1 \1 x" u& Z1 w- E
17.         KEY_4_DOWN,                        /* 4键按下 */
    ( y/ s5 \7 b  L2 z+ p
18.         KEY_4_UP,                                /* 4键弹起 */
    
19.         KEY_4_LONG,                        /* 4键长按 */
    
20. 
    
21.         KEY_5_DOWN,                        /* 5键按下 */
    
22.         KEY_5_UP,                                /* 5键弹起 */
    ; H: l# S: ?2 A; x7 p  Z' u
23.         KEY_5_LONG,                        /* 5键长按 */
    
24. 
    ) c- u. I" E# p, l, U4 b* C( r- @
25.         KEY_6_DOWN,                        /* 6键按下 */
    
26.         KEY_6_UP,                                /* 6键弹起 */
    , I  S; H& y% m8 D3 t* j
27.         KEY_6_LONG,                        /* 6键长按 */
    . V4 Y/ n# |0 ^
28. 
    0 b" X0 _; D5 f! r$ Q
29.         KEY_7_DOWN,                        /* 7键按下 */
    
30.         KEY_7_UP,                                /* 7键弹起 */
    ' l- b, Y2 G8 f* N% x' k3 ]" o
31.         KEY_7_LONG,                        /* 7键长按 */
    * |: F) ^2 _7 H* b& _
32. 
    
33.         KEY_8_DOWN,                        /* 8键按下 */
    
34.         KEY_8_UP,                                /* 8键弹起 */
    2 p/ E- O) ^8 a1 P; v4 l9 C
35.         KEY_8_LONG,                        /* 8键长按 */
    & M8 ?% M) f4 U' n; L
36. 
    ! L6 {: a: l& j" y! Y
37.         /* 组合键 */
    
38.         KEY_9_DOWN,                        /* 9键按下 */
    , U- a9 W" Q9 M, A
39.         KEY_9_UP,                                /* 9键弹起 */
    
40.         KEY_9_LONG,                        /* 9键长按 */
    + Q1 z1 F% K' y' r; u, K: D
41. 
    
42.         KEY_10_DOWN,                        /* 10键按下 */
    * a( R7 g4 X  _$ V, r
43.         KEY_10_UP,                        /* 10键弹起 */
    + O0 Z& E0 y6 a
44.         KEY_10_LONG,                        /* 10键长按 */
    ' I6 V1 ]" z8 M4 h, z
45. }KEY_ENUM;

复制代码

' P6 F/ U# |) q2 K5 p, W( p' B, {" i必须按次序定义每个键的按下、弹起和长按事件，即每个按键对象（组合键也算1个）占用3个数值。我们推荐使用枚举enum, 不用#define的原因：

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

% k5 h2 Y: A) m& F, L

1. /* 定义红外遥控器按键代码, 和bsp_key.h 的物理按键代码统一编码 */
   
2. typedef enum
   & \+ H: j$ }* |; k3 a
3. {
   9 h( L) t& q) N7 G
4.         IR_KEY_STRAT         = 0x80,
   7 P/ ~/ m- C. ~& [  i
5.         IR_KEY_POWER         = IR_KEY_STRAT + 0x45,
   0 u/ {0 W3 M$ A7 p
6.         IR_KEY_MENU         = IR_KEY_STRAT + 0x47,
   $ V! U( z3 y7 x
7.         IR_KEY_TEST         = IR_KEY_STRAT + 0x44,
   
8.         IR_KEY_UP         = IR_KEY_STRAT + 0x40,
   
9.         IR_KEY_RETURN        = IR_KEY_STRAT + 0x43,
   1 b0 Z7 _" G) [- s, b. }
10.         IR_KEY_LEFT        = IR_KEY_STRAT + 0x07,
    " ?0 U4 n6 a  [4 C) Y
11.         IR_KEY_OK                = IR_KEY_STRAT + 0x15,
    ) \+ N# v7 o$ S0 q" G& T; t2 E
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,
    6 H/ t( P) i& X( I6 D) O
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,
    . N7 G8 x2 c& w3 G4 F
20.         IR_KEY_5                = IR_KEY_STRAT + 0x1C,
    
21.         IR_KEY_6                = IR_KEY_STRAT + 0x5A,
    , m8 m+ a" y# V$ i" f
22.         IR_KEY_7                = IR_KEY_STRAT + 0x42,
    ) R2 u: }/ N* A" i# v( v
23.         IR_KEY_8                = IR_KEY_STRAT + 0x52,
    
24.         IR_KEY_9                = IR_KEY_STRAT + 0x4A,        
    6 Z* w0 k7 T$ e( S) H- e
25. }IR_KEY_E;

复制代码

. F$ U- L5 Z) r, n! {* \' b我们下面来看一段简单的应用。这个应用的功能是：主板K1键控制LED1指示灯；遥控器的POWER键和MENU键控制LED2指示灯。
7 r0 f! T  _1 |- _: @; Y, C

1. #include "bsp.h"
   
2. 
   1 [; o* _& Q0 `! b" \7 c+ V
3. int main(void)
   8 c) K: Z" ?$ p0 s8 c3 f
4. {
   
5.         uint8_t ucKeyCode;
   
6.                         
   
7.         bsp_Init();
   
8. 
   9 J' X9 r6 A" T$ P0 o: K; `
9.         IRD_StartWork();        /* 启动红外解码 */
   # C: X) _/ B) A7 B! |2 m( R& ]# ^
10. 
    
11.         while(1)
    / k" l5 D  b, B. j7 T# y
12.         {
    / }, U3 T$ h4 }' _/ t+ T: W
13.                 bsp_Idle();
      B; c8 S# u' g* _9 g: {5 A
14.                
    
15.                 /* 处理按键事件 */
    
16.                 ucKeyCode = bsp_GetKey();
    
17.                 if (ucKeyCode > 0)
    
18.                 {
    
19.                         /* 有键按下 */
    ! [: y4 F; Z: Z& |. ~+ ~, V7 L
20.                         switch (ucKeyCode)
    % `* b7 j5 b) Z* n3 D" B4 Y, R% W) ^
21.                         {
    $ n$ F! o1 G2 [5 e: A5 A
22.                                 case KEY_DOWN_K1:                /* K1键按下 */
    ) P0 Q. o$ @: o+ `
23.                                         bsp_LedOn(1);                /* 点亮LED1 */
    
24.                                         break;
    ; p; [4 U: m4 b/ J+ p5 [4 |
25. 
    
26.                                 case KEY_UP_K1:                /* K1键弹起 */
    
27.                                         bsp_LedOff(1);        /* 熄灭LED1 */
    8 c+ ~. m: f7 n4 C6 `
28.                                         break;                                       
    
29. 
    # a# k( `$ X) u8 q/ j, X$ t6 h; n
30.                                 case IR_KEY_POWER:                /* 遥控器POWER键按下 */
    : B% X% A" U) j2 T! I
31.                                         bsp_LedOn(1);                /* 点亮LED2 */
    2 j: Z+ h) {- _/ h6 s( E
32.                                         break;
    & O3 ?3 w! h( m* L* ]
33. 
    
34.                                 case IR_KEY_MENU:                /* 遥控器MENU键按下 */
    9 [6 Q7 a* S" b; u
35.                                         bsp_LedOff(1);        /* 熄灭LED2 */
    ! J$ s6 ~! i# V4 z" t% |' v
36.                                         break;                                       
    
37. 
    3 w, {" o1 [! P$ F" w) K
38.                                 case MSG_485_RX:                /* 通信程序的发来的消息 */
    0 Y' n; u4 N& k! a/ x9 a
39.                                         /* 执行通信程序的指令 */
    
40.                                         break;
    . z6 N: u" O8 @* i
41. 
    3 y3 V5 Q  M0 H
42.                                 default:
    $ H+ n6 D3 x$ T+ i
43.                                         break;
    
44.                         }
    % I5 W5 l6 e! j+ c
45.                 }
    
46.         }
    
47. }

复制代码

看到这里，想必你已经意识到bsp_PutKey函数的强大之处了，可以将不相关的硬件输入设备统一为一个相同的接口函数。
  `2 P) C! ^0 L+ M- q3 F  F+ M
0 J, \) n, k" @在上面的应用程序中，我们特意添加了一段红色的代码来解说更高级的用法。485通信程序收到有效的命令后通过 bsp_PutKey（MSG_485_RX）函数可以通知APP应用程序进行进一步加工处理（比如显示接收成功）。这是一种非常好的任务间信息传递方式，它不会破坏程序结构。不必新增全局变量来做这种事情，你只需要添加一个键值代码。
* [5 F2 S8 a- v( x9 C: |
7 S+ b; I) V$ M2 A) Z0 U* r! N4 j9 b对于简单的程序，可以借用按键FIFO来进行少量的信息传递。对于复杂的应用，我们推荐使用bsp_msg专门来做这种任务间的通信。因为bsp_msg除了传递消息代码外，还可以传递参数结构。
4 t3 l3 J/ B( h
2 [% f  b7 \# L# q1 t! t% |19.3.3 按键检测程序分析
& p9 }  p& ]! c$ b$ ]; m在bsp_key.h 中定了结构体类型KEY_T。

1. #define KEY_COUNT    10                           /* 按键个数, 8个独立建 + 2个组合键 */
   
2. 
   ! E% m0 l/ Y# ]7 K  B  j
3. typedef struct
   
4. {
   
5.         /* 下面是一个函数指针，指向判断按键手否按下的函数 */
   3 S1 Q' n0 \* `; N% U) i
6.         uint8_t (*IsKeyDownFunc)(void); /* 按键按下的判断函数,1表示按下 */
   1 b" E7 k) y' u' l
7. 
   + N4 m5 ]' l" E9 |' _
8.         uint8_t  Count;                /* 滤波器计数器 */
   : V3 Q9 f4 D2 [3 _; p+ K" H
9.         uint16_t LongCount;        /* 长按计数器 */
   , |% {8 Z& x8 {+ i" j$ C2 {/ Y
10.         uint16_t LongTime;                /* 按键按下持续时间, 0表示不检测长按 */
    
11.         uint8_t  State;                /* 按键当前状态（按下还是弹起） */
    : I( ?) b. H- H) v" m5 N& S
12.         uint8_t  RepeatSpeed;        /* 连续按键周期 */
    8 i9 P8 L) u: F0 J
13.         uint8_t  RepeatCount;        /* 连续按键计数器 */
    0 Z  K) x+ i1 Q+ n4 b7 X, G
14. }KEY_T;

复制代码

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

+ y, q- X4 }, u4 Q9 O+ t

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

复制代码

$ y) W  H/ P) r. Y每个按键对象都分配一个结构体变量，这些结构体变量以数组的形式存在将便于我们简化程序代码行数。

3 T1 v! c" d3 r: V+ @# @使用函数指针IsKeyDownFunc可以将每个按键的检测以及组合键的检测代码进行统一管理。

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

. v. n. `4 }' x- ]: x5 }

1. /*
   4 w0 ]+ |7 M2 }6 F* ~3 ?8 J6 S. f
2. *********************************************************************************************************
   ' X- B% `1 H) h# U& X
3. *        函 数 名: bsp_InitKey
   9 t$ H0 B- ~+ ]: k( a: @; k! q
4. *        功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
   ; F" i! E$ w: T! d: X: r/ L
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   / I# S  m* z  h. Y2 `
8. */
   & c0 v0 h; n1 i9 F+ _9 u% i. \5 z; ^  c: W
9. void bsp_InitKey(void)
   
10. {
    ' a! M* M! Y* \5 C3 L
11.         bsp_InitKeyVar();                /* 初始化按键变量 */
    ) `4 z; V! u4 S: s. S
12.         bsp_InitKeyHard();                /* 初始化按键硬件 */
    
13. }

复制代码

; `! Z2 |  @8 ~; q. o- d下面是bsp_InitKeyVar函数的定义：
9 Z& i4 h! ~1 \$ X! ]' G. y

1. /*
   8 X0 h. `) V4 w  t8 }, n
2. *********************************************************************************************************
   6 X) z+ p! [' `9 i/ ]$ g7 L' G
3. *        函 数 名: bsp_InitKeyVar
   6 q" M" a" @" x: i/ M
4. *        功能说明: 初始化按键变量
   0 u; L) ^8 J' V4 G3 u; X' ]
5. *        形    参:  无
   
6. *        返 回 值: 无
   - B, Y, {, ^% n& d
7. *********************************************************************************************************
   
8. */
   
9. static void bsp_InitKeyVar(void)
   
10. {
    
11.         uint8_t i;
    
12. 
    
13.         /* 对按键FIFO读写指针清零 */
    
14.         s_tKey.Read = 0;
    
15.         s_tKey.Write = 0;
    
16.         s_tKey.Read2 = 0;
    % s% K- D6 `' d3 R
17. 
    
18.         /* 给每个按键结构体成员变量赋一组缺省值 */
    
19.         for (i = 0; i < KEY_COUNT; i++)
    
20.         {
    
21.                 s_tBtn<i>.LongTime = KEY_LONG_TIME;                        /* 长按时间 0 表示不检测长按键事件 */</i>
    
22. <span style="font-style: italic;">                s_tBtn.Count = KEY_FILTER_TIME / 2;                /* 计数器设置为滤波时间的一半 */
    - R9 v2 k- Z- f9 D: Q
23.                 s_tBtn<span style="font-style: italic;">.State = 0;                                                /* 按键缺省状态，0为未按下 */
    + M* j; l' W; a/ W) f- b0 _
24.                 s_tBtn<span style="font-style: italic;">.RepeatSpeed = 0;                                        /* 按键连发的速度，0表示不支持连发 */
    2 W! q# u# I& O' u& A# Q, a
25.                 s_tBtn<i style="font-style: italic;">.RepeatCount = 0;                                        /* 连发计数器 */
    / i2 D% x: v1 R
26.      </i><span style="font-style: normal;">   }
    " ^3 o1 A8 F' M& y) ~
27. 
    
28.         /* 如果需要单独更改某个按键的参数，可以在此单独重新赋值 */
    
29.         
    
30.         /* 摇杆上下左右，支持长按1秒后，自动连发 */
    
31.         bsp_SetKeyParam(KID_JOY_U, 100, 6);
    
32.         bsp_SetKeyParam(KID_JOY_D, 100, 6);
    1 m, r# y9 Q" w& _
33.         bsp_SetKeyParam(KID_JOY_L, 100, 6);
    : ^6 W1 B  H& T7 ?" ?9 L
34.         bsp_SetKeyParam(KID_JOY_R, 100, 6);
    
35. }</span></span></span></span>

复制代码

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

1. /*
   9 d* Z: |+ T$ L+ Z. ^
2.         按键滤波时间50ms, 单位10ms。
   
3.         只有连续检测到50ms状态不变才认为有效，包括弹起和按下两种事件
   + {% \8 j! S/ x+ n% X1 A
4.         即使按键电路不做硬件滤波，该滤波机制也可以保证可靠地检测到按键事件
   
5. */
   
6. #define KEY_FILTER_TIME   5
   + u, D/ D3 Y+ |
7. #define KEY_LONG_TIME     100                        /* 单位10ms， 持续1秒，认为长按事件 */

复制代码

uint8_t KeyPinActive(uint8_t _id)（会调用函数KeyPinActive判断状态）函数就是最底层的GPIO输入状态判断函数。
! b5 X9 n( U; Y7 ^6 Y

1. /*
   
2. *********************************************************************************************************
   4 J# B2 y# u  `$ e9 V/ V
3. *        函 数 名: KeyPinActive
   1 d& ~# Q& B" Y5 I# v5 D
4. *        功能说明: 判断按键是否按下
   
5. *        形    参: 无
   
6. *        返 回 值: 返回值1 表示按下(导通），0表示未按下（释放）
   
7. *********************************************************************************************************
   
8. */
   
9. static uint8_t KeyPinActive(uint8_t _id)
   
10. {
    0 |, \/ s2 K- y9 C8 n
11.         uint8_t level;
    
12.         
    , h6 {* w, g8 k# q. l7 ]5 U! v- o
13.         if ((s_gpio_list[_id].gpio->IDR & s_gpio_list[_id].pin) == 0)
    
14.         {
    
15.                 level = 0;
    
16.         }
    
17.         else
    
18.         {
    
19.                 level = 1;
    
20.         }
    4 w* @+ P3 a* }, V1 j) X' x% X
21. 
    + d4 V' y! N. }3 X" C
22.         if (level == s_gpio_list[_id].ActiveLevel)
    7 D* v- G" t9 t* [; _- w
23.         {
    6 M' U& n- s5 }' n' W% E6 ~
24.                 return 1;
    : R7 T' U2 u4 v
25.         }
    3 ^9 K2 j% A+ E0 J3 X; y" Q
26.         else
    
27.         {
    / q$ M2 N4 m/ S4 p2 b# m
28.                 return 0;
    
29.         }
    
30. }
    
31. 
    - \4 k. u$ |  k; n* B1 V+ Y0 K. q
32. /*
    $ J( l# N% T$ S' r; {
33. *********************************************************************************************************
    $ E# v' k' T( E3 ]# {' q
34. *        函 数 名: IsKeyDownFunc
    0 k8 G/ D3 l5 B# v
35. *        功能说明: 判断按键是否按下。单键和组合键区分。单键事件不允许有其他键按下。
      ^* ^+ w) S: q9 B
36. *        形    参: 无
    " h* y) d; `+ R2 U8 e" C4 T
37. *        返 回 值: 返回值1 表示按下(导通），0表示未按下（释放）
    4 N3 s/ {1 C6 S" G$ v. Z% z) F$ o
38. *********************************************************************************************************
    
39. */
    
40. static uint8_t IsKeyDownFunc(uint8_t _id)
    ) `) d) K2 o. `& S4 b1 L0 `
41. {
    
42.         /* 实体单键 */
    
43.         if (_id < HARD_KEY_NUM)
    2 N, o' v6 Q) g- S0 k
44.         {
    ) ?, S$ P- Z: z; [9 V! ^
45.                 uint8_t i;
    * S0 _; n, ~( @
46.                 uint8_t count = 0;
    
47.                 uint8_t save = 255;
    
48.                
    
49.                 /* 判断有几个键按下 */
    0 q% U+ ]1 T" T; w, O! d
50.                 for (i = 0; i < HARD_KEY_NUM; i++)
    ! L  Z4 {( g0 a& c& \
51.                 {
    
52.                         if (KeyPinActive(i))
    
53.                         {
    / f  V3 {; V3 h' [# j
54.                                 count++;
    
55.                                 save = i;
    
56.                         }
    8 Q# [& k6 [* X! b( x
57.                 }
    + \5 u0 o7 O  p" c, y- v2 n( f
58.                
    
59.                 if (count == 1 && save == _id)
    
60.                 {
    
61.                         return 1;        /* 只有1个键按下时才有效 */
    
62.                 }               
    
63. 
    
64.                 return 0;
    
65.         }
    " w- a3 @. u( P" ]
66.         
    
67.         /* 组合键 K1K2 */
    
68.         if (_id == HARD_KEY_NUM + 0)
    4 D, O: A) u1 P9 l8 {1 ~
69.         {
      I) o4 X4 t! i/ y/ _% P1 {
70.                 if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
    
71.                 {
    # c. G, Q; h4 V3 {& j" D, Z& _
72.                         return 1;
    
73.                 }
    " N5 s6 N: L' q0 ]
74.                 else
    
75.                 {
    / F. u0 ]$ R- m4 m9 ]
76.                         return 0;
    , Y3 L1 _, d9 j/ t+ H6 z  c6 M5 L
77.                 }
    * |6 |1 o( ?! g1 C0 x, g3 Y7 s
78.         }
    
79. 
    
80.         /* 组合键 K2K3 */
    
81.         if (_id == HARD_KEY_NUM + 1)
    6 S; G- a* x8 _0 [) J1 x* F
82.         {
    
83.                 if (KeyPinActive(KID_K2) && KeyPinActive(KID_K3))
    
84.                 {
    # n1 o' L0 Q/ q4 G
85.                         return 1;
    3 n9 ^- L. b$ n" X* ]
86.                 }
    & u9 F7 z0 U) S5 K4 ^0 B$ c9 _
87.                 else
    : o9 I) g" m9 ~7 b- F" z3 E( ^( _) _
88.                 {
    0 \  S* J4 V7 n
89.                         return 0;
    
90.                 }
    8 U+ y  V7 X! D7 t
91.         }
    
92. 
    
93.         return 0;
    
94. }

复制代码

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

1. /*
   
2. *********************************************************************************************************
   ( A) k- J2 F; ?. v) R- W
3. *        函 数 名: bsp_InitKeyHard
   1 t# O$ a  \: ?6 i: b- \+ @; x
4. *        功能说明: 配置按键对应的GPIO
   ) m& Y# Y8 `* M& \; \1 M) d
5. *        形    参:  无
   $ \0 P' H; G5 U" X8 |- @/ h
6. *        返 回 值: 无
   4 B& F! @& I* j. `
7. *********************************************************************************************************
   
8. */
   
9. static void bsp_InitKeyHard(void)
   
10. {        
    , b  x  ^6 T- }( _! m
11.         GPIO_InitTypeDef gpio_init;
    $ v. T* D2 [% M/ n6 |! G
12.         uint8_t i;
    / n: a7 j9 H) t! E( l% C
13. 
    
14.         /* 第1步：打开GPIO时钟 */
    5 H3 C8 A! s' e% J6 j4 `$ H- P
15.         ALL_KEY_GPIO_CLK_ENABLE();
    1 P0 w$ o& _. F! j6 \5 {
16.         
    
17.         /* 第2步：配置所有的按键GPIO为浮动输入模式(实际上CPU复位后就是输入状态) */
    
18.         gpio_init.Mode = GPIO_MODE_INPUT;                           /* 设置输入 */
    
19.         gpio_init.Pull = GPIO_NOPULL;                 /* 上下拉电阻不使能 */
    $ ^. S, M, c) x% b
20.         gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;  /* GPIO速度等级 */
    # |+ C: T8 L* \0 q& Q+ T- q
21.         
      {8 E2 n4 }4 B+ u2 |# \2 P
22.         for (i = 0; i < HARD_KEY_NUM; i++)
    : a8 B7 T0 d6 L" M" ^0 m
23.         {
    
24.                 gpio_init.Pin = s_gpio_list<span style="font-style: italic;"><span style="font-style: normal;">.pin;
    # ]8 r: Y! ?4 [% i
25.                 HAL_GPIO_Init(s_gpio_list</span><span style="font-style: normal;">.gpio, &gpio_init);        
    
26.         }
    
27. }</span></span>

复制代码

2 X, ?7 A( V' b1 k我们再来看看按键是如何执行扫描检测的。
# e  g6 }1 g/ q0 x% Q
按键扫描函数bsp_KeyScan10ms ()每隔10ms被执行一次。bsp_RunPer10ms函数在systick中断服务程序中执行。
" u! _$ d" ^# {& o# j0 U$ J

1. void bsp_RunPer10ms(void)
   
2. {
   1 Z! S0 _, d" _# ~3 e) K7 J- n% N
3.         bsp_KeyScan10ms();                /* 扫描按键 */
   # x% T2 l, A+ f0 N. E2 F; r
4. }

复制代码

& [8 a* z7 S9 n  s0 jbsp_KeyScan10ms ()函数的实现如下：

! B3 u8 N- w( N

1. /*
   
2. *********************************************************************************************************
   1 T; r3 o: L3 X
3. *        函 数 名: bsp_KeyScan10ms
   + [" Z8 p/ v( t& n* A
4. *        功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   ' I/ a5 H8 R+ n
7. *********************************************************************************************************
   ( S/ l; V; P* T( j+ [
8. */
   + C% Y1 i5 h5 ]3 r0 C
9. void bsp_KeyScan10ms(void)
   
10. {
    : A6 N$ B0 }2 v1 s2 I( B
11.         uint8_t i;
    ; p1 h5 b! f, @  K
12. 
    
13.         for (i = 0; i < KEY_COUNT; i++)
    , U. Q7 j: D$ o2 n% e: j
14.         {
    3 q- d% a# e4 D, F2 _
15.                 bsp_DetectKey(i);
    ! n! A* p" W1 V+ }
16.         }
    
17. }

复制代码

每隔10ms所有的按键GPIO均会被扫描检测一次。bsp_DetectKey函数实现如下：
  I- V! r& G* S& B( v. K8 F! h1 j

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_DetectKey
   + f) z  w  [" o( N! S) M$ x
4. *        功能说明: 检测一个按键。非阻塞状态，必须被周期性的调用。
   7 g) m# V( Z9 Z4 w
5. *        形    参: IO的id， 从0开始编码
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   4 X& s, ?, S; g' |
8. */
   ( q5 o- L. U3 c. G9 P
9. static void bsp_DetectKey(uint8_t i)
   
10. {
    $ x; _; v+ ]' v
11.         KEY_T *pBtn;
    
12. 
    1 F* C$ `- ]1 `' l; I0 T5 \$ ~  g$ y
13.         pBtn = &s_tBtn<span style="font-style: italic;"><span style="font-style: normal;">;
    6 \' ]9 c2 R1 x! K6 B% t
14.         if (IsKeyDownFunc(i))
    
15.         {
    8 \+ n8 C0 s2 \, R9 w5 b& ?
16.                 if (pBtn->Count < KEY_FILTER_TIME)
    5 k( H5 E/ E7 W% u2 [$ `, m5 L
17.                 {
    
18.                         pBtn->Count = KEY_FILTER_TIME;
    
19.                 }
    
20.                 else if(pBtn->Count < 2 * KEY_FILTER_TIME)
    7 t# n. T) @4 N8 c  C
21.                 {
      e4 [9 H3 p9 ?4 E, D
22.                         pBtn->Count++;
    
23.                 }
    7 ~* E# [% \, R& L+ P  R
24.                 else
    2 F2 g7 n9 @( K% M9 d2 _
25.                 {
    , j* t5 \% x9 J6 A/ Q8 z0 x% ?
26.                         if (pBtn->State == 0)
    
27.                         {
    ( D7 j6 O. j0 _& w! e
28.                                 pBtn->State = 1;
    . V6 o  S# |+ R7 b# B
29. 
    ' f+ O5 ~/ J& n# l4 G) v
30.                                 /* 发送按钮按下的消息 */
    4 B# E  l6 Q" A3 Q# ^& t6 G
31.                                 bsp_PutKey((uint8_t)(3 * i + 1));
    
32.                         }
    - c- \; `. G$ X8 l, l9 }* B
33. 
    
34.                         if (pBtn->LongTime > 0)
    
35.                         {
    
36.                                 if (pBtn->LongCount < pBtn->LongTime)
    
37.                                 {
    7 z9 P" x# i# `3 N
38.                                         /* 发送按钮持续按下的消息 */
    + e2 Z0 g' T6 v. e: d' @4 ^* n
39.                                         if (++pBtn->LongCount == pBtn->LongTime)
    
40.                                         {
    6 n% R$ T( p# h0 B" _7 C) {5 j4 Q
41.                                                 /* 键值放入按键FIFO */
    - n7 @" H7 s9 _- d$ u: N. u# h
42.                                                 bsp_PutKey((uint8_t)(3 * i + 3));
    
43.                                         }
    ; n' O! H% [( q+ a$ X
44.                                 }
    * b, u; a1 r/ B8 m& p- k/ N# Z$ Z
45.                                 else
    
46.                                 {
    ; L. ]* _5 g5 D2 U# ?* Z; O8 ^1 q! `
47.                                         if (pBtn->RepeatSpeed > 0)
    0 x2 H+ ~, X$ t' W$ P% {' l4 p
48.                                         {
    5 c4 b  t* H1 w" M
49.                                                 if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
    
50.                                                 {
    3 S1 K& U) |5 k/ }* G! v/ ~
51.                                                         pBtn->RepeatCount = 0;
    
52.                                                         /* 常按键后，每隔RepeatSpeed * 10ms发送1个按键 */
    
53.                                                         bsp_PutKey((uint8_t)(3 * i + 1));
    
54.                                                 }
    * S" v: V: S8 _% A. _) i- k
55.                                         }
    
56.                                 }
    / P+ K$ e+ i' p
57.                         }
    8 M& N* c' w( G6 d+ V6 g  }& |1 A
58.                 }
    
59.         }
    
60.         else
    : N1 |) F& {; J" F, m
61.         {
    
62.                 if(pBtn->Count > KEY_FILTER_TIME)
    
63.                 {
    
64.                         pBtn->Count = KEY_FILTER_TIME;
    
65.                 }
    7 S" a2 ~# d. r+ X& c
66.                 else if(pBtn->Count != 0)
    
67.                 {
    ' Z6 E3 b7 l9 P. R
68.                         pBtn->Count--;
    
69.                 }
    - |* [( ~4 E# [
70.                 else
    
71.                 {
    # N0 M; w) d' c
72.                         if (pBtn->State == 1)
    5 d. n- ]6 M$ L
73.                         {
    5 z. a' n+ N/ `$ o1 A
74.                                 pBtn->State = 0;
    # Z. |7 `0 S4 r6 G' X$ C4 I
75. 
    
76.                                 /* 发送按钮弹起的消息 */
    
77.                                 bsp_PutKey((uint8_t)(3 * i + 2));
    
78.                         }
    
79.                 }
    # f  W' |4 I7 d, Q
80. 
    4 X! |  O2 G4 h) ]) P4 }
81.                 pBtn->LongCount = 0;
      g) P- j) C- _& U  t' m" r
82.                 pBtn->RepeatCount = 0;
    6 n1 u* k. y. F) o* ?! O
83.         }
    $ l- x7 j" W! q7 V( L5 w
84. }</span></span>

复制代码

. ]# T; R# Y/ k1 v; b对于初学者，这个函数看起来比较吃力，我们拆分进行分析。
/ d$ E9 I2 a: F# o
8 A) r  q# Q( W4 n9 ?* Z

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

复制代码

4 `" T  M/ y( A/ H8 ~7 N读取相应按键的结构体地址，程序里面每个按键都有自己的结构体。

1. static KEY_T s_tBtn[KEY_COUNT];
   
2. if (IsKeyDownFunc(i))
   ! d6 `( q5 u7 C1 b* j2 ]
3. {
   3 l5 W+ }$ K+ \2 Y) r/ [) {
4.         这个里面执行的是按键按下的处理
   : G) b8 _3 g$ p
5. }
   
6. else
   
7. {
   0 R/ r' j/ Z' Y6 K3 _9 u
8.         这个里面执行的是按键松手的处理或者按键没有按下的处理
   : \! j- S7 H4 c) f" @) y
9. }

复制代码

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

1. /*
   
2. **********************************************************************************
   
3. 下面这个if语句主要是用于按键滤波前给Count设置一个初值，前面说按键初始化的时候
   . b  Y5 W+ o9 n3 S2 I! j( b
4. 已经设置了Count = KEY_FILTER_TIME/2
   
5. **********************************************************************************
   
6. */
   2 Y9 O8 o5 H9 t
7. if (pBtn->Count < KEY_FILTER_TIME)
   : G2 L5 Q* `- d9 p* H9 _
8. {
   
9.     pBtn->Count = KEY_FILTER_TIME;
   + y8 m# m3 H1 G! ]. t1 F
10. }
    
11. 
    : m8 J9 l, y" f% J/ b4 ~! N) M
12. /*
    ' v2 k) b4 [# V/ h, y
13. **********************************************************************************
    
14. 这里实现KEY_FILTER_TIME时间长度的延迟
    & a' C9 W; z4 u5 t$ R  z( _
15. **********************************************************************************
    % x% g( A5 L+ `. v( Y
16. */
    / C# Q' e1 z) U
17. else if(pBtn->Count < 2 * KEY_FILTER_TIME)
    
18. {
    
19.     pBtn->Count++;
    ; O. i! q: l, F. O# u, h
20. }
    
21. /*
    . `5 D3 Z% w! Q0 m( F
22. **********************************************************************************
    ( {$ F% K! w4 f% g, c  [& n+ K
23. 这里实现KEY_FILTER_TIME时间长度的延迟
    
24. **********************************************************************************
    7 T* `+ \8 `8 Q5 `) u5 X
25. */
    4 a$ G- t0 p4 O9 F
26. else
    * [0 Y1 ?3 V. t/ c
27. {
    - Y# ?0 d& Y# {
28. /*
    
29. **********************************************************************************
    0 _+ m/ s" o9 B/ Z& s
30. 这个State变量是有其实际意义的，如果按键按下了，这里就将其设置为1，如果没有按下这个
    ; c1 E2 F3 Q( |1 H9 `
31. 变量的值就会一直是0，这样设置的目的可以有效的防止一种情况的出现：比如按键K1在某个
    
32. 时刻检测到了按键有按下，那么它就会做进一步的滤波处理，但是在滤波的过程中，这个按键
    
33. 按下的状态消失了，这个时候就会进入到上面第二步else语句里面，然后再做按键松手检测滤波
    : ]9 c% ~, P: Z) m
34. ，滤波结束后判断这个State变量，如果前面就没有检测到按下，这里就不会记录按键弹起。
    # Z9 P# O) k! N
35. **********************************************************************************
    
36. */
    - l% @; \7 C2 m) ^: [
37.     if (pBtn->State == 0)
    , }, h) k* |+ }$ b% s4 ^
38.     {
    
39.         pBtn->State = 1;
    - [2 f$ ^: h/ v" M3 D* ^6 G
40. 
    
41.         /* 发送按钮按下的消息 */
    
42.         bsp_PutKey((uint8_t)(3 * i + 1));
    4 Y" O4 u5 g2 }* O
43.     }
    
44. 
    
45.     if (pBtn->LongTime > 0)
    
46.     {
    ; c8 p5 H4 |& O+ N; H0 h# x6 ]
47.         if (pBtn->LongCount < pBtn->LongTime)
    / L8 h; d- |  ]- X; D
48.         {
    
49.             /* 发送按钮持续按下的消息 */
    
50.             if (++pBtn->LongCount == pBtn->LongTime)
    
51.             {
    9 ]' r' D/ {7 \( C4 `
52.                 /* 键值放入按键FIFO */
    ( m6 [) o, b- B; n" f- U9 @
53.                 bsp_PutKey((uint8_t)(3 * i + 3));
    
54.             }
    ) }5 T% E2 b" Q  i' D9 @' y8 {
55.         }
    3 W! V' t  h+ K9 o  w. m" K3 f
56.         else
    + S2 T$ L! s2 Y# O- _0 H# P
57.         {
    
58.             if (pBtn->RepeatSpeed > 0)
    
59.             {
    1 Y: p) d8 p6 O2 `. s- {" j
60.                 if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
    
61.                 {
    
62.                     pBtn->RepeatCount = 0;
    0 d1 t$ L! w+ B( G
63.                     /* 长按键后，每隔10ms发送1个按键 */
    9 G" B6 a6 G3 j5 c, m3 d4 }7 }) H, ?
64.                     bsp_PutKey((uint8_t)(3 * i + 1));
    
65.                 }
    . h& a# e  c2 e4 J
66.             }
    4 T1 r* [" G4 d# c! Y
67.         }
    ' ^5 T' F* x8 Q9 F, y% \3 }
68.     }
    3 z1 v# w; y. E) t% ?
69. }

复制代码

19.3.4 按键检测采用中断方式还是查询方式
1 z: ^' c' Z4 [. Q' L检测按键有中断方式和GPIO查询方式两种。我们推荐大家用GPIO查询方式。

从裸机的角度分析

- J" z' B" g+ F中断方式：中断方式可以快速地检测到按键按下，并执行相应的按键程序，但实际情况是由于按键的机械抖动特性，在程序进入中断后必须进行滤波处理才能判定是否有效的按键事件。如果每个按键都是独立的接一个IO引脚，需要我们给每个IO都设置一个中断，程序中过多的中断会影响系统的稳定性。中断方式跨平台移植困难。
5 \5 T) ]6 U' k  [2 \* P9 j4 G
查询方式：查询方式有一个最大的缺点就是需要程序定期的去执行查询，耗费一定的系统资源。实际上耗费不了多大的系统资源，因为这种查询方式也只是查询按键是否按下，按键事件的执行还是在主程序里面实现。
0 ~! f/ @, f0 y3 c- Z
从OS的角度分析

中断方式：在OS中要尽可能少用中断方式，因为在RTOS中过多的使用中断会影响系统的稳定性和可预见性（抢占式调度的OS基本没有可预见性）。只有比较重要的事件处理需要用中断的方式。

$ B: E+ D$ `4 P& J查询方式：对于用户按键推荐使用这种查询方式来实现，现在的OS基本都带有CPU利用率的功能，这个按键FIFO占用的还是很小的，基本都在1%以下。
6 E: K7 j( J) }% E1 W
! W  i9 I* p3 B% q$ C19.4 按键板级支持包（bsp_key.c）
按键驱动文件bsp_key.c主要实现了如下几个API：

  KeyPinActive
  IsKeyDownFunc
  bsp_InitKey
  B' `5 g0 j- ]. Z# T( V* @  bsp_InitKeyHard
  bsp_InitKeyVar
  bsp_PutKey
  bsp_GetKey
  bsp_GetKey2
  bsp_GetKeyState
  bsp_SetKeyParam
8 }3 g' N# y- w# W6 P* R. X  bsp_ClearKey
  bsp_DetectKey
  bsp_DetectFastIO
  bsp_KeyScan10ms
  bsp_KeyScan1ms
( F: C7 ^! @3 W( F( W
! q4 I; Z; W# P; s! E& b& m所有这些函数在本章的19.3小节都进行了详细讲解，本小节主要是把需要用户调用的三个函数做个说明。

4 [) N4 u: h# _" K19.4.1 函数bsp_InitKeyHard
1 j8 O2 X8 w) P" d# H9 M函数原型：
! R$ x$ u. I. ]6 K
* D" G# `; V/ S" a% E8 M

1. /*
   7 [5 \: W( {5 T( Z) k& d
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_InitKey
   
4. *        功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
   
5. *        形    参: 无
   + k8 K7 y# z: i; H& E" S
6. *        返 回 值: 无
   / ?5 f- O' i9 ]
7. *********************************************************************************************************
   * c* W) P( L% U! G; j, K
8. */
     E$ m$ G8 i. Z( T- V& }8 A
9. void bsp_InitKey(void)
   . ^; X; B+ Q' X, l# ?) H6 g# t
10. {
    
11.         bsp_InitKeyVar();                /* 初始化按键变量 */
    
12.         bsp_InitKeyHard();                /* 初始化按键硬件 */
    , q& @! G; i3 y$ s3 \8 o7 B: @
13. }

复制代码

: v6 s& v2 N3 r: t函数描述：

5 ^4 [# b6 P9 C5 ]此函数主要用于按键的初始化。
4 B$ H  H. D5 M6 R! h
使用举例：
5 y8 Y3 H7 m& y1 {6 R
底层驱动初始化直接在bsp.c文件的函数bsp_Init里面调用即可。
" a7 ]2 W7 C# C+ ^- b+ _
19.4.2 函数bsp_GetKey
# k) T, }) o9 P  G* |% x$ n: s函数原型：
4 {% {1 F5 t7 e4 H$ [) D; y

1. /*
   
2. *********************************************************************************************************
   - U: _+ H3 R1 Y
3. *        函 数 名: bsp_GetKey
   - a( [- |9 ]7 Q" w  F- Z/ I
4. *        功能说明: 从按键FIFO缓冲区读取一个键值。
   ! T7 m* S4 I! s9 w! R
5. *        形    参: 无
   
6. *        返 回 值: 按键代码
   7 s% y2 r( o2 V* T
7. *********************************************************************************************************
   
8. */
   
9. uint8_t bsp_GetKey(void)
   9 m4 y3 {0 {5 ~% x0 Z; p
10. {
    5 M, Z" I  c) d9 ^
11.         uint8_t ret;
    & S: q+ a, z- ~( b+ d
12. 
    
13.         if (s_tKey.Read == s_tKey.Write)
    2 M! U- ?$ ]0 [8 C
14.         {
    
15.                 return KEY_NONE;
    
16.         }
    
17.         else
    + l& E. O# c5 A# F5 I& v
18.         {
    
19.                 ret = s_tKey.Buf[s_tKey.Read];
    5 _/ i# L0 T1 F6 s# e, o
20. 
    ( B5 N; q6 L: _
21.                 if (++s_tKey.Read >= KEY_FIFO_SIZE)
    
22.                 {
    + n3 O$ _% r$ B( ^- [# \) y8 e
23.                         s_tKey.Read = 0;
    
24.                 }
    
25.                 return ret;
    
26.         }
    5 Y% g2 l# ]. |
27. }

复制代码

: y- ]: F  U4 i; k函数描述：
" J: q( ~) N4 ~% e
此函数用于从FIFO中读取键值。

+ r7 t- |& u0 ]7 p使用举例：
+ O' ~! w* s$ x) |: e" j
% I* F" y" v4 W调用此函数前，务必优先调用函数bsp_InitKey进行初始化。
% u" _) v! ~. J- c9 {/ V1 R% X
+ Z  _3 h  b! O: r( e* j' A

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   3 y% d: v; M% a+ y+ c$ I
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   $ \4 `* N# A/ i  k! `
8. */
   
9. int main(void)
   7 x: ^* T3 I% ?
10. {
    : _# N  ~7 ^( e' w( C3 A. `7 J
11.         uint8_t ucKeyCode;                /* 按键代码 */
    / H( m! {4 B3 Q! P; b9 t
12.         
    8 l+ `4 Z  ^7 r$ S
13.         bsp_Init();                /* 硬件初始化 */
    
14.         
    
15.         /* 进入主程序循环体 */
    , c0 Z+ y) {+ U9 d- g& l% |3 k; R
16.         while (1)
    9 B# F  G" ^6 Z6 O0 p5 H/ J4 O! [8 K( Y
17.         {               
    ) ]7 i0 U4 q2 i: s
18.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    + D- t2 r/ N  Z+ V/ b4 O' M
19.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
20.                 if (ucKeyCode != KEY_NONE)
    
21.                 {
    
22.                         switch (ucKeyCode)
    
23.                         {
    1 F6 W( S) x! b8 z
24.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    
25.                                         printf("K1键按下\r\n");
    / o0 V+ m) ^0 }
26.                                         break;
    # m8 W# x. _2 B7 j3 M
27. 
    2 j2 m5 G* d7 P+ D
28.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    8 A# s$ h% N: `0 `3 d% L
29.                                         printf("K2键按下\r\n");
    
30.                                         break;
    
31. 
    
32.                                 default:
    
33.                                         /* 其它的键值不处理 */
    
34.                                         break;
    
35.                         }
    6 r# Z0 W( X3 `( l, x2 I
36.                 }
    
37.         }
    8 x$ G2 S* u! U! N' ?" G
38. }

复制代码

19.4.3 函数bsp_KeyScan10ms
3 F( Q4 c/ D  F: K" j# B/ \函数原型：

1. /*
   7 J. M8 f7 b! Z/ y3 v& p
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_KeyScan10ms
   
4. *        功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
   ( W; ]* @+ @. O* H* ?) W
5. *        形    参: 无
   # E6 ~" U7 K5 s6 a
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   # ]% w. T' Q5 {, `
9. void bsp_KeyScan10ms(void)
   
10. {
    
11.         uint8_t i;
      B( q3 S1 j  f: M2 z8 P
12. 
    
13.         for (i = 0; i < KEY_COUNT; i++)
    
14.         {
    . [7 V+ @8 q: N2 ?/ E, _/ V' u% w
15.                 bsp_DetectKey(i);
    . H4 S2 H; _8 R  X
16.         }
    + {" P7 v/ x. S8 }
17. }

复制代码

函数描述：

$ n) N" `, X7 O2 u0 S此函数是按键的主处理函数，用于检测和存储按下、松手、长按等状态。

2 w( E" j' J" P9 k( b; n使用举例：

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

; y1 O; K+ f# g- j另外，此函数需要周期性调用，每10ms调用一次。

  如果是裸机使用，将此函数放在bsp.c文件的bsp_RunPer10ms函数里面即可，这个函数是由滴答定时器调用的，也就是说，大家要使用按键，定时器的初始化函数bsp_InitTimer一定要调用。
  如果是RTOS使用，需要开启一个10ms为周期的任务调用函数bsp_KeyScan10ms。

6 e  S7 s. K. f19.5 按键FIFO驱动移植和使用
( ~/ e/ G% [$ ?& O, t) E4 r) |按键移植步骤如下：
+ `9 h3 N! _$ @9 T+ m
# W% x8 @/ t8 |  第1步：复制bsp_key.c和bsp_key.c到自己的工程。
! W; G/ R# e/ l0 c& N/ e: A" ^6 j  g- l  第2步：根据自己使用的独立按键个数和组合键个数，修改几个地方。

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

复制代码

  第3步：根据使用的引脚时钟，修改下面函数：
8 P5 }( Y; ]/ s; M. t

1. /* 使能GPIO时钟 */
   1 g+ m  T. o# f+ c8 I$ [" G- k8 H
2. #define ALL_KEY_GPIO_CLK_ENABLE() {        \
   
3.                 __HAL_RCC_GPIOB_CLK_ENABLE();        \
   - @8 A3 j- }) f& s
4.                 __HAL_RCC_GPIOC_CLK_ENABLE();        \
   
5.                 __HAL_RCC_GPIOG_CLK_ENABLE();        \
   
6.                 __HAL_RCC_GPIOH_CLK_ENABLE();        \
   5 [, N# k0 v! e. }
7.                 __HAL_RCC_GPIOI_CLK_ENABLE();        \
   
8.         };

复制代码

0 F: y+ m  [8 r8 A. A/ \- N+ H* l" P  第4步：根据使用的具体引脚，修改如下函数，第3列参数低电平表示按下或者高电平表示按下：

1. /* GPIO和PIN定义 */
   
2. static const X_GPIO_T s_gpio_list[HARD_KEY_NUM] = {
   
3.         {GPIOI, GPIO_PIN_8, 0},                /* K1 */
   
4.         {GPIOC, GPIO_PIN_13, 0},        /* K2 */
   6 K3 ^9 x7 Q7 E& s" h
5.         {GPIOH, GPIO_PIN_4, 0},                /* K3 */
   
6.         {GPIOG, GPIO_PIN_2, 0},                /* JOY_U */        
   
7.         {GPIOB, GPIO_PIN_0, 0},                /* JOY_D */
   9 w. S" J; P2 c1 d
8.         {GPIOG, GPIO_PIN_3, 0},                /* JOY_L */        
   ) F: X1 c# G" x4 `! f8 v( R
9.         {GPIOG, GPIO_PIN_7, 0},                /* JOY_R */        
   
10.         {GPIOI, GPIO_PIN_11, 0},        /* JOY_OK */
    
11. };   

复制代码

     
  第5步：根据使用的组合键个数，在函数IsKeyDownFunc里面添加相应个数的函数：
3 T$ x/ ~. V( C: b4 o2 u3 j

1.         /* 组合键 K1K2 */
   
2.         if (_id == HARD_KEY_NUM + 0)
   
3.         {
   
4.                 if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
   $ G; h; w. z" ~& c; c: A, \. i2 {
5.                 {
   6 A% k/ f# b! x+ y2 j
6.                         return 1;
   7 G9 G  T9 C9 C1 z3 Z- N
7.                 }
   
8.                 else
   1 \' B8 _0 n, F( S/ [
9.                 {
   
10.                         return 0;
    + v$ y$ O" g7 U8 X! i+ y. T8 \
11.                 }
    
12.         }

复制代码

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

$ M  R5 M$ Y4 f3 y4 q$ Q. z0 |另外就是，函数KeyPinActive的参数是表示检测哪两个按键，设置0的时候表示第4步里面的第1组按键，设置为1表示第2组按键，以此类推。

  第6步：主要用到HAL库的GPIO驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
  第7步：移植完整，应用方法看本章节配套例子即可。
* e- c# }. y8 N$ l8 ?2 u6 w特别注意，别忘了每10ms调用一次按键检测函数bsp_KeyScan10ms。
6 }5 o; J- l% |% N
19.6 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：

5 R# r! l' A) V# o6 ]6 A5 `2 G  S4 ~

* v$ v2 b" ?& S  s
1、 第1阶段，上电启动阶段：

& ]: _# r5 Y$ v( L1 Q: |这部分在第14章进行了详细说明。

& B. p( _+ T3 r; V1 q- Y; p 2、 第2阶段，进入main函数：

* L3 Z3 d3 k$ p  第1部分，硬件初始化，主要是MPU、Cache、HAL库、系统时钟、滴答定时器、按键等。
/ {9 i9 Z, k1 Q, l9 g- }  第2部分，应用程序设计部分，实现了一个按键应用。
/ ?+ \/ ~& y2 J2 N2 R6 r  _  第3部分，按键扫描程序每10ms在滴答定时中断执行一次。
# h$ J  |3 b: k  w- E9 V7 j
19.7 实验例程说明（MDK）
配套例子：
  I$ U5 T  c+ JV7-002_按键检测（软件滤波，FIFO机制）

' i3 F" t! {# p* Y' ^/ e" Z) K  q实验目的：
学习按键的按下，弹起，长按和组合键的实现。

实验内容：
启动一个自动重装软件定时器，每100ms翻转一次LED2。

  Q9 ~/ a! b: k  ?$ ~实验操作：
- ^, k- T/ e. o; X9 g3个独立按键和5向摇杆按下时均有串口消息打印。
5向摇杆的左键和右键长按时，会有连发的串口消息。
, G, e5 P2 p, `% U# ]3 [! \独立按键K1和K2按键按下，串口打印消息。

上电后串口打印的信息：
7 x6 G/ |: J3 P- P- p9 U
% Y& e6 Y: j3 b9 f9 O波特率 115200，数据位 8，奇偶校验位无，停止位 1

+ C. E% l7 Y3 T  x, @

$ t! K6 R! e5 L- I
程序设计：

  系统栈大小分配：
4 k7 S6 J* _. Z! Q5 X; R( u
! v5 ^- V% n! r1 \% D8 Y3 r5 w

: M, F1 [/ @5 Y; U
8 ?$ u2 P% S" W, C. o% R  RAM空间用的DTCM：
2 B( i7 P( a$ f' s3 r4 ]% u5 l( N

1 a7 H- Q2 Q! Z; u& C  硬件外设初始化
# F6 s. X. U; x; z; W% W3 a  n. M3 d
& Z% o+ W: v) a+ s( r, u硬件外设的初始化是在 bsp.c 文件实现：

1. /*
   
2. *********************************************************************************************************
   6 v0 K( }" N! e1 ^; t7 y% i
3. *        函 数 名: bsp_Init
   4 X8 {! B4 @3 A, I: K) V# A
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   
6. *        返 回 值: 无
   ) Q$ J6 k' v; @, b
7. *********************************************************************************************************
   5 S8 r6 r/ ^3 N7 w9 g0 i  a
8. */
   
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    & W8 r  T1 f2 ?7 N$ P7 i
12.         MPU_Config();
    
13.         
    
14.         /* 使能L1 Cache */
    3 F6 c; t/ U( @
15.         CPU_CACHE_Enable();
    4 E4 g$ {( a3 ]' E  ?" _) R
16. 
    " Z9 i% x' ~/ z1 \8 C4 O
17.         /*
    4 j  f3 ^" j8 C1 d: l
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    # ?: t. C. R* w
21.          */
    
22.         HAL_Init();
    & n; t0 e9 ^  ~( z5 A- p  C
23. 
    8 D  E# F8 ?2 }, z2 g& y
24.         /*
    ! E/ W+ @6 N6 @; ~/ P/ j7 V
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    ) l  {$ Y) r1 F0 b
29.         SystemClock_Config();
    7 j3 q: S0 u& C' ]  J( i
30. 
    
31.         /*
    
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    4 N3 J: W- B6 o7 ^  Z
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    : ]9 Q) p+ h- w8 R+ C0 j
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    " o* l6 l( N( B" t' l1 |
38.         EventRecorderInitialize(EventRecordAll, 1U);
    1 k7 X+ @! K$ I+ C) }3 h
39.         EventRecorderStart();
    
40. #endif
    
41.         
    7 h( c% ~% U2 F1 d
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    . U* e2 f7 x  ?5 X2 |
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    " K% Q+ U. b2 }2 C/ W
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    
46.         bsp_InitLed();            /* 初始化LED */        
    + Y. |2 [: D2 t5 x( ?" y* W
47. }

复制代码

4 _# o; m# s4 _3 ]+ J0 B  MPU配置和Cache配置：
; x$ D) J) I: L) Q
+ d" i' p- C3 H0 X# Y数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
- v& h8 V$ O: i) Q3 D* c
$ u! a2 @4 @1 V; q

1. /*
   1 s/ I. ?$ v4 k
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   3 ~  q) Y: o9 J9 x5 ]5 j$ L
4. *        功能说明: 配置MPU
   1 C2 L/ _7 ?& Y+ b* `' J& F
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   ; U5 F2 z' c9 x" t6 `
8. */
   6 S$ R) _; ^7 J2 f
9. static void MPU_Config( void )
   * Z/ s) M. s4 `
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.         /* 禁止 MPU */
    ) }: {) S5 w5 B% ?
14.         HAL_MPU_Disable();
    
15. 
    # @: A' u1 o" w- d8 ?3 g
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;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    % v& Z( s+ U/ j5 a! E8 D
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    / L: q  j! w  c$ t* e; G" {
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    * q& Q1 D- v0 ]1 t
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    0 Z' H& C& F5 Y  B: Z- R
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    1 r$ o, x9 K: p  ~0 p9 o; x
28. 
    & y  K+ a0 w5 Y3 K7 @6 T) @  B
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    % G- f5 f6 w; ?  G: `3 h' }
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    + ~; }, f+ o. a$ I+ D
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    9 ^, e5 [* O3 b1 ~! D% d8 W
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    * k( }* S2 s7 t, p3 ?
44.         
    0 |: j6 W7 ?0 O0 c4 s; O( s, j
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    - `! W( b& Q% z1 \9 E
46. 
    , \* M% M% U& G* n
47.         /*使能 MPU */
    + _# P% G7 s7 n) X7 _
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    1 t9 D+ B5 v7 E
49. }
    0 \) ~; n8 r" L4 O# y5 Y- Y
50. 
    
51. /*
    & L# G  K$ ~$ S- I6 y" Z
52. *********************************************************************************************************
    - d$ C* q' l  b0 l% ~3 h
53. *        函 数 名: CPU_CACHE_Enable
    ; @3 U2 f% k. u- ^
54. *        功能说明: 使能L1 Cache
    ; m0 x2 ]" J1 }  _# N
55. *        形    参: 无
    ! C- x) p+ |4 W
56. *        返 回 值: 无
    1 `% ~( }: z, e* Q6 q8 _! \
57. *********************************************************************************************************
    + j0 q' N& o3 W/ b; Q9 n
58. */
    
59. static void CPU_CACHE_Enable(void)
    
60. {
    9 {1 A7 G' L. K: v$ v
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    ' g8 Q/ S( f0 J  s3 P, \
63. 
    $ f/ U) m- ]; `: D" E* @( n
64.         /* 使能 D-Cache */
    ' \0 l6 o5 o& d) _
65.         SCB_EnableDCache();
    6 u4 @* g% ^0 @9 U; w
66. }

复制代码

$ T& a) p' k  ^" Y) y$ {  每10ms调用一次按键检测：

8 V9 `7 k, P; t3 W: D0 j按键检测是在滴答定时器中断里面实现，每10ms执行一次检测。

! R! R/ ~6 {0 r. g7 @3 _

1. /*
   ' v  X9 T( L2 h9 ?3 n0 z0 @
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_RunPer10ms
   
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   4 O( P# @9 T: h( t0 L' _9 t; [
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   " g4 X% q0 y$ X4 M3 T) n
6. *        形    参: 无
   ; X  P; |7 r+ ~: C. O1 C
7. *        返 回 值: 无
   
8. *********************************************************************************************************
   
9. */
   
10. void bsp_RunPer10ms(void)
    * K+ |# V1 |( n" s/ m5 _" m
11. {
    
12.         bsp_KeyScan10ms();
    " n4 B  \6 V" ]# E' O& l6 O
13. }

复制代码

" K2 b. H7 p7 h& c6 F4 g  主功能：

1 N* a5 L7 ~; S* X0 {' Y主功能的实现主要分为两部分：
$ d' G' d5 t" r. U6 [! d
启动一个自动重装软件定时器，每100ms翻转一次LED2
  ?4 W" ?; X; u 按键消息的读取，检测到按下后，做串口打印。

1. /*
   : R& q6 P4 L$ [/ {
2. *********************************************************************************************************
   ! l/ G0 K! e) W' M; O, @$ X0 A
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   $ r$ d, p* J# _: R9 ?3 }
7. *********************************************************************************************************
   4 O' o4 I, E0 M: R# r
8. */
   0 ?' C! u8 i. K, j2 ]" A
9. int main(void)
   
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    # \2 O+ o3 x$ [" G4 z* U0 c
12.         
    3 f& C1 v$ ^2 S: \/ }/ W0 |
13.         bsp_Init();                /* 硬件初始化 */
    / `: Q& H5 k. r" A# Y/ {) S, Z
14.         
    $ Q6 Z2 D2 x: z2 O9 g8 c& a' m
15.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
16.         PrintfHelp();        /* 打印操作提示 */
    : M5 C" c. l% o7 d* A% V. t0 a- B
17. 
    
18. 
    
19.         bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 */
    
20.         
    / E- ~. M7 ~% I0 \! R4 v% s( ~
21.         /* 进入主程序循环体 */
    ( E0 ^# ?0 e% k+ e+ `5 s: k6 e
22.         while (1)
    
23.         {
    
24.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    6 a: S. W# w9 A% [& V
25. 
    
26.                 /* 判断定时器超时时间 */
    / L8 X6 L" x; i: _6 `) b7 o
27.                 if (bsp_CheckTimer(0))        
    
28.                 {
    1 K$ L! N/ b3 d' t( b. o& F
29.                         /* 每隔100ms 进来一次 */  
    
30.                         bsp_LedToggle(2);                        
    8 C  j* F6 {- E: C7 E% Q
31.                 }
    3 S/ D3 O3 y6 z1 D5 F
32.                
    9 Y/ ]4 r+ C* c5 I$ Z/ X
33.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
34.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    + i+ W0 g" h: F/ L0 Y% e  d# L
35.                 if (ucKeyCode != KEY_NONE)
      ~  |7 x+ c' V5 `. a1 x) l+ i
36.                 {
    
37.                         switch (ucKeyCode)
    
38.                         {
    5 a+ q3 G: o0 B! Y7 p
39.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    
40.                                         printf("K1键按下\r\n");
    5 i* U" ]# @  g
41.                                         break;
    4 O0 K, q, e, K" m. t. A$ h, [
42. 
    4 `& V( ^3 l7 m: P9 V5 x
43.                                 case KEY_UP_K1:                                /* K1键弹起 */
    
44.                                         printf("K1键弹起\r\n");
    # L7 n9 ~) f) ^+ m& r) A* T1 U! M. l
45.                                         break;
    
46. 
    $ l; P# V1 E3 \2 \
47.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    
48.                                         printf("K2键按下\r\n");
    
49.                                         break;
    # a  E1 P% Q# A5 h
50. 
    0 K( e- K! K9 k
51.                                 case KEY_UP_K2:                                /* K2键弹起 */
    ; z+ A5 ]( N  g& \
52.                                         printf("K2键弹起\r\n");
    
53.                                         break;
    7 x' x  l2 Q6 H/ X) G2 x
54. 
    
55.                                 case KEY_DOWN_K3:                        /* K3键按下 */
    
56.                                         printf("K3键按下\r\n");
    
57.                                         break;
    " \5 u' ~7 K4 \- l
58. 
    
59.                                 case KEY_UP_K3:                                /* K3键弹起 */
    ) r7 K/ H5 [7 Q
60.                                         printf("K3键弹起\r\n");
    0 u9 g* ]2 S/ X# s3 ^+ X
61.                                         break;
    
62. 
    ' ]( o9 _# W# j% \; x
63.                                 case JOY_DOWN_U:                        /* 摇杆UP键按下 */
    
64.                                         printf("摇杆上键按下\r\n");
    7 ^( |) [( k5 X
65.                                         break;
    
66. 
    ( h! X& G# u) W, D- D- e) `
67.                                 case JOY_DOWN_D:                        /* 摇杆DOWN键按下 */
    " q( S( A7 F& o1 D' n  R# Z% B
68.                                         printf("摇杆下键按下\r\n");
    
69.                                         break;
    * D  A3 P9 \7 S2 n
70. 
    3 U  c+ S8 F, S
71.                                 case JOY_DOWN_L:                        /* 摇杆LEFT键按下 */
    
72.                                         printf("摇杆左键按下\r\n");
    . X, X7 z! T* B% d
73.                                         break;
    
74.                                 
    
75.                                 case JOY_LONG_L:            /* 摇杆LEFT键长按 */
    0 a2 X+ }$ I5 I- U
76.                                         printf("摇杆左键长按\r\n");
    9 ~) p1 R* }# K
77.                                         break;
    8 _& `5 b4 V1 l2 @) `
78. 
    2 u6 f( x8 X% U; ^9 \. J  }
79.                                 case JOY_DOWN_R:                        /* 摇杆RIGHT键按下 */
    
80.                                         printf("摇杆右键按下\r\n");
    
81.                                         break;
    
82.                                 
    - k' f1 L' A1 E9 [& U8 j$ I
83.                                 case JOY_LONG_R:            /* 摇杆RIGHT键长按 */
    8 I/ z6 }# s9 c
84.                                         printf("摇杆右键长按\r\n");
    
85.                                         break;
    
86. 
    
87.                                 case JOY_DOWN_OK:                        /* 摇杆OK键按下 */
    
88.                                         printf("摇杆OK键按下\r\n");
    , N+ m, g5 R2 [4 U  ]5 _
89.                                         break;
    
90. 
    4 Z7 j  J" ~+ y" L' h5 N& g
91.                                 case JOY_UP_OK:                        /* 摇杆OK键弹起 */
    4 _* p: I2 Q& k) t& ^
92.                                         printf("摇杆OK键弹起\r\n");
    
93.                                         break;
    % D6 ^% S" O, a# ]. Z; T
94. 
    
95.                 case SYS_DOWN_K1K2:                        /* 摇杆OK键弹起 */
    4 `) g7 I) c; F" o1 f
96.                                         printf("K1和K2组合键按下\r\n");
    ; l& a7 W/ f/ J
97.                                         break;
    6 R0 g, W: T4 E
98. 
    
99.                                 default:
    
100.                                         /* 其它的键值不处理 */
     , Q7 E6 d0 q! w  _* m/ D$ K6 s
101.                                         break;
     - ]8 t0 R% `  B% Y
102.                         }
     
103.                
     ! {; d0 |- `" u2 R
104.                 }
     % @5 B! [6 j' a/ L% U3 J
105.         }
     ; v0 G  {1 N, h, z! p
106. }

复制代码

8 G+ k3 j5 j& X" W6 E% M19.8 实验例程说明（IAR）
6 v( `1 r1 Q* T) l4 l) p! [配套例子：
9 l+ S! a, s* m. ^5 Y& \) X: EV7-002_按键检测（软件滤波，FIFO机制）

实验目的：
" ~& R  {1 R6 r9 Y% a; y, K$ C4 t学习按键的按下，弹起，长按和组合键的实现。

实验内容：
启动一个自动重装软件定时器，每100ms翻转一次LED2。
9 ~' L* p4 ~" Y+ K
实验操作：
2 s* ]' Q. B1 y& n) ^" W3个独立按键和5向摇杆按下时均有串口消息打印。
5向摇杆的左键和右键长按时，会有连发的串口消息。
) K- Q$ o4 C% u# u, j; Q4 s独立按键K1和K2按键按下，串口打印消息。
+ _0 P+ l$ K4 h* K, r4 r
9 f! F5 _+ F: g上电后串口打印的信息：
* d8 W' U! W- P, @7 {# Z) `
波特率 115200，数据位 8，奇偶校验位无，停止位 1

' |" s/ p; ?3 L
2 O2 c7 M# Z+ L! d; C# m- K2 i% b程序设计：

  系统栈大小分配：
$ x2 |; w  O% P- r: O% Y" r) U

- [4 S; f( q" G5 S  RAM空间用的DTCM：
# _( x' W! s. l- u: K# [7 y

  r. S( m5 J+ a6 Z+ m  硬件外设初始化

- D/ @: y, Y+ Z1 R; P! r# Q* S硬件外设的初始化是在 bsp.c 文件实现：

7 l$ q) k) z/ D4 [- |

1. /*
   
2. *********************************************************************************************************
   ; _8 q; t6 ]5 m
3. *        函 数 名: bsp_Init
   ( x! b/ C+ I' T; f+ o4 Z
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   & n7 h0 x- Z4 B) a. r
9. void bsp_Init(void)
   
10. {
    5 k- u6 ^. e0 w% u# ?5 t
11.     /* 配置MPU */
    
12.         MPU_Config();
    & s" V7 n+ t5 I/ z! |; U
13.         
    
14.         /* 使能L1 Cache */
    % }5 O9 l, N2 }
15.         CPU_CACHE_Enable();
    
16. 
    
17.         /*
      j9 Z& ?0 v& Z& |
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    ) E5 B# ^- R+ K8 \. H2 y
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    5 ^4 m, P6 E& S0 L+ `+ t
20.            - 设置NVIV优先级分组为4。
    0 w% Y0 X" J2 L& R+ f9 C
21.          */
    
22.         HAL_Init();
    ; I% X* l# `% V. X
23. 
    
24.         /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    : y6 L9 x+ L" z3 c, B
29.         SystemClock_Config();
    
30. 
    
31.         /*
    . ?2 ]+ j0 y7 ]- d2 `
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    
36. #if Enable_EventRecorder == 1  
    % l1 V; z" k+ s
37.         /* 初始化EventRecorder并开启 */
    ' M- F( g6 ]: w& M8 c8 i! @
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    / {& C8 p  D1 W4 }
40. #endif
    # ~! q2 ?) f+ ?: b! \
41.         
    # v( {. u( I% `& z  I
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    . d( F( B/ N6 [4 g5 Y& O
44.         bsp_InitUart();        /* 初始化串口 */
    . g* P4 }; w! b7 C9 O5 V$ L
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    8 `; g1 U4 P- q" M' A6 U  {
46.         bsp_InitLed();            /* 初始化LED */        
    : P' \0 ^+ ?+ h/ s: z' T3 x
47. }

复制代码

9 \7 E' H6 ]" O# ]% h# i; l* x  MPU配置和Cache配置：

  }; T& m+ g$ C! O& h% ^$ A5 a+ t数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
6 E* Z5 m! L9 `! m

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   ( N" b* {" L  ~2 I3 c6 m8 @3 V
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   3 I+ D& g' u( U
9. static void MPU_Config( void )
   
10. {
    ) i( Q$ q3 E! H, \
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    6 e; k( |9 u4 E
12. 
    
13.         /* 禁止 MPU */
    ) J9 D2 T; j* l4 R& g) n/ @
14.         HAL_MPU_Disable();
    
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    7 t* n* I/ b, D! Z
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    1 a& S1 |! @" \. `# m
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    $ V' k& o4 b5 G6 I6 I& p8 ]0 I8 u8 n+ z
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
      g' t  K7 I* v/ u
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    # W) u5 z; H; M( a9 r
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    1 [1 W% _, a/ u
28. 
    2 t3 @' u" O7 \+ X  G" M
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    8 u3 @, Z4 }* {- g# F, ?
30.         
    1 ?, O& e' _4 e, z* K6 H7 M+ @
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    ' T. F/ \. m+ x7 Q. X
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    4 `2 T# L9 a: M3 k+ l
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    
47.         /*使能 MPU */
    ! b5 \* C( q0 ?# j% l
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    2 w9 l7 d$ O6 |; a+ z" a; i
50. 
    
51. /*
    
52. *********************************************************************************************************
    5 L* b3 D6 r; H. z
53. *        函 数 名: CPU_CACHE_Enable
    
54. *        功能说明: 使能L1 Cache
    : N! M! P- y' t0 \! }4 B
55. *        形    参: 无
    
56. *        返 回 值: 无
    ( ^$ \* C  v0 O7 i+ ~/ i/ a
57. *********************************************************************************************************
    & y9 d; m3 a* F4 K) `/ e9 t( t- Z% E
58. */
    9 f" S) t# ~0 p/ z- C
59. static void CPU_CACHE_Enable(void)
    
60. {
    
61.         /* 使能 I-Cache */
    " K& v7 h6 i" y
62.         SCB_EnableICache();
    8 B6 T$ ?5 U. ^, n( N
63. 
    + \' F+ Z) t( ]9 w9 T
64.         /* 使能 D-Cache */
    3 R) E0 h& V0 j7 L$ Z
65.         SCB_EnableDCache();
    
66. }

复制代码

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

按键检测是在滴答定时器中断里面实现，每10ms执行一次检测。

1. /*
   % [! X( K  O! H6 r. Q2 A( l
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_RunPer10ms
   
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   / K! y; b# k' Q; {  ]7 M
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *        形    参: 无
   
7. *        返 回 值: 无
   0 I" S& C* W  u4 o. N( i, M
8. *********************************************************************************************************
   
9. */
   
10. void bsp_RunPer10ms(void)
    2 g8 H$ ~# d# p' N! h
11. {
    + b. A+ G7 ^7 U- h8 C/ [* `% H, X
12.         bsp_KeyScan10ms();
    1 A: D3 f1 \. U* F* ^3 U6 Y
13. }

复制代码

7 ?9 Z! Z" Y% i! D: c 主功能：

主功能的实现主要分为两部分：
& n7 a7 G3 v, [( D! `4 S& a
启动一个自动重装软件定时器，每100ms翻转一次LED2
% g1 @# W& s1 r 按键消息的读取，检测到按下后，做串口打印。
9 }0 Q" _. H- @; S  n7 P

1. /*
   1 E/ Y6 J9 o: e3 Y" V3 j
2. *********************************************************************************************************
   2 {% P/ r) ~0 e# E% e- p( A
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   * ]4 v1 v# L8 K% \, C& d# ~
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   8 u8 F2 _1 O2 k
7. *********************************************************************************************************
   
8. */
   # }: n' E' \; w' Q# J
9. int main(void)
   
10. {
    7 q/ w1 W# H, U+ U) [% m
11.         uint8_t ucKeyCode;                /* 按键代码 */
    / m; n0 B$ R/ w
12.         
    
13.         bsp_Init();                /* 硬件初始化 */
    
14.         
    
15.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    / t" W5 Y5 C+ n% M7 m
16.         PrintfHelp();        /* 打印操作提示 */
    
17. 
    
18. 
    
19.         bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 */
    ' x1 ^$ [9 W4 o+ m+ C
20.         
    ( N9 n$ w4 T/ P+ u2 o
21.         /* 进入主程序循环体 */
    
22.         while (1)
    
23.         {
    
24.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
25. 
    : t6 P; S. S0 K% G. B
26.                 /* 判断定时器超时时间 */
    & ~. V7 x/ |3 q: U0 W
27.                 if (bsp_CheckTimer(0))        
    $ K  X% Z4 ^, n* `9 b! y
28.                 {
    
29.                         /* 每隔100ms 进来一次 */  
    ; |; J& v% z, g, ]  `* M* p8 Q
30.                         bsp_LedToggle(2);                        
    9 [+ C1 B; t/ w
31.                 }
    
32.                
    % X; G; {7 e- F
33.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    ( V, Y/ \* j( t* ?8 c5 y
34.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
35.                 if (ucKeyCode != KEY_NONE)
    
36.                 {
    
37.                         switch (ucKeyCode)
    ; \" M2 ~/ ^0 r: i% B2 t
38.                         {
    
39.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    
40.                                         printf("K1键按下\r\n");
    3 Y% e, M. L* \" |8 K6 W
41.                                         break;
    3 p# V/ v+ A+ g6 |3 ^0 P+ h2 j
42. 
    8 ?) Z& |# B( K7 q9 p, p9 _
43.                                 case KEY_UP_K1:                                /* K1键弹起 */
    
44.                                         printf("K1键弹起\r\n");
    6 k+ f5 `* T6 L, J
45.                                         break;
    
46. 
    
47.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    5 \8 O- ?( r* q% z" i
48.                                         printf("K2键按下\r\n");
    
49.                                         break;
    
50. 
    
51.                                 case KEY_UP_K2:                                /* K2键弹起 */
    - ^  s. }% R2 b' f) ?% o$ |& e4 N
52.                                         printf("K2键弹起\r\n");
    
53.                                         break;
    
54. 
    
55.                                 case KEY_DOWN_K3:                        /* K3键按下 */
    : M1 {4 l& p9 o0 p) o
56.                                         printf("K3键按下\r\n");
    0 G9 ~# B' x9 p# ^
57.                                         break;
    
58. 
    : C6 H" a: w8 w
59.                                 case KEY_UP_K3:                                /* K3键弹起 */
    ) M5 K. r6 `2 X% ]7 l6 {5 @
60.                                         printf("K3键弹起\r\n");
    
61.                                         break;
    5 X, `7 t# r3 S+ K* u
62. 
    
63.                                 case JOY_DOWN_U:                        /* 摇杆UP键按下 */
    
64.                                         printf("摇杆上键按下\r\n");
    
65.                                         break;
    
66. 
    
67.                                 case JOY_DOWN_D:                        /* 摇杆DOWN键按下 */
    
68.                                         printf("摇杆下键按下\r\n");
    
69.                                         break;
      V! _5 v6 K' p) i  B9 V& `' o$ o
70. 
    ' {% u, x8 y3 Q& f% y
71.                                 case JOY_DOWN_L:                        /* 摇杆LEFT键按下 */
    1 @9 `/ D- @. s; J& D
72.                                         printf("摇杆左键按下\r\n");
    ; X6 k5 j  j- i, l* U( ?
73.                                         break;
    
74.                                 
    2 u. {9 c8 i% I% K( e; z" H
75.                                 case JOY_LONG_L:            /* 摇杆LEFT键长按 */
    ; m" q+ b0 ~0 R1 b9 B" q' a2 G
76.                                         printf("摇杆左键长按\r\n");
    
77.                                         break;
    % F, g  V7 ^4 [4 W
78. 
    0 L+ T, ]( N) {% c
79.                                 case JOY_DOWN_R:                        /* 摇杆RIGHT键按下 */
    
80.                                         printf("摇杆右键按下\r\n");
    : ]7 N0 V1 C% f+ d1 I3 _! j  P
81.                                         break;
    % ]# K4 s& s# K: G0 h$ _2 D; N% f
82.                                 
    
83.                                 case JOY_LONG_R:            /* 摇杆RIGHT键长按 */
    5 D, ]- i' }- V$ c$ b
84.                                         printf("摇杆右键长按\r\n");
    
85.                                         break;
      F% t3 C# {' o# f2 T7 Y) [
86. 
    + j6 f6 b6 ~7 z8 i
87.                                 case JOY_DOWN_OK:                        /* 摇杆OK键按下 */
    ' }- ^+ y& G; s1 }6 d# m
88.                                         printf("摇杆OK键按下\r\n");
    + i% S; t1 ]- v2 V9 ~, o
89.                                         break;
    
90. 
    
91.                                 case JOY_UP_OK:                        /* 摇杆OK键弹起 */
    1 g( c( }) o1 `: F2 ^4 \  z
92.                                         printf("摇杆OK键弹起\r\n");
    2 Z# B" \9 d9 S  v) v
93.                                         break;
    
94. 
    
95.                 case SYS_DOWN_K1K2:                        /* 摇杆OK键弹起 */
    ! X9 E$ V, q/ n$ Q0 C* k) t' X
96.                                         printf("K1和K2组合键按下\r\n");
    # S" P' v8 `) j
97.                                         break;
    : y, m& O  M* z
98. 
    
99.                                 default:
    
100.                                         /* 其它的键值不处理 */
     
101.                                         break;
     
102.                         }
     
103.                
     3 V' \/ z' i7 y: V4 N# B3 [6 ?6 K
104.                 }
     2 C0 ^# i$ A8 {2 b% ^+ o* V/ o
105.         }
     / b& g+ w5 J4 Y" s
106. }

复制代码

  }' x2 ]0 G7 ~3 `9 c/ S" j19.9 总结
. f- @' {# ~) [4 V+ H. D这个方案在实际项目中已经经过千锤百炼，大家可以放心使用。建议熟练掌握其用法。

7 |& D; v+ W% E1 F" G8 D# ?