单片机模块学习之键盘

最新推荐文章于 2022-04-04 16:42:54 发布
最新推荐文章于 2022-04-04 16:42:54 发布
阅读量690 收藏 3
点赞数

转载一位大神的，很全

一篇理解按键扫描的思想的博文。

理论

按键涉及到的重要知识点就是扫描和消抖了！

关于扫描，主要三种循环查询，定时查询，中断响应，当然各有优缺点，这里来总结下先。

1、循环查询

在一个循环函数里不断地扫描按键值，获取按下的按键。

优点：实现简单。
缺点：消抖需要浪费宝贵的CPU时间，且实时性不足(等待)。

2、定时查询

在中断服务函数里扫描按键活的按键值，根据按键按下的值然后存入缓冲区，等主函数有需要再来处理按键消息。（关于消息机制其实是一个很有意思的东西，这里这样称不知道准不准确。。。）

优点：避免消抖浪费时间，不会丢失捕捉按键按下，容易实现按键按下，长按，以及弹起等动作的识别。
缺点：需要使用定时器中断。

3、中断响应

按键按下触发中断，获取相应的按键值，需要进行消抖处理。
优点：实时性好。
缺点：需要微控制器支持中断，并且消抖浪费CPU资源。

通过上面的分析我们也不难猜出，其实应用比较好的还是定时查询的方式，既可以识别多种按键状态，还不必消抖浪费CPU资源。

实验

①、独立按键

这里写图片描述

1-2短接实现矩阵按键。
2-3短接实现独立按键。

1个独立按键是每2ms扫描一次(进一次中断保存一下当前值)，获取连续8个当前值，也就是耗费 2*8 = 16ms。

独立按键，同时使用一个数码管实现按一下+1的操作。（注意J5插针在右边）

/*
*******************************************************************************
* 文件名：
* 描  述：
* 作  者：CLAY
* 版本号：v1.0.0
* 日  期: 
* 备  注：S4每次加1，S5每次加2，S6每次加3，S7每次加4
*         
*******************************************************************************
*/

#include <stc15.h>

sbit KEY_IN_1 = P3^3;
sbit KEY_IN_2 = P3^2;
sbit KEY_IN_3 = P3^1;
sbit KEY_IN_4 = P3^0;

typedef unsigned char u8;
typedef unsigned int  u16;
typedef unsigned long u32;

u8 code LedChar[] = {  
    0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
    0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
}; 
u8 LedBuff[] = {
    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
};
u8 KeySta[4] = {1, 1, 1, 1};
u8 KeyCodeMap[4] = {'1', '2', '3', '4'};

u8 T0RH;
u8 T0RL;
u16 cnt = 0;

void CloseFucker();
void ConfigTimer0(u16 ms);
void ShowNumber(u16 dat);
void KeyDriver();

void main()
{
    CloseFucker();
    ConfigTimer0(2);//2ms一扫。
    EA = 1;
    ShowNumber(0);

    while(1)
    {   
        KeyDriver();
    }
}

void KeyAction(u8 keycode)
{
    if(keycode == '1')
    {
        cnt += 1;
        ShowNumber(cnt);
    } 
    else if(keycode == '2')
    {
        cnt += 2;
        ShowNumber(cnt);
    } 
    else if(keycode == '3')
    {
        cnt += 3;
        ShowNumber(cnt);
    } 
    else if(keycode == '4')
    {
        cnt += 4;
        ShowNumber(cnt);
    }   
}

void KeyDriver()
{
    u8 i;
    static u8 backup[4] = {1, 1, 1, 1};

    for(i=0; i<4; i++)
    {
        if(KeySta[i] != backup[i])
        {
            if(backup[i] != 0)
            {
                KeyAction(KeyCodeMap[i]);
            }
            backup[i] = KeySta[i];
        }
    }
}


void CloseFucker()
{
    P2 = (P2 & 0x1F) | 0x80;
    P0 = 0xFF;
    P2 = P2 & 0x1F;

    P2 = (P2 & 0x1F) | 0xA0;
    P0 = 0xAF;
    P2 = P2 & 0x1F;
}

void ConfigTimer0(u16 ms)
{
    u32 tmp;

    tmp = 11059200 / 12;
    tmp = (tmp * ms) / 1000;
    tmp = 65536 - tmp;
    T0RH = (u8)(tmp >> 8);
    T0RL = (u8)tmp;
    TMOD &= 0xF0;
    TMOD |= 0x01;
    TH0 = T0RH;
    TL0 = T0RL;
    ET0 = 1;
    TR0 = 1;
}

void ShowNumber(u16 dat)
{
    char i;
    u8 buf[8];

    for(i=0; i<8; i++)
    {
        buf[i] = dat % 10;
        dat /= 10;
    }
    for(i=7; i>0; i--)
    {
        if(buf[i] == 0)
            LedBuff[i] = 0xFF;
        else
            break;
    }
    for( ; i>=0; i--)
    {
        LedBuff[i] = LedChar[buf[i]];
    }
}

void LedScan()
{
    static u8 index = 0;

    P2 = (P2 & 0x1F) | 0xE0;
    P0 = 0xFF;
    P2 = P2 & 0x1F;

    P2 = (P2 & 0x1F) | 0xC0;
    P0 = 0x80 >> index;
    P2 = P2 & 0x1F;

    P2 = (P2 & 0x1F) | 0xE0;
    P0 = LedBuff[index];
    P2 = P2 & 0x1F;

    if(index < 7)
        index++;
    else
        index = 0;
}

void KeyScan()
{
    u8 i;
    static u8 keybuff[4] = {0xFF, 0xFF, 0xFF, 0xFF};

    keybuff[0] = (keybuff[0] << 1) | KEY_IN_1;
    keybuff[1] = (keybuff[1] << 1) | KEY_IN_2;
    keybuff[2] = (keybuff[2] << 1) | KEY_IN_3;
    keybuff[3] = (keybuff[3] << 1) | KEY_IN_4;

    for(i=0; i<4; i++)
    {
        if(keybuff[i] == 0xFF)
        {
            KeySta[i] = 1;
        }
        else if(keybuff[i] == 0x00)
        {
            KeySta[i] = 0;
        }
        else
        {}
    }
}   

void interruptTimer0() interrupt 1
{
    TH0 = T0RH;
    TL0 = T0RL; 

    LedScan();
    KeyScan();
}



 
 



②、矩阵键盘



1个独立按键的时候，一端是接地的。 

这里写图片描述



同理，矩阵按键无非就是软件设置分别接地而已。



 
 



关于扫描时间，这里如果还是2ms, 8个扫描值的话。那么4行按键，每个按键扫8次，也就是2*4*8 = 64ms……有点长了。我们改成，1ms一扫，每个按键扫4次。1*4*4 = 16ms 和 1个独立按键的时间一样！



矩阵按键映射关系



这里写图片描述





/*
*******************************************************************************
* 文件名：
* 描  述：
* 作  者：CLAY
* 版本号：v1.0.0
* 日  期: 
* 备  注：显示对应的0-9
*         
*******************************************************************************
*/

#include <stc15.h>

typedef unsigned char u8;
typedef unsigned int  u16;
typedef unsigned long u32;

sbit KEY_OUT_1 = P3^0;
sbit KEY_OUT_2 = P3^1;
sbit KEY_OUT_3 = P3^2;
sbit KEY_OUT_4 = P3^3;
sbit KEY_IN_4 = P3^4;
sbit KEY_IN_3 = P3^5;
sbit KEY_IN_2 = P4^2;
sbit KEY_IN_1 = P4^4;


u8 code LedChar[] = {
    0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
    0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
}; 
u8 LedBuff[] = {
    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
};

u8 KeySta[4][4] = {
    {1, 1, 1, 1}, {1, 1, 1, 1,}, {1, 1, 1, 1}, {1, 1, 1, 1}
};

u8 KeyCodeMap[4][4] = { 
    {'1', '2',  '3',  0x26},
    {'4', '5',  '6',  0x25},
    {'7', '8',  '9',  0x28},
    {'0', 0x1B, 0x0D, 0x27}
};

u8 T0RH;
u8 T0RL;

void CloseFucker();
void ConfigTimer0(u16 ms);
void KeyDriver();

void main()
{
    CloseFucker();
    ConfigTimer0(1);
    EA = 1;

    while(1)
    {
        KeyDriver();
    }
}

void ShowNumber(u8 dat)
{
    char i;
    u8 buf[8];

    for(i=0; i<8; i++)
    {
        buf[i] = dat % 10;
        dat /= 10;
    }
    for(i=7; i>0; i--)
    {
        if(buf[i] == 0)
            LedBuff[i] = 0xFF;
        else
            break;
    }
    for( ; i>=0; i--)
    {
        LedBuff[i] = LedChar[buf[i]];
    }
}

void KeyAction(u8 keycode)
{
    if((keycode >= '0') && (keycode <= '9'))
    {
        ShowNumber(keycode - '0');
    }
}

void KeyDriver()
{
    u8 i, j;
    static u8 backup[4][4] = {
        {1, 1, 1, 1}, {1, 1, 1, 1,}, {1, 1, 1, 1}, {1, 1, 1, 1}
    };

    for(i=0; i<4; i++)
    {
        for(j=0; j<4; j++)
        {
            if(KeySta[i][j] != backup[i][j])
            {
                if(backup[i][j] != 0)
                {
                    KeyAction(KeyCodeMap[i][j]);
                }
                backup[i][j] = KeySta[i][j];
            }
        }
    }
}


void CloseFucker()
{
    P2 = (P2 & 0x1F) | 0x80;
    P0 = 0xFF;
    P2 = P2 & 0x1F;

    P2 = (P2 & 0x1F) | 0xA0;
    P0 = 0xAF;
    P2 = P2 & 0x1F;
}

void ConfigTimer0(u16 ms)
{
    u32 tmp;

    tmp = 11059200 / 12;
    tmp = (tmp * ms) / 1000;
    tmp = 65536 - tmp;
    T0RH = (u8)(tmp >> 8);
    T0RL = (u8)tmp;
    TMOD &= 0xF0;
    TMOD |= 0x01;
    TH0 = T0RH;
    TL0 = T0RL;
    ET0 = 1;
    TR0 = 1;
}

void LedScan()
{
    static u8 index = 0;

    P2 = (P2 & 0x1F) | 0xE0;
    P0 = 0xFF;
    P2 = P2 & 0x1F;

    P2 = (P2 & 0x1F) | 0xC0;
    P0 = 0x80 >> index;
    P2 = P2 & 0x1F;

    P2 = (P2 & 0x1F) | 0xE0;
    P0 = LedBuff[index];
    P2 = P2 & 0x1F;

    if(index < 7)
        index++;
    else
        index = 0;
}

void KeyScan()
{
    u8 i;
    static u8 keyout = 0;
    static u8 keybuff[4][4] = {
        {0xFF, 0xFF, 0xFF, 0xFF}, {0xFF, 0xFF, 0xFF, 0xFF},
        {0xFF, 0xFF, 0xFF, 0xFF}, {0xFF, 0xFF, 0xFF, 0xFF}
    };

    switch(keyout)
    {
        case 0: KEY_OUT_1 = 0; KEY_OUT_4 = 1; break;
        case 1: KEY_OUT_2 = 0; KEY_OUT_1 = 1; break;
        case 2: KEY_OUT_3 = 0; KEY_OUT_2 = 1; break;
        case 3: KEY_OUT_4 = 0; KEY_OUT_3 = 1; break;
        default : break;
    }

    keybuff[keyout][0] = (keybuff[keyout][0] << 1) | KEY_IN_1;
    keybuff[keyout][1] = (keybuff[keyout][1] << 1) | KEY_IN_2;
    keybuff[keyout][2] = (keybuff[keyout][2] << 1) | KEY_IN_3;
    keybuff[keyout][3] = (keybuff[keyout][3] << 1) | KEY_IN_4;

    for(i=0; i<4; i++)
    {
        if((keybuff[keyout][i] & 0x0F) == 0x0F)
            KeySta[keyout][i] = 1;
        else if((keybuff[keyout][i] & 0x0F) == 0x00)
            KeySta[keyout][i] = 0;
        else
        {}
    }

    keyout++;
    keyout &= 0x03;
}

void interruptTimer0() interrupt 1
{
    TH0 = T0RH;
    TL0 = T0RL;

    LedScan();
    KeyScan();

}


  
  



③、长按键



如果上面所介绍的都没有问题了的话，就可以在其上的基础上再来了解一下长按键的实现了！ 拿独立按键来说，短按下只加一回，长按一直加，思路也很简单，用到了阈值的思路，这个要特别注意长按的加入不能影响到短按！



设置一个像KeySta的全局变量KeyDownTime，用来保存每个按键按下的时间累加，只要弹起就清零，这个是在KeyScan()里面进行操作的，也是和KeySta状态再一起进行判断的！ 

然后还需要个TimeThr这个在KeyDriver()里面，初始值为1000。如果检测到按下，执行按键动作函数，继续往下执行，如果检测到某个按键的KeyDownTime不为0，再判断是否大于阈值，大于阈值也要执行按键动作函数，然后让阈值增大，调节阈值增量可以控制增长速度。一旦KeyDownTime等于0，就是按键弹起来了，让阈值回归1000。



看下怎么实现吧!



以独立按键的实验为例，矩阵按键同理



/*
*******************************************************************************
* 文件名：
* 描  述：
* 作  者：CLAY
* 版本号：v1.0.0
* 日  期: 
* 备  注：S4每次加1，S5每次加2，S6每次加3，S7每次加4
*         
*******************************************************************************
*/

#include <stc15.h>

sbit KEY_IN_1 = P3^3;
sbit KEY_IN_2 = P3^2;
sbit KEY_IN_3 = P3^1;
sbit KEY_IN_4 = P3^0;

typedef unsigned char u8;
typedef unsigned int  u16;
typedef unsigned long u32;

u8 code LedChar[] = {  
    0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xF8,
    0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
}; 
u8 LedBuff[] = {
    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
};
u8 KeySta[4] = {1, 1, 1, 1};
u16 KeyDownTime[4] = {0, 0, 0, 0};
u8 KeyCodeMap[4] = {'1', '2', '3', '4'};

u8 T0RH;
u8 T0RL;
u16 cnt = 0;

void CloseFucker();
void ConfigTimer0(u16 ms);
void ShowNumber(u16 dat);
void KeyDriver();

void main()
{
    CloseFucker();
    ConfigTimer0(2);//2ms一扫。
    EA = 1;
    ShowNumber(0);

    while(1)
    {   
        KeyDriver();
    }
}

void KeyAction(u8 keycode)
{
    if(keycode == '1')
    {
        cnt += 1;
        ShowNumber(cnt);
    } 
    else if(keycode == '2')
    {
        cnt += 2;
        ShowNumber(cnt);
    } 
    else if(keycode == '3')
    {
        cnt += 3;
        ShowNumber(cnt);
    } 
    else if(keycode == '4')
    {
        cnt += 4;
        ShowNumber(cnt);
    }   
}

void KeyDriver()
{
    u8 i;
    static u8 backup[4] = {1, 1, 1, 1};
    static u16 TimeThr[4] = {1000, 1000, 1000, 1000};

    for(i=0; i<4; i++)
    {
        if(KeySta[i] != backup[i])
        {
            if(backup[i] != 0)
            {
                KeyAction(KeyCodeMap[i]);
            }
            backup[i] = KeySta[i];
        }
        if(KeyDownTime[i] > 0)
        {
            if(KeyDownTime[i] > TimeThr[i])
            {
                KeyAction(KeyCodeMap[i]);
                TimeThr[i] += 200;
            }   
        }
        else
        {
            TimeThr[i] = 1000;
        }
    }
}


void CloseFucker()
{
    P2 = (P2 & 0x1F) | 0x80;
    P0 = 0xFF;
    P2 = P2 & 0x1F;

    P2 = (P2 & 0x1F) | 0xA0;
    P0 = 0xAF;
    P2 = P2 & 0x1F;
}

void ConfigTimer0(u16 ms)
{
    u32 tmp;

    tmp = 11059200 / 12;
    tmp = (tmp * ms) / 1000;
    tmp = 65536 - tmp;
    T0RH = (u8)(tmp >> 8);
    T0RL = (u8)tmp;
    TMOD &= 0xF0;
    TMOD |= 0x01;
    TH0 = T0RH;
    TL0 = T0RL;
    ET0 = 1;
    TR0 = 1;
}

void ShowNumber(u16 dat)
{
    char i;
    u8 buf[8];

    for(i=0; i<8; i++)
    {
        buf[i] = dat % 10;
        dat /= 10;
    }
    for(i=7; i>0; i--)
    {
        if(buf[i] == 0)
            LedBuff[i] = 0xFF;
        else
            break;
    }
    for( ; i>=0; i--)
    {
        LedBuff[i] = LedChar[buf[i]];
    }
}

void LedScan()
{
    static u8 index = 0;

    P2 = (P2 & 0x1F) | 0xE0;
    P0 = 0xFF;
    P2 = P2 & 0x1F;

    P2 = (P2 & 0x1F) | 0xC0;
    P0 = 0x80 >> index;
    P2 = P2 & 0x1F;

    P2 = (P2 & 0x1F) | 0xE0;
    P0 = LedBuff[index];
    P2 = P2 & 0x1F;

    if(index < 7)
        index++;
    else
        index = 0;
}

void KeyScan()
{
    u8 i;
    static u8 keybuff[4] = {0xFF, 0xFF, 0xFF, 0xFF};

    keybuff[0] = (keybuff[0] << 1) | KEY_IN_1;
    keybuff[1] = (keybuff[1] << 1) | KEY_IN_2;
    keybuff[2] = (keybuff[2] << 1) | KEY_IN_3;
    keybuff[3] = (keybuff[3] << 1) | KEY_IN_4;

    for(i=0; i<4; i++)
    {
        if(keybuff[i] == 0xFF)
        {
            KeySta[i] = 1;
            KeyDownTime[i] = 0;
        }
        else if(keybuff[i] == 0x00)
        {
            KeySta[i] = 0;
            KeyDownTime[i] += 4;
        }
        else
        {}
    }
}   

void interruptTimer0() interrupt 1
{
    TH0 = T0RH;
    TL0 = T0RL; 

    LedScan();
    KeyScan();
}


   
   





小结



1、充分利用独立按键和矩阵按键再次感受模块化编程的便利，应用层和底层分离，维护修改记忆都方便，一石好几鸟。



2、注意程序中KEY_IN和KEY_OUT引脚定义以及KeyCodeMap的定义。
StarAire
关注
蓝桥杯单片机模块练习之按键扫描
qq_45225613的博客
11-20 673
蓝桥杯单片机比赛系列3按键扫描 按键扫描原理及实现 在独立键盘模式时，要将J5跳在BTN模式。也就是J5中2，3短路。此时S7,S6,S5,S4一端直接接地，一端连接P30,P31,P32,P33。按键按下时P30,P31,P32,P33都为低电平。在程序中判断即可，为了防止抖动造成误判，要加延迟。代码如下。 void keyscan() { if(P30==0) { delay(5); if(P30==0) { //S7动作 } while(!P3
STM32小白进阶之路----按键的模块化，低延时，高灵敏
我云的博客
08-18 3287
两种按键查询方法，两种方式处理第一种方法：扫描查询法 优点：无延迟，高灵敏，无中断 思想：也是别人的代码总结出来的，当按键连续读到10个或者20（这个看你的按键多敏感，我的10就够了）低电平，就算按键按下了 //需要循环扫描 u8 IsKey0Down() { static u16 iCount = 0; if(GPIO_ReadInputDataBit(GPIOE,GPI
单片机键盘模块原理图
05-11
单片机键盘模块原理图，恩就是这样对的，恩，是的是原理图恩恩
【蓝桥杯单片机组模块】4、按键模块
悟已往之不谏 知来者之可追
02-08 4158
不积跬步无以至千里，不积小流无以成江海。 一篇理解按键扫描的思想的博文。 理论 按键涉及到的重要知识点就是扫描和消抖了！ 关于扫描，主要三种循环查询，定时查询，中断响应，当然各有优缺点，这里来总结下先。 1、循环查询 在一个循环函数里不断地扫描按键值，获取按下的按键。 优点：实现简单。 缺点：消抖需要浪费宝贵的CPU时间，且实时性不足(等待)。 2、定时查询 在中断...
单片机系统一个非常实用的按键处理框架MultiButton
weixin_41656917的博客
10-16 3888
单片机系统一个非常实用的按键处理框架MultiButton前言一、MultiButton 是什么？2. 使用步骤和代码的问题2.1 使用步骤2.2 按键库的问题2.3 按键库一些默认参数的配置3. 代码解读 前言 在嵌入式开发中，对于输入设备有这几种，屏幕、按键、编码器等。 按键是我们使用最常见的一种。但是处理按键的时候也有一些麻烦之处，比方说我们对于一个按键进行程序消抖、区分按键单击、双击、长按、短按，如果没有一个按键驱动框架是很难实现的 ，在这里推荐一个非常好用的按键处理框架MultiButton
蓝桥杯模块练习-矩阵按键
03-11
蓝桥杯单片机设计与开发—
单片机系统与标准PC键盘的接口模块设计
08-14
本文介绍了一种设计，即构建一个接口模块，该模块能够接收标准PC键盘产生的位置扫描码，并将其转换为标准的ASCII码、OEM扫描码或Windows虚拟键代码，然后通过并行或串行方式将这些编码传递给单片机。 接口模块的...
51清翔单片机模块化代码
05-21
《51清翔单片机模块化代码》是针对51系列单片机进行系统化、模块化编程的一份宝贵资料。51单片机，作为广泛应用的微控制器，广泛应用于电子设备、智能家居、工业控制等领域。模块化代码设计的核心理念是将复杂系统...
单片机独立按键模块（含短按，长按，连发功能）
03-30
*独立按键扫描程序,定时器0 *本程序采用晶振频率12.000MHz *长，短，连发按键 *外部函数 extern uint8 keyScan4(); //返回值：十位指示按键位，个位指示短长按
4个独立按键设置四位数.c
03-19
4个独立按键设置四位数.c已经通过试验.
KEYscan-按键扫描程序
01-30
按键扫描程序编写示例，能正常使用，编译环境是PM+，所用单片机是NEC78F0513，比较简单
键盘对应数字-keycode值大全
07-12
键盘对应数字-keycode值大全键盘对应数字-keycode值大全
单片机蓝桥杯——长按和短按
weixin_52801934的博客
04-04 1841
题目： 数码管后三位显示计数值count，范围是0~999 若S4按下，计数值加一，长按1s后，计数值一直加; 若S5按下，计数值减一，长按1s后，计数值一直减； 若S6按下，计数值清零。 代码如下： #include "STC15F2K60S2.h" #include "intrins.h" #define uchar unsigned char #define uint unsigned int uchar segCode[25]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,
键盘模块设计
Larry的专栏
08-05 3838
在ARM嵌入式应用中，人机交互对话最通用的方法就是通过键盘和LCD显示进行的，操作者通过键盘向系统发送各种指令或置入必要的数据信息。键盘模块设计的好坏，直接关系到系统的可靠性和稳定性。1 实例说明在ARM应用系统中，键盘扫描只是ARM的工作之一，ARM在忙于各项工作任务时，如何兼顾键盘的输入，则取决于键盘的工作方式。键盘工作方式的选取原则是既要保证能及时响应按键操作，又要不
keyCodeMap
u013934392的博客
08-04 389
keyCodeMap: { “A”:65, “B”:66, “C”:67, “D”:68, “E”:69, “F”:70, “G”:71, “H”:72, “I”:73, “J”:74, “K”:75, “L”:76, “M”:77, “N”:78, “O”:79, “P”:80, “Q”:81, “R”:82, “S”:83, “T”:84, “U”:85, “V”:86, “W”:87, “X...
28335学习笔记4——F28335之3*3按键控制（包含按键消抖和按键检测方法介绍）
qq_39529052的博客
05-17 3372
1.按键消抖 通常的按键所用开关为机械弹性开关,当机械触点断开、 闭合时， 电压信号如下图所示 由于机械点的弹性作用，按键开关在闭合时不会马上稳定的接通，在断开时也不会一下子断开。在闭合和断开的瞬间均伴随着一连串的抖动。抖动时间的长短由按键的机械特性决定的， 一般为 5ms 到 10ms。 按键稳定闭合时间的长短则由操作人员的按键动作决定的， 一般为零点几秒至数秒。 按键抖动会引起按键被误读多次。 为了确保 CPU 对按键的一次闭合仅作一次处理， 必须进行消抖。 按键消抖有两种方式， 一种是硬件消抖（在按
STM32G4系列MCU学习笔记：按键模块
fjhghui的博客
03-29 6021
第一次以写博客的方式记录自己在嵌入式学习过程中的学习经历和踩的那些坑~ Day1 那么开始叭！ STM32G4系列MCU学习笔记：按键模块前言一、硬件操作1. 原理图2. 硬件分析3. 初始化代码二、按键模块的驱动层实现1. 硬件框图2. 按键驱动层代码实现3. 计时操作三、应用层简单逻辑实现总结 前言 我所学过的按键模块有独立按键和矩阵键盘两种，其实两者原理类似，本文主要介绍按键模块中实现长按和短按功能。 注意了：本文是基于HAL库来进行介绍的，如果你想用标准库实现也比较简单，类比移植即可。 由于作者
蓝桥杯单片机----独立按键的基本控制（长按、短按、双击）
热门推荐
朽木自雕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熄灭。 ...
单片机控制的示波器键盘模块与鉴相算法设计
"基于单片机的示波器键盘模块设计" 在现代电子设备中，示波器作为一种重要的信号测量和分析工具，其操作界面的人性化设计至关重要。本论文主要探讨了如何基于单片机技术设计一个高效、可靠的示波器键盘模块。该设计...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值