按键单按、双按、长按的中断与非中断处理

最新推荐文章于 2024-09-14 16:38:12 发布
最新推荐文章于 2024-09-14 16:38:12 发布
阅读量1.1k 收藏 5
点赞数 4
分类专栏： C/C++ 文章标签： gpio 单片机 gd32 stm32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cp_srd/article/details/120451982
版权

开发板是GD32E103R-START，2020-6 V1.0
以下是非中断处理，代码比较简陋

#include "gd32e10x.h

int main(void)
{
    volatile static uint8_t a = 0, b = 0, c = 0, d = 0;
    systick_config();
    rcu_periph_clock_enable(RCU_GPIOC);
    gpio_init(GPIOC, GPIO_MODE_OUT_PP, GPIO_OSPEED_10MHZ, GPIO_PIN_6);
    rcu_periph_clock_enable(RCU_GPIOA);
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_MAX, GPIO_PIN_0);

    while(1){
        if (gpio_input_bit_get(GPIOA, GPIO_PIN_0)){
            delay_1ms(20);
            if (gpio_input_bit_get(GPIOA, GPIO_PIN_0)){
                while (gpio_input_bit_get(GPIOA, GPIO_PIN_0) && c < 100){
                    c++;
                    delay_1ms(10);
                }
            }
        }
        
        if (c >= 100){
            a = 0;
            b = 0;
            c = 0;
            d = 0;
            gpio_bit_write(GPIOC, GPIO_PIN_6, 1);
        }
        else{
            c = 0;

            if (a == 1){
                gpio_bit_write(GPIOC, GPIO_PIN_6, 1);
                delay_1ms(500);
                gpio_bit_write(GPIOC, GPIO_PIN_6, 0);
                delay_1ms(500);
            }

            if ((a == 1) && (b == 0) && (!(gpio_input_bit_get(GPIOA, GPIO_PIN_0))) && (d == 0)){
                delay_1ms(20);
                if (!gpio_input_bit_get(GPIOA, GPIO_PIN_0)){
                    d = 1;
                }
            }

            if ((d == 1) && gpio_input_bit_get(GPIOA, GPIO_PIN_0)){
                delay_1ms(20);
                if (gpio_input_bit_get(GPIOA, GPIO_PIN_0)){
                    a = 0;
                    b = 0;
                    d = 2;
                }
            }

            if ((d == 2) && (a == 0) && (b == 0)){
                gpio_bit_write(GPIOC, GPIO_PIN_6, 1);
                delay_1ms(100);
                gpio_bit_write(GPIOC, GPIO_PIN_6, 0);
                delay_1ms(100);
            }

            if ((a == 0) && (b == 0) && gpio_input_bit_get(GPIOA, GPIO_PIN_0)){
                d = 0;
                delay_1ms(20);
                if (gpio_input_bit_get(GPIOA, GPIO_PIN_0)){
                    a = 1;
                }
            }
        }
    }
}

以下中断处理

#include "gd32e10x.h"
#include "key_led.h"

int main(void)
{
    systick_config();
    key_init();
    rcu_periph_clock_enable(RCU_GPIOC);
    gpio_init(GPIOC, GPIO_MODE_OUT_PP, GPIO_OSPEED_10MHZ, GPIO_PIN_6);

    while(1){
        if (key_sta.double_flag[0]){
            gpio_bit_write(GPIOC, GPIO_PIN_6, 1);
            delay_1ms(100);
            gpio_bit_write(GPIOC, GPIO_PIN_6, 0);
            delay_1ms(100);
        }
        else if (key_sta.short_flag[0]){
            gpio_bit_write(GPIOC, GPIO_PIN_6, 1);
            delay_1ms(500);
            gpio_bit_write(GPIOC, GPIO_PIN_6, 0);
            delay_1ms(500);
        }
        else if (key_sta.long_flag[0]){
            gpio_bit_write(GPIOC, GPIO_PIN_6, 0);
        }
    }
}

// 按键状态定义
#define KEY_PRESSED             (1U)
#define KEY_UNPRESSED           (0U)
#define SHORT_TIME              (40U)
#define LONG_TIME               (100U)
#define DOUBLE_TIME             (2U)
#define INTERVAL_MAX            (40U)
#define INTERVAL_MIN            (1U)
#define SINGLE_CLICKED			(2U)
#define DOUBLE_CLICKED			(3U)
// 按键数量
#define KEY_PORT_NUM            (1U)
// 按键数据结构
#pragma pack(1)
struct ld_key{
    uint8_t key_status[KEY_PORT_NUM];
    uint8_t short_flag[KEY_PORT_NUM];
    uint8_t long_flag[KEY_PORT_NUM];
    uint8_t double_flag[KEY_PORT_NUM];
};
#pragma pack()
extern volatile struct ld_key key_sta;

#include "key_led.h"
#include "gd32e10x.h"

volatile struct ld_key key_sta = {0};

// 按键扫描间隔10ms
static void init_scan_timer(void)
{
    timer_parameter_struct timer_initpara;

    rcu_periph_clock_enable(RCU_TIMER3);
    nvic_irq_enable(TIMER3_IRQn, 1, 1);
    timer_deinit(TIMER3);
    timer_struct_para_init(&timer_initpara);
    timer_initpara.prescaler = 1199;
    timer_initpara.alignedmode = TIMER_COUNTER_EDGE;
    timer_initpara.counterdirection = TIMER_COUNTER_UP;
    timer_initpara.period = 999;
    timer_initpara.clockdivision = TIMER_CKDIV_DIV1;
    timer_initpara.repetitioncounter = 0;
    timer_init(TIMER3, &timer_initpara);
    timer_auto_reload_shadow_enable(TIMER3);
    timer_interrupt_flag_clear(TIMER3, TIMER_INT_FLAG_UP);
    timer_interrupt_enable(TIMER3, TIMER_INT_UP);
    timer_enable(TIMER3);
}

void key_init(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_AF);
    gpio_init(GPIOA, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_MAX, GPIO_PIN_0);
    nvic_irq_enable(EXTI0_IRQn, 1, 1);
    gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOA, GPIO_PIN_SOURCE_0);
    exti_init(EXTI_0, EXTI_INTERRUPT, EXTI_TRIG_RISING);    // 这里需要根据原理图确定是上升沿还是下降沿触发
    exti_interrupt_flag_clear(EXTI_0);
    init_scan_timer();
}

以下是gd32e10x_it.c

#include "gd32e10x_it.h"
#include "systick.h"
#include "key_led.h"
// 10ms一次扫描
void TIMER3_IRQHandler(void)
{
    static uint8_t key_holdon_ms[KEY_PORT_NUM] = {0};
    static uint8_t double_interval_ms = 0;
    static uint8_t which_press = 0;
    static uint8_t double_flag = 0;

    if (timer_interrupt_flag_get(TIMER3, TIMER_INT_FLAG_UP) != RESET){
        gpio_input_bit_get(GPIOA, GPIO_PIN_0) ? (key_holdon_ms[0]++) : (0);

        if ((key_holdon_ms[0] >= DOUBLE_TIME) && (key_holdon_ms[0] < SHORT_TIME)){
            double_flag = SET;
        }
        else if ((key_holdon_ms[0] >= SHORT_TIME) && (key_holdon_ms[0] < LONG_TIME)){
            which_press = SINGLE_CLICKED;
        }
        else if ((key_holdon_ms[0] >= LONG_TIME)){
            which_press = RESET;
            key_sta.long_flag[0] = SET;
            key_sta.short_flag[0] = RESET;
            key_sta.double_flag[0] = RESET;
        }
        else {}

        (double_flag && (!gpio_input_bit_get(GPIOA, GPIO_PIN_0))) ? (double_interval_ms++) : (0);

        if ((double_interval_ms > INTERVAL_MIN) && (double_interval_ms < INTERVAL_MAX) && (double_flag == SET)) {
            which_press = DOUBLE_CLICKED;
            double_flag = RESET;
            double_interval_ms = RESET;
        }

        if (double_interval_ms > INTERVAL_MAX) {
            which_press = RESET;
            double_flag = RESET;
            double_interval_ms = RESET;
        }

        if (!gpio_input_bit_get(GPIOA, GPIO_PIN_0) && key_sta.key_status[0] == KEY_PRESSED){
            switch (which_press){
            case SINGLE_CLICKED:
                key_sta.short_flag[0] = SET;
                key_sta.double_flag[0] = RESET;
                key_sta.long_flag[0] = RESET;
                break;
            case DOUBLE_CLICKED:
                key_sta.double_flag[0] = SET;
                key_sta.short_flag[0] = RESET;
                key_sta.long_flag[0] = RESET;
                break;
            default:
                break;
            }
            key_sta.key_status[0] = KEY_UNPRESSED;
            key_holdon_ms[0] = RESET;
            which_press = RESET;
        }
        timer_interrupt_flag_clear(TIMER3, TIMER_INT_FLAG_UP);
    }
}

void EXTI0_IRQHandler(void)
{
    if (RESET != exti_interrupt_flag_get(EXTI_0)){
        key_sta.key_status[0] = KEY_PRESSED;
        exti_interrupt_flag_clear(EXTI_0);
    }
}
cp_srd
关注
专栏目录
按键单击和长按
u010143916的博客
05-13 180
按键单击长按
单片机定时器双击_STM32学习笔记：单片机按键单击、双击、长按功能实现
weixin_36432451的博客
01-17 1314
由于项目产品的需要，只能设置一个按键，但是需要实现短按(即单击)切换工作模式、长按开关机、双击暂停等复用功能。下图是三种情况下的按键波形。按键未按下时是高电平，按下去是低电平。按键单击时，判断时间门槛设置为50~2000ms；长按门槛为持续按下2000ms。双击可以视为时间间隔很短的俩次有效单击，从第一次单击上升沿到第二次单击上升沿延时门槛为100~500ms。//按键按下去会出现下降沿，设置按键...
按键消抖、长按的处理方案（中断法、延时法）
u012500747的博客
04-11 4285
以上代码，基本逻辑就是设置一个10ms的定时中断，在中断扫描按键。按键的消抖、按下、松开、长按都可以在中断中快速检测，不会有延时函数长时间占用CPU。在中断中将标志位置一，在主循环中执行处理函数，避免因执行处理函数，占用中断过长时间。以上的代码可以起到良好的消抖作用，在一些小项目的经常运用。但是由于该方式，在消抖延时期间和松手判断期间都会长时间占用CPU，有可能影响其他功能，对系统的实时性造成影响。如果程序不采取一些算法进行消抖，会出现一次按下，多次检测到按键的情况，造成识别异常。
基于GD32单片机的独立按键检测
m0_71462161的博客
07-07 476
然后铺垫完成，开始进入到最简单的gpio初始化，因为我用的是GD32l233系列的国产单片机，可能固件库会与stm32不同，大家用的时候注意一下。，来定义一个新类型名称的用法，typedef可以声明新的类型名来代替已有的类型名，但却不能增加新的类型。在这里使用弱声明，可更好的调用函数 ，分别是抬起，按下，长按。
GD32F103单片机-EXTI外部中断
最新发布
m0_51319492的博客
09-14 1428
GD32和STM32的EXTI基本相似，具体见STM32F1单片机-外部中断GD32的EXTI包括20个相互独立的边沿检测电路请求产生中断或事件，4位优先级配置寄存器16个优先等级GD32的EXTI有三种触发方式上升沿下降沿和任意沿触发如下图为EXTI框图，通过(IO的16个管脚和内部模块的4根线)一共20条线路进入到边沿检测，或通过软件触发，最终通过中断屏蔽控制(挂起标志位-指示有中断发生，不意味着中断处理已经完成)到NVIC产生中断或者产生事件下图为EXTI触发源对应表NVIC见。
多功能检测按键 单按 长按 多个按键 响应方式
chuangwu2009的专栏
01-09 5445
按键有效检测方式：1：单按键响应 2:多按键响应 3：长按单个按键响应 4：长按多个按键响应 5：以上响应的方式都可以选择释放后响应和按下马上响应
Z-Stack通过按键中断实现长按功能
重庆李四
08-09 2283
一、功能介绍 项目需要实现长按功能，实现按键有2种方式，一种是通过中断、一种KEY_CHANGE事件轮询的方式。由于中断更加的灵敏，这里选择中断的方式。意外的发现，如果开启了中断，那么按键就不会触发KEY_CHANGE事件了。下面说下按键中断实现长按功能的思路： 1. 按下按键 下降沿触发中断(记录触发时间) 2. 更改触发方式为上升沿触发(这样释放按键的时候就会触发中断了) 3. 上升沿...
CC2530-———非中断方式实现按键中断2
FranzLiszt的博客
01-26 329
#include<iocc2530.h> #define uchar unsigned char #define uint unsigned int #define LED1 P1_5 #define LED2 P1_0 #define LED3 P1_3 #define LED4 P1_4 uint count=0; void Initial(void) { P1SEL&=~0x39; P1DIR|=0x39; P1SEL&=~0x04; P1DIR&=~0x04; P
NodeMCU(ESP8266)按键中断实现单击-双击-长按功能
Lengff
12-14 1万+
背景 很多时候我们的设备就只有一个按键，但是我们需要的功能却比较多，所以就会围绕一个按键实现多种交互功能，单击，双击，长按可能就是最常见的几种交互了，所以我就想着用nodeMcu(esp8266)也搞一个出来，中途遇到很多的问题，为此便写下这篇笔记记录下来，分享给大家！ 实现方式 如果只是要实现按键单击功能是比较简单的，只需要读取对应的GPIO的电平信号即可，但是如果我们要实现案件双击，长按此时单纯靠读取电平信号则无法解决此问题。需要使用外部中断来处理按键的状态值。 大概思路就是根据按键按下的时间，和按键回
按键的单击双击三击和长按
08-06
总的来说，实现按键的单击、双击、三击和长按功能涉及了单片机输入检测、事件处理、时间管理等多个方面，而使用定时器能有效地优化这些操作，提高代码的可移植性和稳定性。通过学习和理解这一过程，开发者可以更好地...
矩阵按键的同时按下长按，短按，长按
2302_76668302的博客
08-30 1017
else if((Press_CNT < 100)&&(Press_CNT > 2)) //短按弹起。//按键弹起或按其他按键，将长按时间清0。if(key_scan()==0) //如果按键已经松开。= New_key) //大于0，非1个按键按下。//按键弹起或按其他按键，将长按时间清0。//按键弹起或按其他按键，将长按时间清0。
按键处理框架（短按，长按，连续按键）.rar_key scan 按键扫描_单片机 长按_按键处理_按键处理框架_长按按键程
07-15
单片机c语言按键扫面程序框架，有短按，连续按，长按1，长按2等功能。方便移植
基于状态机思想的按键扫描程序支持单按，连续按，长按模式。
Sun19910114的专栏
12-13 1773
typedef enum { ButtonsStateUp = 0, ButtonsStateDownJitter , ButtonsStateDown , ButtonsStateUpJitter } EnumButtonsState; typedef unsigned char uint8; typedef unsigned lon
【NiosII学习】第三篇、按键中断
大屁桃的博客
12-15 4637
第一部分、按键的储备知识 1、读写数据寄存器 IORD_ALTERA_AVALON_PIO_DATA(base);//base：是你设置引脚对应的地址，在sysm.h文件中找。 IOWR_ALTERA_AVALON_PIO_DATA(base, data);//base：是你设置引脚对应的地址，在sysm.h文件中找。data：是你想要写入的数据。 用法： 例如在按键中： K = IORD_ALTERA_AVALON_PIO_DATA(base); K = 0则证明按键被按下，K = 1 证
多功能检测按键-3 按键扫描 单按 长按 多个按键 响应方式
chuangwu2009的专栏
05-23 4436
/*************************************** // 函数功能：按键扫描 //这是我第三次对按键扫描的优化，为什么我要这么做呢，很简单， //我只想将简单的事情不断完善好 //第一次发表：http://blog.csdn.net/chuangwu2009/article/details/9466715 //第一次发表：http://blog.csdn.net/ch
stm32----定时器中断实现按键的长按，短按效果
weixin_46323814的博客
09-02 4194
stm32----定时器中断实现按键的长按，短按效果。
瑞萨单片机之外部中断实现按键的长按与短按(二)
小Young
09-12 3098
瑞萨单片机通过外部中断实现按键的长按与短按
按键的单击、双击、连续按、短按和长按实现思路
热门推荐
qq_28576837的博客
05-27 1万+
按键的单击、双击、连续按、短按和长按实现思路
STM32学习笔记 按键和中断基础
qq_52670281的博客
03-17 4059
第三章 按键和中断基础 3.1按键 按键信号的识别：一般来说，按键两个引脚的一端通过电阻上拉到高电平，另一端则接地。即：在没有按键按下的时候，输入引脚为高电平；当有按键按下，输入引脚则为低电平。 通过反复读取按键输入引脚的信号，然后识别高低电平来判断是否有按键触发。 为什么去抖动:按键的输入引脚有低电平产生不代表一定是有按键按下，可能是干扰信号，因此，需要通过去抖动处理，将这些干扰信号过滤，从而获得真实的按键触发信号。 去抖动:首次检测到按键输入引脚有低电平后，稍作延时，再次读取该引脚，如还是低电平，则确
请以STM32G030为硬件，写出一个用状态机方式运行的，能识别5个独立按键的程序，独立按键分别命名为上下左右中，同时能够识别双按键同时按下，同时长按，同时短按，单按键双击，单按键长按
06-08
好的，以下是一个使用状态机方式运行的，能够识别5个独立按键并且能够识别双按键同时按下、长按、短按、单按键双击、单按键长按的程序。这个程序使用了STM32G030为硬件平台，使用了HAL库进行编程。 ```c #include "stm32g0xx_hal.h" #include <stdbool.h> // 定义按键名称 #define KEY_UP 0x01 #define KEY_DOWN 0x02 #define KEY_LEFT 0x04 #define KEY_RIGHT 0x08 #define KEY_CENTER 0x10 // 定义按键状态 typedef enum { KEY_RELEASED = 0, // 按键释放状态 KEY_PRESSED = 1 // 按键按下状态 } KeyState; // 定义按键信息结构体 typedef struct { GPIO_TypeDef* port; // GPIO端口 uint16_t pin; // GPIO引脚 bool inverted; // 是否反相 KeyState state; // 按键状态 uint32_t time; // 按键按下的时间 uint8_t name; // 按键名称 } KeyInfo; // 初始化按键 void KeyInit(KeyInfo* key, GPIO_TypeDef* port, uint16_t pin, bool inverted, uint8_t name) { key->port = port; key->pin = pin; key->inverted = inverted; key->state = KEY_RELEASED; key->time = 0; key->name = name; GPIO_InitTypeDef GPIO_InitStruct = {0}; GPIO_InitStruct.Pin = pin; GPIO_InitStruct.Mode = GPIO_MODE_INPUT; GPIO_InitStruct.Pull = GPIO_NOPULL; HAL_GPIO_Init(port, &GPIO_InitStruct); } // 获取按键状态 KeyState GetKeyState(KeyInfo* key) { bool isPressed = HAL_GPIO_ReadPin(key->port, key->pin) ^ key->inverted; if (isPressed && (key->state == KEY_RELEASED)) { key->state = KEY_PRESSED; key->time = HAL_GetTick(); } else if (!isPressed && (key->state == KEY_PRESSED)) { key->state = KEY_RELEASED; } return key->state; } // 判断是否为长按事件 bool IsLongPress(KeyInfo* key) { if (GetKeyState(key) == KEY_PRESSED) { uint32_t timeDiff = HAL_GetTick() - key->time; if (timeDiff >= 1000) { return true; } } return false; } // 判断是否为短按事件 bool IsShortPress(KeyInfo* key) { if (GetKeyState(key) == KEY_RELEASED) { uint32_t timeDiff = HAL_GetTick() - key->time; if (timeDiff < 1000) { return true; } } return false; } // 判断是否为双击事件 bool IsDoubleClick(KeyInfo* key) { if (GetKeyState(key) == KEY_RELEASED) { uint32_t timeDiff = HAL_GetTick() - key->time; if ((timeDiff > 100) && (timeDiff < 300)) { return true; } } return false; } // 判断是否为双键同时按下事件 bool IsKeyCombination(KeyInfo* key1, KeyInfo* key2) { if ((GetKeyState(key1) == KEY_PRESSED) && (GetKeyState(key2) == KEY_PRESSED)) { return true; } return false; } int main(void) { // 初始化GPIO HAL_Init(); __HAL_RCC_GPIOA_CLK_ENABLE(); __HAL_RCC_GPIOB_CLK_ENABLE(); // 初始化按键 KeyInfo key_up, key_down, key_left, key_right, key_center; KeyInit(&key_up, GPIOA, GPIO_PIN_0, false, KEY_UP); KeyInit(&key_down, GPIOA, GPIO_PIN_1, false, KEY_DOWN); KeyInit(&key_left, GPIOA, GPIO_PIN_2, false, KEY_LEFT); KeyInit(&key_right, GPIOA, GPIO_PIN_3, false, KEY_RIGHT); KeyInit(&key_center, GPIOB, GPIO_PIN_4, false, KEY_CENTER); // 进入状态机 KeyState state = KEY_RELEASED; uint8_t curKey = 0, prevKey = 0; uint32_t curTime = 0, prevTime = 0; while (1) { switch (state) { case KEY_RELEASED: if (IsKeyCombination(&key_up, &key_down)) { state = KEY_UP_DOWN; } else if (IsKeyCombination(&key_left, &key_right)) { state = KEY_LEFT_RIGHT; } else if (IsLongPress(&key_center)) { state = KEY_CENTER_LONG; } else if (IsShortPress(&key_center)) { state = KEY_CENTER_SHORT; } else if (IsDoubleClick(&key_center)) { state = KEY_CENTER_DOUBLE; } else if (GetKeyState(&key_up) == KEY_PRESSED) { state = KEY_UP; } else if (GetKeyState(&key_down) == KEY_PRESSED) { state = KEY_DOWN; } else if (GetKeyState(&key_left) == KEY_PRESSED) { state = KEY_LEFT; } else if (GetKeyState(&key_right) == KEY_PRESSED) { state = KEY_RIGHT; } break; case KEY_UP: curKey = KEY_UP; curTime = HAL_GetTick(); if (IsShortPress(&key_up)) { printf("Key Up Short Pressed\n"); state = KEY_RELEASED; } else if (IsLongPress(&key_up)) { printf("Key Up Long Pressed\n"); state = KEY_RELEASED; } else if (IsDoubleClick(&key_up)) { printf("Key Up Double Clicked\n"); state = KEY_RELEASED; } break; case KEY_DOWN: curKey = KEY_DOWN; curTime = HAL_GetTick(); if (IsShortPress(&key_down)) { printf("Key Down Short Pressed\n"); state = KEY_RELEASED; } else if (IsLongPress(&key_down)) { printf("Key Down Long Pressed\n"); state = KEY_RELEASED; } else if (IsDoubleClick(&key_down)) { printf("Key Down Double Clicked\n"); state = KEY_RELEASED; } break; case KEY_LEFT: curKey = KEY_LEFT; curTime = HAL_GetTick(); if (IsShortPress(&key_left)) { printf("Key Left Short Pressed\n"); state = KEY_RELEASED; } else if (IsLongPress(&key_left)) { printf("Key Left Long Pressed\n"); state = KEY_RELEASED; } else if (IsDoubleClick(&key_left)) { printf("Key Left Double Clicked\n"); state = KEY_RELEASED; } break; case KEY_RIGHT: curKey = KEY_RIGHT; curTime = HAL_GetTick(); if (IsShortPress(&key_right)) { printf("Key Right Short Pressed\n"); state = KEY_RELEASED; } else if (IsLongPress(&key_right)) { printf("Key Right Long Pressed\n"); state = KEY_RELEASED; } else if (IsDoubleClick(&key_right)) { printf("Key Right Double Clicked\n"); state = KEY_RELEASED; } break; case KEY_CENTER_SHORT: printf("Key Center Short Pressed\n"); state = KEY_RELEASED; break; case KEY_CENTER_LONG: printf("Key Center Long Pressed\n"); state = KEY_RELEASED; break; case KEY_CENTER_DOUBLE: printf("Key Center Double Clicked\n"); state = KEY_RELEASED; break; case KEY_UP_DOWN: printf("Key Up and Down Pressed\n"); state = KEY_RELEASED; break; case KEY_LEFT_RIGHT: printf("Key Left and Right Pressed\n"); state = KEY_RELEASED; break; } // 判断单按键双击 if ((curKey != 0) && (curKey == prevKey)) { uint32_t timeDiff = curTime - prevTime; if ((timeDiff > 100) && (timeDiff < 300)) { printf("Key %d Double Clicked\n", curKey); curKey = 0; } } // 记录上一个按下的按键和时间 if (curKey != 0) { prevKey = curKey; prevTime = curTime; } } } ``` 在这个程序中，我们首先定义了按键名称以及按键状态枚举类型。然后我们定义了包含按键信息的结构体`KeyInfo`，包含GPIO端口、引脚、状态、按下时间以及按键名称等信息。接着我们定义了一些函数，包括初始化按键、获取按键状态、判断是否为长按事件、短按事件、双击事件以及双键同时按下事件等。最后我们通过状态机的方式来处理按键事件，包括单按键短按、长按、双击事件以及双键同时按下事件等。同时我们还记录了上一个按下的按键以及时间，以便判断单按键双击事件。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值