【独立按键组成的组合按键、短按与长按、按住不松手的均匀触发】

最新推荐文章于 2023-08-28 16:17:09 发布
最新推荐文章于 2023-08-28 16:17:09 发布
阅读量1k 收藏 8
点赞数 1
分类专栏： 51单片机 文章标签： 单片机 stm32 嵌入式硬件

（1）单击K1点亮LED，单击K2熄灭LED，K1与K2组合按键蜂鸣器发声。

#include "reg52.h"
#define KEY_VOICE_TIME 50//按键触发后发出的声音长度
#define KEY_FILTER_TIME 25//按键滤波的“稳定时间”25ms
// #define KEY_INTERVAL_TIME 400//连续两次单击之间的最大有效时间
sbit beep=P2^3;//蜂鸣器
sbit P1_4=P1^4;//LED
sbit KEY_INPUT1=P3^4;//按键识别输入口
sbit KEY_INPUT2=P3^5;
volatile unsigned char vGu8BeepTimerFlag=0;
volatile unsigned int vGu16BeepTimerCnt=0;
// unsigned char Gu8LedStatus=0;//LED灯的状态，0代表灭，1代表亮
volatile unsigned char vGu8SingleKeySec=0;//单击按键的触发序号
volatile unsigned char vGu8CombinationKeySec=0;//组合按键的触发序号
void SystemInitial()
{
    TMOD=0x01;
    TH0=0xfc;
    TL0=0x66;
    EA=1;
    ET0=1;
    TR0=1;
}
void Delay(unsigned long u32DelayTime)
{
    for(;u32DelayTime>0;u32DelayTime--);
}
void LedOpen()
{
    P1_4=0;
}
void LedClose()
{
    P1_4=1;
}
void PeripheralInitial()
{//led初始化没有放在SystemInitial中是因为led显示内容对上电瞬间要求不高，如果是控制继电器则应该放在SystemInitial中
    LedClose();
}
void BeepOpen()
{
    beep=0;
}
void BeepClose()
{
    beep=1;
}
void VoiceScan()//蜂鸣器的非阻塞驱动."驱动层"的驱动函数,放在定时中断函数里每1ms扫描一次,保证声音长度的一致性
{
    static unsigned char Su8Lock=0;
    if(1==vGu8BeepTimerFlag && vGu16BeepTimerCnt>0)
    {
        if(0==Su8Lock)
        {
            Su8Lock=1;//触发声音后自锁起来，避免BeepOpen()被重复扫描影响执行效率，发声时只执行一次BeepOpen()函数即可
            BeepOpen();//蜂鸣器发声，封装成函数为了代码的移植性
        }
        else//借用else结构实现先发声下一次中断再开始计时
        {
            vGu16BeepTimerCnt--;
            if(0==vGu16BeepTimerCnt)
            {
                Su8Lock=0;//关闭声音后及时解锁为下一次触发做准备
                BeepClose();
            }
        }
    }
}
void KeyScan()//非阻塞,放在中断函数中"清零式滤波"
{
    static unsigned char Su8KeyLock1;//1号按键的自锁
    static unsigned int Su16KeyCnt1;//1号按键的计时器
    static unsigned char Su8KeyLock2;
    static unsigned int Su16KeyCnt2;
    static unsigned char Su8CombinationKeyLock;//组合按键自锁
    static unsigned int Su16CombinationKeyCnt;//组合按键计数器

    if(0!=KEY_INPUT1 || 0!=KEY_INPUT2)//关键语句，同时按下即都是0时退出语句
    {
        Su8CombinationKeyLock=0;//
        Su16CombinationKeyCnt=0;
    }
    else if(0 == Su8CombinationKeyLock)//else设计巧妙，等效于if(0==KEY_INPUT1 && 0==KEY_INPUT2 && 0==Su8CombinationKeyLock)
    {
        Su16CombinationKeyCnt++;
        if(Su16CombinationKeyCnt>=KEY_FILTER_TIME)//滤波的稳定时间
        {
            Su8CombinationKeyLock=1;//自锁避免一直触发
            vGu8CombinationKeySec=1;//组合按键按下标志位
        }
    }

    if(0!=KEY_INPUT1)//IO口是高电平，没有按键按下，”去抖动延时计数器“一直被清零，如果受到外界或抖动干扰就可以去除瞬间的杂波干扰
    {
        Su8KeyLock1=0;//按键解锁
        Su16KeyCnt1=0;//”去抖动延时计数器“，按键去抖动的重要语句，在抖动过程中一旦有高电平立刻置0直到稳定
    }
    else if(0 == Su8KeyLock1)//说明按键被按下，else设计很巧妙相当于KEY_INPUT1==0
    {
        Su16KeyCnt1++;//累加的过程就是在滤波，若在累加过程中受到干扰IO口触发高电平，这时马上将Su16KeyCnt1置0，即去除瞬间杂波
        if(Su16KeyCnt1>=KEY_FILTER_TIME)//滤波的“稳定时间”
        {
            Su8KeyLock1=1;//按键自锁标志位，一旦触发按键标志位置1，防止按键按键按住不松手时不断触发按键
            vGu8SingleKeySec=1;//按键1单击触发
        }
    }
    if(0!=KEY_INPUT2)
    {
        Su8KeyLock2=0;
        Su16KeyCnt2=0;
    }
    else if(0 == Su8KeyLock2)
    {
        Su16KeyCnt2++;
        if(Su16KeyCnt2>=KEY_FILTER_TIME)
        {
            Su8KeyLock2=1;
            vGu8SingleKeySec=2;
        }
    }
}
void SingleKeyTask()
{
    if(0==vGu8SingleKeySec)
    {
        return;//序号为0无按键触发，退出当前函数.因为当按键多达几十个时就能避免主函数每次进入KeyTask函数时进入switch多次判断，可能会更高效
    }
    switch(vGu8SingleKeySec)
    {
        case 1:
            LedOpen();
            vGu8SingleKeySec=0;//响应按键服务程序后按键编号清零避免一直触发
            break;
        case 2:
            LedClose();
            vGu8SingleKeySec=0;
            break;
    }
}
void CombinationKeyTask()
{
    if(0==vGu8CombinationKeySec)
    {
        return;
    }
    switch(vGu8CombinationKeySec)
    {
        case 1:
            vGu8BeepTimerFlag=0;
            vGu16BeepTimerCnt=KEY_VOICE_TIME;//"应用层"只需赋值，就发出固定时间长度的声音
            vGu8BeepTimerFlag=1;
            vGu8CombinationKeySec=0;//响应按键服务程序后，按键编号清零避免一直触发
            break;
    }
}
void main()
{
    SystemInitial();
    Delay(10000);
    PeripheralInitial();
    while(1)
    {
        SingleKeyTask();
        CombinationKeyTask();
    }
}
void T0_time() interrupt 1
{
    VoiceScan();
    KeyScan();//因为KeyScan是特殊函数放在中断函数里，涉及到IO口输入信号的滤波，滤波就涉及到时间的及时性和均匀性，放在中断中更能保证时间的一致性
    TH0=0xfc;//如蜂鸣器驱动，动态数码管驱动，按键扫描驱动
    TL0=0x66;
}

（2）“电脑键盘式”组合按键。如同电脑键盘的“crtl+c”，先按下ctrl再按c才能触发。
K1按下一次LED亮或灭；先按住K2再按住K1触发组合键蜂鸣器响。

#include "reg52.h"
#define KEY_VOICE_TIME 50//按键触发后发出的声音长度
#define KEY_FILTER_TIME 25//按键滤波的“稳定时间”25ms
// #define KEY_INTERVAL_TIME 400//连续两次单击之间的最大有效时间
sbit beep=P2^3;//蜂鸣器
sbit P1_4=P1^4;//LED
sbit KEY_INPUT1=P3^4;//按键识别输入口
sbit KEY_INPUT2=P3^5;
volatile unsigned char vGu8BeepTimerFlag=0;
volatile unsigned int vGu16BeepTimerCnt=0;
unsigned char Gu8LedStatus=0;//LED灯的状态，0代表灭，1代表亮
volatile unsigned char vGu8SingleKeySec=0;//单击按键的触发序号
volatile unsigned char vGu8CombinationKeySec=0;//组合按键的触发序号
void SystemInitial()
{
    TMOD=0x01;
    TH0=0xfc;
    TL0=0x66;
    EA=1;
    ET0=1;
    TR0=1;
}
void Delay(unsigned long u32DelayTime)
{
    for(;u32DelayTime>0;u32DelayTime--);
}
void LedOpen()
{
    P1_4=0;
}
void LedClose()
{
    P1_4=1;
}
void PeripheralInitial()
{//led初始化没有放在SystemInitial中是因为led显示内容对上电瞬间要求不高，如果是控制继电器则应该放在SystemInitial中
    LedClose();
}
void BeepOpen()
{
    beep=0;
}
void BeepClose()
{
    beep=1;
}
void VoiceScan()//蜂鸣器的非阻塞驱动."驱动层"的驱动函数,放在定时中断函数里每1ms扫描一次,保证声音长度的一致性
{
    static unsigned char Su8Lock=0;
    if(1==vGu8BeepTimerFlag && vGu16BeepTimerCnt>0)
    {
        if(0==Su8Lock)
        {
            Su8Lock=1;//触发声音后自锁起来，避免BeepOpen()被重复扫描影响执行效率，发声时只执行一次BeepOpen()函数即可
            BeepOpen();//蜂鸣器发声，封装成函数为了代码的移植性
        }
        else//借用else结构实现先发声下一次中断再开始计时
        {
            vGu16BeepTimerCnt--;
            if(0==vGu16BeepTimerCnt)
            {
                Su8Lock=0;//关闭声音后及时解锁为下一次触发做准备
                BeepClose();
            }
        }
    }
}
void KeyScan()
{
    static unsigned char Su8KeyLock1;
    static unsigned int Su16KeyCnt1;

    if(0!=KEY_INPUT1)
    {
        Su8KeyLock1=0;
        Su16KeyCnt1=0;
    }
    else if(0 == Su8KeyLock1)
    {
        Su16KeyCnt1++;
        if(Su16KeyCnt1>=KEY_FILTER_TIME)
        {
            if(0 == KEY_INPUT2)//"电脑组合按键关键语句"，只有先按下K2再按下K1才能触发组合按键
            {
                Su8KeyLock1=1;
                vGu8CombinationKeySec=1;
            }
            else
            {
                Su8KeyLock1=1;
                vGu8SingleKeySec=1;
            }
        }
    }
}

   
void SingleKeyTask()
{
    if(0==vGu8SingleKeySec)
    {
        return;//序号为0无按键触发，退出当前函数.因为当按键多达几十个时就能避免主函数每次进入KeyTask函数时进入switch多次判断，可能会更高效
    }
    switch(vGu8SingleKeySec)
    {
        case 1:
            if(0 == Gu8LedStatus)
            {
                Gu8LedStatus=1;
                LedOpen();
            }
            else
            {
                Gu8LedStatus=0;
                LedClose();
            }
            vGu8SingleKeySec=0;
            break;
    }
}
void CombinationKeyTask()
{
    if(0==vGu8CombinationKeySec)
    {
        return;
    }
    switch(vGu8CombinationKeySec)
    {
        case 1:
            vGu8BeepTimerFlag=0;
            vGu16BeepTimerCnt=KEY_VOICE_TIME;//"应用层"只需赋值，就发出固定时间长度的声音
            vGu8BeepTimerFlag=1;
            vGu8CombinationKeySec=0;//响应按键服务程序后，按键编号清零避免一直触发
            break;
    }
}
void main()
{
    SystemInitial();
    Delay(10000);
    PeripheralInitial();
    while(1)
    {
        SingleKeyTask();
        CombinationKeyTask();
    }
}
void T0_time() interrupt 1
{
    VoiceScan();
    KeyScan();//因为KeyScan是特殊函数放在中断函数里，涉及到IO口输入信号的滤波，滤波就涉及到时间的及时性和均匀性，放在中断中更能保证时间的一致性
    TH0=0xfc;//如蜂鸣器驱动，动态数码管驱动，按键扫描驱动
    TL0=0x66;
}

（3）独立按键的短按与长按
独立按键“短按”一次亮灭切换，“长按”一次蜂鸣器响

#include "reg52.h"
#define KEY_VOICE_TIME 50
#define KEY_SHOTR_TIME 25//短按时间
#define KEY_LONG_TIME 500//长按时间
sbit beep=P2^3;//蜂鸣器
sbit P1_4=P1^4;//LED
sbit KEY_INPUT1=P3^4;//按键识别输入口
// sbit KEY_INPUT2=P3^5;
volatile unsigned char vGu8BeepTimerFlag=0;
volatile unsigned int vGu16BeepTimerCnt=0;
unsigned char Gu8LedStatus=0;//LED灯的状态，0代表灭，1代表亮
volatile unsigned char vGu8SingleKeySec=0;
void SystemInitial()
{
    TMOD=0x01;
    TH0=0xfc;
    TL0=0x66;
    EA=1;
    ET0=1;
    TR0=1;
}
void Delay(unsigned long u32DelayTime)
{
    for(;u32DelayTime>0;u32DelayTime--);
}
void LedOpen()
{
    P1_4=0;
}
void LedClose()
{
    P1_4=1;
}
void PeripheralInitial()
{//led初始化没有放在SystemInitial中是因为led显示内容对上电瞬间要求不高，如果是控制继电器则应该放在SystemInitial中
    LedClose();
}
void BeepOpen()
{
    beep=0;
}
void BeepClose()
{
    beep=1;
}
void VoiceScan()
{
    static unsigned char Su8Lock=0;
    if(1==vGu8BeepTimerFlag && vGu16BeepTimerCnt>0)
    {
        if(0==Su8Lock)
        {
            Su8Lock=1;
            BeepOpen();
        }
        else
        {
            vGu16BeepTimerCnt--;
            if(0==vGu16BeepTimerCnt)
            {
                Su8Lock=0;
                BeepClose();
            }
        }
    }
}
void KeyScan()
{
    static unsigned char Su8KeyLock1;
    static unsigned int Su16KeyCnt1;
    static unsigned char Su8KeyShortFlag=0;

    if(0!=KEY_INPUT1)
    {
        Su8KeyLock1=0;
        Su16KeyCnt1=0;
        if(1 == Su8KeyShortFlag)
        {
            Su8KeyShortFlag=0;
            vGu8SingleKeySec=1;//松手后在短按时间内才触发短按
        }
    }
    else if(0 == Su8KeyLock1)
    {
        Su16KeyCnt1++;
        if(Su16KeyCnt1>=KEY_SHOTR_TIME)//到达短按时间
        {
            Su8KeyShortFlag=1;//短按标志很重要，松手才能触发短按
        }
        if(Su16KeyCnt1>=KEY_LONG_TIME)//到达长按时间
        {
            Su8KeyLock1=1;//触发自锁，避免一直触发长按
            Su8KeyShortFlag=0;//清除短按标志
            vGu8SingleKeySec=2;//触发长按
        }
    }
}

   
void SingleKeyTask()
{
    if(0==vGu8SingleKeySec)
    {
        return;
    }
    switch(vGu8SingleKeySec)
    {
        case 1:
            if(0 == Gu8LedStatus)
            {
                Gu8LedStatus=1;
                LedOpen();
            }
            else
            {
                Gu8LedStatus=0;
                LedClose();
            }
            vGu8SingleKeySec=0;
            break;
        case 2:
            vGu8BeepTimerFlag=0;
            vGu16BeepTimerCnt=KEY_VOICE_TIME;
            vGu8BeepTimerFlag=1;
            vGu8SingleKeySec=0;
            break;
    }
}
void main()
{
    SystemInitial();
    Delay(10000);
    PeripheralInitial();
    while(1)
    {
        SingleKeyTask();
    }
}
void T0_time() interrupt 1
{
    VoiceScan();
    KeyScan();
    TH0=0xfc;
    TL0=0x66;
}

（4）按键按住不松手的连续均匀触发
按下K1，跑马灯左边跑一步；按下K2，右边跑一步；按住K1或K2不松手连续触发，跑马灯连续跑；按键单击一次时蜂鸣器叫一次，连续触发时不鸣叫。

#include "reg52.h"
#define KEY_VOICE_TIME 50
#define KEY_SHORT_TIME 25//按键滤波的“稳定时间”25ms
#define KEY_ENTER_CONTINUITY_TIME 300//从单击到连击间隔时间
#define KEY_CONTINUITY_TIME 80//连击间隔时间
#define BUS_P1 P1//p1口连接8个led灯
sbit beep=P2^3;//蜂鸣器
sbit KEY_INPUT1=P3^4;//按键识别输入口
sbit KEY_INPUT2=P3^5;
volatile unsigned char vGu8BeepTimerFlag=0;
volatile unsigned int vGu16BeepTimerCnt=0;
unsigned char Gu8LedStatus=0;//1左移的位数
unsigned char Gu8DisplayUpdata=1;//显示的刷新标志
volatile unsigned char vGu8KeySec=0;//按键的触发序号
volatile unsigned char vGu8ShiedVoiceFlag=0;//屏蔽声音标志
void SystemInitial()
{
    TMOD=0x01;
    TH0=0xfc;
    TL0=0x66;
    EA=1;
    ET0=1;
    TR0=1;
}
void Delay(unsigned long u32DelayTime)
{
    for(;u32DelayTime>0;u32DelayTime--);
}
void PeripheralInitial()
{

}
void BeepOpen()
{
    beep=0;
}
void BeepClose()
{
    beep=1;
}
void VoiceScan()
{
    static unsigned char Su8Lock=0;
    if(1==vGu8BeepTimerFlag && vGu16BeepTimerCnt>0)
    {
        if(0==Su8Lock)
        {
            Su8Lock=1;
            BeepOpen();
        }
        else
        {
            vGu16BeepTimerCnt--;
            if(0==vGu16BeepTimerCnt)
            {
                Su8Lock=0;
                BeepClose();
            }
        }
    }
}
/*Gu8DisplayUpdata“显示刷新变量”在显示框架中很常见，目的是既能及时刷新显示，又能避免主函数
“不断执行显示代码”而影响程序效率*/
void DisplayTask()
{
    if(1 == Gu8DisplayUpdata)
    {
        Gu8DisplayUpdata=0;
        BUS_P1=~(1<<Gu8LedStatus);//1左移Gu8LedStatus位
    }
}
void KeyScan()
{
    static unsigned char Su8KeyLock1;
    static unsigned int Su16KeyCnt1;
    static unsigned int Su16KeyContinuityCnt1;

    static unsigned char Su8KeyLock2;
    static unsigned int Su16KeyCnt2;
    static unsigned int Su16KeyContinuityCnt2;

    if(0!=KEY_INPUT1)
    {
        Su8KeyLock1=0;
        Su16KeyCnt1=0;
        Su16KeyContinuityCnt1=0;
    }
    else if(0 == Su8KeyLock1)
    {
        Su16KeyCnt1++;
        if(Su16KeyCnt1>=KEY_SHORT_TIME)//按键滤波时间25ms
        {
            Su8KeyLock1=1;//自锁起来，按住不放进入连续触发检测
            vGu8KeySec=1;//触发一次K1按键
            Su16KeyCnt1=0;
        }
    }
    else if(Su16KeyCnt1<=KEY_ENTER_CONTINUITY_TIME)
    {
        Su16KeyCnt1++;//第一次按下按键之后到连续触发的时间间隔300ms
    }
    else//按住300ms后任然不放手进入连续触发
    {
        Su16KeyContinuityCnt1++;
        if(Su16KeyContinuityCnt1>=KEY_CONTINUITY_TIME)//每80ms触发一次
        {
            Su16KeyContinuityCnt1=0;
            vGu8KeySec=1;//触发
            vGu8ShiedVoiceFlag=1;//连续触发屏蔽按键触发的声音
        }
    }

    if(0!=KEY_INPUT2)
    {
        Su8KeyLock2=0;
        Su16KeyCnt2=0;
        Su16KeyContinuityCnt2=0;
    }
    else if(0 == Su8KeyLock2)
    {
        Su16KeyCnt2++;
        if(Su16KeyCnt2>=KEY_SHORT_TIME)
        {
            Su8KeyLock2=1;
            vGu8KeySec=2;//触发一次K2按键
            Su16KeyCnt2=0;
        }
    }
    else if(Su16KeyCnt2<=KEY_ENTER_CONTINUITY_TIME)
    {
        Su16KeyCnt2++;
    }
    else//按住300ms后任然不放手进入连续触发
    {
        Su16KeyContinuityCnt2++;
        if(Su16KeyContinuityCnt2>=KEY_CONTINUITY_TIME)//每80ms触发一次
        {
            Su16KeyContinuityCnt2=0;
            vGu8KeySec=2;//触发
            vGu8ShiedVoiceFlag=1;//屏蔽按键触发的声音
        }
    }
}

   
void KeyTask()
{
    if(0==vGu8KeySec)
    {
        return;
    }
    switch(vGu8KeySec)
    {
        case 1:
            if(Gu8LedStatus>0)
            {
                Gu8LedStatus--;//跑马灯左跑
                Gu8DisplayUpdata=1;//刷新显示
            }
            if(0==vGu8ShiedVoiceFlag)//没有屏蔽声音
            {
                vGu8BeepTimerFlag=0;
                vGu16BeepTimerCnt=KEY_VOICE_TIME;
                vGu8BeepTimerFlag=1;
            }
            vGu8ShiedVoiceFlag=0;
            vGu8KeySec=0;
            break;
        case 2:
            if(Gu8LedStatus<7)
            {
                Gu8LedStatus++;
                Gu8DisplayUpdata=1;
            }
            if(0==vGu8ShiedVoiceFlag)
            {
                vGu8BeepTimerFlag=0;
                vGu16BeepTimerCnt=KEY_VOICE_TIME;
                vGu8BeepTimerFlag=1;
            }
            vGu8ShiedVoiceFlag=0;
            vGu8KeySec=0;
            break;
    }
}

void main()
{
    SystemInitial();
    Delay(10000);
    PeripheralInitial();
    while(1)
    {
        KeyTask();
        DisplayTask();//显示led任务函数
    }
}
void T0_time() interrupt 1
{
    VoiceScan();
    KeyScan();
    TH0=0xfc;
    TL0=0x66;
}

（5）独立按键按住不松手的“先加速后匀速”的触发
功能：触发K1，自减1，最小值为0；触发K2，自加1，最大值800；单击一次蜂鸣器鸣叫一次，由单击进入连击蜂鸣器不鸣叫。

#include "reg52.h"
#define KEY_VOICE_TIME 50
#define KEY_SHORT_TIME 25//按键滤波的“稳定时间”25ms
#define KEY_ENTER_CONTINUITY_TIME 300//从单击到连击间隔时间
#define KEY_CONTINUITY_INITIAL_TIME 80//连击间隔时间
#define BUS_P1 P1//p1口连接8个led灯
#define KEY_SUB_DA_TIME 20//按键加速时每次减小的时间
#define KEY_CONTINUITY_MIN_TIME 5//加速之后匀速的间隔时间
sbit beep=P2^3;//蜂鸣器
sbit KEY_INPUT1=P3^4;//按键识别输入口
sbit KEY_INPUT2=P3^5;
volatile unsigned char vGu8BeepTimerFlag=0;
volatile unsigned int vGu16BeepTimerCnt=0;
unsigned int Gu16SetData=0;//"加速匀速的设置参数"，0-800
unsigned char Gu8DisplayUpdata=1;//显示的刷新标志
volatile unsigned char vGu8KeySec=0;//按键的触发序号
volatile unsigned char vGu8ShiedVoiceFlag=0;//屏蔽声音标志
void SystemInitial()
{
    TMOD=0x01;
    TH0=0xfc;
    TL0=0x66;
    EA=1;
    ET0=1;
    TR0=1;
}
void Delay(unsigned long u32DelayTime)
{
    for(;u32DelayTime>0;u32DelayTime--);
}
void PeripheralInitial()
{

}
void BeepOpen()
{
    beep=0;
}
void BeepClose()
{
    beep=1;
}
void VoiceScan()
{
    static unsigned char Su8Lock=0;
    if(1==vGu8BeepTimerFlag && vGu16BeepTimerCnt>0)
    {
        if(0==Su8Lock)
        {
            Su8Lock=1;
            BeepOpen();
        }
        else
        {
            vGu16BeepTimerCnt--;
            if(0==vGu16BeepTimerCnt)
            {
                Su8Lock=0;
                BeepClose();
            }
        }
    }
}
/*Gu8DisplayUpdata“显示刷新变量”在显示框架中很常见，目的是既能及时刷新显示，又能避免主函数
“不断执行显示代码”而影响程序效率*/
void DisplayTask()
{
    if(1 == Gu8DisplayUpdata)//需要刷新一次
    {
        Gu8DisplayUpdata=0;
        if(Gu16SetData<100)
        {
            BUS_P1=~(1<<0);
        }
        else if(Gu16SetData<200)
        {
            BUS_P1=~(1<<1);
        }
        else if(Gu16SetData<300)
        {
            BUS_P1=~(1<<2);
        }
        else if(Gu16SetData<400)
        {
            BUS_P1=~(1<<3);
        }
        else if(Gu16SetData<500)
        {
            BUS_P1=~(1<<4);
        }
        else if(Gu16SetData<600)
        {
            BUS_P1=~(1<<5);
        }
        else if(Gu16SetData<700)
        {
            BUS_P1=~(1<<6);
        }
        else
        {
            BUS_P1=~(1<<7);
        }
    }
}
void KeyScan()
{
    static unsigned char Su8KeyLock1;
    static unsigned int Su16KeyCnt1;
    static unsigned int Su16KeyContinuityCnt1;
    static unsigned int Su16KeyContinuityTime1=KEY_CONTINUITY_INITIAL_TIME;

    static unsigned char Su8KeyLock2;
    static unsigned int Su16KeyCnt2;
    static unsigned int Su16KeyContinuityCnt2;
    static unsigned int Su16KeyContinuityTime2=KEY_CONTINUITY_INITIAL_TIME;

    if(0!=KEY_INPUT1)
    {
        Su8KeyLock1=0;
        Su16KeyCnt1=0;
        Su16KeyContinuityCnt1=0;
        Su16KeyContinuityTime1=KEY_CONTINUITY_INITIAL_TIME;
    }
    else if(0 == Su8KeyLock1)
    {
        Su16KeyCnt1++;
        if(Su16KeyCnt1>=KEY_SHORT_TIME)//按键滤波时间25ms
        {
            Su8KeyLock1=1;//自锁起来，按住不放进入连续触发检测
            vGu8KeySec=1;//触发一次K1按键
            Su16KeyCnt1=0;
        }
    }
    else if(Su16KeyCnt1<=KEY_ENTER_CONTINUITY_TIME)
    {
        Su16KeyCnt1++;//第一次按下按键之后到连续触发的时间间隔300ms
    }
    else//按住300ms后任然不放手进入连续触发
    {
        Su16KeyContinuityCnt1++;
        if(Su16KeyContinuityCnt1>=Su16KeyContinuityTime1)//自加或自减Su16KeyContinuityTime1进行加速
        {
            Su16KeyContinuityCnt1=0;
            vGu8KeySec=1;//触发
            vGu8ShiedVoiceFlag=1;//连续触发屏蔽按键触发的声音
            if(Su16KeyContinuityTime1>=KEY_SUB_DA_TIME)
            {
                Su16KeyContinuityTime1=Su16KeyContinuityTime1-KEY_SUB_DA_TIME;//数值不断减小触发速度加快
            }
            if(Su16KeyContinuityTime1<KEY_CONTINUITY_MIN_TIME)//到达最小时间间隔时匀速
            {
                Su16KeyContinuityTime1=KEY_CONTINUITY_MIN_TIME;//匀速的时间间隔
            }
        }
    }

    if(0!=KEY_INPUT2)
    {
        Su8KeyLock2=0;
        Su16KeyCnt2=0;
        Su16KeyContinuityCnt2=0;
        Su16KeyContinuityTime2=KEY_CONTINUITY_INITIAL_TIME;
    }
    else if(0 == Su8KeyLock2)
    {
        Su16KeyCnt2++;
        if(Su16KeyCnt2>=KEY_SHORT_TIME)
        {
            Su8KeyLock2=1;//自锁起来，按住不放进入连续触发检测
            vGu8KeySec=2;//触发一次K1按键
            Su16KeyCnt2=0;
        }
    }
    else if(Su16KeyCnt2<=KEY_ENTER_CONTINUITY_TIME)
    {
        Su16KeyCnt2++;//第一次按下按键之后到连续触发的时间间隔300ms
    }
    else//按住300ms后任然不放手进入连续触发
    {
        Su16KeyContinuityCnt2++;
        if(Su16KeyContinuityCnt2>=Su16KeyContinuityTime2)//自加或自减Su16KeyContinuityTime1进行加速
        {
            Su16KeyContinuityCnt2=0;
            vGu8KeySec=2;//触发
            vGu8ShiedVoiceFlag=1;//连续触发屏蔽按键触发的声音
            if(Su16KeyContinuityTime2>=KEY_SUB_DA_TIME)
            {
                Su16KeyContinuityTime2=Su16KeyContinuityTime2-KEY_SUB_DA_TIME;//数值不断减小触发速度加快
            }
            if(Su16KeyContinuityTime2<KEY_CONTINUITY_MIN_TIME)//到达最小时间间隔时匀速
            {
                Su16KeyContinuityTime2=KEY_CONTINUITY_MIN_TIME;//匀速的时间间隔
            }
        }
    }
}

   
void KeyTask()
{
    if(0==vGu8KeySec)
    {
        return;
    }
    switch(vGu8KeySec)
    {
        case 1://K1按键
            if(Gu16SetData>0)
            {
                Gu16SetData--;//跑马灯左跑
                Gu8DisplayUpdata=1;//刷新显示
            }
            if(0==vGu8ShiedVoiceFlag)//没有屏蔽声音
            {
                vGu8BeepTimerFlag=0;
                vGu16BeepTimerCnt=KEY_VOICE_TIME;
                vGu8BeepTimerFlag=1;
            }
            vGu8ShiedVoiceFlag=0;
            vGu8KeySec=0;
            break;
        case 2://K2按键
            if(Gu16SetData<800)
            {
                Gu16SetData++;
                Gu8DisplayUpdata=1;
            }
            if(0==vGu8ShiedVoiceFlag)
            {
                vGu8BeepTimerFlag=0;
                vGu16BeepTimerCnt=KEY_VOICE_TIME;
                vGu8BeepTimerFlag=1;
            }
            vGu8ShiedVoiceFlag=0;
            vGu8KeySec=0;
            break;
    }
}

void main()
{
    SystemInitial();
    Delay(10000);
    PeripheralInitial();
    while(1)
    {
        KeyTask();
        DisplayTask();//显示led任务函数
    }
}
void T0_time() interrupt 1
{
    VoiceScan();
    KeyScan();
    TH0=0xfc;
    TL0=0x66;
}
蜗牛先森i
关注
  • 1
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单片机按键长按 短按 组合按 双击程序
01-21
有关单片机的 按键 长按 短按 双击 组合按程序分享啊
单片机独立按键模块（含短按，长按，连发功能）
03-30
*独立按键扫描程序,定时器0 *本程序采用晶振频率12.000MHz *长，短，连发按键 *外部函数 extern uint8 keyScan4(); //返回值：十位指示按键位，个位指示短长按
4个独立键盘的同时使用
Xiao_peng117的博客
12-14 1822
S2开启数码管计时，S3暂停数码管计时， S4打开所有的LED，S5关闭所有的LED
key组合按键，长短按键，连续按键 识别方案
qq_42074368的博客
07-26 1238
假如我们有30个按键，要实现识别所有按键的组合短按，组合长按，组合连续按，等等，按规则写出来非常麻烦，我们使用宏定义，整型变量按位检测就很方便。
按键的原理及独立式按键的实现
weixin_46070656的博客
02-11 3115
按键的原理及独立式按键的实现 键盘的基本原理 抖动的消除 硬件消抖 软件消抖 硬件消抖 软件消抖 利用延时程序消除抖动。 键盘的分类 独立式键盘和行列键盘 独立式键盘 特点 每个键占用一根并口线，键位多时占用并口(IO口)线多。 用于键位较少的情况。 处理简单，直接判并口线。 行列键盘—矩阵键盘 特点 键位分布在行列交叉点上。 占用并口线少，键位越多越明显。 键位的识别 第一步是首先检测键盘上是否有键按下； 第二步是识别哪一个键按下。 检测键盘上是否有键按下的处理方法—全扫描 识别键盘中哪
独立按键连按和长按处理技巧.
04-27
独立按键连按和长按处理技巧，此处利用状态机进行对按键的识别而不是使用那些延时程序，提高了51单片机处理效率
python按键按住不放持续响应的实例代码
09-19
今天小编就为大家分享一篇python按键按住不放持续响应的实例代码，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
C# Winform可长按延时触发事件的按钮控件
11-12
对应文章地址在https://blog.csdn.net/mazhiyuan1981/article/details/121286666
STM32通过按键改变PWM占空比产生呼吸灯效果
07-17
实现功能：通过TIM1的CH1输出一个PWM信号，通过长按按键KEY0不断增加PWM占空比，控制LED1由暗变亮；通过长按按键KEY1不断减少PWM占空比，控制LED1由亮变暗；LED2每隔一段时间亮灭一次，用于提示系统正常运行。
全功能按键程序,支持消抖,长按,组合按键,按两次,三次,四次等
09-05
功能包括按键消抖(支持阻塞和非阻塞两种),长按,组合按键,按两次,三次,四次等不同的键值映射。 分为三部分:主程序main.c部分,只是应用实例(用的是msp430的UART作为交互界面);key.h部分是一些定义,主要需调整的是延时参数;key.c是按键的实现部分
51单片机的复杂按键程序
11-13
51单片机的复杂按键程序 可以实现按键组合 按键复用功能
按键处理框架（短按，长按，连续按键）.rar_key scan 按键扫描_单片机 长按_按键处理_按键处理框架_长按按键程
07-15
单片机c语言按键扫面程序框架，有短按，连续按，长按1，长按2等功能。方便移植
09-独立按键的长按和短按
wcsq0523的博客
08-28 982
独立按键的长按和短按 文章目录独立按键的长按和短按1. 硬件部分1.1 按键简介1.2 按键抖动1.3 按键识别1.4 按键选择2. 软件编程2.1 框架式编程结构搭建2.2 初始化2.3 按键扫描数据分配2.4 按键检测消抖，延时划分两种状态短按长按使用场景测试 1. 硬件部分 1.1 按键简介 1.2 按键抖动 1.3 按键识别 按键长按与短按判别流程图 1.4 按键选择 2. 软件编程 2.1 框架式编程结构搭建 新建ROTARY_Drive.c，ROTARY_Drive.h 保存
独立按键控制LED亮灭
m0_61608123的博客
02-25 8409
51单片机中独立按键控制LED亮灭
电子设计教程3：按键滤波电路
geekYatao
02-02 7551
  这是RC低通滤波器的应用。电路板上常见的机械接触式按键，在按下或者松开的过程中，常常会产生不稳定的信号，如下图所示，杂波过程一般持续10ms-20ms，毛刺的频率一般超过10KHz。下图是一款机械自锁按键开关瞬间产生的杂波   为了过滤掉杂波，可以通过单片机程序滤波或者通过硬件滤波电路进行滤波。单片机程序滤波的基本原理是：单片机检测到低电平后，延时若干毫秒，再检测一次，如果还是低电平，则确定...
单片机按键扫描实现短按_长按_重复_组合键功能详解
03-13 6047
在单片机项目中，按键操作通常是产品与用户交互必不可少功能，按键又有短按、长按、重复、组合键等操作，本文介绍了一种按键扫描的实现方法，能够实现短按、长按、重复以为组合键的功能。 短按：即按下按键马上松开，如图1，按下的 时间tl小于允许的最大时间t_max，则认为是短按 长按：即按下按键3秒后再松开，如图2，按下的 时间tl大于时间t_lmax 重复：即一直按住按键不放，重复该按键，如图3，按下的时...
STM32中断+定时器实现单击、多击和长击（二）
最新发布
qq_72890400的博客
08-28 1609
上一节用实现了按键的长、短按键，这一节在原本的功能上加一个多击功能，可以实现双击、三击、四击等等，下面开始吧。
一键开关电路设计（一）
weixin_44850779的博客
04-08 2198
一键开关电路 （一）功能需求提出 在一些电子产品中（列举。。。），按键的开关机是比不可少的。比如有点按开关机，长按2s短按2s关机，或者长短按相结合来开关机。这里，我分享本人在按摩眼罩开发过程中用到的开关机电路，可通过具体开关芯片的选择来实现上面提到的所有开关功能。 （二）具体电路功能剖析 首先先放电路图，如下 具体元器件特性解析如下： 开关过程如下： .........
【源码详解~按键状态机~简洁易懂】1.单个按键实现短按长按的功能（基于STM32）
qq_44078824的博客
03-26 7827
0.引言 在日常生活中，有不少按键长按、短按的应用实例。比如：一个台灯，短按切换亮度，长按关机。 问题来了，单片机是如何区分按键的短按和长按的呢？
Android按钮，如果按住不松手，就不执行onclick的逻辑
07-17
要在 Android 按钮按住不松手时不执行 `onClick` 的逻辑，可以使用按钮的触摸事件监听器（`OnTouchListener`）来实现。以下是一种常见的方法： 1. 在你的 Activity 或 Fragment 中为按钮设置触摸事件监听器： ```...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值