STM32G4系列MCU学习笔记：按键模块
+ _, h" r# o! e# ~: @2 m
2 {  ?9 W  [6 E前言
我所学过的按键模块有独立按键和矩阵键盘两种，其实两者原理类似，本文主要介绍按键模块中实现长按和短按功能。
! c. y8 n% D; Z. N, p注意了：本文是基于HAL库来进行介绍的，如果你想用标准库实现也比较简单，类比移植即可。
: V' B( a6 F7 v( m由于作者第一次写博客，且自身水平有限，如文中有误，还请大家指正，谢谢~
/ e2 F6 R, l1 v: r1 B+ t

先放一张开发板的实物图，它长这样~
* J9 g; O- d, k/ w0 H: ~& ~+ n/ |

一、硬件操作
2 X4 n, r" y- B: z# ~0 }! e/ R在应用层中我利用不同的点灯程序来区分短按和长按所进行的操作。所以先来看看该模块所设计到的硬件原理图。

$ H: }8 d/ B' Z5 s7 B
1. 原理图

注意了：点灯的这个模块，我们这里忽略这个锁存器芯片，不用它的锁存功能，着重于分析按键模块。

我们先把所使用到的所有GPIO口列出来：（方便待会儿看程序更加清楚）
4 q7 [' _* C; q/ O7 J" R1.点灯相关的IO口：PC8,PC9,PC10,PC11,PC12,PC13,PC14,PC15;
2.按键相关的IO口：PB0,PB1,PB2,PA0。


6 X. j- X1 @' h% w% h0 j3 d* {/ u( z2. 硬件分析
从原理图里可以发现，我们如果将PB1设置为输入模式，去采集该GPIO上的电平状态，按键松开时，PB1上的电平应该为高电平，当我们按下按键后，例如：B2按键，PB1上的电平就会被拉低，其余按键类似，所以根据这样一个简单原理，即可实现按键的输入检测。
+ N. r) D7 v) S" m* q- Y

3. 初始化代码

1. /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
   
2.   HAL_Init();//使用默认配置即可
   2 [2 R7 j" j3 \; C) r
3.   /* Configure the system clock */
   ; I$ z3 f6 u& H4 C6 s
4.   SystemClock_Config();
   
5.   /* Initialize all configured peripherals */
   
6.   MX_GPIO_Init();
   

复制代码

（1）时钟设置
这里我使用的内部时钟源HSI = 16MHz；配置HCLK = PCLK1 = PCLK2 = 80MHz。
# s, v: l; Y( B  M/ T3 Y* D1 O

1. void SystemClock_Config(void)
   
2. {
   2 W; P$ ?1 A3 m/ E# G
3.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
   ! M4 b" J7 E* p1 C% i
4.   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
   
5. 
   
6.   /** Configure the main internal regulator output voltage
   
7.   */
   
8.   HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1);
   
9.   /** Initializes the CPU, AHB and APB busses clocks
   ( y5 J9 B0 ?1 Z" z- T; {
10.   */
    / U, R0 Y' g# a0 x) j2 P; j, ~6 l' U( s
11.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
    0 B! h8 A' J# a9 u- t2 z
12.   RCC_OscInitStruct.HSIState = RCC_HSI_ON;
    
13.   RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
    $ v" j9 ]" }& ?
14.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
    
15.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
    
16.   RCC_OscInitStruct.PLL.PLLM = RCC_PLLM_DIV2;
    - X6 v! ?7 G! b6 G% W! r6 ^
17.   RCC_OscInitStruct.PLL.PLLN = 20;
    
18.   RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
    2 ?& \% [' n' U; l
19.   RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
    ; h, ~* n0 h7 |
20.   RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
    2 P( I! {5 I1 H
21.   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
    
22.   {
    6 V1 R& e- W0 C) ?- B! {
23.     Error_Handler();
    
24.   }
    
25.   /** Initializes the CPU, AHB and APB busses clocks
    ( ]. Y' v+ q4 R; M
26.   */
    $ g3 Z5 r! V9 ^8 w! l$ k5 A
27.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
    " w4 x, h6 h; I7 T' h
28.                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
    
29.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
    0 T5 B. M/ ]  f
30.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
    
31.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
    
32.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
    * S) C: U, {0 ]) a
33. 
    , l( N- x5 L5 @
34.   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_3) != HAL_OK)
    ! k3 |7 W+ x  ?! s' o0 U8 A% @# s
35.   {
    
36.     Error_Handler();
    % ?, B( K: _' n( a- d: z% ^/ F
37.   }
    
38. }
    * f' R* Q" B# N* y* g6 v

复制代码

（2）GPIO初始化
, v5 k2 f& O$ b

1. static void MX_GPIO_Init(void)
   8 S& s9 L' y3 l) \- [
2. {
   2 N2 n3 l0 F- T' C  {7 Y0 X4 o
3.   GPIO_InitTypeDef GPIO_InitStruct = {0};
   
4. 
   
5.   /* GPIO Ports Clock Enable */
     |3 u2 n5 {: G0 ?6 e# ]- e" N
6.   __HAL_RCC_GPIOC_CLK_ENABLE();
   
7.   __HAL_RCC_GPIOF_CLK_ENABLE();
   
8.   __HAL_RCC_GPIOA_CLK_ENABLE();
   % E$ V% P3 S8 R
9.   __HAL_RCC_GPIOB_CLK_ENABLE();
   ( ]$ ?$ ], Z) _, k
10.   __HAL_RCC_GPIOD_CLK_ENABLE();
    7 \0 n) P& ^" k7 v, V7 [
11. 
    
12.   /*Configure GPIO pin Output Level */
    6 ]' I7 ]5 o  s' t6 e
13.   HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15|GPIO_PIN_8
    , w; |; }' `5 t$ Z) c9 ^9 @
14.                           |GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12, GPIO_PIN_RESET);
    
15. 
    , ?0 |- z6 [. q5 K5 A. e0 Q9 j
16.   /*Configure GPIO pin Output Level */
    1 R  f5 n3 q; m6 h( V3 ]+ v8 c, u
17.   HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_RESET);
    ; M& w/ `/ B6 I3 }/ s
18. 
    
19.   /*Configure GPIO pins : PC13 PC14 PC15 PC8
    
20.                            PC9 PC10 PC11 PC12 */
    6 |0 M5 ~  P1 ?! @# C+ o) ^
21.   GPIO_InitStruct.Pin = GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15|GPIO_PIN_8
    
22.                           |GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12;
    
23.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    ; T* b. I1 i; P5 s$ \
24.   GPIO_InitStruct.Pull = GPIO_NOPULL;
    $ Q+ j' n( o0 C8 A& ^
25.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    
26.   HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
    
27. 
    
28.   /*Configure GPIO pin : PA0 */
    
29.   GPIO_InitStruct.Pin = GPIO_PIN_0;
    
30.   GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    
31.   GPIO_InitStruct.Pull = GPIO_NOPULL;
    
32.   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    + [7 I/ ^: W; T$ n% T
33. 
    : D$ ~# x% w1 _% }
34.   /*Configure GPIO pins : PB0 PB1 PB2 */
    
35.   GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2;
    
36.   GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    
37.   GPIO_InitStruct.Pull = GPIO_NOPULL;
    
38.   HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
    % E: v: B) X5 G# ~3 Q4 v7 \; t  |
39. 
    . q8 |- [) p$ ~% A
40.   /*Configure GPIO pin : PD2 */
    
41.   GPIO_InitStruct.Pin = GPIO_PIN_2;
    
42.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    
43.   GPIO_InitStruct.Pull = GPIO_NOPULL;
    ' U2 T$ \% u- U" l, v5 g
44.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    . B0 d# l$ J3 }8 ^1 W; h1 e
45.   HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
    ( Z% [& |7 J8 E% S# C7 K0 f
46. 
      L0 v* c1 X* \% D/ U" Y- u
47. }
    7 T  C! u" |  M- o

复制代码

二、按键模块的驱动层实现
1. 硬件框图
! g1 f5 h/ B- ]# M4 Z在这里插入图片描述

避坑点：
短按：按键释放时判断时间
长按：直接判断时间

3 ^& \& c+ Z$ K! X! \; w, e& b
2. 按键驱动层代码实现
* t  f! S; l+ U$ q& d1 r7 v; j5 ?下面直接上C代码：


（1）key.c

1. extern unsigned int keyCount;
   8 `6 ~( N7 j/ R8 S2 d/ }$ \
2. extern uint8_t keyValue;
   4 |% a( ]0 k7 U, y' n, a! Y& \  A
3. uint8_t keyflag = 0;
   6 E2 Z0 {( }: s( T% P+ @" o: P
4. void Key_Scan(void)
   
5. {
   
6. //keyState  按键状态；
   
7. //keyPass   记录哪一个按键被按下
   * T3 W2 C- b3 k
8. //keyCount  记录按键按下时间
   9 a/ D9 U7 _4 F0 m: m6 w
9. //keyflag   开始计数标志位，方便在Systick中断中进行计时
   
10. //keyValue  返回给应用层的键值，用于判断处理相应的事件
    
11. //ShoutKeyx和LongKeyx是两个宏，为了区分短按和长按
    $ M5 L9 k7 v0 G  Z# m
12. //ShoutKeyx 短按x键值，
    
13. //LongKeyx        长按x键值
    
14.     static uint8_t keyState = 0,keyPass = 0;
    
15.     switch(keyState)
    : B; r4 R4 B4 T. o4 X" l3 K5 i
16.     {
    
17.         case 0:if(KEYB_1==0||KEYB_2==0||KEYB_3==0||KEYB_4==0)
    
18.                 {
    ( I: h9 `5 s% S/ `2 C2 ?
19.                     HAL_Delay(100);//消抖
    : j+ p& i5 e  Y
20.                     keyState = 1;
    ( r1 C( K- B6 l5 L
21.                     keyPass = 0xff; //初始化按键
    2 f4 v: N$ w3 M/ H- m$ o
22.                 }   
    
23.                 break;
    
24.                     
    $ X* b* [- I1 k3 ~$ T% B% ^
25.         case 1: if(KEYB_1==0||KEYB_2==0||KEYB_3==0||KEYB_4==0)
    4 ]7 {8 W9 z0 t+ `2 {- r" e
26.                 {
    / Z9 Z1 d. f4 Q; f" H- J
27.                     keyState = 2;
    
28.                     keyflag = 1;//开始计数
    
29.                     if(KEYB_1==0){
    
30.                         keyPass = 1;//返回对应键值
    9 m3 q9 ^, [+ h+ c3 X
31.                     }   
    
32.                     else if(KEYB_2==0)keyPass = 2;
    
33.                     else if(KEYB_3==0)keyPass = 3;
    ( l8 K* Z' X/ a; h2 |
34.                     else if(KEYB_4==0)keyPass = 4;
    
35.                 }   
    
36.                 else keyState = 0;//返回检测按键      
    
37.                
    : t. J9 }4 J4 ^% A  r3 ~
38.                 break;
    
39.         case 2:
    
40.                 switch(keyPass)
    & {% V/ X- i* J6 V& V
41.                 {              
    
42.                     case 1:if(KEYB_1!=0) //判断是否释放按键
    8 w" ~8 Q8 X; k4 w
43.                             {
    9 `( }  F( r) m. s* b" r% ?
44.                                 if((10 < keyCount)&&(keyCount < 800))//短按
    
45.                                 {
    * T3 W& V) s1 w
46.                                     keyCount = 0;
    
47.                                     keyflag = 0;
      Y. R8 A, G! v! E
48.                                     keyValue = ShoutKey1;
    - l1 K2 j% q4 N( m1 X
49.                                     keyState = 0;
    
50.                                 }   
    # ^* y8 q# q% C
51.                             }      
    
52.                             break;
    . ]2 d/ g3 y! U+ j3 x
53.                     case 2:if(KEYB_2!=0)
    
54.                             {
    0 J6 h3 n, w- R$ C" S: X8 n: [
55.                                 if((10 < keyCount)&&(keyCount < 800))//短按
    % f9 G& f4 X- X8 Z* j. L
56.                                 {
    
57.                                     keyCount = 0;
    
58.                                     keyflag = 0;
    
59.                                     keyValue = ShoutKey2;
    + ^# [% u. F/ L& I$ ^
60.                                     keyState = 0;
    ) Z+ V' K" Q% Q, z( K
61.                                 }   
    
62.                             }      
    9 w  y! `4 X6 i
63.                             break;
    2 D. q/ ]# R5 d$ p/ M, n
64.                     case 3:if(KEYB_3!=0)
    4 ?6 Y8 v, ~8 p  `: J
65.                             {
    
66.                                 if((10 < keyCount) && (keyCount < 800))//短按
    
67.                                 {
    
68.                                     keyCount = 0;
    
69.                                     keyflag = 0;
    
70.                                     keyValue = ShoutKey3;
    
71.                                     keyState = 0;
    
72.                                 }   
    0 f9 H$ H: L9 C2 B9 t
73.                             }      
    
74.                             break;
    
75.                     case 4:if(KEYB_4!=0)
    5 \' p) u5 \2 j4 E1 R7 z/ z5 t
76.                             {
    ' a" x) V9 J& K- C9 N# h
77.                                 if((10 < keyCount)&&(keyCount < 800))//短按
    ' O* r+ y  A( q* i: c5 z' R
78.                                 {
    1 Z( N, Y4 N) c# R
79.                                     keyCount = 0;
    
80.                                     keyflag = 0;
    
81.                                     keyValue = ShoutKey4;
    
82.                                     keyState = 0;
      U. J5 ]  M$ q8 Q* Y% @( q
83.                                 }   
    ; X% h+ [. t* e3 J# V7 M
84.                             }
    
85.                             break;
    
86.                 }
    
87.                 if(keyCount > 800)//长按
    $ D3 |; W3 M) `
88.                 {   
    
89.                     if(KEYB_1==0)keyValue = LongKey1;
    
90.                     else if(KEYB_2==0)keyValue = LongKey2;
    8 c! {, R. d9 ]8 R4 F
91.                     else if(KEYB_3==0)keyValue = LongKey3;
    
92.                     else if(KEYB_4==0)keyValue = LongKey4;
    
93. 
    8 v- H4 t  s" q- l! I
94.                     keyState = 3;
    
95.                 }
    ( {7 G& Y; C! I7 e  b: k! T
96.                 break;
    
97. 
    
98.         case 3: if(KEYB_1==1&&KEYB_2==1&&KEYB_3==1&&KEYB_4==1)
    . @) Z6 H- F) O( [' U, I
99.                 {
    + N0 c1 U5 d( p0 M& |2 K
100.                     keyCount = 0;
     
101.                     keyflag = 0;
     # _9 T  f! _; J* }
102.                     keyState = 0;
     7 j  X- y- p/ }, D* Z: w
103.                     keyValue = 0xff;//长按之后释放按键代表不执行操作，就没有键值传出  
     
104.                 }
     & b8 W( K  G3 @; p4 p
105.                
     + M3 _  i5 ~" c1 ]& u  {0 m
106.                 break;
     5 g6 F* f4 x+ [+ i
107.     }
       [5 B* g# H8 E$ |
108. }
     

复制代码

（2）key.h

1. #ifndef __KEY_H
   
2. #define __KEY_H
   
3. #include "stm32g4xx_hal.h"
   
4. #define KEYB_1                 HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_0) //PB0
   # R1 _: p* A" e5 X# o' ]& `4 m
5. #define KEYB_2                 HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) //PB1
   
6. #define KEYB_3                 HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2)//PB2
   
7. #define KEYB_4                 HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0)//PA0
   
8. #define ShoutKey1             1
   " S6 Z% F( U, Y& V3 t6 C0 Z' M- g5 X
9. #define ShoutKey2                2
   
10. #define ShoutKey3                3
    
11. #define ShoutKey4       4
    
12. #define LongKey1             5
    
13. #define LongKey2                6
    $ n% T# o, Z- f2 j# l  e
14. #define LongKey3                7
    3 o, ]; X- }& u1 Y( s& {
15. #define LongKey4        8
    + a3 i0 Q0 P" p" ]
16. void Key_Scan(void);
    
17. #endif
    

复制代码

3. 计时操作
我使用Systick写了一个简单的定时中断函数，（触发Systick的定时中断时间是1ms）去处理计时操作，这是为了给按键驱动提供短按和长按的时间，便于在驱动层进行相应的判断，所以我不去深挖Systick模块的细节，本文会用即可，后面再单独来记录学习Systick模块。
下面直接来看看Systick的中断服务函数叭，很简单，就这么几句~
/ r, |  k  W1 l+ ?

1. extern uint8_t keyflag;
   
2. unsigned int keyCount = 0;
   0 S0 X( x" r# n" e" E6 @) l; O: v
3. void SysTick_Handler(void)
   , i+ `4 }2 ]6 G# C( l  g$ V9 r6 X
4. {
   
5.   HAL_IncTick(); //这个api是用于HAL库的延时函数HAL_Delay(uint32_t Delay)
   3 Z2 B4 B! K1 k2 t# Q, x8 V
6.         if(keyflag == 1) //若有按键按下就开始计时
   " e2 T2 `% p) |# \. ~6 e1 z2 I$ _
7.                 keyCount++;       
   % }; m; q5 W. z3 ^  F; c
8. }
   ; l+ M" ~: _5 H! [

复制代码

三、应用层简单逻辑实现
应用层要做的事情在文章开篇其实已经说了，因为逻辑很简单，就是根据长按和短按实现不同的点灯程序，所以直接上代码叭~
+ r6 M1 _) \$ A0 U

1. HAL_GPIO_WritePin(GPIOC, GPIO_PIN_All, GPIO_PIN_SET); //关闭所有灯
   
2. HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_SET);        //关闭锁存器
   ' I% Q) J* b% Y6 m
3. while (1)
   
4. {
   
5.                 Key_Scan();
   
6.                 if(keyValue) //有按键按下
   
7.                 {
   ' R) V% L8 j2 u* ^# {
8.                         if(keyValue < 5) //短按
   
9.                         {
   3 w- W" ?3 e! U! H7 b. {' Z, e- \. b
10.                                 switch(keyValue)
      v7 J, A  D% x
11.                                 {
    
12.                                         case 1:
    $ `. U$ U8 ?2 t; ^: z
13.                                                         keyValue = 0;
    ) w+ a3 }9 T- f8 a( v
14.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_8);
    , ]( e; U  \5 r& u' `
15.                                                         HAL_Delay(100);
    
16.                                         break;
    
17.                                         case 2:
    
18.                                                         keyValue = 0;
    
19.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_9);
    ' g" @# }! H& m
20.                                                         HAL_Delay(100);
    
21.                                         break;
    
22.                                         case 3:
    2 r  {/ h+ i9 y  |- I
23.                                                         keyValue = 0;
    
24.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_10);
    
25.                                                         HAL_Delay(100);
    
26.                                         break;
    7 [9 ?+ m* B8 x* P$ r" i( ~
27.                                         case 4:
    
28.                                                         keyValue = 0;
    ) a' P8 O+ N+ C' k' n  B2 Z! J
29.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_11);
    0 B" Y: P: y- t6 j: T
30.                                                         HAL_Delay(100);
    * q) u, F' ~3 [7 A0 t5 H9 l9 ]
31.                                         break;
    
32.                                 }
    % U+ k6 b5 w9 @: B
33.                         }
    7 ^3 R0 g$ Z8 \& y5 a" B5 Q
34.                         else
    
35.                         {
    
36.                                 switch(keyValue)
    % a& D9 D6 y2 b0 d- [( u/ j& n
37.                                 {
    0 Q" M3 a1 O) F# h4 o9 R1 t2 v) J
38.                                         case 5:
    
39.                                                         keyValue = 0;
    - z2 Z7 B* i& D& Z1 H) _+ G
40.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_15);
    
41.                                                         HAL_Delay(100);
    
42.                                         break;
    
43.                                         case 6:
    % k* S8 \( `+ J' N6 h
44.                                                         keyValue = 0;
    
45.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_14);
    2 n. }% v: [7 ]9 ^$ N
46.                                                         HAL_Delay(100);
    : ~) u5 G, X- |1 B* D
47.                                         break;
    
48.                                         case 7:
    
49.                                                         keyValue = 0;
    ! c! o- h& t# `
50.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);
    , O' U# a1 g9 b2 y$ G  Y! f
51.                                                         HAL_Delay(100);
    
52.                                         break;
    
53.                                         case 8:
    ) N1 X, `! o# F8 _: p; V- }
54.                                                         keyValue = 0;
    . E) w1 N6 W% p1 h: T! }7 N
55.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_12);
    
56.                                                         HAL_Delay(100);
    3 R* \) T' I7 Q* m1 G
57.                                         break;
    3 k3 x' E7 ^) R2 h; F
58.                                 }
    7 M. {7 m9 `( l) T
59.                         }
    
60.                 }
    
61. }
    ( r0 B) s# h- p

复制代码

总结
以上就是今天要讲的内容，本文仅仅简单介绍了MCU里按键的短按和长按功能，希望能对你有所帮助噢~。

! M/ i" d* H, P% A  u+ a
9 C; U. d; {7 g9 B( ]

: `5 W* K4 \- j5 g9 e  J& c



3 [3 q/ Z. y* C( {! h* [6 c
5 I3 v2 ~* x) }$ }

学习了~~