前言
2 i: d! S# ]$ ^$ i编程开发环境：STM32CubeIDE
按键的单击、双击、长按等在MCU编程中是比较常见且常用的事件，本文章基于STM32来实现，具体思路用在其他MCU也是如此。

2 C1 @# C( {9 b3 ^" u+ G. g+ O8 G8 {具体思路
初始化一个全局标记
' V& N6 A( E" N$ \" H  ]0 s按键中断事件发生后置位标记
; V- n( ^/ P; n3 K1 y1 ^2 Swhile死循环中一直检测这个标记，如果被置位那么进行消抖，然后再次检测连接KEY的IO是否处于按下状态，如是则认为本次按键有效
第一次按键事件有效后，启动定时器定时300ms，在此定时期间内如果有二次按下那么就是双击，如果没有按下，等到300ms定时时间到后读取IO电平，如果处于松开状态那么本次就是单击事件，如果还是按下状态那么就再次启动700定时器，700ms过后再次读取IO电平是否处于按下状态，如是那么就是长按。
工程配置
' j& R6 U4 }5 B" [2 u* y6 n我是使用STM32CUBEMX配置生成的工程，配置按键：

; X& x. z5 @: `9 [' v" t  ?
, c$ J! I  z, }5 g
7 {8 X/ G  I; O3 j7 r( rSTM32的定时器有向上、向下计数模式，向上计数就是从0计数到N然后触发中断，向下计数模式就是倒计时到0，由于我们需要二次启动定时器来检测长按，所以再次配置为向下计数模式，分频为7199，计数3000就是定时300ms：
* p. K: R  k. _# ]$ K" Z


中断配置：
5 e; o' U3 {9 n) M% P' H


: O* O, o/ w* _* a5 h, `代码实现

1. 
   / Z, ^% E* S7 Q5 E  o7 R
2. /*
   6 o3 [' `. `2 l( m
3. * key_state位说明：
   8 x9 P; m8 `2 |) c  B$ Y" q
4. *
     D. N6 j* d7 K) b
5. * bit[15]:按键事件完成标志位
   5 a, ]' A2 S& d* J' x, v$ b
6. * bit[14]:按键中断触发标志位
   : g. I# p  D9 `8 J+ d
7. * bit[13]:长按事件触发需要启动第二次定时器标志位
   ) I* g" n, W& [4 G5 O
8. * bit[12~0]: 按键计数，=1:单击  =2:双击  =3:长按
   
9. */
   
10. __IO uint16_t key_state = 0;
    
11. 
    
12. int __io_putchar(int ch)
    # {! \( p: u5 A$ ?7 Y9 R
13. {
    
14.         HAL_UART_Transmit(&huart1, (uint8_t*) &ch, 1, 100);
    ( S* s" B/ ~3 H( A6 A* @
15.         return ch;
    
16. }
    
17. 
    
18. void TIM4_Stop(void)
    
19. {
    
20.         HAL_TIM_Base_Stop_IT(&htim4);
    
21. }
    / a0 O% s' N+ L' L
22. 
    
23. void TIM4_Start(uint16_t timeout)
    
24. {
    ' W! q4 H/ s5 s1 t6 N
25.         __HAL_TIM_SET_COUNTER(&htim4, timeout);
      W2 ?) Q% V- s3 _
26.         HAL_TIM_Base_Start_IT(&htim4);
    5 Y, `8 N* f& x6 k5 N4 _0 S4 U; Q
27. }
    9 N1 C2 g$ V5 v4 R5 ^
28. 
    * B7 {8 d2 X7 Q0 Q  S+ h* E6 i
29. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    
30. {
    3 a4 f( |* y2 J& E( }4 R4 y
31.         if(htim->Instance == htim4.Instance)
    
32.         {
    6 n! Y$ y1 C8 J/ w4 U; f# d" @
33.                 TIM4_Stop();
    
34.                 if(key_state & 0X2000)    // 如果是700ms的超时
    7 Y1 H; H4 G; R& Y9 v4 o( h
35.                 {
    0 ~  D. ]) T8 [5 _) e* W
36.                         // 再次检测按键如果是按下状态，那么就是长按事件，否则事件无效
      b0 z0 F' n% n8 N% A# h
37.                         if(HAL_GPIO_ReadPin(KEY_GPIO_Port, KEY_Pin) == GPIO_PIN_RESET)
    3 g; x% l7 E6 a, ?. B: H
38.                         {
    
39.                                 key_state = 0X8003;
    
40.                         }else
    ; z4 n% D. M& H( g2 |- _6 a7 T
41.                         {
    ) I+ {8 k, Q, S& K# x7 t& m
42.                                 key_state = 0X8000;
    ; `6 d# C$ @, {  {# c
43.                         }
    9 c; {$ Y# e: ^3 p' C: L
44.                 }
    ) _$ p+ }* \4 T. Q: K( M7 i) u
45.                 else  // 如果是300ms的超时
    2 q! x/ b* `- J8 K
46.                 {
    
47.                          // 300ms时间到再次检测按键状态如果仍处于按下状态，那么就启动700ms的超时，
    
48.                          // 700ms时间到后再次检测按键如果是按下状态，那么就是长按事件了。
    ) H# ]% U& D2 P6 C! N6 L
49.                         if(HAL_GPIO_ReadPin(KEY_GPIO_Port, KEY_Pin) == GPIO_PIN_RESET)  // 按键处于按下状态
    
50.                         {
    
51.                                 key_state |= 0X2000;  // 标记启动了700ms的超时定时
    
52.                                 TIM4_Start(7000);     // 启动700ms超时
    3 v4 s& `) w8 Q; X1 E( R
53.                         }
    * |, u0 x, q( W* C% `
54.                         else  // 按键处于松开状态
    
55.                         {
    9 ~! b3 ~  W7 |0 I" {
56.                                 if((key_state & 0X1FFF) == 1)        // 按键按下计数=1，是单击事件
    - u* h4 T1 ?+ V7 G- G
57.                                 {
    
58.                                         key_state = 0X8001;
    
59.                                 }else if((key_state & 0X1FFF) >= 2)  // 按键按下计数>=2，是双击事件
    
60.                                 {
    
61.                                         key_state = 0X8002;
    ! }; {3 Y) q% G' C
62.                                 }else                                // 按键按下计数为其他值，本次按键事件无效
    $ |6 x8 J. K/ h
63.                                 {
      J7 L" Z9 `: k4 j) U1 e
64.                                         key_state = 0;
    
65.                                 }
    
66.                         }
    $ W. i# n9 A8 Y& h6 C5 K( {0 h
67.                 }
    7 C' L0 r/ a& W& m
68.         }
    
69. }
    
70. 
    
71. void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
    
72. {
    
73.         switch(GPIO_Pin)
    " F1 {4 a+ D/ C6 g9 H1 ~
74.         {
    
75.         case KEY_Pin:
    
76.                 if((key_state & 0X8000) == 0)
    ' s. x3 m, ~( K3 C4 I3 \; A
77.                 {
    7 D3 h/ D6 y' {5 n0 l7 v# x
78.                         key_state |= 0X4000;    // 标记按键中断触发，在while死循环中进行消抖和的启动定时器
    
79.                 }
    # a  t$ j2 ?' R( ?
80.                 break;
    * w& o9 j1 @3 i1 z8 m7 }- p
81.         default:break;
    8 ?7 c0 c9 K) h$ |  Q
82.         }
    / Z2 s; [. C+ d. b& p: v1 P+ F
83. }
    / b. ^2 b6 p# L. z. K
84. 
    7 D' |* x! V: N3 x" i5 K. ?5 x# n
85. int main(void)
    7 y# {( Y# b1 ]* k& y- m
86. {
    
87.         HAL_Init();
    5 a% w5 T" s5 S3 C2 ~6 `) o3 H0 ~
88.         SystemClock_Config();
    ( R. D# R% j% Y% _
89.         MX_GPIO_Init();
    
90.         MX_USART1_UART_Init();
    7 O; c" m8 }" M; e5 S6 W6 t
91.         MX_TIM4_Init();
    
92.         __HAL_TIM_CLEAR_IT(&htim4, TIM_IT_UPDATE);    // STM32的定时器初始化完毕之后如果不清理中断标记为会有直接进入中断的问题
    # ~7 F1 V/ i  s4 M: O2 ?
93. 
    
94.         while (1)
    0 @7 ^3 _2 F0 t8 W! t' T1 R
95.         {
    
96.                 if(key_state & 0X4000)     // 按键中断触发
    + A/ w( a$ |3 R0 p- Q7 u
97.                 {
    6 `( |, C  H- G! x1 w0 ?
98.                         key_state &= ~0x4000;  // 清除事件
      ^! N7 _! a3 a9 \
99.                         HAL_Delay(60);         // 消抖延时
    8 \$ ~3 Y8 a. q! J
100. 
     
101.                         // 消抖完毕之后再次检测按键是否为按下状态，如是则本次按键有效，否则视为无效并清除标识。
     
102.                         if(HAL_GPIO_ReadPin(KEY_GPIO_Port, KEY_Pin) == GPIO_PIN_RESET)
     : m) ]( K. r5 {3 s2 b+ T7 t' ~
103.                         {
     5 K. n+ k3 Y$ f+ Z' j
104.                                 if((key_state & 0X1FFF) == 0)  // 首次按下时启动300ms超时定时器
     
105.                                 {
     : _$ w# i5 Z6 Q' C: |3 T) A
106.                                         TIM4_Start(3000);
     ( |* z! T! r; r  N
107.                                 }
     
108.                                 key_state++;                    // 按键按下计数增加
     9 }, [, P7 @" n+ |
109.                         }
     9 @, b4 x. m, J# S
110.                 }
       V0 o: Z/ O' c$ `$ {
111. 
     $ d! G8 L4 U6 u2 D. b
112.                 if(key_state & 0X8000)  // 按键事件发成了
     
113.                 {
     
114.                         switch(key_state)
     
115.                         {
     
116.                         case 0X8001:
     
117.                                 printf("single\r\n");
     
118.                                 break;
     4 j( y" l  V# ]$ w
119.                         case 0X8002:
     
120.                                 printf("double\r\n");
     3 A6 r. U! F" ]/ @
121.                                 break;
     1 W  o8 O' |  {
122.                         case 0X8003:
     2 \4 v* [. u: @4 {+ y
123.                                 printf("hold\r\n");
     # t; [3 R+ \. N/ G( m
124.                                 break;
     6 T  c2 `6 Z& b2 n9 b
125.                         default:break;
     1 w9 u! U- O) }: Z5 y0 {/ O0 b9 I' |# {
126.                         }
     + p; z, {$ B5 K# ^
127.                         key_state = 0;  // 清除事件
     
128.                 }
     9 a6 K3 U0 k0 P' @; c
129.         }
     # K* u5 r9 C7 ^
130. }
     

复制代码

实验效果
+ _6 w" c& C9 M; x1 s按键单击、双击、长按实验效果如下：
5 {5 \. i) d$ c) G+ O- H; L
8 C! n4 o$ n. a# l