HAL库GPIO输入模式在cubemx中的配置

上节课程介绍了GPIO输出模式的配置，包括修改IO标签，选择GPIO模式、GPIO上下拉等，本节输入模式有很多相同之处，节省时间，小飞哥就简单介绍一下

GPIO选择与配置

依然是先来看看我们的Alios 开发板上的按键硬件连接，总共有3个用户按键，分别挂在GPIOE11、GPIOE14和GPIOE10上，连接方式采用的是低电平有效，也即是，按键按下之后，MCU检测到的电平为低电平，松开之后检测为高电平，外部上拉电阻4.7K

4 l2 t- X7 Y/ C, M

接下来，我们只需要在cubemx对这3个GPIO进行配置即可,工程在上一节内容上继续添加，打开上一节的cubemx工程，选择PE14引脚，选择引脚模式为输入模式

) v- J& ]2 m+ A( D7 L1 }

1 k# }/ s  v8 K" q

然后修改标签为USR_KEY2，其他两个按键一样的配置方法，3个按键配置完成之后如下图所示：

, Y7 m" X- U$ V8 _/ v% `$ F2 ?

接下来依然是对GPIO的模式、配置进行修改，这里需要注意一点就是GPIO的上下拉配置，不要瞎选，这个一定是跟硬件相关的，比如本次硬件设计，空闲时是保持高电平的，那么配置上拉是比较合适的，但是呢，此时外部已经有了上拉电阻，我们内部上拉就不是很有必要了，也可以配置为不上拉也不下拉，但是配置为下拉一定是不合适的，可能会引起信号的误动作，功耗的增加等不必要的麻烦，所以说，cubemx配置只是为你减轻了重复性搬运工作，电路工作原理必须了然于胸，选择最为合适的配置配置

比较简单，我们此次采用的是轮询获取GPIO状态的方法来实现按键，当然也可以采用外部中断的方式，对于普通按键来讲，不是很有必要，轮询GPIO状态即可

HAL库GPIO输入模式操作详解与结构介绍
: C' {7 o7 R. d/ W( }* e接下来，我们生成代码即可

  J# |* i; c& G/ q

1 o) f. w- s1 Z3 r
- u6 Z9 K/ V2 q! A( V( W打开工程之后，我们发现上一节配置的输出IO和这一节的输入IO是放在一起的，cubemx生成代码的规则是把同一类外设统一放在相应的模块初始化代码中，宏定义统一放在main.h中如果能够接受这个布局的话是没有问题的，如果不能还是比较麻烦的
# s! w$ h" |/ T' H5 e. ?

3 e) C* ]& `# o5 I" X/ {

3 F' `" |9 m# Z9 ]3 ^4 N9 ^  h
6 d1 S: K: }; r% d
% T" @; Y/ i5 k. v9 l1 h输入模式相关的GPIO API也比较少，只涉及到 关于GPIO操作的API：

1.   /* Initialization and de-initialization functions *****************************/
   
2. void              HAL_GPIO_Init(GPIO_TypeDef  *GPIOx, GPIO_InitTypeDef *GPIO_Init);
   + P8 t; Q! n/ o! U- d, l) ^- r
3. void              HAL_GPIO_DeInit(GPIO_TypeDef  *GPIOx, uint32_t GPIO_Pin);
   + F+ b; A, I( `! t) N2 E3 ^
4. 
   
5. /**
   
6.   * @}
   * G& W+ G9 y2 a, }8 G) k2 B
7.   */
   ! L( M+ V$ D# x
8. 
   
9. /** @addtogroup GPIO_Exported_Functions_Group2 IO operation functions
   
10. * @{
    # P- b8 g- I0 `! w6 N+ O
11. */
    % z- F1 o) o  U& U
12. 
    
13. /* IO operation functions *****************************************************/
    
14. GPIO_PinState     HAL_GPIO_ReadPin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin);

复制代码

/ `+ Q; h$ [# z7 b
/ g& N) n1 x$ G  ]: [0 i

如何使用呢？

1. 参数GPIO_TypeDef  *GPIOx可以是GPIO组的地址：
   ! H- A& P7 `2 }5 `# o6 s6 d% Y+ ]
2. 
   
3. #define GPIOA               ((GPIO_TypeDef *) GPIOA_BASE)
   3 E$ q* d( T8 v3 V; r! D
4. #define GPIOB               ((GPIO_TypeDef *) GPIOB_BASE)
   
5. #define GPIOC               ((GPIO_TypeDef *) GPIOC_BASE)
   . _$ g- n- E) ~1 Z( p0 m4 `# f4 P
6. #define GPIOD               ((GPIO_TypeDef *) GPIOD_BASE)
   1 y% _" a$ ~. b- H) c
7. #define GPIOE               ((GPIO_TypeDef *) GPIOE_BASE)
   8 _/ b  h% P# p6 n+ b
8. #define GPIOF               ((GPIO_TypeDef *) GPIOF_BASE)
   
9. #define GPIOG               ((GPIO_TypeDef *) GPIOG_BASE)
   
10. #define GPIOH               ((GPIO_TypeDef *) GPIOH_BASE)
    ' t. q4 O! r) y* z
11. #define GPIOI               ((GPIO_TypeDef *) GPIOI_BASE)

复制代码

1. 参数GPIO_Pin可以是GPIO的引脚号：
   
2. 
   
3. #define GPIO_PIN_0                 ((uint16_t)0x0001)  /* Pin 0 selected    */
   6 u) A$ X2 w9 z7 Y1 K* M
4. #define GPIO_PIN_1                 ((uint16_t)0x0002)  /* Pin 1 selected    */
   0 ^8 P3 y% B9 z
5. #define GPIO_PIN_2                 ((uint16_t)0x0004)  /* Pin 2 selected    */
   
6. #define GPIO_PIN_3                 ((uint16_t)0x0008)  /* Pin 3 selected    */
   
7. #define GPIO_PIN_4                 ((uint16_t)0x0010)  /* Pin 4 selected    */
   
8. #define GPIO_PIN_5                 ((uint16_t)0x0020)  /* Pin 5 selected    */
   9 b- E4 z+ i& c+ R9 ]; {
9. #define GPIO_PIN_6                 ((uint16_t)0x0040)  /* Pin 6 selected    */
   
10. #define GPIO_PIN_7                 ((uint16_t)0x0080)  /* Pin 7 selected    */
    + r. h  U2 l  H
11. #define GPIO_PIN_8                 ((uint16_t)0x0100)  /* Pin 8 selected    */
    
12. #define GPIO_PIN_9                 ((uint16_t)0x0200)  /* Pin 9 selected    */
    $ N) {' G0 T1 w) V# t
13. #define GPIO_PIN_10                ((uint16_t)0x0400)  /* Pin 10 selected   */
    # K% e3 s1 q3 E
14. #define GPIO_PIN_11                ((uint16_t)0x0800)  /* Pin 11 selected   */
    4 Z; l6 ~3 M& r* J' {
15. #define GPIO_PIN_12                ((uint16_t)0x1000)  /* Pin 12 selected   */
    * ?% n6 R/ ^1 S( V, u! l
16. #define GPIO_PIN_13                ((uint16_t)0x2000)  /* Pin 13 selected   */
    
17. #define GPIO_PIN_14                ((uint16_t)0x4000)  /* Pin 14 selected   */
    9 ^. Y; z: \5 E
18. #define GPIO_PIN_15                ((uint16_t)0x8000)  /* Pin 15 selected   */
    4 @2 ]. j. s3 F
19. #define GPIO_PIN_All               ((uint16_t)0xFFFF)  /* All pins selected */

复制代码

2 e8 u% N$ j& V8 q& Q1 U( w5 w

输入模式返回值为获取到的GPIO状态，也即是高低电平状态，在没有按键按下的时候，返回GPIO_PIN_SET,按键按下时候，返回GPIO_PIN_SET

1. @endverbatim
   0 o- s" B3 t% @2 ]& Y
2.   * @{
   4 c/ Z- }( g; K% K
3.   */
   
4. 
   
5. /**
   ! _8 H- H( I6 r
6.   * @brief  Read the specified input port pin.
   0 ]) r0 {( n5 ]
7.   * @param  GPIOx where x can be (A..H) to select the GPIO peripheral for STM32L4 family
   & A. T5 q  T5 V1 H
8.   * @param  GPIO_Pin specifies the port bit to read.
   
9.   *         This parameter can be any combination of GPIO_Pin_x where x can be (0..15).
   
10.   * @retval The input port pin value.
    " o& V4 A" v* N1 W( @
11.   */
    
12. GPIO_PinState HAL_GPIO_ReadPin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)
    
13. {
    " f8 V% o5 G+ C2 z+ [* |7 X
14.   GPIO_PinState bitstatus;
      o1 m/ c; ^: j2 X4 [$ Z
15. 
    
16.   /* Check the parameters */
    % m1 c8 G. X+ g% ^4 H. }3 d3 c2 n* _3 `) `
17.   assert_param(IS_GPIO_PIN(GPIO_Pin));
    
18. 
    ! n9 M% F; ^! i; M% V
19.   if ((GPIOx->IDR & GPIO_Pin) != 0x00u)
    3 T/ U9 O2 O; @) w9 f+ `( t7 a
20.   {
    
21.     bitstatus = GPIO_PIN_SET;
    
22.   }
    
23.   else
    / Q8 u0 d9 @% @. [- p/ ]
24.   {
    
25.     bitstatus = GPIO_PIN_RESET;
    
26.   }
    
27.   return bitstatus;
    
28. }

复制代码

$ K7 }& v- {  O6 B6 }6 o

GPIO输入模式的简单测试

接下来在之前led的任务中，对按键状态进行测试,这里涉及到按键的消抖，所谓“消抖”就是：

当检测到按键状态变化时，不是立即去响应动作，而是先等待闭合或断开稳定后再进行处理。即为按键消抖 按键消抖：可分为硬件消抖和软件消抖。

硬件消抖就是在按键上并联一个电容，如图 8-11 所示，利用电容的充放电特性来对抖动过程中产生的电压毛刺进行平滑处理，从而实现消抖。

但实际应用中，这种方式的效果往往不是很好，而且还增加了成本和电路复杂度，所以实际中使用的并不多。绝大多数情况下，我们是用软件即程序来实现消抖的

延时消抖

最简单的消抖原理，就是当检测到按键状态变化后，先等待一个 10ms 左右的延时时间，让抖动消失后再进行一次按键状态检测，如果与刚才检测到的状态相同，就可以确认按键已经稳定的动作了

1. static void rt_led1_flash_entry(void *parameter)
   
2. {
   
3.   for (;;)
   
4.   {
   ) S1 k7 g( c# _$ E  c
5.   if(!HAL_GPIO_ReadPin(USR_KEY1_GPIO_Port,USR_KEY1_Pin))
   
6.   {
   
7.    rt_thread_mdelay(100);
   3 A3 T5 V, O: Q$ R+ v7 i& K/ J
8.    if(!HAL_GPIO_ReadPin(USR_KEY1_GPIO_Port,USR_KEY1_Pin))//消抖
   6 }! L' W- |5 V6 b2 |& G9 c3 W
9.    {
   6 _6 g- L5 G/ c7 w& K: D0 @
10.     rt_kprintf("Key1 is presseded!\r\n");
    & X) |' b0 ~% j! I8 e
11.    }
    
12.   }
    
13.   if(!HAL_GPIO_ReadPin(USR_KEY2_GPIO_Port,USR_KEY2_Pin))
    . q! p' _* H- I! d
14.   {
    + z" X$ ]4 u: j; f  w
15.    rt_thread_mdelay(100);
    
16.    if(!HAL_GPIO_ReadPin(USR_KEY2_GPIO_Port,USR_KEY2_Pin))//消抖
    ! U( V1 E  {% \
17.    {
    $ y0 Z1 F' ~6 o. [
18.     rt_kprintf("Key2 is presseded!\r\n");
    2 ~1 E& @+ n' L* {' Z
19.    }
    ) ~* ]- s" F4 O4 ?# A
20.   }
    
21.   if(!HAL_GPIO_ReadPin(USR_KEY3_GPIO_Port,USR_KEY3_Pin))
    
22.   {
    
23.    rt_thread_mdelay(100);
    
24.    if(!HAL_GPIO_ReadPin(USR_KEY3_GPIO_Port,USR_KEY3_Pin))//消抖
    / G3 a% L! b1 {
25.    {
    
26.     rt_kprintf("Key3 is presseded!\r\n");
    % y4 m& e/ o( e
27.    }
    
28.   }
    " c2 U- }4 f5 j  |- m
29.   }
    2 c1 Z* d1 {4 M& J, Q( r: ^
30. }

复制代码

; ]% O$ ~6 Q" T8 Y% s: y( f0 U
; f/ `* s- i; ], d  Q5 o" [, r测试结果：


; x, }* t% j# \  U
, j( e7 E2 w: V; {! Q/ J  K
; m( G/ O9 t4 }7 }/ {多功能按键移植

上面是简单的按键状态获取，实际中，一个项目可能按键有限但同时又要实现复杂的功能切换，那么按键的功能如果很单一的话，就不能够满足需求，接下来，小飞哥带大家一起移植一个很不错的多功能按键框架，代码来源是github的jiejieTop

% L8 _4 G* L5 a5 E" r8 [8 ]

源码地址：GitHub - jiejieTop/ButtonDrive: 纯C语言实现的一个按键驱动，可移植性强，支持单双击、连按、连按释放、长按；采用回调处理按键事件（自定义消抖时间），使用只需3步，1：创建按键，2：按键事件与回调处理函数链接映射。然后周期检查按键。

' g' t; `  x# N4 p3 l6 e" X

7 @& j' B3 |7 d7 V

我们下载源码进行移植，把文件夹里面的这些文件，我们移植到自己的文件目录，下载文件中包含的main.c中是一个完整的按键初始化，实现，大家可以看看就知道如何使用了

0 V' u$ m9 V( M

2 n# L8 T- H# _3 d: r

下面小飞哥就带大家来看看如何移植到自己的系统里面

可以把memset，printff替换为rt-thread的驱动，当然也可以不关注

2 M2 ?1 P9 I0 X5 w

重新编译一下，刚才的警告已经消失了

然后我们看看如何实现这个多功能按键：

先来看看一些配置项宏定义,位域、结构体、回调函数，面向对象的一套东西都在，是很适合学习的，有关于短按、长按、单击、双击等等的配置，我们根据自己的需要配置即可

1. #define BTN_NAME_MAX  32     //名字最大为32字节
   * V! Q# ~. {: w; M& b
2. 
   
3. /* 按键消抖时间40ms, 建议调用周期为20ms
   . o+ b  H5 }' _  {. g8 r
4. 只有连续检测到40ms状态不变才认为有效，包括弹起和按下两种事件
   2 X* ?5 s5 \' |* i8 q5 Z! L# H
5. */
   
6. 
   6 Y: d8 a) Q: _# q) h
7. #define CONTINUOS_TRIGGER             0  //是否支持连续触发，连发的话就不要检测单双击与长按了
   
8. 
   
9. /* 是否支持单击&双击同时存在触发，如果选择开启宏定义的话，单双击都回调，只不过单击会延迟响应，
   
10.    因为必须判断单击之后是否触发了双击否则，延迟时间是双击间隔时间 BUTTON_DOUBLE_TIME。
    
11.    而如果不开启这个宏定义，建议工程中只存在单击/双击中的一个，否则，在双击响应的时候会触发一次单击，
    
12.    因为双击必须是有一次按下并且释放之后才产生的 */
    
13. #define SINGLE_AND_DOUBLE_TRIGGER     1
      z/ w% R8 A! A
14. 
    # ?' ?% x1 Z7 K7 Q0 j0 J: }
15. /* 是否支持长按释放才触发，如果打开这个宏定义，那么长按释放之后才触发单次长按，
    . A3 h, z  a, S0 C! H1 Y1 O, g: |
16.    否则在长按指定时间就一直触发长按，触发周期由 BUTTON_LONG_CYCLE 决定 */
    - v1 O( O% m7 c6 [4 `" ~/ w7 W; c
17. #define LONG_FREE_TRIGGER             0
    
18. 
    : t; a2 e2 X) j, b
19. #define BUTTON_DEBOUNCE_TIME    2   //消抖时间      (n-1)*调用周期
    
20. #define BUTTON_CONTINUOS_CYCLE  1   //连按触发周期时间  (n-1)*调用周期  
    " s1 p  }4 p: b: r. F5 m
21. #define BUTTON_LONG_CYCLE       1   //长按触发周期时间  (n-1)*调用周期
    
22. #define BUTTON_DOUBLE_TIME      20  //双击间隔时间  (n-1)*调用周期  建议在200-600ms
    7 k2 I# x- m3 @! l( l, s  L) B$ z
23. #define BUTTON_LONG_TIME        50  /* 持续n秒((n-1)*调用周期 ms)，认为长按事件 */
    ) ^/ ]' g! }4 H, [
24. 
    6 K2 B0 r2 b2 K- O- v8 t. ?- C6 a
25. #define TRIGGER_CB(event)   \
    + n' d: R8 N$ \$ }" S: C! e
26.         if(btn->CallBack_Function[event]) \
    " x2 }7 C% F+ l  j
27.           btn->CallBack_Function[event]((Button_t*)btn)
    ( a: k% o7 W( ^, x3 y' m  ~
28. 
    5 Y0 \- M, c! B! d: R
29. typedef void (*Button_CallBack)(void*);   /* 按键触发回调函数，需要用户实现 */
    6 J( R' r" r3 W
30. 
    
31. 
    
32. 
    ; W0 W7 y% j' _/ g! Z. b  y
33. typedef enum {
    
34.   BUTTON_DOWM = 0,
    8 y- m% `, c$ u9 `1 `  d& T4 S5 d4 A
35.   BUTTON_UP,
    & J$ |& i. |7 @, [
36.   BUTTON_DOUBLE,
    . X8 {9 D$ ?6 G8 s: X
37.   BUTTON_LONG,
    * z( b" H: d1 L2 m1 N
38.   BUTTON_LONG_FREE,
    1 k' J( {% A( L6 q' T: b5 @! v2 g
39.   BUTTON_CONTINUOS,
    # n" c( \( u$ p$ B. Z
40.   BUTTON_CONTINUOS_FREE,
    
41.   BUTTON_ALL_RIGGER,
    
42.   number_of_event, /* 触发回调的事件 */
    
43.   NONE_TRIGGER
    3 t$ l/ N1 S5 @% I: m9 U4 ^( J
44. }Button_Event;
    ) n0 M& m( |2 j8 z
45. 
    
46. /*
      I3 o; [9 s' E
47. 每个按键对应1个全局的结构体变量。
    7 Z: T. {+ [! j( J
48. 其成员变量是实现滤波和多种按键状态所必须的
    ' Q/ i* y8 K+ F1 T; L! n
49. */
    
50. typedef struct button
    
51. {
    : m. k' f! W: {' B: a6 K
52. /* 下面是一个函数指针，指向判断按键手否按下的函数 */
    
53. uint8_t (*Read_Button_Level)(void); /* 读取按键电平函数，需要用户实现 */
    3 B3 N+ S) ^) H2 y0 i
54.   
    2 O6 Q* _* H* {- q5 @& a7 w9 |
55.   char Name[BTN_NAME_MAX];
    
56.    
    ; b* N: q+ y3 [1 s& V
57.   uint8_t Button_State              :   4;   /* 按键当前状态（按下还是弹起） */
    % O1 t4 m  T- x! M6 K0 R4 _- u0 x+ H  J
58.   uint8_t Button_Last_State         :   4;   /* 上一次的按键状态，用于判断双击 */
    & h( U9 q0 h5 z3 N
59.   uint8_t Button_Trigger_Level      :   2;    /* 按键触发电平 */
    7 g; ~# l  W& z4 H7 e
60.   uint8_t Button_Last_Level         :   2;    /* 按键当前电平 */
    
61.   
    $ C1 Q6 n6 T# u6 z% i
62.   uint8_t Button_Trigger_Event;     /* 按键触发事件，单击，双击，长按等 */
    
63.   
    4 X- B7 q; w3 A+ O9 D# t
64.   Button_CallBack CallBack_Function[number_of_event];
    # J: A7 h+ }( X* P  M2 P) c9 _
65.   
    ! _0 E5 [& u2 d
66. uint8_t Button_Cycle;            /* 连续按键周期 */
    - p0 _3 O6 h/ w4 E! s
67.   
    6 o7 ]% d' U  O/ \  X1 `, f- p6 a
68.   uint8_t Timer_Count;   /* 计时 */
    
69. uint8_t Debounce_Time;  /* 消抖时间 */
    
70.   
    
71. uint8_t Long_Time;    /* 按键按下持续时间 */
    % e" E3 w6 S7 c( ]8 i# H. A+ ~
72.   
    5 Y" z0 c1 _8 M
73.   struct button *Next;
    4 [, @1 i. \+ m" k, K
74.   
    ! L: o. ^' j9 E, x
75. }Button_t;

复制代码

+ \1 p$ u& Q: y

然后看看如何使用API,我们只需要实现GPIO的状态获取、创建按键对象、编写回调函数即可，在任务中轮询按键状态，移植起来是非常方便的

1. #define KEY_ON    0
   
2. /* Private macro -------------------------------------------------------------*/
   * h- H6 {9 E( c) i
3. 
   5 y4 T6 n( q: I! E* [3 X
4. /* Private variables ---------------------------------------------------------*/
   
5. Button_t Button1;
   
6. /* Private function prototypes -----------------------------------------------*/
   
7. static uint8_t rt_read_key1(void)
   . e! J2 ~9 F: J5 O
8. {
   
9. return HAL_GPIO_ReadPin(USR_KEY1_GPIO_Port,USR_KEY1_Pin);
   
10. }
    $ G7 a- T" a6 t4 v
11. 
    # L( N4 a( _8 o. S0 C9 i
12. static void Btn1_Dowm_CallBack(void *btn)
    
13. {
      b$ }  ?8 A" k; W. \0 e0 h+ E! e8 m
14.   PRINT_INFO("Button1 单击!");
    
15. }
    7 Y7 w) Z$ \3 O& T
16. 
    1 j# J* e5 e6 N" o/ z! u3 l
17. static void Btn1_Double_CallBack(void *btn)
    
18. {
    
19.   PRINT_INFO("Button1 双击!");
    
20. }
    % Z: \7 w1 j* C  a) p9 |
21. 
    # n; A, f8 m% p5 W1 y+ V8 p5 N' J: e
22. static void Btn1_Long_CallBack(void *btn)
    . Y3 N$ H. B) W5 O, }+ B
23. {
    3 L  c6 ]7 @3 F1 j
24.   PRINT_INFO("Button1 长按!");
    
25. }
    , {! s7 x! T5 }
26. 
    & A( [  q  X' W: W
27. static void Btn1_Continuos_CallBack(void *btn)
      _( E. s! x% f$ R
28. {
    . ^7 E: O( x6 G  y' N! r/ }0 a1 b, e
29.   PRINT_INFO("Button1 连按!");
    ) m7 v9 k( _$ \2 f
30. }
    
31. static void Btn1_ContinuosFree_CallBack(void *btn)
    
32. {
    " m  ^/ h" l# q/ I! H* b2 @
33.   PRINT_INFO("Button1 连按释放!");
    
34. }
    
35. /* Private user code ---------------------------------------------------------*/
    - d& U3 V+ r& T3 g
36. 
    
37. /**
    
38. * @function rt_ledflash_entry
    
39. * @author:小飞哥玩嵌入式-小飞哥
    # V0 Y9 E! r! g1 N$ n2 Y
40. * @TODO: LED控制线程
    
41. * @param:
    
42. * @return: NULL
    
43. */
    
44. static void rt_led1_flash_entry(void *parameter)
    
45. {
    
46. 
    
47.    Button_Create("Button1",
    
48.               &Button1,
    + C& ~. @$ J, ^  e
49.               rt_read_key1,
    
50.               KEY_ON);
    - x+ x. F! E* n' j
51.   Button_Attach(&Button1,BUTTON_DOWM,Btn1_Dowm_CallBack);                       //单击
      X8 Z: ?$ k9 H: D
52.   Button_Attach(&Button1,BUTTON_DOUBLE,Btn1_Double_CallBack);                   //双击
    $ M, p' ^. x# _  N( v8 l3 M5 r- u
53.   Button_Attach(&Button1,BUTTON_CONTINUOS,Btn1_Continuos_CallBack);             //连按  
    # t  {9 x2 k: z2 r. y" P
54.   Button_Attach(&Button1,BUTTON_CONTINUOS_FREE,Btn1_ContinuosFree_CallBack);    //连按释放  
    
55.   Button_Attach(&Button1,BUTTON_LONG,Btn1_Long_CallBack);        
    0 ]# h- g$ W0 M& {
56.   
    - W0 {' [% l: M. }1 s
57.    for (;;)
    
58.   {
    
59.   
    / l2 J$ i. t" n# g0 ]$ z+ I% W& Q3 Q
60.   Button_Process();     //需要周期调用按键处理函数
    
61.   rt_thread_mdelay(20);
    
62. //  if(!HAL_GPIO_ReadPin(USR_KEY1_GPIO_Port,USR_KEY1_Pin))
    
63. //  {
    ' _, ?: q- ~0 }$ z, W
64. //   rt_thread_mdelay(100);
    
65. //   if(!HAL_GPIO_ReadPin(USR_KEY1_GPIO_Port,USR_KEY1_Pin))//消抖
    ( C% p7 x! b9 {1 M  n
66. //   {
    
67. //    rt_kprintf("Key1 is presseded!\r\n");
    
68. //   }
    1 |9 C# I/ R9 \
69. //  }
    
70. //  if(!HAL_GPIO_ReadPin(USR_KEY2_GPIO_Port,USR_KEY2_Pin))
    2 b* T! }7 m, s& n7 m' ^' ?) |/ g
71. //  {
    ; i( c. m2 ~+ B1 W
72. //   rt_thread_mdelay(100);
    * H! f. @8 j' G; h. F
73. //   if(!HAL_GPIO_ReadPin(USR_KEY2_GPIO_Port,USR_KEY2_Pin))//消抖
    : U/ y1 i7 c" Y1 _+ f" E
74. //   {
    & Y$ A% U! v" h1 o; m$ V: _( q2 R
75. //    rt_kprintf("Key2 is presseded!\r\n");
    
76. //   }
    ' D' ~2 h( m6 g( R: B( P) s7 _
77. //  }
    
78. //  if(!HAL_GPIO_ReadPin(USR_KEY3_GPIO_Port,USR_KEY3_Pin))
    
79. //  {
    / b6 `1 A! i) T7 ~! K
80. //   rt_thread_mdelay(100);
    
81. //   if(!HAL_GPIO_ReadPin(USR_KEY3_GPIO_Port,USR_KEY3_Pin))//消抖
    
82. //   {
    0 `! u+ }% r/ k# k0 V
83. //    rt_kprintf("Key3 is presseded!\r\n");
    + d% t8 M8 ~3 O4 U
84. //   }
    + B2 K: V; F1 R0 V, P
85. //  }
    7 P& H! Q6 ?& p; |  b$ `: L" d1 z: w
86.   }
    6 _, \( b: m7 n4 X! F* I7 R
87. 
    
88. }

复制代码

! i0 Z$ n, ?4 u( R( T2 h

2 I& t1 X& \8 x! E

来看一下测试效果：