• 蓝桥杯STM32G431RBT6实现按键的单击、双击、长按的识别

    阅读引言： 是这样， 我也参加了这个第十五届的蓝桥杯，查看竞赛提纲的时候发现有按键的双击识别， 接着我就自己实现了一个按键双击的识别，但是识别效果不是特别理想，偶尔会出现识别不准确的情况，接着我搜索了各种资料，自己按照网上的提示实现了自己的按键识别代码，在这篇文章中将我使用的这两种办法分享给大家， 此外我还拓展了一些比赛之外的知识。-----------这是一个从0开始代识别按键的单击、双击、长按的文章。

    目录

    一、基础知识储备

    0.单片机上的按键

    1.识别按键矩阵中具体哪一个按键按下的原理

    2.按键的单击、双击、长按的识别原理

    二、按键的单击、双击、长按识别实验开始

    学习初衷：不仅仅为了比赛！

    一、基础知识储备

    0.单片机上的按键

    在单片机中，按键被用作输入设备，用于接收用户的输入信号。按键通常由一个或多个按钮组成，每个按钮都有一个对应的开关电路。 按键通常分为两种类型：矩阵按键和独立按键。 矩阵按键是一种常见的按键结构，它可以容纳多个按钮。这些按钮被排列成矩阵的形式，每个按钮都有一个行线和一个列线与之连接。在单片机的程序中，通过逐行扫描和逐列扫描的方式来检测按键的状态。当用户按下按钮时，对应的行线和列线会连接，使得单片机可以检测到按键的按下事件。 独立按键是一种单独的按钮，它通常由一个机械开关组成。当用户按下按钮时，按钮会完成一个电路连接，从而触发相应的输入事件。 无论是矩阵按键还是独立按键，它们都可以通过单片机的 GPIO（通用输入输出）引脚连接到单片机上。通过读取相应的 GPIO 引脚状态，单片机可以检测按钮是否被按下。

    在单片机上使用按键时，通常需要注意以下几点：

    1. 防抖动：由于机械开关的非理想性，按键在按下或松开时会出现短暂的抖动，这可能会导致误触发。为了解决这个问题，可以通过硬件电路或软件算法来实现按键防抖动。

    2. 中断或轮询：在处理按键事件时，可以选择使用中断或轮询方式。中断方式利用外部中断引脚，在按键按下或松开时触发中断，并执行相应的处理函数。轮询方式是在主程序中循环检测按键状态，需要定期查询按键的状态。

    3. 按键矩阵的设计：如果使用矩阵按键，需要合理设计按键的布局和连接方式，以便在电路板上实现灵活且经济高效的排布。

    总之，按键是单片机中常见的输入设备，可以通过连接到 GPIO 引脚来实现用户输入的检测和响应。在设计和使用按键时，需要注意防抖动、选择中断或轮询方式以及按键矩阵的设计等因素。

    1.识别按键矩阵中具体哪一个按键按下的原理

    单片机识别矩阵按键的原理是通过行扫描和列扫描的方式来检测按键的状态。下面是一种常见的矩阵按键识别原理：

    1. 按键连接：将矩阵按键的每个按钮连接到单片机的引脚。每个按钮由两个引脚组成，一个连接到行线，一个连接到列线。行线和列线各自连接到单片机的GPIO引脚上。

    2. 行扫描：单片机通过设置行线为输出模式，并将其拉低(或拉高)。这样一来，每次扫描时都只有一行被选中，其余行都处于高电平(或低电平)状态。这样，单片机可以逐行扫描按键状态。

    3. 列扫描：单片机通过设置列线为输入模式，检测列线上的信号状态。当有按键按下时，对应的行线和列线会连接，使得单片机可以检测到按键的按下事件。通过逐列扫描方式，可以检测到所有按键的状态。

    4. 识别按键：单片机通过判断行列上的信号状态来识别按键的按下。当行线为低电平(或高电平)时，单片机读取列线上的信号状态。如果检测到低电平(或高电平)信号，则表示对应的按键被按下。

    5. 按键处理：一旦检测到按键被按下，单片机会触发相应的事件处理程序，根据按键的逻辑关系来执行相应的操作。

    这种行扫描和列扫描的方式允许单片机用较少的引脚来连接多个按键，节省了硬件资源。在软件上，单片机会循环执行行扫描和列扫描，以便不断地检测按键状态。需要注意的是，在行扫描和列扫描的过程中，需要适当加入延时以避免干扰和抖动现象。

    通过这种原理，单片机可以有效地识别矩阵按键的按下情况，并根据实际应用需要来处理相应的事件。

    2.按键的单击、双击、长按的识别原理

    • 方法1

    我们将与按键连接的引脚初始化为输入模式，接着将引脚初始化为高电平，按键按下就能得到这样的波形，当然这只是理论。

    区分单击和长按： 低电平的持续时间， 400-500ms较为合适，可以使用hal库提供的Hal_GetTick()函数获取按键按下和按键松开时候的tick值，接着二者做差，低电平持续的大致时间。

    区分单击和双击： 先获取按键按下低电平的持续时间， 使用这个时间做文章， 这个时间大于500ms视为长按，小于500ms视为短按， 在短按的这个分支里面区分单击和双击，可以阻塞一会200ms，接着在读引脚的电平状态，为低电平，则视为双击，高电平则单击。

    这种方法的缺点： 在阅读引言的位置也给大家提到了， 这是我实现按键双击检测原始版本呢， 实验效果不是特别准确，而且因为有阻塞，倒是实时性变差。

    这种方法的主要代码： 

    1. Key_Press_Event Detec_Key_Event(void)
    2. {
    3. 	uint32_t time_press = 0;
    4. 	uint32_t time_release = 0;
    5. 	
    6. 	if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET) {
    7. 		HAL_Delay(10);
    8. 		if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET) {
    9. 			time_press = HAL_GetTick();
    10. 		}
    11. 		while(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET);
    12. 		time_release = HAL_GetTick();
    13. 	}
    14. 	
    15. 	if(time_release - time_press < 500 && time_release - time_press > 0) { 
    16. 		HAL_Delay(200);
    17. 		if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_RESET) {
    18. 			return DOUBLE_CLICK;
    19. 		} else if(HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0) == GPIO_PIN_SET) {
    20. 			return CLICK;
    21. 		}
    22. 		
    23. 			
    24. 	} else if(time_release - time_press > 500) {
    25. 		return LONG_PRESS;
    26. 	}
    27. 	
    28. 	return NORMAL;
    29. }
    30.  
    31. void Key_Event_Task(void)
    32. {
    33. 	if(uwTick - uwTick_key_event < 200) return;
    34. 	uwTick_key_event = uwTick;
    35. 	
    36. 	Key_Press_Event key_event;
    37. 	
    38. 	key_event = Detec_Key_Event();
    39. 	if(key_event == CLICK) {
    40. 		printf("key is click\n");
    41. 		LCD_DisplayStringLine(Line5, (u8 *)"   click!  ");
    42. 	} else if(key_event == DOUBLE_CLICK) {
    43. 		printf("key is double press\n");
    44. 		LCD_DisplayStringLine(Line5, (u8 *)"   double!  ");
    45. 		HAL_Delay(100);
    46. 	} else if(key_event == LONG_PRESS) {
    47. 		printf("key is long press\n");
    48. 		LCD_DisplayStringLine(Line5, (u8 *)"   long!  ");
    49. 	}
    50. }
    51.  
    52. int main(void)
    53. {
    54.  
    55. 	HAL_Init();
    56. 	SystemClock_Config();
    57. 	
    58. 	/* bsp driver init area */
    59. 	Led_Init();
    60. 	Key_Init();
    61. 	Uart1_Init();
    62. 	Lcd_Pin_Config();
    63. 	Lcd_Base_Config();
    64. 	
    65. 	while (1)
    66. 	{
    67. 		//Led_Task();
    68. 		//Key_Task();
    69. 		Key_Event_Task();
    70. 		Lcd_Display_Task();
    71. 		Uart_Handle_Task();
    72. 	}
    73. }

    二、按键的单击、双击、长按识别实验开始

    兄弟姐妹们，先跟着做，后面涉及到代码的时候在讲解思路，大家就明白了。

    找到按键的原理图，查看需要配置那些引脚

    接着我们还需要初始化一个串口和一个基本定时器

    查看PA9和PA10引脚的复用功能

    初始化usart

    配置一个基本定时器

    好了， 接下来就是代码编写了， 源码在后面

    代码实现思路：

    启动一个计数周期为400ms的定时器，400ms的定时时间一到就进入计数器溢出的ISR，按键第一次按下的时候启动定时器， 定时器的定时时间到了检测按键还是为低电平的话视为长按，接着双击的检测思路就是第一次按键按下之后在400ms的定时期间内检测按键按下的次数， 即可实现按键的双击甚至三击。

    1. #ifndef _KEY_H_
    2. #define _KEY_H_
    3.  
    4. /*
    5. note 1:
    6. 	KEY1: PB0
    7. 	KEY2: PB1
    8. 	KEY3: PB2
    9. 	KEY4: PA0
    10. 	
    11. note 2:
    12. 	定时器的定时周期为400ms
    13. note 3:
    14. 	需要修改的地方to do标记了
    15. */
    16.  
    17. #include 
    18.  
    19. /*to do*/
    20. #define KEY_PORT GPIOB
    21. #define KEY_PIN GPIO_PIN_0
    22.  
    23. extern TIM_HandleTypeDef htim6;
    24.  
    25. typedef enum {
    26. 	KEY_SINGLE,
    27. 	KEY_DOUBLE,
    28. 	KEY_LONG,
    29. 	KEY_NONE
    30. }Key_Event_t;
    31.  
    32.  
    33. /* 这些标志位完全也可以使用位段操作来实现， 节约存储空间，这里嫌麻烦就没做 */
    34. typedef struct {
    35. 	uint8_t fisrt_press_flag;          /* 按键第一次按下的标志位 */
    36. 	uint8_t times;                    /* 存储在一个400ms周期内按键按下的次数 */
    37. 	uint8_t result;                   /* 存储一个400ms周期结束后按键按下的次数 */
    38. 	uint8_t limit_increase;           /* 防止按键长按的时候times一直增加 */
    39. 	uint16_t press_tick;              /* 存储按键按下时的tick值 */
    40. 	uint16_t release_tick;            /* 存储按键释放时的tick值 */
    41. 	uint8_t long_flag;               /* 按键为长按的标志位 */
    42. }Detect_Ket_t; 
    43.  
    44.  
    45. void Key_Scanf(void);
    46. Key_Event_t Get_Key_State(void);
    47.  
    48.  
    49.  
    50.  
    51.  
    52. #endif

    1. /* key.c */
    2. #include "main.h"
    3. #include "key.h"
    4.  
    5. Detect_Ket_t key_meta;
    6.  
    7. void Key_Scanf(void)
    8. {
    9. 	if(HAL_GPIO_ReadPin(KEY_PORT, KEY_PIN) == GPIO_PIN_RESET && key_meta.limit_increase == 1) {
    10. 		key_meta.press_tick = HAL_GetTick();
    11. 		if(key_meta.fisrt_press_flag == 0) {
    12. 			HAL_TIM_Base_Start_IT(&htim6);
    13. 			key_meta.fisrt_press_flag = 1;
    14. 			while(HAL_GPIO_ReadPin(KEY_PORT, KEY_PIN) == GPIO_PIN_RESET);
    15. 			key_meta.release_tick = HAL_GetTick();
    16. 			if(key_meta.release_tick - key_meta.press_tick < 500) {
    17. 				key_meta.times = 1;
    18. 			}
    19. 		} else if(key_meta.fisrt_press_flag == 1) {
    20. 			if(HAL_GPIO_ReadPin(KEY_PORT, KEY_PIN) == GPIO_PIN_RESET) {
    21. 				key_meta.times++;
    22. 			}
    23. 		}
    24. 		key_meta.limit_increase = 0;
    25. 	} else if(HAL_GPIO_ReadPin(KEY_PORT, KEY_PIN) == GPIO_PIN_SET) {
    26. 		key_meta.limit_increase = 1;
    27. 	}
    28. }
    29.  
    30. Key_Event_t Get_Key_State(void)
    31. {
    32. 	if(key_meta.result == 1 && key_meta.long_flag != 1) {
    33. 		key_meta.result = 0;
    34. 		key_meta.press_tick = 0;
    35. 		key_meta.release_tick = 0;
    36. 		return KEY_SINGLE;
    37. 	} else if(key_meta.result >= 2) {
    38. 		key_meta.result = 0;
    39. 		key_meta.press_tick = 0;
    40. 		key_meta.release_tick = 0;
    41. 		return KEY_DOUBLE;
    42. 	} else if(key_meta.long_flag == 1) {
    43. 		key_meta.long_flag = 0;
    44. 		key_meta.press_tick = 0;
    45. 		key_meta.release_tick = 0;
    46. 		return KEY_LONG;
    47. 	}
    48. 	
    49. 	return KEY_NONE;
    50. }
    51.  

    1. /* main.c */
    2. #include "main.h"
    3. #include "tim.h"
    4. #include "usart.h"
    5. #include "gpio.h"
    6. #include 
    7. #include "key.h"
    8.  
    9. extern Detect_Ket_t key_meta;
    10.    
    11. void SystemClock_Config(void);
    12.  
    13. int fputc(int ch, FILE *fp)
    14. {
    15. 	while((USART1->ISR & (1 << 7)) == 0);         /* uart的发送数据寄存器不为空的时候等待 */
    16. 	USART1->TDR = ch;
    17. 	
    18. 	return ch;
    19. }
    20.  
    21. void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
    22. {
    23. 	if(htim->Instance == TIM6) {
    24. 		if(HAL_GPIO_ReadPin(KEY_PORT, KEY_PIN) == GPIO_PIN_RESET) {
    25. 			key_meta.long_flag = 1;
    26. 			return ;
    27. 		}
    28. 		key_meta.result = key_meta.times;
    29. 		key_meta.times = 0;
    30. 		key_meta.fisrt_press_flag = 0;
    31. 		HAL_TIM_Base_Stop_IT(&htim6);
    32. 	}
    33. }
    34.  
    35.  
    36. int main(void)
    37. {
    38. 	
    39. 	Key_Event_t ret;
    40. 	
    41. 	
    42. 	HAL_Init();
    43.  
    44. 	SystemClock_Config();
    45.  
    46. 	MX_GPIO_Init();
    47. 	MX_TIM6_Init();
    48. 	MX_USART1_UART_Init();
    49. 	
    50.  
    51.     /* 先清除计数器溢出中断，这个为默认是置位的，不信大家可以不写这句，按下按键回先打印long         
    52.        press
    53.     */
    54. 	__HAL_TIM_CLEAR_IT(&htim6, TIM_IT_UPDATE);
    55.  
    56. 	while (1)
    57. 	{
    58. 		Key_Scanf();
    59. 		ret = Get_Key_State();
    60. 		switch(ret) {
    61. 			case KEY_SINGLE:
    62. 				printf("single press\n");
    63. 				break;
    64. 			case KEY_DOUBLE:
    65. 				printf("double press\n");
    66. 				break;
    67. 			case KEY_LONG:
    68. 				printf("long press\n");
    69. 				break;
    70. 			case KEY_NONE:
    71. 				break;
    72. 			default:
    73. 				break;
    74. 		}
    75. 		
    76. 		
    77. 	}
    78. }
    79.  
    80. /**
    81.   * @brief System Clock Configuration
    82.   * @retval None
    83.   */
    84. void SystemClock_Config(void)
    85. {
    86.   RCC_OscInitTypeDef RCC_OscInitStruct = {0};
    87.   RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
    88.  
    89.   /** Configure the main internal regulator output voltage
    90.   */
    91.   HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1);
    92.  
    93.   /** Initializes the RCC Oscillators according to the specified parameters
    94.   * in the RCC_OscInitTypeDef structure.
    95.   */
    96.   RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
    97.   RCC_OscInitStruct.HSEState = RCC_HSE_ON;
    98.   RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
    99.   RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
    100.   RCC_OscInitStruct.PLL.PLLM = RCC_PLLM_DIV3;
    101.   RCC_OscInitStruct.PLL.PLLN = 20;
    102.   RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
    103.   RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
    104.   RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
    105.   if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
    106.   {
    107.     Error_Handler();
    108.   }
    109.  
    110.   /** Initializes the CPU, AHB and APB buses clocks
    111.   */
    112.   RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
    113.                               |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
    114.   RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
    115.   RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
    116.   RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
    117.   RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
    118.  
    119.   if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
    120.   {
    121.     Error_Handler();
    122.   }
    123. }
    124.  
    125. /* USER CODE BEGIN 4 */
    126.  
    127. /* USER CODE END 4 */
    128.  
    129. /**
    130.   * @brief  This function is executed in case of error occurrence.
    131.   * @retval None
    132.   */
    133. void Error_Handler(void)
    134. {
    135.   /* USER CODE BEGIN Error_Handler_Debug */
    136.   /* User can add his own implementation to report the HAL error return state */
    137.   __disable_irq();
    138.   while (1)
    139.   {
    140.   }
    141.   /* USER CODE END Error_Handler_Debug */
    142. }
    143.  
    144. #ifdef  USE_FULL_ASSERT
    145. /**
    146.   * @brief  Reports the name of the source file and the source line number
    147.   *         where the assert_param error has occurred.
    148.   * @param  file: pointer to the source file name
    149.   * @param  line: assert_param error line source number
    150.   * @retval None
    151.   */
    152. void assert_failed(uint8_t *file, uint32_t line)
    153. {
    154.   /* USER CODE BEGIN 6 */
    155.   /* User can add his own implementation to report the file name and line number,
    156.      ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
    157.   /* USER CODE END 6 */
    158. }
    159. #endif /* USE_FULL_ASSERT */

    实验结果

  • 相关阅读:
    爬虫（9） - Scrapy框架(1) | Scrapy 异步网络爬虫框架
    21李沐动手学深度学习v2/读写文件，加载和保存张量
    概率论的学习和整理--番外5：等差数列，等比数列求和，以及其他数列之和。
    超详细关于JSR303服务端校验&&拦截器入门到案例使用
    【ESP32_8266_WiFi (十一)】通过JSON实现物联网数据通讯
    gorm查询结果集如何匹配数据字典对应的名称
    关于 Android 没有文件存储权限保存文件的问题
    【Redis】# 常见报错Unsatisfied dependency、设置密码、主从配置
    3 Prim算法的设计--来源舒姐
    FusionCharts Suite XT v3.19 Crack
  • 原文地址：https://blog.csdn.net/m0_74976404/article/details/136248894