一、按键检测原理
按键检测原理比较简单，按键按下和不按下，其连接引脚的电平是不一样的，按键检测正是通过检测按键引脚的电平变化来实现的。比如按键未按下时引脚电平为高电平，按键按下后为低电平。我们在检测按键时只需要检测按键引脚是否变为低电平来确定按键是否按下。
# N1 u; k# K8 a$ p6 J6 \7 Z
二、硬件连接
( a* Q1 |. {! n# R按键的硬件连接决定了我们在配置按键IO时IO的状态。以我们使用的普中核心板为例，上面有三个按键需要硬件电路的小伙伴可以看看本人上传的资源，下载查看原理图。
1 g6 X" T& `. H: E
0 \% o. N2 e% I9 f: [$ ~' M

2 H3 L" a+ M+ I4 U

普中核心板按键硬件电路图

其中K1一端接VCC，另一端接单片机。K2和K3一端接地，另一端接单片机。硬件电路不同，导致他们在进行按键检测时IO的配置不同。

" _/ e1 h2 ?" P针对K1这种按键电路，按键按下时，单片机的引脚接到VCC，因此在未按下的情况下该引脚的默认电平为低电平，也就是要把IO设置为输入下拉模式。同理，对于K2和K3这种连接方式，对应IO应该配置为输入上拉模式，使得按键未被按下时，引脚处于高电平状态。


6 h0 t4 l- F1 G- H! ]8 T% K3 m三、程序设计
2 L' [2 ^; _9 i& W9 l# g按键检测主要有以下步骤
9 i3 Y( q$ d$ \7 O1 B• 初始化GPIO
• 检测按下按键
3 i* [/ g! P0 L9 ?: S! f( F9 i• 消抖（防误触，一般通过延时实现）
5 A7 _1 |1 t" m• 松手检测
: X4 e4 ^+ _) \. J# K$ y• 执行按键功能
0 D  ]/ H" B# n$ E$ Z, m
3.1 初始化GPIO
根据原理图，谱中的STM32核心板提供了三个按键，我们使用K1和K2来实现点亮和关闭LED的操作。K1对应的IO为PA0，K2对应的IO为PE4。
+ A6 h8 ^' ~4 X) \& b
! i% O+ e2 [$ `7 y7 p6 E# l! x% h5 T

按键对应GPIO

根据上一节了解的初始化GPIO程序，初始化按键GPIO。

1. /*
   ; {/ c; M6 m5 ?7 _" ^/ s& p
2. *==============================================================================
   
3. *函数名称：Drv_KeyGpio_Init
   
4. *函数功能：初始化KEY的GPIO
   ; ?; p: O6 P9 U1 `6 q4 f# w' K
5. *输入参数：无
   
6. *返回值：无
   ! e3 ~( s- T3 C4 ~6 K$ @
7. *备  注：根据硬件电路确定GPIO模式
   ' y& V& Z- i" R& O
8. *==============================================================================
   
9. */
   
10. void Drv_KeyGpio_Init (void)
    
11. {
    ( c& z6 L. {% n8 n! j7 F
12.     GPIO_InitTypeDef GPIO_InitStructure;   // 定义结构体
    
13.     // 开启时钟
    ' [! j  Z# }% K! m! ~
14.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOE,ENABLE);
    # O$ h& H) @( J* b2 T, U
15. 
    " t' t5 v$ z3 Y# S0 @. U
16.     // 配置结构体 WK UP
    : C  ]( |% m; o  B% p; r: m4 }
17.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
    3 U! r! Q4 O7 v+ L& r  m
18.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    / q0 Z9 q: D* e
19.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;   // 输入下拉
    - [/ k8 ^( {3 A! f' ]) K! ]
20.     GPIO_Init(GPIOA, &GPIO_InitStructure);
    
21.    
    
22.     // 配置结构体 KEY0，KEY1
    + z/ o8 Y2 X' ~1 Q4 d
23.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3 | GPIO_Pin_4;
    & G' N! \4 T3 W6 m0 \
24.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
25.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;   // 输入上拉
    
26.     GPIO_Init(GPIOE, &GPIO_InitStructure);
    
27. }

复制代码

  K% V* \! {" {
3.2 按键扫描函数
按键扫描函数的功能是检测是否有按键按下，按下的按键是哪一个。检测方法上面已经叙述，通过检测按键引脚的电平。以WK UP按键为例。当WK UP被按下时，其对应的引脚PA0会变为高电平。此时检测PA0的输入电平，如果确实是低电平，则说明WK UP可能被按下。说可能是因为PA0为低电平不一定是WK UP按下造成，也可能是抖动，所以这里就需要消抖操作。这里的消抖操作比较简单粗暴，直接延时10ms看该引脚是否依旧是低电平。如果延时10ms后依旧是高电平，则认为确实是由按键按下导致的电平变化，而不是机械抖动。
  x2 y& O* E+ k' e. F
确定检测到按键按下后，需要等待按键被松开在执行按键功能。为什么需要进行松手检测？举个例子，比如设置阈值时，按键按下阈值加1，如果不进行松手检测，那么按下一次按键会加很多次，因为在不停地执行按键功能。这里按键的松手检测也比较简单粗暴，用一个while死循环等待松手。比如WK UP被按下后，其引脚会一直保持高电平，也就是PAin(0)一直等于1，此时用一个while (PAin(1));来等待松手，做松手检测。

4 A# \! l3 Z4 {) p
四、按键控制LED
9 D0 V& Y! u8 N+ O7 B+ [这里做一个小练习，用普中核心板上的按键KEY0和KEY1来控制LED1的亮灭。步骤如下
6 I0 E- J. t4 `, u
• 初始化LED和KEY的GPIO
• 编写LED控制函数
0 z6 q% N9 g- W1 [7 a  n• 编写按键检测函数（检测按键）
6 w- _, K9 F) L" [4 _6 Z• 编写按键服务函数（实现按键功能）
: P" s2 l& R' c. R9 f- E2 ^5 x
3 {( k* D; i7 w5 a. X0 M4.1 初始化LED和KEY的GPIO

1. /*
   - y% \; h: T1 ]# w- i$ ?% E
2. *==============================================================================
   ' K( n0 q! V' }
3. *函数名称：Drv_LedGpio_Init
   
4. *函数功能：初始化LED的GPIO
   " }$ e6 J; k/ i* N2 b! Y' \* [
5. *输入参数：无
   
6. *返回值：无
   - X, E$ s; ^" a. b. }! ?; ]
7. *备  注：无
   
8. *==============================================================================
   " J1 R9 u8 X+ ~% I$ [& J7 D
9. */
   ( @2 l4 e# q7 }
10. void Drv_LedGpio_Init (void)
    4 {" [" l5 J+ B0 l- d' c
11. {
    * S" M* p) W- t6 n, X1 U/ }
12.     GPIO_InitTypeDef GPIO_InitStructure;   // 定义结构体
    # V# ]3 I; a" U9 A( b) \# b3 b
13.     // 开启时钟
    . S9 b5 i- N/ P+ W
14.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOE,ENABLE);
    7 U: a9 l2 E6 |  y8 |
15. 
    
16.     // 配置结构体 LED0
    ) ^9 \, ~. l0 \4 w
17.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
    
18.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
19.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;   // 推挽式输出
    ; r: G* g' J0 M& `7 |/ c# _
20.     GPIO_Init(GPIOB, &GPIO_InitStructure);
    6 L* Z; s4 Y# t6 @* Z8 b
21.     GPIO_SetBits(GPIOB,GPIO_Pin_5);   // 熄灭LED
    4 {; ]! k1 s, k" l
22.    
    
23.     // 配置结构体 LED1
    
24.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
    
25.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    . A" R! S- \% h7 L/ m; n7 U
26.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;   // 推挽式输出
    1 U2 H3 ^4 l/ B7 f* }) Q2 e
27.     GPIO_Init(GPIOE, &GPIO_InitStructure);
    
28.     GPIO_SetBits(GPIOE,GPIO_Pin_5);   // 熄灭LED
    # l) ~# I% |1 f" ^& k
29. }
    4 V' G- f! x) `2 q0 \( D+ @1 T5 S
30. /*
    
31. *==============================================================================
    8 j7 G3 E) g% o# V
32. *函数名称：Drv_KeyGpio_Init
    % b/ m- c0 X8 r* y# O& l0 R6 h+ j
33. *函数功能：初始化KEY的GPIO
    
34. *输入参数：无
    
35. *返回值：无
    # ^& j: ~' R8 K, X
36. *备  注：根据硬件电路确定GPIO模式
    
37. *==============================================================================
    0 B- t2 L' Z, H6 M& m6 r( W
38. */
    6 y; b; `6 r8 K/ y
39. void Drv_KeyGpio_Init (void)
    
40. {
    * c/ s, s1 H& x5 i6 [
41.     GPIO_InitTypeDef GPIO_InitStructure;   // 定义结构体
    
42.     // 开启时钟
    
43.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOE,ENABLE);
    + O" l# Z% u1 C, ]' B+ S9 Z5 C
44. 
    
45.     // 配置结构体 WK UP
    
46.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
      s: ~. k; K1 M, S7 h7 d0 M
47.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
48.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;   // 输入下拉
    
49.     GPIO_Init(GPIOA, &GPIO_InitStructure);
    1 m) O# ?/ H" u
50.    
    
51.     // 配置结构体 KEY0，KEY1
    ( P; v2 [/ g+ q: v& R1 n6 G
52.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3 | GPIO_Pin_4;
    & k! s) r5 `( Z" F. k
53.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    / J' h0 f3 c* O! c& ?- R1 Z; ?
54.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;   // 输入上拉
    
55.     GPIO_Init(GPIOE, &GPIO_InitStructure);
    5 O; s- ?0 }8 V4 ~0 }. x+ n! @
56. }

复制代码

4.2 编写按键扫描函数
6 j9 ]; e' P+ [6 z

1. ```c
   
2. /*
   
3. *==============================================================================
   1 m$ P+ v$ _3 `4 I
4. *函数名称：Med_KeyScan
   
5. *函数功能：检测按下按键
   ; G" ?# w0 K7 g% A7 Z0 K4 A
6. *输入参数：无
   
7. *返回值：按键键值 0：按键WK UP，1：KEY0，2：KEY1
   
8. *备  注：无
   ! v. ?) C8 i: C( P. u7 b
9. *==============================================================================
   
10. */
    8 K4 Q2 s$ n1 f
11. u8 Med_KeyScan (void)
      J) l1 ~/ }( ~4 U1 P  j
12. {
    
13.     // 按键WK UP
    
14.     if (KEY_UP == 1)
    3 I& U) g4 ?# I
15.     {
    
16.         delay_ms (10);   // 延时10ms消抖
    5 ^0 Z. i2 u4 Z. b& F7 H
17.         if (KEY_UP == 1)
    
18.         {
    
19.             while (KEY_UP);   // 松手检测
    . y1 }$ {& o8 W3 o( v. z% Y
20.             return 1;
    
21.         }
    ( ~. p6 q$ H3 G0 J& j: `2 p
22.     }
    * ^, V- G; C( D9 @9 H' c6 O5 y
23.    
    
24.     // 按键KEY0
    . o; [0 O4 F) F' }$ w: [
25.     else if (KEY0 == 0)
    ( f. y" Q; b; K# E) A1 h
26.     {
    
27.         delay_ms (10);   // 延时10ms消抖
    
28.         if (KEY0 == 0)
    / v( I5 [& s& d( ?4 N) D, g$ P5 }
29.         {
    
30.             while (!KEY0);   // 松手检测
    ; u, e' l4 }; B  g/ ]% R% f* s* I
31.             return 2;
    3 x+ n1 Q9 A6 j3 T# Q) a' W1 _6 g
32.         }
    ! W3 |; h$ [4 n  L0 s3 y
33.     }
    
34.    
    4 [  b  z; k2 n/ L. B/ E- {: w
35.     // 按键KEY1
    ) [1 H7 Y) U9 m9 {& L
36.     else if (KEY1 == 0)
    / K+ I1 B1 O6 J1 Y6 y
37.     {
    
38.         delay_ms (10);   // 延时10ms消抖
      V7 l; X+ p* Y6 [6 x1 W
39.         if (KEY1 == 0)
    
40.         {
    ! [4 t' r, P3 x" O7 L
41.             while (!KEY1);   // 松手检测
    " Y9 O7 ]: p" G8 p" p! F
42.             return 3;
      }8 |9 ^( d( `& k5 g
43.         }
    
44.     }
    2 @, d* t% w& k: k" k3 Z* v% W7 O
45.    
    ' m( |4 X8 J/ Q7 y) S& N& ~+ i
46.     // 没有按键按下
    
47.     return 0xff;   // 用0xff表示没有按键按下
    + Q" c) u+ i7 W( V' G6 @. y+ ~& m
48. }

复制代码

4.2 编写LED控制函数
8 H+ H. \; q- P, {9 Q; A- }+ n1 a

1. /*
   
2. *==============================================================================
   
3. *函数名称：Med_Led_StateCtrl
   ' y* I; D$ B# C+ j( B" Q
4. *函数功能：控制LED亮灭
   
5. *输入参数：
   
6.            LEDx：可选择的LED（0~1）
   % k- l, Y, J4 R# k$ e
7.                      State：LED亮灭状态（LED_ON，LED_OFF）
   9 E: {0 x3 w1 ]- ]1 t/ L5 I: g+ j
8. *返回值：无
   2 X& f; B  u& Z
9. *备  注：无
   . c1 Y2 I$ `1 `9 h- Q3 V# I# t# k
10. *==============================================================================
    % n$ I4 c, [, t1 Y: h
11. */
    & G: k( }# n$ `3 b
12. void Med_Led_StateCtrl (LED_TypeDef LEDx,u8 State)
    1 l2 O$ K1 s: Z/ m
13. {
    - T- _( S& H1 f: `
14.     switch (LEDx)
    ; D( n# t7 k$ @
15.     {
    
16.         case 0:
    " W+ q  H! ]9 [  O9 t7 o' K
17.             PBout(5) = State;
    + n" v/ A* U/ E
18.         break;
    
19.         
    
20.         case 1:
    8 E* X$ H) l$ X$ F/ ~" C) h
21.             PEout(5) = State;
    & j0 M- {9 t: _9 `) ~. H
22.         break;
    
23.         
    
24.         default:
    % {9 o) z& ]3 f0 N# ~% O
25.             break;
    ( L, a0 h9 r. T% F( f% Y5 {
26.     }
    " d- I* U. y' s9 Q! d
27. }

复制代码

% t# r2 X$ {) Y% {
5 M  |3 R$ `  |下面是.h文件中的一些结构体和宏定义。
8 e( I# r$ ?: c- I5 f0 c6 I

1. // 可选择的LED
   * A5 j' H0 n! \- B" ^  s3 t
2. typedef enum
   
3. {
   / F  X, W8 u* f" N
4.     LED1 = 0,
   " a" y& O, h  Z9 v
5.     LED2
   
6. }LED_TypeDef;
   3 V: `$ ?4 Y) p2 o' j# v
7. 
   - D! u$ @4 t4 U  B8 i2 N
8. // 亮灭电平需要根据硬件电路确定
   
9. #define LED_ON   0
   ' d/ Z& U9 X" l+ b& Z- D
10. #define LED_OFF  1

复制代码

4.3 编写按键服务函数
$ B6 ^+ n0 ^7 [! a5 a这里没有再单独编写按键服务函数，直接在main函数中编写。KETY0按下点亮LED1，KEY1按下，熄灭LED1。

1. u8 gKeyValue = 0;   // 记录按键键值变量
   
2. 
   & ~# ]: m; ?2 |
3. int main(void)
   
4. {
   , s$ t- V# y9 S1 J+ p: Q
5.     Med_Mcu_Iint();   // 系统初始化
   
6.    
   2 u* ^7 k! Q) T0 S7 s5 b
7.     while(1)
   % G3 ^  r) k1 v1 b6 S0 ?, N  A+ K
8.   {
   , K- i# t6 N3 y  c4 R; O  q2 Q
9.         gKeyValue = Med_KeyScan();   // 获取按键键值
   
10.         
    
11.         // 按键KEY0按下
    
12.         if (gKeyValue == 2)
      A# _# H4 u2 j  ~* X: f+ H5 w& \" v
13.         {
    ' X8 T' N0 L+ [8 N
14.             Med_Led_StateCtrl(LED1,LED_ON);   // 点亮LED1
    8 B4 Y  |& Y' _. B$ O
15.         }
    ( j' D, R" M% ]$ E8 I) M; W9 s
16.         
    0 c0 H/ \/ g5 `3 p/ b
17.         // 按键KEY1按下
    3 V. F+ B7 G6 m& Y0 ^3 z
18.         if (gKeyValue == 3)
    / I' [, j8 Z8 R9 \" c( K) B
19.         {
    
20.             Med_Led_StateCtrl(LED1,LED_OFF);   // 熄灭LED1
    ; h6 _( C) E: M
21.         }
    
22.     }
    
23. }

复制代码

/ g# j/ u7 s7 S4 ^0 n2 C( D至此，实现了利用KEY0和KEY1控制LED的亮灭状态。


五、拓展
+ D3 u( r; x3 s, ?7 l5 q5.1 一个按键单独控制一个LED亮灭
; n- P( a5 I) |* f1 v9 Q6 t单片机的IO资源是比较珍贵的，在实际用用时很少会用两个IO资源来控制一个外设的开关，这里介绍一下方法并给出例程。比如使用普中核心板上的WK UP按键来控制LED2的亮灭状态。基本思路是在上面学会按键检测的基础上，增加一个按键按下计次变量。按键按下一次，该变量加1。如果检测到变量为1，那么点亮LED，如果检测到变量为2，那么熄灭LED，同时将计数变量清零。程序设计如下

1. u8 gKeyValue = 0;   // 记录按键键值变量
   
2. u8 gKeyWkUpCunt = 0;   // WK UP按下次数计数变量
   
3. 
   
4. int main(void)
   
5. {
   
6.     Med_Mcu_Iint();   // 系统初始化
   
7.    
     w% u5 j; h2 A: N' t
8.     while(1)
   ! b8 W1 k8 D! N8 M1 w' _2 u
9.   {
   - K* d% U3 H2 m7 V
10.         gKeyValue = Med_KeyScan();   // 获取按键键值
    + G. _( X  P& Y! ]  L
11.         
    3 X, g! e9 S4 E; j5 z
12.         // 按键WK UP按下
    
13.         if (gKeyValue == 1)
    
14.         {
    . y& N+ w( Z! h$ S
15.             gKeyWkUpCunt = gKeyWkUpCunt + 1;   // 按键按下次数计数变量加1
    
16.             
    7 [! s- D  O3 l  B
17.             // 第一次被按下
    
18.             if (gKeyWkUpCunt <= 1)
    $ W7 \  R. K, x6 b$ w% {6 {
19.             {
    0 J; v5 N+ ]. q, y* j/ j( w0 n0 F& N
20.                 Med_Led_StateCtrl(LED2,LED_ON);   // 点亮LED2
    
21.             }
    
22.             // 不是第一次被按下
    
23.             else if (gKeyWkUpCunt > 1)
    
24.             {
    ' Q0 t$ Q5 c( ~7 ^/ ~% v; r
25.                 gKeyWkUpCunt = 0;   // 清空计数变量
    ( q# D/ ?5 R- ]0 R3 }8 I! H& ~7 i
26.                 Med_Led_StateCtrl(LED2,LED_OFF);   // 熄灭LED2
    + H* h! ]  Y; j0 e
27.             }
    5 _0 T6 }! P! @1 R) @
28.         }
    9 Z1 j) L' {8 S+ A" E9 ^" f; {2 m
29.     }
    5 I7 S8 b6 A' B: n
30. }

复制代码

4 X2 `" q, @7 R- G) w5.2 按键长短按
) Y8 P+ t( a  [7 P3 S4 b除了上面介绍的一些常规操作外，有时还会用到一个按键分长按和短按。这里给出一种简单粗暴的实现思路。需要检测按键长短按时，修改一下松手检测的逻辑。延时10ms后如果按键IO依旧保持按下状态，那么确定不是机械抖动，此时在之前的松手检测while中进行粗略地计时。定义一个计数变量，每隔10ms加1。直到按键被松开。根据计数变量的值来判断按键被按下的时间，从而来区别长短按。

* W% z0 q% f2 |2 W- \0 ^这里给出一个例程，KEY1短按功能为熄灭LED1，长按功能为LED1和LED2交替闪烁两轮后熄灭。按下持续时间在1s内，认为是短按，按下超过2s认为是长按。短按返回3，长按返回4。程序设计如下
3 N- W6 ?1 Z8 U3 `8 e3 I

1. u8 gKeyValue = 0;   // 记录按键键值变量
   
2. u16 gKey1TimeCunt = 0;   // 按键KEY1的计时变量
   % N% R2 n2 `" l
3. /*
   ) j' S" y, x2 ?, H
4. *==============================================================================
   6 o! n& t% j( w9 c/ H+ U8 m
5. *函数名称：Med_KeyScan
   / q1 {; m; f4 w, j- v+ w1 |1 z' V
6. *函数功能：检测按下按键
   
7. *输入参数：无
   " |6 }: |& W5 M1 H
8. *返回值：按键键值 0：按键WK UP，1：KEY0，2：KEY1
   2 }& O1 _1 i6 v% A' i- e# r7 M% |# ~
9. *备  注：无
   
10. *==============================================================================
    1 L, m3 Y, I- m& C) s2 v& H: B
11. */
    ; d4 x5 J' {! ^- V6 ^
12. u8 Med_KeyScan (void)
    
13. {
    
14.     // 按键WK UP
    
15.     if (KEY_UP == 1)
    + f2 m8 q0 O) ~7 {& m  t
16.     {
    5 [& O, [* ]  j# c
17.         delay_ms (10);   // 延时10ms消抖
    & \2 a+ ]0 a! M; C6 r3 Q
18.         if (KEY_UP == 1)
    7 J- R( j" @/ c, B/ _. ~
19.         {
    ( e( A# F/ r! {- e3 t
20.             while (KEY_UP);   // 松手检测
    
21.             return 1;
    . h* b5 O! j/ K, D3 _
22.         }
    
23.     }
    ( @) h$ N- F- `5 C+ x# i) E
24.    
    
25.     // 按键KEY0
    
26.     else if (KEY0 == 0)
    - U9 H: E  m7 _: g
27.     {
    1 @# Y4 u' d' ~6 s# M! k, t
28.         delay_ms (10);   // 延时10ms消抖
    
29.         if (KEY0 == 0)
    1 R1 x9 [7 X, ~4 R- h- p0 d9 `( X+ L
30.         {
    
31.             while (!KEY0);   // 松手检测
    8 t! a6 U( v- p4 }9 \
32.             return 2;
    1 u. \5 ^  i- x7 |8 X: a0 k) {
33.         }
    & S5 w+ d0 z6 h) _* d; \
34.     }
    
35.    
    ) a* i% ^2 s* K+ ?! w3 c
36.     // 按键KEY1
    & S9 F/ D& w# Z4 R. w; J8 x& R
37.     // 按下1s内认为是短按，返回3
    5 I4 }; B- H4 A1 S$ E" A' G
38.     // 按下超过2s认为是长按，返回4
    
39.     else if (KEY1 == 0)
    
40.     {
    
41.         delay_ms (10);   // 延时10ms消抖
    
42.         if (KEY1 == 0)
    
43.         {
    
44.             // 等待松手
    
45.             while (!KEY1)
    
46.             {
    
47.                 delay_ms (10);
    
48.                 gKey1TimeCunt = gKey1TimeCunt + 1;   // 计时变量加1
    : T& R! O% B2 _
49.             }
    . A" L, j2 U. u! ^, t, K& B
50.         }
    2 V; u- g) o; P3 t' k
51.         
    
52.         // 判断长短按
    : l! b  ~1 E$ {4 l& f) X
53.         if (gKey1TimeCunt <= 99)   // 小于等于1s
    # U( A: @5 o$ d! w* }: Q5 s- k
54.         {
    . Z  u2 n& j) U1 B; P
55.             gKey1TimeCunt = 0;   // 清零计时变量
    : O( w! L6 z  B1 u' G' _1 o" c. c
56.             return 3;   // 短按
    
57.         }
      [6 c8 M% |/ h" n
58.         else if (gKey1TimeCunt >= 199)   // 大于1s，等于2s
    1 o+ H( ]: \  F$ j" _0 N
59.         {
    . w  m. b1 h0 {, C1 u' [
60.             gKey1TimeCunt = 0;   // 清零计时变量
    
61.             return 4;   // 长按
    * u( w7 l* w7 {5 w5 q9 Y; y! G
62.         }
    
63.     }
    0 n. K! k9 X7 k: I
64.    
    
65.     // 没有按键按下
    
66.     return 0xff;   // 用0xff表示没有按键按下
    
67. }

复制代码

main函数中添加下述程序

1. // 长按KEY1
   
2.         if (gKeyValue == 4)
   : ^* M! B. I- q  U
3.         {
     A* t7 u! G" |: Z  _9 p) ^' h
4.             Med_Led_StateCtrl(LED1,LED_ON);   // 点亮LED1
   9 w& t2 L/ y7 {! _# t/ S1 J
5.             delay_ms (500);
   ' L' U5 a- y5 a' h& C# e& H
6.             Med_Led_StateCtrl(LED1,LED_OFF);   // 熄灭LED1
   
7.             Med_Led_StateCtrl(LED2,LED_ON);   // 点亮LED2
   0 v- p! U6 d! v$ C3 b
8.             delay_ms (500);
   : g8 s$ a1 h4 X3 r" S
9.             Med_Led_StateCtrl(LED2,LED_OFF);   // 熄灭LED2
   
10.             Med_Led_StateCtrl(LED1,LED_ON);   // 点亮LED1
    7 R- \, O7 ?& F  t$ K  k6 z) X- M, _
11.             delay_ms (500);
    ) S- @7 E. k1 K4 I. ^* a
12.             Med_Led_StateCtrl(LED1,LED_OFF);   // 熄灭LED1
    # e& o! y- w! d2 O. O
13.             Med_Led_StateCtrl(LED2,LED_ON);   // 点亮LED2
    - g' Q& g# S7 ?! V. e. j
14.             delay_ms (500);
    
15.             Med_Led_StateCtrl(LED1,LED_OFF);   // 熄灭LED1
    " T# c9 b7 }! N
16.             Med_Led_StateCtrl(LED2,LED_OFF);   // 熄灭LED1
    - H# I5 Z) M6 F, J/ u1 I; h
17.         }

复制代码

转载自： 二土电子
3 Y3 C# n! g% N4 B: `5 D如有侵权请联系删除