STM32G4系列MCU学习笔记：按键模块
2 o! \* N' k5 a( N; h. o! t- |. M
3 H* B3 Q0 f' i) @' l" |" q前言
我所学过的按键模块有独立按键和矩阵键盘两种，其实两者原理类似，本文主要介绍按键模块中实现长按和短按功能。
注意了：本文是基于HAL库来进行介绍的，如果你想用标准库实现也比较简单，类比移植即可。
由于作者第一次写博客，且自身水平有限，如文中有误，还请大家指正，谢谢~
% \" M% F  U0 Y& L% L: a- E
! ^: }& m7 K( L" P+ g& N' l
先放一张开发板的实物图，它长这样~
' K6 j4 n9 M' g

一、硬件操作
在应用层中我利用不同的点灯程序来区分短按和长按所进行的操作。所以先来看看该模块所设计到的硬件原理图。
0 {$ _& D) r3 w% p4 J9 v) g" z
* D4 k$ c1 j0 M4 b7 X
1. 原理图

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

我们先把所使用到的所有GPIO口列出来：（方便待会儿看程序更加清楚）
1.点灯相关的IO口：PC8,PC9,PC10,PC11,PC12,PC13,PC14,PC15;
5 T: p/ @: c/ o* s) k2.按键相关的IO口：PB0,PB1,PB2,PA0。


. z  s3 r3 `6 m. U( b' q2. 硬件分析
' }1 m3 B- Q$ w+ l9 b. j* o从原理图里可以发现，我们如果将PB1设置为输入模式，去采集该GPIO上的电平状态，按键松开时，PB1上的电平应该为高电平，当我们按下按键后，例如：B2按键，PB1上的电平就会被拉低，其余按键类似，所以根据这样一个简单原理，即可实现按键的输入检测。
" S3 V" R( M% o  Q5 V2 U

8 e5 ^1 z- @# X% t2 Q8 V' }4 z2 E9 V3. 初始化代码
7 i; r. O  W1 q! _8 ?" d4 E

1. /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
   
2.   HAL_Init();//使用默认配置即可
   
3.   /* Configure the system clock */
   
4.   SystemClock_Config();
   1 K9 A" f$ }9 Z$ U4 e; |
5.   /* Initialize all configured peripherals */
   
6.   MX_GPIO_Init();
   

复制代码

（1）时钟设置
5 R) \& y+ f, X, _1 n+ D这里我使用的内部时钟源HSI = 16MHz；配置HCLK = PCLK1 = PCLK2 = 80MHz。

1. void SystemClock_Config(void)
   . W6 V% i8 W6 D: S
2. {
   
3.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
   
4.   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
   3 ~+ ?7 l9 d2 z  T% t5 X; r5 P
5. 
   " l& Q4 D3 M' E* g4 U' r
6.   /** Configure the main internal regulator output voltage
   
7.   */
   & T! H. D4 I5 _; S4 r& q
8.   HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1);
   
9.   /** Initializes the CPU, AHB and APB busses clocks
   
10.   */
    
11.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
    
12.   RCC_OscInitStruct.HSIState = RCC_HSI_ON;
    1 _, b7 \. w! I
13.   RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
    
14.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
    7 K7 ?% N& ~, v& b6 y) Y
15.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
    4 y  Q6 C* w5 E" o
16.   RCC_OscInitStruct.PLL.PLLM = RCC_PLLM_DIV2;
    8 `6 R1 g* I$ A& _
17.   RCC_OscInitStruct.PLL.PLLN = 20;
    , _. Q; ^! Q: V9 A' S# G, G$ p
18.   RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
    
19.   RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
    
20.   RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
    
21.   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
    1 k# |5 E" [, X4 U* {6 v7 J8 T7 Y
22.   {
    
23.     Error_Handler();
    # }) S: [+ `- @& F1 h, D/ c
24.   }
    4 y0 {6 ?: a* d# I+ d( D) T: ~
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;
    - G2 V+ H4 h  i9 F' f4 s# T
29.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
    ! ]/ ?5 V+ g% M- A" A
30.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
    . @+ _( A$ a1 O7 h* i+ L$ K5 P
31.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
    
32.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
    6 L4 |5 B! h* g9 c
33. 
    6 e2 A- r7 a+ d6 A$ W9 ]0 f
34.   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_3) != HAL_OK)
    
35.   {
    
36.     Error_Handler();
    ! e; t. m% [5 c; I; ]
37.   }
    
38. }
    5 d  {+ T: A1 t; ^% b( O1 b  W; q

复制代码

（2）GPIO初始化

1. static void MX_GPIO_Init(void)
   
2. {
   2 Y# T- q. g3 o, y4 a  Q
3.   GPIO_InitTypeDef GPIO_InitStruct = {0};
   
4. 
   / z' P" j: s3 c+ Y
5.   /* GPIO Ports Clock Enable */
   
6.   __HAL_RCC_GPIOC_CLK_ENABLE();
   & w. h8 F& y0 _/ Y
7.   __HAL_RCC_GPIOF_CLK_ENABLE();
   
8.   __HAL_RCC_GPIOA_CLK_ENABLE();
   
9.   __HAL_RCC_GPIOB_CLK_ENABLE();
   . o; f3 |* d* D8 T1 a( u9 S
10.   __HAL_RCC_GPIOD_CLK_ENABLE();
    
11. 
    
12.   /*Configure GPIO pin Output Level */
    - ^) ]3 V- D% Z
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);
    + [5 D" v1 k3 @9 V- u
15. 
    
16.   /*Configure GPIO pin Output Level */
    
17.   HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_RESET);
    
18. 
    
19.   /*Configure GPIO pins : PC13 PC14 PC15 PC8
    5 Q8 P7 m5 b+ m8 \
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;
    
23.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    
24.   GPIO_InitStruct.Pull = GPIO_NOPULL;
    
25.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    * |, x: F! k. v
26.   HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
    ' p9 f2 I! V/ t& Y. H
27. 
    + R' v: n: `. D  U
28.   /*Configure GPIO pin : PA0 */
    
29.   GPIO_InitStruct.Pin = GPIO_PIN_0;
    
30.   GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    7 e' \3 b3 w- j  Q1 i2 {: w
31.   GPIO_InitStruct.Pull = GPIO_NOPULL;
    
32.   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
    
33. 
    # |6 _' Q. Q% |
34.   /*Configure GPIO pins : PB0 PB1 PB2 */
    + n+ e! a; Z' X9 c  U! r1 d, I# D
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;
    ' W) A, {0 K3 e: o" D% e, {
38.   HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
    8 O3 U/ ^. G" O' @( H2 O+ f  E
39. 
    " _: E, c1 w. x4 ~) s
40.   /*Configure GPIO pin : PD2 */
    
41.   GPIO_InitStruct.Pin = GPIO_PIN_2;
      y7 p8 O4 F* W0 I$ O
42.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    : R/ o0 p. y) z1 ?# q$ _
43.   GPIO_InitStruct.Pull = GPIO_NOPULL;
    
44.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    9 G2 A: u# e1 I7 W6 y" t% i7 J
45.   HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
    
46. 
    7 e7 a8 l. ^9 V+ _1 e
47. }
    2 h7 l4 O$ f6 w5 Y" g- J" k9 m

复制代码

二、按键模块的驱动层实现
1. 硬件框图
) K$ [; z1 J( p1 [1 B8 t在这里插入图片描述
! j/ G7 k1 f0 \& Z$ x/ \+ M
" s# g1 i8 E8 ?0 ^% j% C& {9 i9 G避坑点：
8 i" X+ E; ?3 X; M3 `% _短按：按键释放时判断时间
长按：直接判断时间

8 S$ b5 T/ Q7 b
2 W" E" T* `- n8 O/ t& p1 r2. 按键驱动层代码实现
下面直接上C代码：


' }  ]9 `2 Y2 Z/ @1 e( W- N. v（1）key.c

1. extern unsigned int keyCount;
   0 Q! C0 x5 t) h
2. extern uint8_t keyValue;
   
3. uint8_t keyflag = 0;
   
4. void Key_Scan(void)
     u( M7 b7 w# H- ]2 P+ n) e( Q
5. {
   # J- ^# L/ k  i
6. //keyState  按键状态；
   
7. //keyPass   记录哪一个按键被按下
   
8. //keyCount  记录按键按下时间
   
9. //keyflag   开始计数标志位，方便在Systick中断中进行计时
   
10. //keyValue  返回给应用层的键值，用于判断处理相应的事件
    
11. //ShoutKeyx和LongKeyx是两个宏，为了区分短按和长按
    
12. //ShoutKeyx 短按x键值，
    , p- e+ ^3 Y) h" z
13. //LongKeyx        长按x键值
    
14.     static uint8_t keyState = 0,keyPass = 0;
    ; A% Q0 @5 H( W# ~6 p6 A$ s
15.     switch(keyState)
    
16.     {
    
17.         case 0:if(KEYB_1==0||KEYB_2==0||KEYB_3==0||KEYB_4==0)
    
18.                 {
    
19.                     HAL_Delay(100);//消抖
    , v3 q( r) c4 R! j: N" Y0 ~
20.                     keyState = 1;
    ) U- A4 A% {# R' x
21.                     keyPass = 0xff; //初始化按键
    - f( T/ f- l' |/ ~- t, A- D
22.                 }   
    ' P7 _' ~3 Z( V. s3 E
23.                 break;
    2 d4 n5 |1 _1 ]0 X7 `' h% F9 e
24.                     
    
25.         case 1: if(KEYB_1==0||KEYB_2==0||KEYB_3==0||KEYB_4==0)
    
26.                 {
    
27.                     keyState = 2;
    : ^: T! ^# v: L% j* c" L
28.                     keyflag = 1;//开始计数
    + D0 k8 l& c9 s6 s
29.                     if(KEYB_1==0){
    
30.                         keyPass = 1;//返回对应键值
    
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;//返回检测按键      
    $ o2 _2 y9 N5 b& G" P" O7 K
37.                
    
38.                 break;
    
39.         case 2:
    ! @( F( ^; L, L9 s# N; M7 @
40.                 switch(keyPass)
    
41.                 {              
    
42.                     case 1:if(KEYB_1!=0) //判断是否释放按键
    2 r) U% u' ~2 w. k' Z& h
43.                             {
    
44.                                 if((10 < keyCount)&&(keyCount < 800))//短按
    & {( P8 }6 Q: l, g2 ]4 k0 y
45.                                 {
    ! O, w- z, n4 \2 Q
46.                                     keyCount = 0;
    6 P! C! f$ U' V! u  V
47.                                     keyflag = 0;
    % D6 O1 s; @# U$ z# `: a
48.                                     keyValue = ShoutKey1;
    
49.                                     keyState = 0;
    
50.                                 }   
    
51.                             }      
    
52.                             break;
    
53.                     case 2:if(KEYB_2!=0)
    0 B& Y  y/ |* @# V+ C" D
54.                             {
    
55.                                 if((10 < keyCount)&&(keyCount < 800))//短按
    8 y5 @7 N$ f2 e4 _( C9 H4 r1 P
56.                                 {
    
57.                                     keyCount = 0;
    
58.                                     keyflag = 0;
    ; z$ r( @. _1 f1 L3 n* S( ~! A
59.                                     keyValue = ShoutKey2;
    
60.                                     keyState = 0;
    
61.                                 }   
    5 P4 t" u/ k. D* F6 N& q# t
62.                             }      
    ! s; j& p4 A. r) d) D+ V
63.                             break;
    
64.                     case 3:if(KEYB_3!=0)
    
65.                             {
    
66.                                 if((10 < keyCount) && (keyCount < 800))//短按
    
67.                                 {
    - a- ?* C; e$ v/ s
68.                                     keyCount = 0;
    
69.                                     keyflag = 0;
    
70.                                     keyValue = ShoutKey3;
    
71.                                     keyState = 0;
    
72.                                 }   
    0 T; L0 E$ v& h, N, \, J4 r& W
73.                             }      
    - ^- e7 @$ d+ w0 g
74.                             break;
    
75.                     case 4:if(KEYB_4!=0)
    
76.                             {
    
77.                                 if((10 < keyCount)&&(keyCount < 800))//短按
    # A" t7 P& M" f) L9 a
78.                                 {
    
79.                                     keyCount = 0;
    
80.                                     keyflag = 0;
    * K- u& H6 D8 e5 Q! X6 a
81.                                     keyValue = ShoutKey4;
    
82.                                     keyState = 0;
    
83.                                 }   
    0 t) Z! [7 m) L2 R) o7 l
84.                             }
    
85.                             break;
    % c3 ]$ C2 N6 K: g
86.                 }
    
87.                 if(keyCount > 800)//长按
    
88.                 {   
    8 N' I- K) c* P) l3 m
89.                     if(KEYB_1==0)keyValue = LongKey1;
    
90.                     else if(KEYB_2==0)keyValue = LongKey2;
    
91.                     else if(KEYB_3==0)keyValue = LongKey3;
    % r& y. f+ b2 l- ^3 J
92.                     else if(KEYB_4==0)keyValue = LongKey4;
    
93. 
    2 [% q9 x+ \6 O: q& g# s* M
94.                     keyState = 3;
    
95.                 }
    
96.                 break;
    , e" B: Z; r* z
97. 
    
98.         case 3: if(KEYB_1==1&&KEYB_2==1&&KEYB_3==1&&KEYB_4==1)
    
99.                 {
    
100.                     keyCount = 0;
     ' e+ n5 E" ^& M8 b6 K9 `+ Q7 C% u& x
101.                     keyflag = 0;
     9 Y. t6 s; }% r
102.                     keyState = 0;
     
103.                     keyValue = 0xff;//长按之后释放按键代表不执行操作，就没有键值传出  
     
104.                 }
     
105.                
     3 f$ }$ N# B+ B
106.                 break;
     
107.     }
     
108. }
     

复制代码

（2）key.h

1. #ifndef __KEY_H
   # b/ Z  k$ c7 H: a
2. #define __KEY_H
   
3. #include "stm32g4xx_hal.h"
   ( m, J: o. M; c6 Y
4. #define KEYB_1                 HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_0) //PB0
   ' I# n4 c) X$ V4 n. ~
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
   
9. #define ShoutKey2                2
   
10. #define ShoutKey3                3
    5 J2 V6 D( [- r0 x+ u+ z
11. #define ShoutKey4       4
    6 ~/ c4 J0 F' y1 [7 p3 D4 d9 m
12. #define LongKey1             5
    
13. #define LongKey2                6
    
14. #define LongKey3                7
    
15. #define LongKey4        8
    # G2 m  C3 y) Z) L: X5 p  {
16. void Key_Scan(void);
    
17. #endif
    " O5 [, R/ A  t, r7 J

复制代码

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

1. extern uint8_t keyflag;
   
2. unsigned int keyCount = 0;
   7 q* S$ w0 C2 r$ R
3. void SysTick_Handler(void)
   % ]) K( s. u6 ?- J* p3 Z9 d1 q
4. {
   % F* ~! T" A6 m
5.   HAL_IncTick(); //这个api是用于HAL库的延时函数HAL_Delay(uint32_t Delay)
   2 F/ R0 T! o# G- [
6.         if(keyflag == 1) //若有按键按下就开始计时
   
7.                 keyCount++;       
   
8. }
   

复制代码

三、应用层简单逻辑实现
应用层要做的事情在文章开篇其实已经说了，因为逻辑很简单，就是根据长按和短按实现不同的点灯程序，所以直接上代码叭~
: m$ p6 c# O# Q8 O2 K5 n/ `1 v. ]- n

1. HAL_GPIO_WritePin(GPIOC, GPIO_PIN_All, GPIO_PIN_SET); //关闭所有灯
   
2. HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_SET);        //关闭锁存器
   
3. while (1)
   , c1 H& r& O$ {3 H1 d3 R
4. {
   
5.                 Key_Scan();
   3 b, i2 O5 \- m1 W
6.                 if(keyValue) //有按键按下
   " ?1 `- T" X4 A% Y+ A  y
7.                 {
   
8.                         if(keyValue < 5) //短按
   
9.                         {
   ( O8 l9 [, r- y! q
10.                                 switch(keyValue)
    
11.                                 {
    1 l- x2 b" E+ l( N
12.                                         case 1:
    : N$ |- z4 j! E/ K( H
13.                                                         keyValue = 0;
    1 X9 _3 _6 Q3 q5 B( w
14.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_8);
    
15.                                                         HAL_Delay(100);
    6 t/ g! F2 a, T
16.                                         break;
    ! I4 K6 U" x* V( M6 _
17.                                         case 2:
    
18.                                                         keyValue = 0;
    5 P6 B1 s" C- ?9 B8 \: y% T
19.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_9);
    2 ]& K% U5 B) ^: y- p4 T; y( J0 T/ P
20.                                                         HAL_Delay(100);
    
21.                                         break;
    
22.                                         case 3:
    2 T) W" ]9 {0 D
23.                                                         keyValue = 0;
    ; f# c/ P2 _$ h& P6 z
24.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_10);
    5 n8 ]- g  A: _7 R" D, z9 `4 R
25.                                                         HAL_Delay(100);
    ( f# {4 q# Z3 q% @8 D" v8 f# i
26.                                         break;
    
27.                                         case 4:
    
28.                                                         keyValue = 0;
    
29.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_11);
    
30.                                                         HAL_Delay(100);
    * T3 {3 }. M* g* U) |
31.                                         break;
    
32.                                 }
    9 l) L$ f8 E& ^
33.                         }
    
34.                         else
    ) K, T% |" q$ F2 Q' T& E+ h
35.                         {
    7 L9 A8 U* @1 n* g$ I7 G! @
36.                                 switch(keyValue)
    
37.                                 {
    * r+ x" T) K+ l4 N
38.                                         case 5:
      t+ A' ~: r2 T5 M* a% @
39.                                                         keyValue = 0;
    
40.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_15);
    
41.                                                         HAL_Delay(100);
    $ G* S; ?% y8 o/ l* p' J6 z" H
42.                                         break;
    
43.                                         case 6:
    0 b- F: O- Z, o' z
44.                                                         keyValue = 0;
    8 u/ h6 m- F8 \$ l) |3 H
45.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_14);
    ( Q' y; k( v) _7 H
46.                                                         HAL_Delay(100);
    % `2 L; ^# n4 c$ g) T
47.                                         break;
    2 A# a. i& e! g8 {
48.                                         case 7:
      u( G$ d+ a. F2 N' n' O
49.                                                         keyValue = 0;
    
50.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);
    
51.                                                         HAL_Delay(100);
    
52.                                         break;
    / v, M; M5 [6 S6 }; m, V0 H
53.                                         case 8:
    
54.                                                         keyValue = 0;
    . y2 e% v6 y/ I6 L; ]; D
55.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_12);
    
56.                                                         HAL_Delay(100);
    
57.                                         break;
    
58.                                 }
    
59.                         }
    
60.                 }
    6 Q9 w' i3 T' w# Z
61. }
    

复制代码

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



5 S# h% m' U5 X* z7 z( g
# c6 F5 |/ i6 [7 q; V


  L! `1 }! q( Y; A. n
3 h7 o7 k. d5 @* U8 m0 b/ r( O

学习了~~