按键短按长按连发双击

最新推荐文章于 2024-06-06 15:43:28 发布
最新推荐文章于 2024-06-06 15:43:28 发布
阅读量658 收藏 5
点赞数 2
分类专栏： 单片机 文章标签： c++ 数据结构
原文链接：https://blog.csdn.net/huohongpeng/article/details/60118467#comments
版权

实现按键 长按 短按 连发 双击 处理

代码如下：

/*******************************************************************************
file : platform_key.h
author : huohongpeng 
date : 2017-03-02
description : advance application for key, base on gd gpio lib
*******************************************************************************/
#ifndef __PLATFORM_KEY_H__
#define __PLATFORM_KEY_H__
 
 
#define KEY_EVENT_NULL                     0x0000
#define KEY_EVENT_DOWN                     0x0001
#define KEY_EVENT_UP_SHORT                 0x0002
#define KEY_EVENT_UP_LONG                  0x0003
#define KEY_EVENT_UP_DOUBLE                0x0004
#define KEY_EVENT_SHORT                    0x0005
#define KEY_EVENT_LONG                     0x0006
#define KEY_EVENT_DOUBLE                   0x0007
 
/******************************************************************************
                           User Interface [START]
*******************************************************************************/
 
#define KEY0_NUM                           0x0001
#define KEY1_NUM                           0x0002
 
#define KEY0_DOWN               (KEY_EVENT_DOWN      | KEY0_NUM<<8)
#define KEY0_UP_SHORT           (KEY_EVENT_UP_SHORT  | KEY0_NUM<<8)
#define KEY0_UP_LONG            (KEY_EVENT_UP_LONG   | KEY0_NUM<<8)
#define KEY0_UP_DOUBLE          (KEY_EVENT_UP_DOUBLE | KEY0_NUM<<8)
#define KEY0_SHORT              (KEY_EVENT_SHORT     | KEY0_NUM<<8)
#define KEY0_LONG               (KEY_EVENT_LONG      | KEY0_NUM<<8) 
#define KEY0_DOUBLE             (KEY_EVENT_DOUBLE    | KEY0_NUM<<8)
 
#define KEY1_DOWN               (KEY_EVENT_DOWN      | KEY1_NUM<<8)
#define KEY1_UP_SHORT           (KEY_EVENT_UP_SHORT  | KEY1_NUM<<8)
#define KEY1_UP_LONG            (KEY_EVENT_UP_LONG   | KEY1_NUM<<8)
#define KEY1_UP_DOUBLE          (KEY_EVENT_UP_DOUBLE | KEY1_NUM<<8)
#define KEY1_SHORT              (KEY_EVENT_SHORT     | KEY1_NUM<<8)
#define KEY1_LONG               (KEY_EVENT_LONG      | KEY1_NUM<<8) 
#define KEY1_DOUBLE             (KEY_EVENT_DOUBLE    | KEY1_NUM<<8)
 
 
/******************************************************************************
                           User Interface [END]
*******************************************************************************/
 
 
void key_check_all_loop_1ms(void);
unsigned short key_read_value(void);
 
#endif


/*******************************************************************************
file : platform_key.c
author : huohongpeng 
data : 2017-03-02
description : advance application for key, base on gd gpio lib
*******************************************************************************/
#include "platform_key.h"
#include "GD32f1x0.h"
 
 
/*
 --------------------------------------------------------------------
|  short click                                                       |
|  ______                   ________                                 |
|     |  \                 /  |                                      |
|     |   \_______________/   |                                      |
|     |     |           |     |                                      |
|     |shake|  < long   |shake|                                      |
|                                                                    |
 -------------------------------------------------------------------
|  double click                                                      |
|  ______                   _____________                   ____     |
|     |  \                 /  |       |  \                 /  |      |
|     |   \_______________/   |       |   \_______________/   |      |
|     |     |           |     | < max |     |           |     |      |
|     |shake|  < long   |shake|dclick |shake|  any time |shake|      |
|                                                                    |
 --------------------------------------------------------------------
|  long click                                                        |
|  ______                                           ________         |
|     |  \                                         /  |              |
|     |   \_______________________________________/   |              |
|     |     |                                   |     |              |
|     |shake|             > long click          |shake|              |
|                                                                    |
 --------------------------------------------------------------------
   
*/
 
 
#define KEY_STATUS_DOWN_CHECK                0x00       
#define KEY_STATUS_DOWN_SHAKE                0x01
#define KEY_STATUS_DOWN_HANDLE               0x02
#define KEY_STATUS_LONG_CHECK                0x03
#define KEY_STATUS_SHORT_UP_SHAKE            0x04
#define KEY_STATUS_DOUBLE_CHECK              0x05
#define KEY_STATUS_SHORT_UP_HANDLE           0x06
#define KEY_STATUS_DOUBLE_DOWN_SHAKE         0x07
#define KEY_STATUS_DOUBLE_UP_CHECK           0x08
#define KEY_STATUS_DOUBLE_UP_SHAKE           0x09
#define KEY_STATUS_DOUBLE_UP_HANDLE          0x0a
#define KEY_STATUS_LONG_HANDLE               0x0b
#define KEY_STATUS_CONTINUE_CHECK            0x0c
#define KEY_STATUS_LONG_UP_SHAKE             0x0d
#define KEY_STATUS_LONG_UP_HANDLE            0x0e
 
 
#define KEY_READ_DOWN                        0x00  /* key is pressed          */
#define KEY_READ_UP                          0x01  /* Key isn't pressed       */ 
 
#define KEY_BUF_SIZE                         0x10  /* key value buffer size   */
 
static struct
{
    unsigned short value[KEY_BUF_SIZE];
    unsigned char rd;
    unsigned char wr;
}key_buf;
 
 
struct key_dev
{
    unsigned char status;              /* state machine status                */
    unsigned char num;                 /* number                              */
    unsigned short count_ms;           /* ms counter                          */
    unsigned short long_click_ms;      /* long click check min time           */
    unsigned short shake_filter_ms;    /* shake filter time                   */
    unsigned short max_dclick_ms;      /* double click max interval time      */
    unsigned short continue_send_ms;   /* after long, continue send interval  */
    unsigned char (*read_key)(void);   /* key read pin status function pointer*/
};
 
 
/******************************************************************************
                           User Interface [START]
*******************************************************************************/
 
unsigned char key0_read(void)
{
    if (GPIO_ReadInputBit(GPIOA, GPIO_PIN_0) == 0)
    {
        return KEY_READ_DOWN;
    }
    else
    {
        return KEY_READ_UP;
    }
}
 
unsigned char key1_read(void)
{
    if (GPIO_ReadInputBit(GPIOB, GPIO_PIN_7) == 0)
    {
        return KEY_READ_DOWN;
    }
    else
    {
        return KEY_READ_UP;
    }
}
 
 
struct key_dev key_dev[] = {
    {
     KEY_STATUS_DOWN_CHECK,
     KEY0_NUM,
     0,
     1500,
     20,
     300,
     500,
     (unsigned char (*)(void))key0_read,
    },
    {
     KEY_STATUS_DOWN_CHECK,
     KEY1_NUM,
     0,
     2000,
     20,
     200,
     300,
     (unsigned char (*)(void))key1_read,
    },
 
    /*
            .
            .
        user add other key 
            .
            .
    */
 
};
 
/******************************************************************************
                           User Interface [END]
*******************************************************************************/
 
 
 
 
 
 
 
static void key_write_value(unsigned short key_val);
static void key_status_down_check(struct key_dev *key_dev);
static void key_status_down_shake(struct key_dev *key_dev);
static void key_status_down_handle(struct key_dev *key_dev);
static void key_status_long_check(struct key_dev *key_dev);
static void key_status_short_up_shake(struct key_dev *key_dev);
static void key_status_double_check(struct key_dev *key_dev);
static void key_status_short_up_handle(struct key_dev *key_dev);
static void key_status_double_down_shake(struct key_dev *key_dev);
static void key_status_double_up_check(struct key_dev *key_dev);
static void key_status_double_up_shake(struct key_dev *key_dev);
static void key_status_double_up_handle(struct key_dev *key_dev);
static void key_status_long_hanle(struct key_dev *key_dev);
static void key_status_continue_check(struct key_dev *key_dev);
static void key_status_long_up_shake(struct key_dev *key_dev);
static void key_status_long_up_handle(struct key_dev *key_dev);
 
 
/**
description : write key vaule to buffer
param :  key_val - key value , (KEY_EVENT | KEY_NUMBER<<8) 
retval : None
author : huohongpeng
data : 2017-03-02
*/
void key_write_value(unsigned short key_val)
{   
    key_buf.value[key_buf.wr++] = key_val;
    key_buf.wr %= KEY_BUF_SIZE;
 
    /*
        overflow handle
    */
    if(key_buf.wr == key_buf.rd)
    {
        key_buf.rd++;
        key_buf.rd %= KEY_BUF_SIZE;
    }
}
 
/**
description : read key vaule from buffer
param : None
retval : key_val - key value , (KEY_EVENT | KEY_NUMBER<<8)
author : huohongpeng
data : 2017-03-02
*/
unsigned short key_read_value(void)
{
    unsigned short key_val;
 
    if(key_buf.wr == key_buf.rd)
    {
        key_val = KEY_EVENT_NULL;
    }
    else
    {
        key_val = key_buf.value[key_buf.rd++];
        key_buf.rd %= KEY_BUF_SIZE;
    }
 
    return key_val;
}
 
/**
description : check key whether press down
param : key_dev - key device pointer
retval : None
author : huohongpeng
data : 2017-03-02
*/
static void key_status_down_check(struct key_dev *key_dev)
{
    unsigned char key_read;
 
    key_read = key_dev->read_key();
 
    if(key_read == KEY_READ_DOWN)
    {
        key_dev->status = KEY_STATUS_DOWN_SHAKE;
        key_dev->count_ms = 0;
    }
}
 
/**
description : filter shake after key pressed down
param : key_dev - key device pointer
retval : None
author : huohongpeng
data : 2017-03-02
*/
static void key_status_down_shake(struct key_dev *key_dev)
{
    unsigned char key_read;
 
    key_dev->count_ms++;
 
    if(key_dev->count_ms < key_dev->shake_filter_ms)
    {
        return;
    }
 
    key_read = key_dev->read_key();
 
    if(key_read == KEY_READ_DOWN)
    {
        key_dev->status = KEY_STATUS_DOWN_HANDLE;
    }
    else
    {
        key_dev->status = KEY_STATUS_DOWN_CHECK;
    }
}
 
 
/**
description : key press down handle after pressed down filter shake  
param : key_dev - key device pointer
retval : None
author : huohongpeng
data : 2017-03-02
*/
static void key_status_down_handle(struct key_dev *key_dev)
{
    unsigned short key_val = key_dev->num<<8 | KEY_EVENT_DOWN;
    
    key_write_value(key_val);
 
    key_dev->status = KEY_STATUS_LONG_CHECK;
    key_dev->count_ms = 0;
 
}
 
/**
description : check key whether long click   
param : key_dev - key device pointer
retval : None
author : huohongpeng
data : 2017-03-02
*/
static void key_status_long_check(struct key_dev *key_dev)
{
    unsigned char key_read;
 
    key_dev->count_ms++;
    key_read = key_dev->read_key();
    
    if(key_dev->count_ms < key_dev->long_click_ms)
    {
        if(key_read == KEY_READ_UP)
        {
            key_dev->status = KEY_STATUS_SHORT_UP_SHAKE;                 
        }
 
        return;
    }
 
    key_dev->status = KEY_STATUS_LONG_HANDLE;            
    
}
 
/**
description : short cilck key up filter shake   
param : key_dev - key device pointer
retval : None
author : huohongpeng
data : 2017-03-02
*/
static void key_status_short_up_shake(struct key_dev *key_dev)
{
    unsigned char key_read;
    static unsigned short old = 0xffff;
 
    if(old == 0xffff)
    {
        old = key_dev->count_ms;
        key_dev->count_ms = 0;
    }
 
    key_dev->count_ms++;
 
    if(key_dev->count_ms < key_dev->shake_filter_ms)
    {
        return;
    }
 
    key_read = key_dev->read_key();
 
    if(key_read == KEY_READ_UP)
    {
        key_dev->status = KEY_STATUS_DOUBLE_CHECK;
        key_dev->count_ms = 0;
    }
    else
    {
        key_dev->status = KEY_STATUS_LONG_CHECK;
        key_dev->count_ms += old;        
    }
 
    old = 0xffff;
}
 
/**
description : double cilck check. we consider double click event if key pressed 
              down when after short click up and within max double click interval
param : key_dev - key device pointer
retval : None
author : huohongpeng
data : 2017-03-02
*/
static void key_status_double_check(struct key_dev *key_dev)
{
    unsigned char key_read;
 
    key_dev->count_ms++;
    key_read = key_dev->read_key();
    
    if(key_dev->count_ms < key_dev->max_dclick_ms)
    {
        if(key_read == KEY_READ_DOWN)
        {
            key_dev->status = KEY_STATUS_DOUBLE_DOWN_SHAKE;
            key_dev->count_ms = 0;                 
        }
    }
    else
    {
        key_dev->status = KEY_STATUS_SHORT_UP_HANDLE;            
    }
 
}
 
/**
description : short click key up handle
param : key_dev - key device pointer
retval : None
author : huohongpeng
data : 2017-03-02
*/
static void key_status_short_up_handle(struct key_dev *key_dev)
{
    unsigned short key_val;
 
    key_val= key_dev->num<<8 | KEY_EVENT_SHORT;
    
    key_write_value(key_val);
 
    key_val= key_dev->num<<8 | KEY_EVENT_UP_SHORT;
    
    key_write_value(key_val);
 
    key_dev->status = KEY_STATUS_DOWN_CHECK;
}
 
/**
description : double click key down filter shake
param : key_dev - key device pointer
retval : None
author : huohongpeng
data : 2017-03-02
*/
static void key_status_double_down_shake(struct key_dev *key_dev)
{
    unsigned char key_read;
    static unsigned short old = 0xffff;
 
    if(old == 0xffff)
    {
        old = key_dev->count_ms;
        key_dev->count_ms = 0;
    }
 
    key_dev->count_ms++;
 
    if(key_dev->count_ms < key_dev->shake_filter_ms)
    {
        return;
    }
 
    key_read = key_dev->read_key();
 
    if(key_read == KEY_READ_DOWN)
    {
        unsigned short key_val;
 
        key_val= key_dev->num<<8 | KEY_EVENT_DOUBLE;
    
        key_write_value(key_val);
 
        key_dev->status = KEY_STATUS_DOUBLE_UP_CHECK;
        key_dev->count_ms = 0;
    }
    else
    {
        key_dev->status = KEY_STATUS_DOUBLE_CHECK;
        key_dev->count_ms += old;        
    }
 
    old = 0xffff;
}
 
/**
description : double click key up check
param : key_dev - key device pointer
retval : None
author : huohongpeng
data : 2017-03-02
*/
static void key_status_double_up_check(struct key_dev *key_dev)
{
    unsigned char key_read;
 
    key_read = key_dev->read_key();
 
    if(key_read == KEY_READ_UP)
    {
        key_dev->status = KEY_STATUS_DOUBLE_UP_SHAKE;
        key_dev->count_ms = 0;
    }
}
 
/**
description : double click key up filter shake
param : key_dev - key device pointer
retval : None
author : huohongpeng
data : 2017-03-02
*/
static void key_status_double_up_shake(struct key_dev *key_dev)
{
    unsigned char key_read;
 
    key_dev->count_ms++;
 
    if(key_dev->count_ms < key_dev->shake_filter_ms)
    {
        return;
    }
 
    key_read = key_dev->read_key();
 
    if(key_read == KEY_READ_UP)
    {
        key_dev->status = KEY_STATUS_DOUBLE_UP_HANDLE;
    }
    else
    {
        key_dev->status = KEY_STATUS_DOUBLE_UP_CHECK;
    }
 
}
 
/**
description : double click key up handle
param : key_dev - key device pointer
retval : None
author : huohongpeng
data : 2017-03-02
*/
static void key_status_double_up_handle(struct key_dev *key_dev)
{
    unsigned short key_val;
 
    key_val= key_dev->num<<8 | KEY_EVENT_UP_DOUBLE;
    
    key_write_value(key_val);
 
    key_dev->status = KEY_STATUS_DOWN_CHECK;
}
 
/**
description : long click handle after long click check
param : key_dev - key device pointer
retval : None
author : huohongpeng
data : 2017-03-02
*/
static void key_status_long_hanle(struct key_dev *key_dev)
{
    unsigned short key_val;
 
    key_val= key_dev->num<<8 | KEY_EVENT_LONG;
    
    key_write_value(key_val);
 
    key_dev->status = KEY_STATUS_CONTINUE_CHECK;
    key_dev->count_ms = 0;
}
 
/**
description : continue send short click if long click time overflow
param : key_dev - key device pointer
retval : None
author : huohongpeng
data : 2017-03-02
*/
static void key_status_continue_check(struct key_dev *key_dev)
{
    unsigned char key_read;
    unsigned short key_val;
 
    key_dev->count_ms++;
 
    key_read = key_dev->read_key();
 
    if(key_read == KEY_READ_UP)
    {
        key_dev->status = KEY_STATUS_LONG_UP_SHAKE;
    }
 
    if(key_dev->count_ms < key_dev->continue_send_ms)
    {
        return;
    }
 
    if(key_dev->continue_send_ms == 0)
    {
        return;
    }
  
    key_val= key_dev->num<<8 | KEY_EVENT_SHORT;
    
    key_write_value(key_val);
    key_dev->count_ms = 0;
}
 
/**
description : long click key up filter shake
param : key_dev - key device pointer
retval : None
author : huohongpeng
data : 2017-03-02
*/
static void key_status_long_up_shake(struct key_dev *key_dev)
{
    unsigned char key_read;
    static unsigned short old = 0xffff;
 
    if(old == 0xffff)
    {
        old = key_dev->count_ms;
        key_dev->count_ms = 0;
    }
 
    key_dev->count_ms++;
 
    if(key_dev->count_ms < key_dev->shake_filter_ms)
    {
        return;
    }
 
    key_read = key_dev->read_key();
 
    if(key_read == KEY_READ_UP)
    {
        key_dev->status = KEY_STATUS_LONG_UP_HANDLE;
    }
    else
    {
        key_dev->status = KEY_STATUS_CONTINUE_CHECK;
        key_dev->count_ms += old;      
    }
    
    old = 0xffff;
}
 
/**
description : long click key up filter handle
param : key_dev - key device pointer
retval : None
author : huohongpeng
data : 2017-03-02
*/
static void key_status_long_up_handle(struct key_dev *key_dev)
{
    unsigned short key_val;
 
    key_val= key_dev->num<<8 | KEY_EVENT_UP_LONG;
    
    key_write_value(key_val);
 
    key_dev->status = KEY_STATUS_DOWN_CHECK;
}
 
/**
description : run key state machine once every 1ms
param : key_dev - key device pointer
retval : None
author : huohongpeng
data : 2017-03-02
*/
static void key_check_1ms(struct key_dev *key_dev)
{
    switch(key_dev->status)
    {
        case KEY_STATUS_DOWN_CHECK :
             key_status_down_check(key_dev);
             break;      
        case KEY_STATUS_DOWN_SHAKE : 
             key_status_down_shake(key_dev);
             break;           
        case KEY_STATUS_DOWN_HANDLE : 
             key_status_down_handle(key_dev);
             break;          
        case KEY_STATUS_LONG_CHECK : 
             key_status_long_check(key_dev);
             break;              
        case KEY_STATUS_SHORT_UP_SHAKE :  
             key_status_short_up_shake(key_dev);
             break;
        case KEY_STATUS_DOUBLE_CHECK :
             key_status_double_check(key_dev);
             break;
        case KEY_STATUS_SHORT_UP_HANDLE :
             key_status_short_up_handle(key_dev);
             break;
        case KEY_STATUS_DOUBLE_DOWN_SHAKE : 
             key_status_double_down_shake(key_dev);
             break;
        case KEY_STATUS_DOUBLE_UP_CHECK :
             key_status_double_up_check(key_dev);
             break;
        case KEY_STATUS_DOUBLE_UP_SHAKE :
             key_status_double_up_shake(key_dev);
             break;
        case KEY_STATUS_DOUBLE_UP_HANDLE :
             key_status_double_up_handle(key_dev);
             break;         
        case KEY_STATUS_LONG_HANDLE :
             key_status_long_hanle(key_dev);
             break;
        case KEY_STATUS_CONTINUE_CHECK : 
             key_status_continue_check(key_dev);
             break;
        case KEY_STATUS_LONG_UP_SHAKE : 
             key_status_long_up_shake(key_dev);
             break;
        case KEY_STATUS_LONG_UP_HANDLE :  
             key_status_long_up_handle(key_dev);
             break;
        default:
             key_dev->status = key_dev->status;
    }
}
 
/**
description : run all key state machine once every 1ms
param : key_dev - key device pointer
retval : None
author : huohongpeng
data : 2017-03-02
call :
       timer(1ms) interrupt handle 
*/
void key_check_all_loop_1ms(void)
{
    unsigned char key_num, i;
 
    key_num = sizeof(key_dev)/sizeof(struct key_dev);
 
    for(i = 0; i < key_num; i++)
    {
        key_check_1ms(&key_dev[i]);
    }
 
}
weixin_43991908
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
实现按键的长按、短按、双击.zip
07-12
在嵌入式系统开发中，特别是使用STM32F103这类微控制器时，处理按键的长按、短按和双击事件是一项常见的任务。这些功能可以为用户交互提供更多的控制选项，使得设备操作更加灵活。下面我们将详细介绍如何实现这些...
独立按键之长按、短按、单击、双击
风间琉璃的博客
03-28 7407
目录 一、长按与短按 二、单击与双击 一、长按与短按 在按键按下的时候，即key_down下降沿开始计时。给定一个计时时间，如果在这个计时时间之内检测到了key_up上升沿，即按键松开，则为短按。如果在这个定时时间内没有检测到key_up上升沿，则为长按。 uint8_t Key_Scan(void) { uint8_t val=0; if(HAL_GPIO_ReadPin(GPIOB, GPIO_PIN_0)==0) val =1; if(HAL_GPIO_ReadPin(G
[软件工具]左键连发工具左键连点工具使用教程
FL1623863129的博客
07-03 1344
这个是windows上使用个一个鼠标左键连发工具，效果就是你鼠标左键点击一下，会自动按指定次数点击多次，比如你设置一次点50下，你点一下左键就会自动左键点击50下。我们可以设置连发次数，默认15次，你可以设置大点但是越多时间越长。由于软件打开默认连发功能是关闭状态，主要是为了防止误操作，需要按F9开启连发功能。我们就可以实时使用连发功能，下面是点击一下后连发效果。左键连发软件是一个可以点击一下自动左键连续点击指定次数的软件，比如你设置20次，当你点击一次松开鼠标后，会自动左键连续点击20次。
STM32f103实现按键长按 短按 双击
最新发布
m0_65473174的博客
06-06 630
注意的是delay.h中是笔者写的简单的延迟函数，自行使用大家的延迟函数即可，只在消抖处用到了延时函数，其余部分没用用到。下面为大家介绍以下大体思路，我们知道每个I/O端口都会对应一个EXIT中断，由此我们可以使用EXIT的双边沿触发来实现TIM定时器的开启关闭，当检测按下时开启TIM定时器，当检测松开按键时关闭TIM定时器，从而记录按键按下的时间，根据按键按下的时间长短不同可以判断按键的长短按，另外需要设定标志位来判断双击，下面开始上代码。
按键短按、长按，双击
默铭
12-01 5064
整理的网上按键短按、长按，双击的关键代码和思路 （1） #include"Key_Board.h" /*记录按键按下时间 时间小于1.5S，按键为短按；时间大于1.5S，按键为长按*/ volatileunsignedintkey1_timing =0; /*记录两次短按之间的时间间隔*/ ...
按键的单击、双击、连续按、短按和长按实现思路
qq_28576837的博客
05-27 9400
按键的单击、双击、连续按、短按和长按实现思路
STM32F103ZET6【标准库函数开发】------02.2 按键实现短按、长按、双击的效果（非中断方式）
m0_67391870的博客
05-15 1892
一、硬件介绍 正点原子战舰开发板 LED0-----PB5 LED1-----PE5 KEY0-----PA4 二、实现目的 开机LED0、LED1均熄灭 单击KEY0,LED0点亮、LED1熄灭 双击KEY0，LED0熄灭、LED1点亮 长按，LED0，LED1均熄灭 三、设计思路 1、两个LED对应的IO设置为推挽输出，高电平，保证开机时灯处于熄灭状态 2、按键KEY0设置为上拉输入，按下后为低电平，松手为高电平 3、单击、双击、长按的区别示意图如下 首先需要区分单击和长按，可以看到长按就是按下的
单片机独立按键模块（含短按，长按，连发功能）
03-30
在这个特定的项目中，我们关注的是一个包含短按、长按和连发功能的按键模块，它基于定时器0，并且使用了12.000MHz的晶振频率。下面将详细讨论这些知识点。 首先，单片机是指集成了微处理器、存储器和外围接口的集成...
连发小工具 按键连发 按键快发
10-27
【标题】：“连发小工具 按键连发 按键快发”这个标题指的是一款专门用于实现按键连续快速触发的软件工具。在游戏或者某些需要频繁按键操作的场景下，这样的工具能够极大地提高效率，减轻用户的操作负担。 【描述】...
IR.rar_IR_STB_dvd_按键连发
09-20
描述中的关键点在于“批量按键连发”，这是一个编程实现的功能，允许用户或系统一次性发送多个遥控器按键命令，而无需手动逐个按下。这对于那些需要进行多步骤设置或测试的电视、DVD和STB等设备来说，是一个高效的...
SET_AHK按键连发工具
02-20
SET_AHK.exe是该工具的可执行文件，双击运行后，用户可以在其界面中配置连发参数，如连发速度、按键选择、热键设定等。同时，由于AutoHotkey的开源性质，用户可以根据个人需求修改或扩展源代码，实现更个性化的功能...
按键长按，短按，长按，双击.zip
08-06
直接在.h里改一下引脚就可以了。我这是做的三个按键的。按键长按，短按，长按，双击。调用就更简单了，比如， if(key2==long_press) OLED_Refresh_Gram();
单片机按键长按 短按 组合按 双击程序
01-21
有关单片机的 按键 长按 短按 双击 组合按程序分享啊
按键长按、短按、双击检测。
09-07
通过状态机的方式实现按键的短按、长按、双击检测，同时按键可以灵活增添删除。方便移植。。。。。。。。。。。。。。。。。。。。。。。。。。。
蓝桥杯单片机----独立按键的基本控制（长按、短按、双击）
朽木自雕i的博客
04-19 1万+
在CT107D单片机综合训练平台上，首先将J5处的跳帽接到2~3引脚，使按键S4~S7四个按键的另外一端接地从而成为4个独立键盘。在扫描按键的过程中，发现有按键触发信号后，先做去抖动处理，当确认为按键按下时，才进行相应的功能处理。 设计内容： 1、按下S7后抬起，L1点亮，再次按下S7，L1熄灭； 2、长按S6，L2点亮，松开，L2熄灭； 3、双击S5，L3点亮； 4、双击S4，L3熄灭。 ...
JS 中实现鼠标长按连续触发
UserGuan的博客
07-29 1800
【代码】JS 中实现鼠标长按连续触发。
ESP32的长按、短按、双击、多击 按键检测实现
SimonLiu的博客
05-22 1万+
乐鑫官方有个仓库叫做esp-iot-solution,里面有很多常用外设的驱动和物联网场景的实现代码。其中就有一个button模块来实现按键的长按、短按检测： espressif/esp-iot-solution › components › general › button › button。 README翻译如下： 本模块封装了一个按键对象 一个按键设备定义如下： GPIO 端口号 信号有效电平 触发模式：触发模式决定了是否调用连续触发 多少秒后开始进行进行连续触发 一个按键设备提供如下
51单片机独立按键长按与短按（长按触发连发功能）以及双击功能
热门推荐
m0_63192327的博客
04-11 1万+
独立按键的长按、短按与双击的判断，运用了状态的分析，短按和长按的区别为按键按下的时间不同所以从短按状态到长按状态的条件为按键按下的时间超过设定的长按时间，而二者的共同点为：按键只按下一次。而双击与前者的不同在于双击按键按下了两次。 我在这先识别【单击】和【长按】然后在有一次按键按下的基础下，且必须是【单击】的情况下再去在规定的间隔内检测【双击】。 由于在我们按键按下的时候会有抖动，实际中会有这种情况：按键松开了但没松完，或者按键没有完全按下，只是很轻的按单片机也会判断为【单击】，所以我们在这需要设置判.
C语言处理按键的 单击（短按），长按，双击，多击 处理
ZenNaiHeQiao的专栏
01-08 1万+
【一】： （1）如果为按键按下到释放的一个过程，t1 如果大于 250ms 认为按键有效 否则 按键无效，不做处理。 （2）如果联系两个双脉冲，脉冲之间相差时间t2 < 1S 认为是 双按键 否则 判定为两次不相干的按键行为。 （3）如果按下时间t3 >=5s 判定为长按键 【二】 按键的处理函数 void APP_KEY_Task(void) 每5ms 调用一次 该函数需...
windows电脑按键连发工具 csdn
11-21
Windows电脑的按键连发工具是指能够实现按键连发功能的软件工具。按键连发是指按下一个按键后，该按键会连续不断地重复触发，直到按键松开。这在某些特定的游戏或软件操作中非常有用。 CSDN是中国最大的技术社区，提供了大量的IT技术资源和开发者社交平台。在CSDN上，可以找到各种编程开发、数据库、网络技术等方面的问题解答、教程、项目经验分享等内容。一般来说，CSDN上有很多软件开发和应用技术相关的讨论，其中也包括Windows电脑按键连发工具的介绍和各种软件推荐。 在CSDN上搜索Windows电脑按键连发工具，可以找到很多相关的帖子、下载链接和使用教程。这些工具可以帮助用户在游戏或软件操作中实现按键连发的功能，提高效率和游戏体验。根据个人的需求和喜好，可以选择不同的按键连发工具，有些工具甚至可以自定义连发间隔、设置连发次数等功能。 总之，CSDN是一个资源丰富的技术社区，为用户提供了许多关于Windows电脑按键连发工具的信息和下载资源。用户可以在CSDN上找到合适的按键连发工具，提高在游戏和软件操作中的效率和体验。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值