第八章 按键输入实验

使用 STM32F7 的 IO 口作为输入用。在本章中，我们将利用板载的 3 个按键，来控制板载的两个 LED 的亮灭。通过本章的学习，你将了解到 STM32F7 的 IO 口作为输入口的使用方法。本章分为如下几个小节：

7 [. p/ D1 v- C  X

8.1 STM32F7 IO 口简介

STM32F7 的 IO 口在上一章已经有了比较详细的介绍，这里我们不再多说。STM32F7 的 IO

口做输入使用的时候，是通过调用函数 HAL_GPIO_ReadPin ()来读取 IO 口的状态的。了解了这

点，就可以开始我们的代码编写了。

这一章，我们将通过 ALIENTEK 水星 STM32 开发板上载有的 4 个按钮（KEY_UP、KEY0、

KEY1 和 KEY2），来控制板上的 2 个 LED（DS0 和 DS1），其中 KEY_UP 控制 DS0，DS1 互斥

点亮；KEY2 控制 DS0，按一次亮，再按一次灭；KEY1 控制 DS1，效果同 KEY2；KEY0 则同

时控制 DS0 和 DS1，按一次，他们的状态就翻转一次。

8.2 硬件设计

本实验用到的硬件资源有：

1） 指示灯 DS0、DS1。

2） 4 个按键：KEY0、KEY1、KEY2、和 KEY_UP。

DS0、DS1 和 STM32F767 的连接在上一章已经介绍过了，在水星 STM32 开发板上的按键

KEY0 连接在 PH3 上、KEY1 连接在 PH2 上、KEY2 连接在 PC13 上、KEY_UP 连接在 PA0 上。

如图 7.2.1 所示：

9 S! n& U' I6 n  A3 b, n

图 8.2.1 按键与 STM32F767 连接原理图

这里需要注意的是：KEY0 和 KEY1 是低电平有效的，而 KEY_UP 是高电平有效的，并且

外部都没有上下拉电阻，所以，需要在 STM32F767 内部设置上下拉。

8.3 软件设计

从这章开始，我们的软件设计主要是通过直接打开我们光盘的实验工程，而不再讲解怎么

加入文件和头文件目录。工程中添加相关文件的方法在我们前面实验已经讲解非常详细。

打开按键实验工程可以看到，工程引入了 key.c 文件以及头文件 key.h。下面我们首先打开

key.c 文件，关键代码如下：

1. #include "key.h"
   ( B2 I  T8 b: ]3 v- t
2. #include "delay.h"
   ' u! ~3 z0 U2 p; p( F
3. //按键初始化函数
   
4. void KEY_Init(void)
   & b/ P2 S: R3 [
5. {
   
6. GPIO_InitTypeDef GPIO_Initure;
   
7. __HAL_RCC_GPIOA_CLK_ENABLE();
   " @; c3 w) v5 \* w  q9 x1 [
8. //开启 GPIOA 时钟
   6 n) e1 z$ T+ X8 T1 [& Q
9. __HAL_RCC_GPIOC_CLK_ENABLE();
   ' I3 B  ^6 }9 Y2 F
10. //开启 GPIOC 时钟
    5 n) q; o9 g% U( y
11. __HAL_RCC_GPIOH_CLK_ENABLE();
    
12. //开启 GPIOH 时钟
    / `( D- k: m( B; J3 J5 I' u. }
13. GPIO_Initure.Pin=GPIO_PIN_0;
    
14. //PA0
    
15. GPIO_Initure.Mode=GPIO_MODE_INPUT; //输入
    
16. GPIO_Initure.Pull=GPIO_PULLDOWN; //下拉
    % E' Q6 R: @3 U, j3 w
17. GPIO_Initure.Speed=GPIO_SPEED_HIGH; //高速
    1 y. w; J; G' J( P
18. HAL_GPIO_Init(GPIOA,&GPIO_Initure);
    ) F, V) r9 j, ?
19. GPIO_Initure.Pin=GPIO_PIN_2|GPIO_PIN_3; //PH2,3
    
20. GPIO_Initure.Mode=GPIO_MODE_INPUT; //输入
    " a2 G2 P% J% K, n- ?1 C
21. GPIO_Initure.Pull=GPIO_PULLUP; //上拉
    3 T6 X* X5 M3 c6 ~! Z' e
22. GPIO_Initure.Speed=GPIO_SPEED_HIGH; //高速
    2 z7 g* [' \* s0 @; u% ?
23. HAL_GPIO_Init(GPIOH,&GPIO_Initure);
    & N1 I1 a5 N( z3 s1 z( Q; j
24. }
    9 Y& q+ X( }* _' \
25. //按键处理函数
    $ D" Z) V$ g  O7 q
26. //返回按键值
    
27. //mode:0,不支持连续按;1,支持连续按;
    : v5 V& Z2 J# S6 Y: u
28. //0，没有任何按键按下 1，WKUP 按下 WK_UP
    
29. //注意此函数有响应优先级,KEY0>KEY1>WK_UP!!
    
30. u8 KEY_Scan(u8 mode)
    0 V; N; }- r6 \# J
31. {
    # }7 N  I, c# E' V5 {; g  l
32. static u8 key_up=1;
    * s# W* E; |+ m9 \2 T* p
33. //按键松开标志
    9 k& x0 z) J: p5 l5 g& V
34. if(mode==1)key_up=1; //支持连按
    
35. if(key_up&&(KEY0==0||KEY1==0||WK_UP==1))
    # `0 t; i# L  C( W# a6 ^9 D# i
36. {
    
37. delay_ms(10);
    
38. key_up=0;
    - e7 d5 {9 A2 F
39. if(KEY0==0) return KEY0_PRES;
    
40. else if(KEY1==0) return KEY1_PRES;
    , B* r! c- a! R5 r( l4 y: h" p8 a
41. else if(WK_UP==1) return WKUP_PRES;
    9 \2 o2 M: R: ^) _# T4 R" E+ N! u; R
42. }else if(KEY0==1&&KEY1==1&&WK_UP==0)key_up=1;
    
43. return 0; //无按键按下
    3 t# y1 W: B) F# I/ Q0 A9 K$ O- s
44. }

复制代码

/ h4 U2 M+ I  [, j( D5 A' s" k

这段代码包含 2 个函数，void KEY_Init(void)和 u8 KEY_Scan(u8 mode)，KEY_Init 是用来

初始化按键输入的 IO 口的。实现 PA0、PC13、PH2 和 PH3 的输入设置，这里和第六章的输出

配置差不多，只是这里用来设置成的是输入而第六章是输出。

KEY_Scan 函数，则是用来扫描这 4 个 IO 口是否有按键按下。KEY_Scan 函数，支持两种

扫描方式，通过 mode 参数来设置。

当 mode 为 0 的时候，KEY_Scan 函数将不支持连续按，扫描某个按键，该按键按下之后必

须要松开，才能第二次触发，否则不会再响应这个按键，这样的好处就是可以防止按一次多次

触发，而坏处就是在需要长按的时候比较不合适。

当 mode 为 1 的时候，KEY_Scan 函数将支持连续按，如果某个按键一直按下，则会一直返

回这个按键的键值，这样可以方便的实现长按检测。

有了 mode 这个参数，大家就可以根据自己的需要，选择不同的方式。这里要提醒大家，

因为该函数里面有 static 变量，所以该函数不是一个可重入函数，在有 OS 的情况下，这个大家

要留意下。同时还有一点要注意的就是，该函数的按键扫描是有优先级的，最优先的是 KEY0，

第二优先的是 KEY1，最后是 KEY_UP 按键。该函数有返回值，如果有按键按下，则返回非 0

值，如果没有或者按键不正确，则返回 0。

接下来我们看看头文件 key.h 里面的代码：

1. #ifndef _KEY_H
   ' e* g: h6 ^  ?4 V) w
2. #define _KEY_H
   : M& b% e6 [% b2 j. a6 v9 u+ n
3. #include "sys.h"
   . f  B' Z& B( }! ]: |1 o+ b2 |0 H
4. /*下面的方式是通过直接操作 HAL 库函数方式读取 IO*/
   , X, G6 V" ?+ X- H) S( ^8 F7 o
5. #define KEY0 HAL_GPIO_ReadPin(GPIOH,GPIO_PIN_3) //KEY0 按键 PH3
   # G7 B& G9 u. [! _
6. #define KEY1 HAL_GPIO_ReadPin(GPIOH,GPIO_PIN_2) //KEY1 按键 PH2
   4 I& ?6 X' D$ d3 `% @" Z& W
7. #define WK_UP HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) //WKUP 按键 PA0
   
8. #define KEY0_PRES 1
   
9. #define KEY1_PRES
   
10. 2
    
11. #define KEY2_PRES
    
12. 3
    
13. void KEY_Init(void);
    & T) M5 [1 e" `7 a
14. u8 KEY_Scan(u8 mode);
    ! }$ F" b9 i$ g2 ]7 |' ~
15. #endif

复制代码

" N# G: T. e) [- Y3 w

这段代码里面最关键就是 4 个宏定义：

#define KEY0 HAL_GPIO_ReadPin(GPIOH,GPIO_PIN_3) //KEY0 按键 PH3

#define KEY1 HAL_GPIO_ReadPin(GPIOH,GPIO_PIN_2) //KEY1 按键 PH2

#define WK_UP HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) //WKUP 按键 PA0

这里使用的是调用 HAL 库函数 HAL_GPIO_ReadPin 来实现读取某个 IO 口的输入电平。函

数 HAL_GPIO_ReadPin 的使用方法在上一章跑马灯实验我们已经讲解，这里我们就不累赘了。

在 key.h 中，我们还定义了 KEY0_PRES / KEY1_PRES//WKUP_PRESS 等 4 个宏定义，分

别对应开发板四个按键（KEY0/KEY1/KEY_UP）按键按下时 KEY_Scan 返回的值。通过宏定义

的方式判断返回值，方便大家记忆和使用。

最后，我们看看 main.c 里面编写的主函数代码如下：

1. int main(void)
   . j2 V2 I/ w3 {8 L5 B5 v
2. {
   1 N( J2 {: Z& t  r8 z
3. u8 key;
   * z! \% a% `2 F  @
4. u8 led0sta=1,led1sta=1;
   
5. //LED0,LED1 的当前状态
   
6. Cache_Enable(); //打开 L1-Cache
   : ^! r! A  ^. Y$ }* ^& s
7. HAL_Init();
   + W6 K0 h! w) v! i3 i0 A
8. //初始化 HAL 库
   
9. Stm32_Clock_Init(432,25,2,9); //设置时钟,216Mhz
   
10. delay_init(216); //延时初始化
    ( [( O! V! L7 z; b; C% V
11. uart_init(115200);
    
12. //串口初始化
    
13. LED_Init(); //初始化 LED
    7 y( i6 D3 l8 ~' H/ M! f7 i
14. KEY_Init(); //按键初始化
    & b. s# E3 m/ F$ v( ~/ ?
15. while(1)
    
16. {
    - U6 G2 W$ L( z% u! r( S5 }, q
17. key=KEY_Scan(0);
    - U3 f5 M' F' `/ A
18. //得到键值
    - s# w. C! n* {8 |
19. if(key)
    
20. {
    
21. switch(key)
    
22. {
      T$ H4 o  [4 n- H7 W( b( O4 g
23. case WKUP_PRES:
    8 e. _6 C; k1 Z8 R: l
24. //控制 LED0,LED1 互斥点亮
    
25. led1sta=!led1sta;
    6 `( w; g$ G8 E+ Z' j/ k
26. led0sta=!led1sta;
    9 p- c2 H7 I; K' |, J
27. break;
    # L& M: C* Z7 U; ~/ I5 G) V$ a4 t7 _
28. case KEY0_PRES: //控制 LED0 翻转
    
29. led0sta=!led0sta;
    
30. break;
    
31. case KEY1_PRES: //控制 LED1 翻转
    / l7 ^. A) P) P9 z5 Y1 z
32. led1sta=!led1sta;
    + W1 l0 M0 e* N+ ?( `) I
33. break;
    
34. }
    
35. LED0(led0sta);
    9 V0 E) d  ]/ G0 ?
36. //控制 LED0 状态
    / a2 O- V$ n8 ]( ^
37. LED1(led1sta);
    
38. //控制 LED1 状态
    
39. }else delay_ms(10);
    $ n7 ^$ P  f% g9 j
40. }
    9 v4 `, a7 w2 _# G) Z' z
41. }

复制代码

主函数代码比较简单，先进行一系列的初始化操作，然后在死循环中调用按键扫描函数

KEY_Scan()扫描按键值，最后根据按键值控制 LED 的状态。

1 O* `6 |* _' q7 }- n+ M7 `

8.4 下载验证

同样，我们还是通过 ST LINK 来下载代码，在下载完之后，我们可以按 KEY0、KEY1 和

KEY_UP 来看看 DS0 和 DS1 的变化，是否和我们预期的结果一致？

至此，我们的本章的学习就结束了。本章，作为 STM32F767 的入门第二个例子，介绍了

STM32F767 的 IO 作为输入的使用方法，同时巩固了前面的学习。希望大家在开发板上实际验

证一下，从而加深印象。

4 A( W% a/ E+ ^, B9 l9 O* e

8.5 STM32CubeMX 配置 IO 口输出

上一章我们讲解了使用 STM32CubeMX 工具配置 GPIO 的一般方法。本章我们主要教大家

配置 IO 口为输入模式，操作方法和配置 IO 口为输出模式基本一致。这里我们就直接列出 IO

口配置截图，具体方法请参考 4.8 小节和上一章跑马灯实验。

根据 8.2 小节讲解，水星开发板上有 3 个按键，分别连接四个 IO 口 PA0，PH2 和 PH3。其

中 WK_UP 按键按下后对应的 PA0 输入为高电平，所以默认情况下，该 IO 口（PA0）要初始化

为下拉输入，其他 IO 口初始化为上拉输入即可。

使用 STM32CubeMX 打开光盘工程模板（双击工程目录的 Template.ioc），目录为“4，程

序源码标准例程-库函数版本实验 0-3 Template 工程模板-使用 STM32CubeMX 配置”。我们首

先在 IO 口引脚图上，依次设置四个 IO 口为输入模式 GPIO_Input。这里我们以 PA0 为例，操作

方法如下图 8.5.1 所示：

图 8.5.1 配置 PA0 为输入模式

同样的方法，我们依次配置 PH2 和 PH3 为输入模式。然后我们进入 Configuration->GPIO

配置界面，配置四个 IO 口详细参数。在配置界面点击 PA0 可以发现，当我们在前面设置 IO 口

为输入GPIO_Input之后，其配置参数只剩下模式GPIO Mode和上下拉GPIO Pull-up/Pull-down，

并且模式值中只有输入模式 Input Mode 可选。这里，我们配置 PA0 为下拉输入，其他三个 IO

口配置为上拉输入即可。配置方法如下图 8.5.2 所示：

% Y7 I2 {( E' R/ \/ \$ \6 U& e" W

图 8.5.2 配置 IO 口详细参数

配置完成 IO 口参数之后，接下来我们同样生成工程。打开生成的工程会发现，main.c 文件

中添加了函数 MX_GPIO_Init 函数，内容如下：

1. static void MX_GPIO_Init(void)
   : z0 i9 [# o2 |
2. {
   / [: Z( X; I8 Z' C+ {/ q: T
3. GPIO_InitTypeDef GPIO_InitStruct;
   9 W$ y$ o3 o) r
4. /* GPIO Ports Clock Enable */
   ! l& }0 ^- l4 t' L' C: j
5. __HAL_RCC_GPIOH_CLK_ENABLE();
   
6. __HAL_RCC_GPIOA_CLK_ENABLE();
   3 c2 z! f. n% V& g: q; i' k
7. /*Configure GPIO pin : PA0 */
   
8. GPIO_InitStruct.Pin = GPIO_PIN_0;
   
9. GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
   " w2 s: ]8 y) h/ H! n
10. GPIO_InitStruct.Pull = GPIO_PULLDOWN;
    ( k4 v# b6 \! Z
11. HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
12. /*Configure GPIO pins : PH2 PH3 */
    : b4 O/ `5 X, \% V/ [2 e
13. GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_3;
    + @* q/ N" j3 M' F% p
14. GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    - d! [! x) e0 n" _0 U' }8 H
15. GPIO_InitStruct.Pull = GPIO_PULLUP;
    
16. HAL_GPIO_Init(GPIOH, &GPIO_InitStruct);
    
17. }

复制代码

. Q3 W& u9 W. W$ z$ j+ l  d

该函数实现的功能和按键输入实验中 KEY_Init 函数实现的功能一模一样。有兴趣的同学可

以直接复制该函数内容替换按键输入实验中的 KEY_Init 函数内容，替换后会发现实现现象完全

一致。

使用 STM32CubeMX 配置 IO 口为输入模式方法就给大家介绍到这里。

" o8 C) |2 \6 k6 G( H: X/ W7 c) V