【蓝桥杯嵌入式】HAL库按键单击、双击、长按综合检测(状态机法)，STM32G431,CT117E-M4

最新推荐文章于 2024-08-19 20:36:46 发布
最新推荐文章于 2024-08-19 20:36:46 发布
阅读量837 收藏 11
点赞数 24
文章标签： 蓝桥杯 stm32 职场和发展 嵌入式硬件 c语言 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74858601/article/details/137649400
版权

在蓝桥杯嵌入式赛题中，按键检测几乎每年都考，考到的概率大概就是  单击 > 长按 > 双击。

按键检测有很多方法，比如阻塞法(Delay)，外部中断法（EXTI），状态机法等等。

下面先来一张图，介绍一下我的思路。（写字很丑，介意勿喷），如果各位有更好的方法或者我的思路或者代码有问题，欢迎大家指正！

我这次用的是定时中断法（状态机）。

图中的 LONG 和  DOUBLE 是宏定义

#define LONG 100     //长按最低时间要求 100表示100*10ms=1000ms=1.0s

#define DOUBLE 30  //双击时间间隔，30表示30*10ms=300ms=0.3s

time1  和 time2是程序中的用来定时的变量。

下面是一些宏定义和定义的变量等。

#define LONG 100
#define DOUBLE 30

enum
{
  KEY_UP,
  KEY_DE,
  KEY_WA
} keys[4];
bool key_state[4];
bool key_singleflag[4];
bool key_longflag[4];
bool key_doubleflag[4];
bool key_period[4] = {0};
int time1 = 0;
int time2 = 0;

下面是key_scan()函数 按键扫描，key_scan()函数到时候要放到定时器回调函数中。

void key_scan(void)
{
  key_state[0] = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_0);
  key_state[1] = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1);
  key_state[2] = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2);
  key_state[3] = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0);
  for (int i = 0; i < 4; i++)
  {
    if (!key_period[i]) // 第一状态
    {
      switch (keys[i])
      {
      case KEY_UP:
        if (key_state[i] == GPIO_PIN_RESET)
        {
          keys[i] = KEY_DE;
        }
        break;
      case KEY_DE:
      {
        if (key_state[i] == GPIO_PIN_RESET)
        {
          keys[i] = KEY_WA;
        }
        else
        {
          keys[i] = KEY_UP;
        }
      }
      break;
      case KEY_WA:
      {
        time1++;
        if (key_state[i] == GPIO_PIN_SET)
        {
          if (time1 <= DOUBLE)
          {
            key_period[i] = 1;
            keys[i] = KEY_UP;
            time1 = 0;
          }
          else if (time1 > DOUBLE && time1 < LONG)
          {
            key_singleflag[i] = 1;
            keys[i] = KEY_UP;
            time1 = 0;
          }
          else if (time1 >= LONG)
          {
            key_longflag[i] = 1;
            keys[i] = KEY_UP;
            time1 = 0;
          }
        }
      }
      break;
      default:
        break;
      }
    }
    if (key_period[i])//第二状态
    {
      if (++time2 <= DOUBLE)
      {
        switch (keys[i])
        {
        case KEY_UP:
        {
          if (key_state[i] == GPIO_PIN_RESET)
          {
            keys[i] = KEY_DE;
          }
        }
        break;
        case KEY_DE:
        {
          if (key_state[i] == GPIO_PIN_RESET)
          {
            keys[i] = KEY_WA;
          }
          else
          {
            keys[i] = KEY_UP;
          }
        }
        break;
        case KEY_WA:
        {
          if (key_state[i] == GPIO_PIN_SET)
          {
            keys[i] = KEY_UP;
            if (time2 <= DOUBLE)
            {
              key_doubleflag[i] = 1;
              time2 = 0;
              key_period[i] = 0;
            }

          }
        }
        break;

        default:
          break;
        }
      }
      else
      {
          keys[i]=KEY_UP;
      if(key_state[i]==GPIO_PIN_SET)
        {
        key_singleflag[i] = 1;
        key_period[i] = 0;
        time2 = 0;
        }
 


      }
    }
  }
}

下面是中断回调函数，我用的是TIM4，PSC=80-1     ARR=10000-1

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
  if(htim->Instance==TIM4)
  {
    key_scan();
  }
}

为了方便大家copy，下面是main.c，为了简便一点，我把所有程序都写在main.c中了


#include "main.h"
#include "tim.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "stdio.h"
#include "lcd.h"
#include "stdbool.h"
#define LONG 100
#define DOUBLE 30

/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */
enum
{
  KEY_UP,
  KEY_DE,
  KEY_WA
} keys[4];
bool key_state[4];
bool key_singleflag[4];
bool key_longflag[4];
bool key_doubleflag[4];
bool key_period[4] = {0};
int time1 = 0;
int time2 = 0;
/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */
void key_scan(void)
{
  key_state[0] = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_0);
  key_state[1] = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_1);
  key_state[2] = HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_2);
  key_state[3] = HAL_GPIO_ReadPin(GPIOA, GPIO_PIN_0);
  for (int i = 0; i < 4; i++)
  {
    if (!key_period[i]) // 第一阶段
    {
      switch (keys[i])
      {
      case KEY_UP:
        if (key_state[i] == GPIO_PIN_RESET)
        {
          keys[i] = KEY_DE;
        }
        break;
      case KEY_DE:
      {
        if (key_state[i] == GPIO_PIN_RESET)
        {
          keys[i] = KEY_WA;
        }
        else
        {
          keys[i] = KEY_UP;
        }
      }
      break;
      case KEY_WA:
      {
        time1++;
        if (key_state[i] == GPIO_PIN_SET)
        {
          if (time1 <= DOUBLE)
          {
            key_period[i] = 1;
            keys[i] = KEY_UP;
            time1 = 0;
          }
          else if (time1 > DOUBLE && time1 < LONG)
          {
            key_singleflag[i] = 1;
            keys[i] = KEY_UP;
            time1 = 0;
          }
          else if (time1 >= LONG)
          {
            key_longflag[i] = 1;
            keys[i] = KEY_UP;
            time1 = 0;
          }
        }
      }
      break;
      default:
        break;
      }
    }
    if (key_period[i])
    {
      if (++time2 <= DOUBLE)
      {
        switch (keys[i])
        {
        case KEY_UP:
        {
          if (key_state[i] == GPIO_PIN_RESET)
          {
            keys[i] = KEY_DE;
          }
        }
        break;
        case KEY_DE:
        {
          if (key_state[i] == GPIO_PIN_RESET)
          {
            keys[i] = KEY_WA;
          }
          else
          {
            keys[i] = KEY_UP;
          }
        }
        break;
        case KEY_WA:
        {
          if (key_state[i] == GPIO_PIN_SET)
          {
            keys[i] = KEY_UP;
            if (time2 <= DOUBLE)
            {
              key_doubleflag[i] = 1;
              time2 = 0;
              key_period[i] = 0;
            }

          }
        }
        break;

        default:
          break;
        }
      }
      else
      {
          keys[i]=KEY_UP;
      if(key_state[i]==GPIO_PIN_SET)
        {
        key_singleflag[i] = 1;
        key_period[i] = 0;
        time2 = 0;
        }
 


      }
    }
  }
}




void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
  if(htim->Instance==TIM4)
  {
    key_scan();
  }
}



char text[20];
/* USER CODE END 0 */

/**
 * @brief  The application entry point.
 * @retval int
 */
int main(void)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_TIM4_Init();
  /* USER CODE BEGIN 2 */
  HAL_TIM_Base_Start_IT(&htim4);
  LCD_Init();
  LCD_SetBackColor(Black);
  LCD_SetTextColor(White);
  LCD_Clear(Black);
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    if(key_doubleflag[0]==1)
    {
      key_doubleflag[0]=0;
      sprintf(text,"KEY_DOUBLE      ");
      LCD_DisplayStringLine(Line0,(uint8_t *)text);


    }
    else  if(key_longflag[0]==1)
{
            key_longflag[0]=0;
      sprintf(text,"KEY_LONG      ");
      LCD_DisplayStringLine(Line0,(uint8_t *)text);
    }
        else  if(key_singleflag[0]==1)
    {
            key_singleflag[0]=0;
  
      sprintf(text,"KEY_SINGLE      ");
      LCD_DisplayStringLine(Line0,(uint8_t *)text);
    }




    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

/**
 * @brief System Clock Configuration
 * @retval None
 */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Configure the main internal regulator output voltage
   */
  HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1);
  /** Initializes the RCC Oscillators according to the specified parameters
   * in the RCC_OscInitTypeDef structure.
   */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = RCC_PLLM_DIV3;
  RCC_OscInitStruct.PLL.PLLN = 20;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
  RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
  RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the CPU, AHB and APB buses clocks
   */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1 | RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
 * @brief  This function is executed in case of error occurrence.
 * @retval None
 */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef USE_FULL_ASSERT
/**
 * @brief  Reports the name of the source file and the source line number
 *         where the assert_param error has occurred.
 * @param  file: pointer to the source file name
 * @param  line: assert_param error line source number
 * @retval None
 */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

实验现象

半导小芯
关注
实现多按键同时按下处理程序C语言
04-12
实现多按键同时按下处理程序C语言，自己项目留存备份，如有需求可下载
STM32按键（单击、双击、长按）
04-22
STM32按键（单击、双击、长按）操作
按键收集单击,双击和长按
最新发布
qq_57484399的博客
08-19 970
在我们生活中, 按键是必不可少的, 不同的电器, 有不同的按键, 但是按键总有不够用的时候, 那么给与一个按键赋予不同的功能,就必不可少了. 一个按键可以通过按下的时间长短和频次, 来定义其类型。一次按键收集， 都是在一个按键收集周期的， 比如500毫秒内， 我要收集一个按键类型， 在500毫秒内，按键按下一次按键， 那么到达500毫秒后， 我们就宣布答案， 此次按键是单击。同理， 在500毫秒内， 如果我们按下了， 两次按键，那么就是双击， 以此类推。那长按呢？
STM32使用HAL库实现按键的单击、双击、长按
^_^
09-19 9080
STM32使用HAL库实现按键的单击、双击、长按 目录STM32使用HAL库实现按键的单击、双击、长按前言具体思路工程配置代码实现实验效果 前言 编程开发环境：STM32CubeIDE         ~~~~~~~~        按键的单击、双击、长按等在MCU编程中是比较常见且常用的事件，本文章基于STM32来实现，具体思路用在其他MCU也是
STM32F407霸天虎HAL库学习笔记——按键检测
weixin_43329283的博客
07-24 1006
根据原理图可知，按键1在**PA0**，按键2在**PC13**，这些按键在没有被按下的时候，GPIO 引脚的输入状态为低电平 (按键所在的电路不通，引脚接地)，当按键按下时，GPIO 引脚的输入状态为高电平 (按键所在的电路导通，引脚接到电源)。只要我们检测引脚的输入电平，即可判断按键是否被按下。.........
【STM32】HAL库-利用状态机检测按键
科昂的博客
03-31 2794
在工程实际开发应用中，一般采用状态机和定时中断相结合的方式来完成按键的检测。 状态机是一个抽象的概念，表示把一个过程抽象为若干个状态之间的转换，这些状态之间存在一定的联系。
蓝桥杯STM32G431RBT6实现按键的单击、双击、长按的识别
m0_74976404的博客
02-23 2592
阅读引言： 是这样， 我也参加了这个第十五届的蓝桥杯，查看竞赛提纲的时候发现有按键的双击识别， 接着我就自己实现了一个按键双击的识别，但是识别效果不是特别理想，偶尔会出现识别不准确的情况，接着我搜索了各种资料，自己按照网上的提示实现了自己的按键识别代码，在这篇文章中将我使用的这两种办法分享给大家， 此外我还拓展了一些比赛之外的知识。-----------这是一个从0开始代识别按键的单击、双击、长按的文章。学习初衷：不仅仅为了比赛！
嵌入式-蓝桥杯STM32G431（HAL库开发）-CT117E学习笔记09：EEPROM
03-08
在嵌入式系统开发中，EEPROM（电可擦除可编程只读存储器...通过实践和学习笔记，你可以深入理解STM32G431如何利用HAL库与I2C接口的EEPROM进行高效、可靠的通信，这对于参与蓝桥杯或其他嵌入式项目都是至关重要的技能。
蓝桥杯嵌入式STM32G431资源包
03-02
【嵌入式STM32G431资源包】是一个专为参加【蓝桥杯】比赛的参赛者设计的学习和实践素材。STM32G431是STMicroelectronics公司推出的一款高性能、低功耗的微控制器，属于STM32家族中的G4系列。这个资源包针对的是...
【蓝桥杯嵌入式】国信长天嵌入式实训平台（CT117E-M4）STM32G431RBT6程序
01-15
包含（LL库HAL库程序24个实例）、STM32G4pack包、芯片资料、产品手册、芯片驱动 实验程序： LED 、KEY 、SYSTICK、USART、 USART、 LCD、ADC、EE、RES、TIM BASE、FRQHAL、DAC 2、国信长天嵌入式资源扩展板原理图 ...
蓝桥杯嵌入式组别新版子-CT117E-M4简介
01-07
CT117E-M4是专为蓝桥杯嵌入式竞赛设计的一款训练板，它提供了丰富的硬件资源供参赛者进行实践和学习。该训练板的核心处理器是STM32G431RBT6，这是一款基于Cortex-M4内核的微控制器，拥有高性能、低功耗的特点。...
第六届蓝桥杯嵌入式组省赛（STM32G431-HAL).zip
03-30
【标题】：“第六届蓝桥杯嵌入式组省赛（STM32G431-HAL)”是一个关于嵌入式系统开发的竞赛项目，重点聚焦于STM32G431系列微控制器，使用了HAL（Hardware Abstraction Layer）驱动库进行编程。蓝桥杯是一项全国性的IT...
基于STM32hal库的按键检测+控制LED亮灭
qq_65105107的博客
04-19 1258
针对WK_UP这种按键电路，按键按下时，单片机的引脚接到VCC，因此在未按下的情况下该引脚的默认电平为低电平，也就是要把IO设置为输入下拉模式。同理，对于K2和K3这种连接方式，对应IO应该配置为输入上拉模式，使得按键未被按下时，引脚处于高电平状态。首先，我们从原理图可以得到三个按键接单片机的引脚分别为PA0、PC15、PA15，所以我们要把这三个引脚配置为GPIO输入模式。两个LED一端接地，另一端分别接单片机的PA8和PD2引脚，所以我们要把这两个引脚配置成GPIO输出模式。
题目：多功能按键设计。利用一个I/O口，接一个按键，实现3功能操作：单击 + 双击 + 长按。
Sun19910114的专栏
12-22 4095
题目：多功能按键设计。利用一个I/O口，接一个按键，实现3功能操作：单击 + 双击 + 长按。 ============================================================================ 用户基本操作定义： 1。短按操作：按键按下，按下时间<1s，属于一次短按操作 2。长按操作：按键按下，按下时间>1s，属于一
HAl库自学笔记（二）——按键检测
weixin_45055933的博客
10-06 1092
说明：上一篇做了LED点亮实验，本篇实验做按键控制LED亮灭。
嵌入式系统中的C语言编程技巧：实现按键检测与响应
SVIPCODE的博客
08-20 428
当按键按下时，GPIO引脚的电平会发生变化，我们可以通过读取引脚状态来检测按键事件。此外，为了确保按键检测的可靠性，我们还可以引入一些延时机制，以避免因按键抖动而导致的误触发。例如，可以在检测到按键按下后进行一段短暂的延时，然后再次检测按键状态，只有连续检测到按键按下两次才认定为有效的按键事件。函数并不是C语言标准库中的函数，它是一个示例函数，用于模拟读取GPIO引脚状态的操作。在实际的嵌入式系统开发中，你需要根据所使用的硬件平台和开发环境，调用相应的函数来读取GPIO引脚状态。如果按键按下，函数返回。
蓝桥杯单片机---独立按键单击、长按、双击检测
HTZS6的博客
02-02 1596
实现蓝桥杯单片机独立按键（支持多个独立按键同时检测）单击、长按和双击状态的检测
蓝桥杯 嵌入式开发 例程 CT117E
04-10
"蓝桥杯 嵌入式开发 例程 CT117E" 提供了一套官方标准的例程，旨在帮助参赛者理解和掌握嵌入式系统的开发技巧，这些例程对于实际操作和比赛应用具有很高的可移植性。 "蓝桥杯"是中国知名的编程竞赛，专注于培养和...
STM32器件包（支持新版蓝桥杯嵌入式开发板） Keil.STM32G4xx-DFP.1.5.0
03-29
STM32器件包是STMicroelectronics为基于ARM Cortex-M4内核的STM32G4系列微控制器设计的开发工具支持包。这个特定的版本，"Keil.STM32G4xx-DFP.1.5.0"，是为了配合最新的蓝桥杯嵌入式开发板而发布的。蓝桥杯是一项...
[蓝桥杯嵌入式]hal库 stm32 独立按键单击、双击、长按识别
qq_64777806的博客
02-20 1097
本文章以蓝桥杯嵌入式开发板为使用案列，使用stm32g431rbt6芯片，使用PB0，PB1，PB2，PA0作为独立按键的输入。3、在需要按键功能的代码文件中引用按键结构体变量Key_Str key[4]，这里我在main.c中引用。代码使用前提要求：需要一个10ms调用的定时器（软件定时器，硬件定时器皆可，精度无要求）2、设置一个10ms调用的中断，这里我使用的1ms定时器4中断配合10ms的计数。使用状态机的方式对4个独立按键进行单机，双击以及长按的识别。以上代码实现了按键的单击，双击，以及长按。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值