01. 功能描述
STM32F4 的 IO口做输入使用的时候，是通过调用函数 GPIO_ReadInputDataBit()来读取 IO 口的状态的。
* Z! N& T0 M8 R. @5 L; _9 v2 P. J" {4 F
3 L' x2 c( J0 R* [% g2 u探索者 STM32F4 开发板上载有的 4 个按钮（KEY_UP、KEY0、KEY1 和 KEY2），来控制板上的 2 个 LED（DS0 和 DS1）和蜂鸣器，其中 KEY_UP 控制蜂鸣器，按一次叫，再按一次停；KEY0 控制 DS0，按一次亮，再按一次灭；KEY1 控制 DS1，
7 S9 X& y. p7 `9 z6 z* Z效果同 KEY2；KEY2 则同时控制 DS0 和 DS1，按一次，它们的状态就翻转一次。
2 S- A+ P9 Z. z' U7 X
, y9 j! o/ S& T# B02. 控制原理
6 [/ ~3 l$ {+ g# U, a探索者 STM32F4开发板上的按键 KEY0 连接在 PE4 上、KEY1 连接在 PE3 上、KEY2 连接在 PE2 上、KEY_UP连接在 PA0 上。
6 \) m( b. y' t. y2 G

- s4 w1 m  d0 a% T3 s
# K2 f  ?' b: v' ^这里需要注意的是：KEY0、KEY1 和 KEY2 是低电平有效的，而 KEY_UP 是高电平有效的，并且外部都没有上下拉电阻，所以，需要在STM32F4 内部设置上下拉。
' C; ~! U* n0 _7 l. I" s" r
6 ?" R1 z& D( U03. 程序示例一
1 @2 c5 ^3 M3 i  r2 Q* q+ C2 [) SKey0控制LED1 Key1控制LED2
/ ]/ t' T! v. ^( }+ M
- h9 D; ^: Z1 tkey.h文件内容
4 c5 Z, x. V% V$ Y7 @7 ?

1. #ifndef __KEY_H__
   4 M+ X5 q9 A/ ]9 W) c* g
2. #define __KEY_H__
   * {$ e$ P; o7 U
3. 
   + g1 E8 a) S7 ~) L, ^& e. u
4. #include "sys.h"
   8 q6 Q- t5 @( D3 V5 h; @
5. 
   # W9 j/ `" ~; P& Q& O" S, g0 n5 ?% x
6. 
   , B  w1 K. r6 ?; r! j, T
7. #define KEY0 GPIO_ReadInputDataBit(GPIOE, GPIO_Pin_4)
   
8. #define KEY1 GPIO_ReadInputDataBit(GPIOE, GPIO_Pin_3)
   7 H& W& v3 ^( G8 X: }3 t0 d# V) q
9. #define KEY2 GPIO_ReadInputDataBit(GPIOE, GPIO_Pin_2)
   4 n( h6 C8 T/ t5 S) |0 l5 d7 W" B5 `
10. #define WK_UP GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0)
    
11. 
    % _# m/ Q& O3 y1 E3 J4 H: R
12. #define KEY0_PRESS 1
    
13. #define KEY1_PRESS 2
    5 ?0 s3 g! O$ I' H
14. #define KEY2_PRESS 3
    : X. \2 S: O) f0 @8 @
15. #define WK_UP_PRESS 4
    ' u! A" Y; O) z, z- |% Y
16. 
    0 S- Z3 j& }7 G5 u
17. //GPIO初始化
    
18. void KEY_Init(void);
    7 }0 t5 c, M/ U9 d" Z* I+ A
19. 
    
20. //按键扫描
    ; f2 G$ U  `' ~5 e
21. u8 Key_Scan(void);
    
22. 
    ) U- w* p6 T/ [
23. 
    
24. #endif/*__KEY_H__*/

复制代码

key.c文件内容
# q& \5 M& {3 \# z& o7 S
+ X# @8 H' f% w: O% Q5 a' D

1. #include "key.h"
   
2. #include "delay.h"
   
3. 
   
4. //GPIO初始化
     M+ t( l  x; s, r) n9 E, w
5. void KEY_Init(void)
   
6. {
   
7.         GPIO_InitTypeDef GPIO_InitStruct;
   ( _& C. ?9 N% h* ~& r+ w2 ~$ y+ N
8.         
   
9.         //时钟使能
   ! M) U# O& K. a- C% Z4 D
10.         RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOE, ENABLE);
    
11.         
    - W- `$ S& C) d
12.         //GPIO初始化
    
13.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_2 | GPIO_Pin_3 | GPIO_Pin_4;
    3 F& F' H6 }) Y
14.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN;
    2 k& U" n, n; D+ _* k9 x4 k$ ~
15.         GPIO_InitStruct.GPIO_Speed = GPIO_Speed_100MHz;
    
16.         GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
    - M0 y8 A1 ]+ G0 Y( {/ {5 h2 |
17.         
    
18.         GPIO_Init(GPIOE, &GPIO_InitStruct);
    
19.         
    + Y# f, r( l. {8 q9 h3 n& ^
20.         //GPIO初始化
    
21.         GPIO_InitStruct.GPIO_Pin = GPIO_Pin_0;
    
22.         GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN;
    
23.         GPIO_InitStruct.GPIO_Speed = GPIO_Speed_100MHz;
    
24.         GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_DOWN;
    # h) p% _# \) P. A1 w
25.         GPIO_Init(GPIOA, &GPIO_InitStruct);
    0 S0 A) Z) C+ v2 C; p* d
26.         
    8 k% g) T3 K, @8 t* m
27. }
    
28. 
    + F& ]0 [" m( D  x$ L$ w; G. N. |# H
29. //按键扫描
    
30. u8 Key_Scan(void)
    
31. {
    
32.         //表示按键处于松开状态
    # Z: u: [* B; g1 \0 H2 I
33.         static u8 key_up = 1;
    2 |' |$ ]; N; Z3 K- \  X* C* }' K
34.         
      \( f- ~$ s. ]& O5 @, i
35.         if (key_up && (0 == KEY0 || 0 == KEY1 || 0 == KEY2 || 1 == WK_UP))
    
36.         {
    $ K4 _; ^% K) D7 Z
37.                 //防抖
    , ?: M* ?9 Z2 J$ f3 \! j
38.                 delay_ms(10);
    
39.                
    * A/ T% H/ F) x3 A
40.                 //表示按键已经按下
    2 Y* F& z: z+ @6 M) p) t1 U
41.                 key_up = 0;
    6 v3 u3 D2 F6 d5 z1 I
42.                
    $ o2 f2 N# x% X1 I
43.                 if (0 == KEY0)
    
44.                 {
    8 h* K7 q* S8 q# M# C
45.                         return KEY0_PRESS;
    
46.                 }
    1 e7 M5 T7 ]: k7 U  }" Z
47.                 else if (0 == KEY1)
    2 [* z3 {% J+ }2 b  |) n
48.                 {
    % E# K( z' l- x& Q* k
49.                         return KEY1_PRESS;
    
50.                 }
    ! V; t: k3 v7 d) T
51.                 else if (0 == KEY2)
    ' A% j% X; J3 k! \: n* M: Q8 N2 T
52.                 {
    
53.                         return KEY2_PRESS;
    5 t2 `. ~& H4 w1 v
54.                 }
    
55.                 else if (1 == WK_UP)
    
56.                 {
    ( B, G! H/ Q* o4 y
57.                         return WK_UP_PRESS;
    
58.                 }
    : I, q9 Q( k5 c6 g8 l, [, E( [9 x
59.         }
    0 w) S/ K' U0 N7 B& ^: D3 F6 E
60.         else if ((1 == KEY0) && (1 == KEY1) && (1 == KEY2) && (0 == WK_UP))
    
61.         {
    
62.                 //表示按键已经松开
    $ S# F9 D5 A; ]- a
63.                 key_up = 1;
    , z" b+ \5 |8 E3 n) q6 m
64.         }
    2 D% l8 I2 u' y( W
65. 
    
66.         
    ! G7 v4 K9 P/ }0 @: n
67.         return 0;
    / y6 D0 B7 a6 N. ^3 j1 ^' C8 [7 ^
68. }
    

复制代码

* t" ]/ C; p+ A! @, y2 ?main.c文件
/ r: Y! y/ q$ w

1. #include "stm32f4xx.h"
   
2. 
   4 B) D* Y3 K/ \8 ]! M5 o1 z( Z
3. #include "delay.h"
   6 E: O4 o6 H  @' Q0 [
4. #include "led.h"
   ; n0 o2 {+ K: u/ Q+ T
5. #include "beep.h"
   
6. #include "key.h"
   + ^  I$ E& S! v8 h% \
7. 
   
8. //Key0 控制LED1 Key1控制LED2
   
9. int main(void)
   
10. {
    + P8 x+ w! V6 P1 n4 W, S' k9 c
11.         u8 key = 0;
    
12.         
    
13.         //初始化
    # ~0 w! m7 [3 |9 D, k9 |4 L
14.         delay_init(168);
    + ]) ^) ~0 \. ~- ?7 b. P6 L& r' b; I
15.         LED_Init();
    . h# D/ n/ G% V. A" t, k1 l
16.         BEEP_Init();
    
17.         KEY_Init();
    7 i! x! [. x! ?! |, H& Y
18.         
    % h7 U& }. E$ O! C* E
19.         LED1 = 0;
    
20.         LED2 = 0;
    + M. d8 k4 W; ?: F
21.         BEEP = 0;
    
22.         
    ) I9 ?' O) S  i7 Q+ r" S$ j# D3 _
23.         while(1)
    0 m* ]' X2 G+ V5 r2 `1 |' b. ^
24.         {
    
25.                 key = Key_Scan();
    
26.                
    9 g- Z+ b$ `  U" _8 s" Q: ^
27.                 if (0 != key)
    
28.                 {
    . d9 w# G! z' c; C+ O1 R' I
29.                         switch(key)
    
30.                         {
    % v3 `0 Q' e% r' O' P7 c/ Q/ G, W
31.                                 case KEY0_PRESS:
    1 Z0 H1 i3 J5 n: C* B0 w7 u
32.                                         LED1 = !LED1;
    ; h4 j' d& ?. K9 o. p) d+ p& z
33.                                         break;
    / U2 c. G$ I9 t
34.                                 case KEY1_PRESS:
    
35.                                         LED2 = !LED2;
    1 j; g& H) V3 p
36.                                         break;
    - [$ U/ D* J: D. m, ]6 c
37.                         }
    
38.                
    7 \* l( K+ J! n9 ?! a
39.                 }
    0 x+ \5 g# i- b& ?5 ^5 T# g$ {
40.                 else
    
41.                 {
    ( R% Q2 }% l1 n# _1 }0 X; h
42.                         delay_ms(10);
    
43.                 }
    
44.         }
    7 A# D4 N4 W# R+ }/ Y1 o
45.         
    $ I% Y6 F) W# V- {; p+ \
46. }

复制代码

) u3 ]" ?+ H3 s0 k& C( ?04. 程序示例二
WK_UP控制蜂鸣器

main.c
8 l# J: N, e) d4 s

1. #include "stm32f4xx.h"
   2 L4 d) Q- m% d2 v- {2 K' j
2. 
   
3. #include "delay.h"
   
4. #include "led.h"
   1 ]1 a4 t" }3 z. u# ^9 J" q
5. #include "beep.h"
   1 v# Y8 j# [8 e( o* J9 g/ R
6. #include "key.h"
   3 {  H: r2 N7 }; j! ^( J: H
7. 
   
8. //Key0 控制LED1 Key1控制LED2
   7 U7 ~; a; t. ]$ e! H
9. int main(void)
   - `. q8 X; j; S
10. {
    
11.         u8 key = 0;
    
12.         
    ! r+ P" n" V$ {4 E5 w
13.         //初始化
    8 Z" q% s! {# @; y7 ]- E
14.         delay_init(168);
    ; w; e! j2 W. _$ ?5 M7 d+ a
15.         LED_Init();
    
16.         BEEP_Init();
    / s* A6 z6 p# W
17.         KEY_Init();
    % Z1 i; b# @/ Q6 [
18.         
    
19.         LED1 = 0;
    
20.         LED2 = 0;
    
21.         BEEP = 0;
    
22.         
    
23.         while(1)
    / n7 g& f! C' C% z4 {
24.         {
    0 E: z( b3 i7 ?; y
25.                 key = Key_Scan();
    + K3 H. C, b  s- a
26.                
    
27.                 if (0 != key)
    7 ], v8 l+ j9 Q% n' O
28.                 {
    8 o6 V+ \! e! n% [* A0 B- U
29.                         switch(key)
    
30.                         {
    ' w( s/ R  g6 |8 o% T: p
31.                                 case KEY0_PRESS:
    8 q% M* X$ p( e* M7 U
32.                                         LED1 = !LED1;
    3 K! [9 E4 d, L% F3 J
33.                                         break;
    & i4 `- m5 T+ m# @4 q* H: {; ?
34.                                 case KEY1_PRESS:
    % `4 q, X, g: O8 }) {! {1 s5 _
35.                                         LED2 = !LED2;
    , ?) C4 x, F0 P/ B
36.                                 case WK_UP_PRESS:
    
37.                                         BEEP = !BEEP;
    + `5 x- A% G+ G1 H! J, s% H& i
38.                                         break;
    * \/ f$ u  o* N. q
39.                         }
    
40.                
    ) u/ a9 y, s' S5 M
41.                 }
    
42.                 else
    
43.                 {
    
44.                         delay_ms(10);
    ) F/ [6 J7 ~) C$ O. y
45.                 }
    
46.         }
    
47.         
    
48. }

复制代码

05. 程序实例三
. Y- e6 N/ O( Y4 l综合实例
1 Y/ ]: V6 M: ]( @) Y
KEY_UP 控制蜂鸣器，按一次叫，再按一次停；KEY0 控制 DS0，按一次亮，再按一次灭；KEY1 控制 DS1，效果同 KEY2；KEY2 则同时控制 DS0 和 DS1，按一次，它们的状态就翻转一次。

3 |7 _* V! `" d. J  {2 qmain.c文件
; g5 Z) v$ R0 y: [# j/ E

1. #include "stm32f4xx.h"
     O& Y. I$ M2 b& n; G4 C
2. 
   2 s4 E9 Q2 ]4 C' Q5 y7 T) ^$ u
3. #include "delay.h"
   
4. #include "led.h"
   
5. #include "beep.h"
   
6. #include "key.h"
   - D/ N8 h+ n! z1 O+ {, a. i
7. 
   
8. //Key0 控制LED1 Key1控制LED2
   ! F* \$ B! U( p3 x2 M
9. int main(void)
   # w! O8 a) T0 [7 [
10. {
    
11.         u8 key = 0;
    
12.         
    
13.         //初始化
    + A% v8 m+ h* ^- y
14.         delay_init(168);
    
15.         LED_Init();
    5 R5 s8 B' R  u0 q
16.         BEEP_Init();
    
17.         KEY_Init();
    2 h0 \7 X! e0 N
18.         
    7 w2 P( b/ v( ^
19.         LED1 = 0;
    
20.         LED2 = 0;
    ' Y7 T, s8 ?' M1 F: s
21.         BEEP = 0;
    2 _# A. ~+ r5 M0 U5 k
22.         
    
23.         while(1)
    & \" }  `* f  }/ |5 E) a5 k* E4 y% l
24.         {
    ! I: X; i) m5 u3 j' {9 ^; B
25.                 key = Key_Scan();
    2 a) W2 U+ u1 E) ^' e! v
26.                
    
27.                 if (0 != key)
    % z  k& M/ [: I% ^4 ^7 k
28.                 {
    ( {/ T) G1 g! |( N: Q
29.                         switch(key)
    % E- }5 ^5 Q" h: r3 a
30.                         {
    
31.                                 case KEY0_PRESS:
    3 a( e8 l3 v$ h1 V% s
32.                                         LED1 = !LED1;
    , P2 F" u' f, ]/ t1 w2 L4 `- C
33.                                         break;
    
34.                                 case KEY1_PRESS:
    
35.                                         LED2 = !LED2;
    
36.                                         break;
    
37.                                 case KEY2_PRESS:
    
38.                                         LED1 = !LED1;
    ! K4 Z, ]+ c7 b0 ?% [3 ?  e  G
39.                                         LED2 = !LED2;
    8 \. {+ E# s( H
40.                                         break;        
    + Z8 f9 {: W+ o% E0 R3 P8 u
41.                                 case WK_UP_PRESS:
    
42.                                         BEEP = !BEEP;
    : k1 X& B5 F+ M) G. G6 c" F
43.                                         break;
    
44.                         }
    # ~% L4 [  r; o) ]1 I7 G
45.                
    
46.                 }
    7 o; H1 k: {; g6 r6 M& ]: V9 V
47.                 else
    / g5 {* v- t2 ?  X
48.                 {
    
49.                         delay_ms(10);
    
50.                 }
    
51.         }
    ' m, U/ n2 _/ U6 u
52.         
    ! |( i2 S+ h0 |2 K# ^) {0 ?  a" I
53. }

复制代码

2 o' a2 K, n, x