【经验分享】 STM32H7的GPIO应用之按键FIFO

[复制链接]

STMCU小助手发布时间：2021-10-26 01:12

技术帖
文章封面:
文章简介:	按键FIFO驱动扩展和移植更简单，组合键也更好用。支持按下、弹起、长按和组合键。

19.1 初学者重要提示
学习本章节前，务必保证已经学习了第15，16和17章。
按键FIFO驱动扩展和移植更简单，组合键也更好用。支持按下、弹起、长按和组合键。
19.2 按键硬件设计
V7开发板有三个独立按键和一个五向摇杆，下面是三个独立按键的原理图：

aHR0cHM6Ly9pbWcyMDE4LmNuYmxvZ3MuY29tL2Jsb2cvMTM3OTEwNy8yMDE5MDUvMTM3OTEwNy0yMDE5.png

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

下面是五向摇杆的原理图：

通过这个硬件设计，有如下两个知识点为大家做介绍：

19.2.1 硬件设计
按键和CPU之间串联的电阻起保护作用。按键肯定是存在机械抖动的，开发板上面的硬件没有做硬件滤波处理，即使设计了硬件滤波电路，软件上还是需要进行滤波。

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

红色的线条是GPIO输入通道的信号流向，作为按键检测IO，这些需要配置为浮空输入。按键已经做了5V上拉，因此GPIO内部的上下拉电阻都选择关闭状态。

19.3 按键FIFO的驱动设计
bsp_key按键驱动程序用于扫描独立按键，具有软件滤波机制，采用FIFO机制保存键值。可以检测如下事件：

  按键按下。
  按键弹起。
  长按键。
  长按时自动连发。
我们将按键驱动分为两个部分来介绍，一部分是FIFO的实现，一部分是按键检测的实现。

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

bsp.c 文件会调用bsp_InitKey()初始化函数。

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

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

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

函数调用关系图：

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

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

如果Write！= Read，则我们认为有新的按键事件。

我们通过函数bsp_GetKey读取一个按键值进行处理后，Read变量变为1。Write变量不变。

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

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

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

  可靠地记录每一个按键事件，避免遗漏按键事件。特别是需要实现按键的按下、长按、自动连发、弹起等事件时。
  读取按键的函数可以设计为非阻塞的，不需要等待按键抖动滤波处理完毕。
  按键FIFO程序在嘀嗒定时器中定期的执行检测，不需要在主程序中一直做检测，这样可以有效地降低系统资源消耗。
19.3.2 按键FIFO的实现
在bsp_key.h 中定了结构体类型KEY_FIFO_T。这只是类型声明，并没有分配变量空间。

#define KEY_FIFO_SIZE 10( L1 ]1 G' S2 O! S' M( b: ~
typedef struct! e- M7 R$ e, a# h" ^8 {; w3 K
{+ v2 |) o) W: u) a' d
uint8_t Buf[KEY_FIFO_SIZE]; /* 键值缓冲区 */
, v2 z& l9 T W1 Y. ]* L
uint8_t Read; /* 缓冲区读指针1 */1 ^ ?* ~0 y; s" |, M) n+ ^" m- T
uint8_t Write; /* 缓冲区写指针 */
* T6 ?3 L3 f, i
uint8_t Read2; /* 缓冲区读指针2 */
9 l" k3 `2 n; o7 b
}KEY_FIFO_T;

复制代码

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

static KEY_FIFO_T s_tKey; /* 按键FIFO变量,结构体 */
一般情况下，只需要一个写指针Write和一个读指针Read。在某些情况下，可能有两个任务都需要访问按键缓冲区，为了避免键值被其中一个任务取空，我们添加了第2个读指针Read2。出厂程序在bsp_Idle()函数中实现的按K1K2组合键截屏的功能就使用的第2个读指针。

当检测到按键事件发生后，可以调用 bsp_PutKey函数将键值压入FIFO。下面的代码是函数的实现：

/*
( K. s/ m6 }/ }
*********************************************************************************************************
, k+ K+ E! t0 W( K# M& ~( E
* 函数名: bsp_PutKey! ?6 s* k8 h/ N. I# K
* 功能说明: 将1个键值压入按键FIFO缓冲区。可用于模拟一个按键。, V' |8 Y/ Q) b6 H: b1 y ?
* 形参: _KeyCode : 按键代码
; U0 @. L5 B- ]% Y# p( ]
* 返回值: 无
8 f( h% {! Z5 S6 }& l' H9 l: y+ J
*********************************************************************************************************
7 S) K0 B4 R+ L5 P; J* ]
*/
. g) ~3 Y6 l6 i& Y3 d
void bsp_PutKey(uint8_t _KeyCode)
8 C, I8 ^' o; ]( O4 h& u
{5 ^5 F: Q& v( G# X
s_tKey.Buf[s_tKey.Write] = _KeyCode;* F# T3 y) a8 p; v) I- n- s
, z5 |! [. ?+ `0 k \3 Y
if (++s_tKey.Write >= KEY_FIFO_SIZE)
, A$ ^3 _6 Y; e) M$ e
{+ a8 F/ z; [% s9 n+ h1 n# j
s_tKey.Write = 0;' W. P, ?6 _6 V
}( |) _- K) v7 p6 S/ Q3 U- }) v+ Z
}

复制代码

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

应用程序读取FIFO中的键值，是通过bsp_GetKey函数和bsp_GetKey2函数实现的。我们来看下这两个函数的实现：

/*+ t( B# R' w( c- X$ z
*********************************************************************************************************- S |2 \# @3 G" x1 p: E
* 函数名: bsp_GetKey
4 Q+ t$ ^8 s* _ l- t5 q
* 功能说明: 从按键FIFO缓冲区读取一个键值。
; d" g( r, m4 L9 }$ ?- R* p
* 形参: 无 h, l+ I/ E; j, _5 y
* 返回值: 按键代码
% D5 r% ]7 y: o0 {! k$ u, \
*********************************************************************************************************) _- D7 z4 Q; x6 U
*/
9 N. l+ ]0 s; q
uint8_t bsp_GetKey(void)
9 f7 U/ y [' Z7 ?/ |+ L
{
7 D4 O2 n2 W& v. [! M0 O
uint8_t ret;
, k% C/ A' w6 h7 e$ H4 {+ k
& J9 |( |* w2 B" z7 u
if (s_tKey.Read == s_tKey.Write)7 }0 v9 U! T5 |" V% @: m
{
, Z) C4 n% Q5 k4 o8 n3 x
return KEY_NONE;
: z n9 N6 c1 ?6 j6 Z Y9 O
}
: x" _. y8 k% K5 |
else8 z( D4 z' z6 B0 S: L) e# z
{
4 }. C3 @+ P9 [" {+ N- z9 r, C
ret = s_tKey.Buf[s_tKey.Read];& o1 Q a+ t" L/ h/ _8 J7 P
# J% F1 v" f/ c9 H6 e
if (++s_tKey.Read >= KEY_FIFO_SIZE)
- y+ c- X9 }" {4 [* j, M* w
{
: l; q- b8 N2 g$ H! D
s_tKey.Read = 0;
! I. j$ n% Z4 ^. g) y: _
}1 \+ _# d8 {1 X
return ret;
. N, G- s; O. J$ `' j1 [& s4 M
}* i |$ M% J8 d- C
}; y& y# C F) g3 y. h3 C
+ @2 x$ o! v6 d6 e( r9 h
/*
* \- x, F- @- t$ W' {& i# S
*********************************************************************************************************
+ r# h0 E0 p5 u1 z0 X
* 函数名: bsp_GetKey2
' l+ {5 M5 H* E- A4 Z
* 功能说明: 从按键FIFO缓冲区读取一个键值。独立的读指针。
" d. T1 X$ h; I9 h5 c) j
* 形参: 无
! L! n0 [# j, x! r- h$ M
* 返回值: 按键代码
' O! s) e. ]7 s; j; H
*********************************************************************************************************' W) I4 H3 U; g
*/* ~9 e$ n$ K6 w/ t
uint8_t bsp_GetKey2(void)5 r" C1 ]9 t+ h' y
{2 |, Y! \* ?- e/ a( W8 `
uint8_t ret;
5 N+ [* d9 [( s' Q; K5 ~5 o" E1 j
" ~6 S+ b5 S$ f' C' [8 ^" L
if (s_tKey.Read2 == s_tKey.Write)5 e: u) Q2 N9 g; R6 [! b4 e
{
7 T1 j" Z: `" n" A/ D6 Q) _! W3 V
return KEY_NONE;) r( U+ T' ~/ Y
}1 N0 G; V2 E/ m: j3 d
else1 s0 y) P8 l$ M) v% @5 n7 K
{
% y* T( R. C. D3 d! u2 K/ K
ret = s_tKey.Buf[s_tKey.Read2];
6 _, h; _# w# x8 m0 z
" n' {/ x' I2 b6 N! \ _
if (++s_tKey.Read2 >= KEY_FIFO_SIZE)
7 f* ^$ c' c* C4 _9 N Z
{& `' e% o6 K/ H/ w }0 t5 @$ k- J
s_tKey.Read2 = 0;
4 Q/ l: ]/ z/ ]! g, W
}
$ H- x% q0 F: c x, K: @% |. }
return ret;( p1 f9 j: t% N+ V1 V
}
! g+ Z# ?* r& _5 V+ v, ~9 K
}

复制代码

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

typedef enum' ~9 {3 L" Q0 ~) ?3 }/ q# R. Y# Y
{
A! @8 i: |& x% ?% A: B0 D3 E" Z
KEY_NONE = 0, /* 0 表示按键事件 */! h& ~# G+ C f; R5 d" u/ H
& \( H0 M. l: {0 J) K3 @; Q% t9 Z
KEY_1_DOWN, /* 1键按下 */
& @. q. B# u5 `- L3 {8 p, F. }
KEY_1_UP, /* 1键弹起 */$ D1 W7 ^, t4 e3 m1 o, L
KEY_1_LONG, /* 1键长按 */! |" t2 a* N! g, }4 b
/ Y' F3 V+ \, n k, a& W% J
KEY_2_DOWN, /* 2键按下 */
) t- K) I: b% v6 Z
KEY_2_UP, /* 2键弹起 */# x7 P6 z! W6 [) q
KEY_2_LONG, /* 2键长按 */. X* L2 G, R- X4 u7 O) ]$ j0 O* b
$ T. d. q- O E5 V* O+ Z# [
KEY_3_DOWN, /* 3键按下 */
1 B# M, Y9 c$ T
KEY_3_UP, /* 3键弹起 */
4 ] y6 u% D2 d5 h% m; W3 S9 }
KEY_3_LONG, /* 3键长按 */
: t* ^1 u3 B, k( t
V- C1 h7 p0 y
KEY_4_DOWN, /* 4键按下 */
+ ]* `& X4 t: i* D" V: Y1 w/ ~. J
KEY_4_UP, /* 4键弹起 */. y, i' |( ]/ l. ^/ C) c
KEY_4_LONG, /* 4键长按 */
" q8 s; N1 r, U
KEY_5_DOWN, /* 5键按下 */- d8 s; q, I$ x* t/ B
KEY_5_UP, /* 5键弹起 */2 f X$ t9 I2 j& I& o. S4 i5 M
KEY_5_LONG, /* 5键长按 */
: ]6 s2 }. K1 n: o6 \4 w
/ e- x; Y# r2 U1 ]9 a) @4 \
KEY_6_DOWN, /* 6键按下 */
' b' ]; Z# |; @) y4 _6 H- c. l, v
KEY_6_UP, /* 6键弹起 */
. q% O! ]& u! E% K
KEY_6_LONG, /* 6键长按 */
. l) ?7 c$ b. \5 ]* ~
3 P" R/ p7 x! K. _
KEY_7_DOWN, /* 7键按下 */: P, j/ k, P+ Q; K
KEY_7_UP, /* 7键弹起 */5 A( E4 X* e1 a* c
KEY_7_LONG, /* 7键长按 */
9 t3 S; g3 d+ d* B
- r: U. B. C( Z* U8 V0 ]4 t
KEY_8_DOWN, /* 8键按下 */
& B' b+ }; G0 ^7 `: L# w
KEY_8_UP, /* 8键弹起 */ d1 `8 o6 c$ x) l$ s: i! l
KEY_8_LONG, /* 8键长按 */- A# `! l$ j3 E( H- f7 y K1 @: Q
) z% a+ I2 o4 N7 P- e
/* 组合键 */) j4 p- z. U E
KEY_9_DOWN, /* 9键按下 */
8 I& ]7 w$ F/ G' l. @/ v
KEY_9_UP, /* 9键弹起 */1 ~$ B. z7 l6 I+ B! R) P) o
KEY_9_LONG, /* 9键长按 */+ D) [. I5 a L
) \# ~1 w- p$ H* `4 f
KEY_10_DOWN, /* 10键按下 */5 @" A5 i4 ?0 E
KEY_10_UP, /* 10键弹起 */
6 c3 N9 k" E0 H9 B8 S' C3 r' l
KEY_10_LONG, /* 10键长按 */
! v# A' V7 z' B; g# U
}KEY_ENUM;

复制代码

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

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

/* 定义红外遥控器按键代码, 和bsp_key.h 的物理按键代码统一编码 */

typedef enum* f8 d6 y9 {9 h P3 _
{
& X, \ H0 x, G" C
IR_KEY_STRAT = 0x80,( r5 \1 Y5 g: o/ i0 D
IR_KEY_POWER = IR_KEY_STRAT + 0x45,
E8 v" b O& |- n& `8 y! }# Y
IR_KEY_MENU = IR_KEY_STRAT + 0x47, & K) `( S/ B& l, A3 K6 f
IR_KEY_TEST = IR_KEY_STRAT + 0x44,
; Z \" F8 f! i! O
IR_KEY_UP = IR_KEY_STRAT + 0x40,2 j y' v3 q; {7 c, C; l3 @
IR_KEY_RETURN = IR_KEY_STRAT + 0x43,
! w) f+ u$ L: A' e# l
IR_KEY_LEFT = IR_KEY_STRAT + 0x07,8 G% n( y# l" w) m# @3 k& ~8 y6 G
IR_KEY_OK = IR_KEY_STRAT + 0x15,
( h- F3 m: o$ A3 D1 B4 [
IR_KEY_RIGHT = IR_KEY_STRAT + 0x09,8 Z1 z2 y# c9 F1 V) n
IR_KEY_0 = IR_KEY_STRAT + 0x16,/ ~ ^% S$ H; p6 f" P% [8 b9 ^
IR_KEY_DOWN = IR_KEY_STRAT + 0x19,: Q+ V* \; c) t. V" Q
IR_KEY_C = IR_KEY_STRAT + 0x0D," ^, K: N; b3 G# [
IR_KEY_1 = IR_KEY_STRAT + 0x0C,
- {1 l1 f% u+ I4 [0 a4 s
IR_KEY_2 = IR_KEY_STRAT + 0x18,9 G. \$ e2 Y7 a. ]' T! A8 F% N
IR_KEY_3 = IR_KEY_STRAT + 0x5E,
- N( _" @' E+ u( t. K. P) _
IR_KEY_4 = IR_KEY_STRAT + 0x08, B9 W" }4 g$ C: m& M8 |2 |4 T
IR_KEY_5 = IR_KEY_STRAT + 0x1C,
3 {! ?7 A' M9 m
IR_KEY_6 = IR_KEY_STRAT + 0x5A,' e( [+ d6 M& x4 b) |5 E
IR_KEY_7 = IR_KEY_STRAT + 0x42,
; P2 K% ^. V" ?
IR_KEY_8 = IR_KEY_STRAT + 0x52,
" D5 r1 t5 H9 h. p$ y
IR_KEY_9 = IR_KEY_STRAT + 0x4A, : r* b4 X5 p' W8 W {) ]( w& Q
}IR_KEY_E;

复制代码

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

#include "bsp.h"1 B, L- d2 N/ y6 q0 K
5 O' k* W. H' {7 }6 `" L! s
int main(void)) ~* b0 U8 O9 k/ A8 G$ h# @
{$ G4 i1 [( r6 v! r- e
uint8_t ucKeyCode;
/ X% X* Q8 |7 ]! w6 k7 Z: g
$ ~; ~5 U4 r0 A
bsp_Init();/ S4 L+ p& H# v4 R& e
' ]- W6 X+ L( y# o
IRD_StartWork(); /* 启动红外解码 */$ Q2 X) U; R5 \
+ j! [) x$ l ]" Y7 U7 }
while(1)
+ Y/ n, j B# `" i
{
( m1 D) M# R* Y6 ~$ c+ |6 c
bsp_Idle();
, M4 c2 B+ m1 C# X2 ]7 R o
0 X3 R6 Q. ^ K# o5 i; g
/* 处理按键事件 */ }- n7 S9 [- ^- K9 Q
ucKeyCode = bsp_GetKey();
9 u; `4 u. R9 P8 E7 {2 ~# [
if (ucKeyCode > 0)
) |& [3 t5 h) Q/ A+ ^" u& ^
{/ ]8 B" y# y8 D$ h) j+ m
/* 有键按下 */
" I x1 \/ {% `& n3 ?
switch (ucKeyCode)
3 B) ?4 R% u4 v' T5 d* e* E
{& i# k: {; l5 o8 Y5 K( C
case KEY_DOWN_K1: /* K1键按下 */
/ D8 m, `% I) K
bsp_LedOn(1); /* 点亮LED1 */
) t3 _' g4 d$ P
break;/ }7 i. j7 a' W/ ]5 u# U( |
3 N" d# ^3 a5 g: k* K+ X5 E
case KEY_UP_K1: /* K1键弹起 */9 F# y+ d0 a' d8 a) W9 v7 @8 K
bsp_LedOff(1); /* 熄灭LED1 */
- ?9 ?. g$ \) ~* G* Q5 v
break;
% O- b; k* C& d; [. n; q- m% s3 g" D
8 A4 a9 L5 p0 P+ V
case IR_KEY_POWER: /* 遥控器POWER键按下 */
" m, y/ i4 t. R0 h, M7 ^
bsp_LedOn(1); /* 点亮LED2 */! t+ o' p5 ^7 T9 [: T5 j1 z! v, y- }
break;( \6 W* i: g% P% f% c; E3 x
( V" c4 D6 e8 I) {" B, P
case IR_KEY_MENU: /* 遥控器MENU键按下 */
9 W( V+ v% j" U) i+ |
bsp_LedOff(1); /* 熄灭LED2 */
; i# {+ U, j5 E5 j
break;
# [3 ?. I1 V& I) H! }+ _
0 r, i0 S- R4 V$ Y- G! c) X+ C3 ~
case MSG_485_RX: /* 通信程序的发来的消息 */
3 T: L3 G+ N& f) o- h5 L
/* 执行通信程序的指令 */
7 I5 q2 x) r) X9 X0 \* s$ K
break;1 r; k$ |. j3 A$ b4 L% q! `: I
; q8 R7 b% r2 {/ X7 L0 @
default:
4 i- f0 p& n; P! A9 ^7 m% Q/ n# U
break;
9 d9 Q) V: o0 x# n' d, `
}1 P) L5 A( x# m% Z" F n R' r8 ^1 j
}
. W+ h9 F8 s" K; M: W2 L
}
* s8 ^/ R) {# `/ K& ?
}

复制代码

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

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

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

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

#define KEY_COUNT 10 /* 按键个数, 8个独立建 + 2个组合键 */
* E |, l$ y" {
0 s' u) `6 d3 B/ y- z
typedef struct. q9 Q/ |* q* ?* x" y2 ?% |7 H
{. B1 m8 A* g! d% @
/* 下面是一个函数指针，指向判断按键手否按下的函数 */9 R5 s8 ^5 R" u2 j" \& V' ?$ o
uint8_t (*IsKeyDownFunc)(void); /* 按键按下的判断函数,1表示按下 */# f; @# P9 B' W% K5 c# C1 K) r# J$ O
; b3 C. @$ @6 H# d! b2 [) B7 B
uint8_t Count; /* 滤波器计数器 */
9 F n' E5 P5 b3 _. V: e
uint16_t LongCount; /* 长按计数器 */; a; h t( T" Q$ N
uint16_t LongTime; /* 按键按下持续时间, 0表示不检测长按 */3 C3 U, U+ r: G" _# H
uint8_t State; /* 按键当前状态（按下还是弹起） */3 z( D1 l2 }1 E$ i; @
uint8_t RepeatSpeed; /* 连续按键周期 */
3 A, q. D! H3 ^( C) e
uint8_t RepeatCount; /* 连续按键计数器 */0 Z# t8 t4 n7 _# ?! D- Y
}KEY_T;

复制代码

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

static KEY_T s_tBtn[KEY_COUNT];
static KEY_FIFO_T s_tKey; /* 按键FIFO变量,结构体 */
每个按键对象都分配一个结构体变量，这些结构体变量以数组的形式存在将便于我们简化程序代码行数。

使用函数指针IsKeyDownFunc可以将每个按键的检测以及组合键的检测代码进行统一管理。

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

/*; b2 @2 }3 q3 v3 i* N7 ?
********************************************************************************************************** o5 V8 P/ v5 G8 I9 z( _( X
* 函数名: bsp_InitKey
+ s+ J! e" q) ?; ]
* 功能说明: 初始化按键. 该函数被 bsp_Init() 调用。
5 q! N3 A* E+ S; ?. B
* 形参: 无( r+ ?1 u( @0 K7 y5 n
* 返回值: 无
) w2 a% f; T+ d9 \8 R
*********************************************************************************************************9 X" t5 j/ \$ S. j4 R4 o) H
*/, e8 Q6 r7 F+ u. s4 ?7 f7 X$ F" [
void bsp_InitKey(void)
; u5 _" f: p- M- g) c
{
3 i, A5 D3 F5 L' l+ t& h
bsp_InitKeyVar(); /* 初始化按键变量 */& Y J3 w' k. t) e1 ?+ Q- P, y
bsp_InitKeyHard(); /* 初始化按键硬件 */0 ?/ M2 D) R0 @
}

复制代码

下面是bsp_InitKeyVar函数的定义：

<blockquote>/*

复制代码

注意一下 Count 这个成员变量，没有设置为0。为了避免主板上电的瞬间，检测到一个无效的按键按下或弹起事件。我们将这个滤波计数器的初值设置为正常值的1/2。bsp_key.h中定义了滤波时间和长按时间。
) S4 c+ T) F' r6 K( y t& r7 h0 i- {8 R3 w% J

/*
0 }# q1 B* d9 ? C& R1 t
按键滤波时间50ms, 单位10ms。. B& l+ h3 r- N2 R/ Z V$ e! X8 D/ s
只有连续检测到50ms状态不变才认为有效，包括弹起和按下两种事件
) _9 C. d9 A8 K6 D' t, _. |
即使按键电路不做硬件滤波，该滤波机制也可以保证可靠地检测到按键事件
/ O$ j8 I9 S0 v5 Z b
*/2 `" M8 E9 M2 N9 b6 A3 C4 p% \
#define KEY_FILTER_TIME 5# e3 U$ V* x+ N! V. S
#define KEY_LONG_TIME 100 /* 单位10ms，持续1秒，认为长按事件 */

复制代码

uint8_t KeyPinActive(uint8_t _id)（会调用函数KeyPinActive判断状态）函数就是最底层的GPIO输入状态判断函数。! Q$ g3 E8 I& R& I5 Z" c
+ t+ n, V0 g6 {$ @

/*
& x, V k' [0 U
*********************************************************************************************************7 S { G4 |% o8 ~) l" d8 B
* 函数名: KeyPinActive3 Q `3 ]& Y, J. |5 I q* y
* 功能说明: 判断按键是否按下; o" d4 k6 r* U. ^: L
* 形参: 无( x9 y1 A5 n/ |9 A/ {
* 返回值: 返回值1 表示按下(导通），0表示未按下（释放）
" P( B5 x8 [0 r& O5 L
*********************************************************************************************************
6 H1 \1 [8 u" E8 D8 G
*/
9 e3 [* u: c9 L/ j6 m0 {/ H V
static uint8_t KeyPinActive(uint8_t _id)$ G D5 _1 w% A0 D
{
1 }# ^) E# q" u5 ~
uint8_t level;
* g$ f) K e/ c
( A6 P: Y9 O# ^+ n$ w" r1 x, A
if ((s_gpio_list[_id].gpio->IDR & s_gpio_list[_id].pin) == 0)
4 _& A+ P& ?" T7 G" w8 y2 r
{, x+ x: j( X- N0 k6 z$ `
level = 0;
; `. ]8 _" z$ B. ]- G% ^- D
}! E6 ?2 l) l6 O# u( o7 o6 t
else1 D9 T1 }) b9 f% s2 A1 K
{1 l5 D. w K t
level = 1;
! e8 v% @' ?' l8 t, X: U1 `+ |
}
& U5 Y) G- ]3 x# E
- A; k& k! L+ |% V4 R
if (level == s_gpio_list[_id].ActiveLevel)
3 b' {* ^+ R. B: q, [7 W
{, L2 v& ` K& P# R
return 1;9 u% `$ M' c$ [6 |* t6 i" i5 o( ~( j
}, o; a% K* c7 j9 ~( j7 N5 n- H' N" q; v) q
else
) f% ~2 w3 g6 j/ f# [7 d6 z& M/ s
{- A$ J! @+ v, [% {7 J
return 0;
% o: e/ w2 f$ ^2 C& Y7 W# e' U
}; e4 V$ _1 g& h3 J: e4 W# ?
}- }/ b& V+ l" ?, {3 S
- U4 a$ c- I4 d
/*
0 m2 J) V# d0 ^# P" \
*********************************************************************************************************
# l5 M+ j# }& X2 |
* 函数名: IsKeyDownFunc" d- \( O3 n* I J( O
* 功能说明: 判断按键是否按下。单键和组合键区分。单键事件不允许有其他键按下。+ w. ]- P% I3 I1 L
* 形参: 无% h1 f, E% r0 ?0 w8 i- N# \$ J" E
* 返回值: 返回值1 表示按下(导通），0表示未按下（释放）
' k/ c, |4 {# Z( ]% X i
********************************************************************************************************* o* s6 q% G+ u3 w- B: d3 }
*/
" z6 A8 D5 j9 d" z5 J
static uint8_t IsKeyDownFunc(uint8_t _id). L1 D" z [& n
{) u, Y4 E5 `( q* ]% n; N3 Z
/* 实体单键 */1 O$ r6 \+ E$ [ p
if (_id < HARD_KEY_NUM)7 _! F1 b( A4 I: y, w" z
{
; ]4 k" M l1 Q1 q" W, @, ], B
uint8_t i;
! j+ G( Y. x9 g5 |4 C, i% U
uint8_t count = 0;& k- o( w& S+ y: H% I! r
uint8_t save = 255;" R- Q, b* T: Z: ]* \! I5 J
* @$ Y/ [$ A+ N9 [
/* 判断有几个键按下 */
' l [: N: H# @7 ?3 s# N) t+ j
for (i = 0; i < HARD_KEY_NUM; i++)
3 f2 }" F5 ?8 z
{+ l$ I$ N' A T; K, h, U
if (KeyPinActive(i))
* s* w4 Z! Q6 n' \: w$ w
{: D) X; `$ T2 e
count++;( X& i2 x+ a5 E. q! g S3 H. k0 a
save = i;6 p6 F7 B8 ?* L; u6 }; o
}
8 p1 E2 |; q" q, @9 a$ A& R
}8 U7 t7 `+ Y3 A- W! I$ }' @
3 m! M4 L- R% ~* W1 n% H! D
if (count == 1 && save == _id)" ]7 F1 i5 }" A7 {: P
{
) o' B( h# E# l/ w# `+ u
return 1; /* 只有1个键按下时才有效 */
]1 l% P# H4 [6 e/ w* k
}
0 u- e0 q$ P% ^4 R- ?" X7 R
$ U1 K0 ]- v X* O& i7 c
return 0;: i& o/ ~9 r- G! D+ ]
}0 {5 E* r8 U$ W. t3 n+ v2 o
: \+ L* ?, ~: j; C3 w& b
/* 组合键 K1K2 */% A/ s3 G7 J" W
if (_id == HARD_KEY_NUM + 0)& ^' ]" b, e( i3 F* J u3 S
{
# C2 q& X8 K& a5 l' W1 G
if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))- F0 @2 e" B9 K/ R9 o
{4 b) M1 L' t. j/ k, _6 }
return 1;
7 G8 X n! M* D8 y* ^0 l2 I) u, o
}
( d- X6 @3 `- }0 [# r% \
else, G. R7 _8 L1 c& l
{% f& v- v+ f- K; y+ _* d s
return 0;! y' |# W1 _* v) T5 a
}
$ {" w/ s8 c# a( {* _
}
5 e; [' z) m& N
; J6 \$ S5 N# E/ n8 a1 H
/* 组合键 K2K3 */3 ?1 o X3 Z+ C" u7 {' u, X
if (_id == HARD_KEY_NUM + 1)
$ \. p. x G) B9 b9 {# s
{; |0 S0 n* q& i4 Q+ z
if (KeyPinActive(KID_K2) && KeyPinActive(KID_K3))9 b: @! e' J8 j3 n
{
! V4 f/ I9 q9 f# ]
return 1;
2 Z. E9 T& v4 G$ }' `7 k
}
7 @% {2 k9 A( r0 L" P
else
3 T, {( R' P& n2 ` ~0 O! C
{
! a: J" e7 @: _" Y& r2 L$ e" H/ @
return 0;
" c! l7 ]+ h0 I( b y; I2 Z6 C
}
1 x. H! _! e( u: L9 T! O$ U
}
( d* s" k- j Z: C+ S2 V
; h+ v& r( H( _
return 0;. |1 R2 J S0 C* l
}

复制代码

在使用GPIO之前，我们必须对GPIO进行配置，比如打开GPIO时钟，设置GPIO输入输出方向，设置上下拉电阻。下面是配置GPIO的代码，也就是bsp_InitKeyHard（）函数：* ^( ]1 ` N) d# K" Y* F( s$ z

8 n) D$ G$ }, H/ p$ \2 s5 y

<blockquote>/*

复制代码

我们再来看看按键是如何执行扫描检测的。5 w1 L& x8 m' a o4 I8 B

+ h! b8 L; S- E# h5 e' ~按键扫描函数bsp_KeyScan10ms ()每隔10ms被执行一次。bsp_RunPer10ms函数在systick中断服务程序中执行。: `: M, U) S& Q5 P" B
( @2 d0 l5 D8 {0 n! M

void bsp_RunPer10ms(void)6 t( Y/ c/ M; r: Q( S8 m5 S% Y
{
5 Q7 N0 T3 U6 ^: v
bsp_KeyScan10ms(); /* 扫描按键 */$ L% X# S- j9 ?$ P
}1 S0 z* h! B9 y2 ~' P- W' \" T
bsp_KeyScan10ms ()函数的实现如下：
1 \5 w# g% A& K8 `, b8 R
0 V9 W/ g0 R; f3 n M: w
/*0 M d2 i0 i2 K7 w1 a
*********************************************************************************************************
, V3 }% x& }; ~: Q/ \
* 函数名: bsp_KeyScan10ms
! s, a3 `3 q: n8 f: V
* 功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
3 C0 z$ o% F, y" {8 D2 p0 X; F
* 形参: 无
& o6 ~ [, U& j$ u2 F* P8 k
* 返回值: 无
4 ]1 \) F0 S: d: I4 n
*********************************************************************************************************
$ s5 i: ~. h4 v! w5 y: W
*/
/ S6 x; g/ r( D
void bsp_KeyScan10ms(void)( i) f* D9 X0 ?
{+ \/ t# X- Z/ V/ I; {% y
uint8_t i;7 ]% e% h2 ]$ S) p
" p( Z: Y" G n6 [- }9 |' O
for (i = 0; i < KEY_COUNT; i++)6 b4 l1 z9 n& X" o0 h( B" W
{/ ?. P( H S- O$ @0 \' b
bsp_DetectKey(i);
! w% f4 r+ }; m
}
, w& A# r- `) D
}

复制代码

每隔10ms所有的按键GPIO均会被扫描检测一次。bsp_DetectKey函数实现如下：5 I5 t" B# Z+ N

% [ Q/ p2 |$ z5 C u

/*- ^6 \/ X/ z6 }
*********************************************************************************************************/ t1 g' ?! B; B- q
* 函数名: bsp_DetectKey$ C; K$ I4 @" m
* 功能说明: 检测一个按键。非阻塞状态，必须被周期性的调用。
9 i2 N `5 p$ S+ ]; e: S5 A4 ]
* 形参: IO的id，从0开始编码
" {: S1 K2 d, \/ s
* 返回值: 无
5 A5 u) q! b3 y" M* e
*********************************************************************************************************$ F# B% m" i- M8 \3 I; y
*/" L* P+ b$ R3 r
static void bsp_DetectKey(uint8_t i)6 z# ^! n# `- v4 W, n
{" C4 f7 W8 S" E ^0 ]' D; L- r' h
KEY_T *pBtn;
/ y! e, m3 D/ p. ^3 ^2 b
8 i3 x- C5 i$ J/ ~
pBtn = &s_tBtn;# j+ r7 c) ^( e* [3 Y
if (IsKeyDownFunc(i))
: P( w' { n5 y
{- x f5 N2 M& N
if (pBtn->Count < KEY_FILTER_TIME)
, }% `3 L& y) _0 q4 s5 P- [6 Z
{1 k' f; L* A0 y, |" B
pBtn->Count = KEY_FILTER_TIME;+ q; I& ]& y8 G/ X! g3 H2 l
}
; K% m5 x7 G# f! B- {9 P
else if(pBtn->Count < 2 * KEY_FILTER_TIME)! q+ z% n$ q( A
{# l+ W: e# v9 m2 P9 d
pBtn->Count++;
9 J# H4 g- y% R; W( \8 K
}5 R8 R/ G/ O6 m+ B3 S( w$ }
else. Q/ {0 s- K$ Q% D0 d! C
{4 M: A" ~/ k* d
if (pBtn->State == 0)8 w& L) E, o# v
{* Z% z$ V6 m$ e1 x: @! x4 V$ A9 y
pBtn->State = 1;
: \: u8 O$ I4 R1 J- A' @
( t6 V& B9 n+ W4 [* y( e, s
/* 发送按钮按下的消息 */3 v W+ F, n5 h$ w d
bsp_PutKey((uint8_t)(3 * i + 1));
. U/ M. ]8 `' S- u3 x" N
}! X% y7 J4 Q8 E- _; H& O# q
; v* N9 L0 u+ x4 N
if (pBtn->LongTime > 0). W/ C. F/ B+ b3 J+ f2 _8 C
{
+ s) m, Y' S8 u: N
if (pBtn->LongCount < pBtn->LongTime)/ J. S# ]+ f- k8 ? q* u5 A9 [
{
4 p* ^1 H( k0 x+ g- V
/* 发送按钮持续按下的消息 */$ L& Q- c7 Z C/ z* z8 q
if (++pBtn->LongCount == pBtn->LongTime)
7 L7 F. J0 O/ f* h1 V3 ~
{
6 s+ l: o* o, X
/* 键值放入按键FIFO */
+ s- u* S* B" b" p' v9 v2 U+ Y. w
bsp_PutKey((uint8_t)(3 * i + 3));
) E' c' L! b8 a" Q
}
& ~& G& |2 ^1 S" {1 m# Q; m
}
$ ^; j$ L) S4 R; W! L& _0 e
else/ R/ H9 D G9 m3 b
{
/ e& d8 q* C$ j. R2 j: B" D
if (pBtn->RepeatSpeed > 0)
; m4 ~8 }$ b) l- P3 b+ g
{9 R* ~! t! X) u E4 Y
if (++pBtn->RepeatCount >= pBtn->RepeatSpeed) R+ ?: d i. E7 Y
{; \; @, a& ?+ o& S
pBtn->RepeatCount = 0;- q* i. ^4 p+ j5 n# Z4 o
/* 常按键后，每隔RepeatSpeed * 10ms发送1个按键 */6 [, g8 M1 L4 n) Q
bsp_PutKey((uint8_t)(3 * i + 1));
' j! Z. ]* S) S2 {. G1 M
}
% B1 ~) N Y7 g: ?+ s
}
+ o& ~0 M1 Y1 \/ |( p* J
}
( L* l* N8 h6 U' w
}
; w H# \; r2 A
}, R6 Y, N4 a1 [1 I8 f1 n
}( }5 p# x/ }+ j$ R* R
else
E8 m$ T& Z& f2 m" `
{) {) s8 c) z/ [, K0 Q" B
if(pBtn->Count > KEY_FILTER_TIME) q( b; O2 N" |! [
{
% F. ~8 U6 P( p
pBtn->Count = KEY_FILTER_TIME;- P q: Q( T: i3 h8 @, {* f) v
}
! }% X# z6 I4 A- X6 E) d
else if(pBtn->Count != 0)9 ], [4 }$ O/ L2 _3 _% |/ r
{# [2 y' i0 k& A, l* V |
pBtn->Count--;
3 i: ^7 g1 s9 ?4 T5 S: Z! Z4 }
}0 z! J g% I( J, a' I# M
else+ Q9 R* w. ^3 ^( N& X( ?7 _5 N" D
{
! Y7 R, T8 d# c& w9 Z: l% ^
if (pBtn->State == 1)
" F. h5 M3 v( I" W
{/ u+ [1 @1 N/ c8 [" h1 a/ w
pBtn->State = 0;3 X6 Y# a5 L( ~2 l
: u/ ?$ I8 _% }. r
/* 发送按钮弹起的消息 */
) j. I2 i! M* a/ l1 `0 _
bsp_PutKey((uint8_t)(3 * i + 2));2 r/ U- v# k( p8 q/ C
}
' U$ Z4 l4 R$ V6 f
}
2 P2 W1 b6 i7 g$ ?2 D2 {: v( \
/ E+ I( h/ `# m
pBtn->LongCount = 0;
9 e4 L$ |& o6 ]7 H
pBtn->RepeatCount = 0;
9 Z6 Y% n) u! G% g6 c% Q
}
' i0 c \2 Z3 a0 {$ a
}

复制代码

对于初学者，这个函数看起来比较吃力，我们拆分进行分析。9 m3 e5 U: ^: d' [' i- g& |# k

* I" w4 r; ~7 |; ?5 ~6 c3 N

pBtn = &s_tBtn;

复制代码

读取相应按键的结构体地址，程序里面每个按键都有自己的结构体。
* L; }! `" _! I- t5 F
6 J) t* f+ k" G. h v

static KEY_T s_tBtn[KEY_COUNT];
7 G$ q! m/ R: j9 H4 d# H6 ?
if (IsKeyDownFunc(i))
$ @6 U* Q1 O3 ?+ i( E
{
/ @: W7 Q2 \, L' V; e- L1 Q: b
这个里面执行的是按键按下的处理+ j+ C/ _. j* V' t
}
- }* O: k7 }5 Y" v, B5 [
else' W6 O6 `% O- ^9 v$ |
{
9 U9 z. b' J0 `
这个里面执行的是按键松手的处理或者按键没有按下的处理
1 a* O1 {. S9 p4 K0 Q
}
! m7 v1 F/ G% W3 R# Z
执行函数IsKeyDownFunc(i)做按键状态判断。$ o1 i1 |! L: P
6 B4 X; V) h; k; Z
/*
" w% J H6 ?& X( u3 r
**********************************************************************************
; S" P; }$ G8 ^& p
下面这个if语句主要是用于按键滤波前给Count设置一个初值，前面说按键初始化的时候
Y* Q+ X/ H3 J' D, R6 R
已经设置了Count = KEY_FILTER_TIME/2) _! g$ ^4 @' {# A2 M% p* a
**********************************************************************************
3 {" @: a9 u; s V
*/, Y' j8 e! y5 A5 o
if (pBtn->Count < KEY_FILTER_TIME)9 H, F$ M& E& f* A0 w8 `
{
/ s" C, A9 A' Y" i# E
pBtn->Count = KEY_FILTER_TIME;( [& l& h/ b1 c8 U# f" s( T7 P8 B1 A
}* q% t1 q% V& ?9 @+ d
' {% q7 d# y- K
/*% F8 m: ^" Y* f7 _7 `. _
**********************************************************************************
1 Z) [2 |+ g# R- @* |
这里实现KEY_FILTER_TIME时间长度的延迟5 Y2 O- p" w* k( ~" |! F
**********************************************************************************
' S9 C: S( m7 M5 G! X% u
*/
* P w7 Z3 J$ z; l p- n0 e
else if(pBtn->Count < 2 * KEY_FILTER_TIME)
; {5 T2 B/ g! _/ O5 ?% m
{& R- l+ [/ D$ Z& \+ Z: E+ Z
pBtn->Count++;' R4 T. G+ L! q. v- N% w T' U
}/ S, O, O5 ` t n% _
/*
5 e$ s: W L( z& u! H: O
**********************************************************************************
- D- Z5 C% Z7 }' E3 X3 t) J# u
这里实现KEY_FILTER_TIME时间长度的延迟
' k; R. r8 n U, C7 g
**********************************************************************************1 U. n$ B. o5 ~
*/! X' I: A) E1 f' x4 Y2 K+ V
else
, Y% P; \! M1 B/ i
{% @0 ]6 X$ A4 N
/*
1 p! s' g+ f1 f6 W l9 l
*********************************************************************************** K8 @4 g8 l: C& N( s- V7 Q
这个State变量是有其实际意义的，如果按键按下了，这里就将其设置为1，如果没有按下这个
( Q% v2 J9 W% v, p9 y# @
变量的值就会一直是0，这样设置的目的可以有效的防止一种情况的出现：比如按键K1在某个1 k- U6 O9 e$ e
时刻检测到了按键有按下，那么它就会做进一步的滤波处理，但是在滤波的过程中，这个按键0 P% l4 [" s6 E% ?! j9 q$ {9 @
按下的状态消失了，这个时候就会进入到上面第二步else语句里面，然后再做按键松手检测滤波
9 x7 ]* f D0 S! p+ w0 y/ m) y% l
，滤波结束后判断这个State变量，如果前面就没有检测到按下，这里就不会记录按键弹起。
# O+ i& I, X) i, u# X. E
**********************************************************************************: i0 b7 K9 i; `! y
*/9 v$ ~! h1 M4 I& @4 b
if (pBtn->State == 0)' n5 P% z' K, H+ S/ Q* i( K
{4 ]! N1 N0 W5 a1 w
pBtn->State = 1;% E1 @1 o2 V1 _3 d+ h$ z9 B
, K$ P' n/ K. Z! p/ T
/* 发送按钮按下的消息 */
4 C+ \/ c! C. ~0 z4 A9 s z
bsp_PutKey((uint8_t)(3 * i + 1));: d9 S2 L: W; H! V8 m* {
}
' B1 u; J, C9 v! F, m, _7 ]" J
- F# O( W$ ?% W. }8 G$ g% _0 R
if (pBtn->LongTime > 0)
8 ~# c# V7 P; X$ n( @
{
+ X5 F) \4 Q' D; i
if (pBtn->LongCount < pBtn->LongTime)
. n/ e9 z1 d6 C U
{
0 q3 i! i' I' h* m H
/* 发送按钮持续按下的消息 */
/ V$ N. J. R6 c3 M5 S. m \
if (++pBtn->LongCount == pBtn->LongTime)& j$ p3 Y+ K) C7 X* S O
{; m$ }. R* C8 [( R
/* 键值放入按键FIFO */
; F. z4 B) h' \+ H: @) M
bsp_PutKey((uint8_t)(3 * i + 3));4 m, W) x! r, k, {( v% l
}
0 A7 o! @4 k- F
}9 d" v" |) k( F9 P7 J, r& }
else
! D2 D& H0 o' D. D
{& U; J, O- k# U" D9 @) @6 S" I
if (pBtn->RepeatSpeed > 0)
6 o3 E( z; u8 Y3 m4 f& t
{% z" a& h! m3 C; j3 Z, r' Q6 v
if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)$ ?' t3 H/ C+ E
{
+ z! Y' H; I9 w; b. T8 b
pBtn->RepeatCount = 0;
5 p3 L0 t: }" p* S( f- o
/* 长按键后，每隔10ms发送1个按键 */ m W$ m3 i7 d1 B
bsp_PutKey((uint8_t)(3 * i + 1));
6 T, e# n. T) c+ M' p( i
}
' P) Q s! Z) U5 h q
}
$ Q) a" d' [" I9 H
}
4 c( r) w5 `, t9 D- Z4 ^3 y* r# e
}
" g9 i$ P- c3 \- h6 m
}

复制代码

19.3.4 按键检测采用中断方式还是查询方式# X  ^- Z6 V( }( `2 W) t
检测按键有中断方式和GPIO查询方式两种。我们推荐大家用GPIO查询方式。2 i! ]' m3 ^) @% \

! n) B" G: U; X从裸机的角度分析+ P& a7 J, l8 d8 G
! w2 B* A$ v# {" x  a/ c
中断方式：中断方式可以快速地检测到按键按下，并执行相应的按键程序，但实际情况是由于按键的机械抖动特性，在程序进入中断后必须进行滤波处理才能判定是否有效的按键事件。如果每个按键都是独立的接一个IO引脚，需要我们给每个IO都设置一个中断，程序中过多的中断会影响系统的稳定性。中断方式跨平台移植困难。
  X8 o, d1 W1 s5 r
1 `" Q+ W1 m4 c7 l查询方式：查询方式有一个最大的缺点就是需要程序定期的去执行查询，耗费一定的系统资源。实际上耗费不了多大的系统资源，因为这种查询方式也只是查询按键是否按下，按键事件的执行还是在主程序里面实现。
; A$ _2 z7 t" f% R5 q4 v+ g  a4 q/ W6 J! }, w2 \/ f" O. f0 S/ @6 F1 o
从OS的角度分析
8 {9 i6 \5 j  B  E# t5 U( \. z( j/ u  G( I3 M
中断方式：在OS中要尽可能少用中断方式，因为在RTOS中过多的使用中断会影响系统的稳定性和可预见性（抢占式调度的OS基本没有可预见性）。只有比较重要的事件处理需要用中断的方式。
8 Q8 f# W0 [, l0 y) ^8 o- w2 k* u  n1 R
查询方式：对于用户按键推荐使用这种查询方式来实现，现在的OS基本都带有CPU利用率的功能，这个按键FIFO占用的还是很小的，基本都在1%以下。
5 x* x& ]; _# h: X1 l* b' K
: S; W" J& Z% U7 W7 F5 g7 ]19.4 按键板级支持包（bsp_key.c）' t8 G* _1 z! \: n9 h
按键驱动文件bsp_key.c主要实现了如下几个API：) m" o! \6 Y" P+ [, N

, E' A% @1 i  [+ N+ q2 K  KeyPinActive
- J9 j5 X' P8 p% P& ]+ {, M  IsKeyDownFunc
5 y5 G& `; S3 c1 U( U3 Q; M2 [  bsp_InitKey
2 X; S5 [! l" X: K3 X) N! |  bsp_InitKeyHard
& a, H+ l+ C% r) N& d  bsp_InitKeyVar& s& _- e/ R% F
  bsp_PutKey. @' o3 H( U' T# W
  bsp_GetKey* _, l8 b+ P; V" B7 O3 X2 o) f
  bsp_GetKey2  B! n3 I9 K5 H+ o
  bsp_GetKeyState' y# F' f0 O0 X" W% l
  bsp_SetKeyParam' X3 m9 R& P$ \0 P, p; F0 W1 P+ Q
  bsp_ClearKey: ^2 K9 y* ^3 `9 o
  bsp_DetectKey
! j% P' V& t9 J5 V% O& P2 t$ H  bsp_DetectFastIO, r  {4 K, }3 Y# X5 N9 K+ k# ?+ m
  bsp_KeyScan10ms
6 f1 J2 R1 @5 ]1 p9 o; y  bsp_KeyScan1ms
! v( b5 w8 B9 k& A& P8 \/ r* B/ @' S; G4 N, X9 }  Q
: s/ y% I) K) E# u2 Y6 y
所有这些函数在本章的19.3小节都进行了详细讲解，本小节主要是把需要用户调用的三个函数做个说明。
2 q: s; M+ `+ s" l' E
; \8 x7 O- V# l/ p. y% O19.4.1 函数bsp_InitKeyHard6 P5 Z' o. r3 c" |# T# z" }9 N
函数原型：
5 V" F& ]& G/ ~

n4 q! Q) V3 W P0 C/ w# Q
/*# S6 Q. s- N$ b2 a* q
*********************************************************************************************************
1 B+ h# g& M: i
* 函数名: bsp_InitKey% F" P8 ~( @" N U" ?# z
* 功能说明: 初始化按键. 该函数被 bsp_Init() 调用。& v6 R9 z6 U( K, ~( A
* 形参: 无
9 I8 K) Z' l1 \- h9 F4 u8 e
* 返回值: 无
+ N5 B7 a5 ^# u+ o1 K! W( D4 ]+ l- m
*********************************************************************************************************
7 d) E9 H# w* F8 R4 w. \1 i
*/; p n, i7 ?+ f$ c
void bsp_InitKey(void)
* _8 \8 d' \2 N
{
$ S: }2 v2 ~" d8 J! V/ }% ~
bsp_InitKeyVar(); /* 初始化按键变量 */8 r8 n, G0 Y5 Q6 C
bsp_InitKeyHard(); /* 初始化按键硬件 */
; T' F1 _2 C: f. ]4 j6 v; W
}

复制代码

函数描述：
, J3 O) D, L$ A  y) Z  R2 [- r7 [' W7 l/ s% ^  Q) `
此函数主要用于按键的初始化。
$ R& n7 M8 m& @9 D) ]' J2 q. W2 c  j; s0 C9 X  w2 \# ~
使用举例：
5 i; u5 O! P6 U
; z$ N' d' k6 Y7 |8 k; v! J  w底层驱动初始化直接在bsp.c文件的函数bsp_Init里面调用即可。
  ^" Q) H# a7 a* c2 j% t6 n; h4 s# O
+ f  l! N! g* P9 C1 `19.4.2 函数bsp_GetKey0 |# `) p- \0 b7 _
函数原型：# c6 N. V$ u3 [. E& l# C/ u2 D

4 C7 v1 K! \* Z1 X. Q% C* K

/*
: e1 v3 u+ f9 H D7 c
*********************************************************************************************************3 M5 l7 Y" i9 f- @# a- J4 Q4 x
* 函数名: bsp_GetKey/ R6 K. I& i9 h5 a& |6 @
* 功能说明: 从按键FIFO缓冲区读取一个键值。$ m O4 `9 v$ K, N. \. w
* 形参: 无' j1 C6 b+ j, S, R2 V$ V$ R+ Z
* 返回值: 按键代码9 f6 V5 O( P5 y7 j% b* X
*********************************************************************************************************
) ^. w* }4 R& s! m
*/1 P, R; b# j* O+ e& {( y
uint8_t bsp_GetKey(void)% t0 @4 R. |2 g0 y8 J
{
; Y1 H, N0 v* P5 G
uint8_t ret;" b, t7 B) A0 p
: I \- f& l- H0 q% {; j
if (s_tKey.Read == s_tKey.Write)) ~4 Z8 \; H8 |. A2 D& [, ]
{3 d4 l2 v: @8 i( h g( E7 f
return KEY_NONE;
2 ]2 \1 j7 A4 v' ~. N
}: l$ v5 X2 e4 K- g+ Y0 b
else# R! e- D( Q8 s; |# t( R9 H6 i6 O) t
{
9 b; A4 r( s) Q4 W4 I8 W1 t( P4 [
ret = s_tKey.Buf[s_tKey.Read];
% e2 I l6 n M7 h
4 p$ @! ]( t. k( f1 X8 g, m
if (++s_tKey.Read >= KEY_FIFO_SIZE)+ ?7 q. O& a9 h: N
{8 g% l1 d# K/ l; M; d2 L
s_tKey.Read = 0;( v4 _% c: z% Z3 W) m0 ~0 V
}# _0 w7 M5 I0 Z
return ret;9 L6 _+ K y2 p
}
; k& b( N9 m+ x& h
}

复制代码

函数描述：. a% u8 g( k) A; A5 ~
5 U- f! X) Q5 ^& t! |
此函数用于从FIFO中读取键值。; C9 G( _( E4 O$ P% e5 L6 f7 ~
; y6 i$ p* Q0 e; g
使用举例：
3 g0 f5 l: i) u0 T0 k" L3 o/ s7 n T* o# O B1 ^
调用此函数前，务必优先调用函数bsp_InitKey进行初始化。
& @3 S* M; i" W. ^! T) s
, @2 G5 w8 L$ |7 g. i

/*5 m' F) _( {! m7 M/ Q2 r
*********************************************************************************************************
n1 J9 J8 x/ p' o, _
* 函数名: main
5 e" e9 F- p4 L6 E! B
* 功能说明: c程序入口
: w* w% h1 j- b- ?$ \
* 形参: 无
& Q8 c; \6 j! i5 s# C$ d; G* }
* 返回值: 错误代码(无需处理)
+ m7 }2 m+ {; a9 n
*********************************************************************************************************
. @0 m( X% P- f7 A, A6 z( b
*/: Y* u* y! _% X$ v. J5 L
int main(void)* R- P! }0 K5 |. n7 `. g0 U4 ~( R8 r$ V
{
7 h0 f0 |) i$ W* w
uint8_t ucKeyCode; /* 按键代码 */' o" t: I! Y% Y3 G9 j k0 g
" i- w: Y* z1 z: B* k
bsp_Init(); /* 硬件初始化 */
. @! [. U, ^4 h3 D; m
3 s3 R Y0 q0 x
/* 进入主程序循环体 */+ S+ J- x% ]" Z: e5 ]% ~! x
while (1)) f* a" a- `& R2 W/ |
{
& i) W8 I- S; [+ ^' e& a
/* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
$ S8 [/ H: S( B4 K
ucKeyCode = bsp_GetKey(); /* 读取键值, 无键按下时返回 KEY_NONE = 0 */, ^) r: c. W* C( Z# w3 }: @( W
if (ucKeyCode != KEY_NONE)( l% E' j' [' P5 I6 P5 h
{
9 v) }2 D4 w2 g& v3 ~2 z8 V; n
switch (ucKeyCode): U* t s0 j# n, k1 E z
{
$ K1 @) n4 ~* N) w% p
case KEY_DOWN_K1: /* K1键按下 */, i: D( @ `, e$ t( u4 V' ]' O
printf("K1键按下\r\n");
7 |% y# W. I1 _! N6 | C
break;* @* v/ j& D6 {( s, `
4 s$ l8 U) i. X( r1 I$ q
case KEY_DOWN_K2: /* K2键按下 */" H! M) M' R: ^+ N% x2 d! G. ~
printf("K2键按下\r\n");/ i5 \& T/ G G: _* h: U6 I
break;
7 t, W1 N) |7 u+ T" j# l" O% D
( C, t) R2 z+ p
default:
6 C/ Y4 P' _- s/ }6 K5 @% v
/* 其它的键值不处理 */
6 o7 E; i& p& _! [- U: O& ~
break;2 u7 `- k$ u7 K4 k$ _! J# @
}7 E6 B/ o* k* [0 U; [
}
7 b1 w% e/ A, }% L$ @1 s
}
K; ~7 E" B: Z+ H! \
}

复制代码

19.4.3 函数bsp_KeyScan10ms
3 j, z; [8 k, C+ R6 }+ G函数原型：
- H0 m* ]1 U4 N3 ^
7 U; S/ W [7 B0 L

/*
6 @: Q: n; ?3 B8 O6 J% O& Q; b
*********************************************************************************************************/ O4 ?: y+ ?/ m. U+ A0 c
* 函数名: bsp_KeyScan10ms
: y' h) V" Q2 g" n! S
* 功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用，10ms一次
. N+ P$ x+ S* Z1 O5 l
* 形参: 无
7 `$ L7 u- | C
* 返回值: 无; L' S* u3 h2 ]) G, V
*********************************************************************************************************8 C: Q7 m9 G' f# v- E
*/* |8 X# B! _$ M8 ~. D1 o) f8 i. c
void bsp_KeyScan10ms(void)5 t7 f2 L2 y* e% V1 Y
{8 Z& d4 p/ B, ]+ ~/ ]) y5 j+ N( m
uint8_t i;+ T7 B3 o) F3 R* ?6 u- s+ Z9 I% @
& N9 n3 m1 L+ Y3 {% F3 o
for (i = 0; i < KEY_COUNT; i++)
3 i/ Z) g( h( |8 t
{
0 X' C* k4 c' E! h* r& L
bsp_DetectKey(i);
" f& a2 h0 F; L e6 b
}& a! w0 i9 \1 Z( I8 W
}

复制代码

函数描述：
5 F0 `: `5 f5 J7 u. M5 H, `
9 _( c2 i% h# p0 m3 w# }此函数是按键的主处理函数，用于检测和存储按下、松手、长按等状态。
0 k& t' p. V6 k
9 ?5 l% Y  d, e# S+ r使用举例：
; K* ^3 J# `3 z3 u( Z0 t+ B4 m% H9 P5 j4 f  \- ?8 P0 T
调用此函数前，务必优先调用函数bsp_InitKey进行初始化。
3 E6 c  n) X2 D
0 A1 p7 W& S5 P6 W另外，此函数需要周期性调用，每10ms调用一次。
, H9 f2 ^6 E; q/ Q3 n4 v
, J, E$ ~! f( h  如果是裸机使用，将此函数放在bsp.c文件的bsp_RunPer10ms函数里面即可，这个函数是由滴答定时器调用的，也就是说，大家要使用按键，定时器的初始化函数bsp_InitTimer一定要调用。$ k* R+ w; Y% A- s+ g
  如果是RTOS使用，需要开启一个10ms为周期的任务调用函数bsp_KeyScan10ms。: k8 j4 p- ]5 Y4 q7 v! B
19.5 按键FIFO驱动移植和使用4 d) Q' _9 R0 R7 [" a4 o' g& g! P
按键移植步骤如下：0 i' P& X% z4 e3 [% s, m; L1 w
7 q3 _3 N$ t8 O. {: q
  第1步：复制bsp_key.c和bsp_key.c到自己的工程。4 S5 S" {9 q# }$ Z( s
  第2步：根据自己使用的独立按键个数和组合键个数，修改几个地方。
# p7 o: T/ [5 L

#define HARD_KEY_NUM 8 /* 实体按键个数 */
1 Q7 o; M! b3 Z# O) l
#define KEY_COUNT (HARD_KEY_NUM + 2) /* 8个独立建 + 2个组合按键 */

复制代码

第3步：根据使用的引脚时钟，修改下面函数：( `- T2 B* g8 h; ?# j, L

/* 使能GPIO时钟 */; Z& n6 G4 ~7 }, e) p" u4 ?
#define ALL_KEY_GPIO_CLK_ENABLE() { \
X- U, l \ n0 Z& M- ^% U
__HAL_RCC_GPIOB_CLK_ENABLE(); \2 p, @9 @$ T" l' |/ ~% ?5 L
__HAL_RCC_GPIOC_CLK_ENABLE(); \
" d6 I% x% _! L" s
__HAL_RCC_GPIOG_CLK_ENABLE(); \
9 H |( B! h$ ?) U, \7 K0 j
__HAL_RCC_GPIOH_CLK_ENABLE(); \
( I! ^$ v7 c1 i. c9 K. W% j
__HAL_RCC_GPIOI_CLK_ENABLE(); \
/ f4 O: x3 T g; R
};

复制代码

第4步：根据使用的具体引脚，修改如下函数，第3列参数低电平表示按下或者高电平表示按下：
" C2 v' T4 L/ U& A* ]# X( m

/* GPIO和PIN定义 */
+ [) n$ ~1 u. V. ?: {
static const X_GPIO_T s_gpio_list[HARD_KEY_NUM] = {6 N$ W) V3 A; o' N
{GPIOI, GPIO_PIN_8, 0}, /* K1 */
0 E; X* f! h! S5 o( K
{GPIOC, GPIO_PIN_13, 0}, /* K2 */1 c6 c% w$ W4 b# R& [% p
{GPIOH, GPIO_PIN_4, 0}, /* K3 */3 _2 E9 e# K+ p* L
{GPIOG, GPIO_PIN_2, 0}, /* JOY_U */
' }8 M4 e; D: B& y0 d: P0 O8 M- y0 k
{GPIOB, GPIO_PIN_0, 0}, /* JOY_D */3 P8 _4 L }" T, P' {4 ~0 F
{GPIOG, GPIO_PIN_3, 0}, /* JOY_L */
# r+ s4 \; d0 o8 O0 I
{GPIOG, GPIO_PIN_7, 0}, /* JOY_R */
; _4 Q0 K1 p6 X/ T" _, e' g% ? W. V
{GPIOI, GPIO_PIN_11, 0}, /* JOY_OK */
$ W. H" Y& {' T
};

复制代码

第5步：根据使用的组合键个数，在函数IsKeyDownFunc里面添加相应个数的函数：, M! K# o' u' U' e% Q

/* 组合键 K1K2 */: h Q+ J8 X* ~! z
if (_id == HARD_KEY_NUM + 0). a' q6 k6 t! Z& M( L, F/ m
{$ }! ]# o1 Y; @: x! I& o
if (KeyPinActive(KID_K1) && KeyPinActive(KID_K2))
8 b# E3 z5 ]; Z2 G9 X
{0 s! f [) I# j. X
return 1;3 ~! l; A5 B+ ^" \
}9 K% i' G- a2 E& e% O0 e- a6 O. u X
else
1 l. T4 D7 t/ M0 q+ N A3 _
{
: V3 _% e# a, g! {
return 0;" \& |2 z J. }3 a$ ~2 i
}
: T: y A& x7 A5 ^8 _
}

复制代码

第2行ID表示HARD_KEY_NUM + 0的组合键，HARD_KEY_NUM + 1表示下一个组合键，以此类推。
0 Q, U) S- }5 n# f+ Y$ h6 p$ O# y  m; H/ _% h$ Q
另外就是，函数KeyPinActive的参数是表示检测哪两个按键，设置0的时候表示第4步里面的第1组按键，设置为1表示第2组按键，以此类推。: d4 w% H# z8 l( O  t) A: ~

" s, J. n! n/ p, c. K: ^% ?  第6步：主要用到HAL库的GPIO驱动文件，简单省事些可以添加所有HAL库.C源文件进来。/ d" P' |- ^8 k* I
  第7步：移植完整，应用方法看本章节配套例子即可。% a- J7 s; |( G& U9 z
特别注意，别忘了每10ms调用一次按键检测函数bsp_KeyScan10ms。
, U# i+ Z1 x+ \% u5 Q
1 p. Y3 G8 i  M+ f19.6 实验例程设计框架
; _; X# h! Y- q7 z通过程序设计框架，让大家先对配套例程有一个全面的认识，然后再理解细节，本次实验例程的设计框架如下：( R. I& r% W" d* w1 ]. U# y
6 }+ Z2 D8 t8 q3 l, m) ~6 B' U* E7 i& S

! v. `1 S* x' u' H4 u, }" T
0 {, M) w/ v# U8 U2 o3 d$ M# g, Q
1、第1阶段，上电启动阶段：
# b1 v, a' `8 w  F* A' E
7 F  }+ m! l/ v; f% ?这部分在第14章进行了详细说明。
4 _5 \' }# C+ j! l  j# C) }# K- U# _, Q* n5 t- H$ x
2、第2阶段，进入main函数：; y1 z, {( j/ z# @3 z8 T- p
6 U6 ]. x' ]3 n! ~% r* Z" n
  第1部分，硬件初始化，主要是MPU、Cache、HAL库、系统时钟、滴答定时器、按键等。
- o) v* j2 ]( C4 ^5 I  第2部分，应用程序设计部分，实现了一个按键应用。4 j2 p6 V5 X) t# Z3 y" r6 U
  第3部分，按键扫描程序每10ms在滴答定时中断执行一次。
( H6 ^+ d) z. O5 G* D1 u19.7 实验例程说明（MDK）
7 F3 F/ q6 q* l7 X3 a配套例子：
6 C. E: i7 `7 ~- @5 L) B$ ?
2 a: Y7 {5 P7 ]0 E  S" OV7-002_按键检测（软件滤波，FIFO机制）
6 y7 Q8 X4 K# B' e( i0 s2 Y
) K0 I% ?$ C6 v9 C! N/ N2 a; J实验目的：
* ~0 [3 q+ ~2 _% E% l2 ?. S0 M; }4 M: ?4 B
学习按键的按下，弹起，长按和组合键的实现。" a  s1 @$ c2 I
实验内容：
" ]/ V  }3 F9 o; P! g( ^& c) L% m- L9 ~) Q* u
启动一个自动重装软件定时器，每100ms翻转一次LED2。3 D: }% _7 D) w5 ]
实验操作：
: b' e. h" }, u5 d3 `! _% o. B/ N, A6 N" T# {+ |
3个独立按键和5向摇杆按下时均有串口消息打印。0 y& d. R) B2 f4 `7 P: ^6 `$ B& w
5向摇杆的左键和右键长按时，会有连发的串口消息。% W+ N+ h4 f# m* H
独立按键K1和K2按键按下，串口打印消息。- X2 I( H. U& E5 L  B3 B  c
上电后串口打印的信息：. e9 y, x$ [1 _. a3 ?# n

) _* V+ n$ e" n/ u波特率 115200，数据位 8，奇偶校验位无，停止位 10 @% |- N6 W1 ~8 A  ~
. L  @+ Y! Q, x% y0 }! K- }

" Q9 I8 Y& {7 O) F. [4 v

2 p) {/ D$ i0 i7 Q程序设计：8 W6 ^* k& q; ^, D( A

4 c2 @- |9 G6 ~  系统栈大小分配：
  f  p! l3 f$ z, D3 z$ T2 r( s+ {5 G5 h! W

, F- K2 j+ I" I6 b' ?1 w, m  a8 H
& L( z9 |+ q% U4 Z7 I. L3 v+ H6 ^  RAM空间用的DTCM：
; q( Z& `0 n- y9 b0 Y5 L: v, M& J$ Z

% b2 {- \8 l2 a2 f; i" y
, a( R) v5 T3 L/ Z* A# h+ E1 A& D" e1 L# A1 N4 m$ `
  硬件外设初始化
4 ]9 q- g# I6 p# T: \
/ H. b0 T( B: k& {6 }& {硬件外设的初始化是在 bsp.c 文件实现：- i8 c* w2 F8 J% @

, y$ Y7 ^) E) w0 \& l, J. s

/*& l) A3 ]' i6 P6 y1 X
*********************************************************************************************************& v; B+ z) O6 ?: g& F
* 函数名: bsp_Init2 U! D, W* K1 T+ m2 I
* 功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次9 ?( N/ k @- J& G
* 形参：无
8 _8 n7 A9 ]; W* }( Q
* 返回值: 无6 \; q' T4 s" n5 j) t2 t* `# V
*********************************************************************************************************
- V# W! S& Y- ^
*/
, m2 _- y" y3 d% A. B K8 w! s
void bsp_Init(void)
% ]" F; z2 @; U ~. d
{
% b4 z$ h @" Z% t3 u" ]& j X
/* 配置MPU */
: f7 u8 k6 s3 W2 p4 n$ c
MPU_Config();0 i" ]1 e3 R( s1 ~' h) u2 B+ `
^" [. R% R. ] e/ t: t
/* 使能L1 Cache */
/ X. ]1 l1 R; u/ C+ S
CPU_CACHE_Enable();# a& s$ p$ K, V! l
7 G. [ R- L7 D3 {7 A( U9 t
/*
& E9 j- [6 v k! \3 X
STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:* K% j* C( R9 S7 B1 C
- 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
( A4 c. D) c9 K- O+ W5 \
- 设置NVIV优先级分组为4。6 ~7 {' ?$ j( p& y9 M/ s
*/0 K! [" q+ @) B3 K5 }/ \; D2 l
HAL_Init();+ m, i. a" f" t) ~$ j
* r; |9 Q" r( H& Q7 w# D+ D
/*
$ A7 y& b. }+ T1 o
配置系统时钟到400MHz! Q2 q* x- c0 ^1 S% Q7 \9 e
- 切换使用HSE。+ e/ \( H A' s* {" H2 `
- 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。/ m, M: B4 }+ z0 s2 H/ R1 T% w
*/ A) k8 J0 T. A! L) ~$ E6 s
SystemClock_Config();
1 G! O# ` g/ c2 U( H- x. w3 _- \
2 `3 ~% k' w! e) X; k
/* 6 y2 u# w- ~: v* @
Event Recorder：7 o* {4 ^0 R; T
- 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。
P9 q) u5 L/ s7 `; O9 A0 A% L
- 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
! G7 n Y+ y# d5 {, u3 ?+ e
*/ ! S0 T: v% X3 {: P! C
#if Enable_EventRecorder == 1 $ U% V8 o: V$ Y8 h
/* 初始化EventRecorder并开启 */8 W% \) Q1 F( } F; O
EventRecorderInitialize(EventRecordAll, 1U);
# l9 j/ Z9 E; N) U* e+ V! l
EventRecorderStart();
+ E1 A( O# m2 e" b
#endif
9 E5 R8 t1 S) }6 {7 ?& |- Z3 C
' m. t* [. T, S# f; j
bsp_InitKey(); /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */( R& i# h: k: C* K; C2 S0 l f
bsp_InitTimer(); /* 初始化滴答定时器 */
{+ U& q4 [+ A' b8 r( A% y
bsp_InitUart(); /* 初始化串口 */
5 ?# _' {5 x5 j9 f7 F2 `; ~
bsp_InitExtIO(); /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */ # J# M2 B, S; N5 }2 e- [' l
bsp_InitLed(); /* 初始化LED */ }& g6 f: k" v9 N# T
}

复制代码

MPU配置和Cache配置：
5 J4 K0 \' o3 d# t' c+ z: H2 ?0 q
数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。
* F ]- N/ B1 U! G4 k5 Q
* S+ I/ O0 T; k8 G" x

/*5 N& `; Q( R: Z y' S m
*********************************************************************************************************; @$ m* r9 q, V* q- A9 ?
* 函数名: MPU_Config5 K4 l2 \3 W/ O% a+ I9 B
* 功能说明: 配置MPU
9 S) T! y& H! D$ [7 U4 c
* 形参: 无
+ e" _ p# n2 b7 H+ n
* 返回值: 无
% E; \% w/ a$ I
*********************************************************************************************************2 B. n, w/ [- t: j& g$ |& ]
*/
: R2 h/ D8 l( \( e7 K5 D
static void MPU_Config( void )* b0 g" h$ {2 w/ N% |% [
{
# f# L% p- T: ]1 i& k- q
MPU_Region_InitTypeDef MPU_InitStruct;' x8 N. s& h% i3 J. a: E+ t1 w s
* X9 n6 X# B: B/ O$ a/ B5 S
/* 禁止 MPU */7 Q- j8 ?* z Y# ]: q
HAL_MPU_Disable();
- X% [( u" g" B' n6 g! V
& [, p- g& O! i6 t& h* J9 p
/* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */; ]9 n, j' i) e" p2 ~' A Y& @
MPU_InitStruct.Enable = MPU_REGION_ENABLE;
5 ?9 I" P8 l/ T [* p/ S
MPU_InitStruct.BaseAddress = 0x24000000;- P3 ^4 d3 k L" d5 d
MPU_InitStruct.Size = MPU_REGION_SIZE_512KB;6 T6 E* z4 c( }4 I* O! J" ^1 H; ~6 \
MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;+ n- b$ f& i: W. s- b1 G
MPU_InitStruct.IsBufferable = MPU_ACCESS_BUFFERABLE;
* Q; r( \% j/ p7 c( X8 |. l
MPU_InitStruct.IsCacheable = MPU_ACCESS_CACHEABLE;
/ l/ x6 j( U% d) q
MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;8 n: H6 p/ z3 [, ?. b3 r) g
MPU_InitStruct.Number = MPU_REGION_NUMBER0;
% {9 a$ r \* G7 t: O2 ~5 b
MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL1;
9 _ y8 {8 Y; ^3 V. t! a0 q
MPU_InitStruct.SubRegionDisable = 0x00;
7 a! A5 I. B/ ^$ L' G4 K# ?
MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;
8 ]4 c$ r1 X: w* Z5 P( r4 n
6 n( V9 j P! y8 ^
HAL_MPU_ConfigRegion(&MPU_InitStruct);6 v3 ]6 Y. b# q
$ a. Q8 ?# o( ^! O: o
' O( h; `: _8 Y8 l& p Z
/* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */
1 Z) J: g- ~3 n- _/ \7 Z* J( E
MPU_InitStruct.Enable = MPU_REGION_ENABLE;
5 K& j) e* \2 V2 r- P
MPU_InitStruct.BaseAddress = 0x60000000;; x; }$ g4 U7 Y X$ q
MPU_InitStruct.Size = ARM_MPU_REGION_SIZE_64KB; 1 ~- b4 h7 d! [0 p
MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;' R2 L1 G$ I& i7 X" E
MPU_InitStruct.IsBufferable = MPU_ACCESS_BUFFERABLE;" }. D4 M% v/ F/ D. ^$ n, v$ X
MPU_InitStruct.IsCacheable = MPU_ACCESS_NOT_CACHEABLE; 6 S, t, |; R% P- w
MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;
3 v$ H2 ^' f- B6 U5 u& {
MPU_InitStruct.Number = MPU_REGION_NUMBER1;
: P+ n3 `) R' h9 @& [% O
MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;( y3 O j, r* I
MPU_InitStruct.SubRegionDisable = 0x00;1 O2 I7 [8 ~, D9 a, D+ P
MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;* P! ~' `* M$ v8 B* }
p ^. C( F T: L: P4 ^
HAL_MPU_ConfigRegion(&MPU_InitStruct);0 P$ l4 W! }) I- p- P( A( A4 k. I0 u9 u
- F. O, T0 K" r- S: l# O8 f
/*使能 MPU */
5 E3 r" I. _% U( @ f( U
HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
( C: N0 ~- k' A% \
}: i- f1 [$ Y1 L& M" O4 ]
# V$ O! k) B4 o4 p; o" a( E
/*
+ [6 {8 g: b7 n9 w0 ]4 e/ S
*********************************************************************************************************
* 函数名: CPU_CACHE_Enable
+ ^. s1 N9 L+ M4 g
* 功能说明: 使能L1 Cache
8 f9 q) R2 q: q/ _
* 形参: 无) K2 f& k! o! o
* 返回值: 无" t* H9 \) _/ m% t! @1 ~' E! v( |3 l
*********************************************************************************************************
$ P$ {9 N4 B; Y0 j5 e
*/% q6 R0 B9 T( ^4 u- O( Y
static void CPU_CACHE_Enable(void)
. F+ w8 N( [8 U, @' |% R0 e* _
{' Z" [8 _+ G0 ]
/* 使能 I-Cache *// Q0 h- L/ q! ]( m/ P" |
SCB_EnableICache();: c0 v" v) r4 I
4 x3 t5 P0 F* t t/ o
/* 使能 D-Cache */1 `8 B8 |1 L: U( S7 a
SCB_EnableDCache();' h4 d& |1 A$ t8 V. o, c; E3 A
}

复制代码

每10ms调用一次按键检测：
1 Y7 Z- K/ [1 X( `2 s* f% m1 K6 V9 E
F# S$ v' L* k% U6 b按键检测是在滴答定时器中断里面实现，每10ms执行一次检测。 ^. x1 u! s; o

: t* A& Z, Z+ T; }) ^

/** N" d) ~+ I( C [7 f! M
*********************************************************************************************************/ v/ Y. P8 N* m4 P6 \
* 函数名: bsp_RunPer10ms% {# K- _: i; b2 x; k
* 功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求
2 m- g' P! @! j5 s) o
* 不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。% y- h4 M2 H( j5 C; q( x& X, m
* 形参: 无$ y( @! @" S/ [
* 返回值: 无 {/ m9 m; E- @6 B0 D. J
*********************************************************************************************************2 h* `$ ?" Q5 V2 r% y4 f' Z
*/
4 P: W" ]8 y' |+ c: T7 n2 w- l
void bsp_RunPer10ms(void)$ l6 `( N* g% o
{( m1 q, e+ T$ n! N& v. r
bsp_KeyScan10ms();
4 g6 O2 f' B5 W2 F0 x6 m. v
}

复制代码

主功能：" G2 O( @3 Y$ r t" d. v7 y" N

4 Y" o9 `: R5 {主功能的实现主要分为两部分：
, d# i: \: d* \" \4 K
- _1 {3 T ]( m1 H ]8 I 启动一个自动重装软件定时器，每100ms翻转一次LED2' j) \; U- e5 k [
按键消息的读取，检测到按下后，做串口打印。5 |7 T- o" D! T# {! n

/*
7 d* j8 J- D' t% J
*********************************************************************************************************- ?8 B: e' [. G% ^# J
* 函数名: main: a! g3 r$ V1 D/ q( S; w
* 功能说明: c程序入口- U1 a Y ~5 v @. j
* 形参: 无
j- a# p9 ?! q. B0 X1 ~+ m: Y& L* i
* 返回值: 错误代码(无需处理)
, J# @- m R. c. j6 G. s
*********************************************************************************************************$ v% h: Q/ p" ^% P7 e+ F
*/2 u1 `( v# A% P8 B9 b" p8 N
int main(void)
$ V' y! C5 s$ J5 ^, w1 H" y4 |9 P+ w
{+ M* ~1 |1 w; [. @; d
uint8_t ucKeyCode; /* 按键代码 */
0 K0 L! m" O7 W" [0 P8 F7 n
2 @' N( D6 j4 l% r' w
bsp_Init(); /* 硬件初始化 */
3 @& z1 n) f& m% q/ a1 M
7 e% M u) v# Y2 |1 T' W
PrintfLogo(); /* 打印例程名称和版本等信息 */
! m! A1 |3 K9 s6 I8 z
PrintfHelp(); /* 打印操作提示 */* A* |: @9 q& z T3 m; S3 a1 v
6 M% t( c; p! H. f! q
8 h! C2 E9 S+ w1 w
bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 */- S. c: t: b6 P; L
) s9 t4 ^9 `% R
/* 进入主程序循环体 */
, ]) V! l% E+ s2 _+ P" A# u" ~3 X' b
while (1)4 a# h- Y; D4 ~4 J% H2 A) l
{
9 d4 b# k6 V6 h# q: O- Z8 P" c
bsp_Idle(); /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */2 f+ c* X* p. J0 k; X9 J
! }3 w# f: m5 V' `' R; i" N
/* 判断定时器超时时间 */. V3 s- Q/ p6 \( ~; A: g4 h
if (bsp_CheckTimer(0)) # p# m5 m% U7 Y$ J9 Y% C
{ D* Z3 L+ [2 {' e# `' v
/* 每隔100ms 进来一次 */ 3 I9 A" P% c, I% `: v
bsp_LedToggle(2);
, |& F3 L8 ~: r
}( ? m+ U" o( W' V4 K( r
; [: O* d! O# }. H8 q
/* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */* z0 f; K- F. n: Z6 {. ^
ucKeyCode = bsp_GetKey(); /* 读取键值, 无键按下时返回 KEY_NONE = 0 */9 _1 n3 `( N0 E1 H4 P1 V
if (ucKeyCode != KEY_NONE)
9 g- J" L9 M- q& \& Y- _! @
{0 U- m. s, v }+ t. O
switch (ucKeyCode)4 \! N! m3 o, s+ q! R
{, L1 l0 O- S" _- X( Y7 R2 M& p
case KEY_DOWN_K1: /* K1键按下 */
2 t$ ^+ z2 N1 |$ U: w2 S; x
printf("K1键按下\r\n");
: H8 z0 p ~5 l5 V) q! G, [, X
break;; }; |0 ^( |; S$ t, y
# p' a; Z* r+ o5 e' p ]( s2 T9 x
case KEY_UP_K1: /* K1键弹起 */
" M8 j0 V' w+ l" ?2 b. R9 q
printf("K1键弹起\r\n");4 F6 N1 w3 C: @1 T) ~/ J5 c
break;# O- u( W" U' F9 x) v* ^" {5 K$ K
0 q& R8 E! J3 W7 \! G, A. D
case KEY_DOWN_K2: /* K2键按下 */1 z6 u) D5 W$ X: G" L; _. C
printf("K2键按下\r\n");
( g5 ?0 u' \, K( I& d
break;
* E7 D8 b7 z4 G
& X& j) ^" E+ I. D, a+ l; _
case KEY_UP_K2: /* K2键弹起 */
1 o# B3 p+ i# `# w4 m( p
printf("K2键弹起\r\n");4 D9 m5 G3 F2 Z& @& t$ H! [# m5 c
break;
9 Y, E8 t. W# C2 W2 x( @5 _
H3 e: h, R7 G! e/ [8 |# h& t
case KEY_DOWN_K3: /* K3键按下 */
% z4 T" t. S: Q' l0 {
printf("K3键按下\r\n");+ Q3 O1 m$ n- }8 b# ]0 a
break;
( f8 }/ P5 t4 y/ u( E& F' o5 M. {
7 D' S: F$ r# n6 _ \
case KEY_UP_K3: /* K3键弹起 */# f3 n" p+ F( i. @
printf("K3键弹起\r\n");
% E1 [9 A2 Y! c
break;: S) r# ], T" S. d2 R. V+ r2 {& u1 E
; Y' H) w/ v0 g5 f8 J
case JOY_DOWN_U: /* 摇杆UP键按下 */ }" A. z- v- @& X
printf("摇杆上键按下\r\n");
8 L0 d& ~& ]. U: H: F7 [9 ^
break;
# b+ Y" ]' H/ O: ]
! S, W. S! n' |6 {3 C* s! x
case JOY_DOWN_D: /* 摇杆DOWN键按下 */1 ?- g5 s5 X8 z6 g5 S) N9 l) r& [# r
printf("摇杆下键按下\r\n");2 G5 W4 e+ X& p' s
break;
3 L8 g c5 a$ {3 u( W
9 D: j: Q/ l/ _2 E) f
case JOY_DOWN_L: /* 摇杆LEFT键按下 */
4 r# n3 D' H7 U1 D# ]3 o
printf("摇杆左键按下\r\n");
% G8 @/ G4 `- C% l
break;
( l8 F; \4 ] _0 u6 `2 X S# G
" w# j& ]8 B# @( R* _/ b+ u
case JOY_LONG_L: /* 摇杆LEFT键长按 */- h1 l+ n1 t# c$ i5 l
printf("摇杆左键长按\r\n");# z0 p" x+ X) A6 W" ~. w. `
break;
: D: ~# o" P6 O/ Z6 {8 C
+ ~7 D- V" D( ^' w$ N+ p
case JOY_DOWN_R: /* 摇杆RIGHT键按下 */0 O, J7 t8 M# m1 O% ^" S& }6 [
printf("摇杆右键按下\r\n");
% k5 I/ x: }: E n. @* I- z U
break;4 G4 J/ E6 ~ O
9 M C0 |9 t m- O0 O2 p
case JOY_LONG_R: /* 摇杆RIGHT键长按 */! ~2 s! R4 B/ @9 f4 G- o
printf("摇杆右键长按\r\n");
Z$ \- F" Q' a! t8 U/ |
break;
2 }: i) i6 Y8 d* K* E# B
$ T9 S; p+ i, I8 u% ]( j% N# I! b0 z
case JOY_DOWN_OK: /* 摇杆OK键按下 *// B& R6 e3 O& A3 _8 H
printf("摇杆OK键按下\r\n");
, u4 c( H4 h0 K1 y
break;* Q7 K$ _0 M! ~9 I
* ]7 o+ d5 H3 C% q6 F0 r
case JOY_UP_OK: /* 摇杆OK键弹起 */
* \0 V; E3 i1 }6 K- S! |
printf("摇杆OK键弹起\r\n");
7 m0 L" o9 l6 \1 H
break;
7 N9 x% I1 z" w5 C8 e
s2 T% i# k* J! B9 U2 r5 A' d
case SYS_DOWN_K1K2: /* 摇杆OK键弹起 */
5 A( ?0 A4 N# o3 n* C
printf("K1和K2组合键按下\r\n");6 K: l+ U! h& Q* d# S0 f+ o8 m v
break;! J$ z# ~+ a/ l& L7 G! [
7 w$ N* v6 l8 `( ^6 P! D" t
default:
* I' Q2 _- G5 n2 b4 V6 Y
/* 其它的键值不处理 */! R4 z" Q' z/ H# b" B9 A8 R
break;
0 X0 \+ f3 X( _$ T2 c
}& z K7 @' v' g8 ^. J$ c+ p
7 {- O @% V# w c4 c6 f8 f6 a
}
1 x0 ?5 X" @ Q7 T, h& `) J
}
5 G# a' ]# J' w. q" k
}

复制代码

19.8 实验例程说明（IAR）
5 o% u1 c3 F3 L配套例子：
( }) i% l2 u( G" \) s% q5 [/ G7 m7 ~2 Z5 [7 I* Q. s2 d+ ?5 |4 L
V7-002_按键检测（软件滤波，FIFO机制）
, M, k+ M4 v) u
0 k: }0 x- J5 ~: a! e实验目的：4 K2 R/ T9 Q4 N, G1 j# W
; |. n2 N, _) v+ h; B" K2 U
学习按键的按下，弹起，长按和组合键的实现。2 o$ i* T+ c. A& _3 H
实验内容：
4 a/ e  n8 \$ [) y0 K; l% P3 j( J4 `: t2 b1 s4 c
启动一个自动重装软件定时器，每100ms翻转一次LED2。6 h# v7 }: y9 f' I& ]6 r; x7 e0 X
实验操作：* K7 h- w) x+ ]: ~& ~! j1 M( g; h, w. Y

" ~/ f- a  R4 `; e" s% K, s3个独立按键和5向摇杆按下时均有串口消息打印。
$ q* T$ T: n$ g1 ^$ @6 F& i7 v5向摇杆的左键和右键长按时，会有连发的串口消息。
& `5 [. H$ H: d" l2 ~2 t8 l+ V- S, l独立按键K1和K2按键按下，串口打印消息。
% A/ y/ y; @9 z4 \- a上电后串口打印的信息：/ @% I+ |5 E. ^4 P
. r4 m* |* l8 Y* f  n. b
波特率 115200，数据位 8，奇偶校验位无，停止位 1$ l5 A: ~3 _1 d; k4 T- f
3 J( O8 \. v2 R

  ]4 {0 n" D% p/ G0 a, T
6 m, ]( C, }- ^5 M8 B6 `. G  e程序设计：
/ `+ M2 S4 m2 I& H- N: y
3 @" A6 E. v" e0 g  系统栈大小分配：, l8 A5 P/ v& X& v( ]9 [
# L4 ~4 `- O$ e, S% Z% f

( ^$ l! s1 a0 z8 j4 I1 H* b. j6 R  [1 W! @7 n
  RAM空间用的DTCM：
  r: V; @4 L$ K- A
  n6 A: }) o: \2 b2 R# C, h

7 n2 y- l: o( F0 s
# ?( Z' u# r" `2 D( c9 e
  硬件外设初始化
5 g! T2 O! G/ S5 @* s& I8 g5 Z9 G! T( \. e* w# i3 ~
硬件外设的初始化是在 bsp.c 文件实现：9 ^" i7 L$ s5 _3 u5 d3 {
1 W/ s# Q% N$ Z' N: u7 U" |* `! h

/*
2 l' t! ~. h. G2 l
*********************************************************************************************************
$ k0 a- H5 _1 q- F
* 函数名: bsp_Init# J/ |& _) y5 G( _" v: k3 |
* 功能说明: 初始化所有的硬件设备。该函数配置CPU寄存器和外设的寄存器并初始化一些全局变量。只需要调用一次
* r* m+ w8 B# F0 q
* 形参：无
, R# J7 A2 E' ^ C! x& u. c
* 返回值: 无
' ]% T; S. A" k
*********************************************************************************************************+ A: U9 B6 @, N2 I1 d( X# J5 {
*/
. o1 u* W4 L' f
void bsp_Init(void)! g% ]7 b- L# g6 Q) T# _$ V/ ~" l
{
' Q% Z: _6 ~6 D) L( `
/* 配置MPU */. h | O G3 m. ?$ r
MPU_Config();
6 m& x9 i _8 m( T4 ~
8 d$ N; P3 x( M5 n/ p
/* 使能L1 Cache */: s) f1 n( u f9 p. ]" }
CPU_CACHE_Enable();" N& |0 e+ a1 P/ c: t# u: g3 N
a+ m Q8 e% h& a
/*
" b3 [& i5 O! j; O8 h" Y2 J' V* I8 d
STM32H7xx HAL 库初始化，此时系统用的还是H7自带的64MHz，HSI时钟:+ w. R/ c" t' L& ~7 E% t
- 调用函数HAL_InitTick，初始化滴答时钟中断1ms。
9 Z9 z0 X- o' |. d
- 设置NVIV优先级分组为4。1 b) _- y& A7 q+ o
*/
0 P. f0 x. s7 x' ]+ E: q: \) Z
HAL_Init();& e; H8 H2 v0 B4 {
+ A: n8 E$ ^# _+ {: J
/*
3 c- k- k3 u$ u) e9 ~0 u3 Z' K6 }' ]
配置系统时钟到400MHz3 r: R: X$ e6 F
- 切换使用HSE。
9 R) [; i9 s; P* U. L) U
- 此函数会更新全局变量SystemCoreClock，并重新配置HAL_InitTick。
6 v, r0 u9 b5 U3 Z% U4 i
*/
1 g( s- o+ J: y
SystemClock_Config();
; K; p& l/ W+ q( I
( w: @) P5 c" ?1 S7 {
/*
# N, M( k) v* N4 }2 d
Event Recorder：
: f$ V) c8 }4 i0 _' T
- 可用于代码执行时间测量，MDK5.25及其以上版本才支持，IAR不支持。' q2 t# n2 s6 P: @. x* P
- 默认不开启，如果要使能此选项，务必看V7开发板用户手册第xx章
, j7 g$ B3 e+ Q) n! Q
*/
; ?2 V! e8 c) q4 g/ j
#if Enable_EventRecorder == 1
/ G5 m3 y* y8 o @* Y
/* 初始化EventRecorder并开启 */2 z& f3 h1 j3 w' N) Q5 S) S
EventRecorderInitialize(EventRecordAll, 1U);" m, Z& M* G5 H9 o2 P* z; e
EventRecorderStart();* [5 E( S( T4 Q+ X
#endif
& v5 @7 f8 [2 H- T! V
5 P6 b; h' E: J$ a/ v
bsp_InitKey(); /* 按键初始化，要放在滴答定时器之前，因为按钮检测是通过滴答定时器扫描 */
0 C, l4 z& Z: J% v
bsp_InitTimer(); /* 初始化滴答定时器 */
9 C/ ]' S+ [. t, D; M7 V& M& D2 L
bsp_InitUart(); /* 初始化串口 */
) ~0 K% f1 e* L7 {' K
bsp_InitExtIO(); /* 初始化FMC总线74HC574扩展IO. 必须在 bsp_InitLed()前执行 */
7 v4 `- Z+ y3 t) Z
bsp_InitLed(); /* 初始化LED */
, A0 O% O _$ ^1 K
}

复制代码

MPU配置和Cache配置：2 ?. w, ^0 ~9 ^6 k# B' h
" m) R% R$ E' L. q9 h# t
数据Cache和指令Cache都开启。配置了AXI SRAM区（本例子未用到AXI SRAM）和FMC的扩展IO区。2 u I/ I' ], y$ `/ P( ^+ `. h3 u

( R$ q* [3 z' o2 P

/*
& p7 J; K+ Z& R( A; K
*********************************************************************************************************2 G' c9 a& F6 ]' j
* 函数名: MPU_Config* {+ E5 R9 }9 T; S- J* h
* 功能说明: 配置MPU
0 ~; {2 u* ^2 k
* 形参: 无; E7 R, y0 t# u* z3 B i0 G
* 返回值: 无
) V: Q) W2 F5 T0 l
*********************************************************************************************************
9 q: o5 Y, [# A, P% V* a9 p
*/* o1 Q; h \, I% L: v9 `
static void MPU_Config( void )
2 N3 ]; `( [$ b4 ?. o. ?, `2 G
{
- f, r& i4 z* v+ _1 \8 S
MPU_Region_InitTypeDef MPU_InitStruct;
& J |# B# n2 i' k" s2 s" t4 }
2 i, W/ z5 U; D- N( T' y
/* 禁止 MPU */
3 G; ]4 N) v: \6 f2 {
HAL_MPU_Disable();
4 i: W9 [: M: S& ?5 e" O
/ w/ c- T0 w$ D0 r9 D6 Z+ r
/* 配置AXI SRAM的MPU属性为Write back, Read allocate，Write allocate */* S- W, A2 R3 W9 c! s6 ]
MPU_InitStruct.Enable = MPU_REGION_ENABLE;0 [( N$ A7 U8 p& a1 [
MPU_InitStruct.BaseAddress = 0x24000000;' n+ U1 T4 m: F; c5 R: r- h! j
MPU_InitStruct.Size = MPU_REGION_SIZE_512KB;0 Y- d5 J1 r+ Y7 g i2 l
MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;
2 P9 b' l. C$ V. |! L; ~* T
MPU_InitStruct.IsBufferable = MPU_ACCESS_BUFFERABLE;' k* s1 g* N. v3 I$ I$ t9 O. |+ b
MPU_InitStruct.IsCacheable = MPU_ACCESS_CACHEABLE;2 @) v# O3 B' h7 j R2 m$ o
MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;
' f% z& O1 G9 _8 x# D0 c! y
MPU_InitStruct.Number = MPU_REGION_NUMBER0;
% U) K5 c, P" o' R- X
MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL1;
, c" g8 Z. {) @% ^* u7 ]
MPU_InitStruct.SubRegionDisable = 0x00;
- {/ @6 O/ J: L7 w' h. H S# H6 k
MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;( P7 d! f9 T2 ^
1 D. f- y5 j1 E& m" r/ Y
HAL_MPU_ConfigRegion(&MPU_InitStruct);' p; l6 \. X$ e" c9 C% Q
3 w# f( `' D3 J C" E: W3 H+ E
! w8 p0 J: j) m6 p" Z' u/ \8 Q
/* 配置FMC扩展IO的MPU属性为Device或者Strongly Ordered */" d. v" U0 V7 d7 U" `& Y
MPU_InitStruct.Enable = MPU_REGION_ENABLE;, T9 @" d( K. a# F# B" z9 S
MPU_InitStruct.BaseAddress = 0x60000000;
% i. e# \: d* N0 ^
MPU_InitStruct.Size = ARM_MPU_REGION_SIZE_64KB;
# o/ z# k! W9 {; u. S
MPU_InitStruct.AccessPermission = MPU_REGION_FULL_ACCESS;3 C. \) f5 D S* O+ L/ b
MPU_InitStruct.IsBufferable = MPU_ACCESS_BUFFERABLE;
/ }6 n) l" O0 R7 i5 {: o8 H0 c
MPU_InitStruct.IsCacheable = MPU_ACCESS_NOT_CACHEABLE; # D, J& Y0 e* @" n9 ]
MPU_InitStruct.IsShareable = MPU_ACCESS_NOT_SHAREABLE;$ z9 h" [" o# O& ?7 a. k/ z
MPU_InitStruct.Number = MPU_REGION_NUMBER1;& [" `* g1 s' M& R4 Q8 [4 [/ q
MPU_InitStruct.TypeExtField = MPU_TEX_LEVEL0;
# n# W- h4 O* [# M7 O
MPU_InitStruct.SubRegionDisable = 0x00;/ N* d5 O) o/ R
MPU_InitStruct.DisableExec = MPU_INSTRUCTION_ACCESS_ENABLE;- M/ V+ L& ?" u/ h
; I( C: j, E9 `1 W/ x2 J3 P9 x+ i
HAL_MPU_ConfigRegion(&MPU_InitStruct);
7 ^6 H5 [% N3 y7 ~; w1 w2 n
: I* }' L' ?, t& K8 }( W7 ~5 G6 Q7 G
/*使能 MPU */
) n2 o' d; g M
HAL_MPU_Enable(MPU_PRIVILEGED_DEFAULT);
$ C4 X5 n7 }, K6 |% Z0 A2 B' M0 p
}# X# \1 f1 A+ ~ d* e
/ `7 R: i& j5 U. V2 p' [2 }
/*/ Y& E1 b3 E7 u& i
*********************************************************************************************************
# K# w" D* {5 G# Q- G& `9 ~
* 函数名: CPU_CACHE_Enable1 x; w7 q" J- o+ T
* 功能说明: 使能L1 Cache
$ W5 b: o5 H# i) K4 V
* 形参: 无4 q0 \' p$ c) q' v/ L) x
* 返回值: 无 Y+ |% F# Y2 y7 t" g. ?. B
*********************************************************************************************************
) C& Q% X; C) K
*/6 b, T7 o$ V+ n# R9 `$ \
static void CPU_CACHE_Enable(void). [$ n8 g7 w$ `, i7 i
{, w1 h4 ^, w7 }9 n& q3 o* _: ]1 j
/* 使能 I-Cache */9 Z$ ~7 W; g% Y' i* q- p% _
SCB_EnableICache();
) j- D: C9 Q; M( ~# j
9 A w1 ~5 z; b- h0 f
/* 使能 D-Cache */
P d% e5 k7 U2 V$ @1 H7 W" ~
SCB_EnableDCache();: c" T1 G5 y3 I' m) \
}

复制代码

每10ms调用一次按键检测：( U2 H& a3 v' p5 C, o

: I! b( d, {$ |按键检测是在滴答定时器中断里面实现，每10ms执行一次检测。0 K g) D# Y4 Y) R5 h9 b8 H

- B* w2 g% H9 Y: q) H1 p

/*
6 E6 D! \' b3 t7 p, Z( E- o
*********************************************************************************************************. ~+ \4 @ [; @, ~2 B. D7 X2 }$ p
* 函数名: bsp_RunPer10ms1 U; c- T& }. i" X
* 功能说明: 该函数每隔10ms被Systick中断调用1次。详见 bsp_timer.c的定时中断服务程序。一些处理时间要求' K" k" N$ O9 x7 O: i
* 不严格的任务可以放在此函数。比如：按键扫描、蜂鸣器鸣叫控制等。
/ Y" e5 S# l* @1 D% E5 y
* 形参: 无
8 q, M& Y; o0 y
* 返回值: 无( y9 T0 {7 H2 x. D: O; O
*********************************************************************************************************
& y7 x7 Z5 Q$ o! k
*/
K5 x' ~' ?! @, K
void bsp_RunPer10ms(void)
& k7 a, H; t7 k
{
w- r# j+ `; ]6 T* Z
bsp_KeyScan10ms();
}

复制代码

主功能：
% q' K) m2 K$ S5 }9 w; X* C- ?5 K1 t/ M
主功能的实现主要分为两部分：
" |: {' D- H, r) z- J7 V( P" h- x( y0 t; M: {+ O
启动一个自动重装软件定时器，每100ms翻转一次LED2
5 } w/ b+ j$ W! y% g) P; L. Z 按键消息的读取，检测到按下后，做串口打印。' k% z( b4 Q! X# i V

/*9 I7 l% b$ K& `/ Q- L) Z, H9 [
*********************************************************************************************************
H3 ]7 k/ g% s7 @
* 函数名: main- _/ L4 P4 T/ ~; }
* 功能说明: c程序入口2 ?$ y; V x, R2 \; G
* 形参: 无! ^3 X3 M* D: r9 ~. B6 M3 n
* 返回值: 错误代码(无需处理)' {4 R, {* @$ `
*********************************************************************************************************4 I: Y7 W6 p: g
*/' V6 I3 A! q8 t6 q. I4 q8 y
int main(void)9 L: i9 X5 t4 C8 m y" Y' a9 o* ~
{# R; u s6 k) ?+ c
uint8_t ucKeyCode; /* 按键代码 */3 S4 X( s* k* P6 Q' h2 `4 L
: A6 {: H0 T% Q% {/ k* G9 ~* S! A6 ?
bsp_Init(); /* 硬件初始化 */6 D" {6 F) L% j& L% ?% l
" V/ a* _% v1 A
PrintfLogo(); /* 打印例程名称和版本等信息 */8 L1 }" O0 d6 D9 X
PrintfHelp(); /* 打印操作提示 */3 |3 r4 r" V1 `- M, `/ O2 W
% |4 k' t; z* L9 r0 }' O
- M: W0 d d" t3 z$ |5 e- a
bsp_StartAutoTimer(0, 100); /* 启动1个100ms的自动重装的定时器 *// y, W' A) P+ W3 ~. [+ v8 e) s
8 q. q% V) U4 a
/* 进入主程序循环体 */4 f Y+ x* ~- t
while (1)
1 s4 J8 f k' J6 @6 ?* R
{
# m9 q, i& L* F( O* M# ~" x6 G
bsp_Idle(); /* 这个函数在bsp.c文件。用户可以修改这个函数实现CPU休眠和喂狗 */0 ?* v0 R( s5 Z1 D0 j& x
0 t/ |5 K# q5 i9 }4 V" {
/* 判断定时器超时时间 */
( G+ Z" c' p' w* \7 A4 o$ S
if (bsp_CheckTimer(0)) . L! p6 t% B2 u# _8 b. {
{
5 x' ~. m- H* ~9 D8 {
/* 每隔100ms 进来一次 */ 7 f! i) f; g0 d0 @2 {
bsp_LedToggle(2); 8 `' _" [1 p" O) N
}
4 j) g/ d+ y! U. d2 N X
) X# X/ Q. i/ U
/* 按键滤波和检测由后台systick中断服务程序实现，我们只需要调用bsp_GetKey读取键值即可。 */
7 G5 n8 L- u' u! {( p7 k
ucKeyCode = bsp_GetKey(); /* 读取键值, 无键按下时返回 KEY_NONE = 0 */
9 K H+ D2 E; B* b9 |: w$ ]
if (ucKeyCode != KEY_NONE)
5 g" a: e1 D# Y9 r$ o# S
{) Y, `- I, u @1 C/ T( F3 M
switch (ucKeyCode)5 |% W1 w8 g% y0 \
{
R/ c; {% K4 ~* F3 z; ?
case KEY_DOWN_K1: /* K1键按下 */
7 O+ x/ ]1 S4 R3 f7 n0 M; @
printf("K1键按下\r\n");# j# G2 v+ P8 m9 Y F. d8 b0 F
break;9 J" M! c' f$ }0 O* M) {8 ]: ~
/ M& O4 I7 \' c2 n* u
case KEY_UP_K1: /* K1键弹起 */' M* ]7 A) Q; c4 ] A- ]
printf("K1键弹起\r\n");
' H6 R7 W' M) A4 z `+ k
break;3 U) p# w# f. \7 y9 o
9 N. D$ \& H6 m0 z
case KEY_DOWN_K2: /* K2键按下 */
0 T5 g, l3 u, R" _0 l0 r6 L- \
printf("K2键按下\r\n");
& b+ q! L5 y8 k, @$ v- I. H
break;* L9 u {0 B6 ]5 U) ?
2 e u, L4 A% G x0 n
case KEY_UP_K2: /* K2键弹起 */ z% D6 [ K5 ~6 o- P8 n
printf("K2键弹起\r\n");9 t, q2 |" x% Z" n* F: e A& @, y, @
break;2 ^8 j" @) I- f# {
1 w; z) Z/ h2 n8 G8 `
case KEY_DOWN_K3: /* K3键按下 */, G5 n& r5 C5 K$ s) _6 u
printf("K3键按下\r\n");( t/ K' u, c2 i0 G5 Q; O
break;
+ b% C0 X7 @! y* V! D% b4 ?
2 x' ~- S: p4 N& `
case KEY_UP_K3: /* K3键弹起 */+ D+ ^/ F/ \! c2 e- p9 J: X
printf("K3键弹起\r\n");! V9 p' G! ^- T: [/ m y8 `
break;
$ y+ Y9 `) ^) X4 X F" N& d: N
8 A; f b' j4 u
case JOY_DOWN_U: /* 摇杆UP键按下 */
. w0 f; ]8 h" ?& @" i3 d9 s
printf("摇杆上键按下\r\n");
# N# U& O) S: Z3 C; t
break;
" a- S6 ?' s. Y: ]* G5 s8 h+ [
1 J* B3 k( R `$ t6 Y; b
case JOY_DOWN_D: /* 摇杆DOWN键按下 */* ^7 @( N% C( J/ f$ p) l, e
printf("摇杆下键按下\r\n");
2 _) j8 I! }/ p
break;
5 Y1 [/ _& E2 u' k0 S6 u6 R
3 A2 l( R0 s, W& `. X
case JOY_DOWN_L: /* 摇杆LEFT键按下 */1 d5 J0 W* t7 N
printf("摇杆左键按下\r\n");
+ A# _) D. |1 m6 U4 v! u) a
break;' [& Y. @' }/ O5 @1 i; R- u
$ Z, c6 e. k( S
case JOY_LONG_L: /* 摇杆LEFT键长按 */- H* V7 u) ?. W4 T
printf("摇杆左键长按\r\n");+ ~8 E9 n |$ Z5 T B
break;8 t2 J4 B& D" |- E6 O
! ^6 M' e$ e* f3 Z: Z0 Y
case JOY_DOWN_R: /* 摇杆RIGHT键按下 */: L" a0 ~# P7 N4 h, e) l6 i4 S2 K5 p
printf("摇杆右键按下\r\n");5 z+ M/ o0 _+ s
break;
/ q; N; l, e; f7 Y! R: y# X
# }+ _8 W; z! A" {- R P5 ^8 [
case JOY_LONG_R: /* 摇杆RIGHT键长按 */
7 ` s6 K$ ~/ V7 R
printf("摇杆右键长按\r\n");( D3 ]* o2 U0 U* A+ T8 x# ^% z0 M
break;+ h4 P' o4 Y5 w; U0 Z, y4 B- E/ ^* F D
. ?$ M; k. x5 M5 u M7 D, O
case JOY_DOWN_OK: /* 摇杆OK键按下 */5 c+ v! [+ Y T4 n# ?2 Z+ p5 f) D
printf("摇杆OK键按下\r\n");
# x- @* u6 q2 N: ^+ e, i
break;
% U D8 m) ?4 r* f8 J' n7 X
z) S9 z D% e
case JOY_UP_OK: /* 摇杆OK键弹起 */
2 h- n0 @" m: w9 p5 q. G% D' j
printf("摇杆OK键弹起\r\n");
. l. \4 b6 R6 f( s' Y% g# I( v* x" v
break;4 f# k* r) a/ r- y; W' p
0 k9 J9 v @+ m( }! u
case SYS_DOWN_K1K2: /* 摇杆OK键弹起 */
* S6 ^8 Z" H# J7 v2 Q+ C$ s1 [& a
printf("K1和K2组合键按下\r\n");8 I; g7 ^: u; r5 I
break;
; R5 I X$ [& g5 o3 M
8 J( Z5 o) X- V' ^& Y
default:' ~3 n+ ?* `( s4 ^ M: ]. G. G
/* 其它的键值不处理 */
1 X; V' p+ s7 Z {. P" A* }
break;
$ m4 Z/ E" B% B) [
}
) m) O# L t0 j U
: \* X1 ~4 R! ?
}
2 y6 |0 x5 q3 s# y: W
}
5 E% i# G5 I; D% X! B: ~1 ` ~3 \
}

复制代码

: i; Z D' N' e
9 L9 P5 H0 r. t/ I& r9 ]! M19.9 总结0 ?9 e/ X( I- d9 V" ? k
这个方案在实际项目中已经经过千锤百炼，大家可以放心使用。建议熟练掌握其用法。
7 b; w" w+ N2 ?8 J, |' u4 \/ |/ U9 {5 m5 |9 B