19.1 初学者重要提示
+ g2 O4 u3 \  M' i8 _ 按键FIFO驱动扩展和移植更简单，组合键也更好用。支持按下、弹起、长按和组合键。
- n  j6 k9 c# I& C
19.2 按键硬件设计
V7开发板有三个独立按键和一个五向摇杆，下面是三个独立按键的原理图：

, _5 r- t" s, Q2 h
! g( \/ X' U/ _$ M  s注意，K1（S1）、K2(S2)和K3(S3)按键的上拉电阻是接在5V电压上，因为这三个按键被复用为PS/2键盘鼠标接口，而PS/2是需要5V供电的（注，V5和V6开发板做了PS/2复用，而V7没有使用，这里只是为了兼容之前的板子）。实际测试，K1、K2、K3按键和PS/2键盘是可以同时工作的。
9 Y# u2 q: S/ T6 ~! O' ]
7 I0 `6 z( N% r- A- E8 H/ F+ _下面是五向摇杆的原理图：
/ K6 T8 q/ S4 R0 O
; D. D8 J9 W. b& m

通过这个硬件设计，有如下两个知识点为大家做介绍：
+ {6 ]2 O+ U* R. u, m8 E: W
19.2.1 硬件设计
! [) E# h" \$ @0 K5 J( U# d按键和CPU之间串联的电阻起保护作用。按键肯定是存在机械抖动的，开发板上面的硬件没有做硬件滤波处理，即使设计了硬件滤波电路，软件上还是需要进行滤波。

  保护GPIO，避免软件错误将IO设置为输出，如果设置为低电平还好，如果设置输出的是高电平，按键按下会直接跟GND(低电平)连接，从而损坏MCU。
4 m$ x% D0 W3 y7 O  保护电阻也起到按键隔离作用，这些GPIO可以直接用于其它实验。
9 c7 P! J6 K6 ^! i19.2.2 GPIO内部结构分析按键
, `- f2 E9 m6 ?+ n4 h; U详细的GPIO模式介绍，请参考第15章的15.3小节，本章仅介绍输入模式。下面我们通过一张图来简单介绍GPIO的结构。

1 g1 e* g' t& F& L

9 ]6 T$ Z. V" h: F红色的线条是GPIO输入通道的信号流向，作为按键检测IO，这些需要配置为浮空输入。按键已经做了5V上拉，因此GPIO内部的上下拉电阻都选择关闭状态。
# v# |6 i4 M0 o/ w$ q
19.3 按键FIFO的驱动设计
) E7 Y0 k5 M! \9 C4 s0 vbsp_key按键驱动程序用于扫描独立按键，具有软件滤波机制，采用FIFO机制保存键值。可以检测如下事件：
, |: a* [6 J% X8 S* N3 c
  按键按下。
) e' H0 L5 S% [2 Z  按键弹起。
2 k, H8 b# Q! [! D! t2 ]8 U  长按键。
  长按时自动连发。
我们将按键驱动分为两个部分来介绍，一部分是FIFO的实现，一部分是按键检测的实现。
( t% ?1 x; L0 d- F

5 W. s6 x" Z6 W$ g! E, Cbsp_key.c 文件包含按键检测和按键FIFO的实现代码。

4 ^! h! x3 M+ h1 I& Vbsp.c 文件会调用bsp_InitKey()初始化函数。
  P7 X$ a. D  ]) j
bsp.c 文件会调用bsp_KeyScan按键扫描函数。

7 N' a7 _6 R$ v1 Y' absp_timer.c 中的Systick中断服务程序调用 bsp_RunPer10ms。

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

8 G; U6 m" e& P, u6 S  i函数调用关系图：

% m& n* k, `( z6 l+ O; i
19.3.1 按键FIFO的原理
FIFO是First Input First Output的缩写，先入先出队列。我们这里以5个字节的FIFO空间进行说明。Write变量表示写位置，Read变量表示读位置。初始状态时，Read = Write = 0。

我们依次按下按键K1，K2，那么FIFO中的数据变为：
* v) u' V! [5 E$ n* {2 a  d
8 g4 F' B, x# f

如果Write！= Read，则我们认为有新的按键事件。
$ Q! T) T2 ?8 i% W* R) O9 X  U
; T' Z+ X' V. Q; R& B我们通过函数bsp_GetKey读取一个按键值进行处理后，Read变量变为1。Write变量不变。
9 ]: j5 w+ c" x5 s7 o! K
0 A# o7 m* Q; o& u

+ N; u4 X0 p% _7 _* I
我们继续通过函数bsp_GetKey读取3个按键值进行处理后，Read变量变为4。此时Read = Write = 4。两个变量已经相等，表示已经没有新的按键事件需要处理。
9 D5 q  l6 v* V0 v
8 K3 q* w" C9 L% _9 A; |有一点要特别的注意，如果FIFO空间写满了，Write会被重新赋值为0，也就是重新从第一个字节空间填数据进去，如果这个地址空间的数据还没有被及时读取出来，那么会被后来的数据覆盖掉，这点要引起大家的注意。我们的驱动程序开辟了10个字节的FIFO缓冲区，对于一般的应用足够了。

设计按键FIFO主要有三个方面的好处：
7 r2 W0 H% ]( u0 G
( v4 w& H: u, \" |  可靠地记录每一个按键事件，避免遗漏按键事件。特别是需要实现按键的按下、长按、自动连发、弹起等事件时。
  读取按键的函数可以设计为非阻塞的，不需要等待按键抖动滤波处理完毕。
6 L# A8 s; _8 y4 _+ T$ {  按键FIFO程序在嘀嗒定时器中定期的执行检测，不需要在主程序中一直做检测，这样可以有效地降低系统资源消耗。
1 s$ q; G- _. P
19.3.2 按键FIFO的实现
$ D) l9 ?- \3 D1 E在bsp_key.h 中定了结构体类型KEY_FIFO_T。这只是类型声明，并没有分配变量空间。
! c: n9 Z6 I: ^* D/ o( z* `

1. #define KEY_FIFO_SIZE        10
   
2. typedef struct
   + f  c; g2 y- E+ O
3. {
   : |2 l4 D$ x/ F
4.         uint8_t Buf[KEY_FIFO_SIZE];                /* 键值缓冲区 */
   4 m. {. O  b$ G0 g
5.         uint8_t Read;                                        /* 缓冲区读指针1 */
   2 V& Q9 f! M, {2 O0 Y
6.         uint8_t Write;                             /* 缓冲区写指针 */
   ' T5 D8 m" e/ P
7.         uint8_t Read2;                             /* 缓冲区读指针2 */
   : a* n7 b; I2 h& g. _& B( K1 x
8. }KEY_FIFO_T;

复制代码

1 F7 L5 B! }' ^; ]  H在bsp_key.c 中定义s_tKey结构变量, 此时编译器会分配一组变量空间。
( V1 G& N3 i3 [

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

复制代码

一般情况下，只需要一个写指针Write和一个读指针Read。在某些情况下，可能有两个任务都需要访问按键缓冲区，为了避免键值被其中一个任务取空，我们添加了第2个读指针Read2。出厂程序在bsp_Idle()函数中实现的按K1K2组合键截屏的功能就使用的第2个读指针。
6 ], z( B* s9 x- p! E
* @% m' W( h6 t/ T4 t! V当检测到按键事件发生后，可以调用 bsp_PutKey函数将键值压入FIFO。下面的代码是函数的实现：
1 ^* Z5 p( ~8 c* \4 Q2 {

1. /*
   
2. *********************************************************************************************************
   : d. L% O. x+ ]" h( M0 x' v0 Y4 D
3. *        函 数 名: bsp_PutKey
   
4. *        功能说明: 将1个键值压入按键FIFO缓冲区。可用于模拟一个按键。
   # j1 p, ~7 t2 z
5. *        形    参: _KeyCode : 按键代码
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   7 @( I$ C2 o' s8 z
8. */
   
9. void bsp_PutKey(uint8_t _KeyCode)
   
10. {
    
11.         s_tKey.Buf[s_tKey.Write] = _KeyCode;
    * U# L4 c! N) W4 B% S5 G
12. 
    
13.         if (++s_tKey.Write  >= KEY_FIFO_SIZE)
    5 s5 T6 B- {7 c9 `  ]
14.         {
    1 \2 ~  J% c9 l% y
15.                 s_tKey.Write = 0;
    / c0 S# }4 I  K. A$ y* c0 M3 r
16.         }
    + z. f8 H0 k- G2 U+ A$ |5 `4 g6 R
17. }

复制代码

- {" m1 V7 L$ c7 c5 ~  F, F这个bsp_PutKey函数除了被按键检测函数调用外，还可以被其他底层驱动调用。比如红外遥控器的按键检测，也共用了同一个按键FIFO。遥控器的按键代码和主板实体按键的键值统一编码，保持键值唯一即可实现两套按键同时控制程序的功能。
- K2 ?$ ?" m" o' s* o# [
& e! j% W( k, c8 B/ |) {应用程序读取FIFO中的键值，是通过bsp_GetKey函数和bsp_GetKey2函数实现的。我们来看下这两个函数的实现：

+ y7 C/ Z& P7 F0 C8 Y

1. /*
   8 d5 ^$ r" d5 b& e2 B$ E( u5 w" ~
2. *********************************************************************************************************
   * G1 b  T  [' O9 W7 o3 p
3. *        函 数 名: bsp_GetKey
   
4. *        功能说明: 从按键FIFO缓冲区读取一个键值。
   
5. *        形    参:  无
   
6. *        返 回 值: 按键代码
   
7. *********************************************************************************************************
   
8. */
   
9. uint8_t bsp_GetKey(void)
   
10. {
    ( @. j0 T- M% L6 Q/ k2 Q# ?0 y
11.         uint8_t ret;
    " @, }1 k  w0 B" c6 n+ _" ]
12. 
    % g) `" {" R% Q
13.         if (s_tKey.Read == s_tKey.Write)
    0 a* h9 A& }  W
14.         {
    
15.                 return KEY_NONE;
    ) N  m0 f  Y5 g/ z2 T4 T/ B
16.         }
    ( V8 H. S5 F6 Q- u
17.         else
    
18.         {
    3 f& p5 C6 X  b- z) ^% Z
19.                 ret = s_tKey.Buf[s_tKey.Read];
    ! w1 _% {; q$ x4 W0 O
20. 
    
21.                 if (++s_tKey.Read >= KEY_FIFO_SIZE)
    9 N& h, c4 U+ ^& o9 d7 I! X9 Z
22.                 {
    
23.                         s_tKey.Read = 0;
    
24.                 }
    & y: U! _3 o9 F9 ?) b5 u
25.                 return ret;
    
26.         }
    
27. }
    
28. 
    % F0 u% Q) d0 a* Z# K. J" C
29. /*
    2 R2 X( a' v: V. @1 ?
30. *********************************************************************************************************
    
31. *        函 数 名: bsp_GetKey2
    % ?4 x* N+ ]& T; T+ l# }
32. *        功能说明: 从按键FIFO缓冲区读取一个键值。独立的读指针。
    
33. *        形    参:  无
    3 R" @3 F& W( q/ a4 [1 K
34. *        返 回 值: 按键代码
    
35. *********************************************************************************************************
    
36. */
    
37. uint8_t bsp_GetKey2(void)
    0 \, E8 f. M6 z) I
38. {
    
39.         uint8_t ret;
    
40. 
    4 p+ ~3 H& ?. I! Q  v' S
41.         if (s_tKey.Read2 == s_tKey.Write)
    9 u4 y& u. D' p& Z3 g+ x7 T9 q
42.         {
    
43.                 return KEY_NONE;
    
44.         }
    
45.         else
    
46.         {
    
47.                 ret = s_tKey.Buf[s_tKey.Read2];
    8 T9 |2 m8 s/ t7 n9 j
48. 
    
49.                 if (++s_tKey.Read2 >= KEY_FIFO_SIZE)
    / w# n5 ?! t' c
50.                 {
    
51.                         s_tKey.Read2 = 0;
    
52.                 }
    . P4 |; r5 H4 {; A5 J8 V% H" ~( b
53.                 return ret;
    
54.         }
    . u( D7 x( r* ]5 ]4 i
55. }

复制代码

, B5 u; N0 K' D# L返回值KEY_NONE = 0, 表示按键缓冲区为空，所有的按键时间已经处理完毕。按键的键值定义在 bsp_key.h文件，下面是具体内容：
& o' M8 x3 l5 Y9 p
; S7 U- z9 M2 v2 O. C6 H4 T  T

1. typedef enum
   . o( P0 N" u3 O  \1 J% {
2. {
   
3.         KEY_NONE = 0,                        /* 0 表示按键事件 */
   ' ?6 n( @6 e! w4 }0 v7 B! ]
4. 
   4 P' @- @! e( _% U: d0 G3 _$ Y, }
5.         KEY_1_DOWN,                        /* 1键按下 */
   , k- m. G( \: }- i
6.         KEY_1_UP,                                /* 1键弹起 */
   * d1 u+ R* a* J) @
7.         KEY_1_LONG,                        /* 1键长按 */
   
8. 
   
9.         KEY_2_DOWN,                        /* 2键按下 */
   . m" c+ e3 Q0 N2 n1 H/ s1 N
10.         KEY_2_UP,                                /* 2键弹起 */
    4 u: M  h# m0 ~$ d# O
11.         KEY_2_LONG,                        /* 2键长按 */
    
12. 
    
13.         KEY_3_DOWN,                        /* 3键按下 */
    : ^* a* _" }* `4 V. S
14.         KEY_3_UP,                                /* 3键弹起 */
    
15.         KEY_3_LONG,                        /* 3键长按 */
    
16. 
    
17.         KEY_4_DOWN,                        /* 4键按下 */
    " U+ G# M) w* ~& G2 I0 l7 z# F& s
18.         KEY_4_UP,                                /* 4键弹起 */
    
19.         KEY_4_LONG,                        /* 4键长按 */
    ) ?! j1 f3 U, f9 d; |9 G
20. 
    
21.         KEY_5_DOWN,                        /* 5键按下 */
    % Y; k' _7 h1 {+ O( Q
22.         KEY_5_UP,                                /* 5键弹起 */
    3 z  K1 P0 Q# Z/ U
23.         KEY_5_LONG,                        /* 5键长按 */
    ! R3 M9 ?* r7 [8 U
24. 
    
25.         KEY_6_DOWN,                        /* 6键按下 */
    ( |2 @/ d8 l8 Z2 {4 O
26.         KEY_6_UP,                                /* 6键弹起 */
    ( m( E2 V8 H8 `$ ?  }
27.         KEY_6_LONG,                        /* 6键长按 */
    
28. 
    ; G7 L( a' |  s: ^( K  B9 |$ Z
29.         KEY_7_DOWN,                        /* 7键按下 */
    
30.         KEY_7_UP,                                /* 7键弹起 */
    " W6 U& \* P: ?) E  j1 ?
31.         KEY_7_LONG,                        /* 7键长按 */
    # D6 ~+ i5 v, b( V3 `
32. 
    
33.         KEY_8_DOWN,                        /* 8键按下 */
    
34.         KEY_8_UP,                                /* 8键弹起 */
    
35.         KEY_8_LONG,                        /* 8键长按 */
    
36. 
    
37.         /* 组合键 */
    ( X: H" Y* f/ A3 d5 M) j& X
38.         KEY_9_DOWN,                        /* 9键按下 */
    + A/ w1 T  f) e. ^4 \" a0 L
39.         KEY_9_UP,                                /* 9键弹起 */
    % A. p: E% W# ~; R: ]7 ~0 ]* J
40.         KEY_9_LONG,                        /* 9键长按 */
    
41. 
    ( N/ _# K5 M3 K
42.         KEY_10_DOWN,                        /* 10键按下 */
    2 z5 O: a. q0 N( r5 W3 T5 l6 ]
43.         KEY_10_UP,                        /* 10键弹起 */
    4 g" j. Q; F/ x$ _" h" z9 i- E8 z
44.         KEY_10_LONG,                        /* 10键长按 */
    
45. }KEY_ENUM;

复制代码

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

  便于新增键值,方便调整顺序。
- P; ]3 j% D! R2 y* A9 b  使用{ } 将一组相关的定义封装起来便于理解。
* T* B8 h( Y5 @) r. j7 K  编译器可帮我们避免键值重复。
我们来看红外遥控器的键值定义，在bsp_ir_decode.h文件。因为遥控器按键和主板按键共用同一个FIFO，因此在这里我们先贴出这段定义代码，让大家有个初步印象。

+ k! O# k2 ?/ V

1. /* 定义红外遥控器按键代码, 和bsp_key.h 的物理按键代码统一编码 */
   
2. typedef enum
   
3. {
   0 @- @4 c% n/ n/ d$ {* Z: R
4.         IR_KEY_STRAT         = 0x80,
   
5.         IR_KEY_POWER         = IR_KEY_STRAT + 0x45,
   
6.         IR_KEY_MENU         = IR_KEY_STRAT + 0x47,
   # v1 E& o; n' W
7.         IR_KEY_TEST         = IR_KEY_STRAT + 0x44,
   + p/ P$ c7 m: x2 e5 x! F' m
8.         IR_KEY_UP         = IR_KEY_STRAT + 0x40,
   
9.         IR_KEY_RETURN        = IR_KEY_STRAT + 0x43,
   
10.         IR_KEY_LEFT        = IR_KEY_STRAT + 0x07,
    
11.         IR_KEY_OK                = IR_KEY_STRAT + 0x15,
    7 m; V( P$ v6 I0 D: @
12.         IR_KEY_RIGHT        = IR_KEY_STRAT + 0x09,
    1 E. r% F* v, h  n  _3 r
13.         IR_KEY_0                = IR_KEY_STRAT + 0x16,
    ( {! S! u9 {; A. U: D& X0 [6 ^
14.         IR_KEY_DOWN        = IR_KEY_STRAT + 0x19,
    1 J/ l. j' e* {' O
15.         IR_KEY_C                = IR_KEY_STRAT + 0x0D,
    
16.         IR_KEY_1                = IR_KEY_STRAT + 0x0C,
    
17.         IR_KEY_2                = IR_KEY_STRAT + 0x18,
    . p/ M. k9 N: Q( W) W
18.         IR_KEY_3                = IR_KEY_STRAT + 0x5E,
    * _$ _; N# |$ K( K
19.         IR_KEY_4                = IR_KEY_STRAT + 0x08,
    
20.         IR_KEY_5                = IR_KEY_STRAT + 0x1C,
    5 h2 u) T; C! g% r; K
21.         IR_KEY_6                = IR_KEY_STRAT + 0x5A,
    
22.         IR_KEY_7                = IR_KEY_STRAT + 0x42,
    - q3 B; W7 Y  L+ [; y% D$ r2 c1 ?& H
23.         IR_KEY_8                = IR_KEY_STRAT + 0x52,
    
24.         IR_KEY_9                = IR_KEY_STRAT + 0x4A,        
    - F. m' H( y. ]
25. }IR_KEY_E;

复制代码

% e# @2 s! w& ]% o" D& S) D) s. l我们下面来看一段简单的应用。这个应用的功能是：主板K1键控制LED1指示灯；遥控器的POWER键和MENU键控制LED2指示灯。
7 x0 s, G8 ?" Q( b& ]

1. #include "bsp.h"
   3 h4 H. }" k3 \7 Y/ O  v
2. 
   ) L. `! v) ]0 V! A
3. int main(void)
   
4. {
   1 q- V- S+ ^% G* i
5.         uint8_t ucKeyCode;
   ) m: G; x2 `* I* G0 y$ S9 _) N
6.                         
   
7.         bsp_Init();
   . F# C$ q/ Z. u- h' g' d! Y. v& Z) \/ G
8. 
   
9.         IRD_StartWork();        /* 启动红外解码 */
   
10. 
    ! @" K- t! }4 I4 q
11.         while(1)
    " ]/ f" R8 |- _
12.         {
    
13.                 bsp_Idle();
    
14.                
    
15.                 /* 处理按键事件 */
    
16.                 ucKeyCode = bsp_GetKey();
    & h1 N5 [, d8 i/ m! }
17.                 if (ucKeyCode > 0)
    ; W/ s' U7 n, p# L, k: a
18.                 {
    
19.                         /* 有键按下 */
    
20.                         switch (ucKeyCode)
    
21.                         {
    : T3 ]6 j4 n7 z
22.                                 case KEY_DOWN_K1:                /* K1键按下 */
    0 C2 F" t! w3 I+ E7 Y0 K
23.                                         bsp_LedOn(1);                /* 点亮LED1 */
    . Q5 Z  R. p5 u) |
24.                                         break;
    6 @% K' v$ K% l5 J" h9 H$ X- t- E
25. 
    
26.                                 case KEY_UP_K1:                /* K1键弹起 */
    4 m8 D+ M' N( _5 {( l
27.                                         bsp_LedOff(1);        /* 熄灭LED1 */
    8 ^, U( @! [, `4 A
28.                                         break;                                       
    
29. 
    ) p4 u) C6 \! s- t
30.                                 case IR_KEY_POWER:                /* 遥控器POWER键按下 */
    0 K. O7 f* B- n. O
31.                                         bsp_LedOn(1);                /* 点亮LED2 */
    6 b; g. @+ e3 i
32.                                         break;
    , y/ c2 L' C" a  n" h- I, m! |
33. 
    
34.                                 case IR_KEY_MENU:                /* 遥控器MENU键按下 */
    
35.                                         bsp_LedOff(1);        /* 熄灭LED2 */
    
36.                                         break;                                       
    
37. 
    # }0 B: x3 _( b/ L
38.                                 case MSG_485_RX:                /* 通信程序的发来的消息 */
    1 q# ?  D( ~4 L1 q, K
39.                                         /* 执行通信程序的指令 */
    - T, q# i! y; C
40.                                         break;
    4 D; _3 ?9 l2 d- [8 w; U0 I
41. 
    , q# P" i- H+ s( K  A: X
42.                                 default:
    
43.                                         break;
    
44.                         }
    
45.                 }
    ; \: G% \' N, z) Z8 f- b9 J2 \
46.         }
    7 B9 E  w# @' b! E- ^2 W: v
47. }

复制代码

* {8 r+ r& `3 L2 C  u5 _看到这里，想必你已经意识到bsp_PutKey函数的强大之处了，可以将不相关的硬件输入设备统一为一个相同的接口函数。

0 c' g; j3 Z/ }. `' K在上面的应用程序中，我们特意添加了一段红色的代码来解说更高级的用法。485通信程序收到有效的命令后通过 bsp_PutKey（MSG_485_RX）函数可以通知APP应用程序进行进一步加工处理（比如显示接收成功）。这是一种非常好的任务间信息传递方式，它不会破坏程序结构。不必新增全局变量来做这种事情，你只需要添加一个键值代码。
- A6 }5 `- W/ h- j9 @9 l8 l
对于简单的程序，可以借用按键FIFO来进行少量的信息传递。对于复杂的应用，我们推荐使用bsp_msg专门来做这种任务间的通信。因为bsp_msg除了传递消息代码外，还可以传递参数结构。
  |; q! I9 n- T, P3 ]
19.3.3 按键检测程序分析
在bsp_key.h 中定了结构体类型KEY_T。
* M" r6 X+ s  I' b" L
) I& y  r: N- ~6 T' ^5 m# p

1. #define KEY_COUNT    10                           /* 按键个数, 8个独立建 + 2个组合键 */
   . b3 \& [/ [; Y, @
2. 
   
3. typedef struct
   % F; I' k% q% x$ J
4. {
   ( S* @$ w1 [$ _  K% V, z! W
5.         /* 下面是一个函数指针，指向判断按键手否按下的函数 */
   
6.         uint8_t (*IsKeyDownFunc)(void); /* 按键按下的判断函数,1表示按下 */
   ( R0 k' ?  Q% y" D; K3 u( f* G8 J
7. 
   
8.         uint8_t  Count;                /* 滤波器计数器 */
   
9.         uint16_t LongCount;        /* 长按计数器 */
   
10.         uint16_t LongTime;                /* 按键按下持续时间, 0表示不检测长按 */
    
11.         uint8_t  State;                /* 按键当前状态（按下还是弹起） */
    " e8 v- P: s7 H+ x9 o/ V! c
12.         uint8_t  RepeatSpeed;        /* 连续按键周期 */
    
13.         uint8_t  RepeatCount;        /* 连续按键计数器 */
      h+ h$ v9 U0 y1 w/ X4 A1 j
14. }KEY_T;

复制代码

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

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

复制代码

8 |9 I  |- F( t( a; Y每个按键对象都分配一个结构体变量，这些结构体变量以数组的形式存在将便于我们简化程序代码行数。

) w, Z$ b, V1 i使用函数指针IsKeyDownFunc可以将每个按键的检测以及组合键的检测代码进行统一管理。

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

  e# i9 z2 n7 L6 z. M9 l; b. [3 V4 g

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_InitKey
   
4. *        功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
   * W0 I" F( j3 n6 C
5. *        形    参: 无
   
6. *        返 回 值: 无
   4 A9 \" Z- d  U) ~- o; K2 ?
7. *********************************************************************************************************
   / N% y% Y0 N" Y- f% O) y+ _  B
8. */
   - l9 W% f1 S$ y1 W  s- i) \5 i
9. void bsp_InitKey(void)
   
10. {
    
11.         bsp_InitKeyVar();                /* 初始化按键变量 */
    
12.         bsp_InitKeyHard();                /* 初始化按键硬件 */
    
13. }

复制代码

下面是bsp_InitKeyVar函数的定义：

9 d! z% ?7 P9 i2 O1 r4 d) H

1. /*
   4 d. g0 l7 m- S* _
2. *********************************************************************************************************
   0 [, C% f0 m+ Q1 D2 }
3. *        函 数 名: bsp_InitKeyVar
   
4. *        功能说明: 初始化按键变量
   8 v- k. M* l' `2 X
5. *        形    参:  无
   ' M8 n- J2 s, @( P9 H% C4 J; Y( x
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   5 B; Q3 ^9 L' F3 A' {
9. static void bsp_InitKeyVar(void)
   / A( z. E6 `% F" o# J: E, h2 u  O4 t
10. {
    1 P. c2 \8 h4 o% H+ y
11.         uint8_t i;
    ( o6 L" W1 d' b) b
12. 
    
13.         /* 对按键FIFO读写指针清零 */
    
14.         s_tKey.Read = 0;
    
15.         s_tKey.Write = 0;
    4 A* P6 ~2 V6 K' f
16.         s_tKey.Read2 = 0;
    + [$ L6 l2 _+ Y
17. 
    
18.         /* 给每个按键结构体成员变量赋一组缺省值 */
    + w# M, W: g2 O! c# p& ~
19.         for (i = 0; i < KEY_COUNT; i++)
    8 r' g0 V9 A) B& d& p  S+ q2 O. M
20.         {
    4 ]+ x& I, j: {) J5 F
21.                 s_tBtn<i>.LongTime = KEY_LONG_TIME;                        /* 长按时间 0 表示不检测长按键事件 */</i>
    
22. <span style="font-style: italic;">                s_tBtn.Count = KEY_FILTER_TIME / 2;                /* 计数器设置为滤波时间的一半 */
    
23.                 s_tBtn<span style="font-style: italic;">.State = 0;                                                /* 按键缺省状态，0为未按下 */
    
24.                 s_tBtn<span style="font-style: italic;">.RepeatSpeed = 0;                                        /* 按键连发的速度，0表示不支持连发 */
    
25.                 s_tBtn<i style="font-style: italic;">.RepeatCount = 0;                                        /* 连发计数器 */
    
26.      </i><span style="font-style: normal;">   }
    6 A5 s" R. Q+ `! e  S- a2 H1 Z
27. 
    2 P" @1 S. |% @+ h$ _, Y/ p
28.         /* 如果需要单独更改某个按键的参数，可以在此单独重新赋值 */
    
29.         
    - @5 S. F9 ]$ o* P
30.         /* 摇杆上下左右，支持长按1秒后，自动连发 */
    
31.         bsp_SetKeyParam(KID_JOY_U, 100, 6);
    
32.         bsp_SetKeyParam(KID_JOY_D, 100, 6);
    " q+ c) `' i* n' ^6 J
33.         bsp_SetKeyParam(KID_JOY_L, 100, 6);
    
34.         bsp_SetKeyParam(KID_JOY_R, 100, 6);
    * q  `; I1 o: j  G5 a; V) y
35. }</span></span></span></span>

复制代码

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

4 o/ h  B% Z! A8 Z7 s2 T

1. /*
   
2.         按键滤波时间50ms, 单位10ms。
   
3.         只有连续检测到50ms状态不变才认为有效，包括弹起和按下两种事件
   & g& C+ @6 z. H2 {# `9 q0 `& p. l" s1 v
4.         即使按键电路不做硬件滤波，该滤波机制也可以保证可靠地检测到按键事件
   
5. */
   
6. #define KEY_FILTER_TIME   5
   , Q2 ]( E( s& R! \
7. #define KEY_LONG_TIME     100                        /* 单位10ms， 持续1秒，认为长按事件 */

复制代码

uint8_t KeyPinActive(uint8_t _id)（会调用函数KeyPinActive判断状态）函数就是最底层的GPIO输入状态判断函数。
6 _+ }% G4 `# M' ?- y' c
/ b7 i3 E, b, b

1. /*
   ( W% X: S, d1 w. M5 ]
2. *********************************************************************************************************
   
3. *        函 数 名: KeyPinActive
   * d" ^- I: D* K
4. *        功能说明: 判断按键是否按下
   
5. *        形    参: 无
   
6. *        返 回 值: 返回值1 表示按下(导通），0表示未按下（释放）
   - R0 [& h: z# Y. ]% A
7. *********************************************************************************************************
   
8. */
   % F1 p( O5 b: M4 ]0 M
9. static uint8_t KeyPinActive(uint8_t _id)
   * g$ C2 h+ C' `$ u0 |
10. {
    ( i+ e1 {3 X& C0 i1 O
11.         uint8_t level;
    ! H$ x  D# K* y% u4 T
12.         
    3 U( @6 C* U, @, u- b
13.         if ((s_gpio_list[_id].gpio->IDR & s_gpio_list[_id].pin) == 0)
    
14.         {
    
15.                 level = 0;
    
16.         }
    
17.         else
    
18.         {
    5 m' F- m& s* p' k  O2 e8 s5 I' U* u
19.                 level = 1;
    
20.         }
    4 W6 L$ `, ^  s3 E6 b! p  Q4 B" z/ i
21. 
    
22.         if (level == s_gpio_list[_id].ActiveLevel)
    5 f1 A) ?; I3 w: Y0 ~, Y6 o
23.         {
    1 E- z5 v5 s) o/ N# Q/ I
24.                 return 1;
    9 v# J& l3 x- b( h
25.         }
    % l0 E$ ~+ W) i" {
26.         else
    
27.         {
    
28.                 return 0;
    
29.         }
    3 a  |: b  O+ h% Z: i
30. }
    
31. 
    
32. /*
    9 X& {* B- }$ r  g0 E4 V! ~! e
33. *********************************************************************************************************
    + T, c6 l5 `/ J& r1 U" m' H
34. *        函 数 名: IsKeyDownFunc
    " H; s4 `2 U' ]3 W7 d
35. *        功能说明: 判断按键是否按下。单键和组合键区分。单键事件不允许有其他键按下。
    
36. *        形    参: 无
    
37. *        返 回 值: 返回值1 表示按下(导通），0表示未按下（释放）
    
38. *********************************************************************************************************
    & ^/ g$ z& I/ ~) p% i& y7 g
39. */
    
40. static uint8_t IsKeyDownFunc(uint8_t _id)
    % N: n8 Q" c; R1 T
41. {
    
42.         /* 实体单键 */
    
43.         if (_id < HARD_KEY_NUM)
    ! |( X# c3 @* g1 }/ J' E2 u3 R
44.         {
    
45.                 uint8_t i;
    0 V  p% O, a/ i4 U* m
46.                 uint8_t count = 0;
    : E" e0 q1 q, G% H+ g7 w0 `
47.                 uint8_t save = 255;
    
48.                
    
49.                 /* 判断有几个键按下 */
    : C4 F. @4 F1 Y2 c+ W- Q( C
50.                 for (i = 0; i < HARD_KEY_NUM; i++)
    ! `; c+ h+ H' I9 ?# Y  v; h4 v& |3 ~$ C
51.                 {
    
52.                         if (KeyPinActive(i))
    : m7 u( G% ^' s/ o
53.                         {
    
54.                                 count++;
    & |5 h1 W) k! {4 I. |6 _7 }" h
55.                                 save = i;
    
56.                         }
    7 `4 \4 l9 t3 ]4 z' ?  ?4 P1 ?# w
57.                 }
    
58.                
    7 _8 s  ~  t# X, ?) K" a  r
59.                 if (count == 1 && save == _id)
    
60.                 {
    
61.                         return 1;        /* 只有1个键按下时才有效 */
    
62.                 }               
    8 e7 {0 o: J# _0 b8 O
63. 
    
64.                 return 0;
    
65.         }
    + ^4 q$ p& w* F* W  @$ M
66.         
    6 v' R1 W" \: R: u! ]3 T5 t, J
67.         /* 组合键 K1K2 */
    
68.         if (_id == HARD_KEY_NUM + 0)
    ' `2 z6 p8 a- d* U, A
69.         {
    / @5 G$ v& ]/ x- w8 a- d: j
70.                 if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
    
71.                 {
    0 r5 t; p* j5 E* U3 w
72.                         return 1;
    
73.                 }
    ! ^9 r+ _: Z- ?, i7 _) H. P! P4 f
74.                 else
    
75.                 {
    
76.                         return 0;
    1 h% m' |- q2 D" d% [
77.                 }
    
78.         }
    " G$ t' H5 m7 o" G! N, h' _: M
79. 
    4 o9 r3 y& c0 ^5 I/ V4 f  |
80.         /* 组合键 K2K3 */
    ' q+ e2 X4 j+ u- l
81.         if (_id == HARD_KEY_NUM + 1)
    . k" a7 l1 Z6 a8 [7 Y
82.         {
    
83.                 if (KeyPinActive(KID_K2) && KeyPinActive(KID_K3))
    
84.                 {
    5 l; d' ^4 L* w; y
85.                         return 1;
    
86.                 }
    / J! O. _5 s2 ~' ^" J! T1 J, {
87.                 else
    7 h/ M) b) \  v1 j
88.                 {
    
89.                         return 0;
    4 P  W  Y# F" J4 U7 e" ]; c* g5 W
90.                 }
    0 [0 b! X  W' [( p2 n0 t5 J& u
91.         }
    
92. 
    
93.         return 0;
    6 Q  e5 g  t( K; L
94. }

复制代码

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

1 D2 s- Y+ K0 P! q6 ]- v

1. /*
   
2. *********************************************************************************************************
   . S3 O' B. I+ L% y  D" [7 f2 `" D# ]
3. *        函 数 名: bsp_InitKeyHard
   
4. *        功能说明: 配置按键对应的GPIO
   
5. *        形    参:  无
   ( z' |( S% C4 t% L, ]
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   1 x2 V+ K- h4 i+ h
9. static void bsp_InitKeyHard(void)
   # M% P  ?' A2 ^
10. {        
    
11.         GPIO_InitTypeDef gpio_init;
    
12.         uint8_t i;
    . V" e) b$ E$ w" R
13. 
    
14.         /* 第1步：打开GPIO时钟 */
    ) o! V" s# m8 r1 [+ ^; @
15.         ALL_KEY_GPIO_CLK_ENABLE();
    
16.         
    
17.         /* 第2步：配置所有的按键GPIO为浮动输入模式(实际上CPU复位后就是输入状态) */
    " O6 c- r& k7 u4 P# l7 e9 g4 l* C
18.         gpio_init.Mode = GPIO_MODE_INPUT;                           /* 设置输入 */
    
19.         gpio_init.Pull = GPIO_NOPULL;                 /* 上下拉电阻不使能 */
    
20.         gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;  /* GPIO速度等级 */
    " K% C0 e' `8 E' S1 i3 G
21.         
    
22.         for (i = 0; i < HARD_KEY_NUM; i++)
    ; ?3 K$ j. R6 N# v( d: a5 S3 N
23.         {
    
24.                 gpio_init.Pin = s_gpio_list<span style="font-style: italic;"><span style="font-style: normal;">.pin;
    4 X; F* O! o  m1 D* m/ O3 }* U& n' m
25.                 HAL_GPIO_Init(s_gpio_list</span><span style="font-style: normal;">.gpio, &gpio_init);        
    
26.         }
    
27. }</span></span>

复制代码

我们再来看看按键是如何执行扫描检测的。

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

1. void bsp_RunPer10ms(void)
   % s0 ]' G; y0 v/ i
2. {
   $ ]3 m, ]( K( C+ Z0 i2 M4 X
3.         bsp_KeyScan10ms();                /* 扫描按键 */
   " h8 x, m* G8 h0 U; ^& o
4. }

复制代码

bsp_KeyScan10ms ()函数的实现如下：

; V* f' R5 s( x; y5 A

1. /*
     k: `* p6 _0 C+ h8 W% I$ w
2. *********************************************************************************************************
   7 E$ B& ]8 b. n8 }
3. *        函 数 名: bsp_KeyScan10ms
   
4. *        功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
   : G/ p9 \; f0 N, A3 x
5. *        形    参: 无
   
6. *        返 回 值: 无
   8 Z1 h/ Q+ L4 |7 N
7. *********************************************************************************************************
   1 U2 f8 l) P+ D/ I4 R8 c  f, U" {
8. */
   $ ^5 t5 T/ M2 F* j) w4 J+ f( B  }: l
9. void bsp_KeyScan10ms(void)
   
10. {
    
11.         uint8_t i;
    
12. 
    
13.         for (i = 0; i < KEY_COUNT; i++)
    
14.         {
    
15.                 bsp_DetectKey(i);
    
16.         }
    , ~8 N! ~, l4 S% D6 o0 m0 Q1 }1 y  p
17. }

复制代码

每隔10ms所有的按键GPIO均会被扫描检测一次。bsp_DetectKey函数实现如下：
$ V9 _5 p9 z/ c& m" j8 `
6 ~1 K9 R1 y9 c7 y) S

1. /*
   , r( E0 p! p$ k/ B1 S5 q% o) h
2. *********************************************************************************************************
   2 Z/ T# ~: I% @7 @' K* T5 o5 C- ^
3. *        函 数 名: bsp_DetectKey
   - N# ]. _6 i3 F$ o2 w( A
4. *        功能说明: 检测一个按键。非阻塞状态，必须被周期性的调用。
   
5. *        形    参: IO的id， 从0开始编码
   
6. *        返 回 值: 无
   1 ~# H$ Y, W. {% q
7. *********************************************************************************************************
   
8. */
   
9. static void bsp_DetectKey(uint8_t i)
   ) Q' m; K) F8 \# Y. _
10. {
    
11.         KEY_T *pBtn;
    7 T" W, A$ C; F! U1 l' I- D
12. 
    " N  h/ z0 a$ B, z9 o1 q
13.         pBtn = &s_tBtn<span style="font-style: italic;"><span style="font-style: normal;">;
    
14.         if (IsKeyDownFunc(i))
    
15.         {
    - h0 B- |" u5 z. L+ H- W
16.                 if (pBtn->Count < KEY_FILTER_TIME)
    
17.                 {
    1 Z$ q" {6 d: x, B
18.                         pBtn->Count = KEY_FILTER_TIME;
    
19.                 }
    
20.                 else if(pBtn->Count < 2 * KEY_FILTER_TIME)
    $ V% Z" @; j% ^" g
21.                 {
    
22.                         pBtn->Count++;
    ( z4 K( e: u6 Q
23.                 }
    
24.                 else
    5 L4 a4 t4 q# P4 I
25.                 {
    ) c5 D: ~5 }1 M0 r9 }. f8 U4 g- O7 `
26.                         if (pBtn->State == 0)
    
27.                         {
    7 k1 h8 C: R  l: A6 \( V* F
28.                                 pBtn->State = 1;
    : b- _7 y0 ]. R
29. 
    ! T+ o/ \9 n- r1 @3 Y5 s1 s& N
30.                                 /* 发送按钮按下的消息 */
    
31.                                 bsp_PutKey((uint8_t)(3 * i + 1));
    - n8 u. z% P, h' T8 h5 |! l+ ^
32.                         }
    
33. 
    
34.                         if (pBtn->LongTime > 0)
    
35.                         {
    0 R: v+ U- p3 ]6 G! j' Q. Y. s" A
36.                                 if (pBtn->LongCount < pBtn->LongTime)
    6 g" i8 e! h4 }
37.                                 {
    - U* O- \8 [, f- H$ l" T
38.                                         /* 发送按钮持续按下的消息 */
    
39.                                         if (++pBtn->LongCount == pBtn->LongTime)
      ?5 C% f" Z0 ~, W
40.                                         {
    1 o' J. w  `& v5 E3 I/ r1 `, K' r% H
41.                                                 /* 键值放入按键FIFO */
    * c. ?$ F/ h2 }: c: k
42.                                                 bsp_PutKey((uint8_t)(3 * i + 3));
    
43.                                         }
    
44.                                 }
    
45.                                 else
    # m1 k% w8 n; ]
46.                                 {
    
47.                                         if (pBtn->RepeatSpeed > 0)
    * ?! g* a' {* p% S+ J9 k
48.                                         {
    8 h9 s6 S' o1 a
49.                                                 if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
    ; |5 r0 @3 r7 X
50.                                                 {
    0 W" P' `& U% K9 k7 R! K9 p- \( C
51.                                                         pBtn->RepeatCount = 0;
    
52.                                                         /* 常按键后，每隔RepeatSpeed * 10ms发送1个按键 */
    
53.                                                         bsp_PutKey((uint8_t)(3 * i + 1));
    2 l. q  L2 o6 K3 y0 ~, t1 M& ^
54.                                                 }
    
55.                                         }
    * F1 B& W; f3 ~2 r9 N0 F! A
56.                                 }
    4 J/ q9 k: x6 c, b, O* u% P3 _
57.                         }
    % c! C+ I+ W/ \$ e; p' V9 y
58.                 }
    
59.         }
    
60.         else
    
61.         {
    
62.                 if(pBtn->Count > KEY_FILTER_TIME)
    , ~1 Q, x& @! D- U4 [, c
63.                 {
    
64.                         pBtn->Count = KEY_FILTER_TIME;
    9 ?. {0 `, e) F& N$ [% I
65.                 }
    8 j$ M) F! P$ ~5 W
66.                 else if(pBtn->Count != 0)
    % t- i" c7 _# a+ _
67.                 {
    
68.                         pBtn->Count--;
    
69.                 }
    
70.                 else
      i% o+ Z0 N0 h1 f0 F/ q9 v. {% H
71.                 {
    
72.                         if (pBtn->State == 1)
    / `8 O! ~) D8 p: L
73.                         {
    2 ?  y5 z( u0 `, E( ~8 G3 j
74.                                 pBtn->State = 0;
    * G$ j: e! x+ A5 I. K
75. 
    , Z6 m! Z' }; P
76.                                 /* 发送按钮弹起的消息 */
    
77.                                 bsp_PutKey((uint8_t)(3 * i + 2));
    % r# N9 b0 d" S2 m7 j
78.                         }
    
79.                 }
    / c( ]( K* h  t
80. 
    
81.                 pBtn->LongCount = 0;
    
82.                 pBtn->RepeatCount = 0;
    , \9 f$ r5 P* T  X: d8 b6 ^: G
83.         }
    
84. }</span></span>

复制代码

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

9 O: ~0 {/ t& c' `# [, \, h: B; ]& ]

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

复制代码

读取相应按键的结构体地址，程序里面每个按键都有自己的结构体。

1. static KEY_T s_tBtn[KEY_COUNT];
   ; H4 O) q& a/ J4 {4 U! F8 ^
2. if (IsKeyDownFunc(i))
   # @/ S* O# }# ]' A% B
3. {
   
4.         这个里面执行的是按键按下的处理
   7 k3 s9 Y  m3 @& y
5. }
   5 k. A- H9 j$ A" P2 g+ t
6. else
   
7. {
   
8.         这个里面执行的是按键松手的处理或者按键没有按下的处理
   
9. }

复制代码

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

1. /*
   
2. **********************************************************************************
   ( v% s# Z" ]+ n% z
3. 下面这个if语句主要是用于按键滤波前给Count设置一个初值，前面说按键初始化的时候
   
4. 已经设置了Count = KEY_FILTER_TIME/2
   
5. **********************************************************************************
   
6. */
   6 b; H7 f+ _2 F" M4 |  M
7. if (pBtn->Count < KEY_FILTER_TIME)
   / }! F/ x( F& f; q( I) [6 ^/ P
8. {
   ! x0 K$ v, H+ \% H, u8 S! N
9.     pBtn->Count = KEY_FILTER_TIME;
   
10. }
    
11. 
    8 F- e/ p" Y1 t. n! v" K% E
12. /*
    
13. **********************************************************************************
    " m( B* l: m9 A3 M- w
14. 这里实现KEY_FILTER_TIME时间长度的延迟
    % k: B  A2 N+ @  A
15. **********************************************************************************
    * P+ p* A- @' i/ a$ M/ F3 c4 P
16. */
    
17. else if(pBtn->Count < 2 * KEY_FILTER_TIME)
    0 f. B8 |& `; p9 s$ Q$ Y' [# k6 y% `
18. {
    3 ?" R$ E& A, n( @7 {
19.     pBtn->Count++;
    
20. }
    
21. /*
    9 U. R2 x; E0 V# r7 @0 w  V
22. **********************************************************************************
    
23. 这里实现KEY_FILTER_TIME时间长度的延迟
    
24. **********************************************************************************
    
25. */
    
26. else
    $ c' w/ Y0 N, p) I- F2 i
27. {
    # g/ u3 q- b7 @" J' _4 U
28. /*
    3 {( K( _, O% h; m
29. **********************************************************************************
    
30. 这个State变量是有其实际意义的，如果按键按下了，这里就将其设置为1，如果没有按下这个
    0 ?% a5 W: d0 M, c  p
31. 变量的值就会一直是0，这样设置的目的可以有效的防止一种情况的出现：比如按键K1在某个
    
32. 时刻检测到了按键有按下，那么它就会做进一步的滤波处理，但是在滤波的过程中，这个按键
      M) U! D" T) p
33. 按下的状态消失了，这个时候就会进入到上面第二步else语句里面，然后再做按键松手检测滤波
    ( }& k4 r  \- |) D
34. ，滤波结束后判断这个State变量，如果前面就没有检测到按下，这里就不会记录按键弹起。
    + g. N7 l# ?2 K6 n: H8 w
35. **********************************************************************************
    
36. */
    
37.     if (pBtn->State == 0)
    4 e8 I  D4 e& {+ e
38.     {
    3 j. d5 f! h& _& g& L
39.         pBtn->State = 1;
    
40. 
    6 I6 D( ?' o( R5 i' s" s
41.         /* 发送按钮按下的消息 */
    * b, `/ |" x5 m- D  w3 ?: j
42.         bsp_PutKey((uint8_t)(3 * i + 1));
    " r1 V, S; p( ]# O( f4 o
43.     }
    
44. 
    - Y" L, t, }- c
45.     if (pBtn->LongTime > 0)
    ! l' V% w% F# ?) C$ W
46.     {
    
47.         if (pBtn->LongCount < pBtn->LongTime)
    
48.         {
    
49.             /* 发送按钮持续按下的消息 */
    
50.             if (++pBtn->LongCount == pBtn->LongTime)
    ( C; ^+ \5 E* W% r* D
51.             {
    
52.                 /* 键值放入按键FIFO */
    
53.                 bsp_PutKey((uint8_t)(3 * i + 3));
    
54.             }
    
55.         }
    6 ?3 h# Q/ I+ m0 W) @7 z5 U/ ]
56.         else
    * G' {- h6 j: m. Y
57.         {
    . i" f8 q5 @; c, k  S" y
58.             if (pBtn->RepeatSpeed > 0)
    
59.             {
    
60.                 if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
    & ~5 m: S% y7 A) O7 a6 P
61.                 {
    ; D/ O8 b% b1 O5 K( h! N
62.                     pBtn->RepeatCount = 0;
    
63.                     /* 长按键后，每隔10ms发送1个按键 */
    2 S( s: A& c  z$ p# X4 _
64.                     bsp_PutKey((uint8_t)(3 * i + 1));
    / j/ b6 T* L& N9 p; b
65.                 }
    $ [' i2 Q' a. ^+ r
66.             }
    1 M2 Z. M8 i! _$ ~$ K
67.         }
    
68.     }
    
69. }

复制代码

19.3.4 按键检测采用中断方式还是查询方式
4 N) }& V% ]! {  I8 {6 }检测按键有中断方式和GPIO查询方式两种。我们推荐大家用GPIO查询方式。

从裸机的角度分析

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

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

) v, }& A  J* i从OS的角度分析
! @0 S, d1 t. ?& D6 S$ y  i1 E
; G4 |2 A5 @; n* y9 Y中断方式：在OS中要尽可能少用中断方式，因为在RTOS中过多的使用中断会影响系统的稳定性和可预见性（抢占式调度的OS基本没有可预见性）。只有比较重要的事件处理需要用中断的方式。

查询方式：对于用户按键推荐使用这种查询方式来实现，现在的OS基本都带有CPU利用率的功能，这个按键FIFO占用的还是很小的，基本都在1%以下。

1 T" V& L7 C2 x2 Q) O19.4 按键板级支持包（bsp_key.c）
) e1 ~( I* h% X3 `按键驱动文件bsp_key.c主要实现了如下几个API：

+ W; ?+ R4 l' s4 w! \7 T8 i  KeyPinActive
) F2 {% k) m9 `  X6 p; h& p  IsKeyDownFunc
  bsp_InitKey
" @2 p! j6 `! M: e5 K# F  bsp_InitKeyHard
0 B! Z  ]: q2 ?! u. {+ c2 I  bsp_InitKeyVar
2 B6 K8 D! m! T. p7 z5 }1 c9 r  bsp_PutKey
' F' q: E, s* ^# N( ]  bsp_GetKey
  bsp_GetKey2
  bsp_GetKeyState
4 n" T# N6 f" O  U, F3 _  bsp_SetKeyParam
4 ^# m4 b& o: O+ y  bsp_ClearKey
  bsp_DetectKey
0 J1 S" }' m" C2 N  bsp_DetectFastIO
  bsp_KeyScan10ms
  bsp_KeyScan1ms
% M# _+ X, @, r( y% v, a
7 a9 r! y: X: f  X所有这些函数在本章的19.3小节都进行了详细讲解，本小节主要是把需要用户调用的三个函数做个说明。

9 n- Y8 L: [& I( q% b8 m/ p19.4.1 函数bsp_InitKeyHard
; }+ f9 s( p4 [  {2 P7 c# L函数原型：

/ K2 r. U* l7 R

1. /*
   % E' e' r- @" n/ W. n3 q( O# K# Q
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_InitKey
   
4. *        功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
   & {% ~  |/ w# s) U4 g6 g; R  V
5. *        形    参: 无
   2 l0 o& e. K# e) j
6. *        返 回 值: 无
   - U8 N* O* _6 j  E- g) I, C
7. *********************************************************************************************************
   3 Z  Y7 W- Q6 n2 b* f- m. C
8. */
   
9. void bsp_InitKey(void)
   
10. {
    
11.         bsp_InitKeyVar();                /* 初始化按键变量 */
    
12.         bsp_InitKeyHard();                /* 初始化按键硬件 */
    
13. }

复制代码

函数描述：
; N/ E& B, d0 S( f- g* U
' w$ |: x7 q; U8 x$ ]& k7 ?此函数主要用于按键的初始化。
, w4 l  L6 I7 @: R7 x8 l* K
使用举例：

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

19.4.2 函数bsp_GetKey
+ f8 B" ^( o& t6 x" c" |函数原型：

+ B# q) m: f) {( E8 S- D; f% q! r  n2 d

1. /*
   + a" g% N/ k% N
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_GetKey
   
4. *        功能说明: 从按键FIFO缓冲区读取一个键值。
   
5. *        形    参: 无
   
6. *        返 回 值: 按键代码
   : q7 S1 l# y" o3 h4 ]. e# r
7. *********************************************************************************************************
   8 K: [" U) X" \: y
8. */
   % v# l% g5 {( B8 Q' m. }, Z, H% N
9. uint8_t bsp_GetKey(void)
   
10. {
    
11.         uint8_t ret;
    
12. 
    & I- g0 r% X. D5 w
13.         if (s_tKey.Read == s_tKey.Write)
    
14.         {
    
15.                 return KEY_NONE;
      J' R: X: W; [5 D& |
16.         }
    
17.         else
    
18.         {
    8 n  U4 m4 f# J( I
19.                 ret = s_tKey.Buf[s_tKey.Read];
    3 P7 M0 {, d( c- A0 h8 e
20. 
    ) R3 A, l5 q- p: ?# l
21.                 if (++s_tKey.Read >= KEY_FIFO_SIZE)
    
22.                 {
    
23.                         s_tKey.Read = 0;
    
24.                 }
    
25.                 return ret;
    0 j1 u& D; d6 r+ W6 x: Y0 I
26.         }
    
27. }

复制代码

5 o0 `* N0 ^! C% d' X8 O2 h函数描述：
; t- a! \' ?8 o6 s6 |: k/ F) @" d: j
此函数用于从FIFO中读取键值。
3 i1 s. s0 j$ c1 B
8 q. R2 ?" H$ v! k使用举例：
# q, H# ?; ]/ I# N3 ?, |
$ \4 k5 x. H8 t0 N调用此函数前，务必优先调用函数bsp_InitKey进行初始化。

" ], L6 r, s; Z" D4 N

1. /*
   
2. *********************************************************************************************************
   $ l8 F0 n0 w, Z& D
3. *        函 数 名: main
   4 Y& m4 Z# a3 N3 A9 P
4. *        功能说明: c程序入口
   * ]* g( \5 m$ S8 v0 K) g: B3 R8 n
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   : B& x7 B0 [/ |& A/ z9 L, v
7. *********************************************************************************************************
   8 X" y" m7 i. a6 s
8. */
   ) s; a2 _+ `$ }% _1 t) X, O4 N, V+ Z
9. int main(void)
   
10. {
    " w( B7 r$ k1 Y# I
11.         uint8_t ucKeyCode;                /* 按键代码 */
    
12.         
    # X* U0 g4 ]8 z6 T% g
13.         bsp_Init();                /* 硬件初始化 */
    , X- I. b% b! Q" e, S2 N# x; P
14.         
    4 X+ V( T) ]' L' h" J1 K2 r% F, z* w& I2 W
15.         /* 进入主程序循环体 */
    $ g1 S. J9 v, l4 A  i
16.         while (1)
    
17.         {               
    
18.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
19.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    * \5 S6 X' v5 Y3 y# l* o- g
20.                 if (ucKeyCode != KEY_NONE)
    , ~5 E, |1 B$ D0 O
21.                 {
    
22.                         switch (ucKeyCode)
    
23.                         {
    1 q& w# D( X( [7 b
24.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    
25.                                         printf("K1键按下\r\n");
    4 Q+ [, k0 C5 d( r# ]
26.                                         break;
    - e2 U1 H8 `7 J$ K/ I4 j% z. n
27. 
    : l5 m. Y6 c- h! c2 y7 T  `
28.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    + p8 l4 T/ I3 E. y8 s- R
29.                                         printf("K2键按下\r\n");
    / s+ M* N4 y6 t% O
30.                                         break;
    
31. 
    7 K$ a6 [2 |, _  ~
32.                                 default:
    / I1 J& k! W3 Q9 N6 z
33.                                         /* 其它的键值不处理 */
    9 @2 K4 ~3 N- r/ Y1 O6 ~
34.                                         break;
    ( S6 B) s+ ]8 r) B" I- f; K
35.                         }
    , C, Z, m1 ]; [+ V6 x- v4 i
36.                 }
    8 _' N* k$ X" ^; N% Z
37.         }
    3 S9 r6 j' y/ ^- p, Z
38. }

复制代码

19.4.3 函数bsp_KeyScan10ms
函数原型：
! U/ s# j: m3 W( }8 Z' x1 U' O

1. /*
   % m4 d- G: Y) R2 e
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_KeyScan10ms
   * ^6 f6 _* Q; X
4. *        功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
   
5. *        形    参: 无
   6 t- N9 a+ e3 _+ V" t5 [* |; C7 N
6. *        返 回 值: 无
   7 P0 w# G+ p: ^
7. *********************************************************************************************************
   
8. */
   
9. void bsp_KeyScan10ms(void)
   * t9 h; G  V. ?0 _+ \( C. n
10. {
    
11.         uint8_t i;
    
12. 
    # a6 r* H; V7 }% y( V2 ]2 h2 W% p
13.         for (i = 0; i < KEY_COUNT; i++)
    
14.         {
    # t2 J! Q1 |% l  }; a  F3 {. w" P9 @
15.                 bsp_DetectKey(i);
    
16.         }
    
17. }

复制代码

/ n1 a; R& U; D, U函数描述：

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

使用举例：

调用此函数前，务必优先调用函数bsp_InitKey进行初始化。
3 ^- k/ X9 ?- o  ]& R" U0 o6 _( }
" N% x- K( G- W# C5 p( d7 c另外，此函数需要周期性调用，每10ms调用一次。
+ K* W6 C7 t. l& |2 Q- H3 R% x
  如果是裸机使用，将此函数放在bsp.c文件的bsp_RunPer10ms函数里面即可，这个函数是由滴答定时器调用的，也就是说，大家要使用按键，定时器的初始化函数bsp_InitTimer一定要调用。
- W3 L/ e4 g$ O! B& d& D  如果是RTOS使用，需要开启一个10ms为周期的任务调用函数bsp_KeyScan10ms。

19.5 按键FIFO驱动移植和使用
按键移植步骤如下：
5 \; [/ J$ E' K2 a/ c9 B6 @
  第1步：复制bsp_key.c和bsp_key.c到自己的工程。
  第2步：根据自己使用的独立按键个数和组合键个数，修改几个地方。

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

复制代码

" U6 |7 ^/ z, r' L  第3步：根据使用的引脚时钟，修改下面函数：
, @% K  G8 P/ P6 K& G8 z. L

1. /* 使能GPIO时钟 */
   2 Z4 o1 e5 R8 z% V. m" I1 W: ~
2. #define ALL_KEY_GPIO_CLK_ENABLE() {        \
   9 D+ o6 s; Y- k" p8 k
3.                 __HAL_RCC_GPIOB_CLK_ENABLE();        \
   ; V/ v; p& G) F) d( ^& v6 Q
4.                 __HAL_RCC_GPIOC_CLK_ENABLE();        \
   
5.                 __HAL_RCC_GPIOG_CLK_ENABLE();        \
   
6.                 __HAL_RCC_GPIOH_CLK_ENABLE();        \
   
7.                 __HAL_RCC_GPIOI_CLK_ENABLE();        \
   : h  _) a$ E$ b/ S' W9 C9 s
8.         };

复制代码

# \3 ^$ {5 x: t% c6 ]$ x9 U  第4步：根据使用的具体引脚，修改如下函数，第3列参数低电平表示按下或者高电平表示按下：
+ c: a$ x/ s5 k# }$ Z% _9 q

1. /* GPIO和PIN定义 */
   ! Q3 [8 k% B5 m" X0 z
2. static const X_GPIO_T s_gpio_list[HARD_KEY_NUM] = {
   
3.         {GPIOI, GPIO_PIN_8, 0},                /* K1 */
   0 T; z- ~, D  Z* N9 k' P$ T% n
4.         {GPIOC, GPIO_PIN_13, 0},        /* K2 */
   : ]: F' a6 M, }
5.         {GPIOH, GPIO_PIN_4, 0},                /* K3 */
   * `/ b' V: J* n# E, N" ^" l  x1 r9 P
6.         {GPIOG, GPIO_PIN_2, 0},                /* JOY_U */        
   & m3 k: H& M- B4 |
7.         {GPIOB, GPIO_PIN_0, 0},                /* JOY_D */
   
8.         {GPIOG, GPIO_PIN_3, 0},                /* JOY_L */        
   
9.         {GPIOG, GPIO_PIN_7, 0},                /* JOY_R */        
   1 X. ?% y9 X; K2 I  F' e$ v
10.         {GPIOI, GPIO_PIN_11, 0},        /* JOY_OK */
    
11. };   

复制代码

     
/ v2 f' e+ S: h( k6 B& ?  第5步：根据使用的组合键个数，在函数IsKeyDownFunc里面添加相应个数的函数：

1.         /* 组合键 K1K2 */
   # \7 {1 U# F4 F% u1 Z% H" }6 V
2.         if (_id == HARD_KEY_NUM + 0)
   7 s! U. {% t; Z9 [. a- F8 O
3.         {
   
4.                 if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
   
5.                 {
   
6.                         return 1;
   . S; b/ ^, B' N4 C' M
7.                 }
   3 n+ p8 p9 h- w- V1 W; S
8.                 else
   2 l, `* M& M4 M2 [; h! N
9.                 {
   
10.                         return 0;
    ) i8 i, ]1 A; l) ?
11.                 }
    
12.         }

复制代码

# P) q8 V* h  j. h第2行ID表示HARD_KEY_NUM + 0的组合键，HARD_KEY_NUM + 1表示下一个组合键，以此类推。

另外就是，函数KeyPinActive的参数是表示检测哪两个按键，设置0的时候表示第4步里面的第1组按键，设置为1表示第2组按键，以此类推。
  {# ^# z: I% |8 ?
: f8 E) ^2 `+ d3 b9 q: a& |& G% w/ t  第6步：主要用到HAL库的GPIO驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
  第7步：移植完整，应用方法看本章节配套例子即可。
7 L+ l5 I( Y$ Q/ R# T7 c特别注意，别忘了每10ms调用一次按键检测函数bsp_KeyScan10ms。

/ k+ t8 ]% {3 p/ J% g$ y9 {19.6 实验例程设计框架
: E" x9 {* b0 T  k通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：

* h; X5 M  ~) k. l3 _- j4 X. ~7 D
9 L0 ^" F8 v% o) K 1、 第1阶段，上电启动阶段：

这部分在第14章进行了详细说明。
% x2 D2 z4 |/ g* x1 B  K
2、 第2阶段，进入main函数：

  第1部分，硬件初始化，主要是MPU、Cache、HAL库、系统时钟、滴答定时器、按键等。
  第2部分，应用程序设计部分，实现了一个按键应用。
  第3部分，按键扫描程序每10ms在滴答定时中断执行一次。

, w' y! P' E/ d" {7 Z6 k/ b  n19.7 实验例程说明（MDK）
% V9 Z! A3 d  e7 C  u4 p( n配套例子：
V7-002_按键检测（软件滤波，FIFO机制）

实验目的：
学习按键的按下，弹起，长按和组合键的实现。

实验内容：
启动一个自动重装软件定时器，每100ms翻转一次LED2。
1 r* s% Y& d9 m( X0 `4 r5 Y
实验操作：
* }7 e. _) d- _! V/ n# {3个独立按键和5向摇杆按下时均有串口消息打印。
5向摇杆的左键和右键长按时，会有连发的串口消息。
% l3 [! F5 B5 e3 H0 f, Y独立按键K1和K2按键按下，串口打印消息。

6 E9 f; C+ u+ c  v, D5 j上电后串口打印的信息：
( g# X: _$ W9 y4 _4 k  Y# {
波特率 115200，数据位 8，奇偶校验位无，停止位 1

$ D( P" u- _. ~, t" b: B
程序设计：
( U( \6 |' y# a8 C
! K  q7 C2 R* ^. m4 p  系统栈大小分配：

+ j3 F) Y7 W5 B, p0 @+ d
  RAM空间用的DTCM：
8 _  d) T6 x5 T. A& H1 m0 a5 }+ r& a! s

1 S7 e! v0 }7 F! k
$ z, H) @" I) a" N4 ^  硬件外设初始化
# r' l5 E, G) G
! s+ {$ R+ j  ^; f5 t硬件外设的初始化是在 bsp.c 文件实现：
  h( W* \' i( |; v6 g1 k

1. /*
   + S) j( T. `) F. z5 E  r. o
2. *********************************************************************************************************
   : b$ P* P8 J/ ?6 V  a" W
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   8 J: d& f7 M' y0 t3 r7 }
6. *        返 回 值: 无
   6 C4 R8 L" q% ~* k4 r' y2 C3 K
7. *********************************************************************************************************
   ! j7 a; @! J1 @  @+ C6 K; U& |* H
8. */
   . n4 G# ^8 P. ^. }/ w) N+ R: E
9. void bsp_Init(void)
   0 v9 s% }4 g9 p3 J
10. {
    
11.     /* 配置MPU */
    
12.         MPU_Config();
      w: u. ^& A; i$ V* f1 D# o
13.         
    7 v7 E" J7 h/ V) S0 P
14.         /* 使能L1 Cache */
    ; B6 L! H5 a: Y
15.         CPU_CACHE_Enable();
    
16. 
    ! H* U9 t, _- E( u7 k4 e9 m
17.         /*
    2 C: R8 `, U* `5 M! a2 a
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    + W8 E) ?; F" p; |
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    " L& @1 N+ |0 c  |, X
21.          */
    
22.         HAL_Init();
    4 f2 E- I' ?6 c# ?2 `$ V$ c  L
23. 
    / f1 T$ v3 Y) p, d
24.         /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    , K+ I' U( o# u+ q( b( G( j, y5 `
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    * B) s' \6 ]! j* T
28.     */
    6 n. V+ Z' d% i1 c/ T/ @$ a
29.         SystemClock_Config();
    8 ]* c0 W5 U7 {& g) h
30. 
    ' C0 [7 A- p) A: Y2 g
31.         /*
    
32.            Event Recorder：
    ; Y' O3 g, ~  y3 f& M+ c
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    " m- Z. ^& V- |  D/ N* Q$ r
36. #if Enable_EventRecorder == 1  
    " e8 Z  H; q3 ~' K9 V
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    " d+ |* w( V5 ~) f
39.         EventRecorderStart();
    
40. #endif
    
41.         
    3 l1 ^/ e) ?8 B1 l
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    7 ^; |: |' d5 G( ]3 P5 v
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    - B8 M; V7 h4 y, j( q( K
46.         bsp_InitLed();            /* 初始化LED */        
    % U7 h+ `) M* ~- |1 N* c0 Y; t
47. }

复制代码

  MPU配置和Cache配置：
. N% O. F# N2 |0 A( Z! q0 i
数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

1. /*
   : ^5 @: ]. o7 k9 C! p
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   ) M; d/ \1 e" e5 D
7. *********************************************************************************************************
   
8. */
   
9. static void MPU_Config( void )
   2 R  y! Z6 K; E+ w( h& j; e- p
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.         /* 禁止 MPU */
    - ~( I& L0 {: r7 I) _/ v# y& V! m
14.         HAL_MPU_Disable();
    
15. 
    + j5 d) L: Z: E0 N) T% z
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    7 i4 I4 A! s  v; e( ^5 ]
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    " `/ H' o" }! ~- q3 K" i: c
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    9 H7 R* Z; K: C: G9 s  T
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    8 m- y+ m* K  n9 |3 V) v' t
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    , |2 }1 u: Z0 X6 o) j6 ^+ e
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    : I$ \" c) \( s3 R$ a. L
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    / T- _- h$ Q8 U8 m$ p; {0 A
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    0 I* v9 s" I  J9 g; u1 T
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    1 E$ y6 R% x( d8 R+ M' n# x. P
31.         
    # @7 o: J0 i" t
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    ( U+ H, P8 d* ?9 r" {
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;
    7 t( u7 a% c7 s! x* H1 I; I
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    5 c) `1 O7 ]  N
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    $ d  U; w$ w2 M6 t9 r$ j
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    & u8 @6 {) ^$ U3 n/ |) q4 B: W8 B$ I
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    % s7 F* e* {- I5 v: Y3 I
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    ! |- B4 ?0 T$ c- x& t& U( O
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    , [/ j0 H+ c$ C1 x$ b- f
47.         /*使能 MPU */
    
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    
50. 
    % n: p! F2 k5 E" E/ E2 {
51. /*
    ! e0 Q, [* F5 }; J8 P; m
52. *********************************************************************************************************
    % N2 k6 G2 j; q: Y' Y3 [, F
53. *        函 数 名: CPU_CACHE_Enable
    ( N% o! w- |7 J& y$ `+ E
54. *        功能说明: 使能L1 Cache
    
55. *        形    参: 无
    " d1 O# ~7 L! }$ \2 [
56. *        返 回 值: 无
    / U% Q  H4 O- O& T
57. *********************************************************************************************************
    8 H% @4 V6 Y7 C% Q# B
58. */
    , [- `. G8 {: U6 f) B  O# t. [
59. static void CPU_CACHE_Enable(void)
    ; Z0 N8 Y( }, ]2 _: @, `1 A
60. {
    
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    
63. 
    8 {1 m( V  ~, r' w
64.         /* 使能 D-Cache */
    
65.         SCB_EnableDCache();
    5 \( i  g3 e# |/ f9 J' K1 U* ?
66. }

复制代码

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

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

1. /*
   ; @% g7 t- m2 O! ^
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_RunPer10ms
   7 M( P' v; W! w) y$ e. ^% E
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *        形    参: 无
   ; F, Q1 H$ q6 x8 B3 q
7. *        返 回 值: 无
   
8. *********************************************************************************************************
   6 m: \; r. `+ Z9 ]
9. */
   
10. void bsp_RunPer10ms(void)
    
11. {
    
12.         bsp_KeyScan10ms();
    % I" i/ G! l2 ^7 @& r! K$ |
13. }

复制代码

  主功能：
" x* v) K2 y8 T
4 J# Y, y; r! V* k% Y7 c主功能的实现主要分为两部分：
( X$ y& P* d. O" k7 u2 B* y0 _3 |
启动一个自动重装软件定时器，每100ms翻转一次LED2
& a6 x. o! R7 v: s8 f 按键消息的读取，检测到按下后，做串口打印。
( M# L$ M6 I3 v% F

1. /*
   - v6 d6 Z  H4 U; q
2. *********************************************************************************************************
   + n1 ?' ^% z* {! z" W! M  c* o
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   0 ^1 S& K7 }( [, C2 m& I: Y$ M: _
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   4 E: Q: P; O& j7 N3 ~1 h  |" g$ [
9. int main(void)
   8 F! ~% D7 [# @7 _( l& w
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    
12.         
    
13.         bsp_Init();                /* 硬件初始化 */
    6 o8 I# _/ l: d' ^, b  L; B
14.         
    
15.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    8 v/ @+ ]/ Y6 d3 u% l) ^$ i
16.         PrintfHelp();        /* 打印操作提示 */
    
17. 
    + s: P, I1 L! T6 s" O; Z
18. 
    
19.         bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 */
    
20.         
    % g/ t; T0 C+ ?$ _4 K) g( H
21.         /* 进入主程序循环体 */
    
22.         while (1)
    1 v1 e9 H: Z+ x0 h% A/ c$ R/ o
23.         {
    8 Z9 C1 `8 }9 ?3 A8 ^6 n
24.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
25. 
    + D6 B# O7 H7 u! c7 `+ Y
26.                 /* 判断定时器超时时间 */
    , ?; i8 c7 L) c* o* q9 `0 _# F
27.                 if (bsp_CheckTimer(0))        
    ( A# s4 H% p% B# v
28.                 {
    
29.                         /* 每隔100ms 进来一次 */  
    4 b4 d9 N9 b1 D, |) E8 j, p
30.                         bsp_LedToggle(2);                        
    
31.                 }
    ( h% w* z9 j# x& a
32.                
    9 W; h8 I1 X6 e# d3 R' k
33.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    0 o; }0 K1 d1 W! M( b2 W7 ]* R
34.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    * R; Z3 n3 Z9 M
35.                 if (ucKeyCode != KEY_NONE)
    ' c( ~! u  s# z8 z' i1 I, j  {
36.                 {
    7 n: j$ t" M2 z6 u9 c( o; j! t0 K) Y
37.                         switch (ucKeyCode)
    
38.                         {
    ; u# s! `7 J9 J* o9 H# u6 }' \
39.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    6 }6 d  Q# [  o3 v
40.                                         printf("K1键按下\r\n");
    
41.                                         break;
    
42. 
    . E1 G" S9 z- p# N1 x6 Z/ e
43.                                 case KEY_UP_K1:                                /* K1键弹起 */
    
44.                                         printf("K1键弹起\r\n");
    % }7 L2 M3 Q. y. P! y
45.                                         break;
    8 X1 E8 e3 ]! T2 b4 ~
46. 
    
47.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    9 {% ]8 t9 a! B* |* `5 g5 V6 a
48.                                         printf("K2键按下\r\n");
    4 D7 f+ ]8 d) _% b
49.                                         break;
    
50. 
    
51.                                 case KEY_UP_K2:                                /* K2键弹起 */
    / X6 o- r' z) j% `, A, z( M
52.                                         printf("K2键弹起\r\n");
    
53.                                         break;
    8 e5 ?# M7 }- h5 j$ Q8 S1 h: [
54. 
    
55.                                 case KEY_DOWN_K3:                        /* K3键按下 */
    ( j1 J0 E" _/ s+ |6 Z
56.                                         printf("K3键按下\r\n");
    
57.                                         break;
    
58. 
    
59.                                 case KEY_UP_K3:                                /* K3键弹起 */
    
60.                                         printf("K3键弹起\r\n");
    + B" ]  }& r: a) f* u* \
61.                                         break;
    
62. 
    
63.                                 case JOY_DOWN_U:                        /* 摇杆UP键按下 */
    
64.                                         printf("摇杆上键按下\r\n");
    8 I5 V$ M) d! C- h; N3 S! t
65.                                         break;
    . ~! s  q# w" I5 F- ~+ |
66. 
    9 K' Q; `0 K7 m
67.                                 case JOY_DOWN_D:                        /* 摇杆DOWN键按下 */
    6 M: @: N. g* p' s/ y
68.                                         printf("摇杆下键按下\r\n");
    
69.                                         break;
    4 W7 E+ F% ^/ A$ h4 T
70. 
    
71.                                 case JOY_DOWN_L:                        /* 摇杆LEFT键按下 */
    3 H; H6 D9 c4 X" c% `' b7 D: g# W
72.                                         printf("摇杆左键按下\r\n");
    
73.                                         break;
    9 X7 M2 m8 \5 F4 x  J. c9 n, C
74.                                 
    
75.                                 case JOY_LONG_L:            /* 摇杆LEFT键长按 */
    
76.                                         printf("摇杆左键长按\r\n");
    # o6 e- M5 i8 @; ~, L" z5 ?
77.                                         break;
    . i# r* h4 ^- q
78. 
    
79.                                 case JOY_DOWN_R:                        /* 摇杆RIGHT键按下 */
    5 A# F. P. O( }$ m, I
80.                                         printf("摇杆右键按下\r\n");
    & V+ r0 _) {+ ^5 u2 \; V6 d
81.                                         break;
    ) y$ d1 S0 u/ Q" Q; }* \
82.                                 
    . M0 W0 ^  d# M) G
83.                                 case JOY_LONG_R:            /* 摇杆RIGHT键长按 */
    
84.                                         printf("摇杆右键长按\r\n");
    
85.                                         break;
    ( s. D) T0 e9 Q& d+ _& T) l
86. 
    
87.                                 case JOY_DOWN_OK:                        /* 摇杆OK键按下 */
    
88.                                         printf("摇杆OK键按下\r\n");
    
89.                                         break;
    / l/ E" N! `5 P3 F9 A7 H) @: ^
90. 
    3 s( a' B0 i( d) K8 u; ^
91.                                 case JOY_UP_OK:                        /* 摇杆OK键弹起 */
    
92.                                         printf("摇杆OK键弹起\r\n");
    
93.                                         break;
    - h6 ?5 P1 O# F
94. 
    ! @0 H2 l3 D  h2 p2 I! @
95.                 case SYS_DOWN_K1K2:                        /* 摇杆OK键弹起 */
    
96.                                         printf("K1和K2组合键按下\r\n");
    
97.                                         break;
    * p/ K5 B5 b3 N7 K
98. 
    / R& p) f# b2 p+ M* i5 t
99.                                 default:
    
100.                                         /* 其它的键值不处理 */
     
101.                                         break;
     ( b- o! h" u+ t
102.                         }
     $ {; s0 W- S- F# |1 w8 f0 v1 R- [
103.                
     . C  ~( [# T* |7 a
104.                 }
     
105.         }
     1 {+ B: P7 i- j/ D
106. }

复制代码

2 R0 a& `, G. p- H) \& G19.8 实验例程说明（IAR）
配套例子：
2 M. M6 v; k% H) q+ H7 S. M; VV7-002_按键检测（软件滤波，FIFO机制）

实验目的：
学习按键的按下，弹起，长按和组合键的实现。

实验内容：
启动一个自动重装软件定时器，每100ms翻转一次LED2。
  d: S9 e6 c8 K8 Z# A
* y9 W4 E, Z/ `; Z7 Q: T$ V3 N实验操作：
9 S  Y3 e! e, J( m  @3个独立按键和5向摇杆按下时均有串口消息打印。
5向摇杆的左键和右键长按时，会有连发的串口消息。
独立按键K1和K2按键按下，串口打印消息。

4 B1 j6 A& h% S7 E! l# s上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1
  |; X+ b1 P3 ?$ c1 {6 n

: \0 l& ~/ ^+ T6 p7 {! r( i
程序设计：
9 s; |8 D6 [6 F, o) @: j
  系统栈大小分配：
! F7 h# x1 E: S8 g* U2 g$ s

" v+ g# }' a9 `4 D; S$ E
6 z9 T6 x3 ]& w- r5 p8 A* Z  RAM空间用的DTCM：

- f! Q% r$ b/ C, g/ m

  硬件外设初始化
: B3 r/ \9 U2 i4 m( [& o8 `1 _
硬件外设的初始化是在 bsp.c 文件实现：
( }; z" i/ u( ]0 v% n0 ]& b

1. /*
   ' _% ?& {4 P) e6 w+ x- o! W* B7 m
2. *********************************************************************************************************
   5 |( d% t" h  i: Y2 R9 C4 r7 T
3. *        函 数 名: bsp_Init
   & z" e" k  s: ^7 q9 x
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   & ~- G  j" s$ Q  @0 u7 x
5. *        形    参：无
   
6. *        返 回 值: 无
   + x: H' M1 L% C9 k3 i' ~
7. *********************************************************************************************************
   ( h! G" x+ N9 ]+ b' p  q  b
8. */
   / W$ ~, k  ?9 l$ }7 l
9. void bsp_Init(void)
   
10. {
      e5 H+ }* Q$ L* x5 E! \
11.     /* 配置MPU */
    
12.         MPU_Config();
    $ K6 `( j% H5 P, J( D
13.         
    1 S- v* _/ L0 Z
14.         /* 使能L1 Cache */
    . E$ k( E6 x! H, J) L
15.         CPU_CACHE_Enable();
    
16. 
    
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    4 J5 G6 n/ o7 F0 l
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    9 Y  r3 h4 k2 x2 n% B& r
20.            - 设置NVIV优先级分组为4。
    
21.          */
    2 O  M1 h9 z. m" I
22.         HAL_Init();
    
23. 
    4 c6 I: Z6 A+ G' r# x! W0 p
24.         /*
    & [4 H/ @( L* @6 Z- q) K+ b9 E! G$ i
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
      [7 p! G  w) B; A
29.         SystemClock_Config();
    
30. 
    # }5 Y% z6 Y: y0 X  e
31.         /*
    
32.            Event Recorder：
    ' \/ K" f' d# V5 H: q2 w+ `5 u
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    ( k. W% g: j" `: ]' a$ E
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    
36. #if Enable_EventRecorder == 1  
    3 s5 y( U& P3 a- @& ~
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    2 w( n/ n. ~8 X' D) \$ b
39.         EventRecorderStart();
    
40. #endif
    ( E3 H% {- W+ L% [9 h8 u
41.         
    7 L, O; M( {" B0 g% t9 n6 c
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    " _8 l5 d" h$ _1 F: I4 ^2 @1 ?+ |
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    + Z$ p& s+ D! I/ P! V" d. K" O
46.         bsp_InitLed();            /* 初始化LED */        
    5 q) G; Z7 m* Z# h- }8 q0 r$ Z8 k
47. }

复制代码

* _  B! o& g& [! w  MPU配置和Cache配置：
# o! C; v1 F, S: o: _- P
; O) n3 Q; a3 U" h数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

- [/ K$ y( P5 m1 ?( O' f  `5 q+ f

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   ) v8 Y3 P5 b; D7 E1 m! Z/ \
5. *        形    参: 无
   " ~4 `# c* l$ A* L$ Z) {$ S+ }
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   6 a! o2 L2 g* \8 @: b% e5 `
8. */
   
9. static void MPU_Config( void )
   9 [$ S+ Q" _# F$ _# |' M
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    " q! k; L; s2 ~) g
13.         /* 禁止 MPU */
    ; p+ F9 a7 Z$ d. @
14.         HAL_MPU_Disable();
    % f+ ?& p: C9 C- }6 \; W5 f
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    / z5 M( _! V2 l8 A, z! }, _" E
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    , Y, m: S/ |) i  ]' w/ q
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    * r7 ^8 W; T- h4 \# A
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ; ~+ P1 b- c/ c( J! C
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    . C0 |+ A( z& D+ H) y2 G3 c
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    . |' {( Z  K/ g0 z$ m0 e( |- S
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    + t0 G6 U2 ^& h, u' O
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    . B" {0 I8 a1 {1 c
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    : j5 b2 D1 q) N) |- Z
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    
31.         
    4 \0 l  p5 B6 ?! ?
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ) M- ?8 n6 e6 e6 G. F' O, e
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    9 ?% \5 R5 n" H% f; N
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    2 F& t. n7 @$ `6 v
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    " I. e9 U# s* _5 I
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    8 R' w9 F, J- h$ T$ H  u
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    " u8 S8 B; u6 E4 J0 W9 B
47.         /*使能 MPU */
    * V" V1 p( ^* \% }$ l
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    
50. 
    
51. /*
    ( }& C: y- ~7 W
52. *********************************************************************************************************
    
53. *        函 数 名: CPU_CACHE_Enable
    ) u; `8 W* y# ?0 C4 O/ ?0 m
54. *        功能说明: 使能L1 Cache
    " T6 j( T1 X2 o% M) _, b: V9 Q
55. *        形    参: 无
    
56. *        返 回 值: 无
    $ |- V6 x9 M/ ]0 |0 a2 ~7 d
57. *********************************************************************************************************
    ! g. q- j9 ?3 Y
58. */
    ! D& M: |: M( i9 j" |
59. static void CPU_CACHE_Enable(void)
    : L4 \% v) J  \6 f+ R% R
60. {
    
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    . g4 Z/ g, `. s3 [7 `3 e: i
63. 
    ! }& @* W) n% J
64.         /* 使能 D-Cache */
    
65.         SCB_EnableDCache();
    
66. }

复制代码

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

按键检测是在滴答定时器中断里面实现，每10ms执行一次检测。
9 x% j  p& {9 k3 G8 A

1. /*
   8 Q& u7 ~( i9 @# ^3 {! P
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_RunPer10ms
   
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   2 Y8 M/ U) b4 K1 F
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *        形    参: 无
   
7. *        返 回 值: 无
   
8. *********************************************************************************************************
   # L" Y3 ?: ?; p% t: o6 F
9. */
   
10. void bsp_RunPer10ms(void)
      R( {( V$ J$ g- l) p4 l; c. [) Q
11. {
    ! I" k- ]* e' C3 V1 I5 T
12.         bsp_KeyScan10ms();
    
13. }

复制代码

主功能：
3 q& m7 B* T' y+ L
9 M/ N7 q) p0 S" @6 h( i1 Q主功能的实现主要分为两部分：
, _) Y8 [5 v) q4 f3 {! o4 B
/ ^6 h5 L0 ?2 W7 y 启动一个自动重装软件定时器，每100ms翻转一次LED2
* b+ F1 ~! R! w* i4 u& ?5 M0 A 按键消息的读取，检测到按下后，做串口打印。
  d( |2 e5 M6 s  y3 L+ d- H

1. /*
   " e$ C8 K4 g; p& `% q( o6 E
2. *********************************************************************************************************
   0 p! a; ?+ G8 {  _
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   + h% e9 i0 R+ @- {! _# E7 v7 \
7. *********************************************************************************************************
   
8. */
   
9. int main(void)
   
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    ) y& `% @* K/ M% D- V
12.         
    
13.         bsp_Init();                /* 硬件初始化 */
    0 Q7 g8 g! i! \
14.         
    / M- F% J& _& d  X
15.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    , @9 p8 H7 b' c  u
16.         PrintfHelp();        /* 打印操作提示 */
    " g- D0 c& J0 s" H+ s. Z
17. 
    * o. C1 j* C' \) [- |# s
18. 
    ; Q% I$ u: c) [9 y5 u
19.         bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 */
    
20.         
    
21.         /* 进入主程序循环体 */
    ) I1 h  V& b# L* e; L
22.         while (1)
    1 T& ~  a. u, \* T* F0 G9 Y$ [! a
23.         {
    " l- L" Y6 O5 d7 i4 l  C
24.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    3 g7 p0 N  z' Y& _+ P
25. 
    
26.                 /* 判断定时器超时时间 */
      ~8 y1 u  t$ c8 _, R
27.                 if (bsp_CheckTimer(0))        
    8 X% @, e) w, s- `  X. q
28.                 {
    
29.                         /* 每隔100ms 进来一次 */  
    
30.                         bsp_LedToggle(2);                        
    
31.                 }
    
32.                
    & u+ s2 @5 I$ r" d- s' ]% P2 i
33.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    $ F2 W+ G( h' h! X2 T
34.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
35.                 if (ucKeyCode != KEY_NONE)
    
36.                 {
    / W4 P2 W6 A6 r, v
37.                         switch (ucKeyCode)
    
38.                         {
    
39.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    
40.                                         printf("K1键按下\r\n");
    1 t  j3 y( p; V4 T8 t/ O( w
41.                                         break;
    3 K; |. p1 F/ }$ h+ o( Z2 q
42. 
    / K, [" N7 J# M
43.                                 case KEY_UP_K1:                                /* K1键弹起 */
    
44.                                         printf("K1键弹起\r\n");
    ; q; r1 v  g& _$ B+ _7 r$ d$ j" @7 w
45.                                         break;
    
46. 
    ' f5 z. X# r% M% o
47.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    4 S8 \4 A  [6 A: f
48.                                         printf("K2键按下\r\n");
    ' U' N& Z1 o% y
49.                                         break;
    
50. 
      W6 F1 g" i  ~8 h' a3 ?4 v5 Y
51.                                 case KEY_UP_K2:                                /* K2键弹起 */
    ' N) M* K2 e# m/ u% S
52.                                         printf("K2键弹起\r\n");
    
53.                                         break;
    
54. 
    " f, w& }, e& }
55.                                 case KEY_DOWN_K3:                        /* K3键按下 */
    
56.                                         printf("K3键按下\r\n");
    
57.                                         break;
    
58. 
    0 d; e* Y1 D1 G- X. G
59.                                 case KEY_UP_K3:                                /* K3键弹起 */
    
60.                                         printf("K3键弹起\r\n");
    ! N# }7 S/ H9 [/ d. t, F" m7 l
61.                                         break;
    
62. 
    8 K" n/ M" h& d+ B" l( v
63.                                 case JOY_DOWN_U:                        /* 摇杆UP键按下 */
    
64.                                         printf("摇杆上键按下\r\n");
    
65.                                         break;
    
66. 
    & F. b# q! x3 ~
67.                                 case JOY_DOWN_D:                        /* 摇杆DOWN键按下 */
    . n5 v( E* J/ y6 y# {8 ]: Y. B! E
68.                                         printf("摇杆下键按下\r\n");
    1 U5 v7 N8 h4 l+ i
69.                                         break;
    / L# M5 E( Q) n( ^$ E9 n" @$ W
70. 
    * r- B) R, [% ]! U( @
71.                                 case JOY_DOWN_L:                        /* 摇杆LEFT键按下 */
    ( H& @+ ]9 r- i# W4 k0 q  c/ S
72.                                         printf("摇杆左键按下\r\n");
    
73.                                         break;
    & J" o# F/ A; M5 c) T
74.                                 
    1 y0 c9 b( r5 U! U4 S
75.                                 case JOY_LONG_L:            /* 摇杆LEFT键长按 */
    + O3 A9 a' q3 S6 n
76.                                         printf("摇杆左键长按\r\n");
    8 H+ ~/ f4 k' e, N) k6 a
77.                                         break;
    # x# p0 T1 d( f" a
78. 
    
79.                                 case JOY_DOWN_R:                        /* 摇杆RIGHT键按下 */
    
80.                                         printf("摇杆右键按下\r\n");
    , w1 \! x; K& s1 T# f
81.                                         break;
    5 ~3 Y6 S) ~4 [+ m( M
82.                                 
    
83.                                 case JOY_LONG_R:            /* 摇杆RIGHT键长按 */
    
84.                                         printf("摇杆右键长按\r\n");
    ; ]: f* E, ^# I9 @$ i
85.                                         break;
      F# v/ }* b3 b
86. 
    4 X; X2 {) P  d- N* ]4 p' b, x6 c
87.                                 case JOY_DOWN_OK:                        /* 摇杆OK键按下 */
    
88.                                         printf("摇杆OK键按下\r\n");
    
89.                                         break;
    3 g$ K9 ~4 S4 R) g8 J+ e# r0 ]
90. 
    
91.                                 case JOY_UP_OK:                        /* 摇杆OK键弹起 */
    
92.                                         printf("摇杆OK键弹起\r\n");
    
93.                                         break;
    0 S9 O' U5 X. }
94. 
    & l2 Y1 m4 J2 {
95.                 case SYS_DOWN_K1K2:                        /* 摇杆OK键弹起 */
    
96.                                         printf("K1和K2组合键按下\r\n");
    
97.                                         break;
    
98. 
    
99.                                 default:
    ) y8 U5 E  z/ n3 L: v. h
100.                                         /* 其它的键值不处理 */
     + _3 F) _4 |! h1 @8 D7 v- L
101.                                         break;
     
102.                         }
     
103.                
     5 {: X* `1 ^; E( _% M7 G( n
104.                 }
     
105.         }
     % q+ Q4 @3 m! A1 T& \
106. }

复制代码

19.9 总结
; \% M5 {2 l, I/ H这个方案在实际项目中已经经过千锤百炼，大家可以放心使用。建议熟练掌握其用法。
5 F0 C7 `" F0 Q, d