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

- c/ X4 C6 l* u, B19.2 按键硬件设计
V7开发板有三个独立按键和一个五向摇杆，下面是三个独立按键的原理图：

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

6 i# d3 t3 f: x5 A" {& r( p下面是五向摇杆的原理图：

$ F1 U& t/ r; s1 @+ {. H0 W

. m& b* y; O# A. ?5 |9 |& {
( n0 H" N, Z* {: a5 J通过这个硬件设计，有如下两个知识点为大家做介绍：

19.2.1 硬件设计
0 J1 q$ r1 r, L6 q1 E% }按键和CPU之间串联的电阻起保护作用。按键肯定是存在机械抖动的，开发板上面的硬件没有做硬件滤波处理，即使设计了硬件滤波电路，软件上还是需要进行滤波。
+ }2 V; x( Z2 r2 X6 e
# W6 g1 E2 _+ u' v! y) P* z! K1 c  保护GPIO，避免软件错误将IO设置为输出，如果设置为低电平还好，如果设置输出的是高电平，按键按下会直接跟GND(低电平)连接，从而损坏MCU。
# p6 y2 l- z2 q& e" `: y  保护电阻也起到按键隔离作用，这些GPIO可以直接用于其它实验。
9 }; c; {) o( k  s) q. m0 r19.2.2 GPIO内部结构分析按键
; w' c% Q  T$ g; d, M# L! S详细的GPIO模式介绍，请参考第15章的15.3小节，本章仅介绍输入模式。下面我们通过一张图来简单介绍GPIO的结构。

5 i: Y  K' b3 S# K
2 i' G$ K0 K9 V% I; u) ~红色的线条是GPIO输入通道的信号流向，作为按键检测IO，这些需要配置为浮空输入。按键已经做了5V上拉，因此GPIO内部的上下拉电阻都选择关闭状态。
0 w) Q% A5 u* S8 J. u6 @
19.3 按键FIFO的驱动设计
/ m# e* d) Y- W# f  ?bsp_key按键驱动程序用于扫描独立按键，具有软件滤波机制，采用FIFO机制保存键值。可以检测如下事件：

  按键按下。
  按键弹起。
  长按键。
  长按时自动连发。
# E) q8 q1 D; X7 y3 z我们将按键驱动分为两个部分来介绍，一部分是FIFO的实现，一部分是按键检测的实现。
- y1 \% ~' A* |, S. d' q

bsp_key.c 文件包含按键检测和按键FIFO的实现代码。

5 s% w; O; @# z* u! ^9 dbsp.c 文件会调用bsp_InitKey()初始化函数。
! [9 {. @1 R2 Y% M: D
bsp.c 文件会调用bsp_KeyScan按键扫描函数。
$ q( S8 q+ T. w5 c: U
bsp_timer.c 中的Systick中断服务程序调用 bsp_RunPer10ms。
$ [; o* g! D4 O/ e0 u6 m. P
9 o$ \+ I5 s$ l, K. a9 _% A& z中断程序和主程序通过FIFO接口函数进行信息传递。

函数调用关系图：
( ]* l; J( R2 r" B, v
4 h. w* u- ]8 d$ y

19.3.1 按键FIFO的原理
FIFO是First Input First Output的缩写，先入先出队列。我们这里以5个字节的FIFO空间进行说明。Write变量表示写位置，Read变量表示读位置。初始状态时，Read = Write = 0。
) H( E- b  O( c* w& H1 h
# j4 b$ t" s1 M2 N. T

* b" F6 f! K! V1 \& W5 T6 }3 p; W我们依次按下按键K1，K2，那么FIFO中的数据变为：

: q# z$ P  x, l7 r& v( Q- w9 i

. Z  [! c4 ^5 W* @: n* k
8 t* w. |) X) F+ ^! }/ y如果Write！= Read，则我们认为有新的按键事件。
- Y4 }9 \& N7 R0 Z" \) c+ N$ t
7 ^+ h' d! {# a我们通过函数bsp_GetKey读取一个按键值进行处理后，Read变量变为1。Write变量不变。
8 [$ x5 k: Q7 r& ?4 M

" G, a( ]* B" {* j+ I4 [
4 |9 ^0 D' t/ s* k5 {我们继续通过函数bsp_GetKey读取3个按键值进行处理后，Read变量变为4。此时Read = Write = 4。两个变量已经相等，表示已经没有新的按键事件需要处理。

: b; _' n: c% J1 w6 B2 t有一点要特别的注意，如果FIFO空间写满了，Write会被重新赋值为0，也就是重新从第一个字节空间填数据进去，如果这个地址空间的数据还没有被及时读取出来，那么会被后来的数据覆盖掉，这点要引起大家的注意。我们的驱动程序开辟了10个字节的FIFO缓冲区，对于一般的应用足够了。
" n9 m. V* O" K9 P: r( P. s: d
% R- H% q5 n9 j9 q% h设计按键FIFO主要有三个方面的好处：

& E- G5 X7 n- D8 \( |# C2 E* b8 u) }6 Q  可靠地记录每一个按键事件，避免遗漏按键事件。特别是需要实现按键的按下、长按、自动连发、弹起等事件时。
/ W/ V4 i* H1 a0 J  读取按键的函数可以设计为非阻塞的，不需要等待按键抖动滤波处理完毕。
  按键FIFO程序在嘀嗒定时器中定期的执行检测，不需要在主程序中一直做检测，这样可以有效地降低系统资源消耗。
: @. [! r8 X9 t, n
19.3.2 按键FIFO的实现
$ H: Y$ ~1 g1 g6 f在bsp_key.h 中定了结构体类型KEY_FIFO_T。这只是类型声明，并没有分配变量空间。
5 {3 m3 Z+ t0 ?3 Q$ _. ]0 l0 J( y3 I
* i, f, C, ]* b4 g6 x! H

1. #define KEY_FIFO_SIZE        10
   
2. typedef struct
   
3. {
   # G; ]6 n  i/ m. U" Y; k. s5 o$ e
4.         uint8_t Buf[KEY_FIFO_SIZE];                /* 键值缓冲区 */
   
5.         uint8_t Read;                                        /* 缓冲区读指针1 */
   * f5 g  X9 e% t  |3 w3 f* w
6.         uint8_t Write;                             /* 缓冲区写指针 */
   1 Z/ @( s* }# g! e, K( ^
7.         uint8_t Read2;                             /* 缓冲区读指针2 */
   - M0 E0 D3 q  I8 f* C* A! U0 m
8. }KEY_FIFO_T;

复制代码

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

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

复制代码

一般情况下，只需要一个写指针Write和一个读指针Read。在某些情况下，可能有两个任务都需要访问按键缓冲区，为了避免键值被其中一个任务取空，我们添加了第2个读指针Read2。出厂程序在bsp_Idle()函数中实现的按K1K2组合键截屏的功能就使用的第2个读指针。
1 ?' ^! Z" n- ?
当检测到按键事件发生后，可以调用 bsp_PutKey函数将键值压入FIFO。下面的代码是函数的实现：
% i4 L9 ]4 M7 g) g; Y& p9 H+ M: P/ Y/ l6 e

1. /*
   4 |' [# l) T! P! p
2. *********************************************************************************************************
   ! ~1 j/ n! h' V; R" @" q; y4 E: L/ q
3. *        函 数 名: bsp_PutKey
   
4. *        功能说明: 将1个键值压入按键FIFO缓冲区。可用于模拟一个按键。
   / ^: E. e9 ^0 y2 Q/ S0 c+ a* g* j
5. *        形    参: _KeyCode : 按键代码
   
6. *        返 回 值: 无
   / P- K3 A% t# `
7. *********************************************************************************************************
   9 i: m: J. t( n
8. */
   6 p) i( B7 a* R$ {% y  k
9. void bsp_PutKey(uint8_t _KeyCode)
   
10. {
    ! z! i0 w7 d! g) u" M2 W" r
11.         s_tKey.Buf[s_tKey.Write] = _KeyCode;
    
12. 
    ; x) }' D  E0 p3 f1 Q# S+ {* n
13.         if (++s_tKey.Write  >= KEY_FIFO_SIZE)
    1 p8 n. R. {- F, ~# E( D$ b
14.         {
    / s1 K2 r8 y: [, `. F
15.                 s_tKey.Write = 0;
    
16.         }
    ; x4 x2 _! i) J
17. }

复制代码

这个bsp_PutKey函数除了被按键检测函数调用外，还可以被其他底层驱动调用。比如红外遥控器的按键检测，也共用了同一个按键FIFO。遥控器的按键代码和主板实体按键的键值统一编码，保持键值唯一即可实现两套按键同时控制程序的功能。
! i$ ~8 N3 Z7 x! `, x- O" u% ?
  W, [: v. i) k8 t应用程序读取FIFO中的键值，是通过bsp_GetKey函数和bsp_GetKey2函数实现的。我们来看下这两个函数的实现：
1 d3 j  q& Z2 k# t. ~  P+ x

1. /*
   
2. *********************************************************************************************************
   : H; r" H' z# g  q3 f
3. *        函 数 名: bsp_GetKey
   
4. *        功能说明: 从按键FIFO缓冲区读取一个键值。
     k: v6 b( b0 ^% I/ v
5. *        形    参:  无
   
6. *        返 回 值: 按键代码
   , e( {) s0 H7 Y% I+ ?+ \
7. *********************************************************************************************************
   
8. */
   
9. uint8_t bsp_GetKey(void)
   , j% }' {# F4 ~! h+ W
10. {
    + g# C2 T: |3 l0 T7 m0 i/ ^
11.         uint8_t ret;
    - H/ m9 j% L. B0 _( i
12. 
    
13.         if (s_tKey.Read == s_tKey.Write)
    
14.         {
    
15.                 return KEY_NONE;
    
16.         }
    
17.         else
    ) `: ]3 H4 M$ v4 F$ ?7 S
18.         {
    
19.                 ret = s_tKey.Buf[s_tKey.Read];
    + e; |; U% o9 O' r/ }* E6 ?
20. 
    & z2 f2 F2 f: Q* h
21.                 if (++s_tKey.Read >= KEY_FIFO_SIZE)
    
22.                 {
    / E" m- K' J8 S8 F/ k; t& i
23.                         s_tKey.Read = 0;
    
24.                 }
    # w5 L$ M: Q: I' Q% n
25.                 return ret;
    2 D* ~2 Z$ V% l* d9 j: ?! O  G
26.         }
    
27. }
    
28. 
    4 P9 f" j  R- _
29. /*
    " |: i0 g8 Z! E
30. *********************************************************************************************************
    
31. *        函 数 名: bsp_GetKey2
    
32. *        功能说明: 从按键FIFO缓冲区读取一个键值。独立的读指针。
    ' x& r  \$ M) t
33. *        形    参:  无
    
34. *        返 回 值: 按键代码
    
35. *********************************************************************************************************
    0 T+ z. L( d2 i! U" B( V6 r; ^
36. */
    ) P/ f5 X. E6 Y0 m" B; Z: x
37. uint8_t bsp_GetKey2(void)
    + U2 r: t7 v& B' A. s* l. o* q
38. {
    ' g! [3 v5 ]& f( k$ p
39.         uint8_t ret;
    : u/ Q5 x2 u( O# a" N  Z$ ^
40. 
    
41.         if (s_tKey.Read2 == s_tKey.Write)
    4 s  U% Q; x5 ~: `: J( k+ z/ V
42.         {
    6 P# n! {" v: F  O+ r
43.                 return KEY_NONE;
    : i! n) k6 i9 \; y( i& o* X
44.         }
    ( k4 e. n8 Y5 a0 K1 I
45.         else
    
46.         {
    0 |8 q# Q9 k; s) @' C
47.                 ret = s_tKey.Buf[s_tKey.Read2];
    & V' M5 a3 N6 h* a# ?
48. 
    4 }, m% e7 Q: |1 ~7 B9 h0 ~' \
49.                 if (++s_tKey.Read2 >= KEY_FIFO_SIZE)
    
50.                 {
    ) k8 g/ O; t, O; R: Q- @0 I
51.                         s_tKey.Read2 = 0;
    
52.                 }
    
53.                 return ret;
    
54.         }
    
55. }

复制代码

6 V0 g6 ]' u' Y) a: I9 e4 o' I返回值KEY_NONE = 0, 表示按键缓冲区为空，所有的按键时间已经处理完毕。按键的键值定义在 bsp_key.h文件，下面是具体内容：

' W1 r% q2 G- f9 S) M  A

1. typedef enum
   ) ~0 v  K# H5 b$ w# t9 O* J' k; f
2. {
   
3.         KEY_NONE = 0,                        /* 0 表示按键事件 */
   
4. 
   : m! @/ C5 ]: c
5.         KEY_1_DOWN,                        /* 1键按下 */
   % x2 K( n2 I. M
6.         KEY_1_UP,                                /* 1键弹起 */
   & g/ @7 M7 x* U6 \) W
7.         KEY_1_LONG,                        /* 1键长按 */
   
8. 
   
9.         KEY_2_DOWN,                        /* 2键按下 */
   4 W, Q3 P" U& L- @
10.         KEY_2_UP,                                /* 2键弹起 */
    * f: K5 w& E+ n
11.         KEY_2_LONG,                        /* 2键长按 */
    
12. 
    
13.         KEY_3_DOWN,                        /* 3键按下 */
    
14.         KEY_3_UP,                                /* 3键弹起 */
    1 f  D9 i* b, z. a9 ?" a, L
15.         KEY_3_LONG,                        /* 3键长按 */
    
16. 
    
17.         KEY_4_DOWN,                        /* 4键按下 */
    + S9 A% }4 Y" p5 ~: p' h
18.         KEY_4_UP,                                /* 4键弹起 */
    
19.         KEY_4_LONG,                        /* 4键长按 */
    
20. 
    0 ^/ J5 `- \4 Q8 c6 [( w# C5 u- s
21.         KEY_5_DOWN,                        /* 5键按下 */
    ) m9 M5 ^( u- T* S5 [" l
22.         KEY_5_UP,                                /* 5键弹起 */
    
23.         KEY_5_LONG,                        /* 5键长按 */
    
24. 
    
25.         KEY_6_DOWN,                        /* 6键按下 */
    ; H" X; ~3 C) t' Q  T
26.         KEY_6_UP,                                /* 6键弹起 */
    
27.         KEY_6_LONG,                        /* 6键长按 */
    
28. 
    . ?, S4 f3 Z) |) l4 m+ ^7 |
29.         KEY_7_DOWN,                        /* 7键按下 */
    
30.         KEY_7_UP,                                /* 7键弹起 */
    ; W* h3 R( S2 D0 M* u# m+ ]
31.         KEY_7_LONG,                        /* 7键长按 */
    7 L9 g# M3 L9 f9 T: v' j0 f, }
32. 
    * N8 d5 Z3 y- W5 @/ Z& z
33.         KEY_8_DOWN,                        /* 8键按下 */
    / N9 c8 G* m: w6 K0 z2 r/ B+ p- i! s' E
34.         KEY_8_UP,                                /* 8键弹起 */
    
35.         KEY_8_LONG,                        /* 8键长按 */
    ' B5 _( s/ ~) }7 A. C; H% n# |4 |* Q
36. 
    
37.         /* 组合键 */
    $ l! ]7 N1 D- H- v3 A( b- W( T3 L
38.         KEY_9_DOWN,                        /* 9键按下 */
    1 }, z: v5 F; d5 A! h4 g3 c5 k9 }# j
39.         KEY_9_UP,                                /* 9键弹起 */
    3 j) q. r7 O: ~: H  M4 P
40.         KEY_9_LONG,                        /* 9键长按 */
    $ |9 M5 s# W$ @5 j- a4 z/ C
41. 
    % @2 v- B2 Q: w" V% q
42.         KEY_10_DOWN,                        /* 10键按下 */
    
43.         KEY_10_UP,                        /* 10键弹起 */
    9 v: d6 b1 v1 l5 F+ \5 r# [" l) C0 I
44.         KEY_10_LONG,                        /* 10键长按 */
      u& C* X, \& K' Y2 {( H3 r
45. }KEY_ENUM;

复制代码

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

  便于新增键值,方便调整顺序。
  使用{ } 将一组相关的定义封装起来便于理解。
  编译器可帮我们避免键值重复。
7 j, u$ {2 k, [, k2 X我们来看红外遥控器的键值定义，在bsp_ir_decode.h文件。因为遥控器按键和主板按键共用同一个FIFO，因此在这里我们先贴出这段定义代码，让大家有个初步印象。

1. /* 定义红外遥控器按键代码, 和bsp_key.h 的物理按键代码统一编码 */
   
2. typedef enum
   # I$ ?3 v4 n7 k- q' b! k; ~0 R
3. {
   
4.         IR_KEY_STRAT         = 0x80,
     x- q7 K( C+ A# b, ^* ~+ R
5.         IR_KEY_POWER         = IR_KEY_STRAT + 0x45,
   
6.         IR_KEY_MENU         = IR_KEY_STRAT + 0x47,
   
7.         IR_KEY_TEST         = IR_KEY_STRAT + 0x44,
     w1 \5 h+ y! j( D/ E& `
8.         IR_KEY_UP         = IR_KEY_STRAT + 0x40,
   
9.         IR_KEY_RETURN        = IR_KEY_STRAT + 0x43,
   3 C! ~9 q+ n. S4 t
10.         IR_KEY_LEFT        = IR_KEY_STRAT + 0x07,
    " X. N% w2 M( P7 t+ e
11.         IR_KEY_OK                = IR_KEY_STRAT + 0x15,
    8 H& Z! \4 b( a# D7 j# W
12.         IR_KEY_RIGHT        = IR_KEY_STRAT + 0x09,
    $ Q0 Q2 B) w5 x
13.         IR_KEY_0                = IR_KEY_STRAT + 0x16,
    
14.         IR_KEY_DOWN        = IR_KEY_STRAT + 0x19,
    & k8 i; k; c% \
15.         IR_KEY_C                = IR_KEY_STRAT + 0x0D,
    * \3 H1 V4 a) F& w3 S' A% b
16.         IR_KEY_1                = IR_KEY_STRAT + 0x0C,
    
17.         IR_KEY_2                = IR_KEY_STRAT + 0x18,
    , n' X. T, {8 n; c+ \6 i
18.         IR_KEY_3                = IR_KEY_STRAT + 0x5E,
    5 R8 B( T: j- V
19.         IR_KEY_4                = IR_KEY_STRAT + 0x08,
    " r( b/ y# @5 D' c6 ?
20.         IR_KEY_5                = IR_KEY_STRAT + 0x1C,
    
21.         IR_KEY_6                = IR_KEY_STRAT + 0x5A,
    
22.         IR_KEY_7                = IR_KEY_STRAT + 0x42,
    
23.         IR_KEY_8                = IR_KEY_STRAT + 0x52,
    
24.         IR_KEY_9                = IR_KEY_STRAT + 0x4A,        
    3 z: Y- @2 e5 H# v, ?
25. }IR_KEY_E;

复制代码

我们下面来看一段简单的应用。这个应用的功能是：主板K1键控制LED1指示灯；遥控器的POWER键和MENU键控制LED2指示灯。
6 D0 Y/ x  B4 l" a
' o$ [  L4 h3 {4 Q

1. #include "bsp.h"
   
2. 
   
3. int main(void)
   3 |  d/ X- k' j" L
4. {
   , k. {( ^% g8 N( O% o
5.         uint8_t ucKeyCode;
   + r, ~1 V$ d; U: A5 b& [
6.                         
   ' w; W8 I5 x( x$ g) }9 ?% X
7.         bsp_Init();
   
8. 
   
9.         IRD_StartWork();        /* 启动红外解码 */
   
10. 
    / _  ~5 ~% w* A1 s8 Y
11.         while(1)
    ' \) g* Q3 A0 b- k
12.         {
    
13.                 bsp_Idle();
    2 }- M% h7 T+ }( I+ c* A& k/ K! W% P: G
14.                
    $ Q! b% S! \; I# ]- `0 I+ P: P
15.                 /* 处理按键事件 */
    6 M' L: G* ]) e, |/ S8 Q$ t
16.                 ucKeyCode = bsp_GetKey();
    , z* N1 u! f* Z5 W
17.                 if (ucKeyCode > 0)
    ; S1 c% }3 Q& B% _4 a7 L
18.                 {
    
19.                         /* 有键按下 */
    ! g) F* m0 c2 d8 Z2 t& [6 X# A
20.                         switch (ucKeyCode)
    - i- |% q) G; R% e- s
21.                         {
    
22.                                 case KEY_DOWN_K1:                /* K1键按下 */
    
23.                                         bsp_LedOn(1);                /* 点亮LED1 */
    
24.                                         break;
    + n! M! L/ c, \4 @% Y6 q; y1 |# w
25. 
    
26.                                 case KEY_UP_K1:                /* K1键弹起 */
    3 n+ v& X" L( B# Z
27.                                         bsp_LedOff(1);        /* 熄灭LED1 */
    
28.                                         break;                                       
    
29. 
    / p' R" D# c6 t! E; j  Z$ H' J0 G
30.                                 case IR_KEY_POWER:                /* 遥控器POWER键按下 */
    
31.                                         bsp_LedOn(1);                /* 点亮LED2 */
    
32.                                         break;
    
33. 
    . ?6 W9 u, k0 E6 t& N' K1 m
34.                                 case IR_KEY_MENU:                /* 遥控器MENU键按下 */
    
35.                                         bsp_LedOff(1);        /* 熄灭LED2 */
    
36.                                         break;                                       
    
37. 
    
38.                                 case MSG_485_RX:                /* 通信程序的发来的消息 */
    : h2 V' y9 C' v5 O
39.                                         /* 执行通信程序的指令 */
    
40.                                         break;
      P( ^0 R; j& {7 h% c1 C: D
41. 
      \( N4 g% ^& d7 H" `
42.                                 default:
      A, h3 j  D# p1 |$ D# A8 E
43.                                         break;
    
44.                         }
    $ T4 D. ~; H$ I( g, V
45.                 }
    
46.         }
    
47. }

复制代码

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

在上面的应用程序中，我们特意添加了一段红色的代码来解说更高级的用法。485通信程序收到有效的命令后通过 bsp_PutKey（MSG_485_RX）函数可以通知APP应用程序进行进一步加工处理（比如显示接收成功）。这是一种非常好的任务间信息传递方式，它不会破坏程序结构。不必新增全局变量来做这种事情，你只需要添加一个键值代码。

对于简单的程序，可以借用按键FIFO来进行少量的信息传递。对于复杂的应用，我们推荐使用bsp_msg专门来做这种任务间的通信。因为bsp_msg除了传递消息代码外，还可以传递参数结构。

2 G) c% |5 q: x) a19.3.3 按键检测程序分析
* @2 p' i6 z# [8 g; d在bsp_key.h 中定了结构体类型KEY_T。
0 K0 @! a$ T2 U4 k4 }( r
9 u% |0 ~( T# v5 E

1. #define KEY_COUNT    10                           /* 按键个数, 8个独立建 + 2个组合键 */
   5 M& q) Z# B  i2 E+ T: r- w
2. 
   
3. typedef struct
   
4. {
   6 ]+ L$ @5 a/ q
5.         /* 下面是一个函数指针，指向判断按键手否按下的函数 */
   
6.         uint8_t (*IsKeyDownFunc)(void); /* 按键按下的判断函数,1表示按下 */
   
7. 
   % {: X/ S6 e0 Q4 o$ y3 g
8.         uint8_t  Count;                /* 滤波器计数器 */
   
9.         uint16_t LongCount;        /* 长按计数器 */
   
10.         uint16_t LongTime;                /* 按键按下持续时间, 0表示不检测长按 */
    
11.         uint8_t  State;                /* 按键当前状态（按下还是弹起） */
    
12.         uint8_t  RepeatSpeed;        /* 连续按键周期 */
    4 V! S& {( g6 r* E. s; G0 @
13.         uint8_t  RepeatCount;        /* 连续按键计数器 */
    
14. }KEY_T;

复制代码

5 T) w3 p& X7 \: q! H9 Q! o在bsp_key.c 中定义s_tBtn结构体数组变量。

6 G9 z  ^# n% b) f( j% T7 W/ P

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

复制代码

每个按键对象都分配一个结构体变量，这些结构体变量以数组的形式存在将便于我们简化程序代码行数。
$ C: f) f7 t; L) A
使用函数指针IsKeyDownFunc可以将每个按键的检测以及组合键的检测代码进行统一管理。
, B, G. y2 D3 t% J3 q; [" R
  _& {3 \" I- M8 Q+ Z! y" U; }因为函数指针必须先赋值，才能被作为函数执行。因此在定时扫描按键之前，必须先执行一段初始化函数来设置每个按键的函数指针和参数。这个函数是 void bsp_InitKey(void)。它由bsp_Init()调用。

1. /*
   
2. *********************************************************************************************************
   . [. Q+ Q+ @& ^
3. *        函 数 名: bsp_InitKey
   7 `/ Q( r( Y/ I) }
4. *        功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
   5 v9 P- ?, \. A  q
5. *        形    参: 无
   $ J2 t" v5 ~8 D
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. void bsp_InitKey(void)
   
10. {
    
11.         bsp_InitKeyVar();                /* 初始化按键变量 */
    
12.         bsp_InitKeyHard();                /* 初始化按键硬件 */
    
13. }

复制代码

下面是bsp_InitKeyVar函数的定义：

1. /*
   ! G9 M* J8 A: M) C# b
2. *********************************************************************************************************
   5 d% F% o, Y) [4 ]6 c' Y+ H, D2 ?
3. *        函 数 名: bsp_InitKeyVar
   
4. *        功能说明: 初始化按键变量
   
5. *        形    参:  无
   ( R- y0 I7 f( M$ A* A
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   % Y5 g/ K! Y0 Z- C/ Q
8. */
   
9. static void bsp_InitKeyVar(void)
   
10. {
    7 ?% A9 w/ i  V/ S& f. G
11.         uint8_t i;
    6 T1 I( j/ F: R( U0 x( ]
12. 
    
13.         /* 对按键FIFO读写指针清零 */
    4 i4 Q8 p* Z/ U" j, |
14.         s_tKey.Read = 0;
    
15.         s_tKey.Write = 0;
    
16.         s_tKey.Read2 = 0;
    
17. 
    
18.         /* 给每个按键结构体成员变量赋一组缺省值 */
    ' O/ H/ V) B, M9 W  F. j1 s. C
19.         for (i = 0; i < KEY_COUNT; i++)
    ! l+ A! p; p9 u% `  [
20.         {
    
21.                 s_tBtn<i>.LongTime = KEY_LONG_TIME;                        /* 长按时间 0 表示不检测长按键事件 */</i>
    
22. <span style="font-style: italic;">                s_tBtn.Count = KEY_FILTER_TIME / 2;                /* 计数器设置为滤波时间的一半 */
    - [( p% }# \( c$ M& @0 c& B8 B
23.                 s_tBtn<span style="font-style: italic;">.State = 0;                                                /* 按键缺省状态，0为未按下 */
    ' ]2 t& F& T, y0 w, e& u6 N
24.                 s_tBtn<span style="font-style: italic;">.RepeatSpeed = 0;                                        /* 按键连发的速度，0表示不支持连发 */
    - S+ H; r- x) C0 M/ P& e4 c
25.                 s_tBtn<i style="font-style: italic;">.RepeatCount = 0;                                        /* 连发计数器 */
    ; v, q- G$ e# w: K2 k
26.      </i><span style="font-style: normal;">   }
    1 e- q1 ^/ R+ V; g
27. 
    4 f- H# m+ f& r2 b
28.         /* 如果需要单独更改某个按键的参数，可以在此单独重新赋值 */
    ! S0 [) `) q* }8 U  A! |7 x
29.         
    
30.         /* 摇杆上下左右，支持长按1秒后，自动连发 */
    - k0 T. |( m% G
31.         bsp_SetKeyParam(KID_JOY_U, 100, 6);
    6 ]4 N6 W! U, a6 W8 j3 M% q7 G
32.         bsp_SetKeyParam(KID_JOY_D, 100, 6);
    6 ]2 |3 c  b, j/ O
33.         bsp_SetKeyParam(KID_JOY_L, 100, 6);
    
34.         bsp_SetKeyParam(KID_JOY_R, 100, 6);
    ) e" d4 `" j% G( C0 q
35. }</span></span></span></span>

复制代码

" |5 [) m, v1 y4 Y3 l+ Q" N注意一下 Count 这个成员变量，没有设置为0。为了避免主板上电的瞬间，检测到一个无效的按键按下或弹起事件。我们将这个滤波计数器的初值设置为正常值的1/2。bsp_key.h中定义了滤波时间和长按时间。
( q1 W6 g. |! n5 w

1. /*
   4 G0 V: T) e# @' F& Y. o
2.         按键滤波时间50ms, 单位10ms。
   3 u. T3 t: e3 A7 ]+ I) O7 x3 Z
3.         只有连续检测到50ms状态不变才认为有效，包括弹起和按下两种事件
   
4.         即使按键电路不做硬件滤波，该滤波机制也可以保证可靠地检测到按键事件
   
5. */
   
6. #define KEY_FILTER_TIME   5
   
7. #define KEY_LONG_TIME     100                        /* 单位10ms， 持续1秒，认为长按事件 */

复制代码

" a  O$ l% G0 b& ~. o& K: vuint8_t KeyPinActive(uint8_t _id)（会调用函数KeyPinActive判断状态）函数就是最底层的GPIO输入状态判断函数。
; N, D- y- Y% |6 R

1. /*
   
2. *********************************************************************************************************
   " z4 D. d/ q4 @3 L$ Y+ A7 {& b
3. *        函 数 名: KeyPinActive
   0 }% I- ~1 F: y" m* }( u
4. *        功能说明: 判断按键是否按下
   " e/ q! v4 O4 f" G( Y0 z
5. *        形    参: 无
   
6. *        返 回 值: 返回值1 表示按下(导通），0表示未按下（释放）
   # W- D7 H( z+ u5 p3 Q; ]- w! b
7. *********************************************************************************************************
   : D6 {  ]9 U% y6 I' N- h4 t
8. */
   . k" ~; @6 x- e5 m, n3 v# E
9. static uint8_t KeyPinActive(uint8_t _id)
   5 V) Y' s; }- A" _
10. {
    
11.         uint8_t level;
    3 Z" ]5 B8 O  v9 @4 I. X. @
12.         
    
13.         if ((s_gpio_list[_id].gpio->IDR & s_gpio_list[_id].pin) == 0)
    
14.         {
    & j. \) T* F" ?+ @0 p
15.                 level = 0;
    
16.         }
    4 |1 S4 C, k: Y6 G/ F% Z. Z+ {8 g# S
17.         else
    " p, U2 U$ y8 ?; A5 W
18.         {
    
19.                 level = 1;
    , _5 v$ C0 W. e6 p& |# I
20.         }
    ( B2 D3 z: u) F4 l: W% X3 ?
21. 
    
22.         if (level == s_gpio_list[_id].ActiveLevel)
    
23.         {
    
24.                 return 1;
    
25.         }
    
26.         else
    3 a) [+ x# W' n/ t/ w
27.         {
    
28.                 return 0;
    
29.         }
    : j* M' j) D4 G2 N+ |; {0 s
30. }
    
31. 
    $ H3 Q+ d5 h- ]( L' s3 f& _# C
32. /*
    
33. *********************************************************************************************************
    
34. *        函 数 名: IsKeyDownFunc
    ( X" `( L4 V9 y( v8 S$ u
35. *        功能说明: 判断按键是否按下。单键和组合键区分。单键事件不允许有其他键按下。
    
36. *        形    参: 无
    : Y1 y1 i0 F' g3 {9 u
37. *        返 回 值: 返回值1 表示按下(导通），0表示未按下（释放）
    
38. *********************************************************************************************************
    
39. */
    
40. static uint8_t IsKeyDownFunc(uint8_t _id)
    / Y1 O9 |5 P/ G' Z% [
41. {
    ; E' u' r' q2 D  E* P
42.         /* 实体单键 */
    
43.         if (_id < HARD_KEY_NUM)
    
44.         {
    - v$ u/ m( c3 ~/ T* w$ s2 T
45.                 uint8_t i;
    9 K: w* V. ~2 C0 T5 R) [
46.                 uint8_t count = 0;
    
47.                 uint8_t save = 255;
    1 v: Z% L: W/ o& T9 ^  ~* n1 u* z3 g
48.                
    ' P6 H  Y  R8 e8 ]5 w4 Q1 P: W
49.                 /* 判断有几个键按下 */
    
50.                 for (i = 0; i < HARD_KEY_NUM; i++)
    4 B7 U2 |: \2 k) i8 O6 w
51.                 {
    
52.                         if (KeyPinActive(i))
    
53.                         {
    0 ~5 v7 D2 s$ V) p- F
54.                                 count++;
    & q; \# @1 K: R- k& e. m
55.                                 save = i;
    
56.                         }
    
57.                 }
    
58.                
    ) y8 o$ e% G( X8 s& R9 v
59.                 if (count == 1 && save == _id)
    ) |+ h& U- M$ [% f- a
60.                 {
    5 U0 ]* _4 r, T0 V) E3 i6 ?9 O
61.                         return 1;        /* 只有1个键按下时才有效 */
    - n# Z) [, \9 E! W2 l5 _
62.                 }               
    
63. 
    
64.                 return 0;
    
65.         }
    7 |% d* k1 C; E( T/ c5 Y
66.         
    
67.         /* 组合键 K1K2 */
    
68.         if (_id == HARD_KEY_NUM + 0)
    ! s; U9 G' d( ?
69.         {
    
70.                 if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
    & I" ~: U% F. V' U$ W  I
71.                 {
    
72.                         return 1;
    
73.                 }
    & ?( Q" I5 w. T! N2 Q
74.                 else
    
75.                 {
    
76.                         return 0;
    8 r! v/ c" a% ~# K4 J
77.                 }
    
78.         }
    - b1 g$ N! u2 B9 ~3 `: M% b: n( o8 _
79. 
    
80.         /* 组合键 K2K3 */
    8 Y5 v+ T, m8 P4 K" O
81.         if (_id == HARD_KEY_NUM + 1)
    , c. g' H! C& V5 ]
82.         {
    
83.                 if (KeyPinActive(KID_K2) && KeyPinActive(KID_K3))
    . w3 ?" c. L6 i
84.                 {
    
85.                         return 1;
    ) E2 [" a$ }! l9 b. k9 L6 T
86.                 }
    
87.                 else
    8 e2 l$ g7 @1 f: X  [. S
88.                 {
    % U& T$ z' Z$ [1 x( y( {
89.                         return 0;
    
90.                 }
    
91.         }
    
92. 
    
93.         return 0;
    $ T6 x( b# r/ B7 L: S& B* h( e4 W
94. }

复制代码

在使用GPIO之前，我们必须对GPIO进行配置，比如打开GPIO时钟，设置GPIO输入输出方向，设置上下拉电阻。下面是配置GPIO的代码，也就是bsp_InitKeyHard（）函数：
/ k* G8 q+ m. k# @8 f
/ e2 ~# j! m$ @* u1 v

1. /*
   # E6 |1 A% k# |( l, ]1 g/ ]5 P
2. *********************************************************************************************************
   / `0 O$ d6 G, }7 D6 h( `
3. *        函 数 名: bsp_InitKeyHard
   
4. *        功能说明: 配置按键对应的GPIO
   
5. *        形    参:  无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   
8. */
   
9. static void bsp_InitKeyHard(void)
   # G  p( i' W. A& k9 J- o! o
10. {        
    5 F4 }& G/ X- ]! S' Z0 x7 A
11.         GPIO_InitTypeDef gpio_init;
    ; k* X. G8 j$ F: g5 Y, h+ g: P" v0 g
12.         uint8_t i;
    , t9 N8 h% y, U% K0 q8 `
13. 
    ' L7 p" N1 h9 Q
14.         /* 第1步：打开GPIO时钟 */
    
15.         ALL_KEY_GPIO_CLK_ENABLE();
    6 c9 v" \) q+ ~7 |$ \
16.         
    0 R  n- j/ b4 ^* x8 H3 C
17.         /* 第2步：配置所有的按键GPIO为浮动输入模式(实际上CPU复位后就是输入状态) */
    7 Z! b& Z9 R( N# @
18.         gpio_init.Mode = GPIO_MODE_INPUT;                           /* 设置输入 */
    & W9 r0 \5 u5 P& ]6 x6 R
19.         gpio_init.Pull = GPIO_NOPULL;                 /* 上下拉电阻不使能 */
    
20.         gpio_init.Speed = GPIO_SPEED_FREQ_VERY_HIGH;  /* GPIO速度等级 */
    
21.         
    - P  D" R  G( e4 l" p" N
22.         for (i = 0; i < HARD_KEY_NUM; i++)
    
23.         {
    
24.                 gpio_init.Pin = s_gpio_list<span style="font-style: italic;"><span style="font-style: normal;">.pin;
    : x: ?: z2 I4 C. R2 h; {: V
25.                 HAL_GPIO_Init(s_gpio_list</span><span style="font-style: normal;">.gpio, &gpio_init);        
    
26.         }
    
27. }</span></span>

复制代码

# P- \/ C4 f* P我们再来看看按键是如何执行扫描检测的。

# }6 u( ]" f& H按键扫描函数bsp_KeyScan10ms ()每隔10ms被执行一次。bsp_RunPer10ms函数在systick中断服务程序中执行。

1. void bsp_RunPer10ms(void)
   9 U: X% f- L- N
2. {
   , R. t- \. l0 X2 @& A0 C9 c
3.         bsp_KeyScan10ms();                /* 扫描按键 */
   ) F2 }  e! l- K$ x- b- }
4. }

复制代码

; j) i0 |* C% ^, c3 g( `" e' C" [bsp_KeyScan10ms ()函数的实现如下：

+ Y  G" D& m8 d2 y, t1 z: h% \* O

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_KeyScan10ms
   
4. *        功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
   1 Z) y% \( x" Y. B: x5 o! q
5. *        形    参: 无
   
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   # d" ]$ P( N+ m4 @3 a; u- ?
8. */
   
9. void bsp_KeyScan10ms(void)
   1 W- a& t$ I# S& f2 P+ t
10. {
    ! n, L; m7 @5 R  z; w
11.         uint8_t i;
    
12. 
    
13.         for (i = 0; i < KEY_COUNT; i++)
    * Z7 l4 f  h  q  S% O
14.         {
    - b$ L& F5 a7 \3 y1 |6 }, q
15.                 bsp_DetectKey(i);
    " U8 n9 _0 A) a' x' ^+ z
16.         }
    
17. }

复制代码

每隔10ms所有的按键GPIO均会被扫描检测一次。bsp_DetectKey函数实现如下：
! X+ q8 u# J; z7 L
- @; W) t! B# \

1. /*
   
2. *********************************************************************************************************
   0 t0 x0 A% u' f9 v% o( g; s
3. *        函 数 名: bsp_DetectKey
   * B; ^3 L1 X7 O' H! j. x# G! M' s
4. *        功能说明: 检测一个按键。非阻塞状态，必须被周期性的调用。
   * _* E, _, c: k7 A6 D
5. *        形    参: IO的id， 从0开始编码
   
6. *        返 回 值: 无
   ( t) C( b( ]  Z+ b1 ]
7. *********************************************************************************************************
   
8. */
   
9. static void bsp_DetectKey(uint8_t i)
   " D. a( T9 P1 p. ]1 k4 \( }! j
10. {
    
11.         KEY_T *pBtn;
    + [( T( c- c& I" R% _' {
12. 
    " m- U8 `2 i7 ~2 V6 c
13.         pBtn = &s_tBtn<span style="font-style: italic;"><span style="font-style: normal;">;
    / A  l! A1 d/ Y) p
14.         if (IsKeyDownFunc(i))
    
15.         {
    " q9 }+ X2 q4 Y, a& g; v. X
16.                 if (pBtn->Count < KEY_FILTER_TIME)
    5 ]4 @5 s! i3 d4 c) y
17.                 {
    # v# G" f! G) Q/ m- I' S, l; M
18.                         pBtn->Count = KEY_FILTER_TIME;
    2 c# V' b+ e% U- {* G8 h2 S
19.                 }
    
20.                 else if(pBtn->Count < 2 * KEY_FILTER_TIME)
    % u$ @2 Y5 `8 d3 A
21.                 {
    
22.                         pBtn->Count++;
    
23.                 }
    
24.                 else
    
25.                 {
    
26.                         if (pBtn->State == 0)
    5 K5 D9 G# [& o$ S' {
27.                         {
    & F. f+ w" m. k0 `5 d( W! P" @
28.                                 pBtn->State = 1;
    , t# r+ G  s& I. Q. ~5 W' x* w  j
29. 
    5 ~% q! R7 F; q5 j
30.                                 /* 发送按钮按下的消息 */
    
31.                                 bsp_PutKey((uint8_t)(3 * i + 1));
    
32.                         }
    3 t5 b& z1 e2 Y$ j6 _; g* q1 r
33. 
    
34.                         if (pBtn->LongTime > 0)
    
35.                         {
    ) G" |4 Q' a/ s- R* U" t5 ?9 r
36.                                 if (pBtn->LongCount < pBtn->LongTime)
    / R: I- X' t' L$ F% b
37.                                 {
    + x* }6 s% x0 u5 ]
38.                                         /* 发送按钮持续按下的消息 */
    
39.                                         if (++pBtn->LongCount == pBtn->LongTime)
    
40.                                         {
    
41.                                                 /* 键值放入按键FIFO */
    
42.                                                 bsp_PutKey((uint8_t)(3 * i + 3));
    
43.                                         }
    % t5 H. K, o2 J4 r) {
44.                                 }
    
45.                                 else
    , v0 e6 u0 t/ c" \/ y! z) \
46.                                 {
    % C7 V/ F/ d  D/ j7 R
47.                                         if (pBtn->RepeatSpeed > 0)
    
48.                                         {
    " Y) x2 r- U/ |0 Z$ r& G+ V
49.                                                 if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
    ! ~4 H5 r0 w( {9 n) L3 s
50.                                                 {
    
51.                                                         pBtn->RepeatCount = 0;
    ! Z7 K3 _# Z, v( T8 {! L; w0 V4 q5 J
52.                                                         /* 常按键后，每隔RepeatSpeed * 10ms发送1个按键 */
    * s0 |# ~: A. I+ I
53.                                                         bsp_PutKey((uint8_t)(3 * i + 1));
    8 q! p1 O, `' M: P7 E
54.                                                 }
    
55.                                         }
    
56.                                 }
    
57.                         }
    - W' v  i$ h+ D
58.                 }
    3 e8 `0 S# D6 Y% N( P. p% y7 k7 t
59.         }
    
60.         else
    % j: s' @: Y, e
61.         {
      y2 q8 C$ c+ Q5 i. t
62.                 if(pBtn->Count > KEY_FILTER_TIME)
    $ O  s* ]+ ^5 P
63.                 {
    
64.                         pBtn->Count = KEY_FILTER_TIME;
    2 r: v* H; }$ e& R; d' f
65.                 }
    : B3 [2 d' A( h
66.                 else if(pBtn->Count != 0)
    ) a9 n! @5 C0 d7 q$ P( b, \
67.                 {
    
68.                         pBtn->Count--;
    
69.                 }
    
70.                 else
    
71.                 {
    
72.                         if (pBtn->State == 1)
    
73.                         {
    9 {5 m) O+ v9 j; q4 m$ M6 a% S1 T" J+ k' ]
74.                                 pBtn->State = 0;
    
75. 
    
76.                                 /* 发送按钮弹起的消息 */
    
77.                                 bsp_PutKey((uint8_t)(3 * i + 2));
    
78.                         }
    
79.                 }
    ' b4 o, s* v8 b0 ~6 S! \) s! `; U5 g
80. 
    5 @& F' L+ U. r( ?% a7 ]
81.                 pBtn->LongCount = 0;
    ; h* d3 ?9 p7 y! H$ z
82.                 pBtn->RepeatCount = 0;
    & T$ ~; _1 U  k! j: ~* o
83.         }
    
84. }</span></span>

复制代码

对于初学者，这个函数看起来比较吃力，我们拆分进行分析。
3 u( Z8 I5 i  {5 i8 G

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

复制代码

: r. N( f  {& {读取相应按键的结构体地址，程序里面每个按键都有自己的结构体。
' w; M2 f4 v4 I$ S

1. static KEY_T s_tBtn[KEY_COUNT];
   
2. if (IsKeyDownFunc(i))
   , m' |3 ]# t$ I; V+ g3 \9 O
3. {
   # [7 `: S$ d/ [( s% q
4.         这个里面执行的是按键按下的处理
   
5. }
   
6. else
   
7. {
   
8.         这个里面执行的是按键松手的处理或者按键没有按下的处理
   8 V/ H. b3 |# ~7 e9 g& V- F
9. }

复制代码

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

1. /*
   
2. **********************************************************************************
   
3. 下面这个if语句主要是用于按键滤波前给Count设置一个初值，前面说按键初始化的时候
   " m  Y5 s1 h6 G5 d1 F3 t, j
4. 已经设置了Count = KEY_FILTER_TIME/2
   2 q7 O9 ^$ i' `% A
5. **********************************************************************************
   
6. */
   
7. if (pBtn->Count < KEY_FILTER_TIME)
   
8. {
   - Y3 y. U  B+ [
9.     pBtn->Count = KEY_FILTER_TIME;
   
10. }
    
11. 
    ' G' \7 D" A1 e
12. /*
    9 S( L* T/ ^" c& j! w( {  K% V
13. **********************************************************************************
    
14. 这里实现KEY_FILTER_TIME时间长度的延迟
    ; Q) }; F9 Z( H, Q
15. **********************************************************************************
    
16. */
    
17. else if(pBtn->Count < 2 * KEY_FILTER_TIME)
    7 n( Z6 g  |+ K( O( h$ R7 h, C
18. {
    
19.     pBtn->Count++;
    
20. }
    & z: F2 x0 N0 z% l! m5 h( b0 H
21. /*
    
22. **********************************************************************************
    $ m+ t$ }2 ]! X1 N9 ]
23. 这里实现KEY_FILTER_TIME时间长度的延迟
    . m; F. q% h, N
24. **********************************************************************************
    
25. */
    
26. else
    
27. {
    5 v4 w( S- l, c# V
28. /*
    + k- Y; ?3 V1 _, `  x
29. **********************************************************************************
    ; C7 k1 f! C& O& h  Y& U/ |# S6 a
30. 这个State变量是有其实际意义的，如果按键按下了，这里就将其设置为1，如果没有按下这个
    
31. 变量的值就会一直是0，这样设置的目的可以有效的防止一种情况的出现：比如按键K1在某个
    
32. 时刻检测到了按键有按下，那么它就会做进一步的滤波处理，但是在滤波的过程中，这个按键
    
33. 按下的状态消失了，这个时候就会进入到上面第二步else语句里面，然后再做按键松手检测滤波
    " \/ k  G1 b- z
34. ，滤波结束后判断这个State变量，如果前面就没有检测到按下，这里就不会记录按键弹起。
    
35. **********************************************************************************
    
36. */
    $ G4 @. j* l  X! _+ `
37.     if (pBtn->State == 0)
    
38.     {
    ; }) u% x9 m3 U: k3 f, \3 A
39.         pBtn->State = 1;
    
40. 
    ( N" I  A, P5 I( i" b' G! D
41.         /* 发送按钮按下的消息 */
      l9 ?/ p5 p, i$ _1 _* Y
42.         bsp_PutKey((uint8_t)(3 * i + 1));
    * W, ?1 O0 V1 s
43.     }
    8 ~: c$ I0 ]% [; W" U! s1 |2 J
44. 
    ' k/ {# ^% r% t8 K8 l0 p0 m+ F
45.     if (pBtn->LongTime > 0)
    
46.     {
    + n3 H; U6 Y2 D
47.         if (pBtn->LongCount < pBtn->LongTime)
    
48.         {
    3 v7 t6 }; E6 {7 P& B7 u0 ^
49.             /* 发送按钮持续按下的消息 */
    / P* r  _( k% n: }
50.             if (++pBtn->LongCount == pBtn->LongTime)
    
51.             {
    : f- a6 W7 T+ {% x  v
52.                 /* 键值放入按键FIFO */
    & _1 _! X/ w; t: K& M0 @) K7 c  O; q+ N
53.                 bsp_PutKey((uint8_t)(3 * i + 3));
    7 q1 k1 c( s' q+ Z4 U4 g
54.             }
    7 Q* T0 \+ d5 G3 s$ ^
55.         }
    
56.         else
    / U  c" \5 v1 s  I$ W3 N
57.         {
    , N  o% Z' f  u7 c
58.             if (pBtn->RepeatSpeed > 0)
    
59.             {
    8 l$ o" b8 s) s5 s
60.                 if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
    1 N) e; Z" t5 @
61.                 {
    
62.                     pBtn->RepeatCount = 0;
    
63.                     /* 长按键后，每隔10ms发送1个按键 */
    9 S4 A9 D5 S7 x' K3 S& n9 @
64.                     bsp_PutKey((uint8_t)(3 * i + 1));
    % Z% ~( u4 Z2 E( A: ]5 J9 V  I( e
65.                 }
    + O  t, I: Y* V9 G5 M, h* O
66.             }
    
67.         }
    
68.     }
    
69. }

复制代码

( \5 e* X- i( N  e( \2 f7 `- p19.3.4 按键检测采用中断方式还是查询方式
检测按键有中断方式和GPIO查询方式两种。我们推荐大家用GPIO查询方式。

从裸机的角度分析
  f3 }" n! u, d  k; t. c1 K, r
2 R1 o$ s5 B1 d) X4 e中断方式：中断方式可以快速地检测到按键按下，并执行相应的按键程序，但实际情况是由于按键的机械抖动特性，在程序进入中断后必须进行滤波处理才能判定是否有效的按键事件。如果每个按键都是独立的接一个IO引脚，需要我们给每个IO都设置一个中断，程序中过多的中断会影响系统的稳定性。中断方式跨平台移植困难。

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

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

  q. W* H& o- O: A$ v( P1 w查询方式：对于用户按键推荐使用这种查询方式来实现，现在的OS基本都带有CPU利用率的功能，这个按键FIFO占用的还是很小的，基本都在1%以下。

( ?) x# T( V, O/ N7 a% q9 i19.4 按键板级支持包（bsp_key.c）
' ?5 q! B3 x* A5 M按键驱动文件bsp_key.c主要实现了如下几个API：

  KeyPinActive
  IsKeyDownFunc
  bsp_InitKey
  bsp_InitKeyHard
  bsp_InitKeyVar
: o) a; }  V. h4 r. o6 e  bsp_PutKey
  bsp_GetKey
  bsp_GetKey2
7 L7 B" q) Y+ P, i: ?4 p/ K  bsp_GetKeyState
  bsp_SetKeyParam
5 P2 v4 ?6 o+ i  g/ _6 R7 n  bsp_ClearKey
( k1 {# A" o- O& t  bsp_DetectKey
  bsp_DetectFastIO
% P! v/ Y! F, w8 s3 G8 ~7 {  bsp_KeyScan10ms
3 t7 m, v( s$ h1 N. e  bsp_KeyScan1ms

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

19.4.1 函数bsp_InitKeyHard
2 B. V* s" o' j4 g4 [. m函数原型：

" o- C6 O! d% f2 i

1. /*
   # ]" E  z' J4 `& C" Y2 @* |
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_InitKey
   ; u( O$ c7 _$ X3 R+ |
4. *        功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
   
5. *        形    参: 无
   ' \+ j& @! A4 n
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   7 v) K- u7 d3 w; {0 r6 n# {3 C$ ~
8. */
   " F, ]9 X) r0 M2 h. p$ k
9. void bsp_InitKey(void)
   
10. {
    
11.         bsp_InitKeyVar();                /* 初始化按键变量 */
    
12.         bsp_InitKeyHard();                /* 初始化按键硬件 */
    7 H! G$ P1 g/ I! h2 m0 X4 O
13. }

复制代码

函数描述：

此函数主要用于按键的初始化。

) w$ z1 i% B. A& e0 V# _1 a* Q使用举例：

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

7 O1 e3 m& {- r# s19.4.2 函数bsp_GetKey
% K/ j/ `" P2 k# b3 D/ ?函数原型：
' l# |, U, q% H9 B) t8 @! b

1. /*
   
2. *********************************************************************************************************
   - L. d7 f( g& u& y8 x4 T9 f
3. *        函 数 名: bsp_GetKey
   
4. *        功能说明: 从按键FIFO缓冲区读取一个键值。
   $ \7 a  ]7 n# |4 w4 v& J0 `
5. *        形    参: 无
   
6. *        返 回 值: 按键代码
   ! ^; {/ D: g8 ]5 j; P0 A
7. *********************************************************************************************************
   
8. */
   
9. uint8_t bsp_GetKey(void)
   
10. {
    9 S1 T1 K+ q, N* m. J7 r
11.         uint8_t ret;
    : D: M" c- p+ t8 x3 G7 y
12. 
    3 t* z+ s% P# d( V7 L  @& z
13.         if (s_tKey.Read == s_tKey.Write)
    $ b. A9 d: f. f2 S) ^
14.         {
    " C  ?: H8 f* a' V% t1 K6 q
15.                 return KEY_NONE;
    ! H9 q# R2 a$ R: _! r  Y
16.         }
    % u  [  O7 h! Y' T
17.         else
    
18.         {
    
19.                 ret = s_tKey.Buf[s_tKey.Read];
    7 u( ]6 ?) |' o5 r* \8 q! I
20. 
    
21.                 if (++s_tKey.Read >= KEY_FIFO_SIZE)
    # f. A6 W2 S2 p
22.                 {
    - `: o+ g- d- ^2 T7 {8 P
23.                         s_tKey.Read = 0;
    
24.                 }
    
25.                 return ret;
    
26.         }
    
27. }

复制代码

/ }* \' I; m! J函数描述：

" D4 M# V/ Z  C' p$ J2 q( i此函数用于从FIFO中读取键值。

* l/ P0 o3 j2 D$ K; I1 k1 S: C: |6 `( ^3 e使用举例：
8 L, y$ k7 \7 }1 `- u
调用此函数前，务必优先调用函数bsp_InitKey进行初始化。
7 C4 X: I7 L: K
: |. C) Y0 _0 Q  W! J) g1 v

1. /*
   , r% c5 g1 s7 U
2. *********************************************************************************************************
   
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   8 Y; N0 C4 N! k. v& b/ g7 R
5. *        形    参: 无
   $ J' \2 o& A+ S; p9 k" S, z
6. *        返 回 值: 错误代码(无需处理)
   1 f) V3 Y* Q, h8 D; F; o
7. *********************************************************************************************************
   
8. */
   
9. int main(void)
   
10. {
    # L# s7 p- ~9 Q( K+ X6 C2 _" Z
11.         uint8_t ucKeyCode;                /* 按键代码 */
    
12.         
    4 b$ d1 n/ M, R) N0 P7 o, j
13.         bsp_Init();                /* 硬件初始化 */
    
14.         
    
15.         /* 进入主程序循环体 */
    ; N( R( N' R! Z+ l: q6 Q$ @- H3 R
16.         while (1)
    9 ?, a! b/ o) Q8 l" s$ N3 @
17.         {               
    4 `2 f6 C  _5 \; |4 e% X$ H
18.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
      p) x$ R) |8 p
19.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    ' x  h& m5 ]. M/ f* Q
20.                 if (ucKeyCode != KEY_NONE)
    % G6 }' F! {! M+ E# `- |. \) i$ P
21.                 {
    
22.                         switch (ucKeyCode)
    # W+ D# R2 _2 a  J0 w
23.                         {
    
24.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    
25.                                         printf("K1键按下\r\n");
    
26.                                         break;
    2 h, T1 t8 \- E3 W, E0 w2 }, p
27. 
    
28.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    
29.                                         printf("K2键按下\r\n");
    : a( Z( h% Z& x0 Y- m
30.                                         break;
    * j: {8 C# n3 I9 [
31. 
    ( ?) h' t! E* J+ q
32.                                 default:
    
33.                                         /* 其它的键值不处理 */
    
34.                                         break;
    ) }0 r- ]  A$ R! \% i" M2 Z3 E
35.                         }
    
36.                 }
    
37.         }
    
38. }

复制代码

19.4.3 函数bsp_KeyScan10ms
函数原型：
4 \. J) t$ w/ [- ?
1 q& m0 }) p9 X* M" A* i. I3 l

1. /*
   
2. *********************************************************************************************************
   * Y. w9 a. C2 O( B- {6 u0 O! T
3. *        函 数 名: bsp_KeyScan10ms
   
4. *        功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
   % Y  a$ {. U+ {; H" f9 O
5. *        形    参: 无
   # {3 y. I6 j" Q
6. *        返 回 值: 无
   / H9 `  `, {, S6 W
7. *********************************************************************************************************
   
8. */
   ! o; M; D) p3 v2 j# p
9. void bsp_KeyScan10ms(void)
   1 Q2 ?1 h1 P) A1 e! D* h( T
10. {
    1 O7 D7 t0 X2 A1 c4 [
11.         uint8_t i;
    9 N4 f" y0 q+ k; h+ K
12. 
    
13.         for (i = 0; i < KEY_COUNT; i++)
    
14.         {
    4 e$ n, Z4 z4 q2 k  h2 p
15.                 bsp_DetectKey(i);
    
16.         }
    
17. }

复制代码

函数描述：
  B+ j+ n) h2 A2 k, P/ f
此函数是按键的主处理函数，用于检测和存储按下、松手、长按等状态。
) Q9 i) S$ h! w( O' f3 c
0 Y# C( c! m, C% ~* C- u使用举例：

7 a3 v3 V" @+ L( t) R* f调用此函数前，务必优先调用函数bsp_InitKey进行初始化。

' z( E2 `2 O9 P# V/ ?3 ?另外，此函数需要周期性调用，每10ms调用一次。
5 v4 e4 c" \+ y2 |) i* U+ [
4 C/ x6 X+ ~* [' ~9 A* ?* l  如果是裸机使用，将此函数放在bsp.c文件的bsp_RunPer10ms函数里面即可，这个函数是由滴答定时器调用的，也就是说，大家要使用按键，定时器的初始化函数bsp_InitTimer一定要调用。
  如果是RTOS使用，需要开启一个10ms为周期的任务调用函数bsp_KeyScan10ms。

3 a) C+ p4 y8 w1 ~" T8 _; \19.5 按键FIFO驱动移植和使用
3 g0 S4 W  l' l+ T% P- p按键移植步骤如下：

  第1步：复制bsp_key.c和bsp_key.c到自己的工程。
  第2步：根据自己使用的独立按键个数和组合键个数，修改几个地方。
: ?7 C9 w# c3 V! N

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

复制代码

  第3步：根据使用的引脚时钟，修改下面函数：
. E, U8 a9 k& v% G! A

1. /* 使能GPIO时钟 */
   
2. #define ALL_KEY_GPIO_CLK_ENABLE() {        \
   9 m$ y0 Y" g: V
3.                 __HAL_RCC_GPIOB_CLK_ENABLE();        \
   " h( ?  P/ o" x9 Q# C2 v2 x
4.                 __HAL_RCC_GPIOC_CLK_ENABLE();        \
   7 d) l* n7 W" u! H2 M4 O' U; S: H! W
5.                 __HAL_RCC_GPIOG_CLK_ENABLE();        \
   
6.                 __HAL_RCC_GPIOH_CLK_ENABLE();        \
   5 A4 ~9 D& ~5 E: z4 Q0 w- |
7.                 __HAL_RCC_GPIOI_CLK_ENABLE();        \
   
8.         };

复制代码

  第4步：根据使用的具体引脚，修改如下函数，第3列参数低电平表示按下或者高电平表示按下：
  f9 [' u: r* m$ R3 h9 _

1. /* GPIO和PIN定义 */
   . Q9 v" l! T2 o
2. static const X_GPIO_T s_gpio_list[HARD_KEY_NUM] = {
   $ b; J. z' l: r% z; R& P
3.         {GPIOI, GPIO_PIN_8, 0},                /* K1 */
   $ w( g( T: b3 O$ j4 U$ K/ v
4.         {GPIOC, GPIO_PIN_13, 0},        /* K2 */
   % z" q! L1 ~& R! H& l. ~+ m
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 z  U8 q8 _
9.         {GPIOG, GPIO_PIN_7, 0},                /* JOY_R */        
   & u7 P1 f: w; x/ g. n. h5 c
10.         {GPIOI, GPIO_PIN_11, 0},        /* JOY_OK */
    
11. };   

复制代码

     
  第5步：根据使用的组合键个数，在函数IsKeyDownFunc里面添加相应个数的函数：
- b6 t. z* Y' S/ z7 N# K

1.         /* 组合键 K1K2 */
   + d/ j/ p: {' Z& ]  e% m
2.         if (_id == HARD_KEY_NUM + 0)
   4 b  X* p1 O' O, c! i
3.         {
   
4.                 if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
   
5.                 {
   + h& Q" H, l+ ^' o% `
6.                         return 1;
   : c0 `5 S, ^3 L0 g9 j/ _
7.                 }
   9 A+ E$ K; E3 g$ D; F
8.                 else
     c( L# A9 k+ y0 Q
9.                 {
   
10.                         return 0;
    
11.                 }
    - K5 _: D/ X/ J! L' t, g1 @+ G- _, }7 s0 H
12.         }

复制代码

第2行ID表示HARD_KEY_NUM + 0的组合键，HARD_KEY_NUM + 1表示下一个组合键，以此类推。
% c5 d9 [. E$ O$ Y0 G' @
另外就是，函数KeyPinActive的参数是表示检测哪两个按键，设置0的时候表示第4步里面的第1组按键，设置为1表示第2组按键，以此类推。
5 x7 r# f( Z/ p$ o+ h0 R) t0 ^
0 X! S. f  g- ]0 m  第6步：主要用到HAL库的GPIO驱动文件，简单省事些可以添加所有HAL库.C源文件进来。
  第7步：移植完整，应用方法看本章节配套例子即可。
特别注意，别忘了每10ms调用一次按键检测函数bsp_KeyScan10ms。

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

2 _; F: y8 o6 `+ W+ P! w# w
' x4 V" ]" i' Y& ` 1、 第1阶段，上电启动阶段：
6 ]/ M) v  s9 }6 v  _; P" j! G
这部分在第14章进行了详细说明。

2、 第2阶段，进入main函数：

  第1部分，硬件初始化，主要是MPU、Cache、HAL库、系统时钟、滴答定时器、按键等。
4 S. W. M  s. ?7 r/ m9 [( H! ^  i  第2部分，应用程序设计部分，实现了一个按键应用。
  第3部分，按键扫描程序每10ms在滴答定时中断执行一次。
7 @( a9 S  |5 v2 v( }5 T( S; t
0 _6 N* g0 D5 l9 d. ]8 j, g3 e" R19.7 实验例程说明（MDK）
配套例子：
/ l  T1 {" M8 B" YV7-002_按键检测（软件滤波，FIFO机制）
; j& C+ v" ?1 I/ y6 a# e! P% r
- Q/ a# p- O$ I2 y! N6 G实验目的：
0 S3 @! x7 g1 U  Z学习按键的按下，弹起，长按和组合键的实现。
6 M& U4 b/ ^: q
! u0 u0 `0 d9 X7 `9 t实验内容：
启动一个自动重装软件定时器，每100ms翻转一次LED2。
! H9 Y9 B$ F3 F! X0 S& L# r
2 y4 I6 M' [9 }( }) S0 v实验操作：
4 ~- r4 \: |& |' K$ P3个独立按键和5向摇杆按下时均有串口消息打印。
, A1 y9 ]8 G. U% o1 O5向摇杆的左键和右键长按时，会有连发的串口消息。
. a. R+ J9 U9 q/ m( |# @独立按键K1和K2按键按下，串口打印消息。

上电后串口打印的信息：

波特率 115200，数据位 8，奇偶校验位无，停止位 1
0 Z. W$ [" N# j9 a7 p
+ I7 o1 H: o: g  ]

1 l$ ~$ q" C% s1 f程序设计：
) @& L5 P% r1 I. H
  系统栈大小分配：
* A1 {6 S) {" c; N- T: D% I0 {

  RAM空间用的DTCM：

" ^0 b& L) W0 g1 G/ B5 i

1 k' r" F2 Z+ ~7 z; r& X  K2 @9 w
. s* ~1 o- _+ {6 D0 H6 G  硬件外设初始化

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

- s9 y- G* P0 [

1. /*
   ) u$ r5 }* ?5 }$ H" y7 V
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   " @- p* a; C( G/ s! z. k" b
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   
5. *        形    参：无
   
6. *        返 回 值: 无
   3 y) f6 H9 k# t$ ~. Q4 s5 w! z3 m8 z
7. *********************************************************************************************************
   3 T( \) G, F/ U% Z2 W, _: f
8. */
   
9. void bsp_Init(void)
   ' P9 d: ^; k  X) x8 c8 u5 F5 ]- E
10. {
    
11.     /* 配置MPU */
    4 T! U. k' \/ a3 A( r! Z- t( U( N
12.         MPU_Config();
    
13.         
    
14.         /* 使能L1 Cache */
    ) {3 b' N4 N% U, H
15.         CPU_CACHE_Enable();
    ' q0 C& m" T2 g/ f! t+ h. k& s
16. 
    
17.         /*
    
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    
20.            - 设置NVIV优先级分组为4。
    3 E' y8 Q1 R9 x# W& N- e. @$ L' d  ^, E: k
21.          */
    
22.         HAL_Init();
    : i. [* T3 k1 a/ q8 X7 Q* }
23. 
    6 g9 C2 p6 k9 j) n  @
24.         /*
    * }0 P/ [, u7 Q% |* f5 k
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    
28.     */
    
29.         SystemClock_Config();
      C" r8 `, t6 c9 H
30. 
    4 A( @1 L! h( n9 I+ l
31.         /*
    
32.            Event Recorder：
      G+ Z" f  k8 R6 o9 p
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    
36. #if Enable_EventRecorder == 1  
    
37.         /* 初始化EventRecorder并开启 */
    6 h1 m# p( j% T! F& M
38.         EventRecorderInitialize(EventRecordAll, 1U);
    9 r) D# u' L& W
39.         EventRecorderStart();
    6 R/ U# ~* A# ?, `$ {  r! k% K
40. #endif
    ; C! m9 L7 {- g
41.         
    ' R$ ?: Z$ X6 u; Q' q
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
    
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    * l& l7 \/ t3 t- d
44.         bsp_InitUart();        /* 初始化串口 */
    
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

  MPU配置和Cache配置：

, s! }  O9 h' o0 a# L0 i2 S" p数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
# z: U, k. B" z. h

1. /*
   4 s- C# R  n4 B* K1 B
2. *********************************************************************************************************
   . ~2 p9 Z( A. K
3. *        函 数 名: MPU_Config
   
4. *        功能说明: 配置MPU
   # w+ d( ~, E5 n4 X5 c  ~* o, r
5. *        形    参: 无
   6 Y  z! o& ^4 E2 O# ?# h4 E/ ]2 k
6. *        返 回 值: 无
   & |0 a/ R% {, j' t2 Z/ A/ ^
7. *********************************************************************************************************
   ; {: [5 Q% T: t1 i' u9 W5 |% k
8. */
   6 B6 c( Y4 y% f8 x
9. static void MPU_Config( void )
   
10. {
    . W( O1 q& i: R+ Y  c
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    
12. 
    1 V2 F, s; O2 L
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    $ P0 I  B* {6 Y  G
15. 
    ' q* n6 ~  C. |
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    / `! H/ _! g, A7 Q$ C& s) {' T
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    ; y/ ~: E, d5 Z) c3 Z* K  r
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    5 j: |9 U3 m1 b# V0 v1 _( Y
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    4 K1 ^6 k* {* @; L$ j" u
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    % ~4 _3 ?+ e' @% q5 h, 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;
    ( Q  \* |) H* V0 G
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
30.         
    " i7 S, h6 c0 D. x' D" |
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    + R6 [1 y/ a5 J! o* p4 ]! n0 p
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    / [6 c2 d  t, F9 h9 a
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    ' Z4 s+ j2 C4 Y, T
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    , Y- e. H& P# s* `# ^) |
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    2 s8 N( A) n( H! l0 K
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    . S1 |& A& [& v, O3 x# n8 [3 H
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    5 i% p  [9 C* e" }+ o5 u
44.         
    6 w: s5 l2 r! k4 g$ R
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    
47.         /*使能 MPU */
    
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    
50. 
    # D" X5 P7 p2 S
51. /*
    ( P! s! {0 m" c+ x3 k+ q
52. *********************************************************************************************************
    
53. *        函 数 名: CPU_CACHE_Enable
    6 w; j6 Z$ l1 D# r, o) ]/ p" i
54. *        功能说明: 使能L1 Cache
    
55. *        形    参: 无
    
56. *        返 回 值: 无
    
57. *********************************************************************************************************
    
58. */
    3 G  W2 }3 r4 [7 J& ], M  S5 S
59. static void CPU_CACHE_Enable(void)
    ) f% C, c( u) k3 a, b
60. {
    " Y" Q* O/ P* {0 x, T( W$ s% G! g
61.         /* 使能 I-Cache */
    - O- \0 E; i4 K) V' y
62.         SCB_EnableICache();
    / G  U& E9 y/ m+ c6 C
63. 
    
64.         /* 使能 D-Cache */
    2 j$ T! P- z9 Z  G! d$ U& d
65.         SCB_EnableDCache();
    
66. }

复制代码

$ s+ i5 D% p# i& t* U8 E, p$ H2 d: a6 k  每10ms调用一次按键检测：
0 r  Z/ w( @0 o. q
% ^' Z) V+ n$ y按键检测是在滴答定时器中断里面实现，每10ms执行一次检测。

) X# `5 H* y& Y6 M  ]5 Y7 a, D* Y

1. /*
   ; m  ]# J2 W) J- m/ h9 m
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_RunPer10ms
   
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *        形    参: 无
   + Q8 b2 b/ K8 k' M1 p0 I
7. *        返 回 值: 无
   ( l7 v- Z, x7 |: ]( b4 R% W1 ^
8. *********************************************************************************************************
   6 u% o: b0 E5 b* l/ }" y* ~7 d; ?& U
9. */
   
10. void bsp_RunPer10ms(void)
    
11. {
      K, D7 g1 p! I0 ~
12.         bsp_KeyScan10ms();
      c1 H( H% B/ I5 N  R3 O
13. }

复制代码

  主功能：
/ @' K# |, `. i0 c8 m9 s
6 f  V! D, z) P  V主功能的实现主要分为两部分：

启动一个自动重装软件定时器，每100ms翻转一次LED2
按键消息的读取，检测到按下后，做串口打印。
& C- w' T  u+ X( p* d' K

1. /*
   
2. *********************************************************************************************************
   
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   
5. *        形    参: 无
   
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   6 S" d: B4 [/ D  P+ x
8. */
   " m1 e+ I# W6 `( A$ \' h
9. int main(void)
   
10. {
    + A! b( C  b0 X% b
11.         uint8_t ucKeyCode;                /* 按键代码 */
    
12.         
    
13.         bsp_Init();                /* 硬件初始化 */
    $ K/ J- G5 ?1 Q3 m# e
14.         
    & I) O) l3 b/ V2 e% G1 i
15.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    
16.         PrintfHelp();        /* 打印操作提示 */
    2 g& ?; ~( f% |
17. 
    0 i8 `1 ?9 N' }5 a* B" d
18. 
    + w- M* Z. ^! B1 x$ y
19.         bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 */
    ! r' O) H' d3 Z  _2 ^% k% K
20.         
    : {8 h; T- F9 j
21.         /* 进入主程序循环体 */
    
22.         while (1)
    
23.         {
    
24.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    0 ]6 \6 Y5 a+ ?) A
25. 
    1 b$ `  O% i* S7 x7 V
26.                 /* 判断定时器超时时间 */
    
27.                 if (bsp_CheckTimer(0))        
    
28.                 {
    ' X1 Q% H8 M2 c- ?
29.                         /* 每隔100ms 进来一次 */  
    
30.                         bsp_LedToggle(2);                        
    
31.                 }
    
32.                
    ) A) n6 J. y' R; G* |5 u+ Q
33.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    $ L! r( _: ?% }& t1 k
34.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
35.                 if (ucKeyCode != KEY_NONE)
    , }" W9 S1 |* s
36.                 {
    
37.                         switch (ucKeyCode)
    
38.                         {
    
39.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    $ G0 W6 I0 j; x3 T+ n
40.                                         printf("K1键按下\r\n");
    & K* ~; N6 [$ a) y* ~# \
41.                                         break;
    : [8 U' E; i$ v( @/ j
42. 
    
43.                                 case KEY_UP_K1:                                /* K1键弹起 */
    0 K  q6 E* e. B! n) b0 g2 x  J
44.                                         printf("K1键弹起\r\n");
    - C8 K. g" k8 z5 ~, Z* E5 y
45.                                         break;
    4 ~* u0 s: V  L/ r! y5 N
46. 
    
47.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    - g  }5 _) L! u4 d, f, t& [
48.                                         printf("K2键按下\r\n");
    7 F0 x/ q: s( R: P" C
49.                                         break;
    . @: u$ Q7 B; _% g, r" |
50. 
    ' H1 S) O6 O* r( f) f0 V3 n
51.                                 case KEY_UP_K2:                                /* K2键弹起 */
    
52.                                         printf("K2键弹起\r\n");
    % m1 c! {, O( B( q0 R+ m
53.                                         break;
    ( f9 _' @& L, y7 m, {1 U
54. 
    
55.                                 case KEY_DOWN_K3:                        /* K3键按下 */
    : p. K! A, f( K3 M# X: K7 V. g
56.                                         printf("K3键按下\r\n");
    
57.                                         break;
    
58. 
    3 @/ V9 s3 j, z# [' w  \) E
59.                                 case KEY_UP_K3:                                /* K3键弹起 */
    3 e( P: Y' I8 O9 W
60.                                         printf("K3键弹起\r\n");
    
61.                                         break;
    ' W2 r6 R0 @: d# c6 S7 w) H
62. 
    
63.                                 case JOY_DOWN_U:                        /* 摇杆UP键按下 */
    ) j! V$ R; y2 D; x& D$ ]0 F
64.                                         printf("摇杆上键按下\r\n");
    $ ]& y1 q2 _& e5 X; r% U6 G$ K# H
65.                                         break;
      V8 t' r8 `. ?2 j0 s' Z& L
66. 
    
67.                                 case JOY_DOWN_D:                        /* 摇杆DOWN键按下 */
    
68.                                         printf("摇杆下键按下\r\n");
    ; `2 l! e# I" U  x) _. Z2 C
69.                                         break;
    
70. 
    ( n0 X- b- o1 d% R: y  v" D  ~
71.                                 case JOY_DOWN_L:                        /* 摇杆LEFT键按下 */
    
72.                                         printf("摇杆左键按下\r\n");
    
73.                                         break;
    0 s5 H9 f% N  @4 R
74.                                 
    
75.                                 case JOY_LONG_L:            /* 摇杆LEFT键长按 */
      F  E( x1 I/ `5 E
76.                                         printf("摇杆左键长按\r\n");
    
77.                                         break;
    ' u$ W4 ^) b7 p* O& i. x4 B
78. 
    
79.                                 case JOY_DOWN_R:                        /* 摇杆RIGHT键按下 */
    & T; {8 _" y3 U1 g* N. r
80.                                         printf("摇杆右键按下\r\n");
    . ]1 m3 S5 k7 v
81.                                         break;
    
82.                                 
    
83.                                 case JOY_LONG_R:            /* 摇杆RIGHT键长按 */
    4 \$ a0 j  ]5 e( w" |
84.                                         printf("摇杆右键长按\r\n");
    6 G) m8 ]" q- G
85.                                         break;
    
86. 
    
87.                                 case JOY_DOWN_OK:                        /* 摇杆OK键按下 */
    
88.                                         printf("摇杆OK键按下\r\n");
    
89.                                         break;
    9 Z8 I# }- ?+ D
90. 
    + i& A  w- E! p+ Z- Y! g5 p0 V
91.                                 case JOY_UP_OK:                        /* 摇杆OK键弹起 */
    0 u1 b" H6 K" l: m+ D% s' l$ D
92.                                         printf("摇杆OK键弹起\r\n");
    
93.                                         break;
    6 u2 o  m8 x9 I
94. 
    
95.                 case SYS_DOWN_K1K2:                        /* 摇杆OK键弹起 */
    : ~1 t8 v( U) F( x
96.                                         printf("K1和K2组合键按下\r\n");
    0 X3 y4 w" r& o$ J# q! z+ ~
97.                                         break;
    ) T6 `. ~+ y. s: P; M# A8 v
98. 
    
99.                                 default:
    % Z; Y1 L/ f8 a) ~# V% L
100.                                         /* 其它的键值不处理 */
     
101.                                         break;
     
102.                         }
     . j6 f" S* m5 X* D8 R3 d; R0 c
103.                
     
104.                 }
     
105.         }
     + T5 @! D9 ~# F1 M
106. }

复制代码

19.8 实验例程说明（IAR）
配套例子：
; o* ^1 L- w9 dV7-002_按键检测（软件滤波，FIFO机制）
7 e" M5 m3 Z9 x. y3 l
; H8 A# l1 p6 u: q( G实验目的：
学习按键的按下，弹起，长按和组合键的实现。

! h6 F9 R) A! @( y3 d6 U! y实验内容：
启动一个自动重装软件定时器，每100ms翻转一次LED2。

实验操作：
% _& Y! M8 Y4 Q+ `2 T( C3个独立按键和5向摇杆按下时均有串口消息打印。
5向摇杆的左键和右键长按时，会有连发的串口消息。
独立按键K1和K2按键按下，串口打印消息。

上电后串口打印的信息：
7 P. \  p2 W( s$ p& m5 w
波特率 115200，数据位 8，奇偶校验位无，停止位 1
' x, k0 d. k# Z& K- s7 w% A
6 y$ o- G6 i6 n

1 e* ^/ k, f+ J+ C# ^  w$ g程序设计：

  系统栈大小分配：
/ @& B1 J% ^5 L# X& L3 @
0 {' b8 Q5 ?; u' f

2 i  G( y* {* M# g0 R
# g! g0 w: S/ J  r  RAM空间用的DTCM：
) e; ~2 C" u4 k9 ^8 g  Z2 U1 [6 P
  J& N* R2 v! J+ Z5 f

  硬件外设初始化
! F# W! K' q) c; T2 L" a- b
硬件外设的初始化是在 bsp.c 文件实现：

1. /*
   5 R# Q# ?, b, i- W9 {* f
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_Init
   % G& Q. ^/ D3 |/ T7 T. l
4. *        功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
   " H* _# j. ?4 `
5. *        形    参：无
   8 L# {8 V0 s( m. e" @+ {
6. *        返 回 值: 无
   
7. *********************************************************************************************************
   , v  \5 R& l, m, d
8. */
   
9. void bsp_Init(void)
   " z  G7 r% ?* @6 w+ p
10. {
    
11.     /* 配置MPU */
    
12.         MPU_Config();
    
13.         
    
14.         /* 使能L1 Cache */
    
15.         CPU_CACHE_Enable();
    ' m9 O% h& H. `
16. 
    
17.         /*
    . q( V4 V* [9 v9 h
18.        STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:
    8 L4 Z* J7 C. }* m6 f3 q3 n4 f
19.            - 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
    1 [# ], {5 E$ ?2 i. u
20.            - 设置NVIV优先级分组为4。
    & _0 ^$ k% Q/ a. d9 s2 V3 ~) a' o
21.          */
    
22.         HAL_Init();
    ! j! c4 \7 g; m8 U$ A; W+ k
23. 
    
24.         /*
    , n8 U+ @- K5 G# S7 H% h
25.        配置系统时钟到400MHz
    
26.        - 切换使用HSE。
    
27.        - 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
    7 t; e) S" V* P/ W/ N7 h2 |
28.     */
    
29.         SystemClock_Config();
    
30. 
    / R9 ^  ?$ N" [
31.         /*
    $ T0 T: c5 a- l0 O6 F3 G
32.            Event Recorder：
    # Y7 P8 u  r. I% C3 q  W/ g3 v
33.            - 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
    ( q; d$ A* M2 m  |" \
34.            - 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
    
35.         */        
    3 D8 X0 O# _0 p# W. F0 s4 r6 @
36. #if Enable_EventRecorder == 1  
    8 a  [; q3 k; X% \$ l6 J2 D  ^
37.         /* 初始化EventRecorder并开启 */
    
38.         EventRecorderInitialize(EventRecordAll, 1U);
    
39.         EventRecorderStart();
    
40. #endif
    
41.         
    
42.         bsp_InitKey();            /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
      f6 e2 c/ z& q
43.         bsp_InitTimer();          /* 初始化滴答定时器 */
    
44.         bsp_InitUart();        /* 初始化串口 */
    5 l. F; U# f0 N0 N+ W% `
45.         bsp_InitExtIO();        /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */        
    
46.         bsp_InitLed();            /* 初始化LED */        
    
47. }

复制代码

% {& S2 y8 R" ?9 h1 ?  MPU配置和Cache配置：
- O! M6 `# B  S5 P9 I/ f# G
数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。

1. /*
   3 m$ Q% o7 V& k
2. *********************************************************************************************************
   
3. *        函 数 名: MPU_Config
   1 H" @' _* B+ v5 [9 i1 c
4. *        功能说明: 配置MPU
   
5. *        形    参: 无
   
6. *        返 回 值: 无
   # p& F: B- {& h( {/ [# I! ]
7. *********************************************************************************************************
   7 D1 V+ W2 Q" S% A5 g
8. */
   
9. static void MPU_Config( void )
   3 u9 P* s5 [# r2 T: ~, t
10. {
    
11.         MPU_Region_InitTypeDef MPU_InitStruct;
    8 }; W& x* k, M0 H, Z5 h2 [
12. 
    
13.         /* 禁止 MPU */
    
14.         HAL_MPU_Disable();
    
15. 
    
16.         /* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */
    8 P% y6 u0 ?5 f$ G3 E
17.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    5 k2 E& y' [8 l! B3 o7 ~
18.         MPU_InitStruct.BaseAddress      = 0x24000000;
    ! T( J& t* I. ]  u& m
19.         MPU_InitStruct.Size             = MPU_REGION_SIZE_512KB;
    : |  W6 u- j7 a
20.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    4 w/ }& n1 ]. i# B% _
21.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
22.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_CACHEABLE;
    . G+ R; o" e2 [3 f
23.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    / t- v* x0 z$ Z, h- m
24.         MPU_InitStruct.Number           = MPU_REGION_NUMBER0;
    5 I- a0 N( i5 Z; L2 G
25.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL1;
    
26.         MPU_InitStruct.SubRegionDisable = 0x00;
    
27.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
28. 
    
29.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    ! ~. U6 ?, I# [3 T
30.         
    
31.         
    
32.         /* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
    8 X8 Z) X' @( B$ K& ?) l5 c
33.         MPU_InitStruct.Enable           = MPU_REGION_ENABLE;
    0 t, j) m9 n9 i( j7 K. W" q
34.         MPU_InitStruct.BaseAddress      = 0x60000000;
    
35.         MPU_InitStruct.Size             = ARM_MPU_REGION_SIZE_64KB;        
    ! y& S# J6 q. k
36.         MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
    
37.         MPU_InitStruct.IsBufferable     = MPU_ACCESS_BUFFERABLE;
    
38.         MPU_InitStruct.IsCacheable      = MPU_ACCESS_NOT_CACHEABLE;        
    ( b4 p) M; u; T/ V% o+ O
39.         MPU_InitStruct.IsShareable      = MPU_ACCESS_NOT_SHAREABLE;
    
40.         MPU_InitStruct.Number           = MPU_REGION_NUMBER1;
    
41.         MPU_InitStruct.TypeExtField     = MPU_TEX_LEVEL0;
    3 L! t4 ?" \; u" \- e
42.         MPU_InitStruct.SubRegionDisable = 0x00;
    1 J) W/ [4 J1 {% }4 }! @
43.         MPU_InitStruct.DisableExec      = MPU_INSTRUCTION_ACCESS_ENABLE;
    
44.         
    " @5 N% t# m! Z/ l4 {6 b
45.         HAL_MPU_ConfigRegion(&MPU_InitStruct);
    
46. 
    ( X% l- `: Q. K* F3 V. R( |
47.         /*使能 MPU */
    4 J/ x( m# j1 D2 c# Y
48.         HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
    
49. }
    0 Y7 W6 k- ~6 E9 ^/ n% [% y
50. 
    1 u- ^* g) n- b$ S
51. /*
    
52. *********************************************************************************************************
    
53. *        函 数 名: CPU_CACHE_Enable
    
54. *        功能说明: 使能L1 Cache
    
55. *        形    参: 无
    # w9 p/ O1 O- {
56. *        返 回 值: 无
    
57. *********************************************************************************************************
    , D- k2 w3 O7 u) D+ ], {' q
58. */
    ; m% G  {( A$ E
59. static void CPU_CACHE_Enable(void)
      Q1 J/ W1 V# h+ n
60. {
    
61.         /* 使能 I-Cache */
    
62.         SCB_EnableICache();
    
63. 
    
64.         /* 使能 D-Cache */
    3 ~9 `6 Q9 A3 |
65.         SCB_EnableDCache();
    3 P% T# A- p! D
66. }

复制代码

  每10ms调用一次按键检测：
8 P/ Q- g0 v5 C
按键检测是在滴答定时器中断里面实现，每10ms执行一次检测。

2 q! P3 }/ v. P$ Y' x5 D0 S

1. /*
   6 r( O6 Y- j6 `, A5 k" g2 I
2. *********************************************************************************************************
   
3. *        函 数 名: bsp_RunPer10ms
   
4. *        功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
   ! t6 P# U0 U  a# [2 F5 U; Y
5. *              不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
   
6. *        形    参: 无
   % l4 b' h2 B. |
7. *        返 回 值: 无
   
8. *********************************************************************************************************
   , u" }8 q; n7 j7 v) Y/ v% \7 a
9. */
   3 A- k, l( ?: @8 b* V+ E, b8 W
10. void bsp_RunPer10ms(void)
    7 Z; S1 g. J" p! q) S$ K
11. {
    
12.         bsp_KeyScan10ms();
    7 N+ p% n% F7 g4 m4 _/ P
13. }

复制代码

  S, V' E5 f" F$ k7 @ 主功能：
$ l' o" n& f* N6 ^
主功能的实现主要分为两部分：

) N& f2 s3 d* t 启动一个自动重装软件定时器，每100ms翻转一次LED2
; k- @$ U8 |4 e+ I2 l6 H) F& A 按键消息的读取，检测到按下后，做串口打印。

1. /*
   
2. *********************************************************************************************************
   % X) _4 L$ T. J( r7 m
3. *        函 数 名: main
   
4. *        功能说明: c程序入口
   " [( x$ F! h8 L( s$ Q8 v' [4 Z
5. *        形    参: 无
   8 o. M- c0 @- o/ L( @9 W3 u
6. *        返 回 值: 错误代码(无需处理)
   
7. *********************************************************************************************************
   ) P( S8 O: _1 V9 U* D5 g+ i/ E. u, c
8. */
     c) Z/ ^' b+ a" F3 v9 ^
9. int main(void)
   / Y$ S/ Y8 ?+ e! r, y; P
10. {
    / E2 T5 |4 g9 d$ O+ e, z2 v
11.         uint8_t ucKeyCode;                /* 按键代码 */
    7 M* U8 }) e: L
12.         
    + N3 ~+ P1 d$ U) y
13.         bsp_Init();                /* 硬件初始化 */
    
14.         
    
15.         PrintfLogo();        /* 打印例程名称和版本等信息 */
    % }" o9 ~( \8 r9 f& U0 I, S7 K0 I3 |
16.         PrintfHelp();        /* 打印操作提示 */
    # b. R4 e/ w" N5 h
17. 
    
18. 
    
19.         bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 */
    5 G9 H& M- K5 W* `# ?( X" A
20.         
    
21.         /* 进入主程序循环体 */
    
22.         while (1)
    8 ]9 V( _" o4 m  Q5 d2 F, G0 j
23.         {
    9 ^8 w6 l5 c, L9 I) P# |5 k4 _% R
24.                 bsp_Idle();                /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */
    
25. 
    # w9 p/ `) U( R! u! |5 q
26.                 /* 判断定时器超时时间 */
    " H) t; H& X, T# d2 \' B" u0 F7 ~
27.                 if (bsp_CheckTimer(0))        
    
28.                 {
    3 J8 w! U% O3 P. u  C# u8 O
29.                         /* 每隔100ms 进来一次 */  
    ; u; x( [1 z- t+ X
30.                         bsp_LedToggle(2);                        
    2 s2 }# c5 V' A( ^2 m& p3 }( a
31.                 }
    1 T' _) {( J/ A0 F! ~  z: l
32.                
    
33.                 /* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
    
34.                 ucKeyCode = bsp_GetKey();        /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
    
35.                 if (ucKeyCode != KEY_NONE)
    
36.                 {
    
37.                         switch (ucKeyCode)
    
38.                         {
    
39.                                 case KEY_DOWN_K1:                        /* K1键按下 */
    
40.                                         printf("K1键按下\r\n");
    - C* g, y0 d' b
41.                                         break;
    $ M; J0 J. C% U" o
42. 
    5 V2 c6 N: U( ~  s1 i
43.                                 case KEY_UP_K1:                                /* K1键弹起 */
    ( R7 n; V6 ?/ ]6 C, n+ |, U6 E( J
44.                                         printf("K1键弹起\r\n");
    
45.                                         break;
    & c7 X, c" ?% R# [$ g4 \4 j  \
46. 
    
47.                                 case KEY_DOWN_K2:                        /* K2键按下 */
    5 o5 j  W) k# W" ~' N0 S1 _$ C
48.                                         printf("K2键按下\r\n");
      Z( V; J, A& c# t
49.                                         break;
    
50. 
    
51.                                 case KEY_UP_K2:                                /* K2键弹起 */
      ?& q7 r+ o. ?
52.                                         printf("K2键弹起\r\n");
    $ {% P, ?$ M1 Z+ O5 c8 D
53.                                         break;
    3 i& j6 U: S$ D# ~- X7 \% P1 x/ G
54. 
    ( i! w/ U" G  ]& [
55.                                 case KEY_DOWN_K3:                        /* K3键按下 */
    
56.                                         printf("K3键按下\r\n");
      I* I; X1 h+ H, H6 [
57.                                         break;
    
58. 
    
59.                                 case KEY_UP_K3:                                /* K3键弹起 */
    
60.                                         printf("K3键弹起\r\n");
    % V7 ]4 c/ r- T& l; I4 L
61.                                         break;
    4 L1 ?1 l8 ^$ X, s: _
62. 
    # K- P+ q2 @4 p, y/ [
63.                                 case JOY_DOWN_U:                        /* 摇杆UP键按下 */
    
64.                                         printf("摇杆上键按下\r\n");
      `7 z5 [3 }# X4 C* x- Y# V! K* @
65.                                         break;
    9 U6 Y3 J7 n# Z8 b' R
66. 
    
67.                                 case JOY_DOWN_D:                        /* 摇杆DOWN键按下 */
    7 S  R! [, S3 o4 t
68.                                         printf("摇杆下键按下\r\n");
    
69.                                         break;
    
70. 
    , f' m) l: @! @2 h% O( ]
71.                                 case JOY_DOWN_L:                        /* 摇杆LEFT键按下 */
    
72.                                         printf("摇杆左键按下\r\n");
    
73.                                         break;
    8 o0 \9 J4 @) k
74.                                 
    : U9 k- I" R( P: S2 Z" k8 G
75.                                 case JOY_LONG_L:            /* 摇杆LEFT键长按 */
    
76.                                         printf("摇杆左键长按\r\n");
    + q) k. Z; f7 g( b! j+ n  y. N
77.                                         break;
    ( F& [* y. B4 I$ M3 ^
78. 
    8 K3 k! V# p4 s, z% v
79.                                 case JOY_DOWN_R:                        /* 摇杆RIGHT键按下 */
    $ k- l$ d; `- u- U* ]
80.                                         printf("摇杆右键按下\r\n");
    
81.                                         break;
    
82.                                 
    1 z5 `( g& x/ u' Z: {. |
83.                                 case JOY_LONG_R:            /* 摇杆RIGHT键长按 */
    
84.                                         printf("摇杆右键长按\r\n");
    - O, L, ~  D" a
85.                                         break;
    
86. 
    
87.                                 case JOY_DOWN_OK:                        /* 摇杆OK键按下 */
    
88.                                         printf("摇杆OK键按下\r\n");
    : d* ]( a, h) Q, \: j* U  ~* J2 X2 M
89.                                         break;
    
90. 
    
91.                                 case JOY_UP_OK:                        /* 摇杆OK键弹起 */
    
92.                                         printf("摇杆OK键弹起\r\n");
    
93.                                         break;
    
94. 
    
95.                 case SYS_DOWN_K1K2:                        /* 摇杆OK键弹起 */
    ; w. ]; u# I" Y  h9 x4 }& v& m, B
96.                                         printf("K1和K2组合键按下\r\n");
      v% Z$ i- r) A& j2 }- n) e
97.                                         break;
    
98. 
    
99.                                 default:
    
100.                                         /* 其它的键值不处理 */
     3 p. F/ M; U  g  k
101.                                         break;
     - d# {. x& A; g1 {. I5 X
102.                         }
     
103.                
     9 ?. F* K+ q* e$ T4 t5 [. j
104.                 }
     4 ?( ?) w* r5 \4 F4 W- A
105.         }
     
106. }

复制代码

  H% S$ k6 d/ w19.9 总结
这个方案在实际项目中已经经过千锤百炼，大家可以放心使用。建议熟练掌握其用法。

% r$ M; B7 k! ^% w0 w
5 b4 Z* P  U/ A/ y7 y3 r
8 ?$ _( n/ ?& u) }! `