19.1 初学者重要提示
按键FIFO驱动扩展和移植更简单，组合键也更好用。支持按下、弹起、长按和组合键。
; d5 d4 b/ _# R9 W# l9 O
( M0 E6 b0 @% o" ]( D19.2 按键硬件设计
8 l0 q, h: b5 xV7开发板有三个独立按键和一个五向摇杆，下面是三个独立按键的原理图：
1 i1 N  U& K' J) d" Z- _9 E0 G

注意，K1（S1）、K2(S2)和K3(S3)按键的上拉电阻是接在5V电压上，因为这三个按键被复用为PS/2键盘鼠标接口，而PS/2是需要5V供电的（注，V5和V6开发板做了PS/2复用，而V7没有使用，这里只是为了兼容之前的板子）。实际测试，K1、K2、K3按键和PS/2键盘是可以同时工作的。
8 U$ G+ }6 p) p  Q4 h) Z
* U7 b8 [# _, T. v下面是五向摇杆的原理图：
8 r; @, W: z  i2 @: q7 K5 b

通过这个硬件设计，有如下两个知识点为大家做介绍：
- h( i6 D1 {# B4 [( D1 `
19.2.1 硬件设计
按键和CPU之间串联的电阻起保护作用。按键肯定是存在机械抖动的，开发板上面的硬件没有做硬件滤波处理，即使设计了硬件滤波电路，软件上还是需要进行滤波。
# X8 q+ d6 i/ `4 N" T
  保护GPIO，避免软件错误将IO设置为输出，如果设置为低电平还好，如果设置输出的是高电平，按键按下会直接跟GND(低电平)连接，从而损坏MCU。
0 U2 |! d; n# O( k) O, e" V  保护电阻也起到按键隔离作用，这些GPIO可以直接用于其它实验。
19.2.2 GPIO内部结构分析按键
详细的GPIO模式介绍，请参考第15章的15.3小节，本章仅介绍输入模式。下面我们通过一张图来简单介绍GPIO的结构。
, _; W+ z9 V' U: ^1 a

( P* R# I0 [; G
5 l. n$ j0 j/ Y. x红色的线条是GPIO输入通道的信号流向，作为按键检测IO，这些需要配置为浮空输入。按键已经做了5V上拉，因此GPIO内部的上下拉电阻都选择关闭状态。

0 ]8 F: Z8 f( R5 V, M" v19.3 按键FIFO的驱动设计
& }  E! s& f1 T. U7 W: Z! a' O' I4 H' Ebsp_key按键驱动程序用于扫描独立按键，具有软件滤波机制，采用FIFO机制保存键值。可以检测如下事件：

  按键按下。
$ T6 v8 Z7 B! k# u  按键弹起。
* M! T4 t7 j, h" O  长按键。
  长按时自动连发。
0 Z4 y' r. @' `/ M( l& W我们将按键驱动分为两个部分来介绍，一部分是FIFO的实现，一部分是按键检测的实现。

& R% F) _: P- Q

8 j6 A+ A7 s* ^, K) B# b& R
bsp_key.c 文件包含按键检测和按键FIFO的实现代码。
) v5 e- g' R' t- t7 t
- H5 |: R1 O0 w; pbsp.c 文件会调用bsp_InitKey()初始化函数。

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

bsp_timer.c 中的Systick中断服务程序调用 bsp_RunPer10ms。

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

函数调用关系图：
, p+ L7 @/ ]: U8 W! P

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

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

: t3 I9 J( O1 E' f8 ~  \5 w7 N% [" h
0 |" d/ m5 D9 D' c5 J5 M如果Write！= Read，则我们认为有新的按键事件。
, ~2 p, r' V/ j/ z6 C
* \7 [  B  W" }我们通过函数bsp_GetKey读取一个按键值进行处理后，Read变量变为1。Write变量不变。

9 H- y0 o$ U9 z* j$ O, x) [9 u

. }% D  J8 S8 S. {- w0 [
我们继续通过函数bsp_GetKey读取3个按键值进行处理后，Read变量变为4。此时Read = Write = 4。两个变量已经相等，表示已经没有新的按键事件需要处理。
; [  r5 o1 h  }3 w. Y
有一点要特别的注意，如果FIFO空间写满了，Write会被重新赋值为0，也就是重新从第一个字节空间填数据进去，如果这个地址空间的数据还没有被及时读取出来，那么会被后来的数据覆盖掉，这点要引起大家的注意。我们的驱动程序开辟了10个字节的FIFO缓冲区，对于一般的应用足够了。

1 W# c* O4 c) U7 B4 F设计按键FIFO主要有三个方面的好处：
  m! A$ s4 e) t& p' k+ e9 G
# y3 b. h- Y' a/ j9 g8 }2 A  s# ^  可靠地记录每一个按键事件，避免遗漏按键事件。特别是需要实现按键的按下、长按、自动连发、弹起等事件时。
  读取按键的函数可以设计为非阻塞的，不需要等待按键抖动滤波处理完毕。
4 r4 Y8 Y4 h9 \( |* @. m4 d3 j- _  按键FIFO程序在嘀嗒定时器中定期的执行检测，不需要在主程序中一直做检测，这样可以有效地降低系统资源消耗。

19.3.2 按键FIFO的实现
在bsp_key.h 中定了结构体类型KEY_FIFO_T。这只是类型声明，并没有分配变量空间。
# [2 s/ Y7 G  ~& Q3 G$ K+ h

1. #define KEY_FIFO_SIZE        10
   " l' u6 x% m% f+ P8 ^! n
2. typedef struct
   
3. {
   / D. r/ R$ v; p# I3 O
4.         uint8_t Buf[KEY_FIFO_SIZE];                /* 键值缓冲区 */
   
5.         uint8_t Read;                                        /* 缓冲区读指针1 */
   1 ]5 S  M! H# n+ B% w
6.         uint8_t Write;                             /* 缓冲区写指针 */
   
7.         uint8_t Read2;                             /* 缓冲区读指针2 */
   
8. }KEY_FIFO_T;

复制代码

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

; K# i/ p2 S4 I

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

复制代码

" H- [% p0 J* n4 F$ n一般情况下，只需要一个写指针Write和一个读指针Read。在某些情况下，可能有两个任务都需要访问按键缓冲区，为了避免键值被其中一个任务取空，我们添加了第2个读指针Read2。出厂程序在bsp_Idle()函数中实现的按K1K2组合键截屏的功能就使用的第2个读指针。

$ `. W/ P% L* M# ]  L当检测到按键事件发生后，可以调用 bsp_PutKey函数将键值压入FIFO。下面的代码是函数的实现：
9 A$ _# l5 @; S: K

1. /*
   , V  l: h& e; f
2. *********************************************************************************************************
   ' v2 D% _$ ?6 [- ]9 r
3. *        函 数 名: bsp_PutKey
   & b6 x% d: m+ |$ j+ u, k
4. *        功能说明: 将1个键值压入按键FIFO缓冲区。可用于模拟一个按键。
   ' ]: L0 L6 K: b4 }
5. *        形    参: _KeyCode : 按键代码
   
6. *        返 回 值: 无
   9 B0 ^+ w1 V5 |1 I
7. *********************************************************************************************************
   + M# c% Q7 e3 N. e( @2 y+ x
8. */
   # u: F, |9 Z/ f1 K( t
9. void bsp_PutKey(uint8_t _KeyCode)
   
10. {
    
11.         s_tKey.Buf[s_tKey.Write] = _KeyCode;
    
12. 
    
13.         if (++s_tKey.Write  >= KEY_FIFO_SIZE)
    $ s8 U, Z# {( N9 }
14.         {
    - |7 n( j/ b+ `4 _! f8 M0 N6 @
15.                 s_tKey.Write = 0;
    
16.         }
    
17. }

复制代码

这个bsp_PutKey函数除了被按键检测函数调用外，还可以被其他底层驱动调用。比如红外遥控器的按键检测，也共用了同一个按键FIFO。遥控器的按键代码和主板实体按键的键值统一编码，保持键值唯一即可实现两套按键同时控制程序的功能。
' A- Y" J4 F2 }/ m" c4 }
应用程序读取FIFO中的键值，是通过bsp_GetKey函数和bsp_GetKey2函数实现的。我们来看下这两个函数的实现：
6 L2 ?! Y$ Q! ?* G
& V) b% ?3 C) \" ^0 [: `: \6 _) b& ~

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_GetKey
   % p# S- `/ T* L9 L/ N# \& _
4. *        功能说明: 从按键FIFO缓冲区读取一个键值。
   7 Y0 r" l3 Z  r2 g% h  ]( c' `7 K
5. *        形    参:  无
   
6. *        返 回 值: 按键代码
   
7. *********************************************************************************************************
   
8. */
   2 f  ?) n3 u, H/ s$ L3 z! |8 e
9. uint8_t bsp_GetKey(void)
   . E: w! _" r  ?
10. {
    . m2 w& m2 ^+ S# ]2 e' o
11.         uint8_t ret;
    
12. 
    3 S) g* }3 I, v) b" d) p) [( j
13.         if (s_tKey.Read == s_tKey.Write)
    - B2 R/ I4 Y; W  O8 Z% U' A* W
14.         {
    , ~* R! ~) _/ p
15.                 return KEY_NONE;
    ! P0 q# Q& X+ e: l( T' `$ e! U
16.         }
    
17.         else
    
18.         {
    
19.                 ret = s_tKey.Buf[s_tKey.Read];
    8 R; ?  g/ S/ `7 r1 A. n
20. 
    
21.                 if (++s_tKey.Read >= KEY_FIFO_SIZE)
    ' l2 s+ D" |1 m2 v
22.                 {
    8 O3 {4 _# V6 f0 @+ @6 c* _
23.                         s_tKey.Read = 0;
    
24.                 }
    % S3 q0 G1 c' t# A% Y
25.                 return ret;
    6 g! R: ^8 q  h
26.         }
    5 f" b! Y2 i; U" R* x
27. }
    
28. 
    
29. /*
    % o6 ?7 l4 c1 }( e" ~! f! ?% Y7 d
30. *********************************************************************************************************
    ; k! S5 Z& w0 P" @! H
31. *        函 数 名: bsp_GetKey2
    
32. *        功能说明: 从按键FIFO缓冲区读取一个键值。独立的读指针。
    
33. *        形    参:  无
    
34. *        返 回 值: 按键代码
    9 s* Z& w+ ~" N2 V! H5 V
35. *********************************************************************************************************
    
36. */
    
37. uint8_t bsp_GetKey2(void)
    " H- \: K7 r4 c* f4 U6 I
38. {
    " k4 B  C! Y' N- E
39.         uint8_t ret;
    
40. 
    
41.         if (s_tKey.Read2 == s_tKey.Write)
    6 W# F* k' \5 y$ K
42.         {
    
43.                 return KEY_NONE;
    
44.         }
    1 V# ^" ^5 u; [; D
45.         else
    1 \# f& L) y- x0 u
46.         {
    2 R: Y  W1 E6 o
47.                 ret = s_tKey.Buf[s_tKey.Read2];
    ) ~+ N, Q( g" D
48. 
    % L/ P! f" z) w* c% Y
49.                 if (++s_tKey.Read2 >= KEY_FIFO_SIZE)
    
50.                 {
    
51.                         s_tKey.Read2 = 0;
    " D6 @$ E: @. c1 d% D% s: l  r
52.                 }
    . ^* `- _, A& f. g, h1 q
53.                 return ret;
    
54.         }
    
55. }

复制代码

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

2 L9 R) I' {- k  \

1. typedef enum
   3 ~  [% C, o8 K
2. {
   & _7 r3 J' I6 D9 {' Q  J
3.         KEY_NONE = 0,                        /* 0 表示按键事件 */
   
4. 
   * `3 Q- {* \! o+ [- X
5.         KEY_1_DOWN,                        /* 1键按下 */
   4 \  D* k: H) n
6.         KEY_1_UP,                                /* 1键弹起 */
   
7.         KEY_1_LONG,                        /* 1键长按 */
   
8. 
   
9.         KEY_2_DOWN,                        /* 2键按下 */
   
10.         KEY_2_UP,                                /* 2键弹起 */
    1 E* M, \* V- V. H
11.         KEY_2_LONG,                        /* 2键长按 */
    : `" A1 R; b5 C; C# i9 Q  ?8 ~
12. 
    7 [, s5 S: q# r, |
13.         KEY_3_DOWN,                        /* 3键按下 */
    
14.         KEY_3_UP,                                /* 3键弹起 */
    
15.         KEY_3_LONG,                        /* 3键长按 */
    ' f6 O; B8 H2 M8 U; v: c
16. 
    
17.         KEY_4_DOWN,                        /* 4键按下 */
      v" O$ v& q9 R4 s
18.         KEY_4_UP,                                /* 4键弹起 */
    3 t4 f2 D; s2 K- E
19.         KEY_4_LONG,                        /* 4键长按 */
    3 {, |7 r4 V6 Q5 Y: s/ j- V* y
20. 
    6 K/ e1 W+ _4 p- l
21.         KEY_5_DOWN,                        /* 5键按下 */
    4 _3 ~1 ?+ s+ J# z1 g' |+ h
22.         KEY_5_UP,                                /* 5键弹起 */
    
23.         KEY_5_LONG,                        /* 5键长按 */
    
24. 
    ) s" k# @! c9 _' t& \
25.         KEY_6_DOWN,                        /* 6键按下 */
    1 X" D2 N2 P" w& [& u% c
26.         KEY_6_UP,                                /* 6键弹起 */
    ( i# U3 X# q' Y( P& x
27.         KEY_6_LONG,                        /* 6键长按 */
    : m% i- c5 P  c& f( j# q
28. 
    4 A7 X! q' t, p& L( z
29.         KEY_7_DOWN,                        /* 7键按下 */
    
30.         KEY_7_UP,                                /* 7键弹起 */
    
31.         KEY_7_LONG,                        /* 7键长按 */
    
32. 
    
33.         KEY_8_DOWN,                        /* 8键按下 */
    
34.         KEY_8_UP,                                /* 8键弹起 */
    % D- s4 \7 A& b
35.         KEY_8_LONG,                        /* 8键长按 */
    5 G3 \1 B0 D8 P1 C  y
36. 
    
37.         /* 组合键 */
    : X' L$ A! i9 {
38.         KEY_9_DOWN,                        /* 9键按下 */
    
39.         KEY_9_UP,                                /* 9键弹起 */
    
40.         KEY_9_LONG,                        /* 9键长按 */
    " G4 g: x4 S. V9 w2 [0 k  M
41. 
    
42.         KEY_10_DOWN,                        /* 10键按下 */
    + z/ u4 K& x! i3 w4 s. R
43.         KEY_10_UP,                        /* 10键弹起 */
    
44.         KEY_10_LONG,                        /* 10键长按 */
    
45. }KEY_ENUM;

复制代码

& Z. e' q- S- J3 ^3 D- ~$ N( z必须按次序定义每个键的按下、弹起和长按事件，即每个按键对象（组合键也算1个）占用3个数值。我们推荐使用枚举enum, 不用#define的原因：

0 ?) j" ]5 j0 g) |9 G6 [% J- ^  便于新增键值,方便调整顺序。
, j: {# V0 S! ^8 v: J# H  使用{ } 将一组相关的定义封装起来便于理解。
  编译器可帮我们避免键值重复。
我们来看红外遥控器的键值定义，在bsp_ir_decode.h文件。因为遥控器按键和主板按键共用同一个FIFO，因此在这里我们先贴出这段定义代码，让大家有个初步印象。
# c+ I, Z. t- @& p! }% E

1. /* 定义红外遥控器按键代码, 和bsp_key.h 的物理按键代码统一编码 */
   
2. typedef enum
   4 s5 f  C( O" i% w  X
3. {
   0 j3 i1 V" S9 U9 H- x( [" T3 H
4.         IR_KEY_STRAT         = 0x80,
   3 ^+ l; k" q6 j' n1 }3 K1 F
5.         IR_KEY_POWER         = IR_KEY_STRAT + 0x45,
   9 I4 G1 W& s  T
6.         IR_KEY_MENU         = IR_KEY_STRAT + 0x47,
   + ^, f/ m9 C0 o/ w" A6 X% |
7.         IR_KEY_TEST         = IR_KEY_STRAT + 0x44,
   
8.         IR_KEY_UP         = IR_KEY_STRAT + 0x40,
   
9.         IR_KEY_RETURN        = IR_KEY_STRAT + 0x43,
   
10.         IR_KEY_LEFT        = IR_KEY_STRAT + 0x07,
    * }$ R) Q' ~5 ^9 ^0 m. V
11.         IR_KEY_OK                = IR_KEY_STRAT + 0x15,
    
12.         IR_KEY_RIGHT        = IR_KEY_STRAT + 0x09,
    - r8 i' N0 B+ I/ l
13.         IR_KEY_0                = IR_KEY_STRAT + 0x16,
    2 T  N5 E0 A) Y' ]: N# a
14.         IR_KEY_DOWN        = IR_KEY_STRAT + 0x19,
    
15.         IR_KEY_C                = IR_KEY_STRAT + 0x0D,
    : G: e9 t3 f+ t# m  B( O
16.         IR_KEY_1                = IR_KEY_STRAT + 0x0C,
    ; e. ^* c* S) [) r$ F
17.         IR_KEY_2                = IR_KEY_STRAT + 0x18,
    8 I; A& U5 N% E. o* r" E
18.         IR_KEY_3                = IR_KEY_STRAT + 0x5E,
    ' w( k# j5 b2 v3 a. m# j2 D; k0 F( n
19.         IR_KEY_4                = IR_KEY_STRAT + 0x08,
    6 L! o2 L& c/ s2 h! r6 j$ y
20.         IR_KEY_5                = IR_KEY_STRAT + 0x1C,
    
21.         IR_KEY_6                = IR_KEY_STRAT + 0x5A,
    - F: I- L7 J/ _0 G
22.         IR_KEY_7                = IR_KEY_STRAT + 0x42,
    
23.         IR_KEY_8                = IR_KEY_STRAT + 0x52,
    1 @& @- V' i$ X! C+ i
24.         IR_KEY_9                = IR_KEY_STRAT + 0x4A,        
    
25. }IR_KEY_E;

复制代码

我们下面来看一段简单的应用。这个应用的功能是：主板K1键控制LED1指示灯；遥控器的POWER键和MENU键控制LED2指示灯。

1. #include "bsp.h"
   $ \- Q8 n' a" D. r
2. 
   : N" E( O, E5 i! x/ t
3. int main(void)
   
4. {
   
5.         uint8_t ucKeyCode;
   
6.                         
   ( M- _2 f/ S: `5 E6 s
7.         bsp_Init();
   1 F. x: X& y6 `2 Q* _3 e% T& }  ]. D
8. 
   
9.         IRD_StartWork();        /* 启动红外解码 */
   
10. 
    ; t( R& L" }0 w% |, }/ p5 B
11.         while(1)
    
12.         {
    
13.                 bsp_Idle();
    
14.                
    7 X: A% m+ e+ [" y8 p
15.                 /* 处理按键事件 */
    $ U4 }: _3 X$ t& [" G9 _& N' S
16.                 ucKeyCode = bsp_GetKey();
    
17.                 if (ucKeyCode > 0)
    2 A+ Y/ Q+ v* s% ~# V) ^: y) i
18.                 {
    
19.                         /* 有键按下 */
    
20.                         switch (ucKeyCode)
    
21.                         {
    $ Y8 k0 E- D% ?
22.                                 case KEY_DOWN_K1:                /* K1键按下 */
    & g$ E" J/ l% m* I- Y8 D
23.                                         bsp_LedOn(1);                /* 点亮LED1 */
    
24.                                         break;
    
25. 
    
26.                                 case KEY_UP_K1:                /* K1键弹起 */
    
27.                                         bsp_LedOff(1);        /* 熄灭LED1 */
    
28.                                         break;                                       
    
29. 
    
30.                                 case IR_KEY_POWER:                /* 遥控器POWER键按下 */
    
31.                                         bsp_LedOn(1);                /* 点亮LED2 */
    
32.                                         break;
    " C% V$ c. e" p# K
33. 
    
34.                                 case IR_KEY_MENU:                /* 遥控器MENU键按下 */
    & T: y9 k4 A3 j8 s$ I
35.                                         bsp_LedOff(1);        /* 熄灭LED2 */
    
36.                                         break;                                       
    $ p' d: D6 m' J" F/ {) O: u4 |7 a
37. 
    
38.                                 case MSG_485_RX:                /* 通信程序的发来的消息 */
    
39.                                         /* 执行通信程序的指令 */
    
40.                                         break;
    
41. 
    / ?, c* F2 J3 x) [$ v1 m& _' r
42.                                 default:
    5 y1 A: ~5 R  Y3 g
43.                                         break;
    
44.                         }
    3 G! t* {  z( c, x% y/ b4 f
45.                 }
    
46.         }
    
47. }

复制代码

看到这里，想必你已经意识到bsp_PutKey函数的强大之处了，可以将不相关的硬件输入设备统一为一个相同的接口函数。
. o6 k& C( t- A& G4 q
6 d, c9 O8 a' w( l, |7 ], }$ _0 i& Z在上面的应用程序中，我们特意添加了一段红色的代码来解说更高级的用法。485通信程序收到有效的命令后通过 bsp_PutKey（MSG_485_RX）函数可以通知APP应用程序进行进一步加工处理（比如显示接收成功）。这是一种非常好的任务间信息传递方式，它不会破坏程序结构。不必新增全局变量来做这种事情，你只需要添加一个键值代码。
+ O& I0 |. g  q; V
$ Z) e8 A( u$ n$ ]2 t3 p( ?对于简单的程序，可以借用按键FIFO来进行少量的信息传递。对于复杂的应用，我们推荐使用bsp_msg专门来做这种任务间的通信。因为bsp_msg除了传递消息代码外，还可以传递参数结构。

19.3.3 按键检测程序分析
在bsp_key.h 中定了结构体类型KEY_T。

5 v/ k: k. H! H* ^7 i4 T

1. #define KEY_COUNT    10                           /* 按键个数, 8个独立建 + 2个组合键 */
   7 n4 F5 L4 D3 p3 C6 j9 Q3 Z6 d: I: @- R
2. 
   
3. typedef struct
   
4. {
   8 X# b7 l  d4 O2 [$ z# b7 I9 M9 t5 b
5.         /* 下面是一个函数指针，指向判断按键手否按下的函数 */
   : Y4 V2 g7 p0 v# T) F1 Q
6.         uint8_t (*IsKeyDownFunc)(void); /* 按键按下的判断函数,1表示按下 */
   3 m' K2 _& R2 W( e- Z' ~
7. 
   
8.         uint8_t  Count;                /* 滤波器计数器 */
   . G$ ~. \9 q5 g4 m0 Q8 F
9.         uint16_t LongCount;        /* 长按计数器 */
   - k# s( R) r: Q+ ~
10.         uint16_t LongTime;                /* 按键按下持续时间, 0表示不检测长按 */
    / U9 f0 s1 H2 i8 E" Z
11.         uint8_t  State;                /* 按键当前状态（按下还是弹起） */
    . Q2 S3 e, ?  F7 f! w' _# _
12.         uint8_t  RepeatSpeed;        /* 连续按键周期 */
    + M$ }) @5 L- w* [$ u
13.         uint8_t  RepeatCount;        /* 连续按键计数器 */
    ; p, K/ U* f* l! x' m" V9 ]
14. }KEY_T;

复制代码

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

  \# j  I3 _6 ~1 s( ]$ n

1. static KEY_T s_tBtn[KEY_COUNT];
   0 B/ ]2 A" ]7 P$ ^
2. static KEY_FIFO_T s_tKey; /* 按键FIFO变量,结构体 */

复制代码

每个按键对象都分配一个结构体变量，这些结构体变量以数组的形式存在将便于我们简化程序代码行数。
3 j/ J) a0 y( C- y
使用函数指针IsKeyDownFunc可以将每个按键的检测以及组合键的检测代码进行统一管理。
9 d/ u$ p. p  k: L
因为函数指针必须先赋值，才能被作为函数执行。因此在定时扫描按键之前，必须先执行一段初始化函数来设置每个按键的函数指针和参数。这个函数是 void bsp_InitKey(void)。它由bsp_Init()调用。

- `8 E" U8 D) ^, d' C9 g

1. /*
   7 R$ }' L  j! F2 I5 n5 u
2. *********************************************************************************************************
   # S! Y" W1 V( w7 ?6 B7 S* K% b* P
3. *        函 数 名: bsp_InitKey
   
4. *        功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
   % G3 @0 G  B2 }
5. *        形    参: 无
   * Y- |2 Z( e' N5 @& V) w7 v
6. *        返 回 值: 无
   7 z6 p  W$ Y% ~3 o
7. *********************************************************************************************************
   
8. */
   
9. void bsp_InitKey(void)
   0 y# u) \8 i7 m( I2 j
10. {
    
11.         bsp_InitKeyVar();                /* 初始化按键变量 */
    % }& u  @8 b  W! H, |0 q
12.         bsp_InitKeyHard();                /* 初始化按键硬件 */
    9 S. \2 a; p3 s- m- d1 X
13. }

复制代码

下面是bsp_InitKeyVar函数的定义：

$ h0 [3 V. i% J9 w" g

1. /*
   - x# y( `3 o- r5 m4 [& T* K
2. *********************************************************************************************************
   2 }2 b) H7 [( `  V  n: ^
3. *        函 数 名: bsp_InitKeyVar
   3 f" i* F8 Y; e1 L6 T% w7 N) Y
4. *        功能说明: 初始化按键变量
   
5. *        形    参:  无
   
6. *        返 回 值: 无
   9 u& R' F! Y/ ^
7. *********************************************************************************************************
   % V8 H/ _1 h2 Y5 a# ^
8. */
   
9. static void bsp_InitKeyVar(void)
   
10. {
    7 j+ `2 k& B3 ~' Q
11.         uint8_t i;
    
12. 
    
13.         /* 对按键FIFO读写指针清零 */
    2 O' H: D, J7 a, g8 M
14.         s_tKey.Read = 0;
    
15.         s_tKey.Write = 0;
    
16.         s_tKey.Read2 = 0;
    
17. 
    ; F" T& y3 V. t' Y% |* O/ r; y
18.         /* 给每个按键结构体成员变量赋一组缺省值 */
    
19.         for (i = 0; i < KEY_COUNT; i++)
    $ j/ L! z$ n0 D
20.         {
    3 @$ N& y0 A: C' t
21.                 s_tBtn<i>.LongTime = KEY_LONG_TIME;                        /* 长按时间 0 表示不检测长按键事件 */</i>
    
22. <span style="font-style: italic;">                s_tBtn.Count = KEY_FILTER_TIME / 2;                /* 计数器设置为滤波时间的一半 */
    9 F# X  H4 v1 U+ \$ Z! F+ I, |% E1 s; |) u
23.                 s_tBtn<span style="font-style: italic;">.State = 0;                                                /* 按键缺省状态，0为未按下 */
    
24.                 s_tBtn<span style="font-style: italic;">.RepeatSpeed = 0;                                        /* 按键连发的速度，0表示不支持连发 */
    0 f! R# e1 V! K3 T! G: Y
25.                 s_tBtn<i style="font-style: italic;">.RepeatCount = 0;                                        /* 连发计数器 */
    
26.      </i><span style="font-style: normal;">   }
    
27. 
    ' n. B7 R2 p& ]" b
28.         /* 如果需要单独更改某个按键的参数，可以在此单独重新赋值 */
    
29.         
    % f& N) J: y) }# E# |+ F
30.         /* 摇杆上下左右，支持长按1秒后，自动连发 */
    2 O' q1 g3 M/ u. l8 L
31.         bsp_SetKeyParam(KID_JOY_U, 100, 6);
    & E6 o! w- W" [* P" b
32.         bsp_SetKeyParam(KID_JOY_D, 100, 6);
    / }4 y/ {3 x- s; U% T7 G
33.         bsp_SetKeyParam(KID_JOY_L, 100, 6);
    " M' H" }" U! r3 S) P$ N  K. i
34.         bsp_SetKeyParam(KID_JOY_R, 100, 6);
    : |& q+ z# ?) p, z' ?
35. }</span></span></span></span>

复制代码

注意一下 Count 这个成员变量，没有设置为0。为了避免主板上电的瞬间，检测到一个无效的按键按下或弹起事件。我们将这个滤波计数器的初值设置为正常值的1/2。bsp_key.h中定义了滤波时间和长按时间。
3 T) Q+ P  v. M4 }- Q. L
3 ]9 h( `. T$ x4 _1 N7 i  i" _

1. /*
   / L0 x7 k" G3 i; @
2.         按键滤波时间50ms, 单位10ms。
   
3.         只有连续检测到50ms状态不变才认为有效，包括弹起和按下两种事件
   
4.         即使按键电路不做硬件滤波，该滤波机制也可以保证可靠地检测到按键事件
   / ^: X: D( M: f
5. */
   6 o" C: a# @0 C; s" ?/ `/ _6 F
6. #define KEY_FILTER_TIME   5
   0 F8 ]7 J0 t6 m
7. #define KEY_LONG_TIME     100                        /* 单位10ms， 持续1秒，认为长按事件 */

复制代码

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

6 w8 F; Y& k: H4 H; q# Z- S

1. /*
   
2. *********************************************************************************************************
   1 [3 T. D: z+ d
3. *        函 数 名: KeyPinActive
   1 {. r9 t' ~& C- ]! @
4. *        功能说明: 判断按键是否按下
   
5. *        形    参: 无
   " p$ }" F# w; F6 t) }
6. *        返 回 值: 返回值1 表示按下(导通），0表示未按下（释放）
   ! S# c. D. r; G" ]6 L$ A
7. *********************************************************************************************************
   
8. */
   
9. static uint8_t KeyPinActive(uint8_t _id)
   + E/ G, I$ _2 J& f. T$ R
10. {
    
11.         uint8_t level;
    
12.         
    
13.         if ((s_gpio_list[_id].gpio->IDR & s_gpio_list[_id].pin) == 0)
    
14.         {
    
15.                 level = 0;
    6 o/ P" p, V" s; `6 l
16.         }
    # D7 }3 L" o" p+ R( c6 |, `" o: d0 J
17.         else
    
18.         {
    
19.                 level = 1;
    
20.         }
    
21. 
    
22.         if (level == s_gpio_list[_id].ActiveLevel)
    
23.         {
    
24.                 return 1;
    4 |6 A, ]# Z- _% Y$ T( x
25.         }
    
26.         else
    
27.         {
    5 R0 W5 G1 Z) j+ s! `% J% I4 j
28.                 return 0;
    
29.         }
    
30. }
    ( ^$ s) C/ [( l; T# A# H
31. 
    
32. /*
    
33. *********************************************************************************************************
    
34. *        函 数 名: IsKeyDownFunc
    . d$ W0 u- L) h5 S) b
35. *        功能说明: 判断按键是否按下。单键和组合键区分。单键事件不允许有其他键按下。
    , i( G4 z. L- v9 H( {
36. *        形    参: 无
    ! o8 T9 Y; ~9 ]
37. *        返 回 值: 返回值1 表示按下(导通），0表示未按下（释放）
    / E; k0 J+ N0 i$ _7 w0 H
38. *********************************************************************************************************
    
39. */
    
40. static uint8_t IsKeyDownFunc(uint8_t _id)
    - _' d% u' ^4 f
41. {
    0 V( H, M& i! A- `2 J( H
42.         /* 实体单键 */
    9 A3 Z' h2 V# ]; r8 q5 j6 y
43.         if (_id < HARD_KEY_NUM)
    7 c* S0 V, A2 I) ]) ^: M8 V
44.         {
    + ~6 F1 m) u$ O, o% \
45.                 uint8_t i;
    . e) |" J9 d: [. i% F" s
46.                 uint8_t count = 0;
    2 d5 E. n& ^( m1 b/ x
47.                 uint8_t save = 255;
    # f& F+ W  o% O% z
48.                
    , l/ ~0 r  k) [" [# `9 o! l2 B& a5 y
49.                 /* 判断有几个键按下 */
    
50.                 for (i = 0; i < HARD_KEY_NUM; i++)
    $ F( M0 r, s, y/ M5 n. L% N) S* m
51.                 {
    
52.                         if (KeyPinActive(i))
    6 ^9 x# h) C) d1 k9 n: ^& r& e
53.                         {
    
54.                                 count++;
    % d9 k6 j5 ~7 \  z. L. ]9 a
55.                                 save = i;
    
56.                         }
    ; i9 P) E3 p: r, M6 ^7 d8 c" _
57.                 }
    
58.                
    
59.                 if (count == 1 && save == _id)
    8 A/ e4 o! w. C2 g5 J6 X
60.                 {
    
61.                         return 1;        /* 只有1个键按下时才有效 */
    
62.                 }               
    - h! J+ E( c( n6 s$ w6 V0 J
63. 
    # e, [; g9 g9 Q" b: q+ `  v
64.                 return 0;
    2 L' e8 L  T! I, Y. h
65.         }
    5 M! u( e# a1 O9 ]/ {" P: c
66.         
    
67.         /* 组合键 K1K2 */
    ; f2 B6 y9 g& |' U- c$ c
68.         if (_id == HARD_KEY_NUM + 0)
    $ {! k, t" _1 R; O
69.         {
    
70.                 if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
    # E& P, m: I, L$ ?
71.                 {
    
72.                         return 1;
    ( f/ V" J4 {# H6 m8 ]3 O0 P3 W/ G1 g  G
73.                 }
    
74.                 else
    0 t: A% G0 k) {9 q( Z
75.                 {
    
76.                         return 0;
    % {% }# W. P6 G1 B  i" q  P& G
77.                 }
    
78.         }
    
79. 
    
80.         /* 组合键 K2K3 */
    % y; E8 p5 z9 h* t
81.         if (_id == HARD_KEY_NUM + 1)
    : n$ l8 O- E1 V( J+ J: b1 q
82.         {
    
83.                 if (KeyPinActive(KID_K2) && KeyPinActive(KID_K3))
    + z8 d/ W( b9 L7 c/ G6 Q
84.                 {
    
85.                         return 1;
    
86.                 }
    9 Y- U" J/ I$ b* n: J: s# s% e- G
87.                 else
    
88.                 {
    
89.                         return 0;
    ; _* M' P" {- Z- j' i' \+ B' y( ~
90.                 }
    " ]( i! x" d  ^
91.         }
    
92. 
    ( D* D4 K, G1 ~" S6 N3 }' H. H
93.         return 0;
    
94. }

复制代码

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

1. /*
   5 ?9 y. o; A; ]! ^8 ]# F/ S- l2 k# t
2. *********************************************************************************************************
   1 P# }$ p! @' X7 y8 }) b
3. *        函 数 名: bsp_InitKeyHard
   % i0 b& r0 T+ _! ]$ O0 U5 p9 J
4. *        功能说明: 配置按键对应的GPIO
   % W: V. G; B2 O8 |4 H" [. z
5. *        形    参:  无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void bsp_InitKeyHard(void)
   
10. {        
    $ j3 M9 l2 U! x& H
11.         GPIO_InitTypeDef gpio_init;
    
12.         uint8_t i;
    * R) x; L3 ~4 m) q
13. 
    ' X" r* l8 x  w7 G( B4 D
14.         /* 第1步：打开GPIO时钟 */
    4 L$ K  z& z6 w5 {
15.         ALL_KEY_GPIO_CLK_ENABLE();
    & n% k3 ?$ H$ Z. B8 }1 V# x; e
16.         
    + d1 ]6 t8 ^; ?( M# y, e
17.         /* 第2步：配置所有的按键GPIO为浮动输入模式(实际上CPU复位后就是输入状态) */
    
18.         gpio_init.Mode = GPIO_MODE_INPUT;                           /* 设置输入 */
    % x, k, Z- q! x, }' B
19.         gpio_init.Pull = GPIO_NOPULL;                 /* 上下拉电阻不使能 */
    6 W& @9 q; n% D! u8 P( s- }/ d, r% c
20.         gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;  /* GPIO速度等级 */
    8 r) ]; {) x/ e4 E
21.         
    : x! J. ?0 `/ O* m0 n1 Q
22.         for (i = 0; i < HARD_KEY_NUM; i++)
    
23.         {
    4 G2 B: W0 T" E4 d$ h! P
24.                 gpio_init.Pin = s_gpio_list<span style="font-style: italic;"><span style="font-style: normal;">.pin;
    % Y$ f; {; _; q' V
25.                 HAL_GPIO_Init(s_gpio_list</span><span style="font-style: normal;">.gpio, &gpio_init);        
    ; Q  q, {" X9 K
26.         }
    
27. }</span></span>

复制代码

我们再来看看按键是如何执行扫描检测的。
5 }5 C  R5 k5 {* [, T( s
按键扫描函数bsp_KeyScan10ms ()每隔10ms被执行一次。bsp_RunPer10ms函数在systick中断服务程序中执行。

1. void bsp_RunPer10ms(void)
   
2. {
   3 g, }" g+ x; L0 H
3.         bsp_KeyScan10ms();                /* 扫描按键 */
   
4. }

复制代码

bsp_KeyScan10ms ()函数的实现如下：
$ n( S" h' _3 I; d6 w  D
- L! P" L& B: P0 {

1. /*
   1 n, N" G4 z# U; Q/ I  \; c
2. *********************************************************************************************************
   9 o6 K6 c& ~. {' G' o
3. *        函 数 名: bsp_KeyScan10ms
   
4. *        功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
     ^$ m' N5 E9 q- g. o- K# I
8. */
   
9. void bsp_KeyScan10ms(void)
   ( b0 K$ f2 g* c6 ^: a# N
10. {
    
11.         uint8_t i;
    & F0 i2 l( i3 ^
12. 
    
13.         for (i = 0; i < KEY_COUNT; i++)
    $ C- p; c' T. {9 ^( \( k$ V- c$ r# f
14.         {
    
15.                 bsp_DetectKey(i);
    6 o0 q% ~$ j$ ?5 _- T8 o2 d8 H/ ]
16.         }
    * z1 S; X2 w0 q- e* y! ?# B
17. }

复制代码

" f. v* N3 j3 ^  `每隔10ms所有的按键GPIO均会被扫描检测一次。bsp_DetectKey函数实现如下：
# z1 h9 ^- O3 F6 D& t& T

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_DetectKey
   
4. *        功能说明: 检测一个按键。非阻塞状态，必须被周期性的调用。
   3 f2 O" f" S% v" G7 B
5. *        形    参: IO的id， 从0开始编码
   ; [3 y: N8 g1 }, L# l' W
6. *        返 回 值: 无
     V& Y% X: [* y5 E, J* F; X1 a7 _" h3 z: a
7. *********************************************************************************************************
   $ n3 Q' x+ u# l
8. */
   
9. static void bsp_DetectKey(uint8_t i)
   8 n' _7 _3 y2 L9 [1 H. t) F) @
10. {
    
11.         KEY_T *pBtn;
    
12. 
    ' Z9 w4 {) ?3 L9 t0 |  N
13.         pBtn = &s_tBtn<span style="font-style: italic;"><span style="font-style: normal;">;
    * F" s! D& X$ h  y* M
14.         if (IsKeyDownFunc(i))
    8 Y8 r8 X. L7 C! c* b( [
15.         {
    . K: a5 N( j1 _
16.                 if (pBtn->Count < KEY_FILTER_TIME)
    
17.                 {
    # x4 l8 M+ W; W1 ]) C) i  V+ ?
18.                         pBtn->Count = KEY_FILTER_TIME;
    
19.                 }
    
20.                 else if(pBtn->Count < 2 * KEY_FILTER_TIME)
    
21.                 {
    
22.                         pBtn->Count++;
    
23.                 }
    
24.                 else
    
25.                 {
    
26.                         if (pBtn->State == 0)
    0 \# d" F. Z1 f) B# V
27.                         {
    
28.                                 pBtn->State = 1;
    3 [2 w2 ]- D1 N* c
29. 
    ! C0 g) g% g( i4 {- R' y) K# O4 ^
30.                                 /* 发送按钮按下的消息 */
    
31.                                 bsp_PutKey((uint8_t)(3 * i + 1));
    
32.                         }
    
33. 
    
34.                         if (pBtn->LongTime > 0)
      `* N' V) q# F
35.                         {
    4 G# x) O* ]( m0 f( j/ T& ?
36.                                 if (pBtn->LongCount < pBtn->LongTime)
    
37.                                 {
    ) L$ b. }& |' U
38.                                         /* 发送按钮持续按下的消息 */
    # v' x5 N' K6 y" i
39.                                         if (++pBtn->LongCount == pBtn->LongTime)
    
40.                                         {
    0 r# ^" Y/ w' V* x
41.                                                 /* 键值放入按键FIFO */
    
42.                                                 bsp_PutKey((uint8_t)(3 * i + 3));
    
43.                                         }
    
44.                                 }
    7 r8 H; I  K( d" K& X+ P
45.                                 else
    
46.                                 {
    
47.                                         if (pBtn->RepeatSpeed > 0)
    
48.                                         {
    0 S9 T. t" e8 Q" W: h6 t9 d
49.                                                 if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
    
50.                                                 {
    
51.                                                         pBtn->RepeatCount = 0;
    
52.                                                         /* 常按键后，每隔RepeatSpeed * 10ms发送1个按键 */
    
53.                                                         bsp_PutKey((uint8_t)(3 * i + 1));
    : R8 F/ d5 O5 B8 B. F* Q
54.                                                 }
    
55.                                         }
    
56.                                 }
    6 f! t# i' y2 `6 a7 p! O) _, ~5 U
57.                         }
    * J8 \7 M# u8 \5 x2 ^: D! S$ f/ y
58.                 }
    
59.         }
    ) a% ?8 W; `8 O% i# r2 X
60.         else
    + H3 q9 S5 }* P2 j6 b
61.         {
    3 m. e7 l3 R! `/ k
62.                 if(pBtn->Count > KEY_FILTER_TIME)
    ) Q$ T# O, @0 n) ^
63.                 {
    
64.                         pBtn->Count = KEY_FILTER_TIME;
    
65.                 }
    ' o, p4 t$ j$ P. ^8 q" n) v
66.                 else if(pBtn->Count != 0)
    3 Y! t+ W. p! a6 Y! ~3 q; ~) p- u
67.                 {
    
68.                         pBtn->Count--;
    
69.                 }
    
70.                 else
    
71.                 {
    
72.                         if (pBtn->State == 1)
    
73.                         {
    % q$ d/ F7 Z  k  ^
74.                                 pBtn->State = 0;
    
75. 
    
76.                                 /* 发送按钮弹起的消息 */
    
77.                                 bsp_PutKey((uint8_t)(3 * i + 2));
    
78.                         }
    
79.                 }
    - o' c1 T& M1 u+ W( t! ^
80. 
    4 r' V, {5 p: c7 W: ?9 E  J
81.                 pBtn->LongCount = 0;
    
82.                 pBtn->RepeatCount = 0;
    * ^5 X1 d4 C+ `1 G* O# w$ Y* K
83.         }
    * v& b( h( d3 E: N  e
84. }</span></span>

复制代码

对于初学者，这个函数看起来比较吃力，我们拆分进行分析。
( Y6 z- l) l9 u3 E: V
3 X! u6 I+ w& I

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

复制代码

读取相应按键的结构体地址，程序里面每个按键都有自己的结构体。
5 N5 a5 ^8 c  z0 N$ V3 S) k

1. static KEY_T s_tBtn[KEY_COUNT];
   
2. if (IsKeyDownFunc(i))
   
3. {
   ; ^; G4 p+ v% Q3 V& H
4.         这个里面执行的是按键按下的处理
   9 j/ c" `1 \- M3 u3 y4 S: e
5. }
   $ r0 X* H2 f6 }2 \
6. else
   4 `0 a: F$ h! Q
7. {
   
8.         这个里面执行的是按键松手的处理或者按键没有按下的处理
   
9. }

复制代码

执行函数IsKeyDownFunc(i)做按键状态判断。
; V8 n( n6 T$ t; C* V

1. /*
   
2. **********************************************************************************
   7 [/ Q* I$ S+ T0 ?) I, X. R. J- B
3. 下面这个if语句主要是用于按键滤波前给Count设置一个初值，前面说按键初始化的时候
   
4. 已经设置了Count = KEY_FILTER_TIME/2
   
5. **********************************************************************************
   1 ~6 D3 I9 G' a9 s0 x; _
6. */
   
7. if (pBtn->Count < KEY_FILTER_TIME)
   
8. {
   . o8 _, m: M: L6 M9 e' i5 O
9.     pBtn->Count = KEY_FILTER_TIME;
   
10. }
    
11. 
    
12. /*
    
13. **********************************************************************************
    
14. 这里实现KEY_FILTER_TIME时间长度的延迟
    7 C& e' h9 |. n0 d0 [
15. **********************************************************************************
    
16. */
    
17. else if(pBtn->Count < 2 * KEY_FILTER_TIME)
    
18. {
    
19.     pBtn->Count++;
    & K$ Q# y$ J3 |+ c
20. }
    $ v9 p* f* ?) z8 B
21. /*
    
22. **********************************************************************************
    1 h3 I; o5 ]' `8 E% ]! z- R
23. 这里实现KEY_FILTER_TIME时间长度的延迟
    . Z  D6 v) p; {1 Q% i
24. **********************************************************************************
    & }$ C& ^2 p+ B6 `9 q$ j
25. */
    
26. else
    
27. {
    5 b; O) H) l5 o. o* ]
28. /*
    . ^# O' `/ ~' b% F' D
29. **********************************************************************************
    & W* @5 P0 d5 ^1 l
30. 这个State变量是有其实际意义的，如果按键按下了，这里就将其设置为1，如果没有按下这个
    
31. 变量的值就会一直是0，这样设置的目的可以有效的防止一种情况的出现：比如按键K1在某个
    
32. 时刻检测到了按键有按下，那么它就会做进一步的滤波处理，但是在滤波的过程中，这个按键
    ) ?8 N) L0 Q5 w& J, v: U7 B
33. 按下的状态消失了，这个时候就会进入到上面第二步else语句里面，然后再做按键松手检测滤波
    
34. ，滤波结束后判断这个State变量，如果前面就没有检测到按下，这里就不会记录按键弹起。
    1 O1 d5 b8 l( c! z
35. **********************************************************************************
    ) t  F' }4 B  T' c( d
36. */
    
37.     if (pBtn->State == 0)
    
38.     {
    8 I) p/ u# E; e8 V0 B' |
39.         pBtn->State = 1;
    + _: c% h: \; H' G
40. 
    ; ]2 A. D3 \& i. [, v  K$ \+ t
41.         /* 发送按钮按下的消息 */
    
42.         bsp_PutKey((uint8_t)(3 * i + 1));
    % W" u$ [% E# T  a1 x
43.     }
    " N) y- m; o3 l" K
44. 
    
45.     if (pBtn->LongTime > 0)
    5 f- B4 \# Z; t9 d
46.     {
    1 g' K* Y9 o" m/ t
47.         if (pBtn->LongCount < pBtn->LongTime)
    
48.         {
    
49.             /* 发送按钮持续按下的消息 */
    
50.             if (++pBtn->LongCount == pBtn->LongTime)
    ; c0 \' D: k4 _" B( U
51.             {
    # H  u- e8 e) n, N) H
52.                 /* 键值放入按键FIFO */
    
53.                 bsp_PutKey((uint8_t)(3 * i + 3));
    
54.             }
    5 m' B+ b& A& a% {; [
55.         }
    
56.         else
    ; O, ~/ ?9 _" T$ E% k+ y/ `
57.         {
    ! a5 {* l3 V: y. Q: k$ F5 q1 ~
58.             if (pBtn->RepeatSpeed > 0)
    
59.             {
    . a$ a3 e4 v8 X4 i% ^/ v. k
60.                 if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
    
61.                 {
    # Q, t8 n! N* L" b! c& ^
62.                     pBtn->RepeatCount = 0;
    * f' w/ p& l- q0 L' L" J% c
63.                     /* 长按键后，每隔10ms发送1个按键 */
    
64.                     bsp_PutKey((uint8_t)(3 * i + 1));
    
65.                 }
    
66.             }
    
67.         }
    7 D* Z" Q1 s$ S5 }
68.     }
    ' {/ h4 D) N# o, ~/ c! ^- T
69. }

复制代码

; a8 K9 X. ^" N5 w3 D# Z19.3.4 按键检测采用中断方式还是查询方式
+ h" x- U( \/ }* }检测按键有中断方式和GPIO查询方式两种。我们推荐大家用GPIO查询方式。

! c  y. _6 n" U1 U' y' A6 p$ Y从裸机的角度分析
8 u- h7 j7 o+ z) r- N1 G
2 _6 e% \- N6 f) d! B; P中断方式：中断方式可以快速地检测到按键按下，并执行相应的按键程序，但实际情况是由于按键的机械抖动特性，在程序进入中断后必须进行滤波处理才能判定是否有效的按键事件。如果每个按键都是独立的接一个IO引脚，需要我们给每个IO都设置一个中断，程序中过多的中断会影响系统的稳定性。中断方式跨平台移植困难。
, |4 l2 M- h5 b3 |9 u$ P: s5 B
查询方式：查询方式有一个最大的缺点就是需要程序定期的去执行查询，耗费一定的系统资源。实际上耗费不了多大的系统资源，因为这种查询方式也只是查询按键是否按下，按键事件的执行还是在主程序里面实现。
$ ~( Q1 [! m' e4 Y! ~
# G$ p% ^& C) `2 @% w从OS的角度分析

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

1 ~$ H3 {8 i2 L# O* E19.4 按键板级支持包（bsp_key.c）
按键驱动文件bsp_key.c主要实现了如下几个API：

& _  [6 I! O% X4 u  KeyPinActive
' k! {$ y% v! t7 X0 ~  IsKeyDownFunc
  bsp_InitKey
" k1 w' o" }$ l% \, T" N8 X: [1 C  bsp_InitKeyHard
$ U; e1 s8 s- Q+ L' _% A  bsp_InitKeyVar
  bsp_PutKey
  bsp_GetKey
' S3 E& m& [# i" a$ f3 ]% `  bsp_GetKey2
' y/ i3 v5 G0 ~" w; d. ~5 ?  {' t  bsp_GetKeyState
6 R: T0 j  V, h  bsp_SetKeyParam
: N( R% P4 Q+ S$ r" i  bsp_ClearKey
0 g8 l, I4 W/ Y  bsp_DetectKey
  bsp_DetectFastIO
( p+ i6 }/ A8 w3 y  bsp_KeyScan10ms
  bsp_KeyScan1ms

所有这些函数在本章的19.3小节都进行了详细讲解，本小节主要是把需要用户调用的三个函数做个说明。

19.4.1 函数bsp_InitKeyHard
函数原型：

1. /*
     \0 \" u" @, E6 ]
2. *********************************************************************************************************
   % N, x) z( d! E7 t2 W4 p/ x
3. *        函 数 名: bsp_InitKey
   ; e9 M3 r) T% p* ^2 A% }
4. *        功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
   + L, T. |  w4 c! l2 E8 V
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   + ~. g9 c0 n8 ~! k$ W2 M: [
8. */
   
9. void bsp_InitKey(void)
     \* ^* `: o+ j. y6 d7 E* D
10. {
    
11.         bsp_InitKeyVar();                /* 初始化按键变量 */
    8 O; N3 a9 ~. v$ O! w# Z( s1 f
12.         bsp_InitKeyHard();                /* 初始化按键硬件 */
    & P- \2 @7 y- ^  |/ W1 u( F! r5 }
13. }

复制代码

函数描述：

0 W$ h0 d; H( E- u6 }此函数主要用于按键的初始化。

使用举例：

; u. u! z8 {$ H; ]! Q底层驱动初始化直接在bsp.c文件的函数bsp_Init里面调用即可。
$ ~5 T9 u( m8 @  d5 @' g
19.4.2 函数bsp_GetKey
函数原型：

1. /*
   
2. *********************************************************************************************************
     h: b+ D, Q( r% u4 B5 }4 o
3. *        函 数 名: bsp_GetKey
   
4. *        功能说明: 从按键FIFO缓冲区读取一个键值。
   
5. *        形    参: 无
   
6. *        返 回 值: 按键代码
   & G) m, U, v6 C4 y5 b) j
7. *********************************************************************************************************
   ) U1 ]3 o5 a' n9 Y# M) ^
8. */
   
9. uint8_t bsp_GetKey(void)
   + X% A. ^" Z" a! {: ]2 J) p
10. {
    6 M  s# C$ g& N- H: f) Q+ R
11.         uint8_t ret;
    - G+ S- e8 Q, ~0 l% n4 H$ c
12. 
    
13.         if (s_tKey.Read == s_tKey.Write)
    5 ^) v! f2 T( X' w3 h2 R$ W+ k
14.         {
    
15.                 return KEY_NONE;
    ( z4 ]8 F. Y+ p) I+ P7 H9 j
16.         }
      k* a: H  d0 L  W; R
17.         else
    
18.         {
    
19.                 ret = s_tKey.Buf[s_tKey.Read];
    
20. 
    2 |/ E3 s5 o, F- ?' _' z: a
21.                 if (++s_tKey.Read >= KEY_FIFO_SIZE)
    0 v: X, e, m4 G, l9 K% i6 X/ |
22.                 {
    " T6 B+ ?$ @7 n- ^. m' @4 m
23.                         s_tKey.Read = 0;
    ' h- n( ~! F0 M" W% U' i5 ^
24.                 }
    ! q9 q) F: B; [1 r8 O( x6 n, i
25.                 return ret;
    / y6 x3 k; n' ]; g, ~
26.         }
    
27. }

复制代码

9 n7 _# w5 ]& v3 r8 I函数描述：

此函数用于从FIFO中读取键值。

9 K7 r$ I& @# S2 s  E使用举例：

9 V; `9 G/ C9 y& N) z9 N1 L调用此函数前，务必优先调用函数bsp_InitKey进行初始化。
9 l/ K/ ~; t; s6 n  Y

1. /*
   % Z/ {/ Q5 B- Y( Q- f% ]( h
2. *********************************************************************************************************
   
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   0 W- C' p) G  J0 ?
5. *        形    参: 无
   ) m4 M- F0 N" ^, {9 D
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   ; C: I: K& U4 {( I3 y
8. */
   
9. int main(void)
   
10. {
    4 _4 X! [" z. g' u2 d
11.         uint8_t ucKeyCode;                /* 按键代码 */
    4 q2 l4 q. u# y9 o; ?: m0 z
12.         
    , @" q$ i2 g, I; k  r1 x
13.         bsp_Init();                /* 硬件初始化 */
    1 b) U) p; ?/ O7 k
14.         
    6 F+ D4 |' ]) J+ u9 j; h7 q! F
15.         /* 进入主程序循环体 */
    1 _! h' w, k0 U4 L' G3 A) C
16.         while (1)
    
17.         {               
    
18.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
19.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
20.                 if (ucKeyCode != KEY_NONE)
    
21.                 {
    
22.                         switch (ucKeyCode)
    ) `* ], V5 _4 Y6 Q0 j' h
23.                         {
    
24.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    
25.                                         printf("K1键按下\r\n");
    : q6 a( E: {9 D
26.                                         break;
    2 s8 k3 L6 B+ U% {: N
27. 
    * [0 y* x+ w/ s# L3 h
28.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    : Z& U  F% h7 {$ Y
29.                                         printf("K2键按下\r\n");
    
30.                                         break;
    - Q( l  a% e1 G3 j( P  |  a. S
31. 
    
32.                                 default:
    % l; A8 E$ B$ }% a& `" C
33.                                         /* 其它的键值不处理 */
    
34.                                         break;
    
35.                         }
    " U1 Z; i- Y$ @
36.                 }
    
37.         }
    ( v7 W5 T. P( l7 |
38. }

复制代码

19.4.3 函数bsp_KeyScan10ms
/ i, P/ {; Z& {5 \( y9 Y函数原型：

1. /*
   
2. *********************************************************************************************************
   7 O. l5 U# N, F) K1 u
3. *        函 数 名: bsp_KeyScan10ms
   3 r3 v) r# V! c, R' T0 n
4. *        功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. void bsp_KeyScan10ms(void)
   - v! m  }, U( j
10. {
    - ^6 o$ F2 n1 B% ~
11.         uint8_t i;
    
12. 
      ]" \) F1 D( o: z- Z* p
13.         for (i = 0; i < KEY_COUNT; i++)
    & d8 U, V7 P- B. [! x
14.         {
    4 k$ B: y" j( F' q
15.                 bsp_DetectKey(i);
    
16.         }
    ( M; H, d3 ?- a, T( B0 C+ R9 g
17. }

复制代码

8 e- \7 H' u! h# R* R函数描述：
- h2 N9 T, z; O
此函数是按键的主处理函数，用于检测和存储按下、松手、长按等状态。
7 R  p4 _7 e4 A1 k' e, k! \+ J
2 e6 f( R, X9 u使用举例：
8 I2 ]$ K$ s- W3 L3 M4 I  l0 S' z
调用此函数前，务必优先调用函数bsp_InitKey进行初始化。
# _& T( ~% i" z
& ]  T' ?0 t1 b9 Z) u7 C另外，此函数需要周期性调用，每10ms调用一次。

9 S( E3 o% u  ~  如果是裸机使用，将此函数放在bsp.c文件的bsp_RunPer10ms函数里面即可，这个函数是由滴答定时器调用的，也就是说，大家要使用按键，定时器的初始化函数bsp_InitTimer一定要调用。
  如果是RTOS使用，需要开启一个10ms为周期的任务调用函数bsp_KeyScan10ms。
& c7 T/ }% Z  j3 i/ i9 A% V( K
0 H/ V; l! ~& L19.5 按键FIFO驱动移植和使用
4 m8 J6 w' j8 b按键移植步骤如下：
" a/ D9 ~  U& N% I$ y* q
  第1步：复制bsp_key.c和bsp_key.c到自己的工程。
& b2 g) @. |& H% ^# T  第2步：根据自己使用的独立按键个数和组合键个数，修改几个地方。

1. #define HARD_KEY_NUM        8                     /* 实体按键个数 */
   $ y8 |3 E1 j5 I& Q3 c- f2 s7 \: Z
2. #define KEY_COUNT   (HARD_KEY_NUM + 2)   /* 8个独立建 + 2个组合按键 */

复制代码

9 h( ?4 R. o0 m0 e! a  第3步：根据使用的引脚时钟，修改下面函数：
3 l5 K) U, {, k' i! G" I

1. /* 使能GPIO时钟 */
   - c) `  b, X' Q  q% H7 O2 h% n4 u
2. #define ALL_KEY_GPIO_CLK_ENABLE() {        \
   + l/ h# B' H1 l, E9 l- G- y- J
3.                 __HAL_RCC_GPIOB_CLK_ENABLE();        \
   5 w, f, K0 w/ [9 @5 ?0 O% |
4.                 __HAL_RCC_GPIOC_CLK_ENABLE();        \
   ( i* O. a  v# Y, m' h" A
5.                 __HAL_RCC_GPIOG_CLK_ENABLE();        \
   
6.                 __HAL_RCC_GPIOH_CLK_ENABLE();        \
   
7.                 __HAL_RCC_GPIOI_CLK_ENABLE();        \
   ; z: `' s; R5 B
8.         };

复制代码

  第4步：根据使用的具体引脚，修改如下函数，第3列参数低电平表示按下或者高电平表示按下：

1. /* GPIO和PIN定义 */
   
2. static const X_GPIO_T s_gpio_list[HARD_KEY_NUM] = {
   
3.         {GPIOI, GPIO_PIN_8, 0},                /* K1 */
   ) u) D- @  p! I3 \1 V
4.         {GPIOC, GPIO_PIN_13, 0},        /* K2 */
   
5.         {GPIOH, GPIO_PIN_4, 0},                /* K3 */
   ) ~6 G! v# M0 l8 n9 t$ h+ k. M% p/ P
6.         {GPIOG, GPIO_PIN_2, 0},                /* JOY_U */        
   
7.         {GPIOB, GPIO_PIN_0, 0},                /* JOY_D */
   
8.         {GPIOG, GPIO_PIN_3, 0},                /* JOY_L */        
   . y) U. D* h, r& m  s9 ^
9.         {GPIOG, GPIO_PIN_7, 0},                /* JOY_R */        
   
10.         {GPIOI, GPIO_PIN_11, 0},        /* JOY_OK */
    + {0 T9 ]2 K% n& ~
11. };   

复制代码

     
  第5步：根据使用的组合键个数，在函数IsKeyDownFunc里面添加相应个数的函数：

1.         /* 组合键 K1K2 */
   
2.         if (_id == HARD_KEY_NUM + 0)
   
3.         {
   
4.                 if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
   
5.                 {
   
6.                         return 1;
   
7.                 }
   
8.                 else
   
9.                 {
   ' x8 C+ }5 F* h- M
10.                         return 0;
    % ?2 }' W+ l1 x# u4 {
11.                 }
    & z7 P  g7 B; h0 w1 |
12.         }

复制代码

) a6 }% Y' e# B5 w  J4 l5 B2 Z第2行ID表示HARD_KEY_NUM + 0的组合键，HARD_KEY_NUM + 1表示下一个组合键，以此类推。

" K7 C: H2 M5 _! a另外就是，函数KeyPinActive的参数是表示检测哪两个按键，设置0的时候表示第4步里面的第1组按键，设置为1表示第2组按键，以此类推。
) M  R6 A0 i+ _
  第6步：主要用到HAL库的GPIO驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
  第7步：移植完整，应用方法看本章节配套例子即可。
特别注意，别忘了每10ms调用一次按键检测函数bsp_KeyScan10ms。

2 {- s9 k; G9 J# q% P19.6 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：

( S. j/ l3 U: P% I

1、 第1阶段，上电启动阶段：
0 B( l7 n4 G; `3 v
这部分在第14章进行了详细说明。
. r5 ]0 k" e+ x, V# t
! v6 _& I  @, l9 s; b 2、 第2阶段，进入main函数：
, i- {  K; n$ K& C
  第1部分，硬件初始化，主要是MPU、Cache、HAL库、系统时钟、滴答定时器、按键等。
  第2部分，应用程序设计部分，实现了一个按键应用。
  第3部分，按键扫描程序每10ms在滴答定时中断执行一次。

( n0 H% u) n- U: [/ {. f" s; u19.7 实验例程说明（MDK）
配套例子：
' l) E  B- V1 hV7-002_按键检测（软件滤波，FIFO机制）

8 d9 H, P/ U+ G. L) {实验目的：
* B- w1 c3 ^' V学习按键的按下，弹起，长按和组合键的实现。
2 Z* w3 N9 j% T) O% E" @6 g' F; N
, o# g5 G5 X: Q3 Z实验内容：
- Z4 n! l' b4 d0 a启动一个自动重装软件定时器，每100ms翻转一次LED2。
+ \+ \& e! B. z3 f4 x; }
实验操作：
3个独立按键和5向摇杆按下时均有串口消息打印。
& ?$ w' Z0 c6 {8 Q- Q5向摇杆的左键和右键长按时，会有连发的串口消息。
" a" D2 H. Z+ i' J独立按键K1和K2按键按下，串口打印消息。

上电后串口打印的信息：

0 P3 f4 v7 K" X2 l波特率 115200，数据位 8，奇偶校验位无，停止位 1
$ X1 |$ A$ Q4 |. H

0 i- r" E+ f# h( c: a程序设计：
) l+ `' m# O# t! @2 Z# D7 N* C8 a
, T/ q8 h6 M: m& P. t  |2 b6 o9 e  系统栈大小分配：

: G- ]' l2 k7 _. d7 d" K

+ y. R( F; }1 i0 N% m, W# P( f# b
  RAM空间用的DTCM：
0 I  J: P: s. Y# a' y' v

. a% k3 u6 B5 `! d: P. j  硬件外设初始化
1 I) {* W6 x# t: R/ E& t. q# }
硬件外设的初始化是在 bsp.c 文件实现：

9 N- }: s1 j, B5 r

1. /*
   
2. *********************************************************************************************************
   % N( _2 ?/ E: {$ \
3. *        函 数 名: bsp_Init
   ( N" \& J: j/ l5 \5 g8 @
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   - D3 v! m) r6 X% o
6. *        返 回 值: 无
   + B( \2 h8 ~& j' I& o
7. *********************************************************************************************************
   
8. */
   
9. void bsp_Init(void)
   
10. {
    5 S, z* w" q& \7 P- N
11.     /* 配置MPU */
    
12.         MPU_Config();
    % s. V/ o: u2 s1 T& g/ N6 b$ M& i
13.         
    * Q8 Y3 ~5 x+ i* h% g: @
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    
16. 
    6 O( p. Z/ |4 n+ c+ N
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    6 P2 T4 b1 d2 K' O- x5 L8 G/ e
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    0 \' U  k2 D2 A. Y
21.          */
    0 k- T4 N" k% |
22.         HAL_Init();
    # c5 n0 ~6 ~' G2 r+ F
23. 
    5 r# F0 o/ k' {, A; w; `
24.         /*
    
25.        配置系统时钟到400MHz
    5 T$ F6 R6 M0 b
26.        - 切换使用HSE。
    ' N. O1 A: q+ v
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    ; j9 w7 s6 Q1 d4 F. m0 p. c
28.     */
    / @# Y/ F# x: E  J6 U& u' T9 a
29.         SystemClock_Config();
    
30. 
    0 q, D0 p% W) J( T8 h2 d& G) h
31.         /*
    . T, f& D1 k) B: g
32.            Event Recorder：
    " j' `3 M& ?, F! x; O4 j
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    * T# g- {  J& K4 w6 K4 }
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    $ ?# E2 O1 }0 P$ m3 ~2 x7 t
36. #if Enable_EventRecorder == 1  
    . P3 v/ h: V+ [" _/ F
37.         /* 初始化EventRecorder并开启 */
    7 T( L1 r# b4 k( s6 @8 Q
38.         EventRecorderInitialize(EventRecordAll, 1U);
    9 S0 B1 O2 Q: }* D( B/ ~! E4 m
39.         EventRecorderStart();
    " \2 d( C# J. P/ Y
40. #endif
    6 q' T& p0 e* Y7 n, I; L
41.         
    - s  \4 `' _, u- y7 A
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    , d7 W9 S8 p$ f  w+ J0 ?, Z
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

: r, [5 L& i1 {; d: Y$ X2 C  MPU配置和Cache配置：
. p" _* E! V/ H' R$ j5 }+ E
% v+ u/ ^- x6 }$ L9 [  _: N6 _/ a数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
6 M# a  X5 s+ B8 f" D! Y# Q
  @0 f9 R9 A( C( K* ~9 p

1. /*
   4 ?+ p5 o2 p' K, g2 g' ?$ `, b! r1 j
2. *********************************************************************************************************
   2 h5 v7 W6 X- |3 V; m- a
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   , o$ t& Z8 c' R+ V# f
6. *        返 回 值: 无
   - L9 l( P! d" l' V" j
7. *********************************************************************************************************
   ; h* R" \, b8 }" H% ^3 m* w
8. */
   0 r8 U* s( \# i5 d# `9 j
9. static void MPU_Config( void )
   / J' l* T# D) O6 B" F6 E: k
10. {
    * t6 b8 {0 M6 l: [6 o) a, M
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    
15. 
    ) }' _+ W- X" R4 C
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ; d7 u# A8 W2 S7 }+ {% d! ~  L  m
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    4 {, \. R, ]; K4 T! a7 e
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
      U7 b! M" T: I! M
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    , u2 S/ p. T5 O* w/ A$ ^# R5 ]
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    " w0 a* T3 j! h
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    4 c( R& J" q4 C4 _
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    4 R. s4 z6 ~3 N3 a/ s! z3 _9 Q: k
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    ! ?, a5 k' f- e& P7 W' U
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    ! r, t  X7 d4 ]9 O4 q3 |6 J
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    : [& p1 m* c% b4 C# H7 \, E) e
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    * B, W$ o) i3 X( f/ h  Y
44.         
      v$ {) s2 v, x- S. @
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    + f9 l/ a3 z" C+ P+ `5 u! A
46. 
    ' m0 y, n2 @# u" V; H3 X0 P
47.         /*使能 MPU */
    
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    # {% c/ S9 |# U2 S; u7 F5 T' F" P
49. }
    ( d, L: n* J2 _) b8 ?% X6 f$ N
50. 
    & M) y% ]& X3 O' X
51. /*
    
52. *********************************************************************************************************
    9 r: s- x! k; j+ D. V
53. *        函 数 名: CPU_CACHE_Enable
    
54. *        功能说明: 使能L1 Cache
    
55. *        形    参: 无
    . e: F/ [( Z* P. x
56. *        返 回 值: 无
    # y0 B6 Y; r/ Z4 m3 g% Z7 ]# z
57. *********************************************************************************************************
    " M( w( X* w/ s2 |
58. */
    
59. static void CPU_CACHE_Enable(void)
      b# k4 ^3 T. W/ X3 r  o. [5 U5 o
60. {
    4 t+ ^, L! m3 l, j- j
61.         /* 使能 I-Cache */
    8 p! q5 H4 d3 _, P$ E: z
62.         SCB_EnableICache();
    8 }. T& S3 k: j# M) P2 ~
63. 
    
64.         /* 使能 D-Cache */
    
65.         SCB_EnableDCache();
    
66. }

复制代码

  每10ms调用一次按键检测：
2 S/ g( r4 y6 G0 {: D& b: `2 w% d
3 M8 \$ j# f+ Y6 a/ O7 `9 U按键检测是在滴答定时器中断里面实现，每10ms执行一次检测。
$ r; ?, L# S' X  Z" w

1. /*
   % h7 ?: \- ?% C. V  W
2. *********************************************************************************************************
   ( t5 f9 ^% j7 U$ M) T
3. *        函 数 名: bsp_RunPer10ms
   
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   9 I, Z" r, b: ]) _
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   + M# Z4 @. l: c5 O1 f6 p2 ?
6. *        形    参: 无
   
7. *        返 回 值: 无
   % @4 e9 P, G3 _4 E
8. *********************************************************************************************************
   
9. */
   
10. void bsp_RunPer10ms(void)
    # ?$ \- A& r$ g7 [' j
11. {
    
12.         bsp_KeyScan10ms();
    
13. }

复制代码

  主功能：

! v* B6 a9 H% l: r5 r: K, E主功能的实现主要分为两部分：

9 M- H# k5 t4 F) F6 ] 启动一个自动重装软件定时器，每100ms翻转一次LED2
按键消息的读取，检测到按下后，做串口打印。

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: main
   & E+ t. G1 U! N! v3 \
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   5 t/ d  @# _' }% t. ?) |  v
6. *        返 回 值: 错误代码(无需处理)
   ( ~) _7 }9 T$ J3 G: l+ R0 Q
7. *********************************************************************************************************
   7 P! O* L9 I7 K6 \6 a" O% M
8. */
   
9. int main(void)
   
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    * o0 }5 p4 ?6 b2 |8 V  j, G6 o* ~
12.         
    
13.         bsp_Init();                /* 硬件初始化 */
    % o# \( L+ h/ q6 u. W! Q
14.         
    
15.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
16.         PrintfHelp();        /* 打印操作提示 */
    + B+ p1 L$ ^: h0 a
17. 
    / |  i3 T- ]1 D9 @+ Y
18. 
    0 [) Q. X+ s5 J# @
19.         bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 */
    - `6 j# }# M- ?) e
20.         
    0 a- H! Y1 @# j) j: y: ~
21.         /* 进入主程序循环体 */
    ! I, m% M- K) z4 B7 z, ^' o
22.         while (1)
    ; O, [- v8 v$ T- p' I
23.         {
    8 J2 g. I. \: N0 M% p5 ?$ U
24.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    ! l* P* G/ i, I: P
25. 
    " N1 Z9 e. Y0 M
26.                 /* 判断定时器超时时间 */
    
27.                 if (bsp_CheckTimer(0))        
    
28.                 {
    
29.                         /* 每隔100ms 进来一次 */  
    ; L* P; S. U) B( B6 Y
30.                         bsp_LedToggle(2);                        
    ' x0 Z+ T: u' K8 ?
31.                 }
    
32.                
    
33.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    ! G) u  L* A+ @: h# C1 u3 o
34.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
35.                 if (ucKeyCode != KEY_NONE)
    
36.                 {
    , D4 d$ S/ T- L; d: P: v( J
37.                         switch (ucKeyCode)
    
38.                         {
    . v& s3 m5 K. k8 G- ^
39.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    
40.                                         printf("K1键按下\r\n");
    
41.                                         break;
    
42. 
    
43.                                 case KEY_UP_K1:                                /* K1键弹起 */
    ) \8 A$ }" A3 i7 x9 @( D( |! h
44.                                         printf("K1键弹起\r\n");
    
45.                                         break;
    7 X' J: v+ W! I
46. 
    # p6 P- m% z8 E% P0 Q% E8 f* N
47.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    6 _: [7 o: c  E+ |! v8 k2 J
48.                                         printf("K2键按下\r\n");
    
49.                                         break;
    & Y: N. {- U* {! t8 E( \  K
50. 
    9 G. t2 J* U2 I1 j; `
51.                                 case KEY_UP_K2:                                /* K2键弹起 */
    8 r* J( K: z9 G  y& x/ f5 K9 h
52.                                         printf("K2键弹起\r\n");
    
53.                                         break;
    ' }" f; B$ a$ N; a) G
54. 
    
55.                                 case KEY_DOWN_K3:                        /* K3键按下 */
    
56.                                         printf("K3键按下\r\n");
    9 ~+ @$ }) d, Q4 i
57.                                         break;
    
58. 
    ' Z. e/ ?! z, B% j1 E1 R% ]5 @
59.                                 case KEY_UP_K3:                                /* K3键弹起 */
      s6 P4 P" h+ ]( S8 [
60.                                         printf("K3键弹起\r\n");
    
61.                                         break;
    * |2 D% D4 B3 V& _7 b: w
62. 
    
63.                                 case JOY_DOWN_U:                        /* 摇杆UP键按下 */
    0 A2 M) ?5 f- p2 p8 b* n; @
64.                                         printf("摇杆上键按下\r\n");
    
65.                                         break;
    7 e3 D: K  Y) N7 A" C: L" @
66. 
    ! @) O- H2 _6 A; i7 ]
67.                                 case JOY_DOWN_D:                        /* 摇杆DOWN键按下 */
    
68.                                         printf("摇杆下键按下\r\n");
    1 v' F/ u5 `# n) h, I
69.                                         break;
    
70. 
    
71.                                 case JOY_DOWN_L:                        /* 摇杆LEFT键按下 */
    
72.                                         printf("摇杆左键按下\r\n");
    # b! ]/ b/ ^; p+ ~3 b7 K
73.                                         break;
    
74.                                 
    
75.                                 case JOY_LONG_L:            /* 摇杆LEFT键长按 */
    
76.                                         printf("摇杆左键长按\r\n");
    5 f/ N0 d3 v* G
77.                                         break;
    % F' M* A, A. `( ~
78. 
    
79.                                 case JOY_DOWN_R:                        /* 摇杆RIGHT键按下 */
    4 T1 M0 P' u# Y  U- F/ L% u
80.                                         printf("摇杆右键按下\r\n");
    6 \* G3 f6 S1 f$ T. [' L5 e
81.                                         break;
    4 v, z# i" ^0 R" S6 |% q. q5 k
82.                                 
    ; c: u4 A4 _! Y( }
83.                                 case JOY_LONG_R:            /* 摇杆RIGHT键长按 */
    0 g' p8 H  a0 J  j: d
84.                                         printf("摇杆右键长按\r\n");
    2 s, }! C2 f/ y  s
85.                                         break;
    1 S- m! q$ i  x9 C
86. 
    
87.                                 case JOY_DOWN_OK:                        /* 摇杆OK键按下 */
    " f2 o" e8 i' [
88.                                         printf("摇杆OK键按下\r\n");
    / }" `/ w0 v9 |7 f: @' h  l# B
89.                                         break;
    
90. 
    + e: O+ z0 m, @+ k7 o: y9 G
91.                                 case JOY_UP_OK:                        /* 摇杆OK键弹起 */
    
92.                                         printf("摇杆OK键弹起\r\n");
    : u8 T) e5 Z7 m3 W6 Z
93.                                         break;
    
94. 
    0 Q7 U  A+ z& z/ D& e1 t
95.                 case SYS_DOWN_K1K2:                        /* 摇杆OK键弹起 */
    ( w) z) e3 E* d" v
96.                                         printf("K1和K2组合键按下\r\n");
    
97.                                         break;
    
98. 
    6 {2 z2 q+ |+ J
99.                                 default:
    5 \! m, `, X! D% ^, v! }0 t
100.                                         /* 其它的键值不处理 */
     
101.                                         break;
     
102.                         }
     & d" e' }4 Q' c
103.                
     5 x2 B3 O) m4 F+ _
104.                 }
     
105.         }
     - `; [0 E: A0 R' ?5 G( E7 _
106. }

复制代码

; e5 I9 L" {$ r! x19.8 实验例程说明（IAR）
配套例子：
$ k* m7 t8 H; F& p# y; QV7-002_按键检测（软件滤波，FIFO机制）
# R- L- Z( B# E2 ~) d6 ~2 p6 h
5 |7 D0 }0 F. f" v+ Q" n2 p- j实验目的：
9 m4 }1 ]7 j2 I* c2 d学习按键的按下，弹起，长按和组合键的实现。

8 q0 k. s# b0 P4 d实验内容：
启动一个自动重装软件定时器，每100ms翻转一次LED2。
7 |3 P% X4 m3 W
8 A% s4 x% o; s5 T+ i; F实验操作：
3个独立按键和5向摇杆按下时均有串口消息打印。
5向摇杆的左键和右键长按时，会有连发的串口消息。
独立按键K1和K2按键按下，串口打印消息。

2 Z7 ?& k) t% p% u: M上电后串口打印的信息：
' K* I; t3 F' I( S# g
波特率 115200，数据位 8，奇偶校验位无，停止位 1

程序设计：
( e% K* \5 R) q: l2 t3 L; d& U* o3 q4 }
  系统栈大小分配：

  RAM空间用的DTCM：

  X7 k: H) H3 h* H. H
  硬件外设初始化

5 Q" A& _8 Y' H& S5 g! B. r' M硬件外设的初始化是在 bsp.c 文件实现：

; M/ K% v6 T1 _8 t

1. /*
   & b$ w- f9 t, Y7 F  C/ p6 |* |
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   + f5 c" ?- `6 \/ y
8. */
   * E" M% l9 L) V
9. void bsp_Init(void)
   6 |$ y- B' m) ]) J. \
10. {
    
11.     /* 配置MPU */
    
12.         MPU_Config();
    - G8 G: Z3 E4 v0 ?) G
13.         
    6 H* S" u: o: j+ f% v( N
14.         /* 使能L1 Cache */
    # M  ~" O( o1 S$ s' \5 C
15.         CPU_CACHE_Enable();
    
16. 
    0 K* N4 b% Q, p+ |, w! o
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    ' g/ O. x( f! `5 k
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    " \& D) M  t  F- w7 |
20.            - 设置NVIV优先级分组为4。
    7 l. s* c) ~) v1 Q* `5 v# X7 t
21.          */
    
22.         HAL_Init();
    
23. 
    
24.         /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    " H* N: I7 E. \" f! ?) E
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    8 {) d1 T; H3 }7 Z" I' {
29.         SystemClock_Config();
    ) E9 C% B6 p7 g# ~" e
30. 
    
31.         /*
    & u: f/ }/ d/ p: w
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    # K. Y; D* f! ]4 H/ D& n
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    6 G: R, T8 D# e0 w' }
35.         */        
    * X' a0 U  Z; M
36. #if Enable_EventRecorder == 1  
    # z7 Z( V0 ]( _6 _  Z1 Y9 U9 X1 D
37.         /* 初始化EventRecorder并开启 */
    4 O1 p8 Z2 }. F4 e; r/ {, ~4 K
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    
40. #endif
    2 |2 Z1 [, K" w2 {
41.         
    . _+ L% }' a# z$ b/ ~5 W% B
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    
46.         bsp_InitLed();            /* 初始化LED */        
    7 f9 K) E  }1 [# ^' I, k2 p  v
47. }

复制代码

  MPU配置和Cache配置：

6 Z3 d5 r3 z* |4 \' O" U. I  R数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
5 k% A* P/ m+ H
' }$ ]$ G/ T" D" O" L. L

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   ( p* @( J8 r* a- I. I& C9 @& C
5. *        形    参: 无
   2 H/ P& o9 N! m4 [2 Y
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   . P' h6 x) b- {
8. */
   & I/ z  t; N2 t1 ]& P
9. static void MPU_Config( void )
   6 k8 B( H- ]3 ]* C1 J
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    & S+ B' ]  t* B5 W5 }) S9 f
12. 
    ! r9 y9 v& a" h. x7 O0 K
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    
15. 
    - t0 S" B8 B4 z& J
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    5 L  E8 F  D& [: n: u
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    + R& C9 O2 v2 u$ X+ \+ k
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    ; O4 }1 }' x7 F0 q, i) {5 i
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ) e& o6 B9 K$ m  Q* q5 X- E
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    ' ]: {  M, b4 D
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    , i8 A, e: T: E# K/ V1 v- h
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    ) ?! G* ^* W2 S7 u, S! d7 [
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    $ [. J# x/ y0 `0 ~
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    4 S0 r3 f' `! z4 o1 l4 c! |( l
30.         
    
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    ) X% n9 z! a2 B4 O0 L
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    / E9 \9 ^% L: k: u$ J4 \! ?
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    * f+ P" l( ^; T& n7 ~
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    5 \; J, v1 \- w5 ~& W
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    ' c7 T4 n& @- b. Y& j5 @2 e
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    0 _& Q4 |- M8 `5 g! x
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    ) Y, @6 R% Q$ q9 q6 t( [; x- l' n' N
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    1 ^/ M# k' h6 a8 |% e. T
46. 
    & w- f+ V" V! l2 h) q8 B
47.         /*使能 MPU */
    $ o* e+ i. |1 P$ w
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    & T. Z; T4 K9 i, C
49. }
    * v1 W" T8 ^0 B2 j/ v2 ~
50. 
    
51. /*
    
52. *********************************************************************************************************
    
53. *        函 数 名: CPU_CACHE_Enable
      Z# ?4 P/ S8 z! K5 H2 X
54. *        功能说明: 使能L1 Cache
    ; I- u* v8 [- Q- n  f( T8 s# z+ z
55. *        形    参: 无
    
56. *        返 回 值: 无
    ' j5 X" W' M! ~. Q1 E9 ]
57. *********************************************************************************************************
    4 e1 C1 f0 |5 T4 d, u6 V  @
58. */
    3 i6 F- \# R: e* z# w
59. static void CPU_CACHE_Enable(void)
    , b  ~1 T9 k/ w" l- R8 m' x
60. {
    
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
      S1 j9 o8 p7 ^6 `, W
63. 
    , }9 t: ^! D+ e- v7 ^
64.         /* 使能 D-Cache */
    3 g$ h1 y3 E" F6 ~" G8 T4 s
65.         SCB_EnableDCache();
    ' `, Q5 H, t/ @! C, Y6 y% _
66. }

复制代码

- x% X; u: X1 U9 d$ l- ?' |  每10ms调用一次按键检测：

7 t3 H, U! ]& ^9 w按键检测是在滴答定时器中断里面实现，每10ms执行一次检测。
8 c# a+ U6 w" x2 |. }3 t5 X3 l! G

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_RunPer10ms
   6 ~+ Q, q6 X. q9 Z, x* ^3 |
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *        形    参: 无
   
7. *        返 回 值: 无
   7 x( q- Z6 A/ ?. V- Q; E& |
8. *********************************************************************************************************
   $ r! u6 p/ c0 t4 k+ H
9. */
   
10. void bsp_RunPer10ms(void)
    # y, m/ y. r- G1 p% a- @7 c
11. {
    # |% X! r' R  V/ h9 [1 {$ y2 p0 B
12.         bsp_KeyScan10ms();
    
13. }

复制代码

主功能：

% K8 P4 C" R2 V# M$ C; \% I) D5 w主功能的实现主要分为两部分：
4 M' X, X/ G. `
5 ]. c1 O1 v3 a6 b5 h+ A! c" @ 启动一个自动重装软件定时器，每100ms翻转一次LED2
2 K/ q+ }! O6 o4 i 按键消息的读取，检测到按下后，做串口打印。
& z+ a# q! ?+ L8 f+ z5 e! r: I

1. /*
   
2. *********************************************************************************************************
   9 j: n) p' `" P6 p- _: D
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   $ z' R( C: ]* L
7. *********************************************************************************************************
   
8. */
   
9. int main(void)
   
10. {
    $ q. |$ z) u/ `2 Y. m' O7 w, Q# \
11.         uint8_t ucKeyCode;                /* 按键代码 */
    3 S0 V5 R' R0 y: Z" B' i7 X
12.         
    
13.         bsp_Init();                /* 硬件初始化 */
    % _& P1 _+ o2 D+ v
14.         
    
15.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
16.         PrintfHelp();        /* 打印操作提示 */
    5 K/ L2 z$ D$ ^1 N+ d9 C' K; a# ?' y
17. 
    , `1 E" J) t2 H; ?% v( W/ r
18. 
    - c; o. n7 s* V5 h$ m8 v2 h  Y; R" P
19.         bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 */
    ! Q4 e7 N( u! \; e. M
20.         
    
21.         /* 进入主程序循环体 */
    : T- k6 F, J0 ]; @$ @$ J
22.         while (1)
    
23.         {
    
24.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    ; W# y; u+ d: o! r
25. 
    
26.                 /* 判断定时器超时时间 */
    ' U' a" h) c# r" ~( V$ d# K
27.                 if (bsp_CheckTimer(0))        
    
28.                 {
    6 S) U' o$ ~. L/ c3 U# }# O
29.                         /* 每隔100ms 进来一次 */  
    , f  n6 T! s, L0 E3 S; Q/ l; N
30.                         bsp_LedToggle(2);                        
    4 N, L' |% s3 Q% x- `9 b9 B
31.                 }
    2 V, J% N8 K; S' W8 G2 L; I- _
32.                
    
33.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
34.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    3 {3 q4 @% ?0 Z" Z
35.                 if (ucKeyCode != KEY_NONE)
    
36.                 {
    
37.                         switch (ucKeyCode)
    5 D+ z! d( ^# y  t7 O9 u7 p" M" ^
38.                         {
    9 g9 e! P' M' J' `; R' V
39.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    - n# f/ a# x3 ^5 |% ]
40.                                         printf("K1键按下\r\n");
    
41.                                         break;
    ! M6 `. \& S, a3 l* j- w) f& U
42. 
    4 A# b; r5 t! V! H5 U
43.                                 case KEY_UP_K1:                                /* K1键弹起 */
    
44.                                         printf("K1键弹起\r\n");
    % G4 a, |% [: o2 N! L
45.                                         break;
    
46. 
    % e0 Y' `/ @) ^  e1 D9 A
47.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    2 B! d/ {0 p  p* o& x
48.                                         printf("K2键按下\r\n");
    
49.                                         break;
    % t  @( q; @: I8 d" y# ^& j7 v
50. 
    
51.                                 case KEY_UP_K2:                                /* K2键弹起 */
    ' a5 }, S& m9 r* P9 o3 d+ w$ I# K
52.                                         printf("K2键弹起\r\n");
    - _6 J7 \0 \) d
53.                                         break;
    
54. 
    6 \7 Y% {- p9 R0 t
55.                                 case KEY_DOWN_K3:                        /* K3键按下 */
    
56.                                         printf("K3键按下\r\n");
    # _8 A4 T5 G* u& g/ y
57.                                         break;
    
58. 
    % G3 m: |( m0 S: C. t3 L5 Y7 v& f
59.                                 case KEY_UP_K3:                                /* K3键弹起 */
    
60.                                         printf("K3键弹起\r\n");
    ' U" T( F2 ~. q# d) \
61.                                         break;
    
62. 
    5 p) Y4 m# _4 C$ F& O6 n$ }
63.                                 case JOY_DOWN_U:                        /* 摇杆UP键按下 */
    * h% \2 R: x* |+ I
64.                                         printf("摇杆上键按下\r\n");
    1 p0 `  Y: N0 @0 c+ O4 y
65.                                         break;
    + A: P, f- h& r3 Z( r* `9 B* d
66. 
    
67.                                 case JOY_DOWN_D:                        /* 摇杆DOWN键按下 */
    
68.                                         printf("摇杆下键按下\r\n");
    ; L% ~1 s9 @& u, S
69.                                         break;
    ' x7 P+ Y! @* J- f6 l
70. 
    
71.                                 case JOY_DOWN_L:                        /* 摇杆LEFT键按下 */
    
72.                                         printf("摇杆左键按下\r\n");
    
73.                                         break;
    
74.                                 
    
75.                                 case JOY_LONG_L:            /* 摇杆LEFT键长按 */
    
76.                                         printf("摇杆左键长按\r\n");
    4 P( X; ]2 ]  W3 k
77.                                         break;
    7 K) }$ [' ^- A1 E& K4 a
78. 
    
79.                                 case JOY_DOWN_R:                        /* 摇杆RIGHT键按下 */
    
80.                                         printf("摇杆右键按下\r\n");
    
81.                                         break;
    
82.                                 
    
83.                                 case JOY_LONG_R:            /* 摇杆RIGHT键长按 */
    ; K5 h2 x3 a5 Y5 {" j+ ]
84.                                         printf("摇杆右键长按\r\n");
    
85.                                         break;
    
86. 
    ! K3 {& o0 ?6 c1 t! \
87.                                 case JOY_DOWN_OK:                        /* 摇杆OK键按下 */
    $ k* e& _* f% m$ w# _$ I# |
88.                                         printf("摇杆OK键按下\r\n");
    6 d1 T' R4 ~8 i8 Z) E  o
89.                                         break;
    
90. 
    
91.                                 case JOY_UP_OK:                        /* 摇杆OK键弹起 */
    
92.                                         printf("摇杆OK键弹起\r\n");
    
93.                                         break;
    
94. 
    
95.                 case SYS_DOWN_K1K2:                        /* 摇杆OK键弹起 */
    
96.                                         printf("K1和K2组合键按下\r\n");
    $ }3 i) r4 e( g3 _5 L
97.                                         break;
    " G5 {5 H: G  k2 ~8 N; D
98. 
    
99.                                 default:
    % t- T4 A2 X4 a( P; u( K) P
100.                                         /* 其它的键值不处理 */
     
101.                                         break;
     1 Z0 s7 ?9 F3 W) \1 C
102.                         }
     
103.                
     ; `" \* }$ A) z% I! B- l
104.                 }
     
105.         }
     + @: A+ ]- o5 h& `; O
106. }

复制代码

$ u) I4 O1 |( @" Y; j19.9 总结
这个方案在实际项目中已经经过千锤百炼，大家可以放心使用。建议熟练掌握其用法。

4 U( U6 K0 l* c( r

* p4 D* @& T1 c1 N% ?! \1 U0 e/ |