stm32外设笔记-按键状态机

最新推荐文章于 2024-05-11 13:26:14 发布
最新推荐文章于 2024-05-11 13:26:14 发布
阅读量3k 收藏 30
点赞数 6
分类专栏： 单片机学习记录 文章标签： stm32 单片机 物联网
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51220742/article/details/123391978
版权

文章目录


本文用到的实验平台：

  • 野火MINI-stm32开发板
  • STM32CUBE-IDE开发工具

平时写一些程序的时候如果涉及到一些选择的话，经常需要用到按键什么的，不同的方法写的按键又不一样，有时候需要实现长按短按什么的也不太方便，因此我最近就从github上找了些例程，用起来还是很不错的，下面我对按键的使用进行一些总结，这里要特别感谢开源贡献者。

1、配置io口实现按键功能

野火MINIstm32开发板上的按键如下所示，可以看到这个按键做的还是很好的，加上了电容，电阻也有，可以很好的减缓按键按下时候的毛刺。
在这里插入图片描述
同时我们注意到这里按键是被硬件下拉了的，所以我们在stm32的配置中就无需设置上下拉输入了，直接设置为既不上拉也不下拉即可，不过一旦初始化之后就会被外部硬件拉低，所以我们直接读取肯定就是低电平，这个时候按下按键就会变为高电平了！
在这里插入图片描述
除此之外比较常用的还有中断的方式，中断其实分的挺细的，有事件中断，外部中断两种，也都是上升沿，下降沿，然后上升沿和下降沿，这样组合就是六种了，我们根据实际需求配置即可！
在这里插入图片描述
下面是我配置的框图，下降沿中断，引脚上拉

在这里插入图片描述
这里注意如果开启了中断，一定要去NVIC这里去把中断勾上，其他大部分外设都可以直接选，GPIO的比较隐藏，需要自己去勾选，不要忘了，不然中断不起来
在这里插入图片描述
中断函数都在it.c的文件中，可以查阅中文参考手册，因为我这个几个引脚都是10-15的，所以公用一根中断线
在这里插入图片描述
一般我们写中断后的事情也就是在中断回调函数里面来写了

在这里插入图片描述

2、第一种按键状态机及其实现

按键状态机使得我们可以傻瓜式的使用按键，对按键绑定事件，触发情况等，方便按键触发，下面的这种支持单击，连续按下，短按，长按等功能，具体使用如下：

绑定按键对象，并将按键处理函数放入循环中

在这里插入图片描述
编写回调函数，他是所有的按键都给了回调函数，所以就是在回调函数里面来选按键
在这里插入图片描述
回调函数代码如下

Button btn_k1,btn_k2;
#define BUTTON_KEY1_ID	1
#define BUTTON_KEY2_ID	2

//void button_pressing_callback(uint8_t button_id)
//{
//	switch(button_id)
//	{
//		case BUTTON_KEY1_ID:
//			printf("KEY1被按下\r\n");
//			break;
//		case BUTTON_KEY2_ID:
//			printf("KEY2被按下\r\n");
//			break;
//	}
//}
//void button_release_callback(uint8_t button_id)
//{
//	switch(button_id)
//	{
//		case BUTTON_KEY1_ID:
//			printf("KEY1被松开\r\n");
//			break;
//		case BUTTON_KEY2_ID:
//			printf("KEY2被松开\r\n");
//			break;
//	}
//}
void button_press_short_callback(uint8_t button_id)
{
//	switch(button_id)
//	{
//		case BUTTON_KEY1_ID:
//			printf("KEY1短按\r\n");
//			break;
//		case BUTTON_KEY2_ID:
//			printf("KEY2短按\r\n");
//			break;
//	}
}
void button_pressing_timeout_callback(uint8_t button_id)
{
//	switch(button_id)
//	{
//		case BUTTON_KEY1_ID:
//			printf("KEY1长按\r\n");
//			break;
//		case BUTTON_KEY2_ID:
//			printf("KEY2长按\r\n");
//			break;
//	}
}
void button_pressing_accel_callback(uint8_t button_id) //就感觉这个也有点像长按，基本功能是一样的
{
	switch(button_id)
	{
		case BUTTON_KEY1_ID:
			printf("KEY1快速\r\n");
			break;
		case BUTTON_KEY2_ID:
			printf("KEY2快速\r\n");
			break;
	}
}

代码全文如下

button.c

#include "button.h"

__weak void button_pressing_callback(uint8_t button_id)
{

}
__weak void button_release_callback(uint8_t button_id)
{

}
__weak void button_press_short_callback(uint8_t button_id)
{

}
__weak void button_pressing_timeout_callback(uint8_t button_id)
{

}
__weak void button_pressing_accel_callback(uint8_t button_id)
{

}
void handle_button(Button *btn)
{
	btn->current_status = HAL_GPIO_ReadPin(btn->gpio_port,btn->gpio_pin);
	if(btn->button_active == BUTTON_ACTIVE_HIGH)
	{
		 btn->current_status = !btn->current_status;
	}
	switch(btn->button_state)
	{
		case BUTTON_READ:
		{
			if((btn->current_status == 0 && btn->last_status == 1) )
			{
						btn->time_debounce = HAL_GetTick();
						btn->button_state = BUTTON_WAIT_DEBOUND;
			}
		}
		break;
		case BUTTON_WAIT_DEBOUND:
		{
			if(HAL_GetTick() - btn->time_debounce>= TIME_DEBOUND_BUTTON)
			{
				if(btn->current_status ==0 && btn->last_status ==1)//nhan xuong
				{
					button_pressing_callback(btn->button_id);
					btn->t_long_press = HAL_GetTick();
					btn->last_status = 0;
					btn->t_accel_press = HAL_GetTick();
					btn->t_accel_call = TIME_ACCEL_MAX;
					btn->button_state = BUTTON_WAIT_RELEASE_AND_CHECK_LONG_PRESS;
				}
				else if(btn->current_status ==1 && btn->last_status ==0)//nha ra
				{
					btn->t_long_press = HAL_GetTick() - btn->t_long_press;
					if(btn->t_long_press <= TIME_SHORT_PRESS)
					{
						button_press_short_callback(btn->button_id);
					}
					button_release_callback(btn->button_id);
					btn->last_status = 1;
					btn->button_state = BUTTON_READ;
				}
				else //khong dung
				{
					btn->last_status = 1;
					btn->button_state = BUTTON_READ;
				}
			}
		}
		break;
		case BUTTON_WAIT_RELEASE_AND_CHECK_LONG_PRESS:
		{
				if(btn->current_status == 1 && btn->last_status == 0)
				{
					btn->button_state = BUTTON_WAIT_DEBOUND;
					btn->time_debounce = HAL_GetTick();
				}
				else if(HAL_GetTick() - btn->t_long_press >= TIME_LONG_PRESS)
				{
					button_pressing_timeout_callback(btn->button_id);
					btn->button_state = BUTTON_WAIT_RELEASE;
				}
				else if(HAL_GetTick() -  btn->t_accel_press >= btn->t_accel_call)
				{
					btn->t_accel_call -=TIME_ACCEL_DELTA;
					if(btn->t_accel_call <= TIME_ACCEL_MIN)
					{
						btn->t_accel_call = TIME_ACCEL_MIN;
					}
					button_pressing_accel_callback(btn->button_id);
					btn->t_accel_press = HAL_GetTick();
				}
		}
		break;
		case BUTTON_WAIT_RELEASE:
		{
			if(btn->current_status == 1 && btn->last_status == 0)
			{
				btn->button_state = BUTTON_WAIT_DEBOUND;
				btn->time_debounce = HAL_GetTick();
			}
			else if(HAL_GetTick() -  btn->t_accel_press >= btn->t_accel_call)
			{
				btn->t_accel_call -=TIME_ACCEL_DELTA;
				if(btn->t_accel_call <= TIME_ACCEL_MIN)
				{
					btn->t_accel_call = TIME_ACCEL_MIN;
				}
				button_pressing_accel_callback(btn->button_id);
				btn->t_accel_press = HAL_GetTick();
			}
		}
		break;
		default:
			break;
	}
}

//button_active: BUTTON_ACTIVE_LOW, BUTTON_ACTIVE_HIGH
void Button_init(Button *btn,GPIO_TypeDef *port,uint16_t pin,uint8_t button_active,uint8_t button_id)
{
	btn->gpio_port = port;
	btn->gpio_pin = pin;
	btn->button_active = button_active;
	btn->button_state = BUTTON_READ;
	btn->button_id = button_id;
	btn->current_status = 1;
	btn->last_status = 1;
}

button.h文件

#include "main.h"

#define TIME_DEBOUND_BUTTON	20
#define TIME_SHORT_PRESS	1000
#define TIME_LONG_PRESS	2000
#define TIME_ACCEL_MIN	100
#define TIME_ACCEL_MAX	1000
#define TIME_ACCEL_DELTA	200

#define BUTTON_ACTIVE_LOW	0
#define BUTTON_ACTIVE_HIGH	1

typedef enum
{
	BUTTON_READ,
	BUTTON_WAIT_DEBOUND,
	BUTTON_WAIT_RELEASE_AND_CHECK_LONG_PRESS,
	BUTTON_WAIT_RELEASE
}Button_State;
typedef struct
{
	GPIO_TypeDef *gpio_port;
	uint16_t gpio_pin;
	uint8_t current_status;
	uint8_t last_status;
	uint32_t time_debounce;
	uint32_t t_long_press;
	Button_State button_state;
	uint8_t button_active;
	uint8_t button_id;
	int16_t t_accel_call;
	uint32_t t_accel_press;
}Button;

void handle_button(Button *btn);
void Button_init(Button *btn,GPIO_TypeDef *port,uint16_t pin,uint8_t button_active,uint8_t button_id);

3、第二种按键状态机及其实现

第二种方式我觉得就更加强大了，不仅支持短按长按，还有双击，连续按下的次数等，用起来也很方便

首先注册按键并设置按键模式，他这个就不是对所有按键都统一了，要看你设置的模式，有没有加入相关功能，之后就是编写回调函数了

在这里插入图片描述
在初始化部分我们初始化按键对象，之后这个按键需要提供一个5ms的心跳，使用while循环或者定时器都是可以的，这里偷懒直接使用while循环
在这里插入图片描述
把结果通过串口打印，可以看到还是很正常的！！！

在这里插入图片描述

第二种按键状态机的代码如下

button02.c

#include "Button02.h"

#define EVENT_CB(ev)    \
	if (handle->cb[ev]) \
	handle->cb[ev]((Button_t)handle,(PressEvent)handle->event,(uint8_t)handle->repeat)

typedef void (*BtnCallback)(void*, PressEvent, uint8_t);

typedef struct {
	uint16_t ticks;
	uint8_t repeat :4; // max 15
	uint8_t event :4;
	uint8_t state :3;
	uint8_t debounce_cnt :3;
	uint8_t active_level :1;
	uint8_t button_level :1;
	GPIO_TypeDef *GPIOx;
	uint16_t GPIO_PIN_x;
	BtnCallback cb[EVENT_NUM];
	struct Button *next;
} Button;

// button handle list head.
static Button *head_handle = NULL;

/**
 初始化按键结构体
 */
Button_t button_init(const Btn_init_attr *attr) {
	// allocate memory.
	Button *thisHandle = (Button*) malloc(sizeof(Button));
	if (!thisHandle) {
		return NULL; // allocate memory failed.
	}

	memset(thisHandle, 0, sizeof(Button));
	thisHandle->event = (uint8_t) NONE_PRESS;
	thisHandle->GPIOx = attr->GPIOx;
	thisHandle->GPIO_PIN_x = attr->GPIO_PIN_x;
	thisHandle->active_level = (uint8_t) attr->active_level;
	thisHandle->button_level = !thisHandle->active_level;

	// Attach the button event callback function
	for (uint8_t i = 0; i < attr->event_num; i++) {
		thisHandle->cb[attr->event[i]] =
				(void (*)(void*, PressEvent, uint8_t)) button_callback;
	}

	// start button
	thisHandle->next = head_handle;
	head_handle = thisHandle;
	return (Button_t) thisHandle; // success
}

/**
 按键驱动状态机
 */
static void button_handler(Button *handle) {
	uint8_t read_gpio_level = (uint8_t) HAL_GPIO_ReadPin(handle->GPIOx,
			handle->GPIO_PIN_x);

	// ticks counter working..
	if ((handle->state) > 0)
		handle->ticks++;

	/*------------button debounce handle---------------*/
	if (read_gpio_level != handle->button_level) { // not equal to prev one
												   // continue read 3 times same new level change
		if (++(handle->debounce_cnt) >= DEBOUNCE_TICKS) {
			handle->button_level = read_gpio_level;
			handle->debounce_cnt = 0;
		}
	} else { // leved not change ,counter reset.
		handle->debounce_cnt = 0;
	}

	/*-----------------State machine-------------------*/
	switch (handle->state) {
	case 0:
		if (handle->button_level == handle->active_level) { // start press down
			handle->event = (uint8_t) PRESS_DOWN;
			EVENT_CB(PRESS_DOWN);
			handle->ticks = 0;
			handle->repeat = 1;
			handle->state = 1;
		} else {
			handle->event = (uint8_t) NONE_PRESS;
		}
		break;

	case 1:
		if (handle->button_level != handle->active_level) { // released press up
			handle->event = (uint8_t) PRESS_UP;
			EVENT_CB(PRESS_UP);
			handle->ticks = 0;
			handle->state = 2;
		} else if (handle->ticks > LONG_TICKS) {
			handle->event = (uint8_t) LONG_PRESS_START;
			EVENT_CB(LONG_PRESS_START);
			handle->state = 5;
		}
		break;

	case 2:
		if (handle->button_level == handle->active_level) { // press down again
			handle->event = (uint8_t) PRESS_DOWN;
			EVENT_CB(PRESS_DOWN);
			handle->repeat++;
			handle->event = (uint8_t) PRESS_REPEAT;
			EVENT_CB(PRESS_REPEAT); // repeat hit
			handle->ticks = 0;
			handle->state = 3;
		} else if (handle->ticks > SHORT_TICKS) { // released timeout
			if (handle->repeat == 1) {
				handle->event = (uint8_t) SINGLE_CLICK;
				EVENT_CB(SINGLE_CLICK);
			} else if (handle->repeat == 2) {
				handle->event = (uint8_t) DOUBLE_CLICK;
				EVENT_CB(DOUBLE_CLICK); // repeat hit
			}
			handle->state = 0;
		}
		break;

	case 3:
		if (handle->button_level != handle->active_level) { // released press up
			handle->event = (uint8_t) PRESS_UP;
			EVENT_CB(PRESS_UP);
			if (handle->ticks < SHORT_TICKS) {
				handle->ticks = 0;
				handle->state = 2; // repeat press
			} else {
				handle->state = 0;
			}
		} else if (handle->ticks > SHORT_TICKS) {
			handle->state = 0;
		}
		break;

	case 5:
		if (handle->button_level == handle->active_level) {
			// continue hold trigger
			handle->event = (uint8_t) LONG_PRESS_HOLD;
			EVENT_CB(LONG_PRESS_HOLD);
		} else { // released
			handle->event = (uint8_t) PRESS_UP;
			EVENT_CB(PRESS_UP);
			handle->state = 0; // reset
		}
		break;
	}
}

/**
 移除按键实例化对象
 */
void button_deInit(Button_t handle) {
	Button **curr;
	for (curr = &head_handle; *curr;) {
		Button *entry = *curr;
		if (entry == (Button*) handle) {
			*curr = entry->next;
			free(entry);
		} else
			curr = &entry->next;
	}
}

/**
 定时器重复5ms进行
 */
void button_ticks() {
	Button *target;
	for (target = head_handle; target; target = target->next) {
		button_handler(target);
	}
}

/**
  回调函数，输入实例化按键，事件，次数
 */
void __attribute__((weak)) button_callback(Button_t btn, PressEvent event,
		uint8_t repeat) {
	// nothing to do,please rewrite.
}

button02.h

#include "main.h"

#define TIME_DEBOUND_BUTTON	20
#define TIME_SHORT_PRESS	1000
#define TIME_LONG_PRESS	2000
#define TIME_ACCEL_MIN	100
#define TIME_ACCEL_MAX	1000
#define TIME_ACCEL_DELTA	200

#define BUTTON_ACTIVE_LOW	0
#define BUTTON_ACTIVE_HIGH	1

typedef enum
{
	BUTTON_READ,
	BUTTON_WAIT_DEBOUND,
	BUTTON_WAIT_RELEASE_AND_CHECK_LONG_PRESS,
	BUTTON_WAIT_RELEASE
}Button_State;
typedef struct
{
	GPIO_TypeDef *gpio_port;
	uint16_t gpio_pin;
	uint8_t current_status;
	uint8_t last_status;
	uint32_t time_debounce;
	uint32_t t_long_press;
	Button_State button_state;
	uint8_t button_active;
	uint8_t button_id;
	int16_t t_accel_call;
	uint32_t t_accel_press;
}Button;

void handle_button(Button *btn);
void Button_init(Button *btn,GPIO_TypeDef *port,uint16_t pin,uint8_t button_active,uint8_t button_id);
桃成蹊2.0
关注
  • 6
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 6
    评论
专栏目录
小梅哥Xilinx FPGA学习笔记12——使用状态机实现按键消抖
m0_51430584的博客
12-04 548
第二件事是20ms内检测到上升沿，则表明此时处于抖动状态，立即退回空闲状态。第三件事是20ms内未检测到上升沿，就干巴巴的等待20ms，直至20ms结束仍未有上升沿就进入第一件事。第二件事是20ms内检测到下降沿，则表明此时处于抖动状态，立即退回等待状态。第三件事是20ms内未检测到下降沿，就干巴巴的等待20ms，直至20ms结束仍未有下降沿就进入第一件事。，此时按键已经被按下，这个状态要做的事就是一直检测上升沿的到来，如果上升沿没到来就一直待在等待状态，如果一旦检测到上升沿出现，则立即进入。
c语言按键状态机,C语言状态机编程思想
weixin_31588005的博客
05-18 1016
原标题：C语言状态机编程思想有限状态机概念有限状态机是一种概念思想，把复杂的控制逻辑分解成有限个稳定状态，组成闭环系统，通过事件触发，让状态机按设定的顺序处理事务。单片机C语言的状态机编程，是利用条件选择语句(switch、case或者if、else)切换状态，通过改变状态机状态，让程序按设定的顺序执行。有限状态机由有限的状态和相互之间的转移构成，在任何时候只能处于给定数目的状态中的一个。当接收到...
嵌入式STM32按键状态机-单击双击长按操作
06-02
个人博客：CSDN “老子姓李！” 参考教程链接：http://t.csdn.cn/W9rIy 引言： 在日常生活中，有不少按键长按、短按的应用实例。比如：一个台灯，短按切换亮度，长按关机。 问题来了，单片机是如何区分按键的短按和长按的呢？ 本程序使用定时器，运用状态机的思想，实现了单按键的单击长按操作。 代码简洁规范，可读性强，移植性强。 实验器材: 自制开发板，STM32F03C8T6平台 实验目的: 学习定时器中断、按键使用。实现单击双击长按操作 硬件资源: 按键(PA0,也称之为WK_UP) 定时器3 串口1，用于打印输出 按键事件: 长按事件：任何大于 1秒 按下并释放事件（不支持连按，需连按，稍微修改状态机即可） 单击事件：按下时间不超过 1秒 且 释放后 500ms 内无再次按下的操作 双击事件：俩次短按时间间隔小于500ms，俩次短按操 本程序只供学习使用，未经作者许可，不得用于其它任何用途 感谢大家的阅读与下载，码字开源分享不易，麻烦给个免费的赞。 如果有帮助的，请不要吝啬三连。点赞评论收藏，让更多人看到有用的内容。 本博客作抛砖引玉，欢迎大家评论交流。
状态机应用之按键状态机
weixin_44075145的博客
04-24 435
状态机应用
2024年最全【源码详解~按键状态机~简洁易懂】1，2024年最新还有人不知道什么是GolangX的吗
最新发布
2401_84904534的博客
05-11 941
长按事件：按下时间大于1s，释放后响应。（不支持连按，若需要连按，进行简单修改即可）单击事件：按下时间小于1s， 释放后响应。本文实现短按长按功能，故只有三种事件：无事件、短按事件、长按事件对应代码，即:空闲、单击、长按KEY_Event_Null = 0x00, // 空闲KEY_Event_SingleClick = 0x01, // 单击KEY_Event_LongPress = 0x02 // 长按。
状态机实现双击、短按、长按等按键识别检测算法
weixin_49337111的博客
03-02 1728
按键识别算法在不同的技术和应用背景下有不同的作用，但其核心目标都是准确、可靠地检测和区分用户通过物理或虚拟按键所执行的操作。按键识别算法在各类电子设备及系统中起到至关重要的作用，它确保了人机交互的有效性和准确性，提升了用户体验，并保证了系统的正常运行。按键识别算法也有较多的种类，在这一部分主要介绍独立按键的双击、短按、长按识别算法。
【蓝桥杯嵌入式】状态机按键
Demo_ns的博客
03-04 1117
【蓝桥杯嵌入式】备赛必学——状态机按键
【STM32进阶系列】推荐一种好用的按键处理程序
m0_54916619的博客
03-07 3534
基于状态机的按键处理程序，好用的按键程序，STM32按键进阶，实用程序分享。
按键处理 --- 状态机
sugar0_1的博客
12-10 445
按键处理（状态机）
STC15单片机-按键检测单击、双击和长按(状态机)
weixin_46251230的博客
09-02 8473
在单片机的应用中，利用按键实现与用户的交互功能是相当常见的，同时按键的检测也是很讲究的，众所周知，在有键按下后，数据线上的信号出现一段时间的抖动，然后为低，当按键释放时，信号抖动一段时间后变高，然而这段抖动时间要维持10ms~50ms，这个与按键本身的材质有一定的关系，在这个范围内基本上都可以确定的。像这样的程序经常出现在大学的教科书中，在按键的扫描中，单片机的资源全部用来做按键的扫描，特别是当中的延时程序，对单片机来说，这个一个漫长的过程。这样的教科书的按键处理程序是不实用的，在实际应用中是不可取的。
嵌入式单片机高级篇（一）Stm32F103电容触摸按键
lostlll的博客
10-08 2104
电容触摸按键 一、电容触摸按键原理： 1、电容触摸按键电路是如何组成的？ 回答：电容触摸按键的电路由一个上拉电阻、一个开关以及杂散电容组成，开关断开时，杂散电容充电，开关闭合时，杂散电容放电 2、电容触摸按键如何判别按键是否被触摸？ 回答：根据电容的充电时间，当按键没有触摸时，电源只给杂散电容充电，充电时间较短，记为tcs，当按键被触摸时，相当于与杂散电容并联了一个额外的电容，此时电容充电时间变长，记为ts+tx，由电路里的总电容的充电时间的长短来判别按键是否被触摸。 当充电时间在tcs附近时，认为按键没有
状态机按键 多个独立按键识别 单击 双击 长按 2019.12.30.zip
12-30
STM32按键识别（单击 双击 多击） 使用定时器+状态机实现，该例程已经实现三个独立按键的多功能识别，可以根据自己需要更改为其他用途，也可以更改为多击，长时间按键识别。
STM32自学笔记 随书资料
03-11
本资源“STM32自学笔记 随书资料”是一份全面的学习STM32开发的参考资料，旨在帮助初学者快速入门并深入理解STM32的工作原理和编程技巧。 一、STM32架构与特性 STM32系列涵盖了多种型号，主要基于Cortex-M0、M3、M4...
STM32F070_USB-FS-Device_Lib V1.0.0
07-30
1. **Header Files**：定义了库的结构、接口和枚举常量，包括USB设备描述符、端点配置和枚举状态机等。 2. **Source Files**：实现USB协议栈的核心函数，包括USB初始化、中断处理、枚举过程、数据传输等功能。 3. **...
STM32F407ZGT6学习笔记
01-16
总的来说，STM32F407ZGT6的学习涵盖了微控制器的基础操作到高级应用，包括中断系统、通信接口、外设控制等多个方面，为嵌入式开发提供了强大的工具。通过深入理解并实践这些知识点，开发者能够更好地利用STM32F407ZG...
CNC-STM32-F4.zip
07-04
- **硬件配置文件**：如STM32CubeMX配置，定义了GPIO、定时器、串行接口等外设的初始化设置。 - **库文件**：如USB库、LCD驱动库等，用于实现特定功能。 - **编译工具链**：如Makefile或IDE项目文件，用于构建和调试...
基于stm32及proteus智能小车仿真
12-10
首先，STM32（意法半导体的STM32系列）是一种基于ARM Cortex-M内核的微控制器，具有低功耗、高处理速度和丰富的外设接口。在智能小车项目中，STM32F103C6是常见的型号，它拥有64KB闪存和20KB RAM，足以处理小车控制...
基于stm32mini开发板的简易函数发生器和简易示波器
weixin_45475132的博客
02-25 8495
基于stm32 mini开发板的简易示波器
STM32CubeMX(12) ——利用状态机实现按键的长短按和双击
lzzzzzzm的博客
08-11 5241
STM32 Cubemax(十一) ——利用状态机实现按键的长短按和双击 文章目录STM32 Cubemax(十一) ——利用状态机实现按键的长短按和双击前言一、状态图二、Cubemax配置1、IO口配置2、定时器配置三、代码1、编写有关按键的结构体和定义相关参数2、结构体初始化3、状态机编写4、10ms定时器中反复检测按键状态总结 前言 状态机是一种根据当前状态来执行相应动作，根据输入去改变状态的方法，出处应该在数字电路中。 我们利用状态机的思想来实现按键的消抖和一些其他功能的实现 一、状态图 我们
stm32多个按键状态机
06-02
对于 STM32 板子上的多个按键，可以使用状态机来进行处理。下面是一种可能的实现方法： 1. 首先定义每个按键的状态，例如按下、弹起、长按等。 2. 定义一个状态机，用来管理每个按键的状态。 3. 在每次检测按键时，根据当前按键的状态以及前一次检测时的状态，更新状态机中的状态。 4. 根据更新后的状态，执行相应的操作，例如触发一个事件或者修改某个变量的值。 5. 循环执行以上步骤，直到程序结束。 需要注意的是，在实现状态机时，应该使用合适的数据结构来存储每个按键的状态和状态之间的转移关系，以便于代码的维护和扩展。另外，为了避免按键的抖动现象，可以在检测按键状态时，增加一定的延时或者使用硬件滤波器等方法来进行处理。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

桃成蹊2.0

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值