19.1 初学者重要提示
! @- O& g6 a/ M' |5 H; c 按键FIFO驱动扩展和移植更简单，组合键也更好用。支持按下、弹起、长按和组合键。

19.2 按键硬件设计
; p$ V* n7 s& h8 |6 G7 ^V7开发板有三个独立按键和一个五向摇杆，下面是三个独立按键的原理图：
2 R4 X( e. Z  G5 A+ e
2 f9 [9 z' i1 S- G- m3 Z8 e' F

" k* k7 b3 q) f. E, j6 u  \注意，K1（S1）、K2(S2)和K3(S3)按键的上拉电阻是接在5V电压上，因为这三个按键被复用为PS/2键盘鼠标接口，而PS/2是需要5V供电的（注，V5和V6开发板做了PS/2复用，而V7没有使用，这里只是为了兼容之前的板子）。实际测试，K1、K2、K3按键和PS/2键盘是可以同时工作的。

( j  @7 F4 @: W, L. [下面是五向摇杆的原理图：
- Z1 U4 j1 x" C9 T

7 R: G; o2 K- m) \
; q. U; a8 ?4 u/ X# c5 w6 |; }9 @3 D& R) {通过这个硬件设计，有如下两个知识点为大家做介绍：
8 j) n4 g( v5 U9 D( j; Y# R" T2 N- @
19.2.1 硬件设计
按键和CPU之间串联的电阻起保护作用。按键肯定是存在机械抖动的，开发板上面的硬件没有做硬件滤波处理，即使设计了硬件滤波电路，软件上还是需要进行滤波。
& d& P0 [; S" k3 |* u6 i
  保护GPIO，避免软件错误将IO设置为输出，如果设置为低电平还好，如果设置输出的是高电平，按键按下会直接跟GND(低电平)连接，从而损坏MCU。
  保护电阻也起到按键隔离作用，这些GPIO可以直接用于其它实验。
19.2.2 GPIO内部结构分析按键
, s  Z  O6 j% ?- A2 C% L详细的GPIO模式介绍，请参考第15章的15.3小节，本章仅介绍输入模式。下面我们通过一张图来简单介绍GPIO的结构。
" N4 U1 d3 i& L- t3 o! |, g
% L7 \; i" j8 J0 A, k3 l

* ]6 V/ `( f& Y7 H; \3 ^红色的线条是GPIO输入通道的信号流向，作为按键检测IO，这些需要配置为浮空输入。按键已经做了5V上拉，因此GPIO内部的上下拉电阻都选择关闭状态。
; F3 {+ J: h% B3 ^$ M# q/ C6 g
19.3 按键FIFO的驱动设计
7 @5 o9 P% c9 N- d' kbsp_key按键驱动程序用于扫描独立按键，具有软件滤波机制，采用FIFO机制保存键值。可以检测如下事件：
* H4 [) D' j7 U5 P" s* G# c
  按键按下。
8 ~5 B% S1 G. P: @' T  按键弹起。
8 t& r# n2 ^& O  长按键。
  长按时自动连发。
4 V' V1 O) `  l, T1 ^: J我们将按键驱动分为两个部分来介绍，一部分是FIFO的实现，一部分是按键检测的实现。

6 J' x) F, ?! a

bsp_key.c 文件包含按键检测和按键FIFO的实现代码。
9 W$ P! U9 o& \* G1 W5 G
- s0 [. }1 b; e; O+ H. Obsp.c 文件会调用bsp_InitKey()初始化函数。

bsp.c 文件会调用bsp_KeyScan按键扫描函数。
+ ^/ K* T/ ^; p4 w, H
bsp_timer.c 中的Systick中断服务程序调用 bsp_RunPer10ms。

9 w! k) ^3 h! Z- I  [5 ~( U6 B中断程序和主程序通过FIFO接口函数进行信息传递。
/ u4 F/ m6 P$ u6 D: [! l. F
函数调用关系图：
* o! y3 C% B, Z4 B/ \! g. [
$ u/ x6 l% _4 E4 _

: V- Z- [4 k& K( W  m9 r19.3.1 按键FIFO的原理
; z2 j& `3 P7 C! b0 y& vFIFO是First Input First Output的缩写，先入先出队列。我们这里以5个字节的FIFO空间进行说明。Write变量表示写位置，Read变量表示读位置。初始状态时，Read = Write = 0。

& _" Q/ C2 M2 d6 s4 z' f2 e
9 B) ^' t6 e% t5 g0 |我们依次按下按键K1，K2，那么FIFO中的数据变为：

, Q( E6 [, W$ h- s+ N7 y5 f; D
. m7 W+ ]* d0 y& p1 M9 e如果Write！= Read，则我们认为有新的按键事件。
! q+ W& b; k$ w+ X
我们通过函数bsp_GetKey读取一个按键值进行处理后，Read变量变为1。Write变量不变。
- Q- I$ u/ h/ ]. s) A' N

我们继续通过函数bsp_GetKey读取3个按键值进行处理后，Read变量变为4。此时Read = Write = 4。两个变量已经相等，表示已经没有新的按键事件需要处理。

有一点要特别的注意，如果FIFO空间写满了，Write会被重新赋值为0，也就是重新从第一个字节空间填数据进去，如果这个地址空间的数据还没有被及时读取出来，那么会被后来的数据覆盖掉，这点要引起大家的注意。我们的驱动程序开辟了10个字节的FIFO缓冲区，对于一般的应用足够了。
. V8 C& T' j/ n  o) w/ u8 A3 M
设计按键FIFO主要有三个方面的好处：
; u7 A1 \& |7 S- A% a
& z6 _* J# x; _/ J( |' G1 l! I. i  可靠地记录每一个按键事件，避免遗漏按键事件。特别是需要实现按键的按下、长按、自动连发、弹起等事件时。
2 Z+ t9 q7 ~) x: j* H  读取按键的函数可以设计为非阻塞的，不需要等待按键抖动滤波处理完毕。
  按键FIFO程序在嘀嗒定时器中定期的执行检测，不需要在主程序中一直做检测，这样可以有效地降低系统资源消耗。

19.3.2 按键FIFO的实现
在bsp_key.h 中定了结构体类型KEY_FIFO_T。这只是类型声明，并没有分配变量空间。

) D! X' \4 C. `! T' G

1. #define KEY_FIFO_SIZE        10
   / i; B) z- I5 d3 F0 r
2. typedef struct
   8 Q; c1 [7 u" g; i
3. {
   3 P% a: K7 ~( f. C
4.         uint8_t Buf[KEY_FIFO_SIZE];                /* 键值缓冲区 */
   
5.         uint8_t Read;                                        /* 缓冲区读指针1 */
   
6.         uint8_t Write;                             /* 缓冲区写指针 */
   
7.         uint8_t Read2;                             /* 缓冲区读指针2 */
   
8. }KEY_FIFO_T;

复制代码

8 p8 x: q8 S8 [9 t! x在bsp_key.c 中定义s_tKey结构变量, 此时编译器会分配一组变量空间。

; F' j. D$ P6 [' ^; |( s' f

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

复制代码

# V% N  K, u$ Q) C8 l一般情况下，只需要一个写指针Write和一个读指针Read。在某些情况下，可能有两个任务都需要访问按键缓冲区，为了避免键值被其中一个任务取空，我们添加了第2个读指针Read2。出厂程序在bsp_Idle()函数中实现的按K1K2组合键截屏的功能就使用的第2个读指针。

) l9 {9 U- b# L, T& L当检测到按键事件发生后，可以调用 bsp_PutKey函数将键值压入FIFO。下面的代码是函数的实现：
: t: U- x2 h* e8 k( h7 y: i% H6 @

1. /*
   
2. *********************************************************************************************************
   0 j: x" [4 X! `$ u
3. *        函 数 名: bsp_PutKey
   
4. *        功能说明: 将1个键值压入按键FIFO缓冲区。可用于模拟一个按键。
   
5. *        形    参: _KeyCode : 按键代码
   / K- S' z/ p  w+ H, V
6. *        返 回 值: 无
   % {% A2 w. G5 r* e% n
7. *********************************************************************************************************
   7 P- a* J6 P9 K
8. */
   
9. void bsp_PutKey(uint8_t _KeyCode)
   
10. {
    / Z. e- P. x1 a
11.         s_tKey.Buf[s_tKey.Write] = _KeyCode;
    
12. 
    
13.         if (++s_tKey.Write  >= KEY_FIFO_SIZE)
    
14.         {
    5 E* q( h% O' s1 o" T
15.                 s_tKey.Write = 0;
    
16.         }
    6 Q+ I5 k; B5 b! i2 S: J
17. }

复制代码

这个bsp_PutKey函数除了被按键检测函数调用外，还可以被其他底层驱动调用。比如红外遥控器的按键检测，也共用了同一个按键FIFO。遥控器的按键代码和主板实体按键的键值统一编码，保持键值唯一即可实现两套按键同时控制程序的功能。

; Z' R( Q9 F1 n应用程序读取FIFO中的键值，是通过bsp_GetKey函数和bsp_GetKey2函数实现的。我们来看下这两个函数的实现：
4 Z; _4 I' o2 Q# J4 z- z

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_GetKey
   * D2 n( }4 c- E$ U: ^8 n) l
4. *        功能说明: 从按键FIFO缓冲区读取一个键值。
   6 J; Y$ E9 j8 r9 t+ J6 Q! S
5. *        形    参:  无
   
6. *        返 回 值: 按键代码
   3 e" c+ J! m1 ^0 Z
7. *********************************************************************************************************
   
8. */
   
9. uint8_t bsp_GetKey(void)
   , Q5 |# S# H" }& G8 e. G
10. {
    0 D  z2 `% I; N3 K$ q; a7 i) e
11.         uint8_t ret;
    
12. 
    8 J) x- V3 t5 M# g8 J+ m
13.         if (s_tKey.Read == s_tKey.Write)
    
14.         {
    : y/ P+ K2 i1 t, ^0 w
15.                 return KEY_NONE;
      N9 Y5 m, I3 d/ G0 f7 K9 n
16.         }
    
17.         else
    : f2 s6 |+ }# k; A1 R
18.         {
    
19.                 ret = s_tKey.Buf[s_tKey.Read];
    ' T9 {6 [; g$ b# m/ x! x
20. 
    
21.                 if (++s_tKey.Read >= KEY_FIFO_SIZE)
    ' U& E& S2 b' S" ]: ^' G
22.                 {
    
23.                         s_tKey.Read = 0;
    
24.                 }
    % t- T. l' z" k, p3 k
25.                 return ret;
    & P8 j7 ]% `' Z, e7 _" `% m" t
26.         }
    
27. }
    ' A/ s8 E4 N9 H* ]
28. 
    0 U" u& P" f% \4 V# a1 ~5 `
29. /*
    
30. *********************************************************************************************************
    
31. *        函 数 名: bsp_GetKey2
    
32. *        功能说明: 从按键FIFO缓冲区读取一个键值。独立的读指针。
    
33. *        形    参:  无
    
34. *        返 回 值: 按键代码
    
35. *********************************************************************************************************
    
36. */
    1 r: _+ X3 \! T2 }) c! o, I  i1 u
37. uint8_t bsp_GetKey2(void)
    ' J, S% ]8 e4 F, f0 [% U5 Y9 q
38. {
    - `8 A# v' f& S( R
39.         uint8_t ret;
    1 y. D1 }% D- C9 R5 X1 e* y3 J
40. 
    
41.         if (s_tKey.Read2 == s_tKey.Write)
    
42.         {
    ) |4 L1 `) U' i5 g; {! c( M
43.                 return KEY_NONE;
    ) B+ N8 P- ~3 i; W6 t+ Q4 v
44.         }
    * W( d$ l. A" V
45.         else
    
46.         {
    5 @2 i4 M7 |$ i# q# G1 f7 [
47.                 ret = s_tKey.Buf[s_tKey.Read2];
    % v+ X% m" V  G4 w0 O
48. 
    
49.                 if (++s_tKey.Read2 >= KEY_FIFO_SIZE)
    
50.                 {
    
51.                         s_tKey.Read2 = 0;
    
52.                 }
    7 [* e/ F5 p! k/ T. e5 T- N
53.                 return ret;
    
54.         }
    7 U; i% G" e$ g, B6 R
55. }

复制代码

6 \) \, J# t2 W  C. P( ~4 H/ s返回值KEY_NONE = 0, 表示按键缓冲区为空，所有的按键时间已经处理完毕。按键的键值定义在 bsp_key.h文件，下面是具体内容：
8 d5 c3 x/ w. w0 V6 i

1. typedef enum
   4 p: N/ M! t. y+ w1 O, F
2. {
   + s6 ^# X3 ?. d: v! {( N
3.         KEY_NONE = 0,                        /* 0 表示按键事件 */
   ' }. d. D! \/ [: k2 `. w1 V
4. 
   & _! i" g7 b7 f6 k
5.         KEY_1_DOWN,                        /* 1键按下 */
   
6.         KEY_1_UP,                                /* 1键弹起 */
   
7.         KEY_1_LONG,                        /* 1键长按 */
   , x9 j+ C: I1 {* G" C
8. 
   . M8 H0 |8 w# j/ [! p4 p( `
9.         KEY_2_DOWN,                        /* 2键按下 */
   
10.         KEY_2_UP,                                /* 2键弹起 */
    
11.         KEY_2_LONG,                        /* 2键长按 */
    ! D/ m  [* y. ^( {3 d8 g: D8 b
12. 
    
13.         KEY_3_DOWN,                        /* 3键按下 */
    * Q1 [1 t# W1 I0 H& M0 r, G5 b( R
14.         KEY_3_UP,                                /* 3键弹起 */
    
15.         KEY_3_LONG,                        /* 3键长按 */
    
16. 
    
17.         KEY_4_DOWN,                        /* 4键按下 */
    
18.         KEY_4_UP,                                /* 4键弹起 */
    1 \0 v* A/ J9 V9 {& e$ \- Q0 f" U, o% K
19.         KEY_4_LONG,                        /* 4键长按 */
    
20. 
    
21.         KEY_5_DOWN,                        /* 5键按下 */
    
22.         KEY_5_UP,                                /* 5键弹起 */
    
23.         KEY_5_LONG,                        /* 5键长按 */
    
24. 
      F$ J: a) X1 s/ ~
25.         KEY_6_DOWN,                        /* 6键按下 */
    
26.         KEY_6_UP,                                /* 6键弹起 */
    . L6 j1 u; b' c
27.         KEY_6_LONG,                        /* 6键长按 */
    : m; w' K7 W+ `: w# [/ H1 f
28. 
    ! N2 z; E& Q/ D4 |+ v& o$ K* Z
29.         KEY_7_DOWN,                        /* 7键按下 */
    9 m( K( e3 j4 V7 D% ]
30.         KEY_7_UP,                                /* 7键弹起 */
    
31.         KEY_7_LONG,                        /* 7键长按 */
    
32. 
    $ L  N, l& w' `3 k  I# j: Q8 n% x
33.         KEY_8_DOWN,                        /* 8键按下 */
    
34.         KEY_8_UP,                                /* 8键弹起 */
    
35.         KEY_8_LONG,                        /* 8键长按 */
    * n/ _1 s& _: B' U9 t
36. 
    
37.         /* 组合键 */
    
38.         KEY_9_DOWN,                        /* 9键按下 */
    - V/ r7 Y  J+ C, }$ q) E! t
39.         KEY_9_UP,                                /* 9键弹起 */
    + [* X# ~+ {5 @0 |! a/ Q7 P
40.         KEY_9_LONG,                        /* 9键长按 */
    
41. 
    
42.         KEY_10_DOWN,                        /* 10键按下 */
    , f& O3 G2 [  K8 W" \+ I% E9 [
43.         KEY_10_UP,                        /* 10键弹起 */
    & {/ c; x" n+ K
44.         KEY_10_LONG,                        /* 10键长按 */
    
45. }KEY_ENUM;

复制代码

4 Y& C& q2 o; m7 ~+ M必须按次序定义每个键的按下、弹起和长按事件，即每个按键对象（组合键也算1个）占用3个数值。我们推荐使用枚举enum, 不用#define的原因：
1 J% c2 {7 C6 ^5 F2 P/ C0 h
  便于新增键值,方便调整顺序。
  使用{ } 将一组相关的定义封装起来便于理解。
  编译器可帮我们避免键值重复。
我们来看红外遥控器的键值定义，在bsp_ir_decode.h文件。因为遥控器按键和主板按键共用同一个FIFO，因此在这里我们先贴出这段定义代码，让大家有个初步印象。

) t5 C  J' Z, m, M% x0 t

1. /* 定义红外遥控器按键代码, 和bsp_key.h 的物理按键代码统一编码 */
   
2. typedef enum
   
3. {
   1 c5 |- e2 x& f, c* v
4.         IR_KEY_STRAT         = 0x80,
   . u4 _. z5 w4 l( Q$ S
5.         IR_KEY_POWER         = IR_KEY_STRAT + 0x45,
   ( `1 T1 {* q' G9 {7 S
6.         IR_KEY_MENU         = IR_KEY_STRAT + 0x47,
   
7.         IR_KEY_TEST         = IR_KEY_STRAT + 0x44,
   * c- I5 Q8 F/ F3 c! O! X
8.         IR_KEY_UP         = IR_KEY_STRAT + 0x40,
   
9.         IR_KEY_RETURN        = IR_KEY_STRAT + 0x43,
   2 D/ k# n3 _  r2 ?. W5 P/ w0 o
10.         IR_KEY_LEFT        = IR_KEY_STRAT + 0x07,
    3 p: C. J7 Y  O' e
11.         IR_KEY_OK                = IR_KEY_STRAT + 0x15,
    
12.         IR_KEY_RIGHT        = IR_KEY_STRAT + 0x09,
    : O$ X& A" G* ^$ _$ b' |7 z- S
13.         IR_KEY_0                = IR_KEY_STRAT + 0x16,
    . i& g  ]" P7 f1 y
14.         IR_KEY_DOWN        = IR_KEY_STRAT + 0x19,
    
15.         IR_KEY_C                = IR_KEY_STRAT + 0x0D,
    
16.         IR_KEY_1                = IR_KEY_STRAT + 0x0C,
    . R. y" \- o9 ~
17.         IR_KEY_2                = IR_KEY_STRAT + 0x18,
    : g0 x; z0 l% a2 j7 M" F; W
18.         IR_KEY_3                = IR_KEY_STRAT + 0x5E,
    
19.         IR_KEY_4                = IR_KEY_STRAT + 0x08,
    
20.         IR_KEY_5                = IR_KEY_STRAT + 0x1C,
    
21.         IR_KEY_6                = IR_KEY_STRAT + 0x5A,
    
22.         IR_KEY_7                = IR_KEY_STRAT + 0x42,
    ; Y1 O, x  ^2 s. w1 S: s% |
23.         IR_KEY_8                = IR_KEY_STRAT + 0x52,
    
24.         IR_KEY_9                = IR_KEY_STRAT + 0x4A,        
    1 d9 Z6 k* r3 \6 G& `6 m7 J3 B3 c, F
25. }IR_KEY_E;

复制代码

$ y( X3 P9 ~3 Z9 H! m, I我们下面来看一段简单的应用。这个应用的功能是：主板K1键控制LED1指示灯；遥控器的POWER键和MENU键控制LED2指示灯。
% `  o: u" v& s8 s
1 z: T7 a9 N9 T# E9 h3 A

1. #include "bsp.h"
   
2. 
   
3. int main(void)
   
4. {
   : }3 H6 s4 d$ y, W% K6 ]
5.         uint8_t ucKeyCode;
   1 p) y  ~- p$ ~* N, `. Z
6.                         
   . k/ W- j. ^' @& g& w
7.         bsp_Init();
   
8. 
   . N" l7 a( R6 l9 {6 W* x4 K7 G
9.         IRD_StartWork();        /* 启动红外解码 */
   
10. 
    - k  J$ [+ n! I* n! ?1 ~- Z
11.         while(1)
    ) {- ]( t! X. c. j+ f8 _
12.         {
    & W4 v' R2 h, I5 V  Q
13.                 bsp_Idle();
    
14.                
    - o% H6 ~( D- v# |+ ]8 S! |
15.                 /* 处理按键事件 */
    * y) w. T5 T1 A( K
16.                 ucKeyCode = bsp_GetKey();
    , o( B& ~9 _" p6 f! H0 b
17.                 if (ucKeyCode > 0)
    
18.                 {
    . Z/ V( `0 q' Z, a
19.                         /* 有键按下 */
    7 x+ }" t$ O7 I' t  i
20.                         switch (ucKeyCode)
    1 O$ Z6 d) H2 w& ^$ Z" b
21.                         {
    
22.                                 case KEY_DOWN_K1:                /* K1键按下 */
    
23.                                         bsp_LedOn(1);                /* 点亮LED1 */
    ; ^( t# P( E) I8 R) B) f3 ?3 n. K, `, q/ ?
24.                                         break;
    
25. 
    - M: ]! u$ q( V; g2 E
26.                                 case KEY_UP_K1:                /* K1键弹起 */
    
27.                                         bsp_LedOff(1);        /* 熄灭LED1 */
    / V; l$ Z8 w* q9 ?
28.                                         break;                                       
    
29. 
    + Y/ v! T8 a  S1 x8 K
30.                                 case IR_KEY_POWER:                /* 遥控器POWER键按下 */
    - j: G" C: m: A4 U
31.                                         bsp_LedOn(1);                /* 点亮LED2 */
    , W3 Z" o3 @; O
32.                                         break;
    
33. 
    : T& ?) {& e/ l  O
34.                                 case IR_KEY_MENU:                /* 遥控器MENU键按下 */
    
35.                                         bsp_LedOff(1);        /* 熄灭LED2 */
    4 f) b1 q' t4 L6 Q, b
36.                                         break;                                       
    
37. 
    
38.                                 case MSG_485_RX:                /* 通信程序的发来的消息 */
    
39.                                         /* 执行通信程序的指令 */
    
40.                                         break;
    ! [4 P0 _, H9 T8 Y; n( p
41. 
    # o+ N, f: @$ {1 a( P* g
42.                                 default:
    1 _# E9 P& [' p7 u5 d6 m$ ]
43.                                         break;
    , U2 x- j; a" a  w" ~3 N1 w
44.                         }
    , v, x: H% T6 K, v" Y1 `+ r
45.                 }
    
46.         }
    / |8 \- ^5 p! b; m
47. }

复制代码

看到这里，想必你已经意识到bsp_PutKey函数的强大之处了，可以将不相关的硬件输入设备统一为一个相同的接口函数。

: ^* ^/ k% v7 p7 [) y在上面的应用程序中，我们特意添加了一段红色的代码来解说更高级的用法。485通信程序收到有效的命令后通过 bsp_PutKey（MSG_485_RX）函数可以通知APP应用程序进行进一步加工处理（比如显示接收成功）。这是一种非常好的任务间信息传递方式，它不会破坏程序结构。不必新增全局变量来做这种事情，你只需要添加一个键值代码。
% q' e0 v3 A5 k
对于简单的程序，可以借用按键FIFO来进行少量的信息传递。对于复杂的应用，我们推荐使用bsp_msg专门来做这种任务间的通信。因为bsp_msg除了传递消息代码外，还可以传递参数结构。
3 \% n) \) b. Z+ @. ]1 R- p  Q
19.3.3 按键检测程序分析
在bsp_key.h 中定了结构体类型KEY_T。
+ f# j( e; \! c+ Q- Y: Y
6 i( n# O( n5 v" X+ l3 W& e. _' G

1. #define KEY_COUNT    10                           /* 按键个数, 8个独立建 + 2个组合键 */
   
2. 
   $ C* u( V* j1 J' _
3. typedef struct
   ( X( V; f% N1 @; c
4. {
   
5.         /* 下面是一个函数指针，指向判断按键手否按下的函数 */
   
6.         uint8_t (*IsKeyDownFunc)(void); /* 按键按下的判断函数,1表示按下 */
   
7. 
   
8.         uint8_t  Count;                /* 滤波器计数器 */
   : |8 j: O: L2 l3 u% Z
9.         uint16_t LongCount;        /* 长按计数器 */
   
10.         uint16_t LongTime;                /* 按键按下持续时间, 0表示不检测长按 */
    
11.         uint8_t  State;                /* 按键当前状态（按下还是弹起） */
    
12.         uint8_t  RepeatSpeed;        /* 连续按键周期 */
    8 h& `/ Y& o: C6 I) Y: j
13.         uint8_t  RepeatCount;        /* 连续按键计数器 */
    5 c. q$ M+ H$ u! F! S
14. }KEY_T;

复制代码

2 X  Q7 ^9 p1 B" q% r在bsp_key.c 中定义s_tBtn结构体数组变量。

+ G: n: E8 ^6 w- ]

1. static KEY_T s_tBtn[KEY_COUNT];
   ! S, o8 j+ A) C1 j- K
2. static KEY_FIFO_T s_tKey; /* 按键FIFO变量,结构体 */

复制代码

4 u1 ^7 r& x4 F: Z1 [每个按键对象都分配一个结构体变量，这些结构体变量以数组的形式存在将便于我们简化程序代码行数。

7 z1 G; _7 ^7 w5 z: c: V5 u2 Z: r6 f7 T使用函数指针IsKeyDownFunc可以将每个按键的检测以及组合键的检测代码进行统一管理。
! K) M4 i' t1 h2 k1 y7 q7 s' m3 Q9 Y$ ]
! G$ a; J6 J1 m& R# Q+ {/ i" j因为函数指针必须先赋值，才能被作为函数执行。因此在定时扫描按键之前，必须先执行一段初始化函数来设置每个按键的函数指针和参数。这个函数是 void bsp_InitKey(void)。它由bsp_Init()调用。

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_InitKey
   2 H! |# Z1 t5 q. T0 Z: r1 i% I8 H
4. *        功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
     a0 u2 [7 |7 P7 Y3 a/ Z; d
5. *        形    参: 无
   / k& i0 [' f. F& i9 |
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   : Q; Y8 |9 ^, `9 _
8. */
   
9. void bsp_InitKey(void)
   & H/ B1 V- \* F0 }, U% h
10. {
    
11.         bsp_InitKeyVar();                /* 初始化按键变量 */
    
12.         bsp_InitKeyHard();                /* 初始化按键硬件 */
    
13. }

复制代码

5 ]- Y+ a. T; {9 B# L  e下面是bsp_InitKeyVar函数的定义：
4 d4 |. E: g) U
; B$ |9 O4 M( h; ~  q6 C

1. /*
   - p- K: ]4 J  d0 w
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_InitKeyVar
   5 |4 L- Z0 e% G4 x4 Q; J
4. *        功能说明: 初始化按键变量
   7 Z% z- U, {: |* v! n
5. *        形    参:  无
   * V" B  y( `1 {- t# ]
6. *        返 回 值: 无
   ' |7 L9 v7 w: M1 a, }
7. *********************************************************************************************************
   7 }; p- _% T" J5 A7 E5 x+ @; |
8. */
   : W4 M, A, X7 W! \) m' E
9. static void bsp_InitKeyVar(void)
   
10. {
    7 T* H: u: o/ U
11.         uint8_t i;
    ( V' X+ l" `! T# ]4 }/ y
12. 
    
13.         /* 对按键FIFO读写指针清零 */
    
14.         s_tKey.Read = 0;
    0 H  ?2 R5 \$ i1 I6 F. G
15.         s_tKey.Write = 0;
    
16.         s_tKey.Read2 = 0;
    & L2 N- c! G- T# H2 m
17. 
    
18.         /* 给每个按键结构体成员变量赋一组缺省值 */
    
19.         for (i = 0; i < KEY_COUNT; i++)
    
20.         {
    * C' k: S, m2 }4 A! p# H
21.                 s_tBtn<i>.LongTime = KEY_LONG_TIME;                        /* 长按时间 0 表示不检测长按键事件 */</i>
    ; l5 _: e1 R% q4 t- d
22. <span style="font-style: italic;">                s_tBtn.Count = KEY_FILTER_TIME / 2;                /* 计数器设置为滤波时间的一半 */
    & z2 s: g- J* @/ K
23.                 s_tBtn<span style="font-style: italic;">.State = 0;                                                /* 按键缺省状态，0为未按下 */
    5 M9 L9 M, N$ C6 ~6 S2 j* y1 B
24.                 s_tBtn<span style="font-style: italic;">.RepeatSpeed = 0;                                        /* 按键连发的速度，0表示不支持连发 */
    " ?0 Q) K$ j; H9 j; N
25.                 s_tBtn<i style="font-style: italic;">.RepeatCount = 0;                                        /* 连发计数器 */
    9 {5 u2 O, W; R2 N% ~$ K7 f
26.      </i><span style="font-style: normal;">   }
    
27. 
    & k' ]! s8 r# N8 }! u
28.         /* 如果需要单独更改某个按键的参数，可以在此单独重新赋值 */
    
29.         
    ; u3 D( {( {6 C2 A! ~
30.         /* 摇杆上下左右，支持长按1秒后，自动连发 */
    0 `3 j# {* C5 I1 i
31.         bsp_SetKeyParam(KID_JOY_U, 100, 6);
    
32.         bsp_SetKeyParam(KID_JOY_D, 100, 6);
    4 i2 L( O5 n) f  y  X; G
33.         bsp_SetKeyParam(KID_JOY_L, 100, 6);
    # S: L7 P3 V/ y) T' H
34.         bsp_SetKeyParam(KID_JOY_R, 100, 6);
    & ]3 L* V" W' x3 f
35. }</span></span></span></span>

复制代码

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

1. /*
   + J  ~0 T. [7 l/ R
2.         按键滤波时间50ms, 单位10ms。
   $ W# y2 x9 @7 I: B% k8 c5 i
3.         只有连续检测到50ms状态不变才认为有效，包括弹起和按下两种事件
   
4.         即使按键电路不做硬件滤波，该滤波机制也可以保证可靠地检测到按键事件
   
5. */
   
6. #define KEY_FILTER_TIME   5
   . f; u" N" Z# e3 [! x
7. #define KEY_LONG_TIME     100                        /* 单位10ms， 持续1秒，认为长按事件 */

复制代码

5 T- B" u! g9 ^# B+ uuint8_t KeyPinActive(uint8_t _id)（会调用函数KeyPinActive判断状态）函数就是最底层的GPIO输入状态判断函数。
4 Z6 V5 I/ F4 n
3 D* Y0 Z/ r% \

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: KeyPinActive
   # l% X; r$ W4 }! Q+ [* g
4. *        功能说明: 判断按键是否按下
   
5. *        形    参: 无
   7 e* n8 p3 v$ [7 \: K! y
6. *        返 回 值: 返回值1 表示按下(导通），0表示未按下（释放）
   , [  X$ `2 c, p0 g( A/ J( ~0 E
7. *********************************************************************************************************
   ; d. `" ?/ N! |2 m+ j" A
8. */
   - E4 u& F  t' g8 E: E0 p
9. static uint8_t KeyPinActive(uint8_t _id)
   & j  y( \/ e/ J- E* [+ x, b7 ]
10. {
    . Z9 V  b( Z5 @+ h0 i
11.         uint8_t level;
    9 c* Q+ ~& Y+ Y4 w" b* a4 C' V
12.         
    / t1 E& c+ r0 A4 ]$ d- J- I
13.         if ((s_gpio_list[_id].gpio->IDR & s_gpio_list[_id].pin) == 0)
    7 Q* n) W! _" ~% [; K
14.         {
    # x; u) g" \. u5 H
15.                 level = 0;
    ( T9 ~/ l, E$ [$ c* J
16.         }
    . [) l" M9 D. s6 T  Y
17.         else
    
18.         {
    8 J% U$ o1 v0 K; a3 ~
19.                 level = 1;
    
20.         }
    % H3 b* `. X. K- O0 {( u
21. 
    
22.         if (level == s_gpio_list[_id].ActiveLevel)
    / z- [8 A' t# c' V0 L
23.         {
    
24.                 return 1;
    ; q( ~+ B6 G* _; z7 G5 P
25.         }
    " m& D3 g9 d- y
26.         else
    # H: L1 g8 Y: c$ W2 v# H! a" T
27.         {
    
28.                 return 0;
    
29.         }
    
30. }
    
31. 
    
32. /*
    
33. *********************************************************************************************************
    
34. *        函 数 名: IsKeyDownFunc
    
35. *        功能说明: 判断按键是否按下。单键和组合键区分。单键事件不允许有其他键按下。
    
36. *        形    参: 无
    4 o( t3 m5 S5 {- z# Y& A
37. *        返 回 值: 返回值1 表示按下(导通），0表示未按下（释放）
    
38. *********************************************************************************************************
    2 H9 c* f0 Y, k8 [8 Z  P  r/ I
39. */
    
40. static uint8_t IsKeyDownFunc(uint8_t _id)
    
41. {
    
42.         /* 实体单键 */
      m, y+ U' \1 e3 S. Z: B
43.         if (_id < HARD_KEY_NUM)
    
44.         {
    
45.                 uint8_t i;
    ' k. h3 z, V" G6 C
46.                 uint8_t count = 0;
    6 m4 s  J5 Q9 P- ?! |  V
47.                 uint8_t save = 255;
    
48.                
    , \  a; U; O, ^" [# D6 X
49.                 /* 判断有几个键按下 */
    ! |- `$ T+ e6 ~( e, S0 {
50.                 for (i = 0; i < HARD_KEY_NUM; i++)
    
51.                 {
    : W0 S* t' z" y% \
52.                         if (KeyPinActive(i))
    
53.                         {
    . T4 [' W0 c9 q' `* B' U3 X
54.                                 count++;
    
55.                                 save = i;
    
56.                         }
    
57.                 }
    
58.                
    
59.                 if (count == 1 && save == _id)
    
60.                 {
    6 V/ O, v4 y7 M; N
61.                         return 1;        /* 只有1个键按下时才有效 */
    
62.                 }               
    / M( Q5 o, w. N3 z; f2 _% g
63. 
    # ]& f; l' ]0 I/ T% y$ h  d  m
64.                 return 0;
    
65.         }
    % S' Q" F8 |! X- F- ]" \
66.         
    
67.         /* 组合键 K1K2 */
    
68.         if (_id == HARD_KEY_NUM + 0)
    : r& P3 t- {8 N! h* G8 `% |$ e+ P8 P
69.         {
    5 U6 q2 v, [- N8 m
70.                 if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
    7 b& a5 E0 q1 R0 V; n( H6 _
71.                 {
    6 y1 }/ @5 u! c8 Z, ~
72.                         return 1;
    - V. x) ^- y( r, X* a$ {
73.                 }
    
74.                 else
    ' V; p0 J1 V0 j! }& w# ?
75.                 {
    0 F( e# _$ h. Z$ k
76.                         return 0;
    
77.                 }
    % w+ K6 P4 {, c# a: ^" }) j8 {+ T
78.         }
    
79. 
    
80.         /* 组合键 K2K3 */
    - Y$ j6 _, B) c+ `3 Q2 r
81.         if (_id == HARD_KEY_NUM + 1)
    
82.         {
    
83.                 if (KeyPinActive(KID_K2) && KeyPinActive(KID_K3))
    
84.                 {
    5 M+ U! p" [( a. |* @2 e  W
85.                         return 1;
    + r8 @9 G& O9 T6 f7 `! c. S, p
86.                 }
    + L+ z0 B) U+ g4 l* i, f
87.                 else
    
88.                 {
    
89.                         return 0;
    
90.                 }
    ; K; @, ]& U! S% ~
91.         }
    
92. 
    
93.         return 0;
    
94. }

复制代码

3 \/ }5 ~" i( L# d6 K: p  g在使用GPIO之前，我们必须对GPIO进行配置，比如打开GPIO时钟，设置GPIO输入输出方向，设置上下拉电阻。下面是配置GPIO的代码，也就是bsp_InitKeyHard（）函数：
5 D" p5 _+ {  D" w3 T# R& R

1. /*
   
2. *********************************************************************************************************
   ; r6 X* ]. {: g) p
3. *        函 数 名: bsp_InitKeyHard
   
4. *        功能说明: 配置按键对应的GPIO
   
5. *        形    参:  无
   . r- j: x+ v! V: k$ q$ ?9 a
6. *        返 回 值: 无
   " C+ F. d0 }. I  |  X
7. *********************************************************************************************************
   3 P8 o# I' Q2 Z# J# M2 W$ G
8. */
   8 [8 ^1 C1 J' ]
9. static void bsp_InitKeyHard(void)
   " m0 b0 ?4 u1 t
10. {        
    % h; s. F$ k8 \8 x/ F- z* P; p3 h
11.         GPIO_InitTypeDef gpio_init;
      |0 g9 f1 t' H* L. y5 N, P
12.         uint8_t i;
    
13. 
    5 r7 s2 ^8 m" F
14.         /* 第1步：打开GPIO时钟 */
    
15.         ALL_KEY_GPIO_CLK_ENABLE();
    
16.         
    
17.         /* 第2步：配置所有的按键GPIO为浮动输入模式(实际上CPU复位后就是输入状态) */
    
18.         gpio_init.Mode = GPIO_MODE_INPUT;                           /* 设置输入 */
    9 ]1 Z# i/ v+ B% ^# T
19.         gpio_init.Pull = GPIO_NOPULL;                 /* 上下拉电阻不使能 */
    4 s( A7 w1 S2 L! j; G0 A: U) Y
20.         gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;  /* GPIO速度等级 */
    6 Q4 _; W* Q, @5 P% G
21.         
    0 R/ b( c4 H, V" e
22.         for (i = 0; i < HARD_KEY_NUM; i++)
    7 U. Q/ j! D" E8 M- T0 m4 t
23.         {
    * {& f1 C, Z5 m/ B) `4 n) I, d
24.                 gpio_init.Pin = s_gpio_list<span style="font-style: italic;"><span style="font-style: normal;">.pin;
    
25.                 HAL_GPIO_Init(s_gpio_list</span><span style="font-style: normal;">.gpio, &gpio_init);        
    7 G+ T/ j1 a. _6 X8 }5 m; o
26.         }
    8 |6 ~& X# a0 R) L
27. }</span></span>

复制代码

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

按键扫描函数bsp_KeyScan10ms ()每隔10ms被执行一次。bsp_RunPer10ms函数在systick中断服务程序中执行。
; X  P$ t2 H% K7 z" P5 v
" ~  D' b9 Q$ M6 a, [- t* }

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

复制代码

bsp_KeyScan10ms ()函数的实现如下：
6 P9 a2 n! Q8 \* G1 H5 [" a& i# z
, ]2 a) ?+ k' e$ d1 Y

1. /*
   ! r6 K3 ]  |8 I' O; z4 p' H* K
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_KeyScan10ms
   % ?# m& X4 L9 k# q7 F% {5 D- M/ Z% d
4. *        功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
   
5. *        形    参: 无
   + Q! k' \- r3 \) Y1 u' ?
6. *        返 回 值: 无
   2 X8 Q' M6 O+ F% Z/ r- h( ^
7. *********************************************************************************************************
   : Q1 N. P, I- V1 w9 A. C
8. */
   
9. void bsp_KeyScan10ms(void)
   0 D$ _. W! u7 P8 n5 i/ z$ ~
10. {
    # u; w, w) n# q. M* ]0 A: t$ J
11.         uint8_t i;
    & t# k& k2 ^: N& F
12. 
    
13.         for (i = 0; i < KEY_COUNT; i++)
    
14.         {
    $ T+ @3 b/ p& |
15.                 bsp_DetectKey(i);
    
16.         }
    
17. }

复制代码

每隔10ms所有的按键GPIO均会被扫描检测一次。bsp_DetectKey函数实现如下：
5 n' I* |. [7 g3 R$ T2 ?
) ?; x  o2 O% i3 f  U8 ^

1. /*
   
2. *********************************************************************************************************
   $ w& `6 u) V( {" m* L! d6 @
3. *        函 数 名: bsp_DetectKey
   4 z# `* S! [' X# e3 Z$ O3 f9 K
4. *        功能说明: 检测一个按键。非阻塞状态，必须被周期性的调用。
   
5. *        形    参: IO的id， 从0开始编码
   
6. *        返 回 值: 无
   % d. W3 }) k$ _8 m6 R( f# e
7. *********************************************************************************************************
   " X3 {1 d$ L9 y0 }* v$ m, D
8. */
   ! D+ A* t! v6 i0 M5 @6 p  U. c( p4 p: B7 @
9. static void bsp_DetectKey(uint8_t i)
   
10. {
    * ~+ V- g' I% d, p& |; j$ E
11.         KEY_T *pBtn;
    . Y8 @; _0 ]1 A! z! a4 n! @
12. 
    . I6 ~& c1 k, r& N; m& y2 Y
13.         pBtn = &s_tBtn<span style="font-style: italic;"><span style="font-style: normal;">;
    * P- _+ O" Y- V2 ]2 ?# K8 p
14.         if (IsKeyDownFunc(i))
    
15.         {
    . X+ u& ]. b" d. \/ r* A4 Z
16.                 if (pBtn->Count < KEY_FILTER_TIME)
    , f$ J/ K. H, }4 n6 a* S/ q
17.                 {
    
18.                         pBtn->Count = KEY_FILTER_TIME;
    
19.                 }
    - H/ Q  W  Y" c' S* P* W8 E. z& \- x
20.                 else if(pBtn->Count < 2 * KEY_FILTER_TIME)
    + b' `9 L: V( Y% l0 ]
21.                 {
    
22.                         pBtn->Count++;
    
23.                 }
    
24.                 else
    ' X% m! ^+ f0 E, L! X" c+ ~' p
25.                 {
    
26.                         if (pBtn->State == 0)
    
27.                         {
    ) [9 a9 q, x( G+ s+ E
28.                                 pBtn->State = 1;
    
29. 
    
30.                                 /* 发送按钮按下的消息 */
    
31.                                 bsp_PutKey((uint8_t)(3 * i + 1));
    
32.                         }
    
33. 
    
34.                         if (pBtn->LongTime > 0)
    
35.                         {
    ; E; E. j& X9 l* g2 x6 @# m
36.                                 if (pBtn->LongCount < pBtn->LongTime)
    ; F) u- v3 d4 F. A- O1 k  P' W
37.                                 {
    0 m1 ]! i3 {5 g; ?. ~$ O
38.                                         /* 发送按钮持续按下的消息 */
    - c0 c3 e, K* s
39.                                         if (++pBtn->LongCount == pBtn->LongTime)
    * ]$ a$ `: _% j' S- L) ^: q
40.                                         {
    
41.                                                 /* 键值放入按键FIFO */
      Z: f6 e* C' i$ D
42.                                                 bsp_PutKey((uint8_t)(3 * i + 3));
    
43.                                         }
    
44.                                 }
    . R2 e* `' W) j2 H. c( J0 T
45.                                 else
    
46.                                 {
    
47.                                         if (pBtn->RepeatSpeed > 0)
    2 k4 r* @$ W0 X
48.                                         {
    
49.                                                 if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
    - x+ d$ {( U/ w. x, B
50.                                                 {
    
51.                                                         pBtn->RepeatCount = 0;
    
52.                                                         /* 常按键后，每隔RepeatSpeed * 10ms发送1个按键 */
    
53.                                                         bsp_PutKey((uint8_t)(3 * i + 1));
    
54.                                                 }
    ( u4 c) r# a$ b) [2 N9 b: ^, J/ D
55.                                         }
    
56.                                 }
    8 P' x$ d% T* x, Q2 n- z
57.                         }
    $ u% T" D' n' X! @: J1 c0 \, _7 h1 q
58.                 }
    * Z, G0 C- L2 O  |7 K9 A
59.         }
    
60.         else
    
61.         {
    # i3 v7 X8 R' ?
62.                 if(pBtn->Count > KEY_FILTER_TIME)
    & j# @% h( V; I+ f
63.                 {
      j2 R: l; x4 L9 N; f
64.                         pBtn->Count = KEY_FILTER_TIME;
    
65.                 }
    ; B1 ~% E$ t! i5 V4 L7 V
66.                 else if(pBtn->Count != 0)
    
67.                 {
    
68.                         pBtn->Count--;
    
69.                 }
    
70.                 else
    3 [) P8 w' {- v! r7 |' c' X, {
71.                 {
    
72.                         if (pBtn->State == 1)
    
73.                         {
    
74.                                 pBtn->State = 0;
    2 a1 J  }; \5 _1 k8 J4 q. c
75. 
    2 |7 n. [8 q# S) b* Q, ]* c
76.                                 /* 发送按钮弹起的消息 */
    
77.                                 bsp_PutKey((uint8_t)(3 * i + 2));
    % U3 U# J' r2 G
78.                         }
    
79.                 }
    3 T- e) y3 ?- k3 K  Q
80. 
    
81.                 pBtn->LongCount = 0;
    
82.                 pBtn->RepeatCount = 0;
    6 j; h: J4 O( |- {. ~+ Y" C# @
83.         }
    
84. }</span></span>

复制代码

对于初学者，这个函数看起来比较吃力，我们拆分进行分析。
* {/ A) {" e: }' D( {

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

复制代码

) I; k0 i0 U6 d/ h4 \  I% U& N读取相应按键的结构体地址，程序里面每个按键都有自己的结构体。
# Q3 x5 h& c2 R$ \4 Q' x
2 I+ Q% N6 `( j5 S$ O; \, x0 g

1. static KEY_T s_tBtn[KEY_COUNT];
   
2. if (IsKeyDownFunc(i))
   % I+ e: g# ?9 D+ ?; n2 [
3. {
   
4.         这个里面执行的是按键按下的处理
   
5. }
   
6. else
   4 S6 i1 K0 D0 _$ N- n
7. {
   : ~5 z6 z6 D: r7 G+ z* n* S7 g, o
8.         这个里面执行的是按键松手的处理或者按键没有按下的处理
   
9. }

复制代码

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

1. /*
   1 ?$ L  O2 m) ]3 p9 J
2. **********************************************************************************
   
3. 下面这个if语句主要是用于按键滤波前给Count设置一个初值，前面说按键初始化的时候
   % K9 p! E: I* h" U% a; g/ Z  g9 D
4. 已经设置了Count = KEY_FILTER_TIME/2
   
5. **********************************************************************************
   6 i. H+ l  f" Q9 k7 \8 Z/ q
6. */
   
7. if (pBtn->Count < KEY_FILTER_TIME)
   2 y1 d' b2 [5 Z8 E( z0 I. E2 H% Q" v
8. {
   
9.     pBtn->Count = KEY_FILTER_TIME;
   - n0 C3 b( N7 P, F' O2 l# x
10. }
    
11. 
    
12. /*
    
13. **********************************************************************************
    
14. 这里实现KEY_FILTER_TIME时间长度的延迟
    2 M3 i$ r  C# q. ]& H1 ~: s
15. **********************************************************************************
    % a4 R! A, ~- [7 U. u
16. */
    
17. else if(pBtn->Count < 2 * KEY_FILTER_TIME)
    
18. {
    
19.     pBtn->Count++;
    
20. }
    
21. /*
    
22. **********************************************************************************
    
23. 这里实现KEY_FILTER_TIME时间长度的延迟
    
24. **********************************************************************************
    
25. */
    8 [6 y. x. L( w6 [$ Y) U" Q" ?
26. else
    % X* m$ n& Q) ]! l3 c$ h
27. {
    
28. /*
    
29. **********************************************************************************
    
30. 这个State变量是有其实际意义的，如果按键按下了，这里就将其设置为1，如果没有按下这个
    
31. 变量的值就会一直是0，这样设置的目的可以有效的防止一种情况的出现：比如按键K1在某个
    , ^4 F/ I0 O/ a" \- K4 G+ M
32. 时刻检测到了按键有按下，那么它就会做进一步的滤波处理，但是在滤波的过程中，这个按键
    0 B8 W6 b2 p- `/ z- j7 K1 x
33. 按下的状态消失了，这个时候就会进入到上面第二步else语句里面，然后再做按键松手检测滤波
    
34. ，滤波结束后判断这个State变量，如果前面就没有检测到按下，这里就不会记录按键弹起。
    4 @# @9 c- j; ~
35. **********************************************************************************
    
36. */
    / x5 \. @" j8 t
37.     if (pBtn->State == 0)
    8 e$ m6 T/ r0 C- H  @6 Q
38.     {
    
39.         pBtn->State = 1;
    ) C  @4 `& Q7 @4 o" U. K0 Q* X
40. 
    
41.         /* 发送按钮按下的消息 */
    
42.         bsp_PutKey((uint8_t)(3 * i + 1));
    - O/ @9 x' q8 |. G, }6 m6 r/ X
43.     }
    / F( ?6 l3 W0 q+ I% j
44. 
    
45.     if (pBtn->LongTime > 0)
    
46.     {
    
47.         if (pBtn->LongCount < pBtn->LongTime)
    : `3 M, @$ ~5 @, e- ^9 B  m4 A
48.         {
    
49.             /* 发送按钮持续按下的消息 */
    
50.             if (++pBtn->LongCount == pBtn->LongTime)
    
51.             {
    
52.                 /* 键值放入按键FIFO */
    
53.                 bsp_PutKey((uint8_t)(3 * i + 3));
    $ e& ?  E8 g) D
54.             }
    
55.         }
    
56.         else
    
57.         {
    
58.             if (pBtn->RepeatSpeed > 0)
    
59.             {
    
60.                 if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
    7 x# {. t' }$ j0 }$ Y  b* o
61.                 {
    1 H* l7 c# c$ H
62.                     pBtn->RepeatCount = 0;
    
63.                     /* 长按键后，每隔10ms发送1个按键 */
    ' l, J& _2 x0 b% Y- o4 @
64.                     bsp_PutKey((uint8_t)(3 * i + 1));
    
65.                 }
    
66.             }
    
67.         }
    4 J' g: M0 v  ~# ]4 h5 K& V3 v
68.     }
    ) L/ b: ~' p1 c4 |, c
69. }

复制代码

) P4 D1 \' [" b; ?" e6 E19.3.4 按键检测采用中断方式还是查询方式
检测按键有中断方式和GPIO查询方式两种。我们推荐大家用GPIO查询方式。
. v; P) J4 c/ f1 R
) {4 V7 ^( G* _' g6 O4 |* u从裸机的角度分析

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

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

- R2 a0 {9 S; n, \" ?; n9 t' T从OS的角度分析

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

查询方式：对于用户按键推荐使用这种查询方式来实现，现在的OS基本都带有CPU利用率的功能，这个按键FIFO占用的还是很小的，基本都在1%以下。
& ^( _/ z" P) v8 v4 ^% y
19.4 按键板级支持包（bsp_key.c）
按键驱动文件bsp_key.c主要实现了如下几个API：
* ~. b: A% G) j% H9 L% f
3 e+ }, `3 b$ @/ [7 w  N/ C2 g  KeyPinActive
( M! d* k9 Q0 T* `  IsKeyDownFunc
3 Z5 L3 q% `% l# I- k4 b" ]  bsp_InitKey
3 y  R1 t% q1 q  bsp_InitKeyHard
  bsp_InitKeyVar
- F" E3 ]; Y. E/ e  bsp_PutKey
  bsp_GetKey
* X! y) c2 X+ p$ g. [1 \6 l% ^9 ]  bsp_GetKey2
; N6 i5 o9 C& [. r" V  bsp_GetKeyState
  bsp_SetKeyParam
8 M) U7 ~' g3 X. `3 a& L" R  bsp_ClearKey
9 I5 B% ^& _' l% Y) w$ I2 K  bsp_DetectKey
  bsp_DetectFastIO
# ~; c( |9 L1 C' r4 h& k. F  bsp_KeyScan10ms
  bsp_KeyScan1ms

2 O, s$ e/ W; Y% m0 C! [所有这些函数在本章的19.3小节都进行了详细讲解，本小节主要是把需要用户调用的三个函数做个说明。

( p+ p; h3 _" N- p9 Z8 V* U( p" B19.4.1 函数bsp_InitKeyHard
; H, J3 \$ J7 g: k# y9 x函数原型：
+ s  \; P& i$ |/ S
: Q3 N2 C- j  S" a7 w  U( H- E

1. /*
   ) e6 H4 I# a3 U. [" p1 X
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_InitKey
   . E: B: T% U7 f) |$ m
4. *        功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   " C0 ~/ T" Z) ?  q- H
7. *********************************************************************************************************
   
8. */
   . G; {! m# l( x7 }' K% b; W" {. s
9. void bsp_InitKey(void)
   9 V% a2 D) I1 K- y5 o7 O
10. {
    
11.         bsp_InitKeyVar();                /* 初始化按键变量 */
    ' k* j. ^5 h) ^
12.         bsp_InitKeyHard();                /* 初始化按键硬件 */
    
13. }

复制代码

函数描述：

& j6 j- R: i- C! Q* M9 w) F此函数主要用于按键的初始化。

使用举例：

底层驱动初始化直接在bsp.c文件的函数bsp_Init里面调用即可。
6 W/ C1 o8 f! t$ a1 B  C% h: V. t
  F* |# u9 |$ a+ w& V& |19.4.2 函数bsp_GetKey
函数原型：
# B: P  t6 O- b# u( P0 j7 z4 D$ A

1. /*
   9 b- ]: {# O" N% s2 J- `
2. *********************************************************************************************************
   " `' o+ ]) q7 n5 z# F4 x
3. *        函 数 名: bsp_GetKey
   
4. *        功能说明: 从按键FIFO缓冲区读取一个键值。
   
5. *        形    参: 无
   
6. *        返 回 值: 按键代码
   " q1 V+ r$ O' h+ G5 v# d# J
7. *********************************************************************************************************
   
8. */
   
9. uint8_t bsp_GetKey(void)
   # z8 \9 R6 Q; ^- e" @% M0 Y  J& m
10. {
    
11.         uint8_t ret;
    ; i2 {  o* a. `! Y3 d: S! G) m
12. 
    
13.         if (s_tKey.Read == s_tKey.Write)
    7 Q- |9 ^, t) E0 \0 F: q
14.         {
    ! W$ @0 J: w- x" j6 q. b1 [
15.                 return KEY_NONE;
    ! W$ s; `  H; C9 Z9 s
16.         }
    5 @0 L* B" n! P. p7 m# {. ]- e# u
17.         else
    $ X4 |8 F. B+ v* z) }. z
18.         {
    
19.                 ret = s_tKey.Buf[s_tKey.Read];
    
20. 
    0 u5 A8 Z( Y# [( [. ~( f0 D+ Z  C
21.                 if (++s_tKey.Read >= KEY_FIFO_SIZE)
    
22.                 {
    
23.                         s_tKey.Read = 0;
    3 O( Y4 E- Z- f2 }8 o
24.                 }
    ; [) ]2 A( ^8 [! `
25.                 return ret;
    - u2 B- X4 b2 X1 d  E! ]
26.         }
    , ^9 r9 V! C0 U& _! L- E) Z
27. }

复制代码

函数描述：

* _4 T$ F1 l! D6 x. J此函数用于从FIFO中读取键值。

( a4 I  a( i  J+ L使用举例：

. f7 n" H5 Q4 I7 }; ~调用此函数前，务必优先调用函数bsp_InitKey进行初始化。
3 K2 i2 j- u% U6 R
1 a2 ?4 e3 m+ [* G" d0 o

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   6 l0 R& U5 O' A/ K* G+ h
5. *        形    参: 无
   / l# y* [7 N) E" J& Y5 D7 A* |
6. *        返 回 值: 错误代码(无需处理)
   2 W7 K4 W- L1 u* D
7. *********************************************************************************************************
   7 R- b1 S$ H) T. V
8. */
   
9. int main(void)
   
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    9 k) s/ [; j1 c- P) i
12.         
    - {5 u! e+ W# @7 {- S; E3 S
13.         bsp_Init();                /* 硬件初始化 */
    
14.         
    : i# `2 G, ?# m4 a, [
15.         /* 进入主程序循环体 */
    . g1 }- M: ^; c7 Y$ a
16.         while (1)
    
17.         {               
    
18.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
19.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
20.                 if (ucKeyCode != KEY_NONE)
    
21.                 {
    
22.                         switch (ucKeyCode)
    0 w( N2 d3 B) x& `
23.                         {
    
24.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    
25.                                         printf("K1键按下\r\n");
    . a. S8 n4 \  v/ y0 ^/ E
26.                                         break;
    
27. 
    
28.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    " _, l+ t, f. @% m4 Z
29.                                         printf("K2键按下\r\n");
    ' r! \" @; ?- F+ }
30.                                         break;
    
31. 
    
32.                                 default:
    
33.                                         /* 其它的键值不处理 */
    
34.                                         break;
    
35.                         }
    * I5 U; o% |2 X) K8 N
36.                 }
    
37.         }
    
38. }

复制代码

19.4.3 函数bsp_KeyScan10ms
' I1 N9 x9 V* @函数原型：

/ I  S  h- m) H

1. /*
   
2. *********************************************************************************************************
   $ S& o9 N2 x: x- j5 r' k4 g
3. *        函 数 名: bsp_KeyScan10ms
   8 e6 Z- Q4 Y, }" W
4. *        功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
   
5. *        形    参: 无
   + |# ?  P6 j, [  v+ n/ S' l
6. *        返 回 值: 无
   4 A" I' W2 P3 k+ a# j
7. *********************************************************************************************************
   
8. */
   ( Z0 F9 W& \. z
9. void bsp_KeyScan10ms(void)
   
10. {
    : y+ F8 P% M) j% b
11.         uint8_t i;
    
12. 
    
13.         for (i = 0; i < KEY_COUNT; i++)
    $ r% e/ O, O2 {8 }3 d
14.         {
    & V1 z8 m  I5 z; z
15.                 bsp_DetectKey(i);
    
16.         }
    
17. }

复制代码

函数描述：
5 U# s3 G' w1 Q# S9 _  B2 ]* i0 u/ |
此函数是按键的主处理函数，用于检测和存储按下、松手、长按等状态。
' s: e/ c* X  l7 m
使用举例：

调用此函数前，务必优先调用函数bsp_InitKey进行初始化。
2 d* i8 j+ L, h. O+ i
另外，此函数需要周期性调用，每10ms调用一次。

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

1 {% h* C, w0 [# E; Z19.5 按键FIFO驱动移植和使用
6 N0 H% A, y6 j" ?9 a& ~按键移植步骤如下：

  第1步：复制bsp_key.c和bsp_key.c到自己的工程。
  第2步：根据自己使用的独立按键个数和组合键个数，修改几个地方。

1. #define HARD_KEY_NUM        8                     /* 实体按键个数 */
   8 n  ^* }/ W& U2 y. p+ `, k$ W
2. #define KEY_COUNT   (HARD_KEY_NUM + 2)   /* 8个独立建 + 2个组合按键 */

复制代码

( L" G6 p2 h6 E$ ?: U  第3步：根据使用的引脚时钟，修改下面函数：

1. /* 使能GPIO时钟 */
   / g! `$ Q, `8 D) o* c7 i3 ^
2. #define ALL_KEY_GPIO_CLK_ENABLE() {        \
   
3.                 __HAL_RCC_GPIOB_CLK_ENABLE();        \
   
4.                 __HAL_RCC_GPIOC_CLK_ENABLE();        \
   
5.                 __HAL_RCC_GPIOG_CLK_ENABLE();        \
   8 C% x* j) T- v9 w' u
6.                 __HAL_RCC_GPIOH_CLK_ENABLE();        \
   2 h9 L+ X1 F6 W! T4 p/ u1 Q
7.                 __HAL_RCC_GPIOI_CLK_ENABLE();        \
   0 _5 z7 D* q& z5 ~( a# W) f
8.         };

复制代码

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

1. /* GPIO和PIN定义 */
   ( h8 k" B8 P4 `7 ^
2. static const X_GPIO_T s_gpio_list[HARD_KEY_NUM] = {
   / g/ Y+ {$ }9 p
3.         {GPIOI, GPIO_PIN_8, 0},                /* K1 */
   + ?2 ^7 c$ A; @- u6 A4 h
4.         {GPIOC, GPIO_PIN_13, 0},        /* K2 */
   * A1 n& x; h6 ~; h" y2 H% e9 j
5.         {GPIOH, GPIO_PIN_4, 0},                /* K3 */
   
6.         {GPIOG, GPIO_PIN_2, 0},                /* JOY_U */        
   * S. |  x/ L) t, _" Y
7.         {GPIOB, GPIO_PIN_0, 0},                /* JOY_D */
   # y1 y6 X% X6 j" _1 C5 s+ h. e: S+ F
8.         {GPIOG, GPIO_PIN_3, 0},                /* JOY_L */        
   ; U, a& S6 i$ y
9.         {GPIOG, GPIO_PIN_7, 0},                /* JOY_R */        
   : f" j7 z; L, R; Q1 O4 K
10.         {GPIOI, GPIO_PIN_11, 0},        /* JOY_OK */
    
11. };   

复制代码

     
. x0 `% ~- I  e0 E: M. h$ g' v. }6 q5 Z  第5步：根据使用的组合键个数，在函数IsKeyDownFunc里面添加相应个数的函数：

1.         /* 组合键 K1K2 */
   4 u* f7 V, i' ~
2.         if (_id == HARD_KEY_NUM + 0)
   9 O$ K0 J3 {6 f9 N0 f5 j/ l
3.         {
   
4.                 if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
   
5.                 {
   
6.                         return 1;
   7 E& S# B2 }4 K' o9 E8 J" y4 l
7.                 }
   
8.                 else
   ; W! F/ d, b( M6 R' ~
9.                 {
   
10.                         return 0;
    
11.                 }
    5 R" E. |% |; H' h* v% ?! l
12.         }

复制代码

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

另外就是，函数KeyPinActive的参数是表示检测哪两个按键，设置0的时候表示第4步里面的第1组按键，设置为1表示第2组按键，以此类推。
) n- g4 \1 r, D# {  d* U& o
  第6步：主要用到HAL库的GPIO驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
; E( I6 [4 S8 T3 g9 d; y  第7步：移植完整，应用方法看本章节配套例子即可。
特别注意，别忘了每10ms调用一次按键检测函数bsp_KeyScan10ms。

, O! u4 o  Q6 q( V8 \19.6 实验例程设计框架
通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：

) U# x4 S1 S/ t
! H* l' Y: R7 D. T  h. z4 R; M 1、 第1阶段，上电启动阶段：

这部分在第14章进行了详细说明。

' u$ K. W: ~9 H8 H 2、 第2阶段，进入main函数：

% {% g# T( i4 S9 z3 X  第1部分，硬件初始化，主要是MPU、Cache、HAL库、系统时钟、滴答定时器、按键等。
  第2部分，应用程序设计部分，实现了一个按键应用。
  第3部分，按键扫描程序每10ms在滴答定时中断执行一次。
1 G8 s8 L5 @: S; U. }
+ L& _7 ~3 Q) ?  y5 }; c19.7 实验例程说明（MDK）
6 _9 g/ E) I$ J( E9 O+ g6 v配套例子：
V7-002_按键检测（软件滤波，FIFO机制）
; L- ^1 ^4 v1 O+ P! I
实验目的：
学习按键的按下，弹起，长按和组合键的实现。

: n) I/ n8 n" t实验内容：
启动一个自动重装软件定时器，每100ms翻转一次LED2。
) K3 E3 r% G. F0 ], M, C
, v0 l% o5 w4 H) g8 {/ v! E实验操作：
+ e" c! C. C- Z* p3个独立按键和5向摇杆按下时均有串口消息打印。
( o) A, S! D% y$ R! S9 V5向摇杆的左键和右键长按时，会有连发的串口消息。
独立按键K1和K2按键按下，串口打印消息。
, G# G* r8 X- ?6 P7 b
& g4 Z. f6 Y) _" _, A+ m( R上电后串口打印的信息：
& p8 p$ l2 G: b( m, @4 J5 g3 w+ g  k
  s' ?1 K! s+ S波特率 115200，数据位 8，奇偶校验位无，停止位 1
, ]: E* U2 e, I

& O  I* w1 H8 r5 L! Q
程序设计：

  系统栈大小分配：
- {( n! I; g! \# j, p7 ]" S
4 v) X. m+ `" v

8 `" E) A, K" U2 Q# e$ L# Y! [
9 ^0 x* c/ I( g% K$ K: P0 }9 L  RAM空间用的DTCM：
0 o# @, y0 a' T- P  X, p

2 Z0 K- Z! r- o, a9 h! {) ^2 f
  硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：
( L/ n' g1 [0 e' o8 ]" ^

1. /*
   5 K9 N, Z+ f8 A, M+ l
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   4 B, _. a* ]+ w  J! u
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   9 E# ?0 o5 Y( \8 x/ L0 O
5. *        形    参：无
   5 C9 |/ S5 s% s8 _" L
6. *        返 回 值: 无
   ) u6 a: ]; x3 l6 `3 l/ g. v
7. *********************************************************************************************************
   
8. */
   
9. void bsp_Init(void)
   # W5 C9 G; v$ B1 U* _6 B
10. {
    
11.     /* 配置MPU */
    ) Z% {! M$ F6 L. a, l5 U% {0 @( w
12.         MPU_Config();
      C9 W3 H- A! H! }+ E, I
13.         
    4 v3 s( c. j4 L( i8 G# b8 g
14.         /* 使能L1 Cache */
    ( h! u, A7 G( J% I
15.         CPU_CACHE_Enable();
    
16. 
    + ^' s+ c8 P  j4 Z  c- ?
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    8 {' M9 b/ ?1 d5 ^- O! u
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    9 y4 P( y  `4 ^8 b1 F
21.          */
    ( `: J2 k7 e5 B! h8 r- |
22.         HAL_Init();
    + j0 p% h1 U$ [6 [- i
23. 
    * Z. p' ^; ?& _+ x! X
24.         /*
    
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    , {# L! i, D, ?2 @2 U
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    4 ^/ A) \! G# r3 x$ [
28.     */
    ! _, M: _+ a, g1 w
29.         SystemClock_Config();
    
30. 
    , f% z% e! k8 V3 [; G+ c
31.         /*
    # B4 l1 s# I% l* t
32.            Event Recorder：
    9 N6 b3 G' K1 A9 ]' f2 W
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    * o. X' e! c8 K4 s& \! ?
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    4 {: M6 |, f+ ?: A4 k
35.         */        
    
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    5 H# K$ v9 e: D2 F- T4 T. z; q" l- L9 G0 H
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    % h( O' \3 J7 }: {  H
40. #endif
    ! D8 L" g1 [# I: n& j1 u2 p
41.         
    4 X3 ^5 r! M& J; m: M" e
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
      x, x# \7 k  r5 E3 i# q
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    & F% Y1 \( m4 W9 F9 I3 x) t
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    3 M) d/ d, V6 z6 f, N
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

  MPU配置和Cache配置：
1 B. E: V# q! d+ A4 h
数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

1. /*
   + \' X) {; v& M9 [! i
2. *********************************************************************************************************
   + N4 \. S4 u$ o) D7 ~* T
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void MPU_Config( void )
   - H4 p% V" H0 w( G
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    : s% b* K2 N  E; G5 z% |& D
12. 
    
13.         /* 禁止 MPU */
    ( c+ w& N. G" r6 W, ^1 L
14.         HAL_MPU_Disable();
    / u1 H: {( y* T  u' S- I
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    7 h- E" l" J: ~2 `
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    ' q( J: o% q" t& ]# U, [% _
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    & O; s" }( }7 C$ A$ w8 U
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    + Z. T8 ?  l$ ^+ J+ |" g
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    * _* y( i3 Y  |( H
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    9 `1 z1 y9 d# C  w
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    * Y0 L# x4 |/ |- V* o4 K
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    7 J& j6 c: |, I' Q4 g
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    ( M) m) ?. z2 u( l( O
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    & M5 p5 N: K$ c
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    . @8 y3 Y3 I, ]7 l
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    * j, c  u% ~" a
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    ) y' O0 z+ K4 W* F$ k8 o7 l
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    
47.         /*使能 MPU */
    
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    6 X6 W4 c) b/ R7 _0 c. K
49. }
    ( c/ m1 j1 M7 p
50. 
    ' v7 w( Q: A1 e7 _& A) a
51. /*
    . P3 z. ~6 R) ]: d0 L' B3 Q7 @
52. *********************************************************************************************************
    
53. *        函 数 名: CPU_CACHE_Enable
    
54. *        功能说明: 使能L1 Cache
    5 z5 [* C1 ^( @) S2 ^% d/ ^7 J' x
55. *        形    参: 无
    3 V. h$ Z& C  T5 E+ i
56. *        返 回 值: 无
    
57. *********************************************************************************************************
    
58. */
    
59. static void CPU_CACHE_Enable(void)
    - q8 T5 {; @: ?" ?9 K
60. {
    
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    - j" y' u) z8 K+ A1 c
63. 
    
64.         /* 使能 D-Cache */
    ) h* j: F/ F% `3 t: f5 W9 }+ w- A
65.         SCB_EnableDCache();
    ) v1 Q& r9 F( k1 c8 Y
66. }

复制代码

7 X6 [# \4 n+ ]9 O$ R  每10ms调用一次按键检测：
# y! s( k* B3 K9 H# Z
. Z3 D: e: X  r. J3 @' U按键检测是在滴答定时器中断里面实现，每10ms执行一次检测。

% I) z. f% K6 c0 K

1. /*
   3 \# L7 N5 P. K, ?, A
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_RunPer10ms
   
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *        形    参: 无
   
7. *        返 回 值: 无
   
8. *********************************************************************************************************
   , ]% ?7 U' T" V+ q8 Q5 i: F3 R5 [
9. */
   
10. void bsp_RunPer10ms(void)
    
11. {
    ) T, ]1 P. J% [3 Y' Q1 P
12.         bsp_KeyScan10ms();
    2 p1 q. L# |4 Y* V4 I2 P
13. }

复制代码

  主功能：

主功能的实现主要分为两部分：
* P+ s# a+ M/ p) j9 L
+ k4 A& b* c7 t5 P 启动一个自动重装软件定时器，每100ms翻转一次LED2
按键消息的读取，检测到按下后，做串口打印。

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   9 @: m! {% i: S  d( ^/ n
5. *        形    参: 无
   + b0 D- g! S; h) |
6. *        返 回 值: 错误代码(无需处理)
   % r" z# w5 a* P4 u$ P' r) ]' Y
7. *********************************************************************************************************
   ' I, i% f/ a% F7 D
8. */
   
9. int main(void)
   
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    3 b0 S  u+ |3 U+ w
12.         
    
13.         bsp_Init();                /* 硬件初始化 */
    
14.         
    
15.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    ( z& L3 b9 G, X
16.         PrintfHelp();        /* 打印操作提示 */
    ( ^) {# g& e8 g2 s( _+ e
17. 
    9 K( R8 M: ~+ P* |& L5 q! _
18. 
    ) g: w3 }4 i& A: {0 _0 j" F" y7 Z" R
19.         bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 */
    
20.         
    
21.         /* 进入主程序循环体 */
    
22.         while (1)
    ' H( Q5 I( E+ V; {, f, m
23.         {
    
24.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
25. 
    
26.                 /* 判断定时器超时时间 */
    
27.                 if (bsp_CheckTimer(0))        
    
28.                 {
    * g3 A* Q4 f3 e
29.                         /* 每隔100ms 进来一次 */  
    8 W! Y3 L; U+ H$ v$ i
30.                         bsp_LedToggle(2);                        
    
31.                 }
    
32.                
    
33.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
34.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    9 `: \7 k: Y: g
35.                 if (ucKeyCode != KEY_NONE)
    % N5 @3 \8 W8 z3 a
36.                 {
    8 _7 Z* h2 t) c0 n- J! f
37.                         switch (ucKeyCode)
    
38.                         {
    + _$ _  Z" V' a% W
39.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    ! _! [2 t* J! E8 [
40.                                         printf("K1键按下\r\n");
    . v' w( D) L8 r1 i" t. n: v* P
41.                                         break;
    
42. 
    
43.                                 case KEY_UP_K1:                                /* K1键弹起 */
    
44.                                         printf("K1键弹起\r\n");
    
45.                                         break;
    9 }2 Z, W! y0 X. ^4 ^
46. 
    
47.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    
48.                                         printf("K2键按下\r\n");
    
49.                                         break;
    
50. 
    . C: ]/ |; J+ ~. l' O
51.                                 case KEY_UP_K2:                                /* K2键弹起 */
    $ o0 J* c. {; j& d% t0 M8 I
52.                                         printf("K2键弹起\r\n");
    
53.                                         break;
    
54. 
    7 p4 P! ^4 p9 d
55.                                 case KEY_DOWN_K3:                        /* K3键按下 */
    
56.                                         printf("K3键按下\r\n");
    
57.                                         break;
    
58. 
    
59.                                 case KEY_UP_K3:                                /* K3键弹起 */
    $ }& e4 ?* B4 K. p. g, l
60.                                         printf("K3键弹起\r\n");
    
61.                                         break;
    7 V+ r& q* h# F% O6 R+ k/ R
62. 
    . p+ D2 o" M. d3 D% F, }
63.                                 case JOY_DOWN_U:                        /* 摇杆UP键按下 */
    * K* x$ C9 t) E1 j  D
64.                                         printf("摇杆上键按下\r\n");
    
65.                                         break;
    
66. 
    # d' h. x2 W/ a4 M* K7 ^0 ?
67.                                 case JOY_DOWN_D:                        /* 摇杆DOWN键按下 */
    
68.                                         printf("摇杆下键按下\r\n");
    
69.                                         break;
    2 z2 B. i; r/ Y3 [) z0 `/ ^
70. 
    
71.                                 case JOY_DOWN_L:                        /* 摇杆LEFT键按下 */
    
72.                                         printf("摇杆左键按下\r\n");
    0 X# @* E2 s7 [  w
73.                                         break;
    + U; o+ y! I1 c4 K
74.                                 
    
75.                                 case JOY_LONG_L:            /* 摇杆LEFT键长按 */
    
76.                                         printf("摇杆左键长按\r\n");
    6 f0 j, ?( n% s/ G1 g: X
77.                                         break;
    
78. 
    3 l2 _. z3 `7 O( o3 U6 q( R
79.                                 case JOY_DOWN_R:                        /* 摇杆RIGHT键按下 */
    
80.                                         printf("摇杆右键按下\r\n");
    5 E8 k4 ?8 r  i* L" {
81.                                         break;
    
82.                                 
    5 T0 P7 x: d2 n. B
83.                                 case JOY_LONG_R:            /* 摇杆RIGHT键长按 */
    
84.                                         printf("摇杆右键长按\r\n");
    # E' I9 U  E/ t. k. n+ X6 T
85.                                         break;
    
86. 
    
87.                                 case JOY_DOWN_OK:                        /* 摇杆OK键按下 */
    6 a2 b1 j) q7 e6 ?3 G
88.                                         printf("摇杆OK键按下\r\n");
    % K6 @/ X3 F6 [8 t' p
89.                                         break;
    
90. 
    4 f2 F$ w! U( ~! H
91.                                 case JOY_UP_OK:                        /* 摇杆OK键弹起 */
    ( O' N5 j$ x1 N; E1 [) \0 C. Z
92.                                         printf("摇杆OK键弹起\r\n");
    ' Q7 D4 L- W7 i5 H( l+ o( j& ]" p6 u
93.                                         break;
    3 N- y8 c5 a) p6 e
94. 
    
95.                 case SYS_DOWN_K1K2:                        /* 摇杆OK键弹起 */
    
96.                                         printf("K1和K2组合键按下\r\n");
    
97.                                         break;
    9 N, ?8 O- Z5 l* T5 `
98. 
    % \, [; q8 z. B) g. M# N5 u2 Z
99.                                 default:
    
100.                                         /* 其它的键值不处理 */
     
101.                                         break;
     
102.                         }
     
103.                
     5 X# J. S. u5 z8 f
104.                 }
     
105.         }
     8 |4 M6 Y$ t6 i6 R  m
106. }

复制代码

9 @8 _2 D7 w  f8 C" @: [" T! f19.8 实验例程说明（IAR）
配套例子：
% C8 T" t5 @9 B+ {V7-002_按键检测（软件滤波，FIFO机制）
( Q7 |- R- I8 L+ K1 R5 l+ x( I! ?
实验目的：
学习按键的按下，弹起，长按和组合键的实现。

实验内容：
启动一个自动重装软件定时器，每100ms翻转一次LED2。
* B/ X" }1 ^3 |+ c  M% x
实验操作：
3个独立按键和5向摇杆按下时均有串口消息打印。
5向摇杆的左键和右键长按时，会有连发的串口消息。
独立按键K1和K2按键按下，串口打印消息。

1 M& S* f# J& \6 W0 l+ \上电后串口打印的信息：

0 g: |  f; D- |波特率 115200，数据位 8，奇偶校验位无，停止位 1

( |, Z3 T9 l8 }( O6 F2 g
程序设计：

. ?+ N# @- R( y. G2 t3 _( R5 i" U& J  系统栈大小分配：
  ^- y! R5 W6 S1 q  Z( o* d) c7 T

) Z+ u0 N' J9 s
  RAM空间用的DTCM：
2 i3 M  n4 l) e9 j% w, P, {

- j# E1 X- r2 n: C( ^4 I
  硬件外设初始化
8 j9 l0 ^$ |6 y& N6 q3 b
8 H) Q$ X7 |4 J5 x硬件外设的初始化是在 bsp.c 文件实现：

1. /*
   , v" O# b# ^& ~, d8 E8 Q# K
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   : y. d0 E% E: W4 S
5. *        形    参：无
   1 F) s; O+ z+ Y7 g# U9 p' X
6. *        返 回 值: 无
   , ?+ B; y, N* F. S) |
7. *********************************************************************************************************
   
8. */
   2 A9 B7 K% ^5 y1 T* _
9. void bsp_Init(void)
   ( E5 _) |9 B2 R) K
10. {
    6 {. g0 e! T: D' U/ r* @. K
11.     /* 配置MPU */
    
12.         MPU_Config();
    % F, j% l, X3 m
13.         
    
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    
16. 
    % D3 v, \2 T* |9 y
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    : E% Z8 B( B; |: G
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    ; e5 y/ B: d! x, n
20.            - 设置NVIV优先级分组为4。
    
21.          */
    $ @, O  I( b5 J0 S4 j
22.         HAL_Init();
    
23. 
    + t; d. k" i+ ?  s  [7 y- S1 z/ J
24.         /*
    
25.        配置系统时钟到400MHz
    ( l& [/ s3 M- j
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    5 i6 @: s" J, d. f
29.         SystemClock_Config();
    
30. 
    7 i5 P  T& v) H$ b
31.         /*
    
32.            Event Recorder：
    ! t% j' A& y8 k4 T/ t
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
      J3 ]! W  t6 ]' {
36. #if Enable_EventRecorder == 1  
    6 C/ Q0 o. f5 `7 F/ v( d' n% C& Q1 P
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    8 m. a2 t" f* x+ S3 e; Y
39.         EventRecorderStart();
    - q! _- `5 j6 f8 Y0 P0 m4 s
40. #endif
    7 y5 o. K, o  u2 p8 s% x/ S
41.         
    9 Q% A! s& z% O
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    ! n( [" m4 H1 x6 @) E0 w# e
46.         bsp_InitLed();            /* 初始化LED */        
    4 B# q% L$ l' O4 v2 H. }
47. }

复制代码

  MPU配置和Cache配置：
& W1 \& A( I( q
7 G) s" `2 I2 Z0 v5 n, G, m, Q数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

1. /*
   5 m" P! i7 h, J
2. *********************************************************************************************************
   9 p- d  X& c0 \2 {/ e0 M8 O
3. *        函 数 名: MPU_Config
   7 X8 ]& L2 ~0 U# ^
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   # n; u6 ]- H6 c3 D( x
8. */
   
9. static void MPU_Config( void )
   1 A; Z. i8 V# w* D
10. {
    : C5 G7 {0 m# ]- W- ~+ y
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    / l" U. I* x9 h/ w  i6 O2 m* I% E
13.         /* 禁止 MPU */
    # p7 h- f, L" t% f7 h& r+ v& S; D
14.         HAL_MPU_Disable();
    5 c  a. c$ ]7 i6 b6 m0 n+ s% B
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    5 T( Z/ q! N. X/ z2 r; l& U$ E4 w
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    + m2 w9 w& ?: I$ f4 U5 \
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
      X. O# _5 ^4 d* X6 Y
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    - I( a2 j2 l. X, I
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    6 U: w/ p$ j0 c( w: g# ^
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    0 ?( \9 L! H3 u# N
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    0 M% R/ D/ d# H
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    % o+ P1 b2 f+ }3 A0 T$ o$ S8 P' [
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    - ^5 M. `) P8 k
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    4 w9 y# Y4 d0 W/ B  I' m
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    6 L3 @- Q9 J% ?& I. r
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    % r7 [. C5 j' S2 b2 K' Z) b
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    3 e; ?$ c5 t8 d! m3 p' D6 E
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    5 S# `1 c4 |4 K7 k2 u6 X; s
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    6 G3 h# F) C6 l2 c# [
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    ! P) A, G1 @1 M3 W0 N
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    8 ~! L! D8 B' x
47.         /*使能 MPU */
    
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    ' t' ^" ]7 \( Z, P
49. }
    
50. 
    
51. /*
    
52. *********************************************************************************************************
    ; p& ~% K( {6 R
53. *        函 数 名: CPU_CACHE_Enable
    * K) g& G# `7 b  R$ M
54. *        功能说明: 使能L1 Cache
    : ~9 I; l/ g+ t- u! [* j; z
55. *        形    参: 无
    # v* R+ @" L, X3 u" S7 w
56. *        返 回 值: 无
    + ~4 ~3 R7 X" _
57. *********************************************************************************************************
    
58. */
      r: h, _; q2 c3 \
59. static void CPU_CACHE_Enable(void)
    
60. {
    
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    $ K" o$ ], Q. {! L5 o; \9 s/ S
63. 
    1 V% x( L  T9 X6 X% N' Y  ~
64.         /* 使能 D-Cache */
    % e& B" P' C  i* L' D
65.         SCB_EnableDCache();
    
66. }

复制代码

  每10ms调用一次按键检测：
" r7 a' _6 W8 A: l
% c6 e2 M5 C! C- W按键检测是在滴答定时器中断里面实现，每10ms执行一次检测。
* J+ i6 d) |( _5 Y  ]6 W5 ]' E
) h( ^8 d. l# w; |

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_RunPer10ms
   7 W* Y# W9 l2 ?
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   5 S, Z1 x! O6 T2 J1 a1 b9 H, w9 ]
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *        形    参: 无
   
7. *        返 回 值: 无
   
8. *********************************************************************************************************
   ) h$ E! R- x: g7 l2 F3 s& j
9. */
   + l) U) r/ ]( Z% @" Z3 F% Y7 U
10. void bsp_RunPer10ms(void)
    
11. {
    
12.         bsp_KeyScan10ms();
    
13. }

复制代码

主功能：

主功能的实现主要分为两部分：
: E! `& O: T  A$ S
启动一个自动重装软件定时器，每100ms翻转一次LED2
9 N: V# @& O1 @2 l 按键消息的读取，检测到按下后，做串口打印。

1. /*
   8 Z% x; w! I4 y$ D9 J+ P
2. *********************************************************************************************************
   2 a) n4 j% R3 \8 D0 s1 q
3. *        函 数 名: main
   / X* a7 e9 c8 ]7 C4 a( [
4. *        功能说明: c程序入口
   $ n0 T/ n. Y  k/ N. K
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   ' g5 c& z8 _: _- k
7. *********************************************************************************************************
   5 w0 V& w' U" h) X% v/ F
8. */
   $ f4 g8 @: o3 [
9. int main(void)
   
10. {
    % y7 Y( @4 r* D2 C$ f& v" |
11.         uint8_t ucKeyCode;                /* 按键代码 */
    
12.         
    
13.         bsp_Init();                /* 硬件初始化 */
    
14.         
    9 E% q$ @% D# m8 ^' V( m! ^0 m
15.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    6 W8 s. }) h$ J( [5 a8 |
16.         PrintfHelp();        /* 打印操作提示 */
    
17. 
    
18. 
    
19.         bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 */
    ! w% G0 V5 B8 C* [! m
20.         
    
21.         /* 进入主程序循环体 */
    / X% x# I( d6 c6 i( Y1 ~
22.         while (1)
    & q: g3 D9 [6 y3 p
23.         {
    - z- j: D7 `% I3 E9 T3 l# D5 r
24.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    8 U4 C0 E1 [  P5 x- u
25. 
    
26.                 /* 判断定时器超时时间 */
    % j6 A/ r9 g( v
27.                 if (bsp_CheckTimer(0))        
    3 p8 G& t: C' ?1 y. q
28.                 {
    
29.                         /* 每隔100ms 进来一次 */  
    - z; r/ @7 u& `% v3 J. _7 {
30.                         bsp_LedToggle(2);                        
    ( Q/ q/ l( W; ]: [* i( x2 ?  j  ]2 ^
31.                 }
    3 p) I8 |2 m3 q0 u, y9 k
32.                
    
33.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
34.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
35.                 if (ucKeyCode != KEY_NONE)
    7 Y, ]3 X! Y$ {: }. e- F6 k
36.                 {
    2 o* y8 s1 B4 J0 }+ r; x3 d
37.                         switch (ucKeyCode)
    
38.                         {
    
39.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    * o: p- @( x! x; J
40.                                         printf("K1键按下\r\n");
    
41.                                         break;
    
42. 
    
43.                                 case KEY_UP_K1:                                /* K1键弹起 */
    # j+ a: z% K9 m6 M2 |! r
44.                                         printf("K1键弹起\r\n");
    
45.                                         break;
    
46. 
    & o1 E! z; c% g. _2 b# j
47.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    
48.                                         printf("K2键按下\r\n");
    . v- |6 [5 }; J1 I# M+ ~) c
49.                                         break;
    
50. 
    3 u2 b+ j5 A, C
51.                                 case KEY_UP_K2:                                /* K2键弹起 */
    # ?  L% E  r# G0 r0 o1 g- u
52.                                         printf("K2键弹起\r\n");
    / x( \: |8 |  j. T7 b! T
53.                                         break;
    / c3 s, Q. g2 Y- ~: E9 a; E. W
54. 
    
55.                                 case KEY_DOWN_K3:                        /* K3键按下 */
    6 w+ @  M( q1 {
56.                                         printf("K3键按下\r\n");
    
57.                                         break;
    ! x4 [- Z& H! [* C) K+ r
58. 
    
59.                                 case KEY_UP_K3:                                /* K3键弹起 */
    6 L! B/ P$ L$ j/ w
60.                                         printf("K3键弹起\r\n");
    
61.                                         break;
    
62. 
    ' `! Z5 d; B6 |; [& H
63.                                 case JOY_DOWN_U:                        /* 摇杆UP键按下 */
    8 x  `# ~" }8 p/ [
64.                                         printf("摇杆上键按下\r\n");
    5 V- R3 K! s8 t  Y
65.                                         break;
    2 S" X, y+ d; q3 P; P* Y8 q1 d: ^- G
66. 
    * [4 y. m* X' m! d  V. Q& N' ?+ T
67.                                 case JOY_DOWN_D:                        /* 摇杆DOWN键按下 */
    
68.                                         printf("摇杆下键按下\r\n");
    
69.                                         break;
    ! e+ A' z9 d" P! \+ ^6 L1 q
70. 
    ! i: t, j1 w. \2 ]  r
71.                                 case JOY_DOWN_L:                        /* 摇杆LEFT键按下 */
    
72.                                         printf("摇杆左键按下\r\n");
    * X+ b9 z: g* e, E
73.                                         break;
    
74.                                 
    + Y' ]& `# q1 t' x6 Y4 h, c3 o5 W
75.                                 case JOY_LONG_L:            /* 摇杆LEFT键长按 */
    
76.                                         printf("摇杆左键长按\r\n");
    
77.                                         break;
    ) G5 W" B! [. V3 [, F; n; H
78. 
    : {  e0 G. V* V+ p+ A7 m
79.                                 case JOY_DOWN_R:                        /* 摇杆RIGHT键按下 */
    
80.                                         printf("摇杆右键按下\r\n");
    3 j" U7 @1 B8 Y
81.                                         break;
    
82.                                 
    
83.                                 case JOY_LONG_R:            /* 摇杆RIGHT键长按 */
    4 R. H1 K, ]7 U8 \7 R' Y5 {
84.                                         printf("摇杆右键长按\r\n");
    
85.                                         break;
    
86. 
    
87.                                 case JOY_DOWN_OK:                        /* 摇杆OK键按下 */
    
88.                                         printf("摇杆OK键按下\r\n");
    / Y) x) w- i7 j& E* _" p
89.                                         break;
    3 |$ O; I6 v$ v- r. c# t4 Y9 B
90. 
      x$ U3 r( E8 j* {
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");
    
97.                                         break;
    # C$ U  @) U* K: |2 A
98. 
    1 A2 F6 K9 Z! U- b- G5 k6 J( L1 ?3 |
99.                                 default:
    
100.                                         /* 其它的键值不处理 */
     , u" d: Q- t# M) G# u
101.                                         break;
     
102.                         }
     " u5 k4 b$ i* b- x7 _
103.                
     
104.                 }
     
105.         }
     9 N7 B: G& F+ A8 H: c
106. }

复制代码

19.9 总结
. N! X  @6 U% {9 u这个方案在实际项目中已经经过千锤百炼，大家可以放心使用。建议熟练掌握其用法。
3 Q) D& F* D$ E) b5 k* a6 [( G

# U" L; h( y! l" n) }