本章所要实现的功能是：通过开发板上的 4 个按键控制 LED。

按键介绍

    按键是一种电子开关， 使用时轻轻按开关按钮就可使开关接通， 当松开手时,开关断开。我使用的按键及内部简易图通常如下图所示。

2 n. B: p" ?4 H$ [

    按键管脚两端距离长的表示默认是导通状态，距离短的默认是断开状态，如果按键按下，初始导通状态变为断开，初始断开状态变为导通。通常的按键所用开关为机械弹性开关,当机械触点断开 、闭合时，电压信号如下图所示。

: C0 |7 A4 L6 c8 r

    由于机械点的弹性作用，按键开关在闭合时不会马上稳定的接通，在断开时也不会一下子断开，因而在闭合和断开的瞬间均伴随着一连串的抖动。抖动时间的长短由按键的机械特性决定的，一般为 5ms 到 10ms。按键稳定闭合时间的长短则由操作人员的按键动作决定的，一般为零点几秒至数秒。按键抖动会引起按键被误读多次。为了确保 CPU 对按键的一次闭合仅作一次处理，必须进行消抖。

    按键消抖有两种方式，一种是硬件消抖，另一种是软件消抖。为了使电路更加简单，通常采用软件消抖。我们开发板也是采用软件消抖，一般来说一个简单的按键消抖就是先读取按键的状态，如果得到按键按下之后，延时 10ms，再次读取按键的状态，如果按键还是按下状态，那么说明按键已经按下。其中延时10ms 就是软件消抖处理，至于硬件消抖，大家可以百度了解下，网上都有非常详细的介绍。

硬件设计

    我们STM32F1开发板上有4 个控制按键，其硬件电路如图所示。

: [+ j/ r  |* i( T0 f/ ]

: o( s( F6 O3 ]3 v* {

; U! m# ?1 b* o7 ^7 q0 _) K/ }# c

    从原理图我们可以知道，按键 K_UP 连接在 STM32F1 芯片的 PA0 引脚上，按键 K_LEFT、K_DOWN、K_RIGHT 分别连接在 STM32F1 芯片的 PE2、PE3、PE4 引脚上。

    需要注意的是：K_UP 按键另一端是接在 3.3V 上，按下时输入到芯片管脚即为高电平；K_LEFT、K_DOWN、K_RIGHT 按键另一端是全部接在 GND 上，这个和我们学习 51 单片机是一样的，采用独立式按键接法，按下时输入到芯片管脚即为低电平。为什么在 K_UP 上接一个 3.3V，主要是为后面章节实验使用，到时候我们再具体介绍。

软件设计

    整个程序实现的流程步骤如下：

（1）初始化按键使用的端口及时钟

（2）按键检测处理

（3）按键控制处理

按键初始化函数
( @" C6 X; K8 ]: w

    我们打开工程中 key.c 文件，按键初始化代码如下：

1. /****************************************************************
   
2. * 函 数 名 : KEY_Init
   
3. * 函数功能 : 按键初始化
   
4. * 输 入 : 无
   
5. * 输 出 : 无
   
6. ****************************************************************/
   / G; f% p/ \5 E- A& H. K( T2 t# {; H
7. void KEY_Init(void)
   
8. {
   
9.   GPIO_InitTypeDef GPIO_InitStructure; //定义结构体变量
   
10.   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOE,ENABLE);
    1 }: ?' ^. b  k# r. Q. R$ a
11.   GPIO_InitStructure.GPIO_Pin=KEY_UP_Pin; //选择你要设置的IO 口
      ?( p4 }& q2 B1 Z- V% p
12.   GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPD;//下拉输入
    / g2 `% n( N! c, X: [3 p/ O
13.   GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz; //设置传输速率
    
14.   GPIO_Init(KEY_UP_Port,&GPIO_InitStructure); /* 初始化GPIO */
    
15.   GPIO_InitStructure.GPIO_Pin=KEY_DOWN_Pin|KEY_LEFT_Pin|KEY_RIGHT_Pin;
    6 c% U, u# v  R
16.   GPIO_InitStructure.GPIO_Mode=GPIO_Mode_IPU; //上拉输入
    
17.   GPIO_InitStructure.GPIO_Speed=GPIO_Speed_50MHz;
    $ `7 p% `6 q  W. [' t+ @$ R) _* N
18.   GPIO_Init(KEY_Port,&GPIO_InitStructure);
    - n& A& N" @5 {5 m! y$ v
19. }

复制代码

! i& e$ j- D7 ^) R

    KEY_Init()函数用来初始化按键的端口及时钟。要知道按键是否按下，就需

要读取按键所对应的 IO 口电平状态，因此我们需要把 GPIO 配置为输入模式（不清楚输入模式对应的选项值，可以参考“使用库函数点亮 LED”内容，里面介绍了怎么快速查找代码），因为 K_UP 按键一端是接 3.3V 的，当按下后 PA0管脚即为高电平，所以需要将 PA0 管脚配置为下拉输入模式 GPIO_Mode_IPD，这样 PA0 管脚的默认电平就为低电平，如果读取到 PA0 管脚的电平为高电平时，就说明 K_UP 按键按下。其他几个按键是共地，所以需要配置为上拉输入模式GPIO_Mode_IPU，分析方法和 K_UP 类似。

    在函数内我们看到有几个参数不是库函数内的，比如KEY_LEFT_Pin、KEY_Port，这种情况一般是我们自己定义的宏，通常放在对应的头文件内，我们打开 key.h，可以看到如下代码：

1. #ifndef _key_H
   
2. #define _key_H
   
3. #include "system.h"
   ; ?' F: S% c8 P, _
4. #define KEY_LEFT_Pin GPIO_Pin_2 //定义 K_LEFT 管脚
   2 I. G" T9 C. L3 M
5. #define KEY_DOWN_Pin GPIO_Pin_3 //定义 K_DOWN 管脚
   
6. #define KEY_RIGHT_Pin GPIO_Pin_4 //定义 K_RIGHT 管脚
   
7. #define KEY_UP_Pin GPIO_Pin_0 //定义 KEY_UP 管脚
   
8. #define KEY_Port (GPIOE) //定义端口
   
9. #define KEY_UP_Port (GPIOA) //定义端口
   7 `+ a) E1 T7 M0 t, t$ G
10. //使用位操作定义
    
11. #define K_UP PAin(0)
    
12. #define K_DOWN PEin(3)
    
13. #define K_LEFT PEin(4)
    
14. #define K_RIGHT PEin(2)
    # X- S* C! R1 w, W
15. //使用读取管脚状态库函数定义
    . e5 P& K1 v4 A. X
16. //#define K_UP GPIO_ReadInputDataBit(KEY_UP_Port,KEY_UP_Pin)
    
17. //#define K_DOWN GPIO_ReadInputDataBit(KEY_Port,KEY_DOWN_Pin)
    1 m9 H+ s2 w* y. n1 [5 }4 M
18. //#define K_LEFT GPIO_ReadInputDataBit(KEY_Port,KEY_LEFT_Pin)
    2 J3 k  a, g4 A. B
19. //#define K_RIGHT GPIO_ReadInputDataBit(KEY_Port,KEY_RIGHT_Pin)
    
20. //定义各个按键值
    + ]5 b& D; V5 f/ N' a
21. #define KEY_UP 1
    
22. #define KEY_DOWN 2
    8 M2 M' {: f1 T6 u+ S* U8 d
23. #define KEY_LEFT 3
    
24. #define KEY_RIGHT 4
    * W2 R4 v* u" n7 a
25. void KEY_Init(void);
    ; Z1 g; g' E8 i/ v! {
26. u8 KEY_Scan(u8 mode);
    
27. #endif

复制代码

    key.h 文件内定义了按键的端口、管脚、读取管脚的电平状态、函数声明等信息。里面使用了两种方式定义读取管脚电平宏，一种是通过位操作，另一种是通过读取管脚电平的库函数。由于位操作比较方便，因此我们就使用位操作的方式，库函数定义的宏全部注释掉。

按键检测函数

    要知道哪个按键被按下，就需要编写按键检测函数，具体代码如下：

1. /***************************************************************
   - [% x$ O1 B. [! Q
2. * 函 数 名 : KEY_Scan
   . N% [# d. z" Y4 J) G
3. * 函数功能 : 按键扫描检测
   
4. * 输 入 : mode=0:单次按下按键
   
5. mode=1：连续按下按键
   
6. * 输 出 : 0：未有按键按下
   
7. KEY_UP：K_UP 键按下
   
8. KEY_DOWN：K_DOWN 键按下
   
9. KEY_LEFT：K_LEFT 键按下
   
10. KEY_RIGHT：K_RIGHT 键按下
    
11. ****************************************************************/
    
12. u8 KEY_Scan(u8 mode)
    + a! l; C0 j; {' I5 K- o. D1 [
13. {
    5 C5 U/ t# ^# y/ ^9 s: q2 e
14.   static u8 key=1;
    & t! Z7 }7 _; ~
15.   if(key==1&&(K_UP==1||K_DOWN==0||K_LEFT==0||K_RIGHT==0)) //任意一个按键按下
    
16.   {
    ; }8 E: W$ u  k# }
17.     delay_ms(10); //消抖
    
18.     key=0;
    : J7 }1 U& x+ ~
19.     if(K_UP==1)
    
20.     {
    # g! P: A) P  ~" }, P
21.       return KEY_UP;
    
22.     }
    
23.     else if(K_DOWN==0)
    
24.     {
    
25.       return KEY_DOWN;
    0 Y  e* J7 `0 h# P1 O$ ]: a7 x
26.     }
    ) L* [! c3 t, g! ^# d
27.     else if(K_LEFT==0)
    
28.     {
    , ]1 O8 ^  p0 O" H4 C& _9 ^7 D& v
29.       return KEY_LEFT;
    ) j, }+ H: |: j9 V
30.     }
    
31.     else
    : X' `0 k$ D* u9 Q
32.     {
    * J3 B" @2 y9 H- O9 v$ i
33.       return KEY_RIGHT;
    
34.     }
    & {9 b; h4 B& }; t! n' c) V; Y/ |* m, R
35.   }
    # p/ o- _- B  T- M9 L& Q
36.   else if(K_UP==0&&K_DOWN==1&&K_LEFT==1&&K_RIGHT==1) //无按键按下
    
37.   {
    
38.     key=1;
    9 w1 ?7 w& V' `  E/ r
39.   }
    
40.   if(mode==1) //连续按键按下
    
41.   {
    # i3 ?1 E; U0 F
42.     key=1;
    
43.   }
    
44.   return 0;
    8 ^: m+ t; C" P6 Y' y: c
45. }

复制代码

; {" L0 ~3 d, ]+ J) @8 n

    KEY_Scan 函数带一个形参 mode，该参数用来设定是否连续扫描按键，如果mode 为 0，只能操作一次按键，只有当按键松开后才能触发下次的扫描，这样做的好处是可以防止按下一次出现多次触发的情况。如果 mode 为 1，函数是支持连续扫描的，即使按键未松开，在函数内部有 if(mode==1)这条判断语句，因此key 始终是等于 1 的，所以可以连续扫描按键，当按下某个按键，会一直返回这个按键的键值，这样做的好处是可以很方便实现连按操作。函数内的 delay_ms（10）即为软件消抖处理，通常延时 10ms 即可。

    KEY_Scan 函数还带有一个返回值，如果未有按键按下，返回值即为 0，否则返回值即为对应按键的键值，如 KEY_UP、KEY_DOWN、KEY_LEFT、KEY_RIGHT，这都是头文件内定义好的宏，方便大家记忆和使用。函数内定义了一个 static 变量，所以该函数不是一个可重入函数。还有一点要注意的就是该函数按键的扫描是有优先级的，因为函数内用了 if...else if...else 格式，所以最先扫描处理的按键是 K_UP，其次是 K_DOWN，然后是 K_LEFT，最后是 K_RIGHT。如果需要将其优先级设置一样，那么可以全部用 if 语句。

主函数

    最后我们看下主函数，代码如下：

1. /***************************************************************
   
2. * 函 数 名 : main
   
3. * 函数功能 : 主函数
   / c8 W, I% e) Z( O- y
4. * 输 入 : 无
   
5. * 输 出 : 无
   
6. ****************************************************************/
   
7. int main()
   9 N, _( E2 @$ s* b( V5 @4 C4 C
8. {
   . T4 y1 X( g$ ~! I, h% A) L$ v0 E
9.   u8 key,i;
   
10.   SysTick_Init(72);
    
11.   LED_Init();
    ' {2 f; c' i+ M
12.   KEY_Init();
    
13.   while(1)
    
14.   {
    
15.     key=KEY_Scan(0); //扫描按键
    
16.     switch(key)
    
17.     {
    * o2 [2 V6 P* B& L
18.       case KEY_UP: led2=0;break; //按下 K_UP 按键 点亮D2 指示灯
    
19.       case KEY_DOWN: led2=1;break; //按下 K_DOWN 按键 熄灭D2 指示灯
    
20.       case KEY_LEFT: led3=1;break; //按下 K_LEFT 按键 点亮D3 指示灯
    % ?( |# N# a% y5 f9 l0 g
21.       case KEY_RIGHT: led3=0;break; //按下 K_RIGHT 按键 熄灭D3 指示灯
    
22.      }
    6 u6 t& [! ?6 c  k
23.     i++;
    
24.     if(i%20==0)
    
25.     {
    9 T& X4 [2 e# v; C1 e
26.       led1=!led1; //LED1 状态取反
    
27.     }
    
28.     delay_ms(10);
    
29.   }
    % m! n: [6 K/ F8 P) D" q
30. }

复制代码

    主函数实现的功能比较简单，首先将使用到的硬件初始化（这里说的初始化表示端口和时钟全部初始化，后面就不再强调），比如 LED、蜂鸣器和按键。然后在 while 循环内调用按键扫描函数，扫描函数传入的参数值为 0，即 mode=0，所以这里只对它单次按键操作，将扫描函数返回后的值保存在变量 key 内，通过switch 语句进行比较，从而控制 LED。

    程序后面的 if(i%20==0)判断语句， 表示当 i 能够整除 20 的时候就进入 LED状态翻转，后面有一个 delay_ms(10)延时;也就是间隔 200ms，led1 就会翻转一次状态。将工程程序编译后下载到开发板内，可以看到 D1 指示灯不断闪烁。当按下 K_UP 键，D2 指示灯点亮；当按下 K_DOWN 键，D2 指示灯熄灭；当按下 K_LEFT 键，D3 指示灯熄灭，当按下 K_RIGHT 键，D3 指示灯点亮。

  I) t& P3 u( V0 j4 `) Q4 f; B