你的浏览器版本过低,可能导致网站不能正常访问!
为了你能正常使用网站功能,请使用这些浏览器。

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

[复制链接]
STMCU-管管 发布时间:2021-6-18 16:44
STM32G4系列MCU学习笔记:按键模块
/ W4 C) B# b/ ]4 h8 d" Z
3 v5 P; `$ n1 c. n: D. h前言! H) _; @7 A, k4 j6 G5 t
我所学过的按键模块有独立按键和矩阵键盘两种,其实两者原理类似,本文主要介绍按键模块中实现长按和短按功能。# R( a, B9 x, z& B7 \: _
注意了:本文是基于HAL库来进行介绍的,如果你想用标准库实现也比较简单,类比移植即可。
  K0 ]+ f4 B& ?/ W* Z* z+ ^由于作者第一次写博客,且自身水平有限,如文中有误,还请大家指正,谢谢~2 H; l4 ]* y0 D: {' f+ p2 l

0 A$ [6 v& q0 O: C* X

+ D9 b* K( A  O先放一张开发板的实物图,它长这样~5 `, D3 E5 [; R  L7 U/ s5 \* Z" I
15.png
一、硬件操作
0 ?2 H4 p  P/ p( ~% p在应用层中我利用不同的点灯程序来区分短按和长按所进行的操作。所以先来看看该模块所设计到的硬件原理图。
" e! T0 T4 h0 p& j- v; v1 G0 U8 n5 H" l
7 u# C' y1 K4 l% H
1. 原理图
" T: Z3 U" ^; f( `' Z- c
14.png
注意了:点灯的这个模块,我们这里忽略这个锁存器芯片,不用它的锁存功能,着重于分析按键模块。
: M4 J' l; U% ~, Q! u
13.png
我们先把所使用到的所有GPIO口列出来:(方便待会儿看程序更加清楚)4 M1 W- w' M9 H) ^: V1 _
1.点灯相关的IO口:PC8,PC9,PC10,PC11,PC12,PC13,PC14,PC15;
2 l+ v6 T0 ~. \/ X) `2.按键相关的IO口:PB0,PB1,PB2,PA0。
. ]+ K. s4 q. L6 ?+ \" L
; |$ _2 T3 f" k6 o
9 V# l4 R3 i' q' c& L" ?1 q4 D
2. 硬件分析
6 K$ j. B$ ~( a5 q  O从原理图里可以发现,我们如果将PB1设置为输入模式,去采集该GPIO上的电平状态,按键松开时,PB1上的电平应该为高电平,当我们按下按键后,例如:B2按键,PB1上的电平就会被拉低,其余按键类似,所以根据这样一个简单原理,即可实现按键的输入检测。& L7 L- U$ S, `+ A: {
  E* w! n1 L& d7 E# c( h+ d
+ s: f; U. D: b2 z) u+ r  i
3. 初始化代码
. V2 y- U6 N( Q2 e# n
  1. /* Reset of all peripherals, Initializes the Flash interface and the Systick. */* D' H* v% `7 w. I5 G+ ~+ U
  2.   HAL_Init();//使用默认配置即可( t" k$ Y& ~. D; E- P1 s$ r
  3.   /* Configure the system clock */! w* p+ y4 {, c8 G
  4.   SystemClock_Config();7 \# i' B0 }" k6 x7 n
  5.   /* Initialize all configured peripherals */6 N7 V5 W) W  {. g  a3 f9 m  e2 E3 \, p
  6.   MX_GPIO_Init();
    6 r& K, x& r# X, e3 |7 Y9 p
复制代码
(1)时钟设置4 e& l6 m/ o7 C- A: h& w
这里我使用的内部时钟源HSI = 16MHz;配置HCLK = PCLK1 = PCLK2 = 80MHz。
0 G( x- ^1 L6 t* G
  1. void SystemClock_Config(void)
      E# p; e$ f* L6 b: p; `
  2. {( l2 I& ~0 H) C! K0 }
  3.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};- g2 t( b' L" |
  4.   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};& P& L; x3 e+ _$ ^' L3 a
  5. $ P2 E7 b, Z7 o2 J7 Q2 y
  6.   /** Configure the main internal regulator output voltage
    . K9 ~6 F! g% Q- g$ t5 J
  7.   */
    ) x+ Y1 T  ?: C
  8.   HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1);2 s6 b+ q+ V& M( `8 v5 S' V! Q" k
  9.   /** Initializes the CPU, AHB and APB busses clocks
      j8 E2 d5 ]; l  A
  10.   */
    , w+ u9 ?- S6 V0 e% F* Z& _
  11.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
    ; i/ N1 W: i+ H  j
  12.   RCC_OscInitStruct.HSIState = RCC_HSI_ON;  g0 L" L  h3 \- ~
  13.   RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
    ! F. S! Q  l& o0 y; t8 ?- ~
  14.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
    + T/ `8 Q# e+ K. Z
  15.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
    , d6 A8 H. D8 j- t) Q% m3 |9 A
  16.   RCC_OscInitStruct.PLL.PLLM = RCC_PLLM_DIV2;
    # R$ X/ {9 e% L$ W3 n0 N
  17.   RCC_OscInitStruct.PLL.PLLN = 20;
    7 d! n1 W. c9 }% B% Z, z9 H
  18.   RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
    8 ?  D6 H  d2 X  g7 u
  19.   RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
    . d' E0 U6 [) X0 r5 n
  20.   RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
    , M8 O8 F: _. k3 n1 F( T5 O
  21.   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
    + V7 w0 G* ^3 H& N* x  S- d  v
  22.   {
    * H/ T" g$ d8 n6 \2 j( m
  23.     Error_Handler();
    1 T: m& Y" L' F
  24.   }2 k% Y6 h. _- o+ ^2 V( J# @: K
  25.   /** Initializes the CPU, AHB and APB busses clocks $ Q: f2 N) b0 Z# d7 B& b$ N
  26.   */; D" j# m% x3 H% N  S# T
  27.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
    : O0 w" Z, x  [4 d: v( |3 I" s
  28.                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;$ X1 Z5 |" c! S. Y, |: i7 i9 x
  29.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;4 o7 F- x: G$ s1 B" n& T
  30.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;( D  V4 ?; Z1 D8 h2 x5 r6 P
  31.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;8 D' f0 s! E4 G) O
  32.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;, [4 I; |0 d+ U& C$ ^6 l! A

  33. 9 L5 S9 K" \6 N
  34.   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_3) != HAL_OK)
      o" K" G, v  a! o" n! P( z
  35.   {. p) z- s9 u" s) m$ K0 ~
  36.     Error_Handler();7 U2 ~' U) f7 p% v* V: a
  37.   }
    + K  r: J1 P6 L6 U8 i
  38. }. J  T* P& L# G: {
复制代码
(2)GPIO初始化
$ o& R, R9 ~5 u; f; [' p
  1. static void MX_GPIO_Init(void)7 D2 s8 I8 J* ]0 J! ?8 ?3 K
  2. {7 O8 Q5 B" \; v" ~1 G
  3.   GPIO_InitTypeDef GPIO_InitStruct = {0};2 h, L4 s( R8 @$ c1 S2 O; w6 b

  4. ( @+ j& q+ _6 C
  5.   /* GPIO Ports Clock Enable */2 m, P8 g+ s& [2 k; C
  6.   __HAL_RCC_GPIOC_CLK_ENABLE();
    , z: D+ d8 {" I8 e5 Y5 T
  7.   __HAL_RCC_GPIOF_CLK_ENABLE();, I' l4 g9 m3 n; c+ o& d' `  M2 a9 C
  8.   __HAL_RCC_GPIOA_CLK_ENABLE();
    ; d" ~3 t  x! z) a
  9.   __HAL_RCC_GPIOB_CLK_ENABLE();1 F( ^1 Z& c" w+ E  _
  10.   __HAL_RCC_GPIOD_CLK_ENABLE();- C1 X5 Y; s7 L6 q: g: E
  11. 9 w- c! H2 B* N4 q
  12.   /*Configure GPIO pin Output Level */
    ; F$ Y3 L3 P( L
  13.   HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15|GPIO_PIN_8
    2 e; i* y& a  N8 K3 O3 a  P% k; W; t
  14.                           |GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12, GPIO_PIN_RESET);* ]7 X4 i  O0 d6 f4 i* m
  15. 8 D1 D' z( z% g+ ^4 {
  16.   /*Configure GPIO pin Output Level */& Z5 y5 k+ D, Q6 O' O4 k
  17.   HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_RESET);; p0 A6 l5 d9 V$ f4 S$ x

  18. + \' A3 }' p7 D, Q1 K8 y2 |' i* o- W
  19.   /*Configure GPIO pins : PC13 PC14 PC15 PC8
    - G9 E8 D" e$ o* J9 A, y3 _$ E% f
  20.                            PC9 PC10 PC11 PC12 */
    5 v: M8 D( F3 R8 _1 h* q
  21.   GPIO_InitStruct.Pin = GPIO_PIN_13|GPIO_PIN_14|GPIO_PIN_15|GPIO_PIN_8 9 l# d5 k' q1 ], `" Z
  22.                           |GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12;
    4 @5 u" V! p, O1 w& B3 Q  ?& h7 Q. i
  23.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    ; k9 O* E8 W$ K  }3 e
  24.   GPIO_InitStruct.Pull = GPIO_NOPULL;
      B; j& p9 z& ?& S" N: ^
  25.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;8 h5 v- _+ [0 Q2 c, h' E
  26.   HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
    * g+ t7 P, Z0 O

  27. : u, w! A/ j$ e6 Z8 I
  28.   /*Configure GPIO pin : PA0 */
    * K2 j/ V6 i, Z
  29.   GPIO_InitStruct.Pin = GPIO_PIN_0;
    " w* ?1 {" ?6 j9 q  i/ L
  30.   GPIO_InitStruct.Mode = GPIO_MODE_INPUT;" Y5 V% k, X5 [2 `
  31.   GPIO_InitStruct.Pull = GPIO_NOPULL;
    0 b; U4 L; l# ^# G6 R: X
  32.   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);1 s% m" f  v: q+ b. w- \8 N* V9 ^
  33. 7 W1 {0 |1 u( i) m7 B. r
  34.   /*Configure GPIO pins : PB0 PB1 PB2 */
    " D1 _' r4 H' Q  h
  35.   GPIO_InitStruct.Pin = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_2;. |# O# G7 d% Z, {4 ~, O2 x
  36.   GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
    + b/ e3 Y- a3 P# ~, t7 }+ r
  37.   GPIO_InitStruct.Pull = GPIO_NOPULL;
    7 g5 L% O' }8 E* a: y; _. M6 S
  38.   HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);5 N) R1 h' k* v4 i

  39. ( R. C; u+ F6 o( }- G; u1 q
  40.   /*Configure GPIO pin : PD2 */
    6 k, z% O9 Z$ q2 M; f
  41.   GPIO_InitStruct.Pin = GPIO_PIN_2;
    7 ^6 {; v" U7 O
  42.   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
    $ C6 ?* B4 a+ N9 _' c
  43.   GPIO_InitStruct.Pull = GPIO_NOPULL;
    8 ?& o" d+ X, O" Y6 i  e4 q; S$ V0 B
  44.   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
    1 S% |4 b4 s0 Y
  45.   HAL_GPIO_Init(GPIOD, &GPIO_InitStruct);
    ; e% y6 o! D& S. P
  46.   F+ F* d' F- W7 H
  47. }. m* a1 d: Y/ n0 E* {& b
复制代码
二、按键模块的驱动层实现' |0 t" ]4 `1 p1 R! n
1. 硬件框图' g- P1 C7 R# ^& p  _: ]3 `! ~
在这里插入图片描述' Y3 k8 D% _3 _$ \
11.png * V) b* K/ \( M2 f7 D1 g
避坑点:6 M$ Q7 u) V" S2 p" f" w
短按:按键释放时判断时间, |+ \7 N) Z" F8 y. ~3 h
长按:直接判断时间
/ D, l8 w- E, C: `( b# A
1 ~' E( {* F) G4 v5 F1 a& S8 O2 `( p1 T
, f  q0 C# q+ }( i0 Q
2. 按键驱动层代码实现, H* y% L3 O% d& Y9 D: x/ `
下面直接上C代码:* v/ m& ]7 N, i! A2 H
0 H. q( a# z% I% w. ]

" N4 {7 U0 l% j5 I2 [(1)key.c
: A/ C/ p9 W  I( F1 y7 m1 B" ?# _4 Y
  1. extern unsigned int keyCount;( K, }8 u- V. b# J& {$ `
  2. extern uint8_t keyValue;
    ; X1 A& K: k$ e5 k2 f  T2 K
  3. uint8_t keyflag = 0;9 {/ y7 d$ F* S
  4. void Key_Scan(void)6 t% N+ f5 n1 P# c* D- d) l: M3 B
  5. {  k, R- z! K1 {) _" x9 {
  6. //keyState  按键状态;" `  d3 L, p2 l# N7 G5 g
  7. //keyPass   记录哪一个按键被按下
    " [; S5 J$ ~& D" v8 \$ Y
  8. //keyCount  记录按键按下时间
    $ ~0 ~1 d0 w  o  Z. |: X
  9. //keyflag   开始计数标志位,方便在Systick中断中进行计时
    ' \( Z; q$ c) D
  10. //keyValue  返回给应用层的键值,用于判断处理相应的事件/ h" f; C: G: ], f/ p
  11. //ShoutKeyx和LongKeyx是两个宏,为了区分短按和长按
    . S7 W% `% H7 y: T
  12. //ShoutKeyx 短按x键值,: _+ \7 c* {% G/ A, r
  13. //LongKeyx        长按x键值+ C+ t# T5 c# J+ T+ H
  14.     static uint8_t keyState = 0,keyPass = 0;
    6 D# G  P7 X9 j- U% y! A  s+ `5 {5 @
  15.     switch(keyState)/ {3 H/ p! u* f7 X% ~" [
  16.     {
    % h8 l, W8 Q% C
  17.         case 0:if(KEYB_1==0||KEYB_2==0||KEYB_3==0||KEYB_4==0)
    1 `8 ?) ]1 v6 E' O& i- A( a
  18.                 {/ m" X( B: a) S
  19.                     HAL_Delay(100);//消抖
    , e; l7 @3 J6 w# G# E
  20.                     keyState = 1;4 E( ]1 |& v) g$ C- ^
  21.                     keyPass = 0xff; //初始化按键
    , d& R4 j, Z+ l5 n
  22.                 }   . q: r$ H' m  K9 E8 l* r1 x
  23.                 break;) U, Z9 i1 Y) t7 g/ }
  24.                     & b. @7 Y* v5 g% d' D5 O& X
  25.         case 1: if(KEYB_1==0||KEYB_2==0||KEYB_3==0||KEYB_4==0)
    ) B& q* d" Q0 ]$ v/ ]
  26.                 {
    3 X7 q: x8 I6 w* T
  27.                     keyState = 2;( d, @1 v) Q1 n8 q3 K1 k; M; s
  28.                     keyflag = 1;//开始计数
    # |* X' X/ J1 p& k) B! `
  29.                     if(KEYB_1==0){
    8 a; s+ {% }0 U6 F& M. ]3 N+ s
  30.                         keyPass = 1;//返回对应键值7 c3 a1 W$ U( T  T) ?( e0 q$ i
  31.                     }   
    ( Y/ \  a" V7 ^# e
  32.                     else if(KEYB_2==0)keyPass = 2;8 x7 W* F2 }6 J- O
  33.                     else if(KEYB_3==0)keyPass = 3;& E" O1 {0 V. n6 x2 B  g8 J
  34.                     else if(KEYB_4==0)keyPass = 4;  k. \1 U: X" ^9 F/ B. ~2 G6 v
  35.                 }   
    ( k9 R  g) F3 G; n9 m, \- E" [
  36.                 else keyState = 0;//返回检测按键      7 M% Q  k& ^) D& b9 C
  37.                   d$ U6 V) r! }' P
  38.                 break;$ H2 x2 k4 g1 ~" V1 j
  39.         case 2:, N- X! X0 \4 ]: U. B) K! u0 c
  40.                 switch(keyPass)
    & }# B; H+ Q. i7 V
  41.                 {              ' H6 y) c" H3 j; ]
  42.                     case 1:if(KEYB_1!=0) //判断是否释放按键* M! Q# K6 M; O8 P, ~+ l: i  ^9 i
  43.                             {. G5 |9 F" U# d: N4 t# k
  44.                                 if((10 < keyCount)&&(keyCount < 800))//短按
    ( e! f7 s4 M- ^) T) W7 F! _: {
  45.                                 {4 U- ^: a# |8 ^0 f! Z$ f" Y5 @
  46.                                     keyCount = 0;
    - C9 }4 K, J: b: c+ @- Z
  47.                                     keyflag = 0;
    % F, E3 T' n  V1 X8 a
  48.                                     keyValue = ShoutKey1;
    9 E3 Q, _, \* H8 O1 s) U2 C) t
  49.                                     keyState = 0;9 P* R5 l! O( Q& B
  50.                                 }   ' K4 C! s8 x. q' P2 a% L6 ~1 G
  51.                             }      
    1 R" Q6 f9 j8 ]9 r( d
  52.                             break;" V$ D1 @9 L4 J/ v( d+ D5 o1 C
  53.                     case 2:if(KEYB_2!=0)1 [* }4 K3 Y0 T6 l5 h( }5 y* L
  54.                             {. N, U- u. P1 `% h9 Y
  55.                                 if((10 < keyCount)&&(keyCount < 800))//短按2 a: E& s* h. h+ i* L# O- A0 _4 B6 p9 R
  56.                                 {
    0 i! i5 C% _% ?4 I1 l
  57.                                     keyCount = 0;# h3 ~4 ~% ?3 m1 @- N, A: q
  58.                                     keyflag = 0;' z; d# q1 @" ^
  59.                                     keyValue = ShoutKey2; / `3 x8 }* o: S. U7 |
  60.                                     keyState = 0;. j- z& l0 C8 `7 o( r  p
  61.                                 }   * A- K# H% s3 K7 l' m5 |
  62.                             }         V* d2 V1 x8 P
  63.                             break;4 ^% ?- _2 r7 q- j& w( e" P* P
  64.                     case 3:if(KEYB_3!=0)
    0 d9 V9 Z! Z8 H" P5 M* }
  65.                             {
    % i" G% V- Q8 u7 a9 |# u
  66.                                 if((10 < keyCount) && (keyCount < 800))//短按% j7 ^1 Q" s0 ^1 f7 C6 {' C+ O
  67.                                 {$ C; o. a9 X+ a6 R6 U1 Z7 e/ k( p
  68.                                     keyCount = 0;
    ) H6 N  P0 d5 ]$ O8 ^# {' _
  69.                                     keyflag = 0;
    9 m* L1 w# _# e) \
  70.                                     keyValue = ShoutKey3; $ D3 e7 i8 }+ h' B1 Q2 p) C
  71.                                     keyState = 0;% a$ ^3 H* w. ^' C3 Z7 `
  72.                                 }   
    - _! l! `+ M! `7 j4 R& e
  73.                             }       5 g3 {1 f# `1 h# m: ^
  74.                             break;
    3 d0 Y4 |( p% c' o0 i
  75.                     case 4:if(KEYB_4!=0)  n0 ?8 I; @2 k) C
  76.                             {
    - B, i0 p/ ]) q6 I2 O5 e8 [1 ^8 q  d
  77.                                 if((10 < keyCount)&&(keyCount < 800))//短按% |: l7 A6 I" R- E- q
  78.                                 {
    + W7 T! g' a0 P
  79.                                     keyCount = 0;
    9 n# @0 ?1 G' D* B6 U4 N
  80.                                     keyflag = 0;
    1 y+ y9 ]& \- F
  81.                                     keyValue = ShoutKey4;
    ! j1 {  u3 N9 B$ J
  82.                                     keyState = 0;
    4 K' \( v# l$ s, J6 m7 {$ q/ Q
  83.                                 }   
    # C7 G0 c. N, `/ K0 h! Z, j) h
  84.                             }$ x2 Q+ E% k! ]  J5 Y
  85.                             break;) v. ?3 k. l4 N$ P9 F! t, Z
  86.                 }8 q- }: ~4 m# e$ a& C/ m
  87.                 if(keyCount > 800)//长按
    9 a8 a: C- z8 S, ~2 |4 ]- M
  88.                 {   
    7 |- C- Z. s5 ^: k4 `' g
  89.                     if(KEYB_1==0)keyValue = LongKey1;
    ) @/ n, h: G; s) D  h# d( g
  90.                     else if(KEYB_2==0)keyValue = LongKey2;
    , T/ A+ n" M2 c8 u/ b1 Q$ h2 e
  91.                     else if(KEYB_3==0)keyValue = LongKey3;
    ! J. j8 P( a. u5 a' }9 K* T% Q0 K
  92.                     else if(KEYB_4==0)keyValue = LongKey4;; k* C9 U0 ~2 I  f
  93. ' |, R& X" H4 ^( Z& U
  94.                     keyState = 3;% Y* ?! q6 a4 J# I
  95.                 }3 H/ `3 x5 i3 ]
  96.                 break;7 u8 V+ @: H) f, W$ T7 y

  97. % R! ?6 P" s1 \; I
  98.         case 3: if(KEYB_1==1&&KEYB_2==1&&KEYB_3==1&&KEYB_4==1): A0 a6 N% Y4 a# K! M, u
  99.                 {5 s' e; ^0 ^5 [' H( g
  100.                     keyCount = 0;- V5 u! T: i5 s* t8 W- Y
  101.                     keyflag = 0;
    3 `: W( g) {% q  v
  102.                     keyState = 0;! t7 V. H* l8 o1 J" E  r
  103.                     keyValue = 0xff;//长按之后释放按键代表不执行操作,就没有键值传出  
    ) I9 y4 B, B/ n- {2 o
  104.                 }% O+ c, \6 V. U8 F8 L0 |
  105.                 + B# S7 s; G  m" \% N% ]
  106.                 break;/ b+ k$ G0 g) |7 }8 h- Z5 C
  107.     }
    9 n$ w* N. E: a1 \8 j* o8 T8 q& \
  108. }" s  I4 Z" s( E3 i1 \  O! q' V
复制代码
(2)key.h
4 f/ I+ y- V. _# r1 ]9 [# Q+ m" N
  1. #ifndef __KEY_H
    1 ?" u, }3 m0 [' [2 P/ {4 }
  2. #define __KEY_H
    ( w8 F' C: E: Y* R" s
  3. #include "stm32g4xx_hal.h") k% _# n$ l; a9 d2 v+ a" _
  4. #define KEYB_1                 HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_0) //PB0
    2 s/ _3 g1 S% W8 `9 E: o: P9 i
  5. #define KEYB_2                 HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1) //PB19 g/ }7 {, b( z% N3 i- p$ Y
  6. #define KEYB_3                 HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2)//PB2- G1 U* W! R1 z5 w
  7. #define KEYB_4                 HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0)//PA0
    * U& Y3 _" H! E$ L
  8. #define ShoutKey1             1% i6 X* R$ h# Y( ^. e7 r7 q) i
  9. #define ShoutKey2                28 A/ b$ G" a! S/ k
  10. #define ShoutKey3                3
    . y% {: ^$ x6 {6 `# [% |1 P
  11. #define ShoutKey4       45 E% U: A, I2 [  ^. N  E
  12. #define LongKey1             5" h, q; }$ M! x& q1 L- ^2 Z
  13. #define LongKey2                6$ K+ ^* ^: P& r. m, Y$ ~7 e
  14. #define LongKey3                76 F. k0 S4 x. T( {& K* K8 V
  15. #define LongKey4        82 u% s1 w; B/ V# r, f; v3 ~
  16. void Key_Scan(void);
    0 g- `  ]' u9 |9 g1 J6 W& |7 V
  17. #endif
    # C5 ~9 C2 M. `* B& n# c
复制代码
3. 计时操作
: ?! F  ]$ Z( S6 X4 J, r我使用Systick写了一个简单的定时中断函数,(触发Systick的定时中断时间是1ms)去处理计时操作,这是为了给按键驱动提供短按和长按的时间,便于在驱动层进行相应的判断,所以我不去深挖Systick模块的细节,本文会用即可,后面再单独来记录学习Systick模块。" m% o7 n3 M+ l
下面直接来看看Systick的中断服务函数叭,很简单,就这么几句~1 n( R2 z+ m+ P
  1. extern uint8_t keyflag;* v! V% g* @: ~4 I) E- B9 U7 B  l
  2. unsigned int keyCount = 0;& v  f' l# {! k- y
  3. void SysTick_Handler(void)% S4 p' ~/ m+ ?; L( C" ~$ Z9 T2 E
  4. {
    * D( b! K* o) O8 y9 o7 Q6 @0 S6 X
  5.   HAL_IncTick(); //这个api是用于HAL库的延时函数HAL_Delay(uint32_t Delay)9 o! E8 a  R. w) `0 v7 w7 F
  6.         if(keyflag == 1) //若有按键按下就开始计时
    9 X7 }' @) L0 a$ P5 r
  7.                 keyCount++;          W! D2 B+ P; A( f9 Z
  8. }# a1 Y/ b9 K/ [8 k* N+ r+ E
复制代码
三、应用层简单逻辑实现6 }1 r0 q* P: T' \/ ^  F
应用层要做的事情在文章开篇其实已经说了,因为逻辑很简单,就是根据长按和短按实现不同的点灯程序,所以直接上代码叭~9 y  s/ @8 U7 f0 K
  1. HAL_GPIO_WritePin(GPIOC, GPIO_PIN_All, GPIO_PIN_SET); //关闭所有灯 . f  ]+ H4 ~6 a8 G
  2. HAL_GPIO_WritePin(GPIOD, GPIO_PIN_2, GPIO_PIN_SET);        //关闭锁存器  T. {- }2 e; E$ W" X' e" i
  3. while (1); X9 i/ l5 @) O; t- ]- {
  4. {
    ; C; p  ^$ `# x/ i$ M" x+ F3 m0 v2 J
  5.                 Key_Scan();: ~& w- }8 h5 u
  6.                 if(keyValue) //有按键按下
    5 F, n, ^. O' H+ `
  7.                 {; h  M: S2 m* v, Z9 P' Z
  8.                         if(keyValue < 5) //短按
    0 |7 i# Z+ |4 ]) E
  9.                         {, H1 e1 L; Q* g% V, U8 V
  10.                                 switch(keyValue)
    . f: R# d5 O& i$ c( J/ _
  11.                                 {
    / l; Z4 V/ P6 O' J8 v2 D. ~
  12.                                         case 1:+ \. T. \# f9 v/ C6 ^# s3 k
  13.                                                         keyValue = 0;
    8 ]$ S; N0 x; o$ G
  14.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_8);
    # u4 M; J! A& T5 N* F
  15.                                                         HAL_Delay(100);
    + i2 \6 ~! C) B+ V
  16.                                         break;: X& ^1 v$ v( X6 W" q
  17.                                         case 2:4 N) M6 _9 w4 |4 a5 r
  18.                                                         keyValue = 0;7 ^; J! p  v  W$ B, I
  19.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_9);
      _+ K2 z$ G' d
  20.                                                         HAL_Delay(100);# \/ M/ m: E% j" B: T
  21.                                         break;& T( K) |3 @  v$ @, O6 A( y
  22.                                         case 3:
    : r' D# _+ h6 ^
  23.                                                         keyValue = 0;
    / f/ v8 F" m, i
  24.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_10);, @8 I% U- Z7 Y  m# N. Q
  25.                                                         HAL_Delay(100);
    7 d  ~  L8 z7 r+ L3 [6 e
  26.                                         break;/ U8 V+ p  q1 M7 ~3 K
  27.                                         case 4:4 Z8 M' o% J" t) C/ d5 w
  28.                                                         keyValue = 0;5 o9 M; `" d# Y+ Y& w
  29.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_11);
    # I% K$ B& e7 w! j2 a" [
  30.                                                         HAL_Delay(100);$ [6 S& b4 e0 J3 Q+ B7 w4 W
  31.                                         break;6 v' Q) E. K7 G5 Z/ A& E
  32.                                 }
    * _' A4 j9 |3 R, i! ^! `4 G  _1 Z2 R
  33.                         }
    5 R3 q* X; I: i7 Q; o* H+ ~4 f
  34.                         else
    ' T3 V& H8 ?# S' O
  35.                         {
    * B' A6 E, H# O' W0 o7 l- B
  36.                                 switch(keyValue)2 q" z) _6 X4 S% N' M
  37.                                 {1 {* n. h% r. w5 b, P3 F
  38.                                         case 5:* N1 n( X, @, T8 u; o# a) T' u
  39.                                                         keyValue = 0;
    " g. d5 a3 O; |3 ?: W& P8 b( q! E
  40.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_15);
    7 B. A* d' P1 @# E$ C
  41.                                                         HAL_Delay(100);
    - _& M! m6 p4 `0 F8 `( e# Z$ t
  42.                                         break;
    ) g, @: [1 d6 A) e6 X( c
  43.                                         case 6:2 M$ Q2 n; ?1 A  T8 y: {6 M
  44.                                                         keyValue = 0;8 M, y$ t: A  x/ i* ~% f0 M4 C
  45.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_14);
    7 T* h& d: o( S6 r/ q
  46.                                                         HAL_Delay(100);% Y5 h* }2 B2 E( ]
  47.                                         break;* ?1 v( W( t1 B' l: U6 E
  48.                                         case 7:( U, D5 F8 r5 v7 w( `4 a1 G3 }1 {
  49.                                                         keyValue = 0;
    ) F: j9 M. c' w
  50.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);
    0 U9 D# j- S; H
  51.                                                         HAL_Delay(100);
    0 c5 o' j1 `6 V3 d* {; c" Z7 t
  52.                                         break;4 |* X4 Z; r" i) R  T- V8 G4 E# J. y
  53.                                         case 8:2 M7 k- K/ W9 J( a) B4 Z
  54.                                                         keyValue = 0;
    - ]9 @8 C2 v* ]
  55.                                                         HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_12);
    # P: ?/ e- t% N% S5 z/ x3 `
  56.                                                         HAL_Delay(100);, N/ B4 @% @' K  r4 K" K
  57.                                         break;
    5 w3 A: [3 B8 t$ |6 e
  58.                                 }9 \  Q6 n0 ?/ q5 I, ]
  59.                         }( C$ |# Q6 ~3 U% O
  60.                 }
    4 r4 r4 ^) A4 Z3 F, p. J$ Q' S) C
  61. }
    4 t' q6 t: v5 W: S( X
复制代码
总结8 G8 y) E; x) z1 T6 K
以上就是今天要讲的内容,本文仅仅简单介绍了MCU里按键的短按和长按功能,希望能对你有所帮助噢~。
& y2 B+ q" U. F5 L! n
0 O7 e- R0 f! j* M

$ C4 \$ u& w: U. |. g; ^( M2 \
, ]- y; h5 S$ J% E( W! q

) j& j1 J6 i; H: {( I8 x% ~  E8 S. A. C% u( Q1 g$ H
& C7 U3 r5 {  v4 q; ?1 B& J
* W2 N" b% B" c( l

" o" \; \$ \6 A0 ^  d+ k& ?& H* p7 |7 _/ z3 x; m
赞 收藏 评论1 发布时间:2021-6-18 16:44

举报

1个回答
landeng 回答时间:2021-6-19 11:09:17
学习了~~9 c2 B7 N: e! x/ t& e

所属标签

相似技术帖

官网相关资源

关于
我们是谁
投资者关系
意法半导体可持续发展举措
创新与技术
意法半导体官网
联系我们
联系ST分支机构
寻找销售人员和分销渠道
社区
媒体中心
活动与培训
隐私策略
隐私策略
Cookies管理
行使您的权利
官方最新发布
人形机器人运动控制、感知与智能配电
半导体创新技术与应用方向
EE架构与软件定义汽车
12V/48V 汽车智能配电(SPD)
区域控制单元(ZCU)与分区架构
关注我们
st-img 微信公众号
st-img 手机版