STM32利用状态机实现按键消抖、单击、双击、长按

已于 2024-09-10 23:52:41 修改
阅读量200 收藏 1
点赞数 3
文章标签： 单片机 stm32 c语言
于 2024-09-10 22:50:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2402_83561731/article/details/142111220
版权

一、整体思路

 算法思路整理：不断扫描引脚电平（松开为1，按下为0），每一次按键状态改变后都会记录该状态持续的时间，并且重新计时以确保下一次状态改变后的时间记录的真实性。当按键松开后延时一段时间确保按键状态不会再次改变后对上一次的操作进行判断，判断的依据就是每一次状态持续的时间

二、定时器配置

头文件

#ifndef User_Timer_H
#define User_Timer_H

/* Precondition */
#include "stm32f10x.h"                  // Device header
#include "stdio.h"
#include "stdint.h"

#ifdef __cplusplus
extern "C" {
#endif
#ifndef TARGET_GLOBAL
    #define TARGET_EXT extern
#else
    #define TARGET_EXT
#endif
/* Predefine */
#define Timer_Obj				TIM2
#define Timer_Period			50000			//25s		
#define Timer_Prescaler			36000-1			//0.5ms
#define Timer_CounterMode		TIM_CounterMode_Up
#define Timer_ClockDivision		0
/* Enumeration Declaration */
TARGET_EXT enum
{
	Timer_isBusy,
	Timer_isFree
}Timer_state;
/* Function Declaration */
TARGET_EXT void User_Timer_functionConfigure();
TARGET_EXT void User_Timer_eventConfigure();
TARGET_EXT void User_Timer_pinConfigure();
TARGET_EXT void User_Timer_Initial();	

	
	
	
#ifdef __cplusplus
}
#endif
#endif

源文件

#include "User_Timer.h"

void User_Timer_functionConfigure()
{
	//Initialization structure define.
	TIM_TimeBaseInitTypeDef Timer_timeBaseInit;
	//Initialization structure assignment.
	Timer_timeBaseInit.TIM_Period =Timer_Period;
	Timer_timeBaseInit.TIM_Prescaler=Timer_Prescaler;
	Timer_timeBaseInit.TIM_CounterMode=Timer_CounterMode;
	Timer_timeBaseInit.TIM_ClockDivision=Timer_ClockDivision;
	//Select source of clock.
	TIM_InternalClockConfig(Timer_Obj);
	//Configure the time base of Timer.	
	TIM_TimeBaseInit(Timer_Obj,&Timer_timeBaseInit);
	//Enable or disable the timer.
	TIM_Cmd(Timer_Obj,ENABLE);
}

void User_Timer_eventConfigure()
{

}

void User_Timer_pinConfigure()
{
	
}

void User_Timer_Initial()
{
	TIM2->CNT=0;
	Timer_state=Timer_isFree;
}

三、按键GPIO配置

头文件

#ifndef User_Timer_H
#define User_Timer_H

/* Precondition */
#include "stm32f10x.h"                  // Device header
#include "stdio.h"
#include "stdint.h"

#ifdef __cplusplus
extern "C" {
#endif
#ifndef TARGET_GLOBAL
    #define TARGET_EXT extern
#else
    #define TARGET_EXT
#endif
/* Predefine */
#define Timer_Obj				TIM2
#define Timer_Period			50000			//25s		
#define Timer_Prescaler			36000-1			//0.5ms
#define Timer_CounterMode		TIM_CounterMode_Up
#define Timer_ClockDivision		0
/* Enumeration Declaration */
TARGET_EXT enum
{
	Timer_isBusy,
	Timer_isFree
}Timer_state;
/* Function Declaration */
TARGET_EXT void User_Timer_functionConfigure();
TARGET_EXT void User_Timer_eventConfigure();
TARGET_EXT void User_Timer_pinConfigure();
TARGET_EXT void User_Timer_Initial();	

	
	
	
#ifdef __cplusplus
}
#endif
#endif

源文件

#include "KEY_GPIO.h"

void KEY_GPIO_functionConfigure()
{
	//Initialize structure definition.
	GPIO_InitTypeDef KEY_GPIO_Configure;
	//Initialize structure assignment.
	KEY_GPIO_Configure.GPIO_Pin   =KEY_GPIO_Pin;
	KEY_GPIO_Configure.GPIO_Mode  =KEY_GPIO_Mode;
	KEY_GPIO_Configure.GPIO_Speed =KEY_GPIO_Speed;
	//Configure the GPIO of KEY.
	GPIO_Init(KEY_Obj,&KEY_GPIO_Configure);
}

void KEY_GPIO_eventConfigure()
{

}

void KEY_GPIO_pinConfigure()
{

}

void KEY_GPIO_Initial()
{
	GPIO_SetBits(KEY_Obj,KEY_GPIO_Pin);
	KEY_SM.KEY_state=KEY_state_Free;
	
}

四、状态机实现

头文件

#ifndef KEY_H
#define KEY_H

/* Precondition */
#include "Configure_Device.h"                  // Device header

#ifdef __cplusplus
extern "C" {
#endif
#ifndef TARGET_GLOBAL
    #define TARGET_EXT extern
#else
    #define TARGET_EXT
#endif
/* Function Declaration */	
TARGET_EXT void KEY_stateMachine();
	
	
	
	
	
#ifdef __cplusplus
}
#endif
#endif

源文件

#include "KEY.h"

/*
	@name  :KEY_stateMachine
	@brief :Scan the state of the key using the method of the state machine.
	@param :None.
	@retval:None.
*/
void KEY_stateMachine()
{
	static uint8_t click_isDouble=0;
	uint16_t key_value;
	uint16_t timer_getTime;
	uint16_t High_stableTime=0;
	
	key_value=GPIO_ReadInputDataBit(KEY_Obj,KEY_GPIO_Pin);
	
	switch(KEY_SM.KEY_state)
	{
		case KEY_state_Free:
		{
			if(key_value==0)
			{
				KEY_SM.KEY_state=KEY_state_Unknow;
				KEY_SM.KEY_getHighTime=TIM_GetCounter(Timer_Obj);
				
				Timer_Obj->CNT=0;
			}
			
			High_stableTime=TIM_GetCounter(Timer_Obj);	
			
			break;
		}
		
		case KEY_state_Unknow:
		{	
			timer_getTime=TIM_GetCounter(Timer_Obj);
			if(timer_getTime>=15 && key_value==0)
			{
				KEY_SM.KEY_state=KEY_state_Pressed;
				
				Timer_Obj->CNT=0;
			}
			
			if(timer_getTime>=15 && key_value==1)
			{
				KEY_SM.KEY_state=KEY_state_Free;
				
				Timer_Obj->CNT=0;
			}
				
			break;
		}
		
		case KEY_state_Pressed:
		{
			if(key_value==1)
			{
				KEY_SM.KEY_state=KEY_state_Unknow;
				KEY_SM.KEY_getLowTime=TIM_GetCounter(Timer_Obj);
				
				Timer_Obj->CNT=0;
			}	
			
			break;
		}
		
		default:
		{
			break;
		}
	}
	
	if(KEY_SM.KEY_state==KEY_state_Free && High_stableTime>=200)
	{
		if(KEY_SM.KEY_getHighTime>=100 && KEY_SM.KEY_getHighTime<=200)
		{
			KEY_SM.KEY_clickMode=KEY_click_Double;
			click_isDouble=1;
		}
		else
		{
			click_isDouble=0;
		}
		
		if(KEY_SM.KEY_getLowTime>1500 && click_isDouble==0)
		{
			KEY_SM.KEY_clickMode=KEY_click_Long;
		}
		
		if(KEY_SM.KEY_getLowTime<=1500 && click_isDouble==0)
		{
			KEY_SM.KEY_clickMode=KEY_click_One;
		}
	}
}

代码解释

/*
	按键引脚松开状态为1，按下状态为0
*/
void KEY_stateMachine()
{
	static uint8_t click_isDouble=0;     //该变量用于对双击的判断，如果系统已经认为是双击就不会对单击和长按进行判断        
	uint16_t key_value;			//该变量用于实时探测按键引脚当前状态
	uint16_t timer_getTime;		//该变量用于按键在未知状态时对定时器计数值的读取
	uint16_t High_stableTime;	/*该变量用于按键稳定松开后对松开时间的记录（其实就是利用定时器进行延时，下文会解释）*/
	
	key_value=GPIO_ReadInputDataBit(KEY_Obj,KEY_GPIO_Pin);     //实时更新按键引脚的状态

	switch(KEY_SM.KEY_state)
	{
		case KEY_state_Free:                                             //按键处于松开状态
		{
			if(key_value==0)					//如果检测到按键引脚为0（此时不确定按键是否真的被按下）
			{
				KEY_SM.KEY_state=KEY_state_Unknow;    //跳转到未知状态
				KEY_SM.KEY_getHighTime=TIM_GetCounter(Timer_Obj);   //获取高电平时间（也就是松开的时间）
				
				Timer_Obj->CNT=0;         //定时器清零，重新计时
			}

			High_stableTime=TIM_GetCounter(Timer_Obj);      /*当按键松开且状态未变时读取计时器时间，后续用于延时*/
			}
			
			break;
		}
			
		case KEY_state_Unknow:					//未知状态
		{	
			timer_getTime=TIM_GetCounter(Timer_Obj);     /*当按键在按下和松开的状态改变后都会重新计时，读取时间*/
			if(timer_getTime>=15 && key_value==0)   /*延时15ms消抖，再次判断引脚电平，若还是0那就确定了按键被按下*/
			{
				KEY_SM.KEY_state=KEY_state_Pressed; //跳转到按下状态
				
				Timer_Obj->CNT=0;//重新计时
			}
			
			if(timer_getTime>=15 && key_value==1)  //延时15ms消抖，若电平为1，返回松开状态
			{
				KEY_SM.KEY_state=KEY_state_Free;
				
				Timer_Obj->CNT=0;//重新计时
			}
				
			break;
		}
		
		case KEY_state_Pressed:              //松开状态
		{
			if(key_value==1)             //若引脚电平变化
			{
				KEY_SM.KEY_state=KEY_state_Unknow;     //跳转到未知状态
				KEY_SM.KEY_getLowTime=TIM_GetCounter(Timer_Obj);  //获取按下按键持续的时间
				
				Timer_Obj->CNT=0;//重新计时
			}	
			
			break;
		}
		
		default:
		{
			break;
		}
	}
	
/*
	接下来进行单击、双击、长按的判断
*/
/*
KEY_SM.KEY_state==KEY_state_Free && timer_getTime1>=300：当按键松开后并且延时一定的时间后进行单机、双击、长按的判断。
为什么要延时？
答：如果不进行延时，就会发现在进行判断的时候无论是双击还是长按，在你按下按键的一瞬间都会被判定为单击然后才会被跳转到正确的状态。延时的目的就是按下按键后先等一会，确定你接下来不会再进行别的操作了CPU再进行判断。这个延时时间取决于设定的双击间隔（也就是第一次按下和第二次按下，两次按下间的时间间隔）
*/
	if(KEY_SM.KEY_state==KEY_state_Free && High_stableTime>=300)
	{
/*第一次按下和第二次按下间隔时间在100-300ms时判定为双击。经过调试发现这个数据是比较贴近人手双击速度的，低于100ms后手速基本达不到，高于300ms后需要延时的时间就会比较长，实时性太差*/
		if(KEY_SM.KEY_getHighTime>=100 && KEY_SM.KEY_getHighTime<=300)     
		{
			KEY_SM.KEY_clickMode=KEY_click_Double;
			click_isDouble=1;        //已经判定为双击
		}
		else
		{
			click_isDouble=0;      //未被判定为双击
		}
		 /*按下持续时间低于1500ms并且未被判定为双击的情况下判定为单击*/
		if(KEY_SM.KEY_getLowTime>1500 && click_isDouble==0)       
		{
			KEY_SM.KEY_clickMode=KEY_click_Long;
		}
		
		if(KEY_SM.KEY_getLowTime<=1500 && click_isDouble==0)     //同上，否则为长按
		{
			KEY_SM.KEY_clickMode=KEY_click_One;
		}
	}
}

五、测试

头文件

#ifndef main_H
#define main_H

/* Precondition */
#include "Application_Device.h"      //上面写的头文件都包含在这个里面了

/* Function Declaration */
void Initial_Operation(void);
void KEY_Test();	
void Timer_Test();	
	
	
	
	

#endif

源文件

随便点个灯测试一下

/* Predefine */
#define TARGET_GLOBAL
/* Precondition */
#include "main.h"

int main()
{
	Initial_Operation();
	
	while(1)
	{	
		//KEY_Test();    
		//Timer_Test();
		KEY_stateMachine();
		
		switch(KEY_SM.KEY_clickMode)
		{
			case KEY_click_One:
			{
				LED_on(LED1_GPIO_Pin);
				LED_off(LED2_GPIO_Pin);
				break;
			}
			
			case KEY_click_Double:
			{
				LED_off(LED1_GPIO_Pin);
				LED_on(LED2_GPIO_Pin);
				break;
			}
			
			case KEY_click_Long:
			{
				LED_on(LED1_GPIO_Pin);
				LED_on(LED2_GPIO_Pin);
			}
			
			default:break;
		}
	}
	
}

/*
	@brief:Perform initialization operation.
*/
void Initial_Operation(void)
{
	//User System.
	User_System_functionConfigure();
	User_System_eventConfigure();
	User_System_pinConfigure();
	User_System_Initial();
	//LED GPIO.
	LED_GPIO_functionConfigure();
	LED_GPIO_eventConfigure();
	LED_GPIO_pinConfigure();
	LED_GPIO_Initial();
	//KEY GPIO.
	KEY_GPIO_functionConfigure();
	KEY_GPIO_eventConfigure();
	KEY_GPIO_pinConfigure();
	KEY_GPIO_Initial();
	//User Timer
	User_Timer_functionConfigure();
	User_Timer_eventConfigure();
	User_Timer_pinConfigure();
	User_Timer_Initial();
}

六、日志

2024-9-8  23：25
方案：
	1.按键扫描
	原方案：在主函数里对按键状态进行扫描，当发现按键按下后再利用状态机的方式进行按键消抖。但后来发现如果扫描速度过快，在按键状态稳定时当前状态会被重复读取（特指按键被按下后那一段稳定时间，约为80ms）。
	改进方案：利用开关语句对按键扫描的速度进行限制。但经过调试这个方案被废除，因为开关语句的判断数值的选定较难，并且随着后续代码的增加，这个数值也需要不断地修改。
	改进方案：原方案为了节省单片机的外设资源没有使用外部中断，但在实际的开发中很难较精确捕获到按键状态的改变，所以兜兜转转又回到了外部中断上，本次方案决定使用外部中断捕获按键状态的改变，并在外部中断里打开状态机的开关。在主函数里对状态机的开关状态不断扫描，如果发现状态机开启则跳转到状态机实现函数对按键进行消抖获得按键最终的状态

2024-9-9  22：03
昨天思路完全错误，全部推倒重来

2024-9-10 21：22
经历九九八十一难，终于得到了在只用一个定时器的前提下利用状态机实现按键的消抖、单击、双击、长按的较优解。下面对算法思路进行整理

代码如下：
/*
	按键引脚松开状态为1，按下状态为0
*/
void KEY_stateMachine()
{
	static uint8_t click_isDouble=0;     //该变量用于对双击的判断，如果系统已经认为是双击就不会对单击和长按进行判断        
	uint16_t key_value;			//该变量用于实时探测按键引脚当前状态
	uint16_t timer_getTime;		//该变量用于按键在未知状态时对定时器计数值的读取
	uint16_t timer_getTime1;	  //该变量用于按键稳定松开后对松开时间的记录（其实就是利用定时器进行延时，下文会解释）
	
	key_value=GPIO_ReadInputDataBit(KEY_Obj,KEY_GPIO_Pin);     //实时更新按键引脚的状态
	w=TIM_GetCounter(Timer_Obj);						
	/*
	上面这个W的存在是一个玄学问题，这是一个全局变量，在代码初期用来观测定时器是否正常工作的，在后来的代码里没有	用到这个w。但在整个代码写完后玄学问题出现了，如果我把这个w注释掉，上面那个用来延时的变量就不起作用了，目前还	没有搞清原因在哪里。
	*/

	switch(KEY_SM.KEY_state)
	{
		case KEY_state_Free:                                             //按键处于松开状态
		{
			if(key_value==0)					//如果检测到按键引脚为0（此时不确定按键是否真的被按下）
			{
				KEY_SM.KEY_state=KEY_state_Unknow;    //跳转到未知状态
				KEY_SM.KEY_getHighTime=TIM_GetCounter(Timer_Obj);   //获取高电平时间（也就是松开的时间）
				
				Timer_Obj->CNT=0;         //定时器清零，重新计时
			}
			else
			{
				timer_getTime1=TIM_GetCounter(Timer_Obj);      //当按键松开且状态未变时读取计时器时间，后续用于延时
			}
			
			break;
		}
			
		case KEY_state_Unknow:					//未知状态
		{	
			timer_getTime=TIM_GetCounter(Timer_Obj);     //当按键在按下和松开的状态改变后都会重新计时，读取时间
			if(timer_getTime>=15 && key_value==0)   //延时15ms消抖，再次判断引脚电平，若还是0那就确定了按键被按下
			{
				KEY_SM.KEY_state=KEY_state_Pressed; //跳转到按下状态
				
				Timer_Obj->CNT=0;//重新计时
			}
			
			if(timer_getTime>=15 && key_value==1)  //延时15ms消抖，若电平为1，返回松开状态
			{
				KEY_SM.KEY_state=KEY_state_Free;
				
				Timer_Obj->CNT=0;//重新计时
			}
				
			break;
		}
		
		case KEY_state_Pressed:              //松开状态
		{
			if(key_value==1)             //若引脚电平变化
			{
				KEY_SM.KEY_state=KEY_state_Unknow;     //跳转到未知状态
				KEY_SM.KEY_getLowTime=TIM_GetCounter(Timer_Obj);  //获取按下按键持续的时间
				
				Timer_Obj->CNT=0;//重新计时
			}	
			
			break;
		}
		
		default:
		{
			break;
		}
	}
	
/*
	接下来进行单击、双击、长按的判断
*/
/*
KEY_SM.KEY_state==KEY_state_Free && timer_getTime1>=300：当按键松开后并且延时一定的时间后进行单机、双击、长按的判断。
为什么要延时？
答：如果不进行延时，就会发现在进行判断的时候无论是双击还是长按，在你按下按键的一瞬间都会被判定为单击然后才会被跳转到正确的状态。延时的目的就是按下按键后先等一会，确定你接下来不会再进行别的操作了CPU再进行判断。这个延时时间取决于设定的双击间隔（也就是第一次按下和第二次按下，两次按下间的时间间隔）
*/
	if(KEY_SM.KEY_state==KEY_state_Free && timer_getTime1>=300)
	{
		if(KEY_SM.KEY_getHighTime>=100 && KEY_SM.KEY_getHighTime<=300)     //第一次按下和第二次按下间隔时间在100-300ms时判定为双击。经过调试发现这个数据是比较贴近人手双击速度的，低于100ms后手速基本达不到，高于300ms后需要延时的时间就会比较长，实时性太差
		{
			KEY_SM.KEY_clickMode=KEY_click_Double;
			click_isDouble=1;        //已经判定为双击
		}
		else
		{
			click_isDouble=0;      //未被判定为双击
		}
		
		if(KEY_SM.KEY_getLowTime>1500 && click_isDouble==0)        //按下持续时间低于1500ms并且未被判定为双击的情况下判定为单击
		{
			KEY_SM.KEY_clickMode=KEY_click_Long;
		}
		
		if(KEY_SM.KEY_getLowTime<=1500 && click_isDouble==0)     //同上，否则为长按
		{
			KEY_SM.KEY_clickMode=KEY_click_One;
		}
	}
}

优化后的代码：还是没找到那个玄学问题的原因在哪，不过当我把else去掉后（也就是把时间记录条件放宽，只要按键松开我就记录时间）
void KEY_stateMachine()
{
	static uint8_t click_isDouble=0;
	uint16_t key_value;
	uint16_t timer_getTime;
	uint16_t High_stableTime=0;          //改了变量名增加一下代码的可读性
	
	key_value=GPIO_ReadInputDataBit(KEY_Obj,KEY_GPIO_Pin);
	
	switch(KEY_SM.KEY_state)
	{
		case KEY_state_Free:
		{
			if(key_value==0)
			{
				KEY_SM.KEY_state=KEY_state_Unknow;
				KEY_SM.KEY_getHighTime=TIM_GetCounter(Timer_Obj);
				
				Timer_Obj->CNT=0;            //这里把else删了
			}
			
			High_stableTime=TIM_GetCounter(Timer_Obj);	
			
			break;
		}
		
		case KEY_state_Unknow:
		{	
			timer_getTime=TIM_GetCounter(Timer_Obj);
			if(timer_getTime>=15 && key_value==0)
			{
				KEY_SM.KEY_state=KEY_state_Pressed;
				
				Timer_Obj->CNT=0;
			}
			
			if(timer_getTime>=15 && key_value==1)
			{
				KEY_SM.KEY_state=KEY_state_Free;
				
				Timer_Obj->CNT=0;
			}
				
			break;
		}
		
		case KEY_state_Pressed:
		{
			if(key_value==1)
			{
				KEY_SM.KEY_state=KEY_state_Unknow;
				KEY_SM.KEY_getLowTime=TIM_GetCounter(Timer_Obj);
				
				Timer_Obj->CNT=0;
			}	
			
			break;
		}
		
		default:
		{
			break;
		}
	}
	
	if(KEY_SM.KEY_state==KEY_state_Free && High_stableTime>=200)
	{
		if(KEY_SM.KEY_getHighTime>=100 && KEY_SM.KEY_getHighTime<=200)
		{
			KEY_SM.KEY_clickMode=KEY_click_Double;
			click_isDouble=1;
		}
		else
		{
			click_isDouble=0;
		}
		
		if(KEY_SM.KEY_getLowTime>1500 && click_isDouble==0)
		{
			KEY_SM.KEY_clickMode=KEY_click_Long;
		}
		
		if(KEY_SM.KEY_getLowTime<=1500 && click_isDouble==0)
		{
			KEY_SM.KEY_clickMode=KEY_click_One;
		}
	}
}

算法思路整理：不断扫描引脚电平（松开为1，按下为0），每一次按键状态改变后都会记录该状态持续的时间，并且重新计时以确保下一次状态改变后的时间记录的真实性。当按键松开后延时一段时间确保按键状态不会再次改变后对上一次的操作进行判断，判断的依据就是每一次状态持续的时间

七、优缺点分析

优点

整个过程只用了一个定时器，节省单片机外设资源。没有使用延时函数，CPU利用率高，不影响CPU实时性

缺点

按键检测的实时性差

八、测试视频

利用状态机实现按键消抖、单击、双击、长按


 

 

学习的og
关注
stm32硬件消抖_STM32 状态机实现按键消抖处理源码
weixin_39631350的博客
12-20 452
key.h#ifndef __KEY_H__#define __KEY_H__#include "stm32f10x.h"#ifdef KEY_GLOBALS#define KEY_EXT#else#define KEY_EXT extern#endif//IO定义#define down() GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_1...
基于HAL库，状态机编程STM32F103单片机实现按键消抖，处理按键单击，双击，三击，长按事件 开启定时器中断处理
07-18
基于HAL库，状态机编程STM32F103单片机实现按键消抖，处理按键单击，双击，三击，长按事件。开启定时器中断处理
嵌入式STM32按键状态机-单击双击长按操作
06-02
个人博客：CSDN “老子姓李！” 参考教程链接：http://t.csdn.cn/W9rIy 引言： 在日常生活中，有不少按键长按、短按的应用实例。比如：一个台灯，短按切换亮度，长按关机。 问题来了，单片机是如何区分按键的短按和长按的呢？ 本程序使用定时器，运用状态机的思想，实现了单按键的单击长按操作。 代码简洁规范，可读性强，移植性强。 实验器材: 自制开发板，STM32F03C8T6平台 实验目的: 学习定时器中断、按键使用。实现单击双击长按操作 硬件资源: 按键(PA0,也称之为WK_UP) 定时器3 串口1，用于打印输出 按键事件: 长按事件：任何大于 1秒 按下并释放事件（不支持连按，需连按，稍微修改状态机即可） 单击事件：按下时间不超过 1秒 且 释放后 500ms 内无再次按下的操作 双击事件：俩次短按时间间隔小于500ms，俩次短按操 本程序只供学习使用，未经作者许可，不得用于其它任何用途 感谢大家的阅读与下载，码字开源分享不易，麻烦给个免费的赞。 如果有帮助的，请不要吝啬三连。点赞评论收藏，让更多人看到有用的内容。 本博客作抛砖引玉，欢迎大家评论交流。
利用状态机的按键消抖程序
01-24
利用状态机的按键消抖程序,单片机，STM32
STM32按键扫描及按键消抖
memoryers的博客
08-21 1631
①检测按键是否按下②延时10~15ms③再检测按键是否按下④等待按键抬起⑤返回键值。
【STM32】状态机实现定时器按键消抖，处理单击、双击、三击、长按事件
我的博客
05-14 3454
众所周知，普通的机械按键会产生抖动，可以采取硬件上加电容来滤波，也可以考虑用软件来消抖。这里笔者分享一种基于状态机的按键消抖策略，可以实现单击双击三击长按事件的读取。按键时间也可以自己设置。这种方法需要消耗掉定时器资源，还有额外的RAM支出。如图矩形框内描述，最终键值的确定需要标志位和计数值，因此一个按键结构体应该这样定义//按键端口//按键PIN//按键类型//按压计数器//高电平计数器//按压标志//松手标志//按键键值。
STM32F4按键状态机--单击、双击、长按
最新发布
wwwqqq2014的博客
09-06 1099
STM32F4按键状态机--单击、双击、长按
【STM32】HAL库-利用状态机检测按键
科昂的博客
03-31 2587
在工程实际开发应用中，一般采用状态机和定时中断相结合的方式来完成按键的检测。 状态机是一个抽象的概念，表示把一个过程抽象为若干个状态之间的转换，这些状态之间存在一定的联系。
状态机按键 多个独立按键识别 单击 双击 长按 2019.12.30.zip
12-30
本教程主要探讨如何在STM32微控制器上实现按键的高效识别，包括单击、双击和长按操作，通过使用状态机来实现这一功能。STM32是一款广泛使用的基于ARM Cortex-M内核的微控制器，其强大的性能和丰富的外设接口使其成为...
ESP32定时中断实现单击、双击、长按等功能的按键状态机Arduino代码。
03-31
ESP32最小系统板上只有一个按键，实验中为了实现更加丰富的功能，同时提供按键处理的实时性要求，特别写了一个CLASS，实现类似于鼠标单击、双击、三连击、长按等功能，模块化设计，加了详细中文说明，可读性强，可...
基于STM32+MultiButton实现的按键检测单击双击长按保持按键松开按键弹起等源码+说明文档.zip
05-03
这个压缩包文件提供的资源是关于如何使用STM32处理多种按键事件的实现，包括单击、双击、长按、保持、按键松开以及按键弹起等。这在许多嵌入式系统设计中是非常基础且重要的功能，比如消费电子产品、智能家居设备、...
stm32的 按键 消抖
qq_60610314的博客
12-08 9044
一、什么是抖动 a、较为官方的解释： 在机械按键的触点闭合和断开时，都会产生抖动，为了保证系统能正确识别按键的开关，就必须对按键的抖动进行处理。 按键的抖动对于人类来说是感觉不到的，但对单片机来说，则是完全可以感应到的，而且还是一个很“漫长”的过程，因为单片机处理的速度在“微秒”级，而按键抖动的时间至少在“毫秒”级。 单片机如果在触点抖动期间检测按键的通断状态，则可能导致判断出错，即按键一次按下或释放被错误地认为是多次操作，从而引起误处理。...
stm32_按键消抖_代码与流程分析
riversu
07-31 402
stm32，机械消抖
STM32 按键的读取（属于GPIO的运用）
2302_76668302的博客
11-01 254
通过while循环检测20MS后是否还是在按下，松手了就是一次完整的按下。通过检测函数返回引脚状态。先配置引脚为高阻输入。
STM32HAL库定时器中断、按键中断、串口中断、按键消抖和低通滤波算法详解
weixin_59592549的博客
05-21 5156
本文将详细介绍STM32HAL库中的定时器中断、按键中断、串口中断的使用方法，以及按键消抖和低通滤波算法的实现。定时器中断是STM32开发中常用的一种中断方式，主要用于定时执行某些任务，例如按键消抖、定时更新显示等。1. 定时器中断法：通过定时器中断定时检测按键状态，若连续多次检测到按键状态一致，则认为按键有效。在main函数中，调用HAL_GPIO_EXTI_IRQHandler()函数启动按键中断。在main函数中，调用HAL_TIM_Base_Start_IT()函数启动定时器。
STM32实现按键单击、双击、长按、连按功能，使用状态机，无延时，不阻塞
dothetran的博客
07-02 2141
使用定时器状态机实现按键单击、双击、长按、连按功能。消抖时间可调，长按时间可调，双击判定时间可调，连按单击间隔可调。无延时不阻塞，稳定触发，移植简单
[stm32]stm32按键外部中断，如何消抖
热门推荐
slimmm的博客
09-22 4万+
讨论一下stm32下按键外部中断如何进行有效的消抖 工程的代码是直接使用stm32 cubeMX进行配置生成的，下面就一起讨论吧。 1. 在中断处理服务函数中注释清除中断标志的语句，防止按键抖动而不断的进入中断服务程序中 2. 进入回调函数后先进性延时，一般为10ms，进行消抖，然后再判断引脚的电平状态 3. 在结束时一定注意要延时一段时间，然后才清除中断标志，而且要相对消抖时间要长一些，目的是为...
STM32按键消抖的几种实现方式-STM32 Button Debouncing
robottosan的博客
09-10 2万+
STM32按键消抖的几种实现方式-STM32 Button Debouncing
stm32 状态机 单击 双击 长按 hal
12-10
STM32状态机是一种基于事件驱动的程序设计方法，采用状态机可以更好地管理复杂的系统逻辑。在STM32中，状态机可以应用于处理按键的单击、双击和长按事件。 单击是指短暂按下按钮并快速释放的动作，双击是指在一定时间内连续快速地两次按下按钮，长按是指按下按钮并保持一定时间不放。使用STM32的HAL库可以方便地实现对按键事件的检测和处理。 在状态机中，可以定义多个状态，每个状态对应系统中的某种工作模式或状态。当按键被按下时，状态机会根据当前的状态和按键事件来执行相应的操作，比如切换状态、执行特定的逻辑代码等。通过状态机的设计，程序可以更清晰地描述系统行为，易于维护和扩展。 对于单击、双击和长按的处理，可以在状态机中定义对应的状态，并在每个状态下实现按键事件的处理逻辑。例如，可以通过状态机来判断按下按钮的次数和时长，从而触发单击、双击和长按事件的处理。 总之，STM32状态机可以很好地应用于处理单击、双击和长按等按键事件，通过合理的状态机设计和HAL库的支持，可以实现对这些按键事件的高效处理和管理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值