【经验分享】stm32按键FIFO的实现

[复制链接]

STMCU小助手发布时间：2022-1-18 22:21

技术帖
文章封面:
文章简介:	要介绍实现按键FIFO的优点，首先要了解FIFO的一些基本概念。FIFO即First In First Out，是一种先进先出的数据缓存方式，例如在超市购物之后我们会提着满满的购物车来到收银台排在结账队伍的最后等待付款，先排队的客户先付款离开，后面排队的只有等待前面付款离开才能进行付款。说白了FIFO就是这样一种先进先出机制，先存入的数据在读取时最先被读取到。

1、设计按键FIFO的优点

　　要介绍实现按键FIFO的优点，首先要了解FIFO的一些基本概念。FIFO即First In First Out，是一种先进先出的数据缓存方式，例如在超市购物之后我们会提着满满的购物车来到收银台排在结账队伍的最后等待付款，先排队的客户先付款离开，后面排队的只有等待前面付款离开才能进行付款。说白了FIFO就是这样一种先进先出机制，先存入的数据在读取时最先被读取到。

　　设计按键FIFO注意有三个方面的优点（来自于安富莱电子Eric2013大佬总结）：

　　1、可以有效记录按键事件的发生，特别是系统要实现记录按键按下、松开、长按时，使用FIFO来实现是一种不错的选择方式。

　　2、系统是阻塞的，这样系统在检测到按键按下的情况，由于机械按键抖动的原因不需要在这里等待一段时间，然后在确定按键是否正常按下。

　　3、按键FIFO程序在系统定时器中定时检测按键状态，确认按键按下后将状态写入FIFO中，不一定在主程序中一直做检测，这样可以有效降低系统资源的消耗。

2、按键的硬件设计

　　按键的原理图如上图所示，对于KEY0~KEY2这三个按键，一端接地，另一端连接stm32的GPIO端口。当按键按下时相应的IO口被拉低，如果把GPIO口配置为输入模式，此时读取相应的IO口电平，就可以检测到按键是否被按下。对于KEY_UP按键则是与前面三个按键相反，IO口配置为输入模式时，读取到高电平时表示按键按下。因为机械固有的物理特性,按键按下内部弹簧片在瞬间接触的时候会有力学的回弹,造成2-8毫秒内信号不稳定，所以在设计检测机械按键是否按下的程序时，应考虑到按键消抖问题。

3、按键FIFO代码的设计

3.1 按键FIFO代码主要框图

bsp_KeyScan()检测到按键状态时以3*x+1关系计算出（x代表按键编号）写入FIFO值，例如：

FIFO中读取值1---------------->按键1按下

FIFO中读取值2---------------->按键1弹开

FIFO中读取值3---------------->按键1长按

注意：在配置按键GPIO相应模式时，如果按键硬件设计没有电阻上拉，那么在配置GPIO口时必须将GPIO口内部配置成上拉状态，否则对读取按键结构有影响！

3.2 按键FIFO代码实现

bsp_key.c实现

#include "bsp_key.h"$ g) T8 A& H# S1 w( h2 T9 K
P+ v7 ?/ K4 Q2 B
/*. F# ?+ ?! \. y2 Q& I7 ]
开发板按键口线分配：4 e, o1 g& s3 \1 w- `7 W- E; e
K0 键 : PH3 (低电平表示按下)8 Q7 a( x Y9 ^+ v
K1 键 : PH2 (低电平表示按下)
! A/ b$ q2 R* \6 Q$ p' v
K2 键 : PC14 (低电平表示按下)# L# `% K4 }# F- o: _' t& A
WAKE_UP键 : PA0 (高电平表示按下)
: ~! P/ e) E, F
*/
+ E$ f, x% _& U1 O' z
6 a& }4 N2 o$ ?$ K; N0 I+ d- `
/* 按键连接GPIO对应RCC时钟 *// z! Y. u& u/ _3 z+ v3 \
#define RCC_ALL_KEY (RCC_AHB1Periph_GPIOH|RCC_AHB1Periph_GPIOC|RCC_AHB1Periph_GPIOA)
. N" v8 J" ~6 r1 w; W. L# x
: h3 l5 Y8 `: X) @. Y& }% \
/* 按键0的GPIO----------->GPIOH3 */; J7 r7 i# x9 G5 l7 a' ?: x: a' Z9 N/ X
#define KEY0_GPIO_PORT GPIOH7 U' b; Y) `4 U+ c
#define KEY0_GPIO_PIN GPIO_Pin_3 ) M( n8 _* }( {. o) ~
9 x# T7 Z* ^, b' n! X4 J F0 |
/* 按键1的GPIO----------->GPIOH2 */! a3 ^3 ?/ x9 ^# Q$ r" w; _
#define KEY1_GPIO_PORT GPIOH
+ ^2 w- s- p6 S; e" o8 [% H+ e
#define KEY1_GPIO_PIN GPIO_Pin_2
) ]- b; Z4 E6 o' e* j% Q }: g
, ~& O4 T" a" U S0 N: @
/* 按键2的GPIO----------->GPIOC13 */. J) W: i7 o7 S; k# K
#define KEY2_GPIO_PORT GPIOC o* z! d6 W6 M2 z
#define KEY2_GPIO_PIN GPIO_Pin_13 9 ]+ _$ R5 ?: e/ c. s# D0 _/ I7 R- d
5 C. k/ A' W8 |
/* 按键WK_UP的GPIO----------->GPIOA0 */
5 `5 ?" N4 x. m% E2 M8 a- T
#define KEY_WKUP_GPIO_PORT GPIOA* r8 J8 l- J( D* P2 ?$ x0 g2 c
#define KEY_WKUP_GPIO_PIN GPIO_Pin_0
0 O% Y' o- Z) R- H
* N/ d, J" C; _) v
static KEY_T s_tBtn[KEY_COUNT];
" Z% S* o1 t: `) [
static KEY_FIFO_T s_tKey; /* 按键FIFO变量,结构体 */
t6 j: @5 h' I# q4 S1 e6 F
" w7 X W7 M' h4 x/ _5 I
static void bsp_InitKeyVar(void);
& i7 y$ B* G- }: b$ w
static void bsp_InitKeyHard(void);
& a9 K9 S$ s2 w/ c1 F
static void bsp_DetectKey(uint8_t i);
% S! ~. L& H/ V* N
( m4 v- H; Q; A9 f# ]
/*. Y# b( a% U l$ g# [( y
*********************************************************************************************************
* b# U$ C+ _% k$ K( a8 M2 K
* 函数名: IsKeyDownX
( I6 g! `- \7 e8 i8 G% H( d
* 功能说明: 判断按键是否按下
. U/ w5 X7 L0 H/ ]
* 形参: 无
, \8 s" j- t! Q8 F# j# [
* 返回值: 返回值1 表示按下，0表示未按下
: @, o" v6 N) @( u' E6 ?: n( x S
*********************************************************************************************************
+ [ _, @9 }6 g" \# c
*/
; s \" S" t7 r/ E5 U
static uint8_t IsKeyDown0(void) {if((KEY0_GPIO_PORT->IDR & KEY0_GPIO_PIN) == 0) return 1; else return 0;};
5 h; f: m9 c2 b4 m9 k* a- P* ^
static uint8_t IsKeyDown1(void) {if((KEY1_GPIO_PORT->IDR & KEY1_GPIO_PIN) == 0) return 1; else return 0;};
' V8 o1 D9 f. A U& h ~
static uint8_t IsKeyDown2(void) {if((KEY2_GPIO_PORT->IDR & KEY2_GPIO_PIN) == 0) return 1; else return 0;};
3 D& e4 g3 O* N7 i. h
static uint8_t IsKeyDown3(void) {if((KEY_WKUP_GPIO_PORT->IDR & KEY_WKUP_GPIO_PIN) == KEY_WKUP_GPIO_PIN) return 1; else return 0;};
: n4 b9 N" o( `- Y" J
+ T: p+ E& g. p- H1 P! v& l
/*
3 x9 B% @, t; x
*********************************************************************************************************
7 y6 \( A$ a7 d# V
* 函数名: bsp_InitKey- {. P: q8 `1 g+ w5 u: B
* 功能说明: 配置按键相关的GPIO，该函数被 bsp_Init()调用。
: R) h+ g* o; b x
* 形参: 无9 z4 k: e1 T- o* W4 M' u
* 返回值: 无0 Z3 } i3 Z# u2 n" ^" L' D* z) V' z
*********************************************************************************************************
2 }0 j. X Y W" n0 S
*/" I+ b3 C5 |+ ~' ?1 g" B6 Z% h
void bsp_InitKey(void)
5 K* N% y8 W4 E: g
{, K& K5 o+ N C5 Z: Y! V+ t6 h" d
bsp_InitKeyVar(); /* 初始化按键变量 */0 u; d4 \$ z K0 ?1 J
bsp_InitKeyHard(); /* 初始化按键硬件 */
, g& G9 J7 j( q$ [" [
}
9 j! }) G7 H$ k
, P; E1 n2 f' t. }) u& p
/*
; N7 |+ ?, W2 A! m% `
*********************************************************************************************************, _ H! e1 \% i+ \
* 函数名: bsp_InitKeyHard! M+ L+ G- h! D/ e% d, ^. F
* 功能说明: 配置按键相关的GPIO，该函数被 bsp_InitKey()调用。
% h. h* b [) U B
* 形参: 无
+ x# G9 `4 v& p, X, x
* 返回值: 无
& O2 @& \: G6 H& w9 e6 c5 l
*********************************************************************************************************
7 w; N) @4 |" ]( n B3 z0 f. z
*/( C0 k9 ^+ T% s" x
static void bsp_InitKeyHard(void)' y! X5 p8 w, F* m
{# O2 \% ? }4 P! l; _) V, @
GPIO_InitTypeDef GPIO_InitStructure;
0 x5 e9 J+ i0 L! \
1 J6 b5 p: V [5 p
/* 打开按键连接GPIO的RCC时钟 */
: ~. I6 K% h3 f$ J) I
RCC_AHB1PeriphClockCmd(RCC_ALL_KEY, ENABLE);. J" x' V: w, z" r1 n- J
- z3 N' G' p/ W. H
/* 设置按键连接GPIO为浮空输入模式 */) p& c3 ~! D7 }4 k8 S; i8 p5 G2 }" V
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN; /* 设为输入口 */
k! i6 @: c; o2 r: X
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP; /* 上拉电阻 */
% M* [: v: N0 k6 z3 U% H
! c& o( w+ Y3 U4 {! W0 \% P2 V
GPIO_InitStructure.GPIO_Pin = KEY0_GPIO_PIN;# [/ S3 I( X9 l! I
GPIO_Init(KEY0_GPIO_PORT, &GPIO_InitStructure); ^; f1 o8 Y/ X# u
3 }- ~( t$ h# g5 z: g4 ?
GPIO_InitStructure.GPIO_Pin = KEY1_GPIO_PIN;
/ E/ c" [' N& n. K: ^7 [
GPIO_Init(KEY1_GPIO_PORT, &GPIO_InitStructure);
& _& z8 w7 ]( s6 T3 M( s1 d2 \
0 m% R( s9 X) L* r, u; H$ f
GPIO_InitStructure.GPIO_Pin = KEY2_GPIO_PIN;
1 W- h" G! m3 T4 s3 N, V2 |
GPIO_Init(KEY2_GPIO_PORT, &GPIO_InitStructure);/ @4 ~# Q% _. G, F- k2 k7 V
& l* w5 r7 r. Y9 D+ V8 X# A
GPIO_InitStructure.GPIO_Pin = KEY_WKUP_GPIO_PIN;7 A4 x3 t. d% v7 W' z. N
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN; /* 下拉电阻 */
1 a# ]: \4 n. s: f. D4 v8 _ p- {
GPIO_Init(KEY_WKUP_GPIO_PORT, &GPIO_InitStructure);
% x$ j6 |& T( e$ y
}- Z, L+ C/ L) K C! }# G
' q* g6 F" F7 U- w$ Z ^
/*
! Z$ k) \! J9 {
*********************************************************************************************************2 d! R3 M! B9 M7 U+ g
* 函数名: bsp_InitKeyVar8 t5 B6 U9 `* c8 ?2 i2 i0 d: e. h
* 功能说明: 初始化按键变量
, G+ s" u& h0 g. u7 I5 c
* 形参: 无
' e. s+ v- A- L. a
* 返回值: 无
* d& k8 M) [% ?2 c# K- V0 e, q9 M
*********************************************************************************************************! p( I6 `9 G" r1 k3 f& t! a4 |- \
*/" `+ c& `# ~: p! J/ i& L
static void bsp_InitKeyVar(void)5 i$ t5 |$ G. x% m$ Z: E
{) I/ ]7 j2 o8 I, X6 [, \5 [
uint8_t i;4 d6 U6 H$ r! ~$ B1 Y4 b
/ O' M" \. q5 D+ i8 f
/* 对按键FIFO读写指针清零 */) E. V8 `- H3 q, I/ V- l* q
s_tKey.Read = 0;, f8 x' v" y# i$ A% R5 Y) e& y' L% [
s_tKey.Write = 0;
7 d' C6 n2 `+ |* q1 s, E1 T
s_tKey.Read2 = 0;
: ?7 T5 k% r$ P, d) A; T# H
. N) h+ f( f" u/ J; Y
/* 给每个按键结构体成员变量赋一组缺省值 */% [9 u0 H6 s( ~
for (i = 0; i < KEY_COUNT; i++), Q& N& H* `. n% g6 G$ b7 L5 {
{4 S" v9 b8 I& y! g _9 j2 C W
s_tBtn[i].LongTime = KEY_LONG_TIME; /* 长按时间 0 表示不检测长按键事件 */
' A8 \4 }; B }( D6 u& z
s_tBtn[i].Count = KEY_FILTER_TIME / 2; /* 计数器设置为滤波时间的一半 */& R8 w1 }8 e( p3 h2 d5 K9 t; @+ X
s_tBtn[i].State = 0; /* 按键缺省状态，0为未按下 */- g: L5 Y1 m+ t0 \4 t
//s_tBtn[i].KeyCodeDown = 3 * i + 1; /* 按键按下的键值代码 */8 z' R9 D# C' g; j
//s_tBtn[i].KeyCodeUp = 3 * i + 2; /* 按键弹起的键值代码 */- {# q+ C7 O. ^0 c
//s_tBtn[i].KeyCodeLong = 3 * i + 3; /* 按键被持续按下的键值代码 */
% n' U& n2 a, O! k7 L9 u6 j: `
s_tBtn[i].RepeatSpeed = 0; /* 按键连发的速度，0表示不支持连发 */& R* r. W1 G6 _9 o& g, ^0 L4 G3 [
s_tBtn[i].RepeatCount = 0; /* 连发计数器 */
+ u `/ O# u- D3 a/ @4 ?5 J
}. ~) ~# y2 u0 q' j( j
. z( {3 c! G3 w+ ~
/* 如果需要单独更改某个按键的参数，可以在此单独重新赋值 */
! L5 u% L2 Y; F* F
/* 比如，我们希望按键1按下超过1秒后，自动重发相同键值 */
0 i+ k8 W: p8 q: b: N
// s_tBtn[KID_JOY_U].LongTime = 100;. E4 U# Y _- k( k y" |
// s_tBtn[KID_JOY_U].RepeatSpeed = 5; /* 每隔50ms自动发送键值 */7 ? @. T0 t" {9 M
/ q9 L* Q- T+ l0 V1 H1 _
# K+ B' t' ?2 _, [5 G
/* 判断按键按下的函数 */
" O, z! t; \. O% q4 F0 u
s_tBtn[0].IsKeyDownFunc = IsKeyDown0;( t5 W! l& a6 d4 _* |/ L) f& p1 I
s_tBtn[1].IsKeyDownFunc = IsKeyDown1;/ }9 a9 C! r7 q6 t% M
s_tBtn[2].IsKeyDownFunc = IsKeyDown2;( S' E) c) ^) ?0 G# [4 v
s_tBtn[3].IsKeyDownFunc = IsKeyDown3;' n- S Q0 T, H! i6 J& a% O4 b. U D
3 \6 N/ ^* A( A' O. `+ ?4 [3 B
}; [# L" A0 H- J' `: K) O
! E( [1 H, p: o1 y" `# ^: N: O; _$ _
/*- p: K3 I! `* G
*********************************************************************************************************
) S8 j' S) n# w: B. G( h
* 函数名: bsp_PutKey
* 功能说明: 将1个键值压入按键FIFO缓冲区。可用于模拟一个按键。+ u0 Z. I. G6 f3 d
* 形参: _KeyCode : 按键代码
6 }2 A6 _- }( h2 Y7 s
* 返回值: 无
1 t# [. R+ J; W2 ?. V8 M/ U
*********************************************************************************************************+ s* Z1 |! K6 E* r0 }
*/, ~0 n8 ^# g. Q# Y, v
void bsp_PutKey(uint8_t _KeyCode)
7 B3 f/ r4 E) D" n$ t6 F9 j
{/ b3 d+ S/ ^ @3 x
s_tKey.Buf[s_tKey.Write] = _KeyCode;
2 p# D/ v$ U) G/ C
9 H0 s. M2 U9 |* f* u) f$ |4 [: t5 \
if(++s_tKey.Write >= KEY_FIFO_SIZE)6 G0 I8 n# E; E# I1 n' \# v4 z
{
! y! S. Q9 a/ \
s_tKey.Write = 0;
' b5 |1 A$ ]$ q6 t, ^! W% A: }. _, _
}6 \ N* Y: p/ Z9 d t
}
2 I- G* ~0 u" c4 s g) J' N
. G8 }8 S6 Y& `. F* L
/*$ @7 ~. x8 ^2 b% ^2 A! c
*********************************************************************************************************
8 a4 O0 f$ R/ Q; p! M% r
* 函数名: bsp_GetKey
: J# ^' V0 d2 J. Y( y
* 功能说明: 从按键FIFO缓冲区读取一个键值。
* A* ]% [0 C- ~
* 形参: 无
* b9 ~4 I! O% X% z: L; q
* 返回值: 按键代码
\% L4 L, D' i$ q- I" P
*********************************************************************************************************6 Y: G4 ~# Q2 v, Q
*/ W- c/ N1 i g' V$ Y
uint8_t bsp_GetKey(void)
9 r+ _ `: g9 K1 y
{
$ A9 h- \3 t# h& j
uint8_t ret;2 B" ^0 b: ]( K4 I: q. q9 i
- z+ [' E9 P6 x, t
if (s_tKey.Read == s_tKey.Write)
6 ` s( j0 s9 y3 s3 E
{
5 ^; Y% x+ \. q
return KEY_NONE;
, L4 [$ G, H! [( o. y
}3 i' C3 V7 H" C4 B4 f, e8 H
else
9 w8 g& d Y9 `* m) u
{
$ w! }6 |0 j# n' B
ret = s_tKey.Buf[s_tKey.Read];1 M! f; h! I, ^: ~! {( r. f- I
4 s" u3 K; m# _9 A9 ]
if(++s_tKey.Read >= KEY_FIFO_SIZE) R# I# \4 \2 V& W" u1 z
{
x% H/ |/ k( Z4 j* R) j$ s
s_tKey.Read = 0;/ _) c& F J6 X! @
}
& A% R& \4 ~: O0 V$ L
return ret;
|. @ ]: C' y- b) P& T) \
}! [- }; J+ E5 q: S
}/*1 S/ n! f+ E6 t- D* q0 P3 P, D& F' i
*********************************************************************************************************" @! R% I- C [7 O K: u
* 函数名: bsp_GetKeyState
/ ?% l3 C. K& G" T* a! ?
* 功能说明: 读取按键的状态( ~. z/ B; B+ J' B! i
* 形参: _ucKeyID : 按键ID，从0开始; S& r+ s3 N" i( e3 C7 l* G. L
* 返回值: 1 表示按下， 0 表示未按下
, Q) y7 g9 I5 A- m
*********************************************************************************************************
4 e& W" b0 a. V: \# G9 |+ h
*/
# n& J6 _% U7 C6 R' e
uint8_t bsp_GetKeyState(KEY_ID_E _ucKeyID); V/ i9 Q( l! D! @
{" n+ B# ]+ s8 |% P$ c! ]& S: n
return s_tBtn[_ucKeyID].State;4 R0 q$ Q* C) ?+ ~1 k: x
}* h9 \, Z. z8 J
; X) g4 _0 J: t
/*. b' g7 H- @" }' n+ o6 B* D
********************************************************************************************************* w. J! z: e8 i& f! L
* 函数名: bsp_SetKeyParam& g4 ]9 h9 v9 ^4 J
* 功能说明: 设置按键参数+ T: u8 R. ^! ~ ~' s
* 形参：_ucKeyID : 按键ID，从0开始% E$ H& A# }5 C9 J% K
* _LongTime : 长按事件时间9 N, c2 @' b, S) C
* _RepeatSpeed : 连发速度
* Z4 ~4 M8 l. K; @' L
* 返回值: 无
. u1 S* s, n# U
*********************************************************************************************************' }; ]9 m4 l) X0 S. B0 z( x
*/ ?3 o& f/ `( [& y9 W
void bsp_SetKeyParam(uint8_t _ucKeyID, uint16_t _LongTime, uint8_t _RepeatSpeed)- R5 u! w; s, r2 q0 H
{' c3 Y7 H# v4 D! l' H( @7 u
s_tBtn[_ucKeyID].LongTime = _LongTime; /* 长按时间 0 表示不检测长按键事件 */3 a) H, c) ?; V9 z0 n
s_tBtn[_ucKeyID].RepeatSpeed = _RepeatSpeed; /* 按键连发的速度，0表示不支持连发 */
6 P& w8 B! U" l# L) _+ b
s_tBtn[_ucKeyID].RepeatCount = 0; /* 连发计数器 */7 p! s6 ~8 V7 p7 P+ r# D' e
}9 g$ c' r3 I" V* W9 N0 V T3 ?: t1 T! \
/*0 q9 X+ s/ |2 A
********************************************************************************************************* `% f: I' P: Q, ?
* 函数名: bsp_ClearKey8 Q5 I) }- c; r e9 \- Q: f2 y
* 功能说明: 清空按键FIFO缓冲区; d* p7 Z( \) p- ~; w/ l* ^
* 形参：无" r/ o1 c* d8 q( V+ H
* 返回值: 按键代码1 {6 ?) H7 p2 T) j t
*********************************************************************************************************
% W7 k2 |0 C a8 W
*/7 g( v$ }+ k' D$ I3 o! v
void bsp_ClearKey(void)
2 I+ j! f; x# x- h e$ f ?
{" i: q) l1 ]. l
s_tKey.Read = s_tKey.Write;
2 w: ~1 J" O6 P" Y) t2 e- @
}
# m1 ?/ O# O% v+ K* Y$ K: L& H
( j3 U6 I9 e9 k& N
/*
* ^* V: }# W) a% f& q+ G$ ~4 N
*********************************************************************************************************
/ S" g- K& v0 j' K
* 函数名: bsp_DetectKey3 P! I- D B/ A4 C0 y: K% n! }
* 功能说明: 检测一个按键。非阻塞状态，必须被周期性的调用。
5 [7 [" r6 S( i7 N
* 形参: 按键结构变量指针+ M( F0 {6 y& b4 G) S
* 返回值: 无6 A! m1 N! D7 `4 k) l5 h# ~7 X
*********************************************************************************************************. u, b2 K/ v( c9 x& ^
*/- r1 i: E5 d6 }6 c
static void bsp_DetectKey(uint8_t i)' i$ T) u# ~6 x: H$ v
{# y) I+ B3 s% M/ E
KEY_T *pBtn;. `/ O6 D) V+ b6 [: K# g
! ?* `5 P9 d; q# I: h+ B
/*; _1 G; O$ q' e% Q8 h
如果没有初始化按键函数，则报错
6 A) g( @7 ?9 ^) _/ K! {! c g: D
if (s_tBtn[i].IsKeyDownFunc == 0)
2 x. ]1 h1 j! T' n2 W
{: }: T8 I. j1 u' v# _) F. M2 d; P
printf("Fault : DetectButton(), s_tBtn[i].IsKeyDownFunc undefine");
8 Y4 G, G P8 C5 ?- y7 E+ a( X
}
9 K# F$ V# z8 w. c, z2 d$ D& y
*/
, U$ }' U7 r, g9 i q7 d+ H! K
3 i+ f# p; V1 r% r$ }
pBtn = &s_tBtn[i];
! D2 ^# a2 B3 L; q. A5 [' m5 w2 I
if (pBtn->IsKeyDownFunc())
$ B6 r" E7 r) K# Z( q
{
* i+ B, _" T: q0 K# l1 o" _$ D
if (pBtn->Count < KEY_FILTER_TIME). a. v% W4 b, D8 U
{* z! L. D8 A% W! w2 K
pBtn->Count = KEY_FILTER_TIME;
0 n, q q5 l$ C3 p5 L' d$ t( R
}2 h' X% o% X2 }6 I# b2 [3 B
else if(pBtn->Count < 2 * KEY_FILTER_TIME)
: n9 R) c) D$ g3 ~
{' ?; v9 L, k ^- U5 N4 p# o
pBtn->Count++;2 m S) o0 Y: v Z
}
& r$ w7 R1 u0 f& ~2 ~! E
else
1 J' ~" K. A6 F m+ i
{! k3 S6 A: h* ?! ?
if (pBtn->State == 0)( ^3 c& D% o8 @# k1 `, I$ |. E
{- I$ u7 E1 S1 `- J3 [
pBtn->State = 1;
}$ @ u) G- u" M& J: r
# Q) [. {/ a1 L6 q+ U9 x' f
/* 发送按钮按下的消息 */
2 p2 R/ N0 S* `9 e. |: E8 q2 m
bsp_PutKey((uint8_t)(3 * i + 1));
0 H+ K4 W: M `6 j7 P7 M, t) i
}
7 {4 I+ o" Q* d# u7 K2 c
. {- o) y/ W( X! L* E4 a3 ~' s. `
if (pBtn->LongTime > 0)9 \. `2 E1 n; f
{& U# O0 [5 I% r( a( K$ P5 A2 B
if (pBtn->LongCount < pBtn->LongTime)
9 c" X) @. ^- S; ^
{ b" w$ [( B6 L/ w' M
/* 发送按钮持续按下的消息 */
2 H1 t9 z9 L; f( ~4 @
if (++pBtn->LongCount == pBtn->LongTime)7 B1 p; |4 ~6 U8 ]5 I d1 N* D
{7 e: c9 V) ~; @4 z e0 d8 r
/* 键值放入按键FIFO */
3 T$ K' B. P/ E. {
bsp_PutKey((uint8_t)(3 * i + 3));
/ o" J( }1 ^+ p, F4 u! r& l
}
# z/ } b0 ]9 ^ X/ l. S: P3 K+ x
}
# j7 \1 ^2 s. J S
else
8 s% a3 a3 u. \1 Y
{
5 ^+ e7 O0 O' Y9 M: c
if (pBtn->RepeatSpeed > 0)
' I9 E L4 w7 R/ H o+ ^
{. j% S i7 N" ^/ Z
if (++pBtn->RepeatCount >= pBtn->RepeatSpeed)
* o% r2 W/ Q/ G, P
{; W1 j" R6 p3 ?5 v/ y' W
pBtn->RepeatCount = 0;* [ f3 y; }' B/ _
/* 常按键后，每隔10ms发送1个按键 */! z& G5 F$ q1 k( i3 z1 G, {, K+ u
bsp_PutKey((uint8_t)(3 * i + 1));5 }3 C* g4 Z7 ^
}2 h3 W8 {, J8 q$ V, \7 Y& H; \
}7 C2 u8 {9 _3 N) G
}$ I+ ?, g# w, p
}
: I3 R" Y- u7 o: u2 P
}1 F c, d0 I( H/ u: d: C" R G
}
+ y: V9 Z* o/ l2 a1 L1 M
else! q+ b# {1 H T3 `+ t5 _
{
' U1 N) P+ ?, o# v3 `! Z
if(pBtn->Count > KEY_FILTER_TIME)
5 ]/ D2 `: {- T
{
5 U6 V4 `! J1 R; k
pBtn->Count = KEY_FILTER_TIME;
4 i3 F6 |5 v, K: ]1 Q
}& }+ ^" a, V5 E# D4 l
else if(pBtn->Count != 0)
# }+ c/ G0 I. D2 M: Z8 z* }% |0 e
{
& z7 P6 n, O' s1 S
pBtn->Count--;- y& w& }( c) W! g4 |" z
}
; K; h( D0 b: R
else
8 E+ \% [9 H" h9 f' ~+ L! p
{
+ e3 ]( X" P9 R
if (pBtn->State == 1)4 S L) [2 w X( D
{
! y/ ^& z# f A: t1 |' H
pBtn->State = 0;
! c5 b H) r% s3 }' M+ u
7 E! R9 n* q: Q8 Q
/* 发送按钮弹起的消息 *// c' ]# z& `. d) h& {' `2 Y: E3 u
bsp_PutKey((uint8_t)(3 * i + 2));
: L1 c# N" @7 v1 ~, @/ E
}
4 p2 Q8 Y6 a$ J, f/ A' V; o: n! e
}
( W' _% Y+ Q, o+ ^ d1 f
7 O: Q4 j+ }! k0 P
pBtn->LongCount = 0;
/ B x/ s G. D: v9 h
pBtn->RepeatCount = 0;$ s3 D9 N3 O, W) x: D. Z2 q
}1 T3 f* s" V; E2 J$ o# q0 Z# p
}
; {2 T: g. l3 S" a L- m2 m
9 i' O6 y1 R3 _+ T$ Y3 L
1 O5 T& }# E: m+ B5 C- ?4 K
/*
: u: A) t+ d2 z$ j
*********************************************************************************************************5 q/ S& o% N& w7 S7 {
* 函数名: bsp_KeyScan
( ]9 F: P5 Q9 Y0 X3 N" N
* 功能说明: 扫描所有按键。非阻塞，被systick中断周期性的调用
8 n5 c2 w, Z) S7 T5 U; [
* 形参: 无 X" V/ t0 w3 I' d1 ], i4 p
* 返回值: 无% T2 [$ O+ j# @/ n
*********************************************************************************************************5 s3 Q& [8 g% w- Q; v
*/7 {- w# [& ?# u$ B5 F6 t
void bsp_KeyScan(void)
' ?$ p) {" O* A/ v) _4 x* _
{) D0 y* G7 z9 i5 n
uint8_t i;
2 g% [, h4 W( D
7 s: M6 E) `# q( c. b( k% J5 {
for (i = 0; i < KEY_COUNT; i++)
% ~4 n' f& w* A
{
4 O0 i# \) {5 r6 J
bsp_DetectKey(i);
0 z; j( X c! K1 A- @5 |
}) P. L8 V& q/ v' L: h0 ?
}

复制代码

bsp_key.c文件中核心函数是bsp_DetectKey()，这个函数先通过函数指针调用检测按键GPIO口状态的函数，判断是否有按键按下。

检测到按键按下时先进行相应的消抖操作，消抖持续时间通过bsp_key.h中定义的宏 KEY_FILTER_TIME设置。确定按键按下后，如果在此之前按键是松开的就把相应标志位置位，把按键按下的状态值写入到FIFO

中。如果使能了检测按键长按功能（LongCount>0），程序会继续检测按键是否达到长按时间，如果到达长按时间，将长按状态值写入到FIFO中，在继续检测是否支持长按时状态连续发送功能，如果使能了长按时连

续发送功能（RepeatSpeed>0），达到周期发送时间时，会继续写入FIFO按键按下状态值。

　　检测到按键释放时，首先也会进行相应滤波处理。确认按键松开后，若之前按键处于按下状态，会将检查到的按键松开状况写入到FIFO中，然后清除长按、重复发生的计数值，为下次查询做准备。

bsp_key.h实现

#ifndef __BSP_KEY_H
- B2 O2 |" S5 L& s: a. ]
#define __BSP_KEY_H
: z% O: S4 {& J; C( f
* v: [, [6 I$ ^
#define KEY_COUNT 4 /* 按键个数, 4个独立按键 */! N! B/ F3 W$ s$ H) _; n# q+ T/ b
! Z8 Y9 c( q" K* |3 {
/* 根据应用程序的功能重命名按键宏 */0 o! T7 T+ i. Q- e( U+ b
#define KEY_DOWN_K0 KEY_0_DOWN
# G& b" G$ S0 Y$ V0 b, p: G
#define KEY_UP_K0 KEY_0_UP& o( v+ s6 y# k0 E* A+ t
#define KEY_LONG_K0 KEY_0_LONG: y! t/ I% ^' d C7 E5 X) r' ^
5 \- Z; I5 f' U! F8 U
#define KEY_DOWN_K1 KEY_1_DOWN V+ E9 c: P: e( q
#define KEY_UP_K1 KEY_1_UP+ V( k3 Q A1 k. _2 P [! Z0 F5 C: t
#define KEY_LONG_K1 KEY_1_LONG
$ _2 Y' s( ]" Z, v# G* u a2 Z' K: g
: F$ D! k L' w- l) \2 g" m
#define KEY_DOWN_K2 KEY_2_DOWN+ e2 R F+ T; v# F9 P6 s" @
#define KEY_UP_K2 KEY_2_UP; d) T& M' }1 U: [
#define KEY_LONG_K2 KEY_2_LONG
6 ?: v6 J g4 N( L! R
- r1 k/ Y6 ] n% ~9 o4 o2 E+ E) N
#define KEY_DOWN_WP KEY_4_DOWN /* 上 */- c f- ]0 Q- A1 C, t# h6 g e; }
#define KEY_UP_WP KEY_4_UP$ G/ v+ v! z. g {4 e
#define KEY_LONG_WP KEY_4_LONG
5 f8 e, r: u. ~/ Y g- R. }
6 K! V: O$ z9 S, k V
2 A- j \" ]5 q: X2 n/ N
/* 按键ID, 主要用于bsp_KeyState()函数的入口参数 */
% u2 C( `- |2 Z( K8 D# C
typedef enum
0 Q/ n# C5 U: c2 M
{
8 j3 f8 M4 c, s# f7 e1 \8 ?
KID_K1 = 0,
# c7 m9 E. y. P* R& D; u- u2 \5 a
KID_K2,$ q! A" Y8 H( M' P% s- ~
KID_K3,% r! @6 ]# ~0 I6 R
KID_WAKE_UP,) e! k5 z6 X4 h* {. \! C' G3 I
}KEY_ID_E;
% s* z3 {$ ^/ U
; Y' r2 W" j* J$ P- n* X
/*
* S# i Q, W! F; |
按键滤波时间50ms, 单位10ms。( S, }" A! D Z
只有连续检测到50ms状态不变才认为有效，包括弹起和按下两种事件
1 r$ a4 ?/ t% j K2 @
即使按键电路不做硬件滤波，该滤波机制也可以保证可靠地检测到按键事件
% P" b% D. L7 h+ d2 L
*/
# S3 h; w9 O8 `7 O) Q
#define KEY_FILTER_TIME 5
/ F. H, \, ]$ E* e9 `
#define KEY_LONG_TIME 100 /* 单位10ms，持续1秒，认为长按事件 */
% x) A& r/ {3 [) V+ t- Q" W* f
+ X1 I1 j- X( G+ @9 P! z8 b
/*& ?9 ?' S+ c8 S
每个按键对应1个全局的结构体变量。
4 B L5 N# c U. H% \
*// o' o- }/ N& x
typedef struct
* \2 W T' g) v: M) v, \$ q6 d0 @
{
$ S1 m. b$ G D: ]
/* 下面是一个函数指针，指向判断按键手否按下的函数 */
/ U* y" l9 b3 f7 V: D3 |0 d Z4 s
uint8_t (*IsKeyDownFunc)(void); /* 按键按下的判断函数,1表示按下 */
8 P( [4 {- P( C
7 @9 } R8 n5 L/ f( P
uint8_t Count; /* 滤波器计数器 */
5 Y5 t2 b! V( [, _' G9 A
uint16_t LongCount; /* 长按计数器 */1 E+ h" r8 J9 i& K/ a& A
uint16_t LongTime; /* 按键按下持续时间, 0表示不检测长按 */
' s# d2 w% u9 h& `3 }
uint8_t State; /* 按键当前状态（按下还是弹起） */
. v8 V% z$ I! ~% H, M1 n
uint8_t RepeatSpeed; /* 连续按键周期 */& @) X. a& d! O, U
uint8_t RepeatCount; /* 连续按键计数器 */
0 G4 e X# v' S
}KEY_T;* n! K* ~' \2 ?6 D! [ \5 o
$ ]- N I) u* M6 }& ^& d/ U
/*
! [) \$ z; o- f, J3 q/ s! W+ d
定义键值代码, 必须按如下次序定时每个键的按下、弹起和长按事件，检测按键时使用# S0 V6 A8 q; i q
*/
, j: _" T) S0 u* [% g
typedef enum4 \) y+ G2 k3 ^4 g9 |
{) O8 s( t8 w( T1 K' Z
KEY_NONE = 0, /* 0 表示按键事件 */
: I8 u/ r. R! A1 ~/ ?, B9 ~
( ?$ e$ o$ \' d0 L* i$ ~- h
KEY_0_DOWN, /* 1键按下 */
1 B; x: |; [" C0 F
KEY_0_UP, /* 1键弹起 */+ a. R4 P/ F* C I" o1 W
KEY_0_LONG, /* 1键长按 */7 V* @+ o" E4 ~9 ]
/ E; T& `* P5 f$ v8 B- t, ?
KEY_1_DOWN, /* 2键按下 */4 Z: y7 f( l, y8 P, c( e, {" D
KEY_1_UP, /* 2键弹起 */
$ P$ b) K: W5 g5 K, i# J3 T3 e- U: s
KEY_1_LONG, /* 2键长按 *// v$ G. e9 {6 U0 q+ g6 h" b
' U: Y6 R' }2 R
KEY_2_DOWN, /* 3键按下 */! {8 ?' C% F. @' T
KEY_2_UP, /* 3键弹起 */
r" v j/ ^6 X0 z8 u) v O( ]
KEY_2_LONG, /* 3键长按 */& `9 m! u2 l' F% v# P
& N) s1 t$ [3 } ~: m( i2 _1 a! ]( l
KEY_3_DOWN, /* 4键按下 */% n! G, w+ [$ q8 g4 }
KEY_3_UP, /* 4键弹起 */0 y2 [' d; j6 T$ @: m- W" [
KEY_3_LONG, /* 4键长按 */
+ m9 \! P2 ?, d1 R: V$ ?
}KEY_ENUM;
& x8 I2 j1 c. K8 V6 v
! F: X7 s3 C6 y; G- {$ K
/* 按键FIFO用到变量 */
3 \$ v- D: l$ p) x
#define KEY_FIFO_SIZE 10
: z9 |1 G+ N3 y! Q* C' m3 ?/ v3 C6 c
typedef struct
$ [7 `0 R& l5 ?& H$ b! x
{
" p0 U' H/ A2 K1 X( y
uint8_t Buf[KEY_FIFO_SIZE]; /* 键值缓冲区 */0 H4 c- o C! Z
uint8_t Read; /* 缓冲区读指针1 */
7 t2 s; V3 z% ~; D1 r
uint8_t Write; /* 缓冲区写指针 */
: M9 p! g6 ?7 s6 _$ |' M$ h; |
}KEY_FIFO_T;" I% L& i# l7 q
; I8 o/ {/ H3 ^
/* 供外部调用的函数声明 */7 f0 v1 d$ g0 n
void bsp_InitKey(void);& u& v! S( Q- q' e& N+ L
void bsp_KeyScan(void);: D' Y) T8 ~, j, `4 O
void bsp_PutKey(uint8_t _KeyCode);, R( T" O2 F) D+ z
uint8_t bsp_GetKey(void);1 N% Z# g( O. f& q3 X0 l5 b1 k- |
uint8_t bsp_GetKeyState(KEY_ID_E _ucKeyID);2 M+ K2 g4 K& y4 y
void bsp_SetKeyParam(uint8_t _ucKeyID, uint16_t _LongTime, uint8_t _RepeatSpeed);5 T' \) s+ x# d5 R% @
void bsp_ClearKey(void);
1 A3 q/ F: e3 d- u, J& z0 @
/ j5 L/ g. g# t- Q
#endif