从单片机基础到程序框架（连载）

单片机

爱飞的笨鸟 · 2017-11-14 11:26:35

好资料我学习下

爱飞的笨鸟 · 2017-11-14 11:26:41

好资料我学习下

爱飞的笨鸟 · 2017-11-14 11:27:11

下载资料所以回复

爱飞的笨鸟 · 2017-11-14 11:27:18

下载资料所以回复

爱飞的笨鸟 · 2017-11-14 11:27:23

下载资料所以回复

吴坚鸿 · 2017-11-19 11:01:38

第九十六节：独立按键“一键两用”的短按与长按。

【96.1 “一键两用”的短按与长按。】

            上图96.1.1  独立按键电路

            上图96.1.2  LED电路


            上图96.1.3  有源蜂鸣器电路

      某些项目，当外部按键的资源比较少的时候，一个按键也可以“一键多用”。“一键多用”有很多种玩法，比如，谍战片的无线电通信，依赖一个按键的“不同敲击频率”就可以发送内容丰富的情报。本节“一键两用”也是属于“一键多用”的众多玩法之一。“短按与长按”的原理是依赖“按键按下的时间长度”来区分识别。“短按”是指从按下的“下降沿”到松手的“上升沿”时间，“长按”是指从按下的“下降沿”到一直按住不松手的“低电平持续时间”。本节的例程功能如下：（1）K1每“短按”一次（25ms），LED要么从“灭”变成“亮”，要么从“亮”变成“灭”，在两种状态之间切换。（2）K1每“长按”一次（500ms），蜂鸣器发出“嘀”的一声。代码如下：

#include "REG52.H"
#define KEY_VOICE_TIME 50 //按键“长按”触发后发出的声音长度 50ms
#define KEY_SHORT_TIME 25 //按键的“短按”兼“滤波”的“稳定时间”25ms
#define KEY_LONG_TIME 500 //按键的“长按”兼“滤波”的“稳定时间”500ms
void T0_time();
void SystemInitial(void) ;
void Delay(unsigned long u32DelayTime) ;
void PeripheralInitial(void) ;
void BeepOpen(void);
void BeepClose(void);
void LedOpen(void);
void LedClose(void);
void VoiceScan(void);
void KeyScan(void); //按键识别的驱动函数，放在定时中断里
void SingleKeyTask(void); //单击按键任务函数，放在主函数内
***it P3_4=P3^4; //蜂鸣器
***it P1_4=P1^4; //LED
***it KEY_INPUT1=P2^2; //K1按键识别的输入口。
volatile unsigned char vGu8BeepTimerFlag=0;
volatile unsigned int vGu16BeepTimerCnt=0;
unsigned char Gu8LedStatus=0; //记录LED灯的状态，0代表灭，1代表亮
volatile unsigned char vGu8SingleKeySec=0; //单击按键的触发序号
void main()
{
SystemInitial();
Delay(10000);
PeripheralInitial();
while(1)
{
SingleKeyTask(); //单击按键任务函数
}
}
void T0_time() interrupt 1
{
VoiceScan();
KeyScan(); //按键识别的驱动函数
TH0=0xfc;
TL0=0x66;
}
void SystemInitial(void)
{
TMOD=0x01;
TH0=0xfc;
TL0=0x66;
EA=1;
ET0=1;
TR0=1;
}
void Delay(unsigned long u32DelayTime)
{
for(;u32DelayTime>0;u32DelayTime--);
}
void PeripheralInitial(void)
{
if(0==Gu8LedStatus)
{
LedClose();
}
else
{
LedOpen();
}
}
void BeepOpen(void)
{
P3_4=0;
}
void BeepClose(void)
{
P3_4=1;
}
void LedOpen(void)
{
P1_4=0;
}
void LedClose(void)
{
P1_4=1;
}
void VoiceScan(void)
{
static unsigned char Su8Lock=0;
if(1==vGu8BeepTimerFlag&&vGu16BeepTimerCnt>0)
{
if(0==Su8Lock)
{
Su8Lock=1;
BeepOpen();
}
else
{
vGu16BeepTimerCnt--;
if(0==vGu16BeepTimerCnt)
{
Su8Lock=0;
BeepClose();
}
}
}
}
/* 注释一：
* “长按”与“短按”的识别过程：
* 第一步：平时只要K1没有被按下，按键的自锁标志Su8KeyLock1和去抖动延时计数器Su16KeyCnt1
* 一直被清零。此时属于按键“松手时间”，因此同时检测“短按”标志Su8KeyShortFlag
* 是否有效，如果有效就触发一次“短按”。
* 第二步：一旦K1按键被按下，去抖动延时计数器Su16KeyCnt1开始在定时中断函数里累加，在还没
* 累加到阀值KEY_SHORT_TIME和KEY_LONG_TIME时，如果在这期间由于受外界干扰或者
* 按键抖动，而使IO口突然瞬间触发成高电平，这个时候马上把延时计数器Su16KeyCnt1清零,
* 这个过程非常巧妙，非常有效地去除瞬间的杂波干扰。
* 第三步：如果K1按键按下的时间超过了“短按”阀值KEY_SHORT_TIME，马上把“短按”标志
* Su8KeyShortFlag置1，如果此时还没有松手，直到发现按下的时间超过“长按”阀值
* KEY_LONG_TIME时，先把“短按”标志ucShortTouchFlag1清零，然后触发“长按”，同时，为
* 了防止按住按键不松手后一直触发，要及时把Su8KeyLock1置1“自锁”。
* 第四步：等K1按键松手后，自锁标志Su8KeyLock1及时清零，为下一次自锁做准备，同时，也检测
* “短按”标志Su8KeyShortFlag是否有效，如果有效就触发一次“短按”。
*/
void KeyScan(void) //此函数放在定时中断里每1ms扫描一次
{
static unsigned char Su8KeyLock1;
static unsigned int Su16KeyCnt1;
static unsigned char Su8KeyShortFlag=0; //按键“短按”触发的标志
if(0!=KEY_INPUT1)//单个K1按键没有按下，及时清零一些标志。
{
Su8KeyLock1=0; //按键解锁
Su16KeyCnt1=0; //去抖动延时计数器清零，此行非常巧妙，是全场的亮点。
if(1==Su8KeyShortFlag) //松手的时候，如果“短按”标志有效就触发一次“短按”
{
Su8KeyShortFlag=0; //先清零“短按”标志避免一直触发。
vGu8SingleKeySec=1; //触发K1的“短按”
}
}
else if(0==Su8KeyLock1)//单个按键K1被按下
{
Su16KeyCnt1++; //累加定时中断次数
if(Su16KeyCnt1>=KEY_SHORT_TIME) //“短按”兼“滤波”的“稳定时间”KEY_SHORT_TIME
{
//注意，这里不能“自锁”。后面“长按”触发的时候才“自锁”。
Su8KeyShortFlag=1; //K1的“短按”标志有效，待松手时触发。
}
if(Su16KeyCnt1>=KEY_LONG_TIME) //“长按”兼“滤波”的“稳定时间”KEY_LONG_TIME
{
Su8KeyLock1=1; //此时“长按”触发才“自锁”
Su8KeyShortFlag=0; //既然此时“长按”有效，那么就要废除潜在的“短按”。
vGu8SingleKeySec=2; //触发K1的“长按”
}
}
}
void SingleKeyTask(void) //单击按键任务函数，放在主函数内
{
if(0==vGu8SingleKeySec)
{
return; //按键的触发序号是0意味着无按键触发，直接退出当前函数，不执行此函数下面的代码
}
switch(vGu8SingleKeySec) //根据不同的按键触发序号执行对应的代码
{
case 1: //K1“短按”触发的任务
if(0==Gu8LedStatus)
{
Gu8LedStatus=1;
LedOpen(); //LED亮
}
else
{
Gu8LedStatus=0;
LedClose(); //LED灭
}
vGu8SingleKeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一致触发
break;
case 2: //K1“长按”触发的任务
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //触发一次“长按”后，发出“嘀”一声
vGu8BeepTimerFlag=1;
vGu8SingleKeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一致触发
break;
}
}

复制代码

刘华 · 2017-11-20 09:53:59

跟着鸿哥学习！！！

吴迪 · 2017-11-20 09:55:03

学习学习

ZHAOLH · 2017-11-20 10:46:58

坚持！！！！！！！！！！！！！！

龙 · 2017-11-20 14:13:12

我的天，这么好的资料！！！

吴坚鸿 · 2017-11-26 11:35:33

第九十七节：独立按键按住不松手的连续均匀触发。

【97.1 按住不松手的连续均匀触发。】

            上图97.1.1  独立按键电路


            上图97.1.2  灌入式驱动8个LED


            上图97.1.3  有源蜂鸣器电路

      在电脑上删除某个文件某行文字的时候，单击一次“退格按键[Backspace]”，就删除一个文字，如果按住“退格按键[Backspace]”不松手，就会“连续均匀”的触发“删除”的功能，自动逐个把整行文字删除清空，这就是“按住不松手的连续均匀触发”应用案例之一。除此之外，在很多需要人机交互的项目中都有这样的功能，为了快速加减某个数值，按住某个按键不松手，某个数值有节奏地快速往上加或者快速往下减。这种“按住不松手连续均匀触发”的按键识别，在程序上有“3个时间”需要留意，第1个是按键单击的“滤波”时间，第2个是按键“从单击进入连击”的间隔时间（此时间是“单击”与“连击”的分界线），第3个是按键“连击”的间隔时间，
      本节例程实现的功能如下：（1）8个受按键控制的跑马灯在某一时刻只有1个LED亮，每触发一次K1按键，“亮的LED”就“往左边跑一步”；相反，每触发一次K2按键，“亮的LED”就“往右边跑一步”。如果按住K1或者K2不松手就连续触发，“亮的LED”就“连续跑”，一直跑到左边或者右边的尽头。（2）按键每“单击”一次蜂鸣器就鸣叫一次，但是，当按键“从单击进入连击”后，蜂鸣器就不鸣叫。

#include "REG52.H"
#define KEY_VOICE_TIME 50
#define KEY_SHORT_TIME 25 //按键单击的“滤波”时间25ms
#define KEY_ENTER_CONTINUITY_TIME 300 //按键“从单击进入连击”的间隔时间300ms
#define KEY_CONTINUITY_TIME 80 //按键“连击”的间隔时间80ms
#define BUS_P0 P0 //8个LED灯一一对应单片机的P0口总线
void T0_time();
void SystemInitial(void) ;
void Delay(unsigned long u32DelayTime) ;
void PeripheralInitial(void) ;
void BeepOpen(void);
void BeepClose(void);
void VoiceScan(void);
void KeyScan(void);
void KeyTask(void);
void DisplayTask(void); //显示的任务函数（LED显示状态）
***it P3_4=P3^4; //蜂鸣器
***it KEY_INPUT1=P2^2; //K1按键识别的输入口。
***it KEY_INPUT2=P2^1; //K2按键识别的输入口。
volatile unsigned char vGu8BeepTimerFlag=0;
volatile unsigned int vGu16BeepTimerCnt=0;
unsigned char Gu8LedStatus=0; //LED灯的状态
unsigned char Gu8DisplayUpdate=1; //显示的刷新标志
volatile unsigned char vGu8KeySec=0; //按键的触发序号
volatile unsigned char vGu8ShieldVoiceFlag=0; //屏蔽声音的标志
void main()
{
SystemInitial();
Delay(10000);
PeripheralInitial();
while(1)
{
KeyTask(); //按键的任务函数
DisplayTask(); //显示的任务函数（LED显示状态）
}
}
/* 注释一：
* Gu8DisplayUpdate这类“显示刷新变量”在“显示框架”里是很常见的，而且屡用屡爽。
* 目的是，既能及时刷新显示，又能避免主函数“不断去执行显示代码”而影响程序效率。
*/
void DisplayTask(void) //显示的任务函数（LED显示状态）
{
if(1==Gu8DisplayUpdate) //需要刷新一次显示
{
Gu8DisplayUpdate=0; //及时清零，避免主函数“不断去执行显示代码”而影响程序效率
//Gu8LedStatus是左移的位数，范围（0至7），决定了跑马灯的显示状态。
BUS_P0=~(1<
}
}
/* 注释二：
* 按键“连续均匀触发”的识别过程：
* 第一步：平时只要K1没有被按下，按键的自锁标志Su8KeyLock1、去抖动延时计数器Su16KeyCnt1、
* 连击计数器Su16KeyContinuityCnt1，一直被清零。
* 第二步：一旦K1按键被按下，去抖动延时计数器Su16KeyCnt1开始在定时中断函数里累加，在还没
* 累加到阀值KEY_SHORT_TIME时，如果在这期间由于受外界干扰或者按键抖动，
* 而使IO口突然瞬间触发成高电平，这个时候马上把延时计数器Su16KeyCnt1清零,
* 这个过程非常巧妙，非常有效地去除瞬间的杂波干扰。
* 第三步：如果K1按键按下的时间超过了阀值KEY_SHORT_TIME，则触发一次“单击”，同时，马上把自锁
* 标志Su8KeyLock1置1防止按住按键不松手后一直触发，并且把计数器Su16KeyCnt1清零为了下
* 一步用来累加“从单击进入连击的间隔时间1000ms”。如果此时还没有松手，直到发现按下的时
* 间超过“从单击进入连击的间隔时间”阀值KEY_ENTER_CONTINUITY_TIME时，从此进入“连击”
* 的模式，连击计数器Su16KeyContinuityCnt1开始累加，每到达一次阀值
* KEY_CONTINUITY_TIME就触发1次按键，为了屏蔽按键声音及时把vGu8ShieldVoiceFlag也置1，
* 同时，Su16KeyContinuityCnt1马上清零为继续连击作准备。
* 第四步：等K1按键松手后，自锁标志Su8KeyLock1、去抖动延时计数器Su16KeyCnt1、
* 连击计数器Su16KeyContinuityCnt1，及时清零，为下一次按键触发做准备。
*/
void KeyScan(void) //此函数放在定时中断里每1ms扫描一次
{
static unsigned char Su8KeyLock1;
static unsigned int Su16KeyCnt1;
static unsigned int Su16KeyContinuityCnt1; //连击计数器
static unsigned char Su8KeyLock2;
static unsigned int Su16KeyCnt2;
static unsigned int Su16KeyContinuityCnt2; //连击计数器
//K1按键
if(0!=KEY_INPUT1)//单个K1按键没有按下，及时清零一些标志。
{
Su8KeyLock1=0; //按键解锁
Su16KeyCnt1=0; //去抖动延时计数器清零，此行非常巧妙，是全场的亮点。
Su16KeyContinuityCnt1=0; //连击计数器
}
else if(0==Su8KeyLock1)//单个按键K1被按下
{
Su16KeyCnt1++; //累加定时中断次数，每一次累加额度是1ms
if(Su16KeyCnt1>=KEY_SHORT_TIME) //按键的“滤波”时间25ms
{
Su8KeyLock1=1; //“自锁”
vGu8KeySec=1; //触发一次K1按键
Su16KeyCnt1=0; //清零，为了下一步用来累加“从单击进入连击的间隔时间300ms”
}
}
else if(Su16KeyCnt1<=KEY_ENTER_CONTINUITY_TIME)//按住不松手累加到300ms
{
Su16KeyCnt1++; //累加定时中断次数，每一次累加额度是1ms
}
else //按住累加到300ms后仍然不放手，这个时候进入有节奏的连续触发
{
Su16KeyContinuityCnt1++; //连击计数器开始累加，每一次累加额度是1ms
if(Su16KeyContinuityCnt1>=KEY_CONTINUITY_TIME) //按住没松手，每0.08秒就触发一次
{
Su16KeyContinuityCnt1=0; //清零，为了继续连击。
vGu8KeySec=1; //触发一次K1按键
vGu8ShieldVoiceFlag=1; //把当前按键触发的声音屏蔽掉
}
}
//K2按键
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
{
Su16KeyContinuityCnt2++;
if(Su16KeyContinuityCnt2>=KEY_CONTINUITY_TIME)
{
Su16KeyContinuityCnt2=0;
vGu8KeySec=2; //触发一次K2按键
vGu8ShieldVoiceFlag=1; //把当前按键触发的声音屏蔽掉
}
}
}
void KeyTask(void) //按键任务函数，放在主函数内
{
if(0==vGu8KeySec)
{
return; //按键的触发序号是0意味着无按键触发，直接退出当前函数，不执行此函数下面的代码
}
switch(vGu8KeySec) //根据不同的按键触发序号执行对应的代码
{
case 1: //K1触发的任务
if(Gu8LedStatus>0)
{
Gu8LedStatus--; //控制LED“往左边跑”
Gu8DisplayUpdate=1; //刷新显示
}
if(0==vGu8ShieldVoiceFlag) //声音没有被屏蔽
{
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //触发一次“长按”后，发出“嘀”一声
vGu8BeepTimerFlag=1;
}
vGu8ShieldVoiceFlag=0; //及时把屏蔽标志清零，避免平时正常的单击声音也被淹没。
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一致触发
break;
case 2: //K2触发的任务
if(Gu8LedStatus<7)
{
Gu8LedStatus++; //控制LED“往右边跑”
Gu8DisplayUpdate=1; //刷新显示
}
if(0==vGu8ShieldVoiceFlag) //声音没有被屏蔽
{
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //触发一次“长按”后，发出“嘀”一声
vGu8BeepTimerFlag=1;
}
vGu8ShieldVoiceFlag=0; //及时把屏蔽标志清零，避免平时正常的单击声音也被淹没。
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一致触发
break;
}
}
void T0_time() interrupt 1
{
VoiceScan();
KeyScan(); //按键识别的驱动函数
TH0=0xfc;
TL0=0x66;
}
void SystemInitial(void)
{
TMOD=0x01;
TH0=0xfc;
TL0=0x66;
EA=1;
ET0=1;
TR0=1;
}
void Delay(unsigned long u32DelayTime)
{
for(;u32DelayTime>0;u32DelayTime--);
}
void PeripheralInitial(void)
{
}
void BeepOpen(void)
{
P3_4=0;
}
void BeepClose(void)
{
P3_4=1;
}
void VoiceScan(void)
{
static unsigned char Su8Lock=0;
if(1==vGu8BeepTimerFlag&&vGu16BeepTimerCnt>0)
{
if(0==Su8Lock)
{
Su8Lock=1;
BeepOpen();
}
else
{
vGu16BeepTimerCnt--;
if(0==vGu16BeepTimerCnt)
{
Su8Lock=0;
BeepClose();
}
}
}
}

复制代码

刘斌 · 2017-11-29 11:54:04

跟着大神每天学习学习

ZHAOLH · 2017-11-30 10:55:53

你敢跟新，我就顶帖！！！！！！！！！！

ZHAOLH · 2017-11-30 10:56:24

你敢跟新，我就顶帖！！！！！！！！！！

周勇 · 2017-11-30 17:09:44

谢谢

马先生 · 2017-12-5 15:25:04

jianhong_wu 发表于 2017-9-4 19:32
第八十五节：定时中断的寄存器配置。

【85.1 寄存器配置的本质。】

感谢楼主分享

吴坚鸿 · 2017-12-7 11:35:49

第九十八节：独立按键按住不松手的“先加速后匀速”的触发。

【98.1 “先加速后匀速”的触发。】


            上图98.1.1  独立按键电路


            上图98.1.2  灌入式驱动8个LED


            上图98.1.3  有源蜂鸣器电路

      当“连续加”或者“连续减”的数据范围很大的时候，就需要按键的加速与匀速相结合的触发方式。“加速”是指按住按键不松手，按键刚开始触发是从慢到快的渐进过程，当“加速”到某个特别快的速度的时候，就“不再加速”，而是以该“恒定高速”进行“连续匀速”触发。这种触发方式，“加速”和“匀速”是相辅相成缺一不可的，为什么？假如没有“加速”只有“匀速”，那么刚按下按键就直接以最高速的“匀速”进行，就会跑过头，缺乏微调功能；而假如没有“匀速”只有“加速”，那么按下按键不松手后，速度就会一直不断飙升，最后失控过冲。
      本节例程实现的功能如下：
   （1）要更改一个“设置参数”（一个全局变量），参数的范围是0到800。
   （2）8个受“设置参数”控制的跑马灯在某一时刻只有1个LED亮，每触发一次K1按键，该“设置参数”就自减1，最小值为0；相反，每触发一次K2按键，该“设置参数”就自加1，最大值为800。
   （3）LED灯实时显示“设置参数”的范围状态：
            只有第0个LED灯亮：0<=“设置参数”<100。
            只有第1个LED灯亮：100<=“设置参数”<200。
            只有第2个LED灯亮：200<=“设置参数”<300。
            只有第3个LED灯亮：300<=“设置参数”<400。
            只有第4个LED灯亮：400<=“设置参数”<500。
            只有第5个LED灯亮：500<=“设置参数”<600。
            只有第6个LED灯亮：600<=“设置参数”<700。
            只有第7个LED灯亮：700<=“设置参数”<=800。
   （4）按键每“单击”一次蜂鸣器就鸣叫一次，但是，当按键“从单击进入连击”后，蜂鸣器就不鸣叫。

#include "REG52.H"
#define KEY_VOICE_TIME 50
#define KEY_SHORT_TIME 25 //按键单击的“滤波”时间
#define KEY_ENTER_CONTINUITY_TIME 300 //按键“从单击进入连击”的间隔时间
#define KEY_CONTINUITY_INITIAL_TIME 80 //按键“连击”起始的预设间隔时间
#define KEY_SUB_DT_TIME 8 //按键在“加速”时每次减小的时间。
#define KEY_CONTINUITY_MIN_TIME 10 //按键时间减小到最后的“匀速”间隔时间。
#define BUS_P0 P0 //8个LED灯一一对应单片机的P0口总线
void T0_time();
void SystemInitial(void) ;
void Delay(unsigned long u32DelayTime) ;
void PeripheralInitial(void) ;
void BeepOpen(void);
void BeepClose(void);
void VoiceScan(void);
void KeyScan(void);
void KeyTask(void);
void DisplayTask(void); //显示的任务函数（LED显示状态）
***it P3_4=P3^4; //蜂鸣器
***it KEY_INPUT1=P2^2; //K1按键识别的输入口。
***it KEY_INPUT2=P2^1; //K2按键识别的输入口。
volatile unsigned char vGu8BeepTimerFlag=0;
volatile unsigned int vGu16BeepTimerCnt=0;
unsigned int Gu16SetData=0; //“设置参数”。范围从0到800。LED灯反映该当前值的范围状态
unsigned char Gu8DisplayUpdate=1; //显示的刷新标志
volatile unsigned char vGu8KeySec=0; //按键的触发序号
volatile unsigned char vGu8ShieldVoiceFlag=0; //屏蔽声音的标志
void main()
{
SystemInitial();
Delay(10000);
PeripheralInitial();
while(1)
{
KeyTask(); //按键的任务函数
DisplayTask(); //显示的任务函数（LED显示状态）
}
}
/* 注释一：
* Gu8DisplayUpdate这类“显示刷新变量”在“显示框架”里是很常见的，而且屡用屡爽。
* 目的是，既能及时刷新显示，又能避免主函数“不断去执行显示代码”而影响程序效率。
*/
void DisplayTask(void) //显示的任务函数（LED显示状态）
{
if(1==Gu8DisplayUpdate) //需要刷新一次显示
{
Gu8DisplayUpdate=0; //及时清零，避免主函数“不断去执行显示代码”而影响程序效率
if(Gu16SetData<100)
{
BUS_P0=~(1<<0); //第0个灯亮
}
else if(Gu16SetData<200)
{
BUS_P0=~(1<<1); //第1个灯亮
}
else if(Gu16SetData<300)
{
BUS_P0=~(1<<2); //第2个灯亮
}
else if(Gu16SetData<400)
{
BUS_P0=~(1<<3); //第3个灯亮
}
else if(Gu16SetData<500)
{
BUS_P0=~(1<<4); //第4个灯亮
}
else if(Gu16SetData<600)
{
BUS_P0=~(1<<5); //第5个灯亮
}
else if(Gu16SetData<700)
{
BUS_P0=~(1<<6); //第6个灯亮
}
else
{
BUS_P0=~(1<<7); //第7个灯亮
}
}
}
/* 注释二：
* 按键“先加速后匀速”的识别过程：
* 第一步：每次按一次就触发一次“单击”，如果按下去到松手的时间不超过1秒，则不会进入
* “连击”模式。
* 第二步：如果按下去不松手的时间超过1秒，则进入“连击”模式。按键触发的节奏
* 不断加快，直至到达某个极限值，然后以此极限值间隔匀速触发。这就是“先加速后匀速”。
*/
void KeyScan(void) //此函数放在定时中断里每1ms扫描一次
{
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; //动态时间阀值
//K1按键
if(0!=KEY_INPUT1)//单个K1按键没有按下，及时清零一些标志。
{
Su8KeyLock1=0; //按键解锁
Su16KeyCnt1=0; //去抖动延时计数器清零，此行非常巧妙，是全场的亮点。
Su16KeyContinuityCnt1=0; //连击计数器
Su16KeyContinuityTime1=KEY_CONTINUITY_INITIAL_TIME; //动态时间阀值。重装初始值。
}
else if(0==Su8KeyLock1)//单个按键K1被按下
{
Su16KeyCnt1++; //累加定时中断次数，每一次累加额度是1ms
if(Su16KeyCnt1>=KEY_SHORT_TIME) //按键的“滤波”时间25ms
{
Su8KeyLock1=1; //“自锁”
vGu8KeySec=1; //触发一次K1按键
Su16KeyCnt1=0; //清零，为了下一步用来累加“从单击进入连击的间隔时间300ms”
}
}
else if(Su16KeyCnt1<=KEY_ENTER_CONTINUITY_TIME)//按住不松手累加到300ms
{
Su16KeyCnt1++; //累加定时中断次数，每一次累加额度是1ms
}
else //按住累加到300ms后仍然不放手，这个时候进入有节奏的连续触发
{
Su16KeyContinuityCnt1++; //连击计数器开始累加，每一次累加额度是1ms
if(Su16KeyContinuityCnt1>=Su16KeyContinuityTime1) //按住没松手，每隔一会就触发一次
{
Su16KeyContinuityCnt1=0; //清零，为了继续连击。
vGu8KeySec=1; //触发一次K1按键
vGu8ShieldVoiceFlag=1; //把当前按键触发的声音屏蔽掉
if(Su16KeyContinuityTime1>=KEY_SUB_DT_TIME)
{
//此数值不断被减小，按键的触发速度就不断变快
Su16KeyContinuityTime1=Su16KeyContinuityTime1-KEY_SUB_DT_TIME;//变快节奏
}
if(Su16KeyContinuityTime1
{
Su16KeyContinuityTime1=KEY_CONTINUITY_MIN_TIME; //最后以此最高速进行“匀速”
}
}
}
//K2按键
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; //触发一次K2按键
Su16KeyCnt2=0;
}
}
else if(Su16KeyCnt2<=KEY_ENTER_CONTINUITY_TIME)
{
Su16KeyCnt2++;
}
else
{
Su16KeyContinuityCnt2++;
if(Su16KeyContinuityCnt2>=Su16KeyContinuityTime2)
{
Su16KeyContinuityCnt2=0;
vGu8KeySec=2; //触发一次K2按键
vGu8ShieldVoiceFlag=1;
if(Su16KeyContinuityTime2>=KEY_SUB_DT_TIME)
{
Su16KeyContinuityTime2=Su16KeyContinuityTime2-KEY_SUB_DT_TIME;
}
if(Su16KeyContinuityTime2
{
Su16KeyContinuityTime2=KEY_CONTINUITY_MIN_TIME;
}
}
}
}
void KeyTask(void) //按键任务函数，放在主函数内
{
if(0==vGu8KeySec)
{
return; //按键的触发序号是0意味着无按键触发，直接退出当前函数，不执行此函数下面的代码
}
switch(vGu8KeySec) //根据不同的按键触发序号执行对应的代码
{
case 1: //K1触发的任务
if(Gu16SetData>0)
{
Gu16SetData--; //“设置参数”
Gu8DisplayUpdate=1; //刷新显示
}
if(0==vGu8ShieldVoiceFlag) //声音没有被屏蔽
{
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //发出“嘀”一声
vGu8BeepTimerFlag=1;
}
vGu8ShieldVoiceFlag=0; //及时把屏蔽标志清零，避免平时正常的单击声音也被淹没。
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一致触发
break;
case 2: //K2触发的任务
if(Gu16SetData<800)
{
Gu16SetData++; //“设置参数”
Gu8DisplayUpdate=1; //刷新显示
}
if(0==vGu8ShieldVoiceFlag) //声音没有被屏蔽
{
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //发出“嘀”一声
vGu8BeepTimerFlag=1;
}
vGu8ShieldVoiceFlag=0; //及时把屏蔽标志清零，避免平时正常的单击声音也被淹没。
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一致触发
break;
}
}
void T0_time() interrupt 1
{
VoiceScan();
KeyScan(); //按键识别的驱动函数
TH0=0xfc;
TL0=0x66;
}
void SystemInitial(void)
{
TMOD=0x01;
TH0=0xfc;
TL0=0x66;
EA=1;
ET0=1;
TR0=1;
}
void Delay(unsigned long u32DelayTime)
{
for(;u32DelayTime>0;u32DelayTime--);
}
void PeripheralInitial(void)
{
}
void BeepOpen(void)
{
P3_4=0;
}
void BeepClose(void)
{
P3_4=1;
}
void VoiceScan(void)
{
static unsigned char Su8Lock=0;
if(1==vGu8BeepTimerFlag&&vGu16BeepTimerCnt>0)
{
if(0==Su8Lock)
{
Su8Lock=1;
BeepOpen();
}
else
{
vGu16BeepTimerCnt--;
if(0==vGu16BeepTimerCnt)
{
Su8Lock=0;
BeepClose();
}
}
}
}