19.1 初学者重要提示
% q- G) O5 m/ Q9 r( i 按键FIFO驱动扩展和移植更简单，组合键也更好用。支持按下、弹起、长按和组合键。

19.2 按键硬件设计
6 M9 A2 l, x( vV7开发板有三个独立按键和一个五向摇杆，下面是三个独立按键的原理图：
: H7 k% V0 `8 ~
5 {+ S3 @, N1 f+ c; M) W* r

1 t/ j8 H3 P" x# m. p- U注意，K1（S1）、K2(S2)和K3(S3)按键的上拉电阻是接在5V电压上，因为这三个按键被复用为PS/2键盘鼠标接口，而PS/2是需要5V供电的（注，V5和V6开发板做了PS/2复用，而V7没有使用，这里只是为了兼容之前的板子）。实际测试，K1、K2、K3按键和PS/2键盘是可以同时工作的。
: }, g6 A' N8 g8 e
& k0 v* h  t6 l5 d2 t: [. g0 s下面是五向摇杆的原理图：
# v$ q; ?  ^6 s' r+ P1 n8 m
" S; Q3 z7 O; c, q% _3 a! _/ K( @, B
1 ~0 U9 ?1 ~2 P& o( B* N5 U
3 ?( @! S, C: U" h" L" q通过这个硬件设计，有如下两个知识点为大家做介绍：

19.2.1 硬件设计
$ z1 D" b5 ^/ Q2 p+ a8 A& u按键和CPU之间串联的电阻起保护作用。按键肯定是存在机械抖动的，开发板上面的硬件没有做硬件滤波处理，即使设计了硬件滤波电路，软件上还是需要进行滤波。

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



红色的线条是GPIO输入通道的信号流向，作为按键检测IO，这些需要配置为浮空输入。按键已经做了5V上拉，因此GPIO内部的上下拉电阻都选择关闭状态。
* x- ~, v1 s, S1 D
* W, G  y& N2 j6 T7 `! v19.3 按键FIFO的驱动设计
) G/ F* r6 d+ qbsp_key按键驱动程序用于扫描独立按键，具有软件滤波机制，采用FIFO机制保存键值。可以检测如下事件：
% s; l/ Q/ D& B+ ]" s
$ F9 F1 w  X/ {' N/ p  按键按下。
  按键弹起。
  长按键。
. M! P- n. c5 r% v$ O! J+ H# D  长按时自动连发。
我们将按键驱动分为两个部分来介绍，一部分是FIFO的实现，一部分是按键检测的实现。
6 Y* p' p7 h7 q4 A$ o2 D
# G5 ]# `+ `3 O( e
+ g  T9 e% V* X! S, E
bsp_key.c 文件包含按键检测和按键FIFO的实现代码。
( U. j+ ^$ C/ c4 j) f7 n2 Z
% \4 L* n( A, n9 [bsp.c 文件会调用bsp_InitKey()初始化函数。
! f0 o+ C2 A* F: I
7 f1 S# |, G7 ]0 z5 Hbsp.c 文件会调用bsp_KeyScan按键扫描函数。
1 @3 @# C3 f# m
bsp_timer.c 中的Systick中断服务程序调用 bsp_RunPer10ms。

3 W+ H( M  x0 \! K$ j3 ^0 e* O1 ]1 l中断程序和主程序通过FIFO接口函数进行信息传递。

7 j0 a1 ~5 B; m函数调用关系图：
& s6 a; e8 m# Z7 _5 r) A
# f' @3 `# J1 Z( P, G" {

( S# N* z6 S+ b& u19.3.1 按键FIFO的原理
FIFO是First Input First Output的缩写，先入先出队列。我们这里以5个字节的FIFO空间进行说明。Write变量表示写位置，Read变量表示读位置。初始状态时，Read = Write = 0。



) ?, ^) _6 s/ E. @- R5 p我们依次按下按键K1，K2，那么FIFO中的数据变为：
& }4 k/ K6 Q# @/ L9 M2 R1 @2 y


1 b) K. ]4 l% G! W( o) X. ^如果Write！= Read，则我们认为有新的按键事件。

我们通过函数bsp_GetKey读取一个按键值进行处理后，Read变量变为1。Write变量不变。
+ p* m! v! w' N


& q3 q2 \$ A% w* |8 [; b+ t我们继续通过函数bsp_GetKey读取3个按键值进行处理后，Read变量变为4。此时Read = Write = 4。两个变量已经相等，表示已经没有新的按键事件需要处理。

有一点要特别的注意，如果FIFO空间写满了，Write会被重新赋值为0，也就是重新从第一个字节空间填数据进去，如果这个地址空间的数据还没有被及时读取出来，那么会被后来的数据覆盖掉，这点要引起大家的注意。我们的驱动程序开辟了10个字节的FIFO缓冲区，对于一般的应用足够了。
* Q* O4 m3 e4 n! \


6 s. k& {7 j1 u& Z6 D设计按键FIFO主要有三个方面的好处：

  可靠地记录每一个按键事件，避免遗漏按键事件。特别是需要实现按键的按下、长按、自动连发、弹起等事件时。
  读取按键的函数可以设计为非阻塞的，不需要等待按键抖动滤波处理完毕。
" o) k# m( q. N  @7 s  r  按键FIFO程序在嘀嗒定时器中定期的执行检测，不需要在主程序中一直做检测，这样可以有效地降低系统资源消耗。
19.3.2 按键FIFO的实现
在bsp_key.h 中定了结构体类型KEY_FIFO_T。这只是类型声明，并没有分配变量空间。
% \: g9 i5 {- i2 M5 _2 y, a4 F
#define KEY_FIFO_SIZE        10
typedef struct
1 v7 [) \! d9 |+ Z5 ^% ~  M{
        uint8_t Buf[KEY_FIFO_SIZE];                /* 键值缓冲区 */
8 q' I3 W: a3 K$ X8 k7 P0 A. ?        uint8_t Read;                                        /* 缓冲区读指针1 */
        uint8_t Write;                             /* 缓冲区写指针 */
) X, y9 u) t  H* h" {        uint8_t Read2;                             /* 缓冲区读指针2 */
0 }  S! L" O: L( Q5 _4 e2 J2 g$ o+ n}KEY_FIFO_T;
在bsp_key.c 中定义s_tKey结构变量, 此时编译器会分配一组变量空间。

static KEY_FIFO_T s_tKey;                /* 按键FIFO变量,结构体 */
一般情况下，只需要一个写指针Write和一个读指针Read。在某些情况下，可能有两个任务都需要访问按键缓冲区，为了避免键值被其中一个任务取空，我们添加了第2个读指针Read2。出厂程序在bsp_Idle()函数中实现的按K1K2组合键截屏的功能就使用的第2个读指针。
  Q# Y* E4 |5 \& a
# ?/ @2 o' o, X/ L( ?当检测到按键事件发生后，可以调用 bsp_PutKey函数将键值压入FIFO。下面的代码是函数的实现：

/*
* g& |3 ^  a+ g/ ?, d! O( l, C; E# O*********************************************************************************************************
*        函 数 名: bsp_PutKey
# b  ^+ b$ g; x" `*        功能说明: 将1个键值压入按键FIFO缓冲区。可用于模拟一个按键。
*        形    参: _KeyCode : 按键代码
*        返 回 值: 无
*********************************************************************************************************
*/
void bsp_PutKey(uint8_t _KeyCode)
{
        s_tKey.Buf[s_tKey.Write] = _KeyCode;
9 j4 c# ~% `6 B& [' o3 T
        if (++s_tKey.Write  >= KEY_FIFO_SIZE)
; b; M4 O+ J& n$ r        {
# W; l- q. H8 w$ ]( g) o& o, I/ E                s_tKey.Write = 0;
; ?( y* m  B! ]4 b7 g        }
) d2 a( H3 i+ E}
这个bsp_PutKey函数除了被按键检测函数调用外，还可以被其他底层驱动调用。比如红外遥控器的按键检测，也共用了同一个按键FIFO。遥控器的按键代码和主板实体按键的键值统一编码，保持键值唯一即可实现两套按键同时控制程序的功能。
9 L* G1 V) f( O/ u% ~: [
应用程序读取FIFO中的键值，是通过bsp_GetKey函数和bsp_GetKey2函数实现的。我们来看下这两个函数的实现：
7 D; p1 h9 L6 n3 U
/*
8 W, c+ I- o$ |1 I9 u*********************************************************************************************************
. x' v- [5 G, R*        函 数 名: bsp_GetKey
9 t/ ], r; |4 Q- x4 _2 T6 m2 l*        功能说明: 从按键FIFO缓冲区读取一个键值。
2 k8 E& o8 \" ^, [  ?8 y*        形    参:  无
# M; ?9 [2 H! G; w! d8 S1 k+ G*        返 回 值: 按键代码
1 A4 ~' O+ R( W*********************************************************************************************************
* `2 I" u: i  v( ]*/
uint8_t bsp_GetKey(void)
: ]5 G: \) ]  t9 C{
) Z/ r4 O8 ~4 |$ |/ Y4 W; o* p+ |' ]+ k        uint8_t ret;

        if (s_tKey.Read == s_tKey.Write)
        {
3 @) l! [9 R4 T, h: d/ k                return KEY_NONE;
4 g% N) Z) Y9 W6 p% L. X6 `        }
2 t) ]2 K4 `0 A  p, G8 c& ]7 w% |        else
        {
                ret = s_tKey.Buf[s_tKey.Read];

                if (++s_tKey.Read >= KEY_FIFO_SIZE)
+ k8 c: s/ Z/ G. l! A- y3 I% G4 D                {
1 V  {/ d- ]# l; S                        s_tKey.Read = 0;
                }
                return ret;
6 m; p" u) y" `7 {' ]        }
5 I, k. K, h" c5 A2 F}
# F+ \" \! h9 ^6 [" G
/*
*********************************************************************************************************
*        函 数 名: bsp_GetKey2
& m+ T  ?/ k1 b6 \/ U/ n0 }; v*        功能说明: 从按键FIFO缓冲区读取一个键值。独立的读指针。
% F( O% W0 @3 k*        形    参:  无
*        返 回 值: 按键代码
*********************************************************************************************************
. d+ O1 V5 g7 M  h0 Q7 @*/
uint8_t bsp_GetKey2(void)
' f4 e& m$ E6 {# F/ b{
        uint8_t ret;

9 e3 ]  p6 h0 d, \5 _        if (s_tKey.Read2 == s_tKey.Write)
  O; @# O, G% v        {
; x2 e3 g' B' I' h0 ^. K                return KEY_NONE;
" v4 V; r4 E0 i6 @, N: t, Y9 s) j- J        }
        else
        {
2 }% t' j  ?. j                ret = s_tKey.Buf[s_tKey.Read2];
' }- a5 y# T) _- \
                if (++s_tKey.Read2 >= KEY_FIFO_SIZE)
                {
5 t0 u( f3 V) F                        s_tKey.Read2 = 0;
2 D3 x0 J* L5 y- J, n                }
                return ret;
7 c; t! ~0 S. s        }
( r3 m" n' Z( h: C3 |$ Z" K}
返回值KEY_NONE = 0, 表示按键缓冲区为空，所有的按键时间已经处理完毕。按键的键值定义在 bsp_key.h文件，下面是具体内容：
' i' c4 g7 U. ~) m" {1 {2 u
typedef enum
. F9 d- J5 S3 }8 c$ G2 \{
        KEY_NONE = 0,                        /* 0 表示按键事件 */

6 `9 o4 ?- d1 R! I2 S& O1 |        KEY_1_DOWN,                        /* 1键按下 */
        KEY_1_UP,                                /* 1键弹起 */
        KEY_1_LONG,                        /* 1键长按 */

        KEY_2_DOWN,                        /* 2键按下 */
        KEY_2_UP,                                /* 2键弹起 */
        KEY_2_LONG,                        /* 2键长按 */
& _3 J3 F- ?* B
        KEY_3_DOWN,                        /* 3键按下 */
        KEY_3_UP,                                /* 3键弹起 */
        KEY_3_LONG,                        /* 3键长按 */

        KEY_4_DOWN,                        /* 4键按下 */
        KEY_4_UP,                                /* 4键弹起 */
! E& k4 z4 u* S2 p, k  h2 U        KEY_4_LONG,                        /* 4键长按 */

        KEY_5_DOWN,                        /* 5键按下 */
        KEY_5_UP,                                /* 5键弹起 */
        KEY_5_LONG,                        /* 5键长按 */

        KEY_6_DOWN,                        /* 6键按下 */
        KEY_6_UP,                                /* 6键弹起 */
! n# q9 m  `9 H) x' z# `        KEY_6_LONG,                        /* 6键长按 */
  V6 S/ {1 V  A2 }- B9 k' n
. J9 z# H, I% y        KEY_7_DOWN,                        /* 7键按下 */
        KEY_7_UP,                                /* 7键弹起 */
        KEY_7_LONG,                        /* 7键长按 */

( l( y- S' G2 C! P/ E        KEY_8_DOWN,                        /* 8键按下 */
        KEY_8_UP,                                /* 8键弹起 */
        KEY_8_LONG,                        /* 8键长按 */
  w8 B7 K0 G- m
        /* 组合键 */
        KEY_9_DOWN,                        /* 9键按下 */
; ]2 x' g/ s  T9 o. }        KEY_9_UP,                                /* 9键弹起 */
        KEY_9_LONG,                        /* 9键长按 */

        KEY_10_DOWN,                        /* 10键按下 */
        KEY_10_UP,                        /* 10键弹起 */
9 g8 \. P5 R, u/ U( R        KEY_10_LONG,                        /* 10键长按 */
  {' D: r# ?* p$ p2 @, l2 g8 o  S}KEY_ENUM;
必须按次序定义每个键的按下、弹起和长按事件，即每个按键对象（组合键也算1个）占用3个数值。我们推荐使用枚举enum, 不用#define的原因：
5 O) n& v# W' K' Y
( z: [, o- ?5 |0 I  便于新增键值,方便调整顺序。
  使用{ } 将一组相关的定义封装起来便于理解。
/ R- ]& ?) X" l" ?* X4 P8 t  编译器可帮我们避免键值重复。
我们来看红外遥控器的键值定义，在bsp_ir_decode.h文件。因为遥控器按键和主板按键共用同一个FIFO，因此在这里我们先贴出这段定义代码，让大家有个初步印象。

9 H3 C& z4 P% H! j/* 定义红外遥控器按键代码, 和bsp_key.h 的物理按键代码统一编码 */
typedef enum
' Y4 k6 x: ~) _. l9 v+ N: c  U. g  E{
        IR_KEY_STRAT         = 0x80,
        IR_KEY_POWER         = IR_KEY_STRAT + 0x45,
. S9 n- c% m) x9 I+ g. \) k0 s        IR_KEY_MENU         = IR_KEY_STRAT + 0x47,
        IR_KEY_TEST         = IR_KEY_STRAT + 0x44,
: s; G  N  q- }5 w+ c8 b        IR_KEY_UP         = IR_KEY_STRAT + 0x40,
) H1 ?  F* [! i& [3 X        IR_KEY_RETURN        = IR_KEY_STRAT + 0x43,
        IR_KEY_LEFT        = IR_KEY_STRAT + 0x07,
        IR_KEY_OK                = IR_KEY_STRAT + 0x15,
* }+ P& c* |& M" u. b        IR_KEY_RIGHT        = IR_KEY_STRAT + 0x09,
        IR_KEY_0                = IR_KEY_STRAT + 0x16,
4 H! V1 r9 S' c* M. Z  ^) q        IR_KEY_DOWN        = IR_KEY_STRAT + 0x19,
% A  r7 N: j& N+ K        IR_KEY_C                = IR_KEY_STRAT + 0x0D,
        IR_KEY_1                = IR_KEY_STRAT + 0x0C,
5 i1 A) y/ o& k7 [  r3 G        IR_KEY_2                = IR_KEY_STRAT + 0x18,
* U0 z+ m2 _4 s        IR_KEY_3                = IR_KEY_STRAT + 0x5E,
        IR_KEY_4                = IR_KEY_STRAT + 0x08,
        IR_KEY_5                = IR_KEY_STRAT + 0x1C,
        IR_KEY_6                = IR_KEY_STRAT + 0x5A,
2 ]$ L* b0 W* u% l        IR_KEY_7                = IR_KEY_STRAT + 0x42,
        IR_KEY_8                = IR_KEY_STRAT + 0x52,
        IR_KEY_9                = IR_KEY_STRAT + 0x4A,       
}IR_KEY_E;
) W2 Y+ V$ }" x% H0 Z1 A; c我们下面来看一段简单的应用。这个应用的功能是：主板K1键控制LED1指示灯；遥控器的POWER键和MENU键控制LED2指示灯。

. u+ }6 ~$ g* x#include "bsp.h"
( P. K+ O( p7 w/ O# f
% J8 b; S( Q2 k. Kint main(void)
{
        uint8_t ucKeyCode;
                       
/ b" m1 Z' R5 ~0 \+ p  e        bsp_Init();
) l+ O' g* v+ H7 e
        IRD_StartWork();        /* 启动红外解码 */
2 R/ N  C( ^0 H0 [: z: W
7 n, d" @& Y! }- c0 B3 \2 f+ m        while(1)
/ p! ?1 S5 z7 a4 w        {
# R/ {/ N2 X! f+ K                bsp_Idle();
               
' C: Q3 e( e4 _1 L* H: D' D8 ~                /* 处理按键事件 */
                ucKeyCode = bsp_GetKey();
                if (ucKeyCode > 0)
                {
) r0 ^& v5 I- w1 X" R, `& k                        /* 有键按下 */
+ h* s: ?+ l: w  o. n; ?  L                        switch (ucKeyCode)
1 W" [" e. J5 p$ _# i+ f' |4 j$ O                        {
                                case KEY_DOWN_K1:                /* K1键按下 */
" S( ^! P. W2 n: R                                        bsp_LedOn(1);                /* 点亮LED1 */
7 a/ D: F% h, a% x; U1 ?9 H                                        break;
( C9 \7 P% ?- l1 \. S) ]" `% N
$ x' V; T% K, i0 }' x2 t                                case KEY_UP_K1:                /* K1键弹起 */
                                        bsp_LedOff(1);        /* 熄灭LED1 */
- P8 M4 i; {# l3 g7 P                                        break;                                       
0 y$ H8 ]9 u3 x: ?: _. U+ b* R3 `8 n
) P: I% D/ U' @+ r. f( ~                                case IR_KEY_POWER:                /* 遥控器POWER键按下 */
                                        bsp_LedOn(1);                /* 点亮LED2 */
% O- I5 H# L$ U9 O                                        break;
4 j9 a% F0 I+ G' ~% x
0 o! z' Z5 X3 r' s4 x                                case IR_KEY_MENU:                /* 遥控器MENU键按下 */
) {. F  l0 p1 [! N6 g: d+ S+ [                                        bsp_LedOff(1);        /* 熄灭LED2 */
! R. f$ m) H# f" G( m- o+ R                                        break;                                       

                                case MSG_485_RX:                /* 通信程序的发来的消息 */
  C4 w, u: U) ~) h                                        /* 执行通信程序的指令 */
# j$ B7 W8 D5 s# @! s9 k                                        break;
) I6 i9 s# P2 v! X2 D/ y
                                default:
                                        break;
                        }
                }
        }
2 f" E% j, J+ r  ?}
看到这里，想必你已经意识到bsp_PutKey函数的强大之处了，可以将不相关的硬件输入设备统一为一个相同的接口函数。

8 l" a& \5 w/ u: ^7 f% d% J在上面的应用程序中，我们特意添加了一段红色的代码来解说更高级的用法。485通信程序收到有效的命令后通过 bsp_PutKey（MSG_485_RX）函数可以通知APP应用程序进行进一步加工处理（比如显示接收成功）。这是一种非常好的任务间信息传递方式，它不会破坏程序结构。不必新增全局变量来做这种事情，你只需要添加一个键值代码。
) _: X" n: i" x% G9 y2 `, @
% _) D0 U. P$ r# W" X对于简单的程序，可以借用按键FIFO来进行少量的信息传递。对于复杂的应用，我们推荐使用bsp_msg专门来做这种任务间的通信。因为bsp_msg除了传递消息代码外，还可以传递参数结构。

19.3.3 按键检测程序分析
在bsp_key.h 中定了结构体类型KEY_T。
! P* }6 Q# I& s# U6 f
#define KEY_COUNT    10                           /* 按键个数, 8个独立建 + 2个组合键 */
& G6 X; P' j5 l% }8 Y: a
) J1 w8 Y  @& P# D* Ntypedef struct
" J2 W' M, Y6 E4 F{
  X* k. k9 B' h$ ~& ]! Z; R9 {, f  }        /* 下面是一个函数指针，指向判断按键手否按下的函数 */
        uint8_t (*IsKeyDownFunc)(void); /* 按键按下的判断函数,1表示按下 */
, y6 ?' _. U2 r" j4 A" |
/ ]9 E$ Z! B  b7 `        uint8_t  Count;                /* 滤波器计数器 */
2 V$ G& X; e* |8 {        uint16_t LongCount;        /* 长按计数器 */
7 l  W& N( m5 S2 p& p5 F        uint16_t LongTime;                /* 按键按下持续时间, 0表示不检测长按 */
        uint8_t  State;                /* 按键当前状态（按下还是弹起） */
        uint8_t  RepeatSpeed;        /* 连续按键周期 */
( G4 Q3 z& }# @  Z; |0 Q        uint8_t  RepeatCount;        /* 连续按键计数器 */
}KEY_T;
: w8 O8 Q2 e; h! }在bsp_key.c 中定义s_tBtn结构体数组变量。
$ w4 V4 K# y6 s# D- g
" `% H. Y& h+ y, Cstatic KEY_T s_tBtn[KEY_COUNT];
5 T+ y% T5 {) Z0 gstatic KEY_FIFO_T s_tKey; /* 按键FIFO变量,结构体 */
3 L- D* V& j+ a* |4 G$ m每个按键对象都分配一个结构体变量，这些结构体变量以数组的形式存在将便于我们简化程序代码行数。

& x- H! ~. D# \$ V3 O4 F. l使用函数指针IsKeyDownFunc可以将每个按键的检测以及组合键的检测代码进行统一管理。

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

; {! y' I# Z! o& g! D3 [/*
*********************************************************************************************************
2 R* X: f% A- w8 W& z*        函 数 名: bsp_InitKey
; M! V) K& b" o. v$ _*        功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
*        形    参: 无
8 \1 i! ]" S, H* @& e*        返 回 值: 无
8 j4 i; U/ W+ \$ f) u7 e*********************************************************************************************************
*/
void bsp_InitKey(void)
' A9 T! i, E6 B8 {{
        bsp_InitKeyVar();                /* 初始化按键变量 */
        bsp_InitKeyHard();                /* 初始化按键硬件 */
1 n; `8 L# u/ r* y/ ^7 N0 k}
0 r5 i  U9 k/ u" @下面是bsp_InitKeyVar函数的定义：

/*
( n( d5 }. ~3 U*********************************************************************************************************
; u' u+ z/ x. \! o9 K2 D* L4 A*        函 数 名: bsp_InitKeyVar
*        功能说明: 初始化按键变量
) e1 y) G$ }0 C2 s*        形    参:  无
*        返 回 值: 无
6 R: [0 I2 G9 X: @) T$ w*********************************************************************************************************
*/
6 a! [* s" H: ?  z; i" bstatic void bsp_InitKeyVar(void)
{
        uint8_t i;

        /* 对按键FIFO读写指针清零 */
        s_tKey.Read = 0;
        s_tKey.Write = 0;
  f# S8 [- a! |* o" g  H        s_tKey.Read2 = 0;
" F7 L9 `. P; Q5 e- _
        /* 给每个按键结构体成员变量赋一组缺省值 */
        for (i = 0; i < KEY_COUNT; i++)
        {
                s_tBtn.LongTime = KEY_LONG_TIME;                        /* 长按时间 0 表示不检测长按键事件 */
                s_tBtn.Count = KEY_FILTER_TIME / 2;                /* 计数器设置为滤波时间的一半 */
                s_tBtn.State = 0;                                                /* 按键缺省状态，0为未按下 */
                s_tBtn.RepeatSpeed = 0;                                        /* 按键连发的速度，0表示不支持连发 */
                s_tBtn.RepeatCount = 0;                                        /* 连发计数器 */
        }
5 z; H* E/ h9 V  _% r
        /* 如果需要单独更改某个按键的参数，可以在此单独重新赋值 */
       
3 W* u8 q' U, j/ p& n8 U0 z  Z        /* 摇杆上下左右，支持长按1秒后，自动连发 */
        bsp_SetKeyParam(KID_JOY_U, 100, 6);
: t* D- t& T% F        bsp_SetKeyParam(KID_JOY_D, 100, 6);
) F, u  y+ _0 v# M' t8 f, O        bsp_SetKeyParam(KID_JOY_L, 100, 6);
" b  \- T- }( K  Z  O* F4 I        bsp_SetKeyParam(KID_JOY_R, 100, 6);
1 r1 |5 a4 |9 s$ y  T. U- }}
注意一下 Count 这个成员变量，没有设置为0。为了避免主板上电的瞬间，检测到一个无效的按键按下或弹起事件。我们将这个滤波计数器的初值设置为正常值的1/2。bsp_key.h中定义了滤波时间和长按时间。

/*
% L- l' B6 v/ s# I* ^# @& S& u        按键滤波时间50ms, 单位10ms。
  S2 x4 q* b0 ~" a+ ?. T1 p        只有连续检测到50ms状态不变才认为有效，包括弹起和按下两种事件
! v5 T$ o" b" j5 J- m        即使按键电路不做硬件滤波，该滤波机制也可以保证可靠地检测到按键事件
*/
#define KEY_FILTER_TIME   5
#define KEY_LONG_TIME     100                        /* 单位10ms， 持续1秒，认为长按事件 */
uint8_t KeyPinActive(uint8_t _id)（会调用函数KeyPinActive判断状态）函数就是最底层的GPIO输入状态判断函数。

/ I( ], L" n# z$ N$ B% z/*
*********************************************************************************************************
7 M1 T# [; s( M; u$ }% B; P*        函 数 名: KeyPinActive
*        功能说明: 判断按键是否按下
0 Q% q6 d- X3 ?- g*        形    参: 无
& s& f+ T6 N3 @; j0 e* s# K" J& |: k*        返 回 值: 返回值1 表示按下(导通），0表示未按下（释放）
*********************************************************************************************************
7 T( u1 d  a8 s0 `3 O) W8 ]*/
static uint8_t KeyPinActive(uint8_t _id)
( c$ b8 Y, Y. X: s5 `{
% b" @7 L( K6 [& j. t        uint8_t level;
       
' |9 ~- T; o' h        if ((s_gpio_list[_id].gpio->IDR & s_gpio_list[_id].pin) == 0)
        {
' D) z3 C( X3 Q0 k  P                level = 0;
        }
        else
        {
- w8 \! \1 i$ B7 Y5 m* b                level = 1;
6 z# O/ L* V2 A4 f/ l( Z8 S. p1 O        }
. H: y4 C  e4 ?
        if (level == s_gpio_list[_id].ActiveLevel)
        {
5 K0 d2 x5 D  [8 F0 M- C$ Z. j                return 1;
        }
. P$ I" _& Q" H6 b        else
" U( w2 s; W% p/ f        {
                return 0;
9 T1 @5 ?. w. |9 v8 Y% E' D% l. s        }
& @' Z0 l" z/ ~+ Q0 r1 `7 J* V; h8 [# a}
4 J; \, }  L, v& u4 j3 o
2 L5 t: {  C0 p3 @/*
*********************************************************************************************************
: G" X& j; M' }: U) A# g2 x*        函 数 名: IsKeyDownFunc
*        功能说明: 判断按键是否按下。单键和组合键区分。单键事件不允许有其他键按下。
*        形    参: 无
*        返 回 值: 返回值1 表示按下(导通），0表示未按下（释放）
* [: T$ W# @1 I* e% K% K*********************************************************************************************************
$ e' U2 n  [; q3 ~8 D4 p  H*/
1 x& Q0 x+ }6 tstatic uint8_t IsKeyDownFunc(uint8_t _id)
1 g2 b$ U; n7 v0 J; ~{
! w4 E  W, s5 s9 h" K        /* 实体单键 */
, S2 K8 u3 s$ M: X! C        if (_id < HARD_KEY_NUM)
1 F6 t0 ^* T* ?& L8 s3 J        {
9 ]5 E& O. u$ s: T1 l' I0 p                uint8_t i;
2 [* F5 _, k9 u- Q3 \4 f9 `" q                uint8_t count = 0;
                uint8_t save = 255;
               
                /* 判断有几个键按下 */
! o, k+ S  v- H! j" b; v                for (i = 0; i < HARD_KEY_NUM; i++)
                {
                        if (KeyPinActive(i))
                        {
                                count++;
# @8 F( W# c7 a! x) u  j                                save = i;
8 m" d4 E4 f& ?) _- ]                        }
                }
               
                if (count == 1 && save == _id)
5 N9 ]' k3 j2 h0 E' a# e: P9 U& w                {
                        return 1;        /* 只有1个键按下时才有效 */
! I* R* `+ F0 A' ]3 W                }               

) b9 V+ T& f% E                return 0;
  `6 E2 \0 `! n; B        }
       
        /* 组合键 K1K2 */
        if (_id == HARD_KEY_NUM + 0)
        {
; q% b0 }1 P1 V6 I                if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
7 @/ B* N0 n4 T6 ^! ]/ y6 s2 i- _                {
                        return 1;
                }
                else
                {
5 I9 l& T0 o' w% |) y. R                        return 0;
                }
9 c, _5 `7 s. J' L5 L, T& G        }
; k) [* f* F& D# F9 K) Q% V4 I
' r& l3 `# S& X        /* 组合键 K2K3 */
        if (_id == HARD_KEY_NUM + 1)
# X9 L* a& \1 T. m* ?- }3 f6 a- U/ V" u        {
                if (KeyPinActive(KID_K2) && KeyPinActive(KID_K3))
                {
- z, V8 ?; b$ V! M+ g                        return 1;
                }
5 U0 ?& L5 ^1 m! j0 `                else
) |4 Z+ C0 c6 X4 ~) @' V                {
                        return 0;
  l) K' Q  G/ w2 k                }
        }

1 M6 `; q* g: `( Z4 P0 s9 d; x& i: o        return 0;
8 C" x; I4 G9 V% a}
( b. |( [; W7 g. {在使用GPIO之前，我们必须对GPIO进行配置，比如打开GPIO时钟，设置GPIO输入输出方向，设置上下拉电阻。下面是配置GPIO的代码，也就是bsp_InitKeyHard（）函数：
) C- _6 K2 ^; [6 {) i8 }
; B7 @. ?, E8 y; l$ H0 J; U* @/*
7 E( c  j/ `% a  O6 a5 L( S8 ^*********************************************************************************************************
5 x1 a! a& K& b  j*        函 数 名: bsp_InitKeyHard
/ H6 N2 |; \& d$ |7 a, {* V*        功能说明: 配置按键对应的GPIO
*        形    参:  无
. I3 S& Z" D* A( C/ O) t*        返 回 值: 无
*********************************************************************************************************
*/
( [$ g) J  L! B( |static void bsp_InitKeyHard(void)
1 `. k/ h/ n  m) p{       
        GPIO_InitTypeDef gpio_init;
7 k: s4 @. x1 D- e* C' X        uint8_t i;

        /* 第1步：打开GPIO时钟 */
& R% _7 O6 M1 v* f6 D: S! t        ALL_KEY_GPIO_CLK_ENABLE();
5 K1 `- l. A% L' q9 |       
        /* 第2步：配置所有的按键GPIO为浮动输入模式(实际上CPU复位后就是输入状态) */
2 [; L% t" D- H5 B        gpio_init.Mode = GPIO_MODE_INPUT;                           /* 设置输入 */
        gpio_init.Pull = GPIO_NOPULL;                 /* 上下拉电阻不使能 */
1 d% k$ h/ V6 u* F, n2 t  Y% J        gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;  /* GPIO速度等级 */
       
        for (i = 0; i < HARD_KEY_NUM; i++)
8 M" B0 A; r: B0 @# R/ U        {
                gpio_init.Pin = s_gpio_list.pin;
                HAL_GPIO_Init(s_gpio_list.gpio, &gpio_init);       
4 j% [2 Q4 O1 K  m2 O, a& H2 I        }
! q1 Q( c; b) C5 D. y" Y}
我们再来看看按键是如何执行扫描检测的。

/ G; g5 a. v. K9 z按键扫描函数bsp_KeyScan10ms ()每隔10ms被执行一次。bsp_RunPer10ms函数在systick中断服务程序中执行。

void bsp_RunPer10ms(void)
5 m+ t$ P, k6 P9 y4 G{
        bsp_KeyScan10ms();                /* 扫描按键 */
}
7 k9 @( |! H( t& ]2 Obsp_KeyScan10ms ()函数的实现如下：
5 X3 s2 ^& c0 \
2 Z' M7 z+ P- J: h9 M3 ^3 U/ v. A/*
*********************************************************************************************************
! w" L; m" E6 N5 z$ S4 _+ X5 n*        函 数 名: bsp_KeyScan10ms
# W' }9 J1 i7 ^+ b! Y* q  j7 c*        功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
*        形    参: 无
*        返 回 值: 无
*********************************************************************************************************
*/
void bsp_KeyScan10ms(void)
: `7 J0 F! D8 P( A; O{
        uint8_t i;

        for (i = 0; i < KEY_COUNT; i++)
        {
                bsp_DetectKey(i);
! d9 A. q" |# K8 k        }
}
' ?4 Q! O0 H! E# x7 a# F6 B6 l每隔10ms所有的按键GPIO均会被扫描检测一次。bsp_DetectKey函数实现如下：
; [' w- d# z1 J
( h; t! d3 @& f5 D/ g0 ?/*
  v3 B$ w0 Q2 j% p% `*********************************************************************************************************
*        函 数 名: bsp_DetectKey
% r, T3 J. _3 y* Z! {% f, }! q*        功能说明: 检测一个按键。非阻塞状态，必须被周期性的调用。
+ w7 I4 W( H5 z- Y*        形    参: IO的id， 从0开始编码
/ B& Y+ d$ y, |) L  w# G*        返 回 值: 无
' f$ Q' O$ W4 ], V*********************************************************************************************************
*/
/ i# Z% I. k+ w- }static void bsp_DetectKey(uint8_t i)
{
        KEY_T *pBtn;
8 X% j, a" `, k* o
        pBtn = &s_tBtn;
        if (IsKeyDownFunc(i))
        {
9 C& R& D7 \: [4 F                if (pBtn->Count < KEY_FILTER_TIME)
! b& T# n4 W* W3 D- L2 ^                {
) U' t4 u9 e( F                        pBtn->Count = KEY_FILTER_TIME;
. ]+ N4 X9 n4 E3 h! V) ^* b                }
                else if(pBtn->Count < 2 * KEY_FILTER_TIME)
                {
( L) `) @6 j# R% v: Y% y                        pBtn->Count++;
                }
; {/ C4 V; b# [9 x7 ]3 _                else
( N: g0 V1 Z8 |5 I( Y                {
                        if (pBtn->State == 0)
                        {
0 H- a8 h# N; W6 v+ X* a; |( k5 z                                pBtn->State = 1;
( K' b" f! Z) q1 x0 n+ k
                                /* 发送按钮按下的消息 */
                                bsp_PutKey((uint8_t)(3 * i + 1));
                        }
, P. O# z& H6 a) _7 ^+ Z4 a9 y  D
& U- l* o5 o6 k0 n2 b8 _6 {                        if (pBtn->LongTime > 0)
                        {
5 |1 j% G6 O+ n, G, n                                if (pBtn->LongCount < pBtn->LongTime)
! u9 C. r8 b$ l) t" ]$ ]                                {
                                        /* 发送按钮持续按下的消息 */
: y, n& t( P+ I+ f7 I) O+ [7 z                                        if (++pBtn->LongCount == pBtn->LongTime)
1 B, _& T' @* l                                        {
                                                /* 键值放入按键FIFO */
                                                bsp_PutKey((uint8_t)(3 * i + 3));
1 ~0 ]/ y. B' @* _; D" c! K                                        }
; O( ?" M( h4 K7 g5 y6 N4 ~6 C% E                                }
# _" q! x1 i$ A8 n: X) a4 a% [                                else
8 P8 o+ _1 ]2 r+ N                                {
                                        if (pBtn->RepeatSpeed > 0)
& J9 _1 a- i6 ], N  }$ ~% D& I3 x                                        {
                                                if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
) N  w) T; V9 W( }% X                                                {
7 [# U# s& y2 i& e4 W                                                        pBtn->RepeatCount = 0;
                                                        /* 常按键后，每隔RepeatSpeed * 10ms发送1个按键 */
' F5 S. a) t/ q! c0 o, [) U/ U+ W                                                        bsp_PutKey((uint8_t)(3 * i + 1));
9 s2 M1 Y4 j( C7 e2 }                                                }
                                        }
                                }
; A% \! t9 }/ H                        }
                }
        }
2 T' b& p) [0 Z0 B" N* {+ R9 `        else
$ ]8 y+ n7 r8 \$ k8 _5 N8 y" F  ?: P        {
, E2 b4 y5 x+ M/ I* `                if(pBtn->Count > KEY_FILTER_TIME)
9 d( M: S- f1 Q7 s! G1 J6 ]                {
" T$ }: E  N. _                        pBtn->Count = KEY_FILTER_TIME;
' }4 W) ?  ]8 H% v) [% w                }
                else if(pBtn->Count != 0)
                {
                        pBtn->Count--;
& j+ e- |2 t6 k* a                }
7 q4 q% f  U% [' v                else
: Y$ j# A% g- }8 w9 i! |4 h                {
                        if (pBtn->State == 1)
                        {
7 Y0 c8 W: X5 q                                pBtn->State = 0;

                                /* 发送按钮弹起的消息 */
                                bsp_PutKey((uint8_t)(3 * i + 2));
                        }
                }
* u- R# t; A( l  ^+ Q3 V
                pBtn->LongCount = 0;
                pBtn->RepeatCount = 0;
" O' s+ S9 `- I$ v0 {, o        }
}
4 n0 C; j9 t$ q: f0 t( c; B  r! r对于初学者，这个函数看起来比较吃力，我们拆分进行分析。

pBtn = &s_tBtn;
$ H. Z: v% C8 x% |% @读取相应按键的结构体地址，程序里面每个按键都有自己的结构体。

5 t& r5 A5 X; _* Y, f, w5 R& Wstatic KEY_T s_tBtn[KEY_COUNT];
( W3 ]: H7 s& H% A9 wif (IsKeyDownFunc(i))
2 k7 x& \; Z) o) Z1 w, T{
        这个里面执行的是按键按下的处理
}
# @) D5 T& G, l& melse
7 h: d8 z( K4 B6 _{
# G; P5 H5 [2 W/ A        这个里面执行的是按键松手的处理或者按键没有按下的处理
}
  {7 z3 J1 Y. ~0 @8 j3 t执行函数IsKeyDownFunc(i)做按键状态判断。
5 V1 D# f+ q; p( }& u
: l" @5 ]. Q# W# _  b* G% c" j/*
**********************************************************************************
下面这个if语句主要是用于按键滤波前给Count设置一个初值，前面说按键初始化的时候
已经设置了Count = KEY_FILTER_TIME/2
**********************************************************************************
*/
if (pBtn->Count < KEY_FILTER_TIME)
{
5 H) g5 m8 T# ?4 o2 e    pBtn->Count = KEY_FILTER_TIME;
; n8 j$ R# @% W. g}

/*
**********************************************************************************
这里实现KEY_FILTER_TIME时间长度的延迟
**********************************************************************************
*/
else if(pBtn->Count < 2 * KEY_FILTER_TIME)
{
    pBtn->Count++;
1 u& D7 t1 D7 }4 ^% H& N0 [}
/*
**********************************************************************************
9 X7 U- L  \$ N$ U这里实现KEY_FILTER_TIME时间长度的延迟
**********************************************************************************
*/
1 L& ^" p8 F( N8 D3 ^) N6 felse
8 b# \8 L% U) F4 C( V1 Z{
/*
& M2 W5 Q& u3 l0 `4 T$ o**********************************************************************************
这个State变量是有其实际意义的，如果按键按下了，这里就将其设置为1，如果没有按下这个
变量的值就会一直是0，这样设置的目的可以有效的防止一种情况的出现：比如按键K1在某个
时刻检测到了按键有按下，那么它就会做进一步的滤波处理，但是在滤波的过程中，这个按键
- |0 x1 T0 _0 A+ G, T2 C2 t4 P# N  `" r按下的状态消失了，这个时候就会进入到上面第二步else语句里面，然后再做按键松手检测滤波
，滤波结束后判断这个State变量，如果前面就没有检测到按下，这里就不会记录按键弹起。
**********************************************************************************
# b0 k6 u& M; G' ^: U*/
: K% b- \3 k3 u6 ]4 ^& {  `( q    if (pBtn->State == 0)
" K/ X3 I, T& F, h9 K    {
        pBtn->State = 1;

+ F9 O9 v8 V% e  a        /* 发送按钮按下的消息 */
        bsp_PutKey((uint8_t)(3 * i + 1));
    }

* c6 O$ T- L9 ~( }8 i& j: \    if (pBtn->LongTime > 0)
& @6 Y  E! ^/ k# `, l    {
        if (pBtn->LongCount < pBtn->LongTime)
0 h, U7 `2 p; l        {
, D8 x8 ?% t8 s: y0 I" F* [- X            /* 发送按钮持续按下的消息 */
            if (++pBtn->LongCount == pBtn->LongTime)
            {
4 y: ~" a: }9 V* Y  t3 R6 Y                /* 键值放入按键FIFO */
                bsp_PutKey((uint8_t)(3 * i + 3));
            }
        }
        else
        {
            if (pBtn->RepeatSpeed > 0)
8 K- s: A6 Z) M* x# `. V( y            {
9 B! s6 P* P4 z+ j5 R9 v                if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
1 W, _$ l* E  P# c8 v& o9 e                {
                    pBtn->RepeatCount = 0;
9 H3 _3 j" Y& ^( @: i: v                    /* 长按键后，每隔10ms发送1个按键 */
4 n8 `* L% ^' |  S; [0 M                    bsp_PutKey((uint8_t)(3 * i + 1));
4 l; E% o, v5 {3 a                }
            }
3 t2 N6 W6 N( @- }) \4 |  ?+ z        }
    }
}
19.3.4 按键检测采用中断方式还是查询方式
2 i6 w: h. b! v& x0 i" j检测按键有中断方式和GPIO查询方式两种。我们推荐大家用GPIO查询方式。

8 l$ z1 A( I+ `2 C6 i3 f从裸机的角度分析

中断方式：中断方式可以快速地检测到按键按下，并执行相应的按键程序，但实际情况是由于按键的机械抖动特性，在程序进入中断后必须进行滤波处理才能判定是否有效的按键事件。如果每个按键都是独立的接一个IO引脚，需要我们给每个IO都设置一个中断，程序中过多的中断会影响系统的稳定性。中断方式跨平台移植困难。
0 t0 Y  A) b1 Y; d
2 l0 A. g2 {4 u5 I$ _6 l查询方式：查询方式有一个最大的缺点就是需要程序定期的去执行查询，耗费一定的系统资源。实际上耗费不了多大的系统资源，因为这种查询方式也只是查询按键是否按下，按键事件的执行还是在主程序里面实现。
: X" n/ g' T. l
从OS的角度分析

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

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

19.4 按键板级支持包（bsp_key.c）
5 o" m0 a9 B2 q按键驱动文件bsp_key.c主要实现了如下几个API：
, b( }3 a/ a7 L1 M3 A/ @
- s3 n& d& p; e  KeyPinActive
  IsKeyDownFunc
3 u- v" }* y* N+ ^  bsp_InitKey
  bsp_InitKeyHard
7 L- M. x: W# J" N% d$ L  bsp_InitKeyVar
  bsp_PutKey
( u+ u. h. T: N  bsp_GetKey
$ M) L+ o: F0 D, r  k  bsp_GetKey2
  bsp_GetKeyState
  bsp_SetKeyParam
  bsp_ClearKey
  bsp_DetectKey
  bsp_DetectFastIO
( [5 v/ @2 E* G9 i6 J  bsp_KeyScan10ms
  bsp_KeyScan1ms
6 E, Q- u' q0 q2 Q- O$ z4 S

所有这些函数在本章的19.3小节都进行了详细讲解，本小节主要是把需要用户调用的三个函数做个说明。
9 ]2 i& U2 Z0 a' i$ w
( U' z) W% Z( N3 w, f' s% ]9 L19.4.1 函数bsp_InitKeyHard
# A9 G2 b* C* |+ u函数原型：

; Y  ?; s* Z$ [: m/ G7 f/*
" P" W% {, h2 |1 G2 X  M+ H*********************************************************************************************************
*        函 数 名: bsp_InitKey
*        功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
*        形    参: 无
*        返 回 值: 无
. y" l: _4 C) G% ^*********************************************************************************************************
*/
void bsp_InitKey(void)
4 e" d" N: v3 W- S{
        bsp_InitKeyVar();                /* 初始化按键变量 */
        bsp_InitKeyHard();                /* 初始化按键硬件 */
, j1 b4 f9 [5 V  L5 W: I}
函数描述：
8 R4 E& M  @: y( |& @- n& b
此函数主要用于按键的初始化。
" T" X: V0 u4 R  ?
; K2 D; W, A7 `" m; r使用举例：

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

) v% f* @3 {# o8 w( o1 A! n19.4.2 函数bsp_GetKey
6 m7 k5 r8 o+ y- R) C& K' c函数原型：

/*
0 a* N$ K2 }6 {. b3 p  v*********************************************************************************************************
+ h/ s! ~* N6 n; h  z7 @" o6 {*        函 数 名: bsp_GetKey
*        功能说明: 从按键FIFO缓冲区读取一个键值。
*        形    参: 无
*        返 回 值: 按键代码
*********************************************************************************************************
*/
% Y  P, m+ W& S2 Guint8_t bsp_GetKey(void)
{
8 ~, S' q: X& O6 V  F& c7 G" K8 c        uint8_t ret;
' F9 {) \! H( }. E# `8 T
7 x! {1 }6 j+ z" ]        if (s_tKey.Read == s_tKey.Write)
        {
2 n, p0 c* {. t. R& ]1 r% A6 Z                return KEY_NONE;
, ^0 h0 T) T' |1 `        }
        else
        {
, I7 q8 @8 ^1 @% Q& A# ~/ R                ret = s_tKey.Buf[s_tKey.Read];
4 b7 P$ M4 a1 ^7 b6 u9 i) {
' {6 c) u3 C) P4 D0 Y+ B                if (++s_tKey.Read >= KEY_FIFO_SIZE)
                {
                        s_tKey.Read = 0;
                }
                return ret;
* q' r8 G& i; N1 b6 y        }
}
- V2 N& J5 V5 k: C6 K5 d, E6 x/ Z函数描述：
4 e  V) B; ]% R: `1 C! |! t$ y
此函数用于从FIFO中读取键值。
4 I) a" E/ K9 G* w' ]
使用举例：

* A/ Q  Q; h* p& n  k) {( j( C7 v' L调用此函数前，务必优先调用函数bsp_InitKey进行初始化。
. Q4 X6 \) N( P. P' Y
/*
*********************************************************************************************************
- _  M8 ^8 f& J; S2 k% A*        函 数 名: main
*        功能说明: c程序入口
- J3 K# {2 m7 @: \- V*        形    参: 无
*        返 回 值: 错误代码(无需处理)
*********************************************************************************************************
+ L1 n2 f" d  J*/
int main(void)
: r  }! e( u! C{
        uint8_t ucKeyCode;                /* 按键代码 */
       
$ ^" j1 {% J% k& i2 E2 t. H8 S0 R        bsp_Init();                /* 硬件初始化 */
# v9 K( m+ z8 U       
, ^+ h+ l7 i8 `; g2 M6 B        /* 进入主程序循环体 */
        while (1)
0 `/ j7 N. U, D$ u# r1 K        {               
                /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
                ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
9 B$ Q$ |) }5 a) k' i7 L4 B                if (ucKeyCode != KEY_NONE)
( T, a: D$ ^1 y) B2 p* u5 h% }                {
9 }( |. U- }2 m  w                        switch (ucKeyCode)
                        {
                                case KEY_DOWN_K1:                        /* K1键按下 */
" A' `* h3 p% r9 H+ I' f                                        printf("K1键按下\r\n");
                                        break;

                                case KEY_DOWN_K2:                        /* K2键按下 */
                                        printf("K2键按下\r\n");
                                        break;

                                default:
# U. H9 y3 P7 M- R5 T5 a- P8 \                                        /* 其它的键值不处理 */
* Q5 l0 h4 `) r" h' o                                        break;
2 |7 {% t) R) c7 G1 O& T- }& o7 X                        }
                }
        }
6 l  F- k+ F" W7 \/ F}
19.4.3 函数bsp_KeyScan10ms
; o" F8 Y6 _- L# f' @% _函数原型：
- E& E! W; N* {1 X9 H, c* v
0 [4 V* U5 ?$ ~/*
*********************************************************************************************************
*        函 数 名: bsp_KeyScan10ms
' x# m, g* I2 a7 n*        功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
*        形    参: 无
$ y* r0 l; }. T# S9 U% b1 }*        返 回 值: 无
2 \9 F! b7 o! V*********************************************************************************************************
*/
void bsp_KeyScan10ms(void)
& p2 t+ @  O( R/ z5 E{
& H* ?' l$ t4 U4 X        uint8_t i;

        for (i = 0; i < KEY_COUNT; i++)
        {
, H8 T9 U$ i6 G! f                bsp_DetectKey(i);
( r9 U, X. b7 w. s3 [- `        }
  b3 [0 C& f$ X+ h}
* }( Z- x( ^! [1 v6 a4 t函数描述：
* T1 R; N/ K  i! I9 _, W
5 `6 W0 A, ?7 H; [0 C8 ?5 @此函数是按键的主处理函数，用于检测和存储按下、松手、长按等状态。

使用举例：

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

! L/ X* r5 I0 G+ Q& c+ D3 y0 F0 c( p另外，此函数需要周期性调用，每10ms调用一次。

  如果是裸机使用，将此函数放在bsp.c文件的bsp_RunPer10ms函数里面即可，这个函数是由滴答定时器调用的，也就是说，大家要使用按键，定时器的初始化函数bsp_InitTimer一定要调用。
  如果是RTOS使用，需要开启一个10ms为周期的任务调用函数bsp_KeyScan10ms。
% b5 _* K) {0 A1 L19.5 按键FIFO驱动移植和使用
按键移植步骤如下：

* V* `0 b0 t! H: _  第1步：复制bsp_key.c和bsp_key.c到自己的工程。
  第2步：根据自己使用的独立按键个数和组合键个数，修改几个地方。
#define HARD_KEY_NUM        8                     /* 实体按键个数 */
3 O3 E, z* t4 B" R) ]8 b#define KEY_COUNT   (HARD_KEY_NUM + 2)   /* 8个独立建 + 2个组合按键 */
  第3步：根据使用的引脚时钟，修改下面函数：
6 p8 J% g/ t9 h( v9 S# X/* 使能GPIO时钟 */
3 k3 t/ X9 w. r( v7 Y#define ALL_KEY_GPIO_CLK_ENABLE() {        \
9 t( v2 |& j. `6 i4 N% B( P                __HAL_RCC_GPIOB_CLK_ENABLE();        \
                __HAL_RCC_GPIOC_CLK_ENABLE();        \
: V& j9 g# Y$ H9 E# E                __HAL_RCC_GPIOG_CLK_ENABLE();        \
* m$ t: K4 [, x( ~                __HAL_RCC_GPIOH_CLK_ENABLE();        \
                __HAL_RCC_GPIOI_CLK_ENABLE();        \
- p1 |5 t" x4 w. |% z4 L        };
  第4步：根据使用的具体引脚，修改如下函数，第3列参数低电平表示按下或者高电平表示按下：
8 E3 }2 J" X1 e1 ]" W% b/* GPIO和PIN定义 */
static const X_GPIO_T s_gpio_list[HARD_KEY_NUM] = {
$ g: [- M- p- y6 {        {GPIOI, GPIO_PIN_8, 0},                /* K1 */
2 p# b# H5 C6 {, z' W) I& z        {GPIOC, GPIO_PIN_13, 0},        /* K2 */
! f/ |! o. C, ]* t        {GPIOH, GPIO_PIN_4, 0},                /* K3 */
+ V+ c5 _( I; M( r/ w2 V* j        {GPIOG, GPIO_PIN_2, 0},                /* JOY_U */       
/ I' G% }  p7 b% y9 M        {GPIOB, GPIO_PIN_0, 0},                /* JOY_D */
* a3 n# N. m, l6 \& o* ]: Q        {GPIOG, GPIO_PIN_3, 0},                /* JOY_L */       
        {GPIOG, GPIO_PIN_7, 0},                /* JOY_R */       
        {GPIOI, GPIO_PIN_11, 0},        /* JOY_OK */
};       
  第5步：根据使用的组合键个数，在函数IsKeyDownFunc里面添加相应个数的函数：
        /* 组合键 K1K2 */
9 |' g. w2 {( [        if (_id == HARD_KEY_NUM + 0)
; g7 S3 H5 t  x% J) v6 U        {
                if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
                {
5 ?& o  K) `( c9 n                        return 1;
                }
                else
8 Q+ `0 U4 k% x/ G2 X$ q, h                {
                        return 0;
5 E9 b5 @$ Q, ^- i7 T! _                }
  i4 V: U9 u% k# s* ]        }
第2行ID表示HARD_KEY_NUM + 0的组合键，HARD_KEY_NUM + 1表示下一个组合键，以此类推。

另外就是，函数KeyPinActive的参数是表示检测哪两个按键，设置0的时候表示第4步里面的第1组按键，设置为1表示第2组按键，以此类推。

  第6步：主要用到HAL库的GPIO驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
  第7步：移植完整，应用方法看本章节配套例子即可。
特别注意，别忘了每10ms调用一次按键检测函数bsp_KeyScan10ms。

19.6 实验例程设计框架
% O& P/ J0 l4 j  [! P) j通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：



1、 第1阶段，上电启动阶段：
7 O. A; d$ ]; x
2 _# Y  a3 C4 @% O这部分在第14章进行了详细说明。
2 q( w" a1 y3 G4 V! `$ c
- V. e9 z5 R/ F( Z- z  V 2、 第2阶段，进入main函数：
6 i5 y1 a- Q2 J! B
  第1部分，硬件初始化，主要是MPU、Cache、HAL库、系统时钟、滴答定时器、按键等。
# |% {$ |8 u: A* X4 x* V  第2部分，应用程序设计部分，实现了一个按键应用。
" F2 q/ N) Z8 l9 P4 x2 H  第3部分，按键扫描程序每10ms在滴答定时中断执行一次。
9 n  g0 S8 h" p- N: g19.7 实验例程说明（MDK）
配套例子：
7 d. ^1 T5 }3 l/ c. I3 ^7 f# Q
V7-002_按键检测（软件滤波，FIFO机制）
6 {. |& \5 R- H- f8 X. ~
9 {5 P9 T  o3 f) |9 N: c实验目的：
- d' x' m7 O9 F
  H: H! x; _9 {% D0 U学习按键的按下，弹起，长按和组合键的实现。
实验内容：
7 T" b9 F% o% S/ T: ~: z% s" k
. m+ {! u0 A6 D1 e) C启动一个自动重装软件定时器，每100ms翻转一次LED2。
* o% j  x! E1 k. e" s6 J实验操作：

3 g' H2 U# {7 l5 S/ R2 g3个独立按键和5向摇杆按下时均有串口消息打印。
2 s. X2 s# J( ^# }5向摇杆的左键和右键长按时，会有连发的串口消息。
2 O% h' c: V8 h6 k5 h1 ^- }独立按键K1和K2按键按下，串口打印消息。
& j% n! P+ G0 \# K4 N3 i! ]上电后串口打印的信息：

0 c- K- ~9 W. A2 Z* \波特率 115200，数据位 8，奇偶校验位无，停止位 1

- I0 c4 h" F! d; z
5 [6 X4 Q1 z. {& \' ^
程序设计：

3 O% a. {0 A4 U$ P7 K( R! E  系统栈大小分配：

3 e# p. J- S% J- f9 \" J

  RAM空间用的DTCM：
4 a: w! A9 f- g$ o/ `0 j9 C$ W$ p


  硬件外设初始化

7 }# [* b$ s7 E. J' Z) ?硬件外设的初始化是在 bsp.c 文件实现：

/*
; U9 `: R# e0 d9 X0 Q! ?' O*********************************************************************************************************
*        函 数 名: bsp_Init
% G$ \! l$ {  ?) w*        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
$ c; `! L; u2 [9 Z. F*        形    参：无
*        返 回 值: 无
1 I0 |* E$ P& n% a9 ^*********************************************************************************************************
*/
7 Y8 E  i; ]" M: F0 {' mvoid bsp_Init(void)
- ]* T4 n  ~3 m* `# B- @) n/ U{
    /* 配置MPU */
1 ~9 Z5 a: e, W' l" o  g6 g        MPU_Config();
$ w' q0 d+ g( Z$ w3 R, W; i% y       
+ O7 u, G+ Y5 C& {  z        /* 使能L1 Cache */
, N4 t! Z7 ?% z4 `, B* F        CPU_CACHE_Enable();
' E7 @3 U8 [. D/ h5 f% [
        /*
. U4 G" [! j5 ~3 a. M: x2 f       STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
, g3 {% Z" h6 y) h. `7 n           - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
           - 设置NVIV优先级分组为4。
         */
        HAL_Init();
1 F, J" E5 T" S4 \6 ^' g
        /*
+ G5 x2 ~# A) N       配置系统时钟到400MHz
7 v* U4 U" ~! ]. ?' F7 q       - 切换使用HSE。
1 y+ ]7 |& B: k' `7 a       - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
  _1 Z3 P$ [1 `4 r5 }; X    */
        SystemClock_Config();
! q% {4 ]. r( e  o( z3 Y, n
        /*
           Event Recorder：
$ i2 H- u7 V  s0 S! `           - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
           - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
5 Q5 V1 M' W  \8 W0 y- {9 P8 _        */       
$ S& V! ]6 o2 j! `7 i% g#if Enable_EventRecorder == 1  
& M. Y0 _. {% L/ H        /* 初始化EventRecorder并开启 */
7 w7 j4 z% F# k) ~$ K9 ~4 O, {        EventRecorderInitialize(EventRecordAll, 1U);
) z1 ?. h% r9 E6 y* v  {        EventRecorderStart();
#endif
       
        bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
% ^, v: i( l- O/ D! X0 {        bsp_InitTimer();          /* 初始化滴答定时器 */
! o8 G3 n* `3 E/ U        bsp_InitUart();        /* 初始化串口 */
! ~7 K" r7 d, b9 I        bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */       
( A  u0 |; R" C, `! [- @" H8 ^) A        bsp_InitLed();            /* 初始化LED */       
+ Z5 E5 z# y: I}
  MPU配置和Cache配置：
+ @( G$ m" J6 @  |
) X) S$ p% H& n7 u9 b6 i8 P' t数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

/*
  S  m) j2 u; f' b2 e/ c* B+ z: N*********************************************************************************************************
*        函 数 名: MPU_Config
/ t0 }, \& \5 S$ n2 X) u*        功能说明: 配置MPU
6 c" @) s+ F  I2 z- M: B*        形    参: 无
*        返 回 值: 无
+ G$ ?3 h4 N4 m9 Z+ P( D*********************************************************************************************************
*/
7 `/ P' l$ E5 zstatic void MPU_Config( void )
{
        MPU_Region_InitTypeDef MPU_InitStruct;
/ z" A5 W2 V: l* m6 @0 D& O
        /* 禁止 MPU */
        HAL_MPU_Disable();
5 I5 S# {4 G: X
        /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
! ]) j6 ^2 l# P  S+ Q) |) h        MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
        MPU_InitStruct.BaseAddress      = 0x24000000;
  L/ k- X. A- G( V% S        MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
: Y6 C' p  u8 Z; q( k3 |) g; e        MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
        MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
        MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
        MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
7 k+ z0 b6 K; A  V' {8 A' l  O        MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
        MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
        MPU_InitStruct.SubRegionDisable = 0x00;
        MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;

: c4 ]. x+ u" ]# L: ]9 L. d        HAL_MPU_ConfigRegion(&MPU_InitStruct);
8 s, J5 R  h: g) \% R       
       
) f; t" b- F" M* g6 Y1 L        /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
8 S) r( }5 {/ u1 ]7 Y: w3 i        MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
4 l6 i4 {5 C* {% X# T& H        MPU_InitStruct.BaseAddress      = 0x60000000;
        MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;       
        MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
        MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
- j, W: X+ B$ [        MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;       
- r& |: s7 K+ i( I% d1 D        MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
, s9 m: B3 d; z        MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
) ]5 B' A% H; `  R; p        MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
! u9 t7 c8 L! b        MPU_InitStruct.SubRegionDisable = 0x00;
( D, i' J5 P% @" b: l        MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
       
        HAL_MPU_ConfigRegion(&MPU_InitStruct);
3 n- _* M! y7 A- n/ |0 |4 D
        /*使能 MPU */
0 n3 H+ t/ @. b! T. c; @        HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
" U5 {$ d0 \9 G1 H. Q% E! B. }}
3 Y2 Z2 C$ X: i/ n6 j0 G( S/ G
) E0 u4 {# a9 |3 B+ E5 A' Q0 S; d/*
3 ]% ^$ [0 r, o: |*********************************************************************************************************
*        函 数 名: CPU_CACHE_Enable
*        功能说明: 使能L1 Cache
*        形    参: 无
*        返 回 值: 无
0 n% B* N' S, [*********************************************************************************************************
6 [- B/ O/ t) \$ W, j*/
static void CPU_CACHE_Enable(void)
{
        /* 使能 I-Cache */
        SCB_EnableICache();

        /* 使能 D-Cache */
& j6 u- j, B: y4 i1 \        SCB_EnableDCache();
4 ?* W1 d; a4 d; ^2 c( Y4 b}
4 a6 t* |3 C- u' X/ m  每10ms调用一次按键检测：
/ I1 m) t7 h6 P& ^2 C
& T0 @3 l9 Z6 g' ^0 X% c按键检测是在滴答定时器中断里面实现，每10ms执行一次检测。
4 O- U0 z* ]/ X8 j9 @7 ?2 Q
! n; N3 L2 w* l/*
*********************************************************************************************************
*        函 数 名: bsp_RunPer10ms
*        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
*              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
*        形    参: 无
*        返 回 值: 无
4 C8 O% U5 a4 S*********************************************************************************************************
! \5 z9 J( y4 c* M*/
! W+ g* A4 f" W# N3 Rvoid bsp_RunPer10ms(void)
% d7 C: X5 N9 V+ r! ^{
        bsp_KeyScan10ms();
}
  主功能：
& q# w. \/ n; T; F  i! a
" m3 A' Y( \0 L. W+ G9 Q, e, ~7 r主功能的实现主要分为两部分：

7 L! j# o! B  s1 u# D- V 启动一个自动重装软件定时器，每100ms翻转一次LED2
4 k' W7 D: A% q 按键消息的读取，检测到按下后，做串口打印。
/*
*********************************************************************************************************
/ a# v" g% @5 A*        函 数 名: main
/ m' Y2 Q$ v3 }*        功能说明: c程序入口
  M3 y2 p3 c8 X" y/ ~% u: o1 L*        形    参: 无
: u: O. P! }' x1 S*        返 回 值: 错误代码(无需处理)
) v- w4 a/ i8 m- @9 C*********************************************************************************************************
*/
3 J) M% R8 |" l% x# C! ]4 ]. Yint main(void)
{
        uint8_t ucKeyCode;                /* 按键代码 */
; N5 h* ?& }/ _$ S1 W. w8 X, w       
        bsp_Init();                /* 硬件初始化 */
       
+ P& K  ~9 \+ [/ O. N/ I# q        PrintfLogo();        /* 打印例程名称和版本等信息 */
, W( H9 {6 V6 o* m) q        PrintfHelp();        /* 打印操作提示 */

* J( J' @, V& H& F; X
        bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 */
7 e8 F( p; F5 b. ~       
" q9 q8 N, o  o* x0 s        /* 进入主程序循环体 */
        while (1)
        {
                bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */

                /* 判断定时器超时时间 */
8 ?' `- A# g* ?4 c& o) O* H% j                if (bsp_CheckTimer(0))       
                {
                        /* 每隔100ms 进来一次 */  
$ H* |: m. m) {/ C4 w8 L$ a                        bsp_LedToggle(2);                       
! ?+ q; E! A& c, ]5 a8 {1 `                }
               
" Y! Q+ C0 T2 J3 Q! {3 S& [3 c                /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
                ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
                if (ucKeyCode != KEY_NONE)
                {
                        switch (ucKeyCode)
2 x( u+ G% ~' y0 |4 w6 g- u& i                        {
2 U6 d* ~! K$ v# A3 r                                case KEY_DOWN_K1:                        /* K1键按下 */
                                        printf("K1键按下\r\n");
                                        break;
$ p8 R9 q5 Q4 E' N7 f5 ^5 X; J* J
# Z* L; h6 {& R% K* P) k                                case KEY_UP_K1:                                /* K1键弹起 */
                                        printf("K1键弹起\r\n");
                                        break;
0 c+ Q: h8 [4 N" @3 g( P
                                case KEY_DOWN_K2:                        /* K2键按下 */
! C( F  y: t9 g& w$ Q                                        printf("K2键按下\r\n");
                                        break;

                                case KEY_UP_K2:                                /* K2键弹起 */
) q: x! r- W) ?( q: c" r( Z: k7 O                                        printf("K2键弹起\r\n");
                                        break;
7 n& L% R+ f; S
5 {) l+ \" z4 {, L$ v5 i                                case KEY_DOWN_K3:                        /* K3键按下 */
                                        printf("K3键按下\r\n");
, o; K/ j$ W& h, \1 w: k9 N! V, \                                        break;
% z' k6 X6 T. q! }4 h
                                case KEY_UP_K3:                                /* K3键弹起 */
                                        printf("K3键弹起\r\n");
" g( ^/ W4 K1 `- i                                        break;
5 S& ~  {- V, @$ p# l
                                case JOY_DOWN_U:                        /* 摇杆UP键按下 */
( J2 b! M8 P" R5 D' r                                        printf("摇杆上键按下\r\n");
                                        break;

                                case JOY_DOWN_D:                        /* 摇杆DOWN键按下 */
                                        printf("摇杆下键按下\r\n");
                                        break;
! {2 P/ O  [7 \8 y% R8 C( e" L8 _
                                case JOY_DOWN_L:                        /* 摇杆LEFT键按下 */
% a1 \5 o+ q5 X( b: D7 q1 [2 C  p2 `7 A                                        printf("摇杆左键按下\r\n");
                                        break;
6 f+ k% _3 h: j5 Q; `% l5 Y                               
                                case JOY_LONG_L:            /* 摇杆LEFT键长按 */
) e* s1 @: T# L7 m1 N5 l                                        printf("摇杆左键长按\r\n");
) B2 m1 y$ ~, X1 e. w; A/ F) i6 r                                        break;
+ V. z' }  w6 {
& D6 k' j0 L* w! F7 S9 J5 G( o                                case JOY_DOWN_R:                        /* 摇杆RIGHT键按下 */
                                        printf("摇杆右键按下\r\n");
9 p3 j. D8 s6 I' K; L                                        break;
. J+ ^) `' ?: ?4 U                               
) M% _' Z& r; G- X                                case JOY_LONG_R:            /* 摇杆RIGHT键长按 */
; H& x5 F, ~% ]( V% g$ w& ^+ V: ?                                        printf("摇杆右键长按\r\n");
% d1 p. y% I* r  X( z                                        break;
8 @# v, k9 E2 _6 q6 q5 ~
                                case JOY_DOWN_OK:                        /* 摇杆OK键按下 */
                                        printf("摇杆OK键按下\r\n");
: Y- j+ H/ O, E7 d) z% s$ d. E                                        break;
/ H- ?& b" g- f3 d
                                case JOY_UP_OK:                        /* 摇杆OK键弹起 */
                                        printf("摇杆OK键弹起\r\n");
                                        break;
9 @! v# j% V, }5 y# C
                case SYS_DOWN_K1K2:                        /* 摇杆OK键弹起 */
                                        printf("K1和K2组合键按下\r\n");
6 A& e" [2 t1 n. c. _' b                                        break;
1 b* D8 |% T9 n. G
4 U8 @3 u. O- C+ J                                default:
                                        /* 其它的键值不处理 */
                                        break;
                        }
               
8 r" F, ?' Q# b: \4 j" I                }
        }
9 s3 Y. c2 m( H" h. Y}
2 o8 f0 t0 a9 x0 q3 ~19.8 实验例程说明（IAR）
配套例子：
& E7 G# d8 ~4 o' _- U
- w8 a) D+ s1 i+ LV7-002_按键检测（软件滤波，FIFO机制）

  i- M/ K7 ]6 Z" N! u$ [: {" D( R实验目的：
5 w1 c/ K+ }% _, T3 T9 e
学习按键的按下，弹起，长按和组合键的实现。
9 n  b9 o+ l3 r实验内容：

, I7 ]# r4 ?# ]. Q5 @3 u% H" x启动一个自动重装软件定时器，每100ms翻转一次LED2。
/ s* y7 D7 X) w7 s3 I7 E实验操作：
4 Z# I, R6 p2 z8 Z# m" U' L
! _: G' l! K) K. Y7 [5 S3个独立按键和5向摇杆按下时均有串口消息打印。
5向摇杆的左键和右键长按时，会有连发的串口消息。
+ L" y& u  U) B8 _. \6 G独立按键K1和K2按键按下，串口打印消息。
上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1
0 \7 i7 V5 }7 X3 \" u2 v


& R& [5 O6 {$ o8 ?, H- J" W3 F程序设计：

" r4 R1 B$ c2 O1 u0 [0 W. W  系统栈大小分配：


7 S& d' j. X7 Z3 L) {3 H2 t. {
5 u6 {7 q& U; x8 Y! r, o9 l  RAM空间用的DTCM：


! t8 Y% x& W0 O2 \& T
  硬件外设初始化
% X  v+ A+ x5 A1 l: z
硬件外设的初始化是在 bsp.c 文件实现：

1 F' n# h; J: S& S6 K4 m' K3 r/*
*********************************************************************************************************
*        函 数 名: bsp_Init
- A3 }* B! X% ^" T  `- H*        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
! m/ [# h9 V! t6 W: R- k8 r*        形    参：无
*        返 回 值: 无
/ J) H* U! @( Z7 N4 r*********************************************************************************************************
% g% ~3 q* V3 K1 z2 ~8 X* ?*/
void bsp_Init(void)
7 q4 K8 a7 Q# c{
    /* 配置MPU */
        MPU_Config();
6 D3 z' j. m7 M4 J7 k       
9 N; Y+ Y% U+ b" w/ |2 D& x, w        /* 使能L1 Cache */
        CPU_CACHE_Enable();

        /*
2 M, G/ v9 t: ^       STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
7 B; V+ m1 U* I+ W           - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
$ F! |( M( y7 c           - 设置NVIV优先级分组为4。
         */
+ ~2 ?+ X+ Z  j2 D        HAL_Init();
  T4 J- x" e( x1 w+ @: D
        /*
% p1 R& b# P( a& q8 l6 V3 G0 P       配置系统时钟到400MHz
       - 切换使用HSE。
7 Q# b7 c+ g. m' p  j! e0 B1 Z       - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
* q5 A1 R. @: n( g5 ?1 t    */
        SystemClock_Config();
5 N) ^# l5 w9 a& a7 z1 b
        /*
" }; E4 u2 o/ n( z           Event Recorder：
5 I% @7 c1 u, m' P) t5 {# o1 b5 F           - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
4 S1 K: w* {$ `5 A( U, s           - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
6 l5 h& B- Q2 \& k        */       
) _' k( s8 R- D: A9 c" d% Q#if Enable_EventRecorder == 1  
, A4 d$ X* D3 D        /* 初始化EventRecorder并开启 */
7 }. X2 h- z, R! s. Y        EventRecorderInitialize(EventRecordAll, 1U);
+ T: k. L. `3 z" R) G* W        EventRecorderStart();
1 b9 f6 K5 g& y/ Y#endif
; U7 q9 r3 G* W( P0 U       
- Z- [0 P: ^% w' |        bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
        bsp_InitTimer();          /* 初始化滴答定时器 */
        bsp_InitUart();        /* 初始化串口 */
% H) h1 v4 ^! y$ O9 R) F        bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */       
; m; g( n1 r1 \        bsp_InitLed();            /* 初始化LED */       
}
; b% @; q; N$ Y! f  MPU配置和Cache配置：

5 e4 Z3 S2 F/ t! q7 x2 v数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

% R- V$ l  j: b2 c/ `) M/*
*********************************************************************************************************
*        函 数 名: MPU_Config
/ {+ @) {/ h& `, D7 P% [*        功能说明: 配置MPU
*        形    参: 无
*        返 回 值: 无
*********************************************************************************************************
*/
% w! ^  W  C( ?5 h+ h$ B6 [. _static void MPU_Config( void )
{
        MPU_Region_InitTypeDef MPU_InitStruct;

5 \. r8 e* m* T  G5 W: K        /* 禁止 MPU */
        HAL_MPU_Disable();

        /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
: O6 L( N) G6 L& `4 p        MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
2 U5 s7 F* x5 o4 V' x7 Y9 q6 E        MPU_InitStruct.BaseAddress      = 0x24000000;
        MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
8 b% S& B, d( e' O5 ~        MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
        MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
        MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
        MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
        MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
        MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
$ {) o2 P+ [: G4 O" F6 @% `9 E* r        MPU_InitStruct.SubRegionDisable = 0x00;
+ H  |& @# k" f8 U8 U- ]        MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
0 _1 P0 Q6 t) l2 o1 g
! \% E! z+ [9 f2 r        HAL_MPU_ConfigRegion(&MPU_InitStruct);
5 m  `) @+ ^( S4 g       
       
        /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
9 L* K/ U* s" n- f        MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
        MPU_InitStruct.BaseAddress      = 0x60000000;
        MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;       
% n" S, I3 e$ [) y  R, Y        MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
        MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
0 d  [1 Q0 P4 L2 G8 J! ]        MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;       
$ V' y1 G( C* K7 `4 K  c        MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
        MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
        MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
        MPU_InitStruct.SubRegionDisable = 0x00;
  Z9 h2 M" {5 q! S        MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
       
3 z% `2 K2 ~' U% W9 a        HAL_MPU_ConfigRegion(&MPU_InitStruct);
3 v) n9 Y* \2 v# \. O7 {5 H& h, p8 T
        /*使能 MPU */
        HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
1 V. w8 B- u4 R, C( z, M}
& `. u, r5 E7 K$ V  H3 r$ {
/*
' Q, X% L! l7 Y+ n& z' Y*********************************************************************************************************
*        函 数 名: CPU_CACHE_Enable
) y6 `$ V/ [0 t4 ]  A*        功能说明: 使能L1 Cache
*        形    参: 无
0 E: R$ _4 U$ Q$ c  v& W2 g*        返 回 值: 无
*********************************************************************************************************
*/
6 Q: P1 I$ d9 C) \static void CPU_CACHE_Enable(void)
{
1 a) C9 ]& P  m6 ?# S8 U        /* 使能 I-Cache */
" d# o4 Y+ c% J, n  J( y        SCB_EnableICache();

& S. @. K* Y3 {$ A% U) w        /* 使能 D-Cache */
        SCB_EnableDCache();
, o3 T0 Y6 j* E' |; U, w}
  每10ms调用一次按键检测：

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

/*
; P" D, {: E, Y$ i# _" c  u. X9 x) c*********************************************************************************************************
0 |: X8 a/ T7 u9 [( y*        函 数 名: bsp_RunPer10ms
8 R4 v. u" m) R' v4 |*        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
*              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
; O$ L- n3 Y0 o*        形    参: 无
*        返 回 值: 无
0 ~+ i: ], H1 U- K*********************************************************************************************************
: R1 X2 c9 e! ?3 {' y6 a*/
# y* X, z8 `: W3 D$ e0 z6 fvoid bsp_RunPer10ms(void)
6 t0 t  f. E) }0 \5 [& D0 Y: V{
0 N/ R* ]: n0 [+ D" L" T0 a        bsp_KeyScan10ms();
* j6 t2 |7 o% l7 l4 {}
: l: Z% |5 y" o' L: J5 S2 Z 主功能：

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

启动一个自动重装软件定时器，每100ms翻转一次LED2
' e! ?6 x3 ~1 j& b1 h 按键消息的读取，检测到按下后，做串口打印。
/*
) f/ y' T3 E# V; K*********************************************************************************************************
*        函 数 名: main
*        功能说明: c程序入口
9 }* M4 H9 i/ Z) X$ N9 k  _*        形    参: 无
( g2 A4 A- g7 ]9 b" P( r6 Q*        返 回 值: 错误代码(无需处理)
+ `, D  }1 j1 n# I*********************************************************************************************************
*/
  M) B7 F) R( B2 P1 ^. sint main(void)
{
        uint8_t ucKeyCode;                /* 按键代码 */
7 ~4 n) ?& K, _7 \, m& N       
) K1 `4 [* f$ V+ m        bsp_Init();                /* 硬件初始化 */
       
        PrintfLogo();        /* 打印例程名称和版本等信息 */
, f9 V4 N: D* d+ e& U& x7 V        PrintfHelp();        /* 打印操作提示 */

. e& d, |3 S: r
        bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 */
       
3 e6 f7 P" R+ t+ k8 F8 ]  _8 i        /* 进入主程序循环体 */
        while (1)
. K' t! m7 a2 ?6 S/ g5 t        {
                bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
  j( B7 c8 T' k  b- m# j0 Y: ]
                /* 判断定时器超时时间 */
                if (bsp_CheckTimer(0))       
4 R) y( R0 p2 r- ~' Q+ R8 V                {
+ p# Y* h2 F' N1 }% A' F                        /* 每隔100ms 进来一次 */  
# A. Q8 B& a' }4 U5 X- g' f- @& x0 T                        bsp_LedToggle(2);                       
# {6 H6 }5 {' j                }
               
; c3 @2 M; \6 ]# k4 S$ n& J                /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
) Q9 i  g3 e, _" R5 f                ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
                if (ucKeyCode != KEY_NONE)
                {
1 t4 h7 p- y; }1 v- F8 u                        switch (ucKeyCode)
                        {
                                case KEY_DOWN_K1:                        /* K1键按下 */
6 b  X6 P$ ^5 k) }6 r+ U0 [4 T                                        printf("K1键按下\r\n");
; C  j/ U+ Z, P, F+ y0 l: s4 w                                        break;
/ a3 b3 s* H6 u* R& R
# _1 f2 r/ v) y' n7 @# D4 Z                                case KEY_UP_K1:                                /* K1键弹起 */
                                        printf("K1键弹起\r\n");
                                        break;

' m" n: K7 R1 p! c# P2 \  S* Q                                case KEY_DOWN_K2:                        /* K2键按下 */
                                        printf("K2键按下\r\n");
5 ]) F, P; a* u                                        break;
) K) u# o2 e8 B7 m0 I
                                case KEY_UP_K2:                                /* K2键弹起 */
                                        printf("K2键弹起\r\n");
                                        break;

                                case KEY_DOWN_K3:                        /* K3键按下 */
8 S# r* W4 ]# o1 E2 U                                        printf("K3键按下\r\n");
                                        break;

9 E+ K) f# C+ I, i/ g. ^: f                                case KEY_UP_K3:                                /* K3键弹起 */
4 X# a) D2 l  k; J" T8 o                                        printf("K3键弹起\r\n");
                                        break;

, G; `2 p. G# Z# {  D                                case JOY_DOWN_U:                        /* 摇杆UP键按下 */
                                        printf("摇杆上键按下\r\n");
                                        break;
* t, Q& z, B' m6 H6 e) \/ u  u
: x+ B+ i; E0 E" m                                case JOY_DOWN_D:                        /* 摇杆DOWN键按下 */
- |6 S3 l3 X9 h! z: s1 [3 v) W                                        printf("摇杆下键按下\r\n");
( D9 g9 h0 H% L- _/ |* ^/ n                                        break;
4 ^+ d0 M  Y# e' ]( i
: K% X# C% ~: F+ n, y4 B0 r                                case JOY_DOWN_L:                        /* 摇杆LEFT键按下 */
6 Q, b9 H- c- H( X                                        printf("摇杆左键按下\r\n");
                                        break;
7 k$ z0 t( G& H. \0 e; k/ d                               
                                case JOY_LONG_L:            /* 摇杆LEFT键长按 */
( F1 q$ b7 w5 B0 n                                        printf("摇杆左键长按\r\n");
3 U* D2 e: {( Q9 j; K, n. k# z7 z1 d                                        break;
/ g4 f3 p( o, K2 _; Z" d- Q  @
1 X/ ]; F; N8 a                                case JOY_DOWN_R:                        /* 摇杆RIGHT键按下 */
                                        printf("摇杆右键按下\r\n");
. k- W7 R  r  l6 q                                        break;
                               
                                case JOY_LONG_R:            /* 摇杆RIGHT键长按 */
0 C6 l! ^/ V" Y; x. E. B8 N' |. N                                        printf("摇杆右键长按\r\n");
                                        break;
# f. w+ t4 p& X% i5 Q
+ F9 E9 d% H$ g. u2 }3 _7 K; O                                case JOY_DOWN_OK:                        /* 摇杆OK键按下 */
                                        printf("摇杆OK键按下\r\n");
$ ?" `$ x& r. N9 F. U- M# M1 Q                                        break;
( @6 k) [1 r* ^. Z# f! h+ e8 Y( t$ a
                                case JOY_UP_OK:                        /* 摇杆OK键弹起 */
9 P  P7 A0 o/ Z, _( Q                                        printf("摇杆OK键弹起\r\n");
                                        break;
- f+ V0 B; x4 z4 k
                case SYS_DOWN_K1K2:                        /* 摇杆OK键弹起 */
                                        printf("K1和K2组合键按下\r\n");
5 ]- [0 N6 ~& ]4 ?" K+ @                                        break;

                                default:
! y( S" a! S+ _5 r4 Q( r( \+ E  E! g                                        /* 其它的键值不处理 */
( v& H  ?6 u5 x                                        break;
0 M( p" u* x& h: C7 r. h2 V7 }                        }
  M$ e3 I$ f8 i* O               
                }
# a9 ^! l0 E: ]. E) V        }
}


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

6 `* V, S; M& ^0 q( b8 O% ^3 q
/ v8 G# Z, H# P( ]5 v3 y