STM32G4系列MCU学习笔记：按键模块

/ E3 q% r! J1 C2 ?% W前言
, f7 D, Z: q$ S: q& \, ~) b我所学过的按键模块有独立按键和矩阵键盘两种，其实两者原理类似，本文主要介绍按键模块中实现长按和短按功能。
注意了：本文是基于HAL库来进行介绍的，如果你想用标准库实现也比较简单，类比移植即可。
6 V- Q" C" R4 Q4 I1 @. l" K由于作者第一次写博客，且自身水平有限，如文中有误，还请大家指正，谢谢~


9 |1 D. G) `% |3 h先放一张开发板的实物图，它长这样~

一、硬件操作
3 @9 R( A" C/ A) S: J在应用层中我利用不同的点灯程序来区分短按和长按所进行的操作。所以先来看看该模块所设计到的硬件原理图。
% D5 Q( z" D5 f/ }8 P& M7 ^
  q. d: A$ I7 {8 p6 \
1. 原理图
6 `7 V3 @+ B, T; g' \5 A

注意了：点灯的这个模块，我们这里忽略这个锁存器芯片，不用它的锁存功能，着重于分析按键模块。
2 j- r$ `# p8 I* U$ a

我们先把所使用到的所有GPIO口列出来：（方便待会儿看程序更加清楚）
1.点灯相关的IO口：PC8,PC9,PC10,PC11,PC12,PC13,PC14,PC15;
2.按键相关的IO口：PB0,PB1,PB2,PA0。
# c' E8 y, ~+ P; B+ D) g0 Q

2. 硬件分析
从原理图里可以发现，我们如果将PB1设置为输入模式，去采集该GPIO上的电平状态，按键松开时，PB1上的电平应该为高电平，当我们按下按键后，例如：B2按键，PB1上的电平就会被拉低，其余按键类似，所以根据这样一个简单原理，即可实现按键的输入检测。
1 i- d8 Y' `& I4 W: p2 k% A
3 l5 I: I& \' J" [3 h4 y& n
3. 初始化代码

1. /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
   
2.   HAL_Init();//使用默认配置即可
   
3.   /* Configure the system clock */
   
4.   SystemClock_Config();
   ' E! Q1 I& \! r" E
5.   /* Initialize all configured peripherals */
   % V( O' ~3 |, w* I9 V
6.   MX_GPIO_Init();
   7 h& j3 T* \. ?4 |3 i+ }

复制代码

（1）时钟设置
8 c9 k6 a7 ^$ d% z3 q这里我使用的内部时钟源HSI = 16MHz；配置HCLK = PCLK1 = PCLK2 = 80MHz。
7 x6 a8 @1 B) H, _

1. void SystemClock_Config(void)
   & Z5 }6 o9 j# l: g) T
2. {
   
3.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
   
4.   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
   7 W; \! c/ z! h8 f* v) l2 `  J
5. 
   
6.   /** Configure the main internal regulator output voltage
   , v$ G6 m. J& E( W
7.   */
   
8.   HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1);
   / y8 C* p5 T$ l/ Y* H  m
9.   /** Initializes the CPU, AHB and APB busses clocks
   ! q4 y. g( u8 T- d
10.   */
    8 T3 E/ l, m3 d* Z) I& K
11.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
    
12.   RCC_OscInitStruct.HSIState = RCC_HSI_ON;
    
13.   RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
    
14.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
    
15.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
    
16.   RCC_OscInitStruct.PLL.PLLM = RCC_PLLM_DIV2;
    
17.   RCC_OscInitStruct.PLL.PLLN = 20;
    + F3 Y9 E/ L1 E+ `: i9 z2 ]2 u% k) D
18.   RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
    - E; b9 p7 ~& b! F! r( B2 r
19.   RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
    " o% ^8 C% i1 @2 Q/ n
20.   RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
    
21.   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
    4 g+ H4 G8 T+ w# i2 C5 u% {
22.   {
    ! s: M- d2 }9 d" K( b. `2 K
23.     Error_Handler();
    
24.   }
    
25.   /** Initializes the CPU, AHB and APB busses clocks
    
26.   */
    
27.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
    
28.                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
    
29.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
    & M6 @, g9 r+ y3 q5 U3 l
30.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
    
31.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
    
32.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
    # W2 S5 ~( X: T; t: u
33. 
    * T  k, x, @+ @$ H% }7 H$ \
34.   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_3) != HAL_OK)
    . @6 l' v: _* H, Q6 C- \( G
35.   {
    
36.     Error_Handler();
    & h' V, n+ n" J) D
37.   }
    
38. }
    . _- j5 x1 W6 d/ O$ X* z0 m

复制代码

（2）GPIO初始化

1. static void MX_GPIO_Init(void)
   9 D* f1 ]9 I. T' b# I
2. {
   ; j+ v0 n2 E7 r; `
3.   GPIO_InitTypeDef GPIO_InitStruct = {0};
   # `" [& H8 p6 s- r& A+ z
4. 
   
5.   /* GPIO Ports Clock Enable */
   
6.   __HAL_RCC_GPIOC_CLK_ENABLE();
   2 f/ z% I" A- R. b8 E# m0 r
7.   __HAL_RCC_GPIOF_CLK_ENABLE();
   
8.   __HAL_RCC_GPIOA_CLK_ENABLE();
   
9.   __HAL_RCC_GPIOB_CLK_ENABLE();
   ) a/ Z$ q8 g  E/ R9 C! E% _
10.   __HAL_RCC_GPIOD_CLK_ENABLE();
    
11. 
    
12.   /*Configure GPIO pin Output Level */
    
13.   HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15|GPIO_PIN_8
    
14.                           |GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12, GPIO_PIN_RESET);
    
15. 
    " L/ x! M& v( f8 J
16.   /*Configure GPIO pin Output Level */
    
17.   HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_RESET);
    
18. 
    4 q& X  D5 }; C
19.   /*Configure GPIO pins : PC13 PC14 PC15 PC8
    
20.                            PC9 PC10 PC11 PC12 */
    
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;
    # ?: I. C5 ?  F! j! ]! O
23.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    5 h, }2 x# \( X
24.   GPIO_InitStruct.Pull = GPIO_NOPULL;
    
25.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    
26.   HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
    
27. 
    
28.   /*Configure GPIO pin : PA0 */
    ! x! U, [4 n: V5 s
29.   GPIO_InitStruct.Pin = GPIO_PIN_0;
      u( Z# B7 P- @- U, u" v2 Z6 P. o
30.   GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    
31.   GPIO_InitStruct.Pull = GPIO_NOPULL;
    4 E9 _7 E: O! s( ]" G( {! Y
32.   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
33. 
    
34.   /*Configure GPIO pins : PB0 PB1 PB2 */
    5 l$ H' K( d% ^) n7 m  R
35.   GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2;
    
36.   GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    0 {5 D, H# P5 M; q
37.   GPIO_InitStruct.Pull = GPIO_NOPULL;
    3 ]2 ?  D. @  Z" ?/ h. y& K
38.   HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
    0 {: }* r; ^2 N3 D# f! ~1 Q2 a
39. 
    
40.   /*Configure GPIO pin : PD2 */
    4 J7 c: f- U1 \! E0 l6 {) B
41.   GPIO_InitStruct.Pin = GPIO_PIN_2;
    
42.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    ) |' j' J' q8 g% M. E2 o
43.   GPIO_InitStruct.Pull = GPIO_NOPULL;
    
44.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    * J, O3 {' b5 W, j& a
45.   HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
    
46. 
    
47. }
    . T4 H( C: j8 g' O& }

复制代码

二、按键模块的驱动层实现
1. 硬件框图
在这里插入图片描述
1 N. H! E, c) t- e; x6 j
避坑点：
短按：按键释放时判断时间
% F9 m9 V) @- g) F4 B* j7 Z长按：直接判断时间
6 Q- _% h5 q7 Y! S+ v
& M# t. F$ _) b8 Y
- Q0 R( D2 x* v: o2. 按键驱动层代码实现
下面直接上C代码：

2 S: W/ `/ E) m9 p
（1）key.c
. u$ _9 j6 W% W. k

1. extern unsigned int keyCount;
   
2. extern uint8_t keyValue;
   : r8 u2 f  z) O7 H( Y/ B7 i
3. uint8_t keyflag = 0;
   3 j( n0 N/ {# M9 D7 V! i
4. void Key_Scan(void)
   
5. {
   
6. //keyState  按键状态；
   
7. //keyPass   记录哪一个按键被按下
   
8. //keyCount  记录按键按下时间
   
9. //keyflag   开始计数标志位，方便在Systick中断中进行计时
   0 C, Z$ z0 f  L+ K7 y* n' {
10. //keyValue  返回给应用层的键值，用于判断处理相应的事件
    
11. //ShoutKeyx和LongKeyx是两个宏，为了区分短按和长按
      p* f) n3 K% t' i3 j& W& o  i
12. //ShoutKeyx 短按x键值，
    
13. //LongKeyx        长按x键值
    : V  S$ B) d5 B; S* C: A7 J! D
14.     static uint8_t keyState = 0,keyPass = 0;
    
15.     switch(keyState)
    
16.     {
    ! H% e6 q" B8 b* ~5 v
17.         case 0:if(KEYB_1==0||KEYB_2==0||KEYB_3==0||KEYB_4==0)
    
18.                 {
    
19.                     HAL_Delay(100);//消抖
    
20.                     keyState = 1;
    " m0 M+ W* q6 W3 Z3 L2 q& W
21.                     keyPass = 0xff; //初始化按键
    % n$ U& U7 U. {
22.                 }   
    
23.                 break;
    / k- b4 D  ~) X- e' v
24.                     
    
25.         case 1: if(KEYB_1==0||KEYB_2==0||KEYB_3==0||KEYB_4==0)
    " O2 c; H' {& o# }/ m
26.                 {
    / P1 `5 w3 n/ @" H
27.                     keyState = 2;
    
28.                     keyflag = 1;//开始计数
    
29.                     if(KEYB_1==0){
    
30.                         keyPass = 1;//返回对应键值
    0 X6 e/ M! m, w
31.                     }   
    
32.                     else if(KEYB_2==0)keyPass = 2;
    
33.                     else if(KEYB_3==0)keyPass = 3;
    
34.                     else if(KEYB_4==0)keyPass = 4;
    
35.                 }   
    
36.                 else keyState = 0;//返回检测按键      
    
37.                
    
38.                 break;
    
39.         case 2:
    
40.                 switch(keyPass)
    
41.                 {              
    - g! U; U4 a& V& n( g
42.                     case 1:if(KEYB_1!=0) //判断是否释放按键
    
43.                             {
    
44.                                 if((10 < keyCount)&&(keyCount < 800))//短按
    + B. h: E2 H' U3 Q1 W1 Q8 P2 r9 a2 ]
45.                                 {
    
46.                                     keyCount = 0;
      j& u/ C- Z* K% U0 S( e, w1 a  {
47.                                     keyflag = 0;
    
48.                                     keyValue = ShoutKey1;
    
49.                                     keyState = 0;
      b% s2 B4 h5 i( f
50.                                 }   
    
51.                             }      
    
52.                             break;
    7 f$ U, o% ~; x: [
53.                     case 2:if(KEYB_2!=0)
    
54.                             {
    ' a: q% N3 q/ I2 q
55.                                 if((10 < keyCount)&&(keyCount < 800))//短按
    ) A7 b+ n- ?4 I; G+ |
56.                                 {
    ' ^3 \; F( b1 ~3 n" S( n
57.                                     keyCount = 0;
    : G8 G/ L$ D& i8 C; S4 [
58.                                     keyflag = 0;
    
59.                                     keyValue = ShoutKey2;
    & Y+ P6 D" |* m- i3 j
60.                                     keyState = 0;
    
61.                                 }   
    : g  |( [8 K" [% K
62.                             }      
    : [" U, ]  c* A
63.                             break;
    ' O* q/ c6 c4 @' y+ h- |& ~! O
64.                     case 3:if(KEYB_3!=0)
    
65.                             {
    
66.                                 if((10 < keyCount) && (keyCount < 800))//短按
    
67.                                 {
    
68.                                     keyCount = 0;
    9 B: o6 G" I% D, `3 N6 o2 J
69.                                     keyflag = 0;
    8 d( [$ m  q- A* u1 w
70.                                     keyValue = ShoutKey3;
    ' h# h- [+ z# [3 y
71.                                     keyState = 0;
    
72.                                 }   
    , D) M4 T+ N: P
73.                             }      
    
74.                             break;
    5 l" p$ I5 B! G4 W9 L, i3 f3 Q0 f4 L
75.                     case 4:if(KEYB_4!=0)
    
76.                             {
    
77.                                 if((10 < keyCount)&&(keyCount < 800))//短按
    
78.                                 {
    
79.                                     keyCount = 0;
    
80.                                     keyflag = 0;
    % G( H( n. m5 Y% Q9 K$ H
81.                                     keyValue = ShoutKey4;
    + {7 p; n& X0 v: G2 ^6 a
82.                                     keyState = 0;
    
83.                                 }   
    
84.                             }
    
85.                             break;
    - \% p  J. L; Y- B: g
86.                 }
    
87.                 if(keyCount > 800)//长按
    7 P% t; a$ _3 T% \- c0 a7 u
88.                 {   
    5 u9 ?& Q' f+ @; k7 W/ Z* T7 ^
89.                     if(KEYB_1==0)keyValue = LongKey1;
    
90.                     else if(KEYB_2==0)keyValue = LongKey2;
    
91.                     else if(KEYB_3==0)keyValue = LongKey3;
    8 F5 W% R9 C5 Z( P# P( b5 }6 l
92.                     else if(KEYB_4==0)keyValue = LongKey4;
    1 h' A9 N& K4 I- K; E% ?
93. 
    
94.                     keyState = 3;
    # U5 t+ l- t$ W2 M" |
95.                 }
    
96.                 break;
    
97. 
    # V  t, j4 A' r7 E  U
98.         case 3: if(KEYB_1==1&&KEYB_2==1&&KEYB_3==1&&KEYB_4==1)
    
99.                 {
    ' a# m4 G5 ^1 L" k* W5 F
100.                     keyCount = 0;
     8 K# ?6 R# J. f  }  J
101.                     keyflag = 0;
     * X* V3 {7 G' a- `! ]
102.                     keyState = 0;
     5 c  Q, ^" i1 X/ E# G2 }: m5 ~% P
103.                     keyValue = 0xff;//长按之后释放按键代表不执行操作，就没有键值传出  
     & V6 _( W% W0 P6 R( w% H
104.                 }
     . N+ w2 e+ H% B6 f
105.                
     , H9 I0 e( P* u, P! L0 R
106.                 break;
     
107.     }
     9 T9 I* `, I1 ]9 e4 n
108. }
     6 N3 H. p+ N# T- a( h/ T

复制代码

（2）key.h
* E, Y3 ], {! K. x; I$ Y

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
   
5. #define KEYB_2                 HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) //PB1
   
6. #define KEYB_3                 HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2)//PB2
     c; e" y6 V/ Z3 l
7. #define KEYB_4                 HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0)//PA0
   
8. #define ShoutKey1             1
   - z  X3 ?* [. c6 `2 k1 V
9. #define ShoutKey2                2
   
10. #define ShoutKey3                3
    
11. #define ShoutKey4       4
    7 |7 N' R+ N& ~  H0 X0 D/ d
12. #define LongKey1             5
    
13. #define LongKey2                6
    ( a# A/ P& i( N0 R% c
14. #define LongKey3                7
    1 X% v  X4 F, J- w7 j
15. #define LongKey4        8
    
16. void Key_Scan(void);
    - z: y) A: h$ f. Y) {
17. #endif
    1 |: `' Z' u; c

复制代码

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

1. extern uint8_t keyflag;
   
2. unsigned int keyCount = 0;
   8 O7 @3 }% J9 h0 P9 e$ _
3. void SysTick_Handler(void)
   , J- _7 U& |, b
4. {
   
5.   HAL_IncTick(); //这个api是用于HAL库的延时函数HAL_Delay(uint32_t Delay)
   . ]$ M' d% d/ E5 M
6.         if(keyflag == 1) //若有按键按下就开始计时
   4 K9 J9 r2 h# }9 ~
7.                 keyCount++;       
   
8. }
   + q, A0 o7 l( \/ O

复制代码

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

1. HAL_GPIO_WritePin(GPIOC, GPIO_PIN_All, GPIO_PIN_SET); //关闭所有灯
   # G7 q" E* Y5 s& \6 C" ?0 u6 k) s7 x
2. HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_SET);        //关闭锁存器
   2 z7 g; k5 n0 ^3 z! o( K
3. while (1)
   0 w% N; @9 U5 O( N
4. {
   3 {: Y3 {3 F! F5 @1 d' b
5.                 Key_Scan();
   
6.                 if(keyValue) //有按键按下
   
7.                 {
   1 Y/ D& C5 Q. a( g3 K/ Z( L2 y
8.                         if(keyValue < 5) //短按
   % P/ S5 s+ V7 a1 a* u* ~" l
9.                         {
   
10.                                 switch(keyValue)
    
11.                                 {
    
12.                                         case 1:
    
13.                                                         keyValue = 0;
    , U; z) ~' B7 F* K1 {9 i3 _, z1 P
14.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_8);
    
15.                                                         HAL_Delay(100);
    
16.                                         break;
    . v. R% d  I+ h8 k$ I: Y, y
17.                                         case 2:
    
18.                                                         keyValue = 0;
    0 s5 R1 }- i1 K: C- P
19.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_9);
    ; D% }' j6 k0 ~! W
20.                                                         HAL_Delay(100);
    
21.                                         break;
    
22.                                         case 3:
    
23.                                                         keyValue = 0;
    
24.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_10);
    
25.                                                         HAL_Delay(100);
    
26.                                         break;
    
27.                                         case 4:
      `: Q5 G/ H+ w
28.                                                         keyValue = 0;
    
29.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_11);
    
30.                                                         HAL_Delay(100);
    0 C$ o6 Y: |5 ]! z* H
31.                                         break;
    
32.                                 }
    0 V2 W1 q# U* w+ ~% @5 @
33.                         }
    
34.                         else
    
35.                         {
    5 ]: o# s+ _( ?% B3 i
36.                                 switch(keyValue)
    8 P, m+ M2 {6 Z" F$ M( m, m
37.                                 {
    
38.                                         case 5:
    * h% l- ?% H0 z. C/ `
39.                                                         keyValue = 0;
    
40.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_15);
    $ }) Z9 B% _* U+ c1 h5 x1 h
41.                                                         HAL_Delay(100);
    
42.                                         break;
    5 B3 _4 ]. ]; d/ v5 n) u7 ^; Y
43.                                         case 6:
    ' ?) I) a% Q! h' d; _
44.                                                         keyValue = 0;
    
45.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_14);
    
46.                                                         HAL_Delay(100);
    ! j2 g5 R# [8 k' _  H, g, F' W
47.                                         break;
    
48.                                         case 7:
    
49.                                                         keyValue = 0;
    1 E% |. Q" c% l8 c7 B0 `( u
50.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);
    ) r. I+ Y6 ?3 n
51.                                                         HAL_Delay(100);
    . h. s" j5 N* x, K( |
52.                                         break;
    
53.                                         case 8:
    % b1 ^; I/ N) j- i' U
54.                                                         keyValue = 0;
    . F& W  o8 O, X& V$ v
55.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_12);
      Z: R; |3 P; z; j/ a. a. b0 b! D
56.                                                         HAL_Delay(100);
    
57.                                         break;
    
58.                                 }
    2 i1 R& F, t3 K4 d6 |
59.                         }
    # d5 L# a% Q# R
60.                 }
    
61. }
    ( \* @: A( ~$ |7 F/ e2 c# q2 j, D

复制代码

总结
9 P) p9 x" |; s# y# n# c0 I5 p7 {以上就是今天要讲的内容，本文仅仅简单介绍了MCU里按键的短按和长按功能，希望能对你有所帮助噢~。
0 f% B6 U3 Q. H0 P) h- |





# W5 @5 l1 F; l+ d6 l

& h- ?! ]+ O$ V2 w% ^
: t4 X" H& r4 O, g

学习了~~