12.1 关于按键
2 @) U+ u0 C( e$ r  H0 N, c前面控制LED灯是让GPIO输出高低电平，而获取按键则是读取GPIO电平，从而获知用户是否按下按键。

0 n  @! w* w% v3 D% @" b0 q按键监测一般有两种：按键扫描和按键中断。按键扫描是间隔很短时间反复查询GPIO状态，从而得知是否有按键动作，这种方式代码简单，但比较耗资源。按键中断而是通过按键产生中断信号，从而实现按键的检测，这种方式需要使用到中断机制，需要对MCU了解深入一点，效果是最好的。

5 n! j7 D3 Z- q4 w2 v! X本节先介绍按键扫描，理解按键的基本原理，下一章再介绍按键中断，同时了解STM32F103的中断使用方法。
" B4 o  g6 q& B9 c! Z' h1 [: [
按键一般占用一个GPIO口，通过监测该GPIO的电平变化得知按键操作，典型的电路如图 12.1.1 所示。当所需按键比较多时，则可以采用矩阵按键减少GPIO的占用。矩阵按键需要通过编程扫描等方式实现对多个按键的监控，这里以最简单的独立按键为基础进行介绍。
% d6 g) y: z( J% s& C; o9 d
7 T( B* @6 R% n, I7 G% x3 L

- U0 H3 c' e4 F7 i图 12.1.1 按键与MCU的连接方式示意图
可以看到，在没有按下按键时，电源3.3V通过电阻连接到MCU的PA0脚上，此时MCU读取PA0的电平就是3.3V的高电平。在按键按下时，电源3.3V经过电阻，再经过按键连接到了地，此时PA0连接到接地的一端，读到的电平就是0V的低电平。由此，MCU就可用过读取对应引脚的电平值，得知按键的变化。
4 J# X5 W4 ~3 W. z: Y+ F
3 i9 p2 n+ ^" a( C2 d1 J常用的按键都是机械触点式按键，机械式按键在按下或释放的过程中，由于机械弹性作用的影响，会伴随机械抖动，如图 12.1.2 所示。


9 L* }* c3 B7 V. B
  ~: L- W9 H  I. R5 J9 D1 w2 ^1 @
图 12.1.2 机械按键抖动示意图

0 W! X$ o' `" G1 Q
* z0 @/ p3 ^7 s; `1 I抖动的时长与机械开关特性相关，一般为5-10ms。在这抖动过程中，会产生多次高低电平，导致被识别为多次按键操作。为了避免机械触点按键检测误判，必须消抖处理。按键消抖可以硬件上处理，即在按键旁并联电容，吸收抖动的电平。也可以软件处理，即通过延时，避开抖动。

由此，首先获取对应引脚的电平得知按键状态，再硬件或软件消除抖动。
6 [1 S( V' G- Z, ^

12.2 硬件设计
0 a3 V' R4 f. Z8 c2 ^6 q开发板上有两个按键，一个是复位按键（K1，红色），另一个是用户按键（K2，白色），这里只有用户按键能够编程控制。

如图 12.2.1 为开发板用户按键部分的原理图，电容C15用于硬件去抖，可以看作不存在。按键松开时，3V3经过上拉电阻R20到网络标号KEY，网络标号KEY另一端连接MCU的PA0，此时读取PA0电平为高电平；按键按下时，3V3经过上拉电阻R20，再通过按键接地，此时读取PA0电平为低电平。

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

, F3 j+ m/ K6 x
' k* @9 f# w2 u
* N% i% [" A2 T: q8 `1 z4 f图 12.2.1 用户按键原理图

2 Y7 c9 j7 M4 T3 U9 I8 {/ H: k4 y4 Q+ o
: z- @( ?. V' ?$ K12.3 软件设计
1.3.1 软件设计思路
2 |0 [, B' V& ~  S实验目的：本实验通过轮询读方式取GPIO的输入电平判断按键是否按下，并操作LED。
. Y8 Q' c* Z8 A' s7 f; Q& o
1) 按键初始化：GPIO端口时钟使能、GPIO引脚设置为输入（PA0）；

/ U9 r# g9 O0 c, v2) 封装每个按键处理函数：读取按键GPIO状态，操作LED灯亮灭；

% W$ H' z7 k+ w4 \3) 主函数轮询按键状态：一直检测是否有按键被按下；
3 ?& q( v. S) y' j  h: t6 e
3 g1 S8 P5 a) S+ I0 u本实验配套代码位于“5_程序源码\5_GPIO—按键轮询\”。


& [/ c, ]' Y" u; T' Y4 A' B$ v, W1.3.2 软件设计讲解
1) GPIO宏定义与接口宏定义
7 a( ?. @: b: Z6 Q) [: s' U7 N0 b
* [- F8 H$ Z* c代码段 12.3.1 引脚宏定义（driver_key.h）
! @  i% K5 l' e& g! H# N5 ?

1. /*********************
   ; w+ m+ W/ c$ J
2. 
   ' d% i( R1 w9 r5 }
3. * 按键引脚状态定义
   
4. 
   / L# G) {0 A5 e+ W$ @8 `% U
5. **********************/
   0 m4 L) g2 d8 o; X7 W( T
6. 
   % ]1 g0 J2 F7 E0 [% y
7. #define PUSH_DOWN                       GPIO_PIN_RESET
   
8. 
   
9. #define SPRING_UP                       GPIO_PIN_SET
   & J# o2 U& c3 J; N& x
10. 
    # c9 r8 e6 E3 M2 c
11. 
    / G' i+ g% F9 }" |3 ~
12. 
    
13. /*********************
    
14. 
    
15. * 引脚宏定义
    
16. 
    & \7 p8 B: ]2 [6 P, u+ P8 {
17. **********************/
    0 i. n% x& t/ n4 ?" W
18. 
    
19. #define KEY_GPIO_PIN                 GPIO_PIN_0
    
20. 
    
21. #define KEY_GPIO_PORT                GPIOA
      T$ X4 H- K9 b( Q& K1 I: P, B- \
22. 
    5 B* `4 P- |; a; V
23. #define KEY_GPIO_CLK_EN()            __HAL_RCC_GPIOA_CLK_ENABLE()
    ' T  a* e! q7 j9 j, J7 \: d
24. 
    # ^# }3 @* P+ ?0 J1 E
25. 
    9 c6 U9 }( s6 Z: }& S
26. 
    
27. /*********************
    % C- Q/ `. ]' X0 f7 |& M
28. 
    
29. * 函数宏定义
    
30. 
    
31. **********************/
    ! w. C- N1 {. c. Y) P2 ]8 U- `3 {! M
32. 
    0 N5 L5 R6 V% z  l
33. /*
    / {2 ~5 `3 p" g* x7 Z6 y- G
34. 
    ! Q6 {' }+ i: m; M( ?
35. * 按键状态读取函数宏定义
    
36. 
    ) n" ^2 N) X8 ~- e1 W
37. */
    
38. 
    
39. #define KEY                  HAL_GPIO_ReadPin(KEY_GPIO_PORT, KEY_GPIO_PIN)

复制代码

) t' X% u3 a$ j8 k8 I8 a
根据硬件设计选定的对应按键的引脚，将其宏定义命名为KEY，且对他们的读取函数进行重命名。其中“HAL_GPIO_ReadPin()”原型“GPIO_PinState HAL_GPIO_ReadPin(GPIO_TypeDef *GPIOx, uint16_t GPIO_Pin)”，参数依次是：引脚组，引脚号，返回的是0（低电平）或1（高电平）。
8 R4 U8 r) Q% N9 c$ k& ]! C

2) GPIO初始化

$ W8 w0 l1 ^; ^$ Q代码段 12.3.2 按键初始化（driver_key.c）

# j* h  W9 m7 j( v0 L8 h) L

1. /*
   9 M' h% l1 I& u7 R4 m( U
2. 
   
3. *  函数名：void KeyInit(void)
   7 T+ [, N- U7 x/ l. Q# x; u  O
4. 
   , F3 C0 F% O! P+ z% c0 U5 ^
5. *  输入参数：无
   
6. 
   
7. *  输出参数：无
   ( G4 u# n% a$ t3 `9 |! {
8. 
   + w/ F* Q7 v' F' |4 ^5 G2 u/ {! v
9. *  返回值：无
   
10. 
    8 l) V; g$ z! ~: x0 E
11. *  函数作用：初始化按键的引脚，配置为输入
    
12. 
    
13. */
    & `, u3 L! K- F8 u" v
14. 
    : z) X3 `  }& d% c
15. void KeyInit(void)
    + R& y+ v. [( A/ p$ C
16. 
    
17. {
    
18. 
    
19.     // 定义GPIO的结构体变量
    0 G. C  [" |; ^3 A7 r! i* f& _1 n. P7 y
20. 
    
21.     GPIO_InitTypeDef GPIO_InitStruct = {0};
    6 i) T5 ]9 k  t6 K+ s2 g: E
22. 
    
23.     // 使能按键的GPIO对应的时钟
    % ]: K4 I/ ^+ p1 F
24. 
    9 G/ {5 L) y  x+ e
25.     KEY_GPIO_CLK_EN();
    
26. 
    
27. 
    
28. 
    0 p5 Y- Y+ m9 T" h
29.     GPIO_InitStruct.Mode = GPIO_MODE_INPUT;             // 设置为输入模式
    
30. 
    
31.     GPIO_InitStruct.Pull = GPIO_PULLUP;                 // 默认上拉
    - Z: _/ x7 Q5 Q. W2 s3 d8 q: Z, u
32. 
    
33.     GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;       // 引脚反转速度设置为快
    
34. 
    
35. 
    
36. 
    
37.     // 初始化按键引脚配置
    9 f, p* \; z4 C" J# K9 k' v
38. 
    
39.     GPIO_InitStruct.Pin = KEY_GPIO_PIN;              // 选择按键的引脚
    7 y. Q- e# ~# q  f7 D% C* m
40. 
    
41.     HAL_GPIO_Init(KEY_GPIO_PORT, &GPIO_InitStruct);
    + A6 U" K9 M& i  M8 i9 T1 C. m8 S
42. 
    
43. }

复制代码

' |8 Q( X: V  H7 @) {8 L* d5 U' R. v7 y使能时钟，将引脚初始化为上拉输入。

! [  q- |; E. J5 o9 N
- V7 T7 U/ o3 R' [7 G3) 按键读取函数

: `9 I1 D$ `1 m0 Y4 d; [1 x; M$ O为了展示效果，编写代码查询按键是否按下，按下后切换LED灯亮灭状态。

代码段 12.3.3 按键读取函数（driver_key.c）

& Q" R% W/ u0 W  r

1. /*
   
2. 
   
3. *  函数名：void KeyPolling(void)
   
4. 
   5 u9 v# a* f" F6 c* E5 j3 b
5. *  输入参数：无
   
6. 
   
7. *  输出参数：无
   
8. 
   
9. *  返回值：无
   . [$ n, x, r: q- ^8 _, y
10. 
    
11. *  函数作用：使用轮询方式查询按键是否按下，通过按下控制LED灯亮灭
    1 U8 d$ Y# |  S0 X. ?
12. 
    - g3 v& L/ C6 G, D6 h. y* U6 O! r
13. */
    
14. 
    
15. static bool key_flag = false;
    
16. 
    + Q" {" ?$ W& \* Y2 R
17. void KeyPolling(void)
    
18. 
    
19. {
    
20. 
    1 f, A: @! q% h, l. K7 T  r4 B! }% K
21.     if(KEY == PUSH_DOWN)          // 如果检测到按键被按下
    
22. 
    
23.     {
    
24. 
    
25.         HAL_Delay(8);             // 延时8ms防按键抖动
    
26. 
    
27.         if(KEY == PUSH_DOWN)      // 如果防抖动后按键依然是处于被按下的状态，就认为按键被按下过
    ! R" H/ ~' Q/ W) a
28. 
    5 i* {; @( w) O  N% [* p( p
29.         {
    
30. 
    
31.             key_flag = !key_flag; // 用一个标志位来判断按键被按下次数，按下一次灯亮，再按一次灯灭，如此反复
    
32. 
    
33. BLED(key_flag?OFF:ON);
    7 p; u* [% ?- H" f' w  j7 Q
34. 
    
35.         }
    
36. 
    
37.     }
    
38. 
    1 P$ \/ y/ @$ a7 p& C9 q
39. }

复制代码

8行：定义了一个全局变量标志位“key_flag”，作为按键被按下的标志；
9 U; W/ d" Z" _4 _0 k1 d
& c0 L( {# Y, c8 a11行：获取该按键状态;

13行：延时5-10ms，软件去抖；
8 }; J) k( U/ r. s8 r& U- U( y
14行：再次获取该按键状态，此时依旧按下，说明是正常按键操作，非抖动；
1 \1 y1 o# D/ \# O6 J0 k" i( x/ i
16行：将标志位置反，按键按一次置反一次（即0->1->0->1这样循环）；
( p: T+ S: ?5 d/ }
0 N: T) y' y: s; ?17行：根据标志位“key_flag”的值，让LED灯亮或灭；

. F# o3 \( S' G% X, ?此时每按下一次按键键，蓝色LED灯将亮灭交替。
1 I  ~/ m7 }" k( y
+ h7 G& Q4 x1 r  t( h$ [* p
1 Q9 j* L/ A: ^' G3 L4) 主函数测试

代码段 12.3.4 主函数控制逻辑（main.c）
" p. q/ r' ?; E; Q8 {
' I0 P' E3 E& q

1. // 初始化LED
   
2. 
   % Q2 Z7 f9 X+ |7 m0 }4 G
3. LedGpioInit();
   : X) ~! \' C1 J  o
4. 
   
5. // 初始化按键
   + T. b+ H  h5 y5 X3 S
6. 
   3 `, r$ h! |+ i/ e$ z
7. KeyInit();
   / ]( k" [+ X! [+ C: e
8. 
   
9. 
   
10. 
    7 J* \% X& L; h1 @" n  B( d
11. while(1)
    
12. 
    ' t$ j' G( Z0 k5 M
13. {
    
14. 
    + u6 l: \/ \  d% z
15.     // 轮询按键键
      f, i- P# `) n4 K- z' ]+ F" u
16. 
    
17.     KeyPolling();
    
18. 
    9 M& _+ _/ P8 j4 ~
19. }

复制代码

1~4行：初始化LED灯和按键；

9 w# n+ z0 j1 ~2 |  B6~10行：一直循环查询每个按键当前状态，从而判断对应按键是否按下;

12.4 实验效果
0 ^9 y$ l) M* v" H4 h本实验对应配套资料的“5_程序源码\5_GPIO—按键轮询\”。打开工程后，编译，下载。按下按键，用户LED灯亮/灭。
+ d; w' f! g% H7 J# [% k

8 k- C* @8 ]- W$ e7 \