12.1 关于按键
5 j1 B$ V* I2 f9 W$ _% p6 Y前面控制LED灯是让GPIO输出高低电平，而获取按键则是读取GPIO电平，从而获知用户是否按下按键。

" I$ o6 |3 }3 J& v4 w按键监测一般有两种：按键扫描和按键中断。按键扫描是间隔很短时间反复查询GPIO状态，从而得知是否有按键动作，这种方式代码简单，但比较耗资源。按键中断而是通过按键产生中断信号，从而实现按键的检测，这种方式需要使用到中断机制，需要对MCU了解深入一点，效果是最好的。
5 |" c+ Q: w; U& ~8 p! g
本节先介绍按键扫描，理解按键的基本原理，下一章再介绍按键中断，同时了解STM32F103的中断使用方法。

0 u6 ]0 F' m' O0 D, M. B3 e: t* X* O按键一般占用一个GPIO口，通过监测该GPIO的电平变化得知按键操作，典型的电路如图 12.1.1 所示。当所需按键比较多时，则可以采用矩阵按键减少GPIO的占用。矩阵按键需要通过编程扫描等方式实现对多个按键的监控，这里以最简单的独立按键为基础进行介绍。
+ G0 F" ?% l- b! e& Y7 S9 K4 q
) ~/ w* P7 s0 h
) F8 x9 O+ C$ @" s$ h' u9 B
图 12.1.1 按键与MCU的连接方式示意图
" \9 n4 I- c9 b( w' A# a可以看到，在没有按下按键时，电源3.3V通过电阻连接到MCU的PA0脚上，此时MCU读取PA0的电平就是3.3V的高电平。在按键按下时，电源3.3V经过电阻，再经过按键连接到了地，此时PA0连接到接地的一端，读到的电平就是0V的低电平。由此，MCU就可用过读取对应引脚的电平值，得知按键的变化。
3 u* i  ]2 z/ M  a4 ?8 Z
常用的按键都是机械触点式按键，机械式按键在按下或释放的过程中，由于机械弹性作用的影响，会伴随机械抖动，如图 12.1.2 所示。



- g. T$ f( |5 [; P: R
图 12.1.2 机械按键抖动示意图


- i2 D' k6 x$ H$ L" A8 s抖动的时长与机械开关特性相关，一般为5-10ms。在这抖动过程中，会产生多次高低电平，导致被识别为多次按键操作。为了避免机械触点按键检测误判，必须消抖处理。按键消抖可以硬件上处理，即在按键旁并联电容，吸收抖动的电平。也可以软件处理，即通过延时，避开抖动。
3 ^0 j4 x( M/ _
由此，首先获取对应引脚的电平得知按键状态，再硬件或软件消除抖动。
' v* e  i$ P. k4 F9 V0 U# r

12.2 硬件设计
开发板上有两个按键，一个是复位按键（K1，红色），另一个是用户按键（K2，白色），这里只有用户按键能够编程控制。
' J/ M% z3 @' O7 ?- Z* O% j5 Y+ L0 T
如图 12.2.1 为开发板用户按键部分的原理图，电容C15用于硬件去抖，可以看作不存在。按键松开时，3V3经过上拉电阻R20到网络标号KEY，网络标号KEY另一端连接MCU的PA0，此时读取PA0电平为高电平；按键按下时，3V3经过上拉电阻R20，再通过按键接地，此时读取PA0电平为低电平。

由此可知，按键按下，GPIO引脚电平变低，反之为高，按键所接GPIO为PA0。


" Z6 S; g6 c% a! X
图 12.2.1 用户按键原理图


# I9 g' y) {+ h5 W! X12.3 软件设计
0 f6 C# `$ j/ e) V6 d& s2 c1.3.1 软件设计思路
实验目的：本实验通过轮询读方式取GPIO的输入电平判断按键是否按下，并操作LED。

$ A  [1 Y3 m2 v7 [$ C; u1) 按键初始化：GPIO端口时钟使能、GPIO引脚设置为输入（PA0）；
+ D0 O5 F& [* M. b/ ?
7 @* v; r+ i/ s) }+ @" p! C2) 封装每个按键处理函数：读取按键GPIO状态，操作LED灯亮灭；
* K" }% c( J! n- V, `
% w/ ]0 ]9 b0 U( U& Z, Y& k3) 主函数轮询按键状态：一直检测是否有按键被按下；

& h) U! D0 x" |  P9 B本实验配套代码位于“5_程序源码\5_GPIO—按键轮询\”。
; l& n$ A6 v% O0 d
9 G+ D; ]2 ~& J7 Q
9 q4 g8 |' [2 f# [# d  {7 I1.3.2 软件设计讲解
- |- u" x. U3 [+ V' K* S7 d1) GPIO宏定义与接口宏定义
9 z( v3 J) Q' \4 F, u
代码段 12.3.1 引脚宏定义（driver_key.h）
/ a  H/ @8 C# j& }0 w# z# B) K

1. /*********************
   
2. 
   ' X) O, U3 K3 `. }% q# F
3. * 按键引脚状态定义
   9 q3 j% B& J2 @1 Y9 w
4. 
   2 s; Q" \4 W; \/ h
5. **********************/
   
6. 
   * g4 e! z! J$ e6 J. w/ E/ j2 n) a
7. #define PUSH_DOWN                       GPIO_PIN_RESET
   
8. 
   
9. #define SPRING_UP                       GPIO_PIN_SET
   $ `3 X! _9 _2 ?$ H: |! _7 ^
10. 
    ; }& j8 @( j( I: n0 I, Q" A) O
11. 
    
12. 
    ( `4 @% l  t  ~; [8 w7 q
13. /*********************
    . E% D3 h5 Z' v7 o; A5 O
14. 
    4 a6 H, `2 m: v, ^! V1 N8 Z! l
15. * 引脚宏定义
    
16. 
    / M6 X* n# g& b  Z: Q& h
17. **********************/
    
18. 
    
19. #define KEY_GPIO_PIN                 GPIO_PIN_0
    8 n  L6 o% ]& y6 Y+ m
20. 
    
21. #define KEY_GPIO_PORT                GPIOA
    
22. 
    , G2 t5 a0 W. U6 V, H* V
23. #define KEY_GPIO_CLK_EN()            __HAL_RCC_GPIOA_CLK_ENABLE()
    
24. 
    ) f5 k9 H& L: P5 Y' ?
25. 
    
26. 
    
27. /*********************
    $ X% t. g5 ]5 [9 \
28. 
    
29. * 函数宏定义
    ' r5 }( G& F! ^, [. |9 _
30. 
    
31. **********************/
    8 ?: x/ y: v/ a
32. 
    5 u! g5 G5 J6 Z5 B( x" V
33. /*
    ; R) ]$ m9 }) J+ Y) r6 i( V
34. 
    
35. * 按键状态读取函数宏定义
    + _! z* d% k" A. I
36. 
    
37. */
    
38. 
    
39. #define KEY                  HAL_GPIO_ReadPin(KEY_GPIO_PORT, KEY_GPIO_PIN)

复制代码

根据硬件设计选定的对应按键的引脚，将其宏定义命名为KEY，且对他们的读取函数进行重命名。其中“HAL_GPIO_ReadPin()”原型“GPIO_PinState HAL_GPIO_ReadPin(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin)”，参数依次是：引脚组，引脚号，返回的是0（低电平）或1（高电平）。
/ }6 H) L: J4 I! V/ e9 W! ^

2) GPIO初始化
& B" u5 t7 T. @1 h! o' `0 E
代码段 12.3.2 按键初始化（driver_key.c）
8 N2 L/ c2 B/ Z) B# v, c

1. /*
   
2. 
   
3. *  函数名：void KeyInit(void)
   / b1 U) L' C% E& u
4. 
   # L+ [6 }: t7 S. l( J' C# n% {
5. *  输入参数：无
   ' n6 Y4 F5 p3 b2 U6 I5 {
6. 
   
7. *  输出参数：无
   
8. 
   
9. *  返回值：无
   $ A+ w( V( S- j  A8 V' J
10. 
    
11. *  函数作用：初始化按键的引脚，配置为输入
    ! C! I7 K+ R$ Y  g! Q( a% Y1 ]1 }
12. 
    
13. */
    3 ]- f( Z1 i2 m- a0 t/ N
14. 
    
15. void KeyInit(void)
    , k# V  Y/ u$ }7 |2 q, M3 E2 @1 A
16. 
    
17. {
    + U* i3 n, l4 Y4 s  b) X  f  s
18. 
    7 Y" E. X7 N1 f- p6 n
19.     // 定义GPIO的结构体变量
    0 S! U% |8 B, S
20. 
    
21.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    
22. 
    
23.     // 使能按键的GPIO对应的时钟
    
24. 
    
25.     KEY_GPIO_CLK_EN();
      h; b, H0 _$ P" A9 H
26. 
    , r3 Q9 ?2 R% {
27. 
    ) o& f) k, E8 }7 ^; a6 o
28. 
    
29.     GPIO_InitStruct.Mode = GPIO_MODE_INPUT;             // 设置为输入模式
    . E/ E! m- h6 \0 [6 j9 C
30. 
    6 {. L3 Q6 p$ B, K) A+ D6 E
31.     GPIO_InitStruct.Pull = GPIO_PULLUP;                 // 默认上拉
    ! G8 T* N1 M! ^' N* b; n
32. 
    ( d0 i$ ], }, ]/ R0 Y
33.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;       // 引脚反转速度设置为快
    1 v/ R; q0 |8 b& }9 E, ]5 n% u" d) S
34. 
    
35. 
    + c$ c2 [( P! B" v& Y
36. 
    5 ]# F. {# t7 H" W! D. a
37.     // 初始化按键引脚配置
    
38. 
    2 k+ n. a+ B" `$ [
39.     GPIO_InitStruct.Pin = KEY_GPIO_PIN;              // 选择按键的引脚
    ' I% j' A% B) W% i3 f
40. 
    ' j& D  b0 @, T! Z" K
41.     HAL_GPIO_Init(KEY_GPIO_PORT, &GPIO_InitStruct);
    , T1 @; a. N+ }/ i
42. 
    
43. }

复制代码

2 m0 |9 p; d& J& d% U0 A% y) x" W& n  x使能时钟，将引脚初始化为上拉输入。

7 \) ^/ C* d! E- C& x6 j: ~6 {
3 @$ z. p- n0 y6 P8 z; K# f3) 按键读取函数

为了展示效果，编写代码查询按键是否按下，按下后切换LED灯亮灭状态。

- e* E' Q* S& C- Z/ w 代码段 12.3.3 按键读取函数（driver_key.c）

1. /*
   
2. 
   
3. *  函数名：void KeyPolling(void)
   
4. 
   
5. *  输入参数：无
   
6. 
   
7. *  输出参数：无
   6 _$ T# Z. @, M% \
8. 
   
9. *  返回值：无
     u. V( C& o& i' w
10. 
    : z) T$ D5 Y$ p' p3 k
11. *  函数作用：使用轮询方式查询按键是否按下，通过按下控制LED灯亮灭
    0 L$ S+ y/ ~- z6 p! N3 H
12. 
    . J2 Z+ O/ A1 ~- Y5 Y
13. */
    ( l3 s& e9 q* T* G1 X" C, M5 q
14. 
    
15. static bool key_flag = false;
    - j6 @" b& C+ H  o5 s
16. 
    1 `. R/ T( E# F4 \
17. void KeyPolling(void)
    
18. 
    
19. {
    
20. 
    
21.     if(KEY == PUSH_DOWN)          // 如果检测到按键被按下
    
22. 
    
23.     {
    
24. 
    
25.         HAL_Delay(8);             // 延时8ms防按键抖动
    " }4 \1 z3 H* s4 ]( v8 P
26. 
    " L& ]8 k% w2 {
27.         if(KEY == PUSH_DOWN)      // 如果防抖动后按键依然是处于被按下的状态，就认为按键被按下过
    
28. 
    
29.         {
    
30. 
    
31.             key_flag = !key_flag; // 用一个标志位来判断按键被按下次数，按下一次灯亮，再按一次灯灭，如此反复
    ! W! w/ x5 J7 Z# M1 U  z7 K' M; H, I
32. 
    
33. BLED(key_flag?OFF:ON);
    , _$ {  ?. ?, [* z6 {8 L
34. 
    ! h' S8 x0 r" e
35.         }
    
36. 
    / y8 n7 A3 }& j! L- G' a
37.     }
    
38. 
    
39. }

复制代码

8行：定义了一个全局变量标志位“key_flag”，作为按键被按下的标志；

11行：获取该按键状态;

4 Z; g; _2 ?" g+ N) Z4 S- R1 N13行：延时5-10ms，软件去抖；

' w( V% ]- m5 ~6 q14行：再次获取该按键状态，此时依旧按下，说明是正常按键操作，非抖动；
% B% B+ \4 }4 Z) y& ?2 q' d  O6 V' C
! }. _7 X0 Q! H1 C& }16行：将标志位置反，按键按一次置反一次（即0->1->0->1这样循环）；
8 P, C; m6 ~. a* c5 r) Q
# v& H6 P# D( F' k& T7 h17行：根据标志位“key_flag”的值，让LED灯亮或灭；
9 c: R- |$ w' b3 {/ o0 f
; l$ z1 ]% X: \3 n此时每按下一次按键键，蓝色LED灯将亮灭交替。


4) 主函数测试
1 |. A/ E# w/ ^- F6 E
3 w* `0 {0 @3 G8 T代码段 12.3.4 主函数控制逻辑（main.c）

1. // 初始化LED
   + H$ d& g6 k7 d
2. 
   
3. LedGpioInit();
   
4. 
   : ]7 k, }: U! M- @
5. // 初始化按键
   
6. 
   2 {6 J. [5 |- f/ V; [' E
7. KeyInit();
   
8. 
   ' H  W9 D8 Z# ]! v
9. 
   4 M0 x7 ^+ @, p4 B3 w2 P9 ]
10. 
    % d4 t6 F7 W% h  H( \, F, N
11. while(1)
    6 Q1 m& U4 v) q) I7 |4 ~; `% W
12. 
      Q6 _: H( Y/ R
13. {
    
14. 
    ! N7 e. [& F  ]# `1 Y3 ]
15.     // 轮询按键键
    % G& l9 y' t+ H
16. 
    
17.     KeyPolling();
    
18. 
    ( z4 C% Q9 t2 j$ e1 H* }8 U6 M
19. }

复制代码

8 C: X) k) Y) I6 F' v. V5 h1~4行：初始化LED灯和按键；
5 l- H: l1 `' I% I
6~10行：一直循环查询每个按键当前状态，从而判断对应按键是否按下;

12.4 实验效果
本实验对应配套资料的“5_程序源码\5_GPIO—按键轮询\”。打开工程后，编译，下载。按下按键，用户LED灯亮/灭。


0 n5 C8 }) v/ H6 Q$ C, N2 {