STM32按键扫描

外部中断

• 此方法需注意Timer base（也就是HAL_Delay）的优先级，要低于外部中断的优先级，否则会卡死，推荐下面状态机实现的方法。
  

• 上拉输入：
  

1. if (HAL_GPIO_ReadPin(KEY_GPIO_Port, KEY_Pin) == GPIO_PIN_SET) {  // 按下
2.             OSTimeDly(20,OS_OPT_TIME_DLY,&err); // 去抖
3.             if (HAL_GPIO_ReadPin(KEY_GPIO_Port, KEY_Pin) == GPIO_PIN_SET) {
4.                 /* 用户代码 */
5.             }
6.         }

复制代码

• 长按短按：
  

1. if (HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_12) == GPIO_PIN_RESET) {  // 按下
2.         HAL_Delay(20);  // 去抖
3.         if (HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_12) == GPIO_PIN_RESET) {  
4.             HAL_Delay(500);  // 判断长按
5.             if (HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_12) == GPIO_PIN_RESET) {  
6.                 /* 长按 */
7.             }
8.             else {
9.                 /* 短按 */
10.             }
11.         }
12.     }

复制代码

状态机实现多按键短按长按

key.c

1. #include "key.h"
3. #define KEY_NUM 3
4. #define LONG_PRESS_TIME 1000
5. #define DEBOUNCE_TIME 20
7. Key_t keys[KEY_NUM];
9. /**
10. * @brief 初始化按键接口参数
11. */
12. void Key_Init(void)
13. {
14.     keys[0].port = KEY_L_GPIO_Port;
15.     keys[0].pin = KEY_L_Pin;
16.     keys[0].active_level = 1;
17.     keys[0].state = KEY_IDLE;
18.     keys[0].last_level = 0;
20.     keys[1].port = KEY_M_GPIO_Port;
21.     keys[1].pin = KEY_M_Pin;
22.     keys[1].active_level = 0;
23.     keys[1].state = KEY_IDLE;
24.     keys[1].last_level = 1;
26.     keys[2].port = KEY_R_GPIO_Port;
27.     keys[2].pin = KEY_R_Pin;
28.     keys[2].active_level = 0;
29.     keys[2].state = KEY_IDLE;
30.     keys[2].last_level = 1;
31. }
33. /**
34. * @brief 按键扫描函数
35. * @retval result.key_id    按键id
36. * @retval result.event     事件类型
37. */
38. KeyEvent_t Key_Scan(void)
39. {
40.     KeyEvent_t result = {0, KEY_EVENT_NONE};
42.     for(uint8_t i = 0; i < KEY_NUM; i++)
43.     {
44.         bool current_level;
45.         if (HAL_GPIO_ReadPin(keys[i].port, keys[i].pin) == keys[i].active_level)
46.         {
47.             current_level = 1;
48.         }
49.         else current_level = 0;
51.         switch (keys[i].state)
52.         {
53.         case KEY_IDLE:
54.             if (current_level && !keys[i].last_level)
55.             {
56.                 keys[i].state = KEY_PRESSED;
57.                 keys[i].timer = HAL_GetTick();
58.             }
59.             break;
60.            
61.         case KEY_PRESSED:
62.             if (current_level)
63.             {
64.                 if (HAL_GetTick() - keys[i].timer >= DEBOUNCE_TIME)
65.                 {
66.                     keys[i].state = KEY_HOLD;
67.                 }
68.             }
69.             else keys[i].state = KEY_IDLE;
70.             break;
72.         case KEY_HOLD:
73.             if (current_level)
74.             {
75.                 if (HAL_GetTick() - keys[i].timer >= LONG_PRESS_TIME)
76.                 {
77.                     result.key_id = i;
78.                     result.event = KEY_EVENT_LONG;
79.                     keys[i].state = KEY_RELEASED;
80.                     keys[i].last_level = current_level;
81.                     return result;  // 长按事件
82.                 }
83.             }
84.             else
85.             {
86.                 if (HAL_GetTick() - keys[i].timer >= DEBOUNCE_TIME)
87.                 {
88.                     result.key_id = i;
89.                     result.event = KEY_EVENT_SHORT;
90.                     keys[i].state = KEY_IDLE;
91.                     keys[i].last_level = current_level;
92.                     return result;  // 短按事件
93.                 }
94.                 else keys[i].state = KEY_RELEASED;
95.             }
96.             break;
97.         
98.         case KEY_RELEASED:
99.             if (!current_level && (HAL_GetTick() - keys[i].timer >= DEBOUNCE_TIME))
100.             {
101.                 keys[i].state = KEY_IDLE;
102.             }
103.             break;
104.         
105.         
106.         default:
107.             break;
108.         }
109.         keys[i].last_level = current_level;
110.     }
111.     return result;
112. }

复制代码

key.h

1. #ifndef __KEY_H
2. #define __KEY_H
4. #include "main.h"
6. #include <stdbool.h>
8. // 按键状态枚举
9. typedef enum {
10.     KEY_IDLE,      // 空闲
11.     KEY_PRESSED,   // 按下（去抖中）
12.     KEY_HOLD,      // 持续按下
13.     KEY_RELEASED   // 释放（去抖中）
14. } KeyState;
16. // 按键事件枚举
17. typedef enum {
18.     KEY_EVENT_NONE,   // 无事件
19.     KEY_EVENT_SHORT,  // 短按
20.     KEY_EVENT_LONG    // 长按
21. } KeyEvent;
23. // 按键事件返回结构体
24. typedef struct {
25.     uint8_t key_id;   // 按键ID
26.     KeyEvent event;   // 事件类型
27. } KeyEvent_t;
29. // 按键结构体
30. typedef struct {
31.     GPIO_TypeDef* port; // GPIO端口
32.     uint16_t pin;       // GPIO引脚
33.     bool active_level;       // 按下时的有效电平（true: 高电平, false: 低电平）
34.     KeyState state;          // 当前状态
35.     uint32_t timer;          // 计时器
36.     bool last_level;         // 上次电平
37. } Key_t;
39. void Key_Init(void);
40. KeyEvent_t Key_Scan(void);
42. #endif

复制代码

实现方法
在main.c文件中：

1. #include "key.h"
3. KeyEvent_t key;
5. void main(void)
6. {
7.   Key_Init();
8.   while (1)
9.   {
10.     key = Key_Scan();
11.     if (key.event != KEY_EVENT_NONE)
12.     {
13.       switch (key.event)
14.       {
15.       case KEY_EVENT_SHORT:
16.         printf("key %d short press\n", key.key_id);
17.         break;
19.       case KEY_EVENT_LONG:
20.         printf("key %d long press\n", key.key_id);
21.         break;
23.       default:
24.         break;
25.       }
26.     }
27.   }
28. }

复制代码

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

懂技术并乐意极积无私分享的人越来越少。珍惜

感谢分享，下载保存了，貌似很强大