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

; N, o1 X' Y" {  J4 G19.2 按键硬件设计
/ s1 X/ }0 R8 X) jV7开发板有三个独立按键和一个五向摇杆，下面是三个独立按键的原理图：
/ T8 h0 [: M1 l0 S8 [! a. x

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

6 }! w: J6 l' h( b" U下面是五向摇杆的原理图：
' R5 j: ^% ^3 O+ m, }( t" v

5 `6 d; t! k4 i' h% X5 v
; ^$ M: `# o- i通过这个硬件设计，有如下两个知识点为大家做介绍：
; [" e1 b+ h! J3 n' P) A
' O. v" d- l. c19.2.1 硬件设计
& i0 P. ]7 @+ U1 C按键和CPU之间串联的电阻起保护作用。按键肯定是存在机械抖动的，开发板上面的硬件没有做硬件滤波处理，即使设计了硬件滤波电路，软件上还是需要进行滤波。

  保护GPIO，避免软件错误将IO设置为输出，如果设置为低电平还好，如果设置输出的是高电平，按键按下会直接跟GND(低电平)连接，从而损坏MCU。
  保护电阻也起到按键隔离作用，这些GPIO可以直接用于其它实验。
7 J  \$ O- e2 s# v1 P19.2.2 GPIO内部结构分析按键
% R: Y) d9 Q( R# X! g7 X详细的GPIO模式介绍，请参考第15章的15.3小节，本章仅介绍输入模式。下面我们通过一张图来简单介绍GPIO的结构。

: p, d) h; q6 u4 d9 l9 \
8 q( R/ a* S0 F( f8 o红色的线条是GPIO输入通道的信号流向，作为按键检测IO，这些需要配置为浮空输入。按键已经做了5V上拉，因此GPIO内部的上下拉电阻都选择关闭状态。
8 c* i& V( V" \9 Q9 R) ?# U/ Q
" {4 E. f9 r$ Y" C19.3 按键FIFO的驱动设计
) H5 x2 Q8 A4 F) }: xbsp_key按键驱动程序用于扫描独立按键，具有软件滤波机制，采用FIFO机制保存键值。可以检测如下事件：
, r9 F' z( n  ^, t! M" a- K
  按键按下。
1 p; Z7 G9 U8 ]+ ^& S6 a  按键弹起。
: A# `# I% s) ]2 v5 p, k) i  长按键。
5 i9 e/ L' \6 L- m  e  长按时自动连发。
3 s$ t9 z& t# y. N1 D6 `我们将按键驱动分为两个部分来介绍，一部分是FIFO的实现，一部分是按键检测的实现。
9 C" h$ m' m4 R9 ~1 W) p8 s0 Y

# c7 m5 F4 t# N, f3 m! a8 h( Z& `' B8 e
bsp_key.c 文件包含按键检测和按键FIFO的实现代码。

bsp.c 文件会调用bsp_InitKey()初始化函数。
9 V7 o1 `* R; [# N. B" @" s
bsp.c 文件会调用bsp_KeyScan按键扫描函数。

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

中断程序和主程序通过FIFO接口函数进行信息传递。
- y% d9 a1 v8 B/ p$ i, t
函数调用关系图：

  P$ {" B6 S) _( f  q/ g9 k0 e* r
19.3.1 按键FIFO的原理
) U9 `$ w! ^' `0 ^) LFIFO是First Input First Output的缩写，先入先出队列。我们这里以5个字节的FIFO空间进行说明。Write变量表示写位置，Read变量表示读位置。初始状态时，Read = Write = 0。
* y" j8 Z. j  {" w4 ]
0 J8 d- N- T3 p: N4 P  `

3 s8 I( v5 L8 m我们依次按下按键K1，K2，那么FIFO中的数据变为：

! U7 d& ]5 y/ W6 l7 u6 V; N

! h: h' u: @( Q: U, W4 d
# W& c! O- c+ j. t- M如果Write！= Read，则我们认为有新的按键事件。
7 b2 N" S" H3 [8 F* P+ A
我们通过函数bsp_GetKey读取一个按键值进行处理后，Read变量变为1。Write变量不变。

* z* v" f- ]$ s# I- L
- t/ \# }* Y, c& \* X( Q4 A我们继续通过函数bsp_GetKey读取3个按键值进行处理后，Read变量变为4。此时Read = Write = 4。两个变量已经相等，表示已经没有新的按键事件需要处理。

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

设计按键FIFO主要有三个方面的好处：

, x+ w3 V! w3 E. z5 ~, T  可靠地记录每一个按键事件，避免遗漏按键事件。特别是需要实现按键的按下、长按、自动连发、弹起等事件时。
  读取按键的函数可以设计为非阻塞的，不需要等待按键抖动滤波处理完毕。
! a# z  [* V/ Z- ]# v. L6 e& Z+ t3 G  按键FIFO程序在嘀嗒定时器中定期的执行检测，不需要在主程序中一直做检测，这样可以有效地降低系统资源消耗。

# f9 b! O- s: S: Y: r19.3.2 按键FIFO的实现
0 e% B6 J/ @$ x5 b/ _- y# E3 V在bsp_key.h 中定了结构体类型KEY_FIFO_T。这只是类型声明，并没有分配变量空间。
  M& P* R( [' v2 x5 O
* z# I; c; m- Z9 v

1. #define KEY_FIFO_SIZE        10
   / t4 y& h0 p& R! M. V) E; h2 Z
2. typedef struct
   ! ^# W6 i( y; u/ _/ _
3. {
   7 f( m, a/ F/ }2 I  h
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;

复制代码

在bsp_key.c 中定义s_tKey结构变量, 此时编译器会分配一组变量空间。
$ ^/ [: y: P2 @& v

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

复制代码

( C+ T+ x& }3 P7 T9 m9 K一般情况下，只需要一个写指针Write和一个读指针Read。在某些情况下，可能有两个任务都需要访问按键缓冲区，为了避免键值被其中一个任务取空，我们添加了第2个读指针Read2。出厂程序在bsp_Idle()函数中实现的按K1K2组合键截屏的功能就使用的第2个读指针。
" s% t' T' c+ D& U3 {- Q- c, S/ k
当检测到按键事件发生后，可以调用 bsp_PutKey函数将键值压入FIFO。下面的代码是函数的实现：
4 q! h6 f+ ~6 ?+ p; @1 Z

1. /*
   " x4 \0 J6 B+ ]6 F1 F" @( b
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_PutKey
   
4. *        功能说明: 将1个键值压入按键FIFO缓冲区。可用于模拟一个按键。
     [5 j4 n+ z2 ?( r( G
5. *        形    参: _KeyCode : 按键代码
   % w5 r1 o/ b4 V! U7 M) i
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   ) ^1 a9 J) Z" ~7 w
8. */
   $ r" m2 T& x# _, Y. W! U! e  K/ L
9. void bsp_PutKey(uint8_t _KeyCode)
   
10. {
    
11.         s_tKey.Buf[s_tKey.Write] = _KeyCode;
    + X1 s/ ?  T8 ~9 S6 S
12. 
    5 e( b- c: |8 B3 @
13.         if (++s_tKey.Write  >= KEY_FIFO_SIZE)
    $ v  j) J* k+ o0 z2 i6 a
14.         {
    1 ]" j, v9 c* i0 W1 B' m. g
15.                 s_tKey.Write = 0;
    
16.         }
    
17. }

复制代码

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

1 @; B5 Z4 g3 `" f% r! Q# d应用程序读取FIFO中的键值，是通过bsp_GetKey函数和bsp_GetKey2函数实现的。我们来看下这两个函数的实现：
1 ~1 d9 _4 x9 d' t! R5 j2 V8 h

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_GetKey
   * \' q1 S/ D! m. l2 p6 y
4. *        功能说明: 从按键FIFO缓冲区读取一个键值。
     a5 ]- }0 u; C+ f- ?$ n+ E" L
5. *        形    参:  无
   , s2 K% Z1 a5 B& g3 d, B) H$ F. R; Y) T- c
6. *        返 回 值: 按键代码
   & S) `2 h) [& _' @% L
7. *********************************************************************************************************
   . j. b* ]9 ~4 L3 a9 V1 d6 P
8. */
   2 N# a# _8 S/ q% F0 }4 J  h! d
9. uint8_t bsp_GetKey(void)
   5 ~! R. H6 ^, K0 H3 x8 @+ r2 V
10. {
    & Z) w: ~7 T) V  H5 u8 r& I* Q' \& A
11.         uint8_t ret;
    ( v$ v' M0 F, \' Q% U
12. 
    
13.         if (s_tKey.Read == s_tKey.Write)
    
14.         {
    . n9 m# J5 e3 y1 e/ K, P
15.                 return KEY_NONE;
    
16.         }
    " `+ c! n: p8 y. @; r: R" L# k
17.         else
    " l6 P/ H) J  n6 m  Z9 a# U* x
18.         {
    
19.                 ret = s_tKey.Buf[s_tKey.Read];
    
20. 
    
21.                 if (++s_tKey.Read >= KEY_FIFO_SIZE)
    ! ]( W- |7 [- B+ ?) ?8 o
22.                 {
    
23.                         s_tKey.Read = 0;
    : Q, W. c* P; y8 ?" n1 V- z2 A
24.                 }
    5 U9 }+ S: J0 U& {
25.                 return ret;
    6 I3 R! @+ D. V' B/ M. Y
26.         }
      S. v$ N1 L, |% O4 Q
27. }
    
28. 
    
29. /*
    
30. *********************************************************************************************************
    
31. *        函 数 名: bsp_GetKey2
    
32. *        功能说明: 从按键FIFO缓冲区读取一个键值。独立的读指针。
    
33. *        形    参:  无
    ) V: k- r7 n! l! V, F2 Z3 e) r) L: G
34. *        返 回 值: 按键代码
    
35. *********************************************************************************************************
    
36. */
    ( s7 O. T9 W9 \& U! u
37. uint8_t bsp_GetKey2(void)
    
38. {
    4 H7 G+ l0 y/ D& J$ Z/ Z) F6 N
39.         uint8_t ret;
    
40. 
    
41.         if (s_tKey.Read2 == s_tKey.Write)
    
42.         {
    + _# f# r# I; ^8 T
43.                 return KEY_NONE;
    
44.         }
    ; U% v( \7 c/ e: d' {
45.         else
    ( v/ v( A: ^  _
46.         {
    
47.                 ret = s_tKey.Buf[s_tKey.Read2];
    . C3 F5 z+ o+ q; M" `) [
48. 
    8 L8 C2 t3 e1 n" S7 T& Y6 U
49.                 if (++s_tKey.Read2 >= KEY_FIFO_SIZE)
    ( t7 D1 ?1 `0 s# s+ T
50.                 {
    
51.                         s_tKey.Read2 = 0;
      M" ]2 h; Q. r- |3 G
52.                 }
    
53.                 return ret;
    * o% j+ u1 E- \6 I7 B; s8 E/ ^+ K
54.         }
    ) r3 @; d% u2 d! j+ D( z7 v  u  S# q
55. }

复制代码

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

' J3 f) Q/ K  W# D  c5 \

1. typedef enum
   
2. {
   
3.         KEY_NONE = 0,                        /* 0 表示按键事件 */
   4 R$ h8 j; E2 o" L3 M3 I) P" D
4. 
   
5.         KEY_1_DOWN,                        /* 1键按下 */
   ) h# Y; F0 R6 |, I1 p
6.         KEY_1_UP,                                /* 1键弹起 */
   
7.         KEY_1_LONG,                        /* 1键长按 */
   
8. 
   
9.         KEY_2_DOWN,                        /* 2键按下 */
   
10.         KEY_2_UP,                                /* 2键弹起 */
    
11.         KEY_2_LONG,                        /* 2键长按 */
    
12. 
    
13.         KEY_3_DOWN,                        /* 3键按下 */
    
14.         KEY_3_UP,                                /* 3键弹起 */
    # C3 W+ M$ k4 b6 V/ c
15.         KEY_3_LONG,                        /* 3键长按 */
    
16. 
    , x  M4 t; W! j: [: A: \
17.         KEY_4_DOWN,                        /* 4键按下 */
    " k( S: \. u9 U6 x% K
18.         KEY_4_UP,                                /* 4键弹起 */
    7 F- i* u, \/ G) t  [* j& w8 }
19.         KEY_4_LONG,                        /* 4键长按 */
    4 h7 D9 r# V6 y  ^
20. 
    
21.         KEY_5_DOWN,                        /* 5键按下 */
    ! U- R  A$ ?6 Z: _1 m
22.         KEY_5_UP,                                /* 5键弹起 */
    
23.         KEY_5_LONG,                        /* 5键长按 */
    , s4 J- Z, G% q" _# g8 v( j5 t
24. 
    
25.         KEY_6_DOWN,                        /* 6键按下 */
    
26.         KEY_6_UP,                                /* 6键弹起 */
    
27.         KEY_6_LONG,                        /* 6键长按 */
    
28. 
    
29.         KEY_7_DOWN,                        /* 7键按下 */
    
30.         KEY_7_UP,                                /* 7键弹起 */
    3 P# q8 M# i0 o6 O9 w" b9 Q# g$ ~
31.         KEY_7_LONG,                        /* 7键长按 */
    
32. 
    
33.         KEY_8_DOWN,                        /* 8键按下 */
    
34.         KEY_8_UP,                                /* 8键弹起 */
    
35.         KEY_8_LONG,                        /* 8键长按 */
    * W  e5 a5 N& e0 w0 {
36. 
    ) A) x3 U+ N( @' M  ]% s
37.         /* 组合键 */
    & Y0 l" C+ `/ R, r
38.         KEY_9_DOWN,                        /* 9键按下 */
    
39.         KEY_9_UP,                                /* 9键弹起 */
    
40.         KEY_9_LONG,                        /* 9键长按 */
    
41. 
    
42.         KEY_10_DOWN,                        /* 10键按下 */
    
43.         KEY_10_UP,                        /* 10键弹起 */
    
44.         KEY_10_LONG,                        /* 10键长按 */
    * ~; V3 I! S" X/ Z
45. }KEY_ENUM;

复制代码

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

) x# ^6 ]9 p  e3 U3 d! K: U; z) m  便于新增键值,方便调整顺序。
- c0 h& j0 Z) s4 y7 \" Y8 O; P  使用{ } 将一组相关的定义封装起来便于理解。
  编译器可帮我们避免键值重复。
  R/ e0 [' W4 z" Z# _* H; I/ E我们来看红外遥控器的键值定义，在bsp_ir_decode.h文件。因为遥控器按键和主板按键共用同一个FIFO，因此在这里我们先贴出这段定义代码，让大家有个初步印象。

2 b  V, m9 G% n9 j6 V0 G; I

1. /* 定义红外遥控器按键代码, 和bsp_key.h 的物理按键代码统一编码 */
   
2. typedef enum
   5 n, Y* y% g9 z, Q
3. {
   7 m; G9 Y7 M/ F* u* x% |
4.         IR_KEY_STRAT         = 0x80,
   3 p; A$ n* x, t' U
5.         IR_KEY_POWER         = IR_KEY_STRAT + 0x45,
   , P, m! ^* [: m
6.         IR_KEY_MENU         = IR_KEY_STRAT + 0x47,
   + E% O, h- Y' q; ?. n- [
7.         IR_KEY_TEST         = IR_KEY_STRAT + 0x44,
   
8.         IR_KEY_UP         = IR_KEY_STRAT + 0x40,
   ( m  P* u, W  ^/ V8 e' @7 v  m% D
9.         IR_KEY_RETURN        = IR_KEY_STRAT + 0x43,
   : }- m6 B3 P% W9 r$ I
10.         IR_KEY_LEFT        = IR_KEY_STRAT + 0x07,
    
11.         IR_KEY_OK                = IR_KEY_STRAT + 0x15,
    , |0 F- B& q# n- o
12.         IR_KEY_RIGHT        = IR_KEY_STRAT + 0x09,
    8 r: H8 k4 {. `; K) o' }: N3 x
13.         IR_KEY_0                = IR_KEY_STRAT + 0x16,
    . }8 J. U0 b# m
14.         IR_KEY_DOWN        = IR_KEY_STRAT + 0x19,
    
15.         IR_KEY_C                = IR_KEY_STRAT + 0x0D,
    & @* ^* ^/ A: F0 G
16.         IR_KEY_1                = IR_KEY_STRAT + 0x0C,
    0 K! p* f' X- f5 _
17.         IR_KEY_2                = IR_KEY_STRAT + 0x18,
    
18.         IR_KEY_3                = IR_KEY_STRAT + 0x5E,
    $ B) [5 n/ ~) \3 [
19.         IR_KEY_4                = IR_KEY_STRAT + 0x08,
    8 j8 ?; N" l* s3 L8 F* r
20.         IR_KEY_5                = IR_KEY_STRAT + 0x1C,
    
21.         IR_KEY_6                = IR_KEY_STRAT + 0x5A,
    ! N! f7 @. @! R7 B% j
22.         IR_KEY_7                = IR_KEY_STRAT + 0x42,
    
23.         IR_KEY_8                = IR_KEY_STRAT + 0x52,
    
24.         IR_KEY_9                = IR_KEY_STRAT + 0x4A,        
    
25. }IR_KEY_E;

复制代码

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

1. #include "bsp.h"
   . t. Y' O1 O/ }  ]2 |; P2 u
2. 
   
3. int main(void)
   8 N' o5 I( \+ m; W, @1 a
4. {
   
5.         uint8_t ucKeyCode;
   
6.                         
   
7.         bsp_Init();
   7 ~1 w$ o7 e+ u
8. 
   4 X, \9 e! t* C& O8 m1 a
9.         IRD_StartWork();        /* 启动红外解码 */
   
10. 
    
11.         while(1)
    . l- _, x/ o) U7 @( N
12.         {
    0 Y9 h8 O# j- [$ U+ O/ g5 o
13.                 bsp_Idle();
    
14.                
    ! s9 W& m1 J" V7 I0 d+ ~' Y
15.                 /* 处理按键事件 */
    3 P9 M' H# |# c  ~
16.                 ucKeyCode = bsp_GetKey();
    ) N' }# i- i) L1 k0 M. ?
17.                 if (ucKeyCode > 0)
    4 @7 c1 E( V8 {" M
18.                 {
    ( c# R& V' T" c4 t
19.                         /* 有键按下 */
    0 T4 c; ?# P: ^: d, w
20.                         switch (ucKeyCode)
    
21.                         {
    
22.                                 case KEY_DOWN_K1:                /* K1键按下 */
    
23.                                         bsp_LedOn(1);                /* 点亮LED1 */
    2 J3 U5 d! X. ^  Q# H5 A, ]- s) q0 E$ v% h
24.                                         break;
    8 R) c8 j' C- P9 A5 C
25. 
    
26.                                 case KEY_UP_K1:                /* K1键弹起 */
    + M) S" M& _" j+ }6 Y3 G" p* q7 Q  y
27.                                         bsp_LedOff(1);        /* 熄灭LED1 */
    
28.                                         break;                                       
    
29. 
    0 e: L  I' o0 r/ L: y
30.                                 case IR_KEY_POWER:                /* 遥控器POWER键按下 */
    8 @/ G& ?! S- a' U3 ]6 d( o2 ~9 z
31.                                         bsp_LedOn(1);                /* 点亮LED2 */
    , a7 [8 n( A5 F) x
32.                                         break;
    
33. 
    9 h' q6 Z' w1 t
34.                                 case IR_KEY_MENU:                /* 遥控器MENU键按下 */
    
35.                                         bsp_LedOff(1);        /* 熄灭LED2 */
    
36.                                         break;                                       
    
37. 
    
38.                                 case MSG_485_RX:                /* 通信程序的发来的消息 */
    : o+ ^  H* ~! K) ~
39.                                         /* 执行通信程序的指令 */
    
40.                                         break;
    / ]/ V0 N% X2 x0 O% l
41. 
    
42.                                 default:
    
43.                                         break;
    
44.                         }
    & s$ E3 y; [4 e0 W, U7 {7 a' R
45.                 }
    
46.         }
      R4 A; w5 y$ b, K; Q, o
47. }

复制代码

/ s& ~6 S4 {4 T  b9 x& Y/ D0 Q看到这里，想必你已经意识到bsp_PutKey函数的强大之处了，可以将不相关的硬件输入设备统一为一个相同的接口函数。

. ]) V1 k+ Y2 K( @在上面的应用程序中，我们特意添加了一段红色的代码来解说更高级的用法。485通信程序收到有效的命令后通过 bsp_PutKey（MSG_485_RX）函数可以通知APP应用程序进行进一步加工处理（比如显示接收成功）。这是一种非常好的任务间信息传递方式，它不会破坏程序结构。不必新增全局变量来做这种事情，你只需要添加一个键值代码。
+ Z" O  \* i& d! u- z; T; F5 ~- [
对于简单的程序，可以借用按键FIFO来进行少量的信息传递。对于复杂的应用，我们推荐使用bsp_msg专门来做这种任务间的通信。因为bsp_msg除了传递消息代码外，还可以传递参数结构。

8 S: g% G8 v5 R9 T8 R2 s2 G0 @9 W19.3.3 按键检测程序分析
在bsp_key.h 中定了结构体类型KEY_T。
3 H. q& k2 h* O1 Y; ^' I7 N+ ^
  F7 _, `" x" [% S, |' o

1. #define KEY_COUNT    10                           /* 按键个数, 8个独立建 + 2个组合键 */
   
2. 
   7 j( C" }/ `- i
3. typedef struct
   
4. {
   / j3 l7 {0 t8 z" E- s! L
5.         /* 下面是一个函数指针，指向判断按键手否按下的函数 */
   
6.         uint8_t (*IsKeyDownFunc)(void); /* 按键按下的判断函数,1表示按下 */
   5 \  r" `6 v! W
7. 
   - W! d# w7 u, P4 {$ J
8.         uint8_t  Count;                /* 滤波器计数器 */
   " s2 a9 q# R1 y' L* S
9.         uint16_t LongCount;        /* 长按计数器 */
   ! R/ O: k2 f! z3 T+ D# @
10.         uint16_t LongTime;                /* 按键按下持续时间, 0表示不检测长按 */
    
11.         uint8_t  State;                /* 按键当前状态（按下还是弹起） */
    ! K7 d0 k$ f0 T* N/ s  r! X
12.         uint8_t  RepeatSpeed;        /* 连续按键周期 */
    . _$ T) {, r/ |# U! ^1 k
13.         uint8_t  RepeatCount;        /* 连续按键计数器 */
    - d4 \) I5 |' b. K; v/ h
14. }KEY_T;

复制代码

在bsp_key.c 中定义s_tBtn结构体数组变量。
! j  {/ p! d& A7 f' k# G
( i" ?/ `9 W2 b- v' Z

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

复制代码

每个按键对象都分配一个结构体变量，这些结构体变量以数组的形式存在将便于我们简化程序代码行数。
- |2 ?  s4 w, _" `/ Y& t
使用函数指针IsKeyDownFunc可以将每个按键的检测以及组合键的检测代码进行统一管理。
% d" O; y! q) G* j! {
/ X& f4 o1 a* O8 G) W+ h- M: z因为函数指针必须先赋值，才能被作为函数执行。因此在定时扫描按键之前，必须先执行一段初始化函数来设置每个按键的函数指针和参数。这个函数是 void bsp_InitKey(void)。它由bsp_Init()调用。

+ ^1 C. _1 @' Y7 ]1 s/ O

1. /*
   1 d+ |- ]! d* }
2. *********************************************************************************************************
   ) _6 H* k5 Z, [7 ?
3. *        函 数 名: bsp_InitKey
   
4. *        功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
   % F* D9 q+ S7 k0 I9 Y2 w
5. *        形    参: 无
   9 J; s4 v/ ]5 j6 A# R/ W" O0 ?- j
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
     X" g' p: i0 a: ^# H% b0 C
9. void bsp_InitKey(void)
   
10. {
    
11.         bsp_InitKeyVar();                /* 初始化按键变量 */
    
12.         bsp_InitKeyHard();                /* 初始化按键硬件 */
    
13. }

复制代码

下面是bsp_InitKeyVar函数的定义：
" n9 j" m6 `: }  n& b. |7 k
4 g: f+ U. D) y6 }# |3 h' M

1. /*
   
2. *********************************************************************************************************
   % M9 h! G+ |1 m9 }
3. *        函 数 名: bsp_InitKeyVar
   * J' v- Z+ [; B8 \0 S2 b! W
4. *        功能说明: 初始化按键变量
   
5. *        形    参:  无
   % [% m% _* t  l* W" [, v
6. *        返 回 值: 无
   $ [& e  z( T( X" y* y9 O
7. *********************************************************************************************************
   
8. */
   ; R, \0 }6 l* W+ j$ ^
9. static void bsp_InitKeyVar(void)
   
10. {
    
11.         uint8_t i;
    
12. 
    & o9 q' h1 T. \
13.         /* 对按键FIFO读写指针清零 */
    2 q( F: b: B$ d0 _0 o1 W% X( ^0 i
14.         s_tKey.Read = 0;
    
15.         s_tKey.Write = 0;
    8 U* ^0 |/ R# t8 n
16.         s_tKey.Read2 = 0;
    & }5 _9 I0 z  |* h6 h, p  {$ E- ]
17. 
    
18.         /* 给每个按键结构体成员变量赋一组缺省值 */
    / D* U% O, d$ @  Y" S% [
19.         for (i = 0; i < KEY_COUNT; i++)
    ( c9 W3 P8 s: x7 Z; x
20.         {
    
21.                 s_tBtn<i>.LongTime = KEY_LONG_TIME;                        /* 长按时间 0 表示不检测长按键事件 */</i>
    " r- B3 J/ V6 K& @6 f' n8 @$ j1 U
22. <span style="font-style: italic;">                s_tBtn.Count = KEY_FILTER_TIME / 2;                /* 计数器设置为滤波时间的一半 */
    5 T( Y. k6 p+ b- j" ?
23.                 s_tBtn<span style="font-style: italic;">.State = 0;                                                /* 按键缺省状态，0为未按下 */
    
24.                 s_tBtn<span style="font-style: italic;">.RepeatSpeed = 0;                                        /* 按键连发的速度，0表示不支持连发 */
    
25.                 s_tBtn<i style="font-style: italic;">.RepeatCount = 0;                                        /* 连发计数器 */
    / g, y# `" _' M! S/ W% w: s8 S8 ^
26.      </i><span style="font-style: normal;">   }
    2 y1 ?# p5 `3 z% q) Y1 s) k6 l- y9 a: U
27. 
    
28.         /* 如果需要单独更改某个按键的参数，可以在此单独重新赋值 */
    
29.         
    
30.         /* 摇杆上下左右，支持长按1秒后，自动连发 */
    
31.         bsp_SetKeyParam(KID_JOY_U, 100, 6);
    ' K1 `' O3 g! C% j4 Z
32.         bsp_SetKeyParam(KID_JOY_D, 100, 6);
    
33.         bsp_SetKeyParam(KID_JOY_L, 100, 6);
    
34.         bsp_SetKeyParam(KID_JOY_R, 100, 6);
    
35. }</span></span></span></span>

复制代码

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

8 E9 L0 G2 i& ]/ f$ C* }

1. /*
   
2.         按键滤波时间50ms, 单位10ms。
   
3.         只有连续检测到50ms状态不变才认为有效，包括弹起和按下两种事件
   
4.         即使按键电路不做硬件滤波，该滤波机制也可以保证可靠地检测到按键事件
   
5. */
   
6. #define KEY_FILTER_TIME   5
   
7. #define KEY_LONG_TIME     100                        /* 单位10ms， 持续1秒，认为长按事件 */

复制代码

2 r; |* t# l# t5 g0 kuint8_t KeyPinActive(uint8_t _id)（会调用函数KeyPinActive判断状态）函数就是最底层的GPIO输入状态判断函数。
/ y% Z8 O0 P3 l' y- H! M

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: KeyPinActive
   
4. *        功能说明: 判断按键是否按下
   # |0 i% p4 C+ |
5. *        形    参: 无
   
6. *        返 回 值: 返回值1 表示按下(导通），0表示未按下（释放）
   # o8 U0 d* e6 L6 |6 Z% `
7. *********************************************************************************************************
   
8. */
   / I- c! Y4 _& N# T& D! [3 j
9. static uint8_t KeyPinActive(uint8_t _id)
   5 {3 z, g: L+ m; K. _
10. {
    
11.         uint8_t level;
    
12.         
    ' \7 n) w  ~7 J
13.         if ((s_gpio_list[_id].gpio->IDR & s_gpio_list[_id].pin) == 0)
    + O! i$ B  S7 V7 F, r: e6 M4 w0 e6 ?% j
14.         {
    
15.                 level = 0;
    
16.         }
    # H6 I; s( \. [6 J
17.         else
    ! O( ]5 f! u5 W% I/ |
18.         {
    
19.                 level = 1;
    " k# s. B. D0 d6 A" h
20.         }
    ' n6 ?2 x- p; e$ D$ D3 W% x
21. 
    : \9 r4 b! N, R& N0 o
22.         if (level == s_gpio_list[_id].ActiveLevel)
      V7 Z; X3 q+ D" @6 M# W6 _4 t
23.         {
    + P* G1 [; Y- ?$ e& k; |
24.                 return 1;
    
25.         }
    
26.         else
    0 T4 F- j2 E# _# {0 m$ P3 n2 w, R1 N
27.         {
    
28.                 return 0;
    5 L1 `" W$ v" G2 I- t2 I
29.         }
    . k3 `7 O: t. z# C
30. }
    ( X/ B8 d6 P0 @
31. 
    
32. /*
    + G  g  Q" b9 v6 c! ^4 O
33. *********************************************************************************************************
    0 j; O- h6 o* |2 o; A  O
34. *        函 数 名: IsKeyDownFunc
    
35. *        功能说明: 判断按键是否按下。单键和组合键区分。单键事件不允许有其他键按下。
    & d% A, m0 f! _4 \
36. *        形    参: 无
    ! }: b' [& A8 T1 m7 l2 w
37. *        返 回 值: 返回值1 表示按下(导通），0表示未按下（释放）
    
38. *********************************************************************************************************
    ) J- h) {9 ]7 A3 ]1 b+ b; J4 Z
39. */
    9 q7 l+ I# r- J, [  r
40. static uint8_t IsKeyDownFunc(uint8_t _id)
    * L9 p' T, D; X& r& {
41. {
    8 \) u3 T) K4 b: ]" e
42.         /* 实体单键 */
    . M+ t# a( L( ]! Q: @
43.         if (_id < HARD_KEY_NUM)
    & J- d! t! i7 x" b- Q
44.         {
    ; n' t! E3 G0 g, s& L3 c& v% [' a
45.                 uint8_t i;
    ) c+ k8 d: h) b, q; W9 c, i2 }+ o
46.                 uint8_t count = 0;
    2 a. r% ~0 `; O  a4 U8 C. L" S
47.                 uint8_t save = 255;
    4 g! p* y- h) Z( N5 g3 Y( @1 G; v
48.                
    
49.                 /* 判断有几个键按下 */
    
50.                 for (i = 0; i < HARD_KEY_NUM; i++)
    
51.                 {
    6 I# b: S# |/ P. H" U9 N5 N% ]0 X
52.                         if (KeyPinActive(i))
    
53.                         {
    " C. _, f4 |" U
54.                                 count++;
    : X0 K& V. S. C. x9 s/ M7 f3 _
55.                                 save = i;
    , o, ~& ?1 u3 ^+ G
56.                         }
    
57.                 }
    
58.                
    
59.                 if (count == 1 && save == _id)
    2 T" P1 E& F5 V8 u, r5 z
60.                 {
    
61.                         return 1;        /* 只有1个键按下时才有效 */
    
62.                 }               
    # F- }' ?" j) x" o/ Q
63. 
    
64.                 return 0;
    
65.         }
    
66.         
    
67.         /* 组合键 K1K2 */
    
68.         if (_id == HARD_KEY_NUM + 0)
    
69.         {
    * @4 G, R6 [% B3 M5 K( H8 ^
70.                 if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
    
71.                 {
    
72.                         return 1;
    
73.                 }
    
74.                 else
    4 ?3 q# M0 ?; X( i, N# {1 I
75.                 {
    ! g! C1 x1 |0 ]) u) F% ]" X
76.                         return 0;
    
77.                 }
    ' S, z3 @! K6 f! \
78.         }
    
79. 
    
80.         /* 组合键 K2K3 */
    
81.         if (_id == HARD_KEY_NUM + 1)
    
82.         {
    
83.                 if (KeyPinActive(KID_K2) && KeyPinActive(KID_K3))
    
84.                 {
    
85.                         return 1;
    
86.                 }
    3 U5 U0 h2 A' k; }6 C6 E
87.                 else
    
88.                 {
    5 H4 m. e. m1 ^6 Z% b/ [. M3 A
89.                         return 0;
    
90.                 }
    
91.         }
    
92. 
    : U/ C9 U5 h# P- F% W' k, w
93.         return 0;
    3 J# e. R8 F; g6 L; }9 [
94. }

复制代码

+ o0 A8 m2 d: d3 H$ v) S在使用GPIO之前，我们必须对GPIO进行配置，比如打开GPIO时钟，设置GPIO输入输出方向，设置上下拉电阻。下面是配置GPIO的代码，也就是bsp_InitKeyHard（）函数：
7 u$ @# }7 Y2 N% g

1. /*
   " }; m( p, G3 c, F& N: J6 I
2. *********************************************************************************************************
   0 ^& g2 ^# y1 {3 b
3. *        函 数 名: bsp_InitKeyHard
   . y/ b# m/ A: N" B. h
4. *        功能说明: 配置按键对应的GPIO
   ) k" I; v+ H5 C2 ]( J5 J* k9 ]
5. *        形    参:  无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   $ D( x; w8 \8 u+ Y
8. */
   ; G, p& s7 @* @6 B! R" I1 n
9. static void bsp_InitKeyHard(void)
   
10. {        
    
11.         GPIO_InitTypeDef gpio_init;
    
12.         uint8_t i;
    
13. 
    
14.         /* 第1步：打开GPIO时钟 */
    : y" G9 K! q( L) k$ P2 C: l) h
15.         ALL_KEY_GPIO_CLK_ENABLE();
    ( o3 {. @+ ]$ J0 F
16.         
    ! ~- {2 |% C# X4 y3 d' v8 e' w
17.         /* 第2步：配置所有的按键GPIO为浮动输入模式(实际上CPU复位后就是输入状态) */
    5 v3 p# j# P% u7 ^  U' x
18.         gpio_init.Mode = GPIO_MODE_INPUT;                           /* 设置输入 */
    
19.         gpio_init.Pull = GPIO_NOPULL;                 /* 上下拉电阻不使能 */
    
20.         gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;  /* GPIO速度等级 */
    
21.         
    ' f  ^  X. J9 U' w' w# o
22.         for (i = 0; i < HARD_KEY_NUM; i++)
    / X* e0 r9 _; _$ K/ `0 R/ E
23.         {
    . r, h" A% A% |% i8 L- E
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);        
    * @# V# `' C1 A( ^2 N
26.         }
    ( k5 v6 X" d! J, W& T- u
27. }</span></span>

复制代码

我们再来看看按键是如何执行扫描检测的。
8 Q! ]* `" @: i+ N7 ]; Z' l" u) s9 h
7 V1 D! f6 j: U4 b$ o按键扫描函数bsp_KeyScan10ms ()每隔10ms被执行一次。bsp_RunPer10ms函数在systick中断服务程序中执行。

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

复制代码

bsp_KeyScan10ms ()函数的实现如下：

1. /*
   
2. *********************************************************************************************************
   & \5 ^! h( f7 `* S. A( E, P8 V: A  w
3. *        函 数 名: bsp_KeyScan10ms
   
4. *        功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
   ; c/ `5 M" Q" L$ ~1 j! X5 n. V
5. *        形    参: 无
   : X8 ?! ?, x" i7 ]9 Y) E" a; E$ P
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   & W+ {( k# S$ i: c9 Q
9. void bsp_KeyScan10ms(void)
   
10. {
    
11.         uint8_t i;
    
12. 
    ' ^+ X* w: B# H/ u/ n
13.         for (i = 0; i < KEY_COUNT; i++)
    
14.         {
    4 w. e2 B7 w( l' ~5 a' H2 c
15.                 bsp_DetectKey(i);
    " V$ s1 |1 ^, p2 G) e$ E- u
16.         }
    
17. }

复制代码

# A3 {( w' [$ J$ H/ U; X$ U每隔10ms所有的按键GPIO均会被扫描检测一次。bsp_DetectKey函数实现如下：

+ B" b  c  w* c( \& j& c/ @9 z

1. /*
   % H1 X+ |* @& v
2. *********************************************************************************************************
   : D# U! b1 d- f' ~) p' b
3. *        函 数 名: bsp_DetectKey
   
4. *        功能说明: 检测一个按键。非阻塞状态，必须被周期性的调用。
   
5. *        形    参: IO的id， 从0开始编码
   
6. *        返 回 值: 无
   7 {# ^' U& k2 L3 B9 \7 P5 r
7. *********************************************************************************************************
   
8. */
   6 s9 \- t3 |$ O7 z& T% Y7 \7 V2 v5 u
9. static void bsp_DetectKey(uint8_t i)
   
10. {
    
11.         KEY_T *pBtn;
    ) x& z1 A( S7 _. Z0 H
12. 
    
13.         pBtn = &s_tBtn<span style="font-style: italic;"><span style="font-style: normal;">;
    
14.         if (IsKeyDownFunc(i))
    . K" c& y, X3 b) v" ?# D8 e& V5 x
15.         {
    
16.                 if (pBtn->Count < KEY_FILTER_TIME)
    5 O. l% g1 j$ ]$ P6 b$ @0 a0 z( O
17.                 {
    + j2 N+ g- m1 B% G% \3 p3 q
18.                         pBtn->Count = KEY_FILTER_TIME;
    
19.                 }
    ) p3 L  ~% }- |& r& J
20.                 else if(pBtn->Count < 2 * KEY_FILTER_TIME)
    0 f/ c- Q3 ?9 R, ^) A5 H
21.                 {
    
22.                         pBtn->Count++;
    
23.                 }
    
24.                 else
    & L$ c+ ^! {7 e$ u
25.                 {
    
26.                         if (pBtn->State == 0)
    % f: q6 V) R+ a
27.                         {
    $ j" X, Y' \& P! t
28.                                 pBtn->State = 1;
    
29. 
    * v7 B9 ?2 t8 Q: n$ N
30.                                 /* 发送按钮按下的消息 */
    2 u/ S4 d* N# K4 V
31.                                 bsp_PutKey((uint8_t)(3 * i + 1));
    
32.                         }
    
33. 
    
34.                         if (pBtn->LongTime > 0)
    
35.                         {
    
36.                                 if (pBtn->LongCount < pBtn->LongTime)
    8 u0 f$ j# `% Z
37.                                 {
    
38.                                         /* 发送按钮持续按下的消息 */
    
39.                                         if (++pBtn->LongCount == pBtn->LongTime)
    
40.                                         {
      z: o1 d- ]& Q1 h0 Y
41.                                                 /* 键值放入按键FIFO */
    
42.                                                 bsp_PutKey((uint8_t)(3 * i + 3));
    
43.                                         }
    3 |7 A5 E) V/ b2 \
44.                                 }
    8 G) t" `0 g* w4 g6 W8 Q2 s
45.                                 else
    ; p' W4 y0 f3 T' g# p7 j
46.                                 {
    : R' U0 [; K9 O* I0 l5 U8 B
47.                                         if (pBtn->RepeatSpeed > 0)
    
48.                                         {
    " X) @9 }+ e5 e, r
49.                                                 if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
    
50.                                                 {
    
51.                                                         pBtn->RepeatCount = 0;
    
52.                                                         /* 常按键后，每隔RepeatSpeed * 10ms发送1个按键 */
    * L$ d/ i+ P8 ]' S7 ]  O4 B
53.                                                         bsp_PutKey((uint8_t)(3 * i + 1));
    . M9 u) o; z1 q" Z9 f4 p
54.                                                 }
    
55.                                         }
    
56.                                 }
    
57.                         }
    6 {+ y2 {3 y) O; v5 T! S
58.                 }
    
59.         }
    5 ~0 Q) ?6 l/ {; _
60.         else
    
61.         {
    % c3 k; s3 b1 n) Z1 A( U9 G+ T: C. u; F
62.                 if(pBtn->Count > KEY_FILTER_TIME)
    
63.                 {
    ! R' }0 E6 V/ `4 j$ f* m6 |
64.                         pBtn->Count = KEY_FILTER_TIME;
    
65.                 }
    
66.                 else if(pBtn->Count != 0)
    
67.                 {
    
68.                         pBtn->Count--;
    # p8 v/ y* W0 k2 ?6 G
69.                 }
    + R. W" X- q! D2 l
70.                 else
      `* ^% r% ^/ L  D6 d
71.                 {
    5 n7 ?4 G8 Q' c- I9 b/ B
72.                         if (pBtn->State == 1)
    ( N1 g' E! P# n! A1 t3 h! Y
73.                         {
      f" J# A- O% Z6 K# W% t
74.                                 pBtn->State = 0;
    ! Y2 V* u, p+ j
75. 
    
76.                                 /* 发送按钮弹起的消息 */
    
77.                                 bsp_PutKey((uint8_t)(3 * i + 2));
    
78.                         }
    . b( y1 {) p% m: v5 q
79.                 }
    
80. 
    0 |- E" Y+ j, ]
81.                 pBtn->LongCount = 0;
    ( r3 ~2 H8 n' o& \- ~7 f
82.                 pBtn->RepeatCount = 0;
    : ^9 {/ ^- d7 J
83.         }
    
84. }</span></span>

复制代码

: p/ Z: s, A% S' y* H& p1 ~对于初学者，这个函数看起来比较吃力，我们拆分进行分析。
8 R: B  i4 u# n% G. b4 p2 N- \

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

复制代码

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

% h  U% d  E! u7 B: `  D

1. static KEY_T s_tBtn[KEY_COUNT];
   ' c" ?' q! V5 ~2 O$ L7 M
2. if (IsKeyDownFunc(i))
   ; D( F; X: r7 a. ]2 P  z
3. {
   ; \& v4 K* c# ]) ^# y  I) u7 l
4.         这个里面执行的是按键按下的处理
   
5. }
   2 g5 |! E* U  _3 \# K: Z; x) Z- W
6. else
   $ N/ `; m: ~5 ~+ P! I3 Z
7. {
   
8.         这个里面执行的是按键松手的处理或者按键没有按下的处理
   % x$ A( a1 X1 ^" }8 [
9. }

复制代码

6 E5 Z5 r% W9 d% U执行函数IsKeyDownFunc(i)做按键状态判断。
; S; [( N' S" Q8 s/ M
2 p5 K9 q" Z. Y! }5 A; j" N

1. /*
   
2. **********************************************************************************
   
3. 下面这个if语句主要是用于按键滤波前给Count设置一个初值，前面说按键初始化的时候
   
4. 已经设置了Count = KEY_FILTER_TIME/2
   ) Q4 n+ u2 D5 S6 j8 A
5. **********************************************************************************
   
6. */
   
7. if (pBtn->Count < KEY_FILTER_TIME)
   
8. {
   5 }7 ^* b7 e7 C1 O5 m
9.     pBtn->Count = KEY_FILTER_TIME;
   ( j. ~) ^# W* q
10. }
    
11. 
    5 k& P+ o2 ~7 Y# X
12. /*
    
13. **********************************************************************************
    
14. 这里实现KEY_FILTER_TIME时间长度的延迟
    & \0 o8 o' i4 c6 b$ i
15. **********************************************************************************
    ( |2 ]6 b9 M* Z+ p! v1 O
16. */
    - C4 a  S6 U) r3 G8 W3 i/ r/ Z
17. else if(pBtn->Count < 2 * KEY_FILTER_TIME)
    
18. {
    
19.     pBtn->Count++;
    ' ^/ ^. L3 }4 [9 C* h+ `& F
20. }
    * c* D5 w5 `+ o. X
21. /*
    
22. **********************************************************************************
    8 d7 o; y! r. K2 L- C
23. 这里实现KEY_FILTER_TIME时间长度的延迟
    
24. **********************************************************************************
    ! K7 O+ L+ G; G, s
25. */
    
26. else
    6 C6 h" P& Q1 |9 V1 C3 ]/ f7 e
27. {
    - W5 Z, F) h* b( i5 o" ~2 z4 P6 k
28. /*
    
29. **********************************************************************************
    # K2 |' b% T) @& F4 J( Y
30. 这个State变量是有其实际意义的，如果按键按下了，这里就将其设置为1，如果没有按下这个
    
31. 变量的值就会一直是0，这样设置的目的可以有效的防止一种情况的出现：比如按键K1在某个
    
32. 时刻检测到了按键有按下，那么它就会做进一步的滤波处理，但是在滤波的过程中，这个按键
    
33. 按下的状态消失了，这个时候就会进入到上面第二步else语句里面，然后再做按键松手检测滤波
    3 f3 r0 Q7 ?; @" Q
34. ，滤波结束后判断这个State变量，如果前面就没有检测到按下，这里就不会记录按键弹起。
    ( {( l$ _! D# H4 b: B. N
35. **********************************************************************************
    3 Q) r8 R' W% l2 v9 |8 o0 H
36. */
    
37.     if (pBtn->State == 0)
    
38.     {
    
39.         pBtn->State = 1;
    
40. 
    
41.         /* 发送按钮按下的消息 */
    
42.         bsp_PutKey((uint8_t)(3 * i + 1));
    
43.     }
    
44. 
    ' ~& d1 M7 m0 O! f6 [/ G
45.     if (pBtn->LongTime > 0)
    # w* Q& h: B/ D2 s. O* [
46.     {
    9 G& g1 p) _+ {$ ~5 t/ X% }
47.         if (pBtn->LongCount < pBtn->LongTime)
    
48.         {
    
49.             /* 发送按钮持续按下的消息 */
    
50.             if (++pBtn->LongCount == pBtn->LongTime)
    & X+ r* e2 R& ?3 ]
51.             {
    , l, ^% d1 ~, L4 b
52.                 /* 键值放入按键FIFO */
    
53.                 bsp_PutKey((uint8_t)(3 * i + 3));
    
54.             }
    ; u7 m' `; s- b! y# H" V
55.         }
    0 w# p+ C% z; l$ w
56.         else
    - R& q& M( `* g
57.         {
    2 u' Q) b: R, V, B8 B
58.             if (pBtn->RepeatSpeed > 0)
    
59.             {
    % L$ P) p5 ?1 R- r& \  ?
60.                 if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
    # r7 E5 P, N3 L  D" x9 ]
61.                 {
    
62.                     pBtn->RepeatCount = 0;
    4 d2 \7 F, H& Y8 ~5 }
63.                     /* 长按键后，每隔10ms发送1个按键 */
    
64.                     bsp_PutKey((uint8_t)(3 * i + 1));
    
65.                 }
    
66.             }
    
67.         }
    
68.     }
    
69. }

复制代码

( s9 B- \; E) z- i; C, B- V19.3.4 按键检测采用中断方式还是查询方式
0 }& r9 A3 d8 i7 P, |$ b+ [检测按键有中断方式和GPIO查询方式两种。我们推荐大家用GPIO查询方式。
) _. U5 J  k) ]- J8 G9 P
从裸机的角度分析

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

' y) B8 j2 Y+ F0 x中断方式：在OS中要尽可能少用中断方式，因为在RTOS中过多的使用中断会影响系统的稳定性和可预见性（抢占式调度的OS基本没有可预见性）。只有比较重要的事件处理需要用中断的方式。
0 o# g. U; L$ V/ H9 ~
查询方式：对于用户按键推荐使用这种查询方式来实现，现在的OS基本都带有CPU利用率的功能，这个按键FIFO占用的还是很小的，基本都在1%以下。

+ C  g$ j# \- {: T19.4 按键板级支持包（bsp_key.c）
. O7 G7 @8 \" q. C& o7 |. l* t5 N按键驱动文件bsp_key.c主要实现了如下几个API：

8 i2 t) o0 f" I8 I  KeyPinActive
- D9 N; V, n, Z7 z0 D8 i# x, W  IsKeyDownFunc
  bsp_InitKey
$ V( A4 @/ f2 b6 j: t  bsp_InitKeyHard
  bsp_InitKeyVar
  bsp_PutKey
  bsp_GetKey
  bsp_GetKey2
+ x1 ]. ?( M" f  bsp_GetKeyState
  bsp_SetKeyParam
7 E$ L& @  `; c, s9 k  `  bsp_ClearKey
' B$ Y+ X- v' O& W  bsp_DetectKey
  bsp_DetectFastIO
  bsp_KeyScan10ms
  bsp_KeyScan1ms
8 I* E& ]: d7 A2 ^. n- u. q$ O
所有这些函数在本章的19.3小节都进行了详细讲解，本小节主要是把需要用户调用的三个函数做个说明。

8 l8 f: a" g: R  f1 [  A) I19.4.1 函数bsp_InitKeyHard
函数原型：
- {7 s8 {* i/ B' O6 m$ L, K
2 \: K* W, V3 h+ L+ L

1. /*
   4 M( J0 h, u0 `: c) g$ V% p
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_InitKey
   
4. *        功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   , [$ ?/ N+ ]4 t9 b- M5 d
9. void bsp_InitKey(void)
   1 V1 z' C% }! G/ F  X; w
10. {
    7 ?( n  f( h( M+ u. Z
11.         bsp_InitKeyVar();                /* 初始化按键变量 */
    
12.         bsp_InitKeyHard();                /* 初始化按键硬件 */
    
13. }

复制代码

9 E& v/ @0 Y* E( m. T0 W$ |函数描述：
, F  H5 N$ Q& n8 b0 r/ A' A1 M
此函数主要用于按键的初始化。

使用举例：
$ n: B# h; q0 _( c$ g+ }0 `
底层驱动初始化直接在bsp.c文件的函数bsp_Init里面调用即可。

19.4.2 函数bsp_GetKey
函数原型：

4 g% K; z" y0 J/ h

1. /*
   9 H: g" V3 `$ T0 b: |, p: q
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_GetKey
   
4. *        功能说明: 从按键FIFO缓冲区读取一个键值。
   % @# T: N4 A3 y, V3 s
5. *        形    参: 无
   & A& e7 Y6 ?$ _
6. *        返 回 值: 按键代码
   8 H) L/ u1 B4 A  U
7. *********************************************************************************************************
   / j9 y. h  H$ Z/ c* v# X7 W8 Y
8. */
   6 u5 m: b, B3 X  e; u" W, d* t9 R
9. uint8_t bsp_GetKey(void)
   4 b+ F8 M1 x/ _" F- }; j
10. {
    $ W+ [& |! Q4 Z" a- L
11.         uint8_t ret;
    # a" Y; p4 i* L( b
12. 
    
13.         if (s_tKey.Read == s_tKey.Write)
    
14.         {
    + G  f. c  f5 c/ t( \8 H! i. f1 O
15.                 return KEY_NONE;
    
16.         }
    . A1 r/ k9 W. R3 y/ j
17.         else
    4 K6 @7 G' R- |$ q/ _
18.         {
    : ~+ m/ u* d. e# s4 n
19.                 ret = s_tKey.Buf[s_tKey.Read];
    5 U( x4 y- g- b0 u
20. 
      U- r! O% v+ k" U8 N% [4 @3 U
21.                 if (++s_tKey.Read >= KEY_FIFO_SIZE)
    / H' K: F/ r* p# }  [- R; ]! G# J/ o( E
22.                 {
    # R2 p# o  h$ C
23.                         s_tKey.Read = 0;
    
24.                 }
    
25.                 return ret;
    ) s$ R+ K: K2 J1 x
26.         }
    / w8 m3 f/ S: I  [4 n0 y2 t
27. }

复制代码

函数描述：
; \. x, t4 Z, U" Q
此函数用于从FIFO中读取键值。
, q  n: S" g5 l& l
使用举例：
1 l6 U3 y$ J2 C; r  F  Y" |
  C* P! I0 T  P1 i" ~- z; @调用此函数前，务必优先调用函数bsp_InitKey进行初始化。

" b3 g; a0 S9 h: q5 Y: U

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   " E' U7 j& J- k
5. *        形    参: 无
   $ n  r' o4 ~. d; N" F& N8 A/ {
6. *        返 回 值: 错误代码(无需处理)
   / k) E3 O8 j9 Z' g* P& Q
7. *********************************************************************************************************
   ' x! |8 `, Y6 H) B% |5 O. a. t# o
8. */
   . g) s" q2 t. Z
9. int main(void)
   8 y( d9 N5 Z' e% a0 @
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    , v: K, Q+ }6 j
12.         
    
13.         bsp_Init();                /* 硬件初始化 */
    + ~, U' _9 A# Y& Y& E
14.         
    4 ]% ], ]) F$ y( C/ n
15.         /* 进入主程序循环体 */
    . i- t, a5 y0 s( Y: Y
16.         while (1)
    
17.         {               
    ; K/ E. z" E. j& S
18.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
19.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
20.                 if (ucKeyCode != KEY_NONE)
    ( N& E+ `0 g4 j9 G
21.                 {
    
22.                         switch (ucKeyCode)
    
23.                         {
    
24.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    
25.                                         printf("K1键按下\r\n");
    ! p  q) a# u4 Q4 V9 R$ {9 q5 I
26.                                         break;
    1 a+ c' s! f, P% t$ Z7 M* N( b
27. 
    
28.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    
29.                                         printf("K2键按下\r\n");
    
30.                                         break;
    . h9 k# ^+ m- j1 o/ M  M
31. 
    2 Y% c2 T# i$ |8 i' _+ ]
32.                                 default:
    
33.                                         /* 其它的键值不处理 */
    
34.                                         break;
    & a/ a) n5 ^9 \9 w
35.                         }
    
36.                 }
    4 Z* ~: Y) a* v
37.         }
    
38. }

复制代码

19.4.3 函数bsp_KeyScan10ms
函数原型：

1. /*
   7 }% f* w8 m3 S2 e9 R  Z7 O! `
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_KeyScan10ms
   ' t  a; b4 M; N0 T7 V
4. *        功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
   & c% \9 w8 b1 M( u- n" x
5. *        形    参: 无
   1 a' Y. g0 D! U" [: S$ W4 M" b
6. *        返 回 值: 无
   ' E9 ~4 R, K! h, _" ~
7. *********************************************************************************************************
   
8. */
   / P# v  U) z6 Y3 f- w
9. void bsp_KeyScan10ms(void)
   9 H7 g: ?+ Z% F- L+ Z+ N
10. {
      G/ }; e1 t! p7 Q4 V. I% b# @
11.         uint8_t i;
    
12. 
    9 s7 \7 L6 R8 F/ ?! `
13.         for (i = 0; i < KEY_COUNT; i++)
    
14.         {
    , M7 `0 x7 W0 q& Z& N
15.                 bsp_DetectKey(i);
    * i( d2 Y2 g, m$ s
16.         }
    1 K) I5 v' y) i: ?* ]9 k3 @
17. }

复制代码

" ~5 r: s1 o& z函数描述：
# o4 t7 B% e2 w' {6 |* A4 F5 f2 J) N
此函数是按键的主处理函数，用于检测和存储按下、松手、长按等状态。

. d4 G$ Z1 q8 P# R1 N; w& C( H使用举例：
8 U: L3 L1 _$ @  B/ H. J
调用此函数前，务必优先调用函数bsp_InitKey进行初始化。

另外，此函数需要周期性调用，每10ms调用一次。
6 ^2 d+ o+ O+ p- O5 M
, y5 k9 l" c, Q0 O! U8 N% D  如果是裸机使用，将此函数放在bsp.c文件的bsp_RunPer10ms函数里面即可，这个函数是由滴答定时器调用的，也就是说，大家要使用按键，定时器的初始化函数bsp_InitTimer一定要调用。
  如果是RTOS使用，需要开启一个10ms为周期的任务调用函数bsp_KeyScan10ms。

19.5 按键FIFO驱动移植和使用
按键移植步骤如下：

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

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

复制代码

  第3步：根据使用的引脚时钟，修改下面函数：
$ _  r6 h/ }+ \

1. /* 使能GPIO时钟 */
   : _/ S$ e0 M* Z4 Z
2. #define ALL_KEY_GPIO_CLK_ENABLE() {        \
   , k6 y0 \& o& f; @( D+ C& @5 X$ t
3.                 __HAL_RCC_GPIOB_CLK_ENABLE();        \
   
4.                 __HAL_RCC_GPIOC_CLK_ENABLE();        \
   
5.                 __HAL_RCC_GPIOG_CLK_ENABLE();        \
   # x# u  d  e; g$ n& `
6.                 __HAL_RCC_GPIOH_CLK_ENABLE();        \
   . h. f) t4 l- ^: C4 w
7.                 __HAL_RCC_GPIOI_CLK_ENABLE();        \
   
8.         };

复制代码

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

1. /* GPIO和PIN定义 */
   " A. F' _0 o7 U% X
2. static const X_GPIO_T s_gpio_list[HARD_KEY_NUM] = {
   3 N0 t3 x: C/ S- d. A: D
3.         {GPIOI, GPIO_PIN_8, 0},                /* K1 */
   
4.         {GPIOC, GPIO_PIN_13, 0},        /* K2 */
   4 Y/ q0 V2 K% b: |5 H
5.         {GPIOH, GPIO_PIN_4, 0},                /* K3 */
   
6.         {GPIOG, GPIO_PIN_2, 0},                /* JOY_U */        
   
7.         {GPIOB, GPIO_PIN_0, 0},                /* JOY_D */
   
8.         {GPIOG, GPIO_PIN_3, 0},                /* JOY_L */        
   
9.         {GPIOG, GPIO_PIN_7, 0},                /* JOY_R */        
   2 I+ z9 u* v# P4 `; j) F# I; }
10.         {GPIOI, GPIO_PIN_11, 0},        /* JOY_OK */
    
11. };   

复制代码

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

1.         /* 组合键 K1K2 */
     Q: V4 R8 M: ^* R/ u) Z) S
2.         if (_id == HARD_KEY_NUM + 0)
     c+ Y) T. q5 H+ D& y* ^
3.         {
   " ]- u. l% C: X2 L6 |  h
4.                 if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
   6 S5 h1 j5 e/ F8 {3 {
5.                 {
   2 X" t  E/ `$ R
6.                         return 1;
   * }; [' t" s) r8 y) T( }- a
7.                 }
   
8.                 else
   * m2 O' [+ H) V: s
9.                 {
   
10.                         return 0;
    
11.                 }
    
12.         }

复制代码

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

6 H( U/ N2 n9 z另外就是，函数KeyPinActive的参数是表示检测哪两个按键，设置0的时候表示第4步里面的第1组按键，设置为1表示第2组按键，以此类推。
# @& h* ~+ `& n: f% k& b4 L
# J( o. S6 D' j+ i; E1 h  第6步：主要用到HAL库的GPIO驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
  第7步：移植完整，应用方法看本章节配套例子即可。
5 X9 ^/ l8 w/ R, |特别注意，别忘了每10ms调用一次按键检测函数bsp_KeyScan10ms。

19.6 实验例程设计框架
% M3 L. d; b0 ^4 S' I& Y  m/ x0 X通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：
) y+ V( |. c4 f! U* g7 ?2 s" X

6 s  g/ t4 {& x# V. g0 X1 I
1、 第1阶段，上电启动阶段：
* K; ?& u1 N* W6 z6 `6 v' v
这部分在第14章进行了详细说明。
' _6 {  i4 R( d" _
2、 第2阶段，进入main函数：
/ p# T! x- m6 K% P! ~
, N) b- d+ T+ _- E  第1部分，硬件初始化，主要是MPU、Cache、HAL库、系统时钟、滴答定时器、按键等。
0 u  f- L1 G8 C! e  第2部分，应用程序设计部分，实现了一个按键应用。
) c8 |- G) |8 u  第3部分，按键扫描程序每10ms在滴答定时中断执行一次。

19.7 实验例程说明（MDK）
! b$ @" Y4 ]) {( R7 s+ X配套例子：
) x5 x4 P9 n5 H6 }* e) [V7-002_按键检测（软件滤波，FIFO机制）
, ?3 y6 O5 c1 s" Y  g8 ]0 j
3 y+ Q% ^; w/ @实验目的：
0 u; a8 @. @' k* @; q学习按键的按下，弹起，长按和组合键的实现。
& _* L8 [2 j$ s! M7 K* S' |3 Y. T3 U
7 u( J1 A9 j% W9 C6 A* e9 Q实验内容：
启动一个自动重装软件定时器，每100ms翻转一次LED2。
6 h: H5 F! h) W7 k1 F8 I# e" K
4 b* Z7 A1 S- F8 m" p实验操作：
3个独立按键和5向摇杆按下时均有串口消息打印。
5向摇杆的左键和右键长按时，会有连发的串口消息。
* [4 |+ M3 t- r; ]# a, @* c独立按键K1和K2按键按下，串口打印消息。

上电后串口打印的信息：

& |1 _. @) W, ?0 |; I/ b波特率 115200，数据位 8，奇偶校验位无，停止位 1

7 w) w" G5 @0 ^  ]: Z9 w8 P
程序设计：

  系统栈大小分配：

  RAM空间用的DTCM：
7 R5 @2 y% e4 e- u8 |
( t% ?- p, e$ [9 V8 v5 E

# p: G9 X& q5 U3 I+ U/ K: V* j% W
  硬件外设初始化

硬件外设的初始化是在 bsp.c 文件实现：

4 ~3 f' p% `1 x% q6 ^" n6 g8 N

1. /*
   
2. *********************************************************************************************************
   # u8 B/ G+ y9 l' t/ f9 h
3. *        函 数 名: bsp_Init
   - [: R! D/ I6 p- h
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   5 x8 t2 M, r# `8 j& [' K4 N
5. *        形    参：无
   
6. *        返 回 值: 无
   ! v. d- y1 ?; h( R6 W
7. *********************************************************************************************************
   : Q* z* @: I& A$ @( X
8. */
   ) C* b$ d: R6 ?8 m0 c$ s
9. void bsp_Init(void)
   " |8 d( V2 R0 l( h( r2 ?
10. {
    ; T) s6 m' N% t' v; c5 ~. Y+ O& ^
11.     /* 配置MPU */
    8 ~! S- o+ m2 q$ o% X
12.         MPU_Config();
    % x+ h4 Q/ T7 B
13.         
    
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    % @9 c, ?% a& u4 Z' \8 ]
16. 
    
17.         /*
    - E9 E1 Z( q3 a! M+ e" g4 [; W
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    ( C7 I- x1 _# J9 q2 |6 Y. R$ I
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    / i6 l+ H. i0 u1 k
20.            - 设置NVIV优先级分组为4。
    6 j6 N0 g  F. Y1 R% E" h( f
21.          */
    / z+ M- m9 y0 S- t# I
22.         HAL_Init();
    - \# K# R5 O# H! m! E8 y0 D
23. 
    
24.         /*
    ! g% z: e' t% p) e3 O% P" t8 ^
25.        配置系统时钟到400MHz
    ( b% R- U- o$ x, O
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    8 Z& L+ R2 j+ |$ o0 T9 t3 `
29.         SystemClock_Config();
    
30. 
    - r. Q  U+ ^: |  x
31.         /*
    9 C  |; ^4 n2 y$ {
32.            Event Recorder：
    
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    ; ^" k0 [1 B$ p2 J; j# _: H
38.         EventRecorderInitialize(EventRecordAll, 1U);
    9 z; c0 j, u7 n+ a! [. c  I2 X" _4 Y
39.         EventRecorderStart();
    6 k. v& F% j2 q1 T* x2 R
40. #endif
    
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    - T0 g/ z" n) F3 P8 Q( x$ Z5 ?
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    
46.         bsp_InitLed();            /* 初始化LED */        
    ( m; N; P4 x: P9 b$ p/ D
47. }

复制代码

  MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

1. /*
   1 T* L% ?7 B; X. p  Y* ]
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   6 {4 C% T; t( P  O. m* M' b
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   % G' o. ^! k: X5 c$ ]% S. q2 V& z
9. static void MPU_Config( void )
   
10. {
    ' t! h& i3 l6 R+ @7 B
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    ) ^- P9 q3 ^, `& u
13.         /* 禁止 MPU */
    ) L" T+ N& |- i1 o* a
14.         HAL_MPU_Disable();
    
15. 
    1 g3 X- g3 T) {( M
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    6 [1 @. P+ g( g* D3 j
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    6 C! F% B% o: t
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;
    + C& q' {& R% q! y3 r$ k
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    $ o& I+ g. [( Y, p2 [
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    ! a2 G% `2 k* v
31.         
    5 h: ?( j5 m: T8 t* D1 c
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    ! @: j! b- s) a
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    , S7 H  b* k( f  N( g! ]/ }6 M' u
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    & O7 J& Y1 N  k" q
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
      g3 @8 ?9 m( U
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    ! \7 W% ]- y- u: `. x$ h# n. }
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    + N* `  N) g4 y# A& T2 f" c  T6 X
44.         
    
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ; b  m4 t, Z' H
46. 
    
47.         /*使能 MPU */
    6 ?% U% p, I- i( d! m& u
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    
50. 
    % f/ ]1 E/ O; G9 P  k$ J% v
51. /*
    7 v1 n- Y3 T- H) _/ C
52. *********************************************************************************************************
    - T; F( o, U  v. D1 D
53. *        函 数 名: CPU_CACHE_Enable
    
54. *        功能说明: 使能L1 Cache
    ( F1 ]- R! ?) U* y
55. *        形    参: 无
    
56. *        返 回 值: 无
    4 Z" @! p) f: m
57. *********************************************************************************************************
    1 Z2 g4 E; P: j% m. Q7 G- h
58. */
    
59. static void CPU_CACHE_Enable(void)
    3 B7 X; O0 e9 u2 {% \4 H- L
60. {
    6 K: S% o% B- j+ \* ^6 w# o
61.         /* 使能 I-Cache */
    : j) [! \! o: o+ B3 d
62.         SCB_EnableICache();
    
63. 
    3 ?8 C- \" S$ j' c+ {8 Q+ l/ U
64.         /* 使能 D-Cache */
    # A! \! G2 t  ]8 ~! i
65.         SCB_EnableDCache();
    
66. }

复制代码

3 z$ _% M  j( f  每10ms调用一次按键检测：
) e- l7 V2 i$ e' k4 h; t+ y
按键检测是在滴答定时器中断里面实现，每10ms执行一次检测。
8 Y7 _2 J5 o! t# p5 A

1. /*
   
2. *********************************************************************************************************
   8 v+ C+ A, h( N$ v+ Y8 B7 g, m
3. *        函 数 名: bsp_RunPer10ms
   
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   5 K; l- e  |  o3 T4 [/ R' t4 w+ {
6. *        形    参: 无
   , j) z% D& h! i- ^* N% w
7. *        返 回 值: 无
   % j! X# C( I5 b0 {% X
8. *********************************************************************************************************
   
9. */
   2 f- M8 N2 f; H* X+ [
10. void bsp_RunPer10ms(void)
    - v9 w. i0 I' P5 `0 S8 o) v; u5 z
11. {
    
12.         bsp_KeyScan10ms();
    
13. }

复制代码

  主功能：

2 I" A0 [2 y/ ~$ Q2 [$ K+ O主功能的实现主要分为两部分：
1 p2 _2 v1 x( w$ j
启动一个自动重装软件定时器，每100ms翻转一次LED2
. v' }  `, G+ {  N. `8 \/ g 按键消息的读取，检测到按下后，做串口打印。
5 G" Q+ K% h) B0 V. j

1. /*
   
2. *********************************************************************************************************
   & k. d' V; q% g+ u+ A! Z& l
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   
8. */
   
9. int main(void)
   2 C3 ~# Y% J6 v( @1 H( H- P5 s
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    : ]9 l% L1 c5 ^: a+ B
12.         
    
13.         bsp_Init();                /* 硬件初始化 */
    
14.         
    
15.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    % K: h1 F/ q' l5 K2 w. b  q
16.         PrintfHelp();        /* 打印操作提示 */
    
17. 
    . k+ }6 p- h: ?) Z, b% j' x
18. 
    4 y3 o6 g0 {/ ]1 B- U; F
19.         bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 */
    ' h0 k% L- h% l3 O/ F" f' L' v0 H9 H
20.         
    * T/ y6 @0 J9 w! [1 J: z
21.         /* 进入主程序循环体 */
    
22.         while (1)
    
23.         {
    
24.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    / }- _; B" Y4 V8 }% H' D, [
25. 
    ' `2 K! R7 K, B
26.                 /* 判断定时器超时时间 */
    
27.                 if (bsp_CheckTimer(0))        
    2 N0 O, B1 N! f7 n
28.                 {
    ! `9 i0 }* x2 i' G& ~2 i
29.                         /* 每隔100ms 进来一次 */  
    * _+ s+ E+ i& ~7 g( u7 B& F
30.                         bsp_LedToggle(2);                        
      O' o% y& d7 e% `
31.                 }
    ; N( E6 k4 K) O3 o" n3 [8 E2 v
32.                
    " u2 _5 M6 R) P& i* n" z" y
33.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    8 D8 i% ~( T- f& ~
34.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
35.                 if (ucKeyCode != KEY_NONE)
    ' f& F0 D) D/ I7 K0 D0 f& Z8 n4 W
36.                 {
    
37.                         switch (ucKeyCode)
    3 ?# t) u; x4 s
38.                         {
    8 V7 `$ {" O7 V; M, X2 ?
39.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    * h7 H$ M7 g4 _% d9 k( x
40.                                         printf("K1键按下\r\n");
    ( `/ m7 f( V, J# H& R3 w8 n5 r
41.                                         break;
      U( G( K- ?4 d7 O: ~
42. 
    , q! j" ~+ f& x# k* V7 ^4 H
43.                                 case KEY_UP_K1:                                /* K1键弹起 */
    # l; q8 _8 T. ?/ X, P; g  i; w; i
44.                                         printf("K1键弹起\r\n");
    
45.                                         break;
    
46. 
    1 M# o& k7 U; s8 W- I" Y
47.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    
48.                                         printf("K2键按下\r\n");
    
49.                                         break;
    9 K0 w6 y& [# m1 c2 S$ c9 \% j
50. 
    8 F3 X" y7 M5 s$ E2 f
51.                                 case KEY_UP_K2:                                /* K2键弹起 */
    
52.                                         printf("K2键弹起\r\n");
    
53.                                         break;
    3 ?: z0 q" ^5 D) v! E6 O2 Y
54. 
    
55.                                 case KEY_DOWN_K3:                        /* K3键按下 */
    : ]# @$ h  W4 j8 v( y8 u, r
56.                                         printf("K3键按下\r\n");
    $ V5 f9 d+ }* d) p7 E  @9 V4 l
57.                                         break;
    
58. 
    . `$ s- Q3 g1 z1 Y1 F9 I
59.                                 case KEY_UP_K3:                                /* K3键弹起 */
    ' f9 y8 s: B' M6 o; i- x& D$ L; g
60.                                         printf("K3键弹起\r\n");
    
61.                                         break;
    6 f, k1 z5 v9 ]% Z' f
62. 
    $ ~! I' o8 d5 o/ i# L! X
63.                                 case JOY_DOWN_U:                        /* 摇杆UP键按下 */
    
64.                                         printf("摇杆上键按下\r\n");
    7 [9 ~" b, j) I* ~+ w( F9 c  J
65.                                         break;
    
66. 
    
67.                                 case JOY_DOWN_D:                        /* 摇杆DOWN键按下 */
    
68.                                         printf("摇杆下键按下\r\n");
    * k( G- |$ A/ P
69.                                         break;
    
70. 
    
71.                                 case JOY_DOWN_L:                        /* 摇杆LEFT键按下 */
    
72.                                         printf("摇杆左键按下\r\n");
    # e# `; A5 W* |
73.                                         break;
    2 n7 u! k- x# ]
74.                                 
    
75.                                 case JOY_LONG_L:            /* 摇杆LEFT键长按 */
    : a0 B" l+ l+ l. H! [" `
76.                                         printf("摇杆左键长按\r\n");
    
77.                                         break;
    . |* B0 [9 o6 h4 \% ]; @  X
78. 
    ) N7 u( N# }. _; E2 x" J5 g' H
79.                                 case JOY_DOWN_R:                        /* 摇杆RIGHT键按下 */
    
80.                                         printf("摇杆右键按下\r\n");
    & s( c3 M5 e8 A4 v% L1 a
81.                                         break;
      j7 R( y( U# z: j, U1 Z
82.                                 
    & i$ y& k$ E9 [7 p; Y- V9 s& K; v
83.                                 case JOY_LONG_R:            /* 摇杆RIGHT键长按 */
    1 b! p) X4 z& R
84.                                         printf("摇杆右键长按\r\n");
    
85.                                         break;
    ' B: v( B1 M4 v, g5 l$ i8 R
86. 
    
87.                                 case JOY_DOWN_OK:                        /* 摇杆OK键按下 */
    6 G9 S' z1 }+ L, ?
88.                                         printf("摇杆OK键按下\r\n");
    
89.                                         break;
    
90. 
    5 G, u+ |: `% R7 f8 j% s2 a- f! W
91.                                 case JOY_UP_OK:                        /* 摇杆OK键弹起 */
    - Q, |, P! q- F/ _' ^8 F
92.                                         printf("摇杆OK键弹起\r\n");
    ( @! M/ Z. @( W  |/ j" c2 N7 c
93.                                         break;
    
94. 
    6 M( `3 [# d( i( t& f5 _$ ~0 }
95.                 case SYS_DOWN_K1K2:                        /* 摇杆OK键弹起 */
    
96.                                         printf("K1和K2组合键按下\r\n");
    + C1 L8 k; {5 p7 q+ ?
97.                                         break;
    ' {; x4 A; q' Q% t5 t
98. 
    ' W0 a) {% r% b% \* z; O% E. p
99.                                 default:
    
100.                                         /* 其它的键值不处理 */
     
101.                                         break;
     3 q0 h! z4 @0 [# N% d
102.                         }
     % H3 @  c  D: s$ B7 c/ s
103.                
     
104.                 }
     
105.         }
     
106. }

复制代码

19.8 实验例程说明（IAR）
配套例子：
$ s. L' S7 I' h9 [+ J+ k/ MV7-002_按键检测（软件滤波，FIFO机制）
; G" O' E& y* q, R. l& Q7 k
实验目的：
学习按键的按下，弹起，长按和组合键的实现。
1 r, `# a3 ?$ `+ i
' \# K+ G# n4 ]5 @0 m实验内容：
启动一个自动重装软件定时器，每100ms翻转一次LED2。

2 R! ?; c3 d  T% f实验操作：
6 N3 K1 b5 E% I8 [3个独立按键和5向摇杆按下时均有串口消息打印。
+ r8 @; N$ ~+ s- c5向摇杆的左键和右键长按时，会有连发的串口消息。
独立按键K1和K2按键按下，串口打印消息。
$ [) M3 T9 R/ j2 ]  C0 F, Q
上电后串口打印的信息：
2 f% q' }2 Q7 c; f# ?8 v
波特率 115200，数据位 8，奇偶校验位无，停止位 1
5 k. c1 n/ h* L4 U" \
( t3 D" z( f" ]

7 z" |) B& R2 `, h, N4 l2 B( z
程序设计：
$ s  u- G% c4 t/ q; t% K- L3 M
  系统栈大小分配：

4 i/ F' v2 |0 s; Y6 k/ Z

  RAM空间用的DTCM：

/ w; \3 j4 r( ]0 c+ g

6 E5 |; G. @9 w$ H; ^
  硬件外设初始化
; f! _3 w) W6 v9 ?: J3 [; X+ r0 [
( I4 A8 I5 v% u, b  O; M+ G硬件外设的初始化是在 bsp.c 文件实现：

1. /*
   2 |/ W" w& R. M' b) ^
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   
6. *        返 回 值: 无
   # d* H8 H. x" }! G% H* H. k
7. *********************************************************************************************************
   
8. */
   7 f/ b$ q0 {# m' `. E
9. void bsp_Init(void)
   
10. {
    
11.     /* 配置MPU */
    , |# }4 X) r8 x7 i4 g
12.         MPU_Config();
    
13.         
    
14.         /* 使能L1 Cache */
    $ q9 {! b" H! f+ i; h: E+ C
15.         CPU_CACHE_Enable();
    % h- N, o! R6 k  X' J. c4 Q1 h
16. 
    $ N, D! t: ], c( X
17.         /*
    1 }; E9 m0 J& p% M0 O" W1 F& Y" P
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    . R4 B2 J2 w; G# d+ b; C( P+ ^5 C
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    ; E$ Z3 z$ n+ m& x8 J: x, h
20.            - 设置NVIV优先级分组为4。
      g% G; w5 f9 ?4 v3 }
21.          */
    4 c0 y8 }+ T) w8 ?
22.         HAL_Init();
    ; a1 S/ l# ?2 _9 s
23. 
    
24.         /*
    
25.        配置系统时钟到400MHz
    7 v( s8 `1 I& g$ x  C$ w
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.         SystemClock_Config();
    " j" `! C) u1 h( D& O
30. 
    
31.         /*
    
32.            Event Recorder：
    2 n. B; s# m  L. A( ^$ i  _
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    3 b4 s* w" b3 g; l& ^" s
35.         */        
    
36. #if Enable_EventRecorder == 1  
    * y) Y( f; S# x9 c9 ^: e( }
37.         /* 初始化EventRecorder并开启 */
    2 w0 y; [" d# G; {/ k7 P
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    
40. #endif
    
41.         
    ! T6 r) C+ C# [) v" _; W
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    8 p. `  L4 N2 x
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    
46.         bsp_InitLed();            /* 初始化LED */        
    1 U& _3 Q  ], i( H, D, k  ^& W
47. }

复制代码

  MPU配置和Cache配置：

数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

1. /*
   
2. *********************************************************************************************************
   5 E/ V( |: S3 b; W5 c8 v& G7 M
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   $ S4 S% t  r4 k7 k' \8 N& T, U
9. static void MPU_Config( void )
   
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    
13.         /* 禁止 MPU */
    # Z% S+ ~$ G8 ?) W
14.         HAL_MPU_Disable();
      d$ k; \/ [% K" w5 {; C
15. 
    3 K# J7 M6 a& h4 R# I1 j) _, ]
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    - I2 \7 R( i* w
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    + C! z" Y, \1 c+ |' Y
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    - h( V0 \* j2 K4 L, }7 w( Y/ E
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    7 }7 _3 |' B  @  ^. m
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    * h8 B" M7 r7 |& g' B, M; l
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    . }9 g/ N/ J+ F) E
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    ' r% Q) \6 R- E5 w% }4 v! G1 ]
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    ( H  f0 y, u4 f' V# H
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    " }4 D) z  U; a7 F- ^7 y
30.         
    
31.         
    # ~7 w; ~; w3 }9 B1 M( b' e
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    2 ?% q8 O9 L4 S2 Q" ?- d
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ; E2 H* O% I8 k) T  L3 q' i
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    ! r. B# C1 c) J
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    9 P* F" U4 G) h4 j* {3 x! j
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    # C" `" J9 V7 Q' ~$ p( C
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;
    ( i7 q- K! o$ S/ s5 D
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
      S5 S, D! f) h
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    % R+ S, o7 w0 i; ?  m4 l# u% z
46. 
    & K4 J) j/ y0 e& C% U* {8 V
47.         /*使能 MPU */
    6 V: _7 `$ l% E' [
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    
50. 
    6 y) i( F/ J: f. X
51. /*
    + c& `4 Z0 q! I. h
52. *********************************************************************************************************
    1 R# w: G! b5 l  c
53. *        函 数 名: CPU_CACHE_Enable
    
54. *        功能说明: 使能L1 Cache
    ; u2 d* L: z" e; g# x
55. *        形    参: 无
    
56. *        返 回 值: 无
    ; R+ I. M& q( ?& i$ r5 S
57. *********************************************************************************************************
    5 \/ Q% D; a2 p: |* ?4 K
58. */
    
59. static void CPU_CACHE_Enable(void)
    8 E  j* p& a! J  E( `
60. {
    + T+ Z1 Q3 M1 X6 I( C% x0 X
61.         /* 使能 I-Cache */
    ) m' N+ L7 x& }9 U, x  X* b
62.         SCB_EnableICache();
    / m! x- z% n; S2 a, N" ^
63. 
    : z( ]1 Q+ a* h) B5 X
64.         /* 使能 D-Cache */
    
65.         SCB_EnableDCache();
    
66. }

复制代码

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

按键检测是在滴答定时器中断里面实现，每10ms执行一次检测。
) ?( _. l$ R2 u6 f. ]; a+ [
4 @) t/ ]3 ]* s  V9 _$ e# J0 z

1. /*
   6 F7 x5 f, B& c& u3 B. _
2. *********************************************************************************************************
   0 [2 `& y. s; _8 V/ a5 {' w5 P% i
3. *        函 数 名: bsp_RunPer10ms
   
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *        形    参: 无
   
7. *        返 回 值: 无
   ( G+ `5 u: p/ N% s
8. *********************************************************************************************************
   % Q" I/ J# t, @, y, E5 S- H% ]- I! b6 n
9. */
   ( m' B* M  B& y2 b6 I1 b6 M# u
10. void bsp_RunPer10ms(void)
    
11. {
    
12.         bsp_KeyScan10ms();
    
13. }

复制代码

主功能：

: r5 s9 E, N4 M3 I0 L2 H主功能的实现主要分为两部分：
: }& z  l$ T; Q  C! i
启动一个自动重装软件定时器，每100ms翻转一次LED2
8 [" ^: r3 ~- y* T, S& F 按键消息的读取，检测到按下后，做串口打印。
, q3 G# [/ E3 ~0 V& x

1. /*
   0 c2 |7 S1 k& [5 p; X- f
2. *********************************************************************************************************
   5 V4 g/ j- b! E# n6 i" H3 j- [' w$ |
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   3 R  x8 M3 B, K' w4 V
6. *        返 回 值: 错误代码(无需处理)
   $ |% S, s) B& ~% E! Y
7. *********************************************************************************************************
   , K" q/ u* p8 o
8. */
   9 A9 M- D8 r$ s  q5 U( V
9. int main(void)
   0 X7 o6 f( I# k' A1 W
10. {
    
11.         uint8_t ucKeyCode;                /* 按键代码 */
    1 ^6 J& M$ s$ e- G
12.         
    
13.         bsp_Init();                /* 硬件初始化 */
    $ e% {% x: F7 d
14.         
    
15.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
16.         PrintfHelp();        /* 打印操作提示 */
    ! @. ^" D/ A9 w- t9 ?& N
17. 
    
18. 
    
19.         bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 */
    
20.         
    
21.         /* 进入主程序循环体 */
    
22.         while (1)
    
23.         {
    * W' P" o/ X4 ?5 S" v: x1 s# i; @
24.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
25. 
    
26.                 /* 判断定时器超时时间 */
    9 S/ G: A% N6 R& |
27.                 if (bsp_CheckTimer(0))        
    % X: n+ Z: n8 w: }; H9 y
28.                 {
    
29.                         /* 每隔100ms 进来一次 */  
    
30.                         bsp_LedToggle(2);                        
    
31.                 }
    . n& A% x: x( m* V) b
32.                
    0 V2 l/ {* L# |8 w
33.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    / h# G! t- b/ O
34.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
35.                 if (ucKeyCode != KEY_NONE)
    ( }) L9 w5 X# ^3 `# U$ P6 t9 B# V
36.                 {
      ~; w+ A, v  G) ]3 L' ~% D, t  t
37.                         switch (ucKeyCode)
    ' @& l1 K, i; U( `  s
38.                         {
    
39.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    , a- S# l  Q' i0 a3 y
40.                                         printf("K1键按下\r\n");
    
41.                                         break;
    
42. 
    
43.                                 case KEY_UP_K1:                                /* K1键弹起 */
    8 @7 L+ z7 q! T$ `
44.                                         printf("K1键弹起\r\n");
    
45.                                         break;
    0 L" z! Z2 S+ N; ^
46. 
    
47.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    : O; I9 k7 p( P" k
48.                                         printf("K2键按下\r\n");
    
49.                                         break;
    : C  ]5 m6 ~6 W5 T: t3 C+ J% s4 H% r
50. 
    1 I- S$ A# E+ w7 [4 h, |# K* j
51.                                 case KEY_UP_K2:                                /* K2键弹起 */
    ' b+ l; [) ?/ \- b4 A  l( ^9 {8 r
52.                                         printf("K2键弹起\r\n");
    ) a7 `  ?$ b# O( e1 S, q
53.                                         break;
    9 k9 m2 b: {  e* t, [
54. 
    
55.                                 case KEY_DOWN_K3:                        /* K3键按下 */
    
56.                                         printf("K3键按下\r\n");
    - s. D) K& l3 P. T
57.                                         break;
    
58. 
    & e) b, T6 @& |6 N( o
59.                                 case KEY_UP_K3:                                /* K3键弹起 */
    
60.                                         printf("K3键弹起\r\n");
    3 b$ v. b' j5 S+ a
61.                                         break;
    ( s9 X  a/ `2 z
62. 
    , @& K- x% j! X7 F( k
63.                                 case JOY_DOWN_U:                        /* 摇杆UP键按下 */
    
64.                                         printf("摇杆上键按下\r\n");
    % R. m# o: n5 k" I  N, [
65.                                         break;
    ' I# H; [5 q) Z. K* O
66. 
    
67.                                 case JOY_DOWN_D:                        /* 摇杆DOWN键按下 */
    
68.                                         printf("摇杆下键按下\r\n");
    ( L( C! t; P* b/ }5 k, K
69.                                         break;
    5 _' @% k* b9 m6 x( ~6 |
70. 
    
71.                                 case JOY_DOWN_L:                        /* 摇杆LEFT键按下 */
    
72.                                         printf("摇杆左键按下\r\n");
    
73.                                         break;
    
74.                                 
    
75.                                 case JOY_LONG_L:            /* 摇杆LEFT键长按 */
    0 R  |% T; C6 L! t1 J. j+ L* P
76.                                         printf("摇杆左键长按\r\n");
    
77.                                         break;
    6 L2 S1 @7 D; e$ o' v* }/ N& L
78. 
    ' x5 j4 e; x9 t+ d0 S# [$ H) X
79.                                 case JOY_DOWN_R:                        /* 摇杆RIGHT键按下 */
    4 f5 @5 d# \! ]9 y0 t7 _: P
80.                                         printf("摇杆右键按下\r\n");
    
81.                                         break;
    ! K* v1 L0 E8 V* c: _# w  N* [
82.                                 
    8 L) s" ]# ]) a! k2 c, H
83.                                 case JOY_LONG_R:            /* 摇杆RIGHT键长按 */
    
84.                                         printf("摇杆右键长按\r\n");
    
85.                                         break;
    
86. 
    
87.                                 case JOY_DOWN_OK:                        /* 摇杆OK键按下 */
    
88.                                         printf("摇杆OK键按下\r\n");
    
89.                                         break;
    
90. 
    3 _6 F2 F; m( K2 C
91.                                 case JOY_UP_OK:                        /* 摇杆OK键弹起 */
    
92.                                         printf("摇杆OK键弹起\r\n");
      P( Y8 V) A2 N: P& f: f7 x- U
93.                                         break;
    ) F) w# Z' M' f  V. B! @1 T
94. 
    8 X# s7 @, Z" U( D/ Q; p$ P2 A0 D
95.                 case SYS_DOWN_K1K2:                        /* 摇杆OK键弹起 */
    7 H. r: s$ U! D/ r
96.                                         printf("K1和K2组合键按下\r\n");
    1 a4 \" |7 z: ^" e( ?
97.                                         break;
    
98. 
    ( _+ z' C3 f# G4 W# Y& x' l
99.                                 default:
    
100.                                         /* 其它的键值不处理 */
     
101.                                         break;
     4 k; h) J% ^1 u, h) |
102.                         }
     
103.                
     ) M# U; [2 T3 t5 h7 \0 N
104.                 }
     
105.         }
     
106. }

复制代码

+ U/ H% R  }6 X6 m, {, S4 d19.9 总结
0 k/ o0 I/ D/ D: ^2 \( y这个方案在实际项目中已经经过千锤百炼，大家可以放心使用。建议熟练掌握其用法。
2 u( [; l; |$ S2 b; _4 _
) K& p# H: n9 v$ m