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

单片机

njwueng · 2017-10-12 09:52:15

不错的文章，通俗易懂，顶一个

ZHAOLH · 2017-10-12 10:03:24

知道你喜欢楼主的帖子，但这样刷屏顶帖就有点过了，可能楼主也不太喜欢！

J木昜 · 2017-10-14 11:40:32

花了两天的时间看完了90节很有收获编程的模块化处理使得程序的可读性和易修改性增强如果单纯的为了点亮发光二极管或者实现流水灯的话楼主不用花这么多时间和心思写那么多程序正如楼主标题所言写的是程序框架

张洪德 · 2017-10-15 14:04:22

好文，大神的态度值得尊敬，教程非常值得学习拜读。感谢！

吴坚鸿 · 2017-10-17 17:54:59

第九十一节：蜂鸣器的“非阻塞”驱动。

【91.1 蜂鸣器的硬件电路简介。】


   上图91.1.1  PNP三极管驱动有源蜂鸣器

   蜂鸣器有两种，一种是有源蜂鸣器，一种是无源蜂鸣器。有源蜂鸣器的驱动最简单，只要通电就一直响，断电就停，跟驱动LED灯一样。无源蜂鸣器则不一样，无源蜂鸣器一直断电不响，奇怪的是一直通电也不响，只有“通，关，通，关...”反复通电关电的状态，才会持续发生稳定的声音，此方式称为脉冲驱动方式，或者PWM驱动方式。本教程用的是有源蜂鸣器。
   蜂鸣器的驱动电路也有两种常用的方式，一种是NPN三极管驱动，一种是PNP三极管驱动。NPN三极管驱动电路，单片机输出“1”（高电平）蜂鸣器导通，输出“0”（低电平）蜂鸣器关闭。而PNP三极管驱动电路恰恰相反，单片机输出“0”（低电平）蜂鸣器导通，输出“1”（高电平）蜂鸣器关闭。本教程所用的是PNP三极管驱动电路，如上图。

【91.2 “非阻塞”驱动程序。】

   “驱动层”是相对“应用层”而言。“应用层”发号施令，“驱动层”负责执行。一个好的“驱动层”必须给“应用层”提供快捷便利的调用接口，此接口可以是函数或者全局变量。本节驱动蜂鸣器所用的是全局变量vGu16BeepTimerCnt。“应用层”只需给vGu16BeepTimerCnt赋值，就可以控制蜂鸣器发声，赋值越大，发声越长，500代表发声500ms，1000代表发声1000ms，具体细节实现，则由“驱动层”的驱动函数负责执行，驱动函数放在定时中断函数里定时扫描。为什么不把驱动函数放到main函数的循环里去？因为放在定时中断里，能保证蜂鸣器的声音长度是一致的，如果放在main循环里，声音的长度有可能在某些项目中受到某些必须一气呵成的任务干扰，得不到及时响应，影响声音长度的一致性。下面代码实现的功能是，单片机只要一上电，蜂鸣器就发出一次1000ms长度的“嘀”声音。

#include "REG52.H"
#define BEEP_TIME 1000 //控制蜂鸣器发声的长度，此处是1000ms
void T0_time();
void SystemInitial(void) ;
void Delay(unsigned long u32DelayTime) ;
void PeripheralInitial(void) ;
void BeepOpen(void); //蜂鸣器发声
void BeepClose(void); //蜂鸣器关闭
void VoiceScan(void); //蜂鸣器的驱动函数，放在定时中断里
***it P3_4=P3^4; //控制蜂鸣器的IO口。0代表发声，1代表关闭。
volatile unsigned char vGu8BeepTimerFlag=0;
volatile unsigned int vGu16BeepTimerCnt=0; //控制蜂鸣器发声长度的计时器
void main()
{
SystemInitial();
Delay(10000);
PeripheralInitial(); //此函数内部有“应用层”的赋值操作，控制上电的声音长度。
while(1)
{
;
}
}
void T0_time() interrupt 1
{
VoiceScan(); //蜂鸣器的驱动函数
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)
{
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=BEEP_TIME; //“应用层”只需赋值，一上电，蜂鸣器发出1000ms长度的声音。
vGu8BeepTimerFlag=1;
}
//蜂鸣器发声
void BeepOpen(void)
{
P3_4=0; //0代表发声
}
//蜂鸣器关闭
void BeepClose(void)
{
P3_4=1; //1代表关闭
}
//蜂鸣器的驱动函数，放在定时中断函数里每定时1ms扫描一次。
void VoiceScan(void)
{
//Su8Lock的作用是避免BeepOpen()被重复扫描影响效率，发声时只执行一次此函数即可。
//同时，也巧妙借用else结构，实现逻辑顺序分解成“先发声，下一次再开始定时”的两个步骤。
static unsigned char Su8Lock=0;
if(1==vGu8BeepTimerFlag&&vGu16BeepTimerCnt>0)
{
if(0==Su8Lock)
{
Su8Lock=1; //进入触发声音后就自锁起来
BeepOpen(); //发声，此处封装成函数，为了今后代码的移植性。
}
else //巧妙借用else结构，实现先发声，下一次中断再开始计时的逻辑顺序。比如，
{ //如果赋值1，就能确保有1ms的计时发声。
vGu16BeepTimerCnt--; //定时器自减，控制蜂鸣器发声的时间长度
if(0==vGu16BeepTimerCnt)
{
Su8Lock=0; //关闭声音后，及时解锁，为下一次触发做准备
BeepClose(); //关闭声音，此处封装成函数，为了今后代码的移植性。
}
}
}
}

复制代码

yy1yy1 · 2017-10-17 18:50:34

支持楼主，谢谢你的无私

J木昜 · 2017-10-18 13:43:58

定时器中断函数需要声明吗？不是直接可以用？

J木昜 · 2017-10-19 14:35:05

楼主有没有朱兆祺51单片机开发板的原理图只看程序没有原理图不行啊！！！

小陈 · 2017-10-20 10:13:37

lsf1 · 2017-10-24 16:20:04

顶再顶写的的真不错！！！！！！！！

lsf1 · 2017-10-24 16:20:38

顶再顶写的的真不错！！！！！！！！

lsf1 · 2017-10-24 16:21:25

顶再顶写的的真不错！！！！！！！！

lsf1 · 2017-10-24 16:30:23

顶再顶写的的真不错！！！！！！！！

db1001001 · 2017-10-25 10:19:45

还没更吗

QidongChen · 2017-10-25 10:58:50

支持！！！明明可以靠技术，现在靠人品

吴坚鸿 · 2017-10-25 11:30:28

本帖最后由 jianhong_wu 于 2017-10-28 09:10 编辑

第九十二节：独立按键的四大要素（自锁，消抖，非阻塞，清零式滤波）。

【92.1 独立按键的硬件电路简介。】

            上图92.1.1  独立按键电路

   按键有两种驱动方式，一种是独立按键，一种是矩阵按键。1个独立按键要占用1个IO口，IO口不能共用。而矩阵按键的IO口是分时片选复用的，用少量的IO口就可以驱动翻倍级别的按键数量。比如，用8个IO口只能驱动8个独立按键，但是却可以驱动16个矩阵按键（4x4）。因此，按键少的时候就用独立按键，按键多的时候就用矩阵按键。这两种按键的驱动本质是一样的，都是靠识别输入信号的下降沿（或上升沿）来识别按键的触发。
   独立按键的硬件原理基础，如上图，P2.2这个IO口，在按键K1没有被按下的时候，P2.2口因为单片机内部自带上拉电阻把电平拉高，此时P2.2口是高电平的输入状态。当按键K1被按下的时候，按键K1左右像一根导线连接到电源的负极（GND），直接把原来P2.2口的电平拉低，此时P2.2口变成了低电平的输入状态。编写按键驱动程序，就是要识别这个电平从高到低的过程，这个过程也叫下降沿。多说一句，51单片机的P1,P2,P3口是内部自带上拉电阻的，而P0口是内部没有上拉电阻的，需要外接上拉电阻。除此之外，很多单片机内部其实都没有上拉电阻的，因此，建议大家在做独立按键电路的时候，养成一个习惯，凡是按键输入状态都外接上拉电阻。
   识别按键的下降沿触发有四大要素：自锁，消抖，非阻塞，清零式滤波。
   “自锁”，按键一旦进入到低电平，就要“自锁”起来，避免不断触发按键，只有当按键被松开变成高电平的时候，才及时“解锁”为下一次触发做准备。
   “消抖”，按键是一个机械触点器件，在接触的瞬间必然存在微观上的机械抖动，反馈到电平的瞬间就是“高，低，高，低...”这种不稳定的电平状态是一种干扰，但是，按键一旦按下去稳定了之后，这种状态就消失，电平就一直保持稳定的低电平。消抖的本质就是滤波，要把这种接触的瞬间抖动过滤掉，避免按键的“一按多触发”。
   “非阻塞”，在处理消抖的时候，必须用到延时，如果此时用阻塞的delay延时就会影响其它任务的运行效率，因此，用非阻塞的定时延时更加有优越性。
   “清零式滤波”，在消抖的时候，有两种境界，第一种境界是判断两次电平的状态，中间插入“固定的时间”延时，这种方法前后一共判断了两次，第一次是识别到低电平就进入延时的状态，第二次是延时后再确认一次是否继续是低电平的状态，这种方法的不足是，“固定的时间”全凭经验值，但是不同的按键它们的抖动时间长度是不同的，除此之外，前后才判断了两次，在软件的抗干扰能力上也弱了很多，“密码等级”不够高。第二种境界就是“清零式滤波”，“清零式滤波”非常巧妙，抗扰能力超强，它能自动过滤不同按键的“抖动时间”，然后再进入一个“稳定时间”的“N次识别判断”，更加巧妙的是，在“抖动时间”和“稳定时间”两者时间内，只要发现一次是高电平的干扰，就马上自动清零计时器，重新开始计时。“稳定时间”一般取20ms到30ms之间，而“抖动时间”是隐藏的，在代码上并没有直接描写出来，但是却无形地融入了代码之中，只有慢慢体会才能发现它的存在。
      具体的代码如下，实现的功能是按一次K1或者K2按键，就触发一次蜂鸣器鸣叫。

#include "REG52.H"
#define KEY_VOICE_TIME 50 //按键触发后发出的声音长度
#define KEY_FILTER_TIME 25 //按键滤波的“稳定时间”25ms
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); //按键任务函数，放在主函数内
***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;
volatile unsigned char vGu8KeySec=0; //按键的触发序号，全局变量意味着是其它函数的接口。
void main()
{
SystemInitial();
Delay(10000);
PeripheralInitial();
while(1)
{
KeyTask(); //按键任务函数
}
}
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();
}
}
}
}
/* 注释一：
* 独立按键扫描的详细过程，以按键K1为例，如下：
* 第一步：平时没有按键被触发时，按键的自锁标志,去抖动延时计数器一直被清零。
* 第二步：一旦有按键被按下，去抖动延时计数器开始在定时中断函数里累加，在还没累加到
* 阀值KEY_FILTER_TIME时，如果在这期间由于受外界干扰或者按键抖动，而使
* IO口突然瞬间触发成高电平，这个时候马上把延时计数器Su16KeyCnt1清零了,这个过程
* 非常巧妙，非常有效地去除瞬间的杂波干扰。以后凡是用到开关感应器的时候，
* 都可以用类似这样的方法去干扰。
* 第三步：如果按键按下的时间达到阀值KEY_FILTER_TIME时，则触发按键，把编号vGu8KeySec赋值。
* 同时，马上把自锁标志Su8KeyLock1置1，防止按住按键不松手后一直触发。
* 第四步：等按键松开后，自锁标志Su8KeyLock1及时清零（解锁），为下一次自锁做准备。
* 第五步：以上整个过程，就是识别按键IO口下降沿触发的过程。
*/
void KeyScan(void) //此函数放在定时中断里每1ms扫描一次
{
static unsigned char Su8KeyLock1; //1号按键的自锁
static unsigned int Su16KeyCnt1; //1号按键的计时器
static unsigned char Su8KeyLock2; //2号按键的自锁
static unsigned int Su16KeyCnt2; //2号按键的计时器
//1号按键
if(0!=KEY_INPUT1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
{
Su8KeyLock1=0; //按键解锁
Su16KeyCnt1=0; //按键去抖动延时计数器清零，此行非常巧妙，是全场的亮点。
}
else if(0==Su8KeyLock1)//有按键按下，且是第一次被按下。这行很多初学者有疑问，请看专题分析。
{
Su16KeyCnt1++; //累加定时中断次数
if(Su16KeyCnt1>=KEY_FILTER_TIME) //滤波的“稳定时间”KEY_FILTER_TIME，长度是25ms。
{
Su8KeyLock1=1; //按键的自锁,避免一直触发
vGu8KeySec=1; //触发1号键
}
}
//2号按键
if(0!=KEY_INPUT2)
{
Su8KeyLock2=0;
Su16KeyCnt2=0;
}
else if(0==Su8KeyLock2)
{
Su16KeyCnt2++;
if(Su16KeyCnt2>=KEY_FILTER_TIME)
{
Su8KeyLock2=1;
vGu8KeySec=2; //触发2号键
}
}
}
void KeyTask(void) //按键任务函数，放在主函数内
{
if(0==vGu8KeySec)
{
return; //按键的触发序号是0意味着无按键触发，直接退出当前函数，不执行此函数下面的代码
}
switch(vGu8KeySec) //根据不同的按键触发序号执行对应的代码
{
case 1: //1号按键
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //触发按键后，发出固定长度的声音
vGu8BeepTimerFlag=1;
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一致触发
break;
case 2: //2号按键
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //触发按键后，发出固定长度的声音
vGu8BeepTimerFlag=1;
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一致触发
break;
}
}

复制代码

【92.2 专题分析：else if(0==Su8KeyLock1)。】

疑问：

if(0!=KEY_INPUT1)
{
Su8KeyLock1=0;
Su16KeyCnt1=0;
}
else if(0==Su8KeyLock1)//有按键按下，且是第一次被按下。为什么？为什么？为什么？
{
Su16KeyCnt1++;
if(Su16KeyCnt1>KEY_FILTER_TIME)
{
Su8KeyLock1=1;
vGu8KeySec=1;
}
}

复制代码

解答：
首先，我们要明白C语言的语法中，

if(条件1)
{
}
else if(条件2)
{
}

复制代码

   以上语句是一对组合语句，不能分开来看。当（条件1）成立的时候，它是绝对不会判断（条件2）的。当（条件1）不成立的时候，才会判断（条件2）。
   回到刚才的问题，当程序执行到（条件2） else if(0==Su8KeyLock1)的时候，就已经默认了（条件1） if(0!=KEY_INPUT1)不成立，这个条件不成立，就意味着0==KEY_INPUT1，也就是有按键被按下，因此，这里的else if(0==Su8KeyLock1)等效于else if(0==Su8KeyLock1&&0==KEY_INPUT1)，而Su8KeyLock1是一个自锁标志位，一旦按键被触发后，这个标志位会变1，防止按键按住不松手的时候不断触发按键。这样，按键只能按一次触发一次，松开手后再按一次，又触发一次。

【92.3 专题分析：if(0!=KEY_INPUT1)。】

   疑问：为什么不用if(1==KEY_INPUT1)而用if(0!=KEY_INPUT1)？
   解答：其实两者在功能上是完全等效的，在这里都可以用。之所以本教程优先选用后者if(0!=KEY_INPUT1)，是因为考虑到了代码在不同单片机平台上的可移植性和兼容性。很多32位的单片机提供的是库函数，库函数返回的按键状态是一个字节变量来表示，当被按下的时候是0，但是，当没有按下的时候并不一定等于1，而是一个“非0”的数值。

【92.4 专题分析：把KeyScan函数放在定时器中断里。】

   疑问：为什么把KeyScan函数放在定时器中断里？
   解答：中断函数里放的函数或者代码越少越好，但是KeyScan函数是特殊的函数，是涉及到IO口输入信号的滤波，滤波就涉及到时间的及时性与均匀性，放在定时中断函数里更加能保证时间的一致性。比如，蜂鸣器驱动，动态数码管驱动，按键扫描驱动，我个人都习惯放在定时中断函数里。

【92.5 专题分析：if(0==vGu8KeySec)return。】

   疑问：if(0==vGu8KeySec)return是不是多此一举？
   解答：在KeyTask函数这里，if(0==vGu8KeySec)return这行代码删掉，对程序功能是没有影响的，这里之所以多插入这行判断语句，是因为，当按键多达几十个的时候，避免主函数每次进入KeyTask函数，都挨个扫描判断switch的状态进行多次判断，如果增加了这行if(0==vGu8KeySec)return代码，就可以直接退出省事，在理论上感觉更加运行高效。其实，不同单片机不同的C编译器可能对switch语句的翻译不一样，因此，这里的是不是更加高效我不敢保证。但是可以保证的是，加了这行代码也没有其它副作用。

ZHAOLH · 2017-10-25 16:37:18

终于等到楼主更新了！！！！！！！！！！！！！！！

吴坚鸿 · 2017-10-29 10:53:37

本帖最后由 jianhong_wu 于 2017-10-29 11:47 编辑

第九十三节：独立按键鼠标式的单击与双击。

【93.1 鼠标式的单击与双击。】

            上图93.1.1  独立按键电路

            上图93.1.2  LED电路


            上图93.1.3  有源蜂鸣器电路

      鼠标的左键，可以触发单击，也可以触发双击。双击的规则是这样的，两次单击，如果第1次单击与第2次单击的时间比较“短”的时候，则这两次单击就构成双击。编写这个程序的最大亮点是如何控制好第1次单击与第2次单击的时间间隔。程序例程要实现的功能是：（1）单击改变LED灯的显示状态，单击一次LED从原来“灭”的状态变成“亮”的状态，或者从原来“亮”的状态变成“灭”的状态，依次循环切换。（2）双击则蜂鸣器发出“嘀”的一声。代码如下：

#include "REG52.H"
#define KEY_VOICE_TIME 50 //按键触发后发出的声音长度
#define KEY_FILTER_TIME 25 //按键滤波的“稳定时间”25ms
#define KEY_INTERVAL_TIME 250 //连续两次单击之间的最大有效时间250ms
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); //单击按键任务函数，放在主函数内
void DoubleKeyTask(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; //单击按键的触发序号
volatile unsigned char vGu8DoubleKeySec=0; //双击按键的触发序号
void main()
{
SystemInitial();
Delay(10000);
PeripheralInitial();
while(1)
{
SingleKeyTask(); //单击按键任务函数
DoubleKeyTask(); //双击按键任务函数
}
}
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)
{
/* 注释一：
* 把LED的初始化放在PeripheralInitial而不是放在SystemInitial，是因为LED显示内容对上电
* 瞬间的要求不高。但是，如果是控制继电器，则应该把继电器的输出初始化放在SystemInitial。
*/
//根据Gu8LedStatus的值来初始化LED当前的显示状态，0代表灭，1代表亮
if(0==Gu8LedStatus)
{
LedClose(); //关闭LED
}
else
{
LedOpen(); //点亮LED
}
}
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();
}
}
}
}
/* 注释二：
* 双击按键扫描的详细过程：
* 第一步：平时没有按键被触发时，按键的自锁标志,去抖动延时计数器一直被清零。
* 如果之前已经有按键触发过1次单击，那么启动时间间隔计数器Su16KeyIntervalCnt1，
* 在KEY_INTERVAL_TIME这个允许的时间差范围内，如果一直没有第2次单击触发，
* 则把累加按键触发的次数Su8KeyTouchCnt1也清零，上一次累计的单击数被清零，
* 就意味着下一次新的双击必须重新开始累加两次单击数。
* 第二步：一旦有按键被按下，去抖动延时计数器开始在定时中断函数里累加，在还没累加到
* 阀值KEY_FILTER_TIME时，如果在这期间由于受外界干扰或者按键抖动，而使
* IO口突然瞬间触发成高电平，这个时候马上把延时计数器Su16KeyTimeCnt1
* 清零了,这个过程非常巧妙，非常有效地去除瞬间的杂波干扰，以后凡是用到开关感应器的时候，
* 都可以用类似这样的方法去干扰。
* 第三步：如果按键按下的时间超过了阀值KEY_FILTER_TIME，马上把自锁标志Su8KeyLock1置1，
* 防止按住按键不松手后一直触发。与此同时，累加1次按键次数，如果按键次数累加有2次，
* 则认为触发双击按键，并把编号vGu8DoubleKeySec赋值。
* 第四步：等按键松开后，自锁标志Su8KeyLock1及时清零解锁，为下一次自锁做准备。并且累加间隔时间，
* 防止两次按键的间隔时间太长。如果连续2次单击的间隔时间太长达到了KEY_INTERVAL_TIME
* 的长度，立即清零当前按键次数的计数器，这样意味着上一次的累加单击数无效，下一次双击
* 必须重新累加新的单击数。
*/
void KeyScan(void) //此函数放在定时中断里每1ms扫描一次
{
static unsigned char Su8KeyLock1; //1号按键的自锁
static unsigned int Su16KeyCnt1; //1号按键的计时器
static unsigned char Su8KeyTouchCnt1; //1号按键的次数记录
static unsigned int Su16KeyIntervalCnt1; //1号按键的间隔时间计数器
//1号按键
if(0!=KEY_INPUT1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
{
Su8KeyLock1=0; //按键解锁
Su16KeyCnt1=0; //按键去抖动延时计数器清零，此行非常巧妙。
if(Su8KeyTouchCnt1>=1) //之前已经有按键触发过一次，再来一次就构成双击
{
Su16KeyIntervalCnt1++; //按键间隔的时间计数器累加
if(Su16KeyIntervalCnt1>=KEY_INTERVAL_TIME) //达到最大允许的间隔时间
{
Su16KeyIntervalCnt1=0; //时间计数器清零
Su8KeyTouchCnt1=0; //清零按键的按下的次数
}
}
}
else if(0==Su8KeyLock1)//有按键按下，且是第一次被按下。此行如有疑问，请看第92节的讲解。
{
Su16KeyCnt1++; //累加定时中断次数
if(Su16KeyCnt1>=KEY_FILTER_TIME) //滤波的“稳定时间”KEY_FILTER_TIME，长度是25ms。
{
Su8KeyLock1=1; //按键的自锁,避免一直触发
Su16KeyIntervalCnt1=0; //按键有效间隔的时间计数器清零
Su8KeyTouchCnt1++; //记录当前单击的次数
if(1==Su8KeyTouchCnt1) //只按了1次
{
vGu8SingleKeySec=1; //单击任务
}
else if(Su8KeyTouchCnt1>=2) //连续按了两次以上
{
Su8KeyTouchCnt1=0; //统计按键次数清零
vGu8SingleKeySec=1; //单击任务
vGu8DoubleKeySec=1; //双击任务
}
}
}
}
void SingleKeyTask(void) //单击按键任务函数，放在主函数内
{
if(0==vGu8SingleKeySec)
{
return; //按键的触发序号是0意味着无按键触发，直接退出当前函数，不执行此函数下面的代码
}
switch(vGu8SingleKeySec) //根据不同的按键触发序号执行对应的代码
{
case 1: //单击任务
//通过Gu8LedStatus的状态切换，来反复切换LED的“灭”与“亮”的状态
if(0==Gu8LedStatus)
{
Gu8LedStatus=1; //标识并且更改当前LED灯的状态。0就变成1。
LedOpen(); //点亮LED
}
else
{
Gu8LedStatus=0; //标识并且更改当前LED灯的状态。1就变成0。
LedClose(); //关闭LED
}
vGu8SingleKeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一致触发
break;
}
}
void DoubleKeyTask(void) //双击按键任务函数，放在主函数内
{
if(0==vGu8DoubleKeySec)
{
return; //按键的触发序号是0意味着无按键触发，直接退出当前函数，不执行此函数下面的代码
}
switch(vGu8DoubleKeySec) //根据不同的按键触发序号执行对应的代码
{
case 1: //双击任务
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //触发双击后，发出“嘀”一声
vGu8BeepTimerFlag=1;
vGu8DoubleKeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一致触发
break;
}
}

复制代码

ZHAOLH · 2017-10-30 10:59:53

为楼主的坚持点赞！！！！！！！！

吴坚鸿 · 2017-11-5 11:19:49

第九十四节：两个独立按键构成的组合按键。

【94.1 组合按键。】

            上图94.1.1  独立按键电路

            上图94.1.2  LED电路


            上图94.1.3  有源蜂鸣器电路

      组合按键的触发，是指两个按键同时按下时的“非单击”触发。一次组合按键的产生，必然包含了三类按键的触发。比如，K1与K2两个独立按键，当它们产生一次组合按键的操作时，就包含了三类触发：K1单击触发，K2单击触发，K1与K2的组合触发。这三类触发可以看作是底层的按键驱动程序，在按键应用层的任务函数SingleKeyTask和CombinationKeyTask中，可以根据项目的实际需要进行响应。本节程序例程要实现的功能是：（1）K1单击让LED变成“亮”的状态。（2）K2单击让LED变成“灭”的状态。（3）K1与K2的组合按键触发让蜂鸣器发出“嘀”的一声。代码如下：

#include "REG52.H"
#define KEY_VOICE_TIME 50 //组合按键触发后发出的声音长度
#define KEY_FILTER_TIME 25 //按键滤波的“稳定时间”25ms
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); //单击按键任务函数，放在主函数内
void CombinationKeyTask(void); //组合按键任务函数，放在主函数内
***it P3_4=P3^4; //蜂鸣器
***it P1_4=P1^4; //LED
***it KEY_INPUT1=P2^2; //K1按键识别的输入口。
***it KEY_INPUT2=P2^1; //K2按键识别的输入口。
volatile unsigned char vGu8BeepTimerFlag=0;
volatile unsigned int vGu16BeepTimerCnt=0;
volatile unsigned char vGu8SingleKeySec=0; //单击按键的触发序号
volatile unsigned char vGu8CombinationKeySec=0; //组合按键的触发序号
void main()
{
SystemInitial();
Delay(10000);
PeripheralInitial();
while(1)
{
CombinationKeyTask(); //组合按键任务函数
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)
{
LedClose(); //初始化关闭LED
}
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与K2两个按键中有一个没有被按下时，按键的自锁标志,去抖动延时计数器
* 一直被清零。
* 第二步：一旦两个按键都处于被按下的状态，去抖动延时计数器开始在定时中断函数里累加，在还没
* 累加到阀值KEY_FILTER_TIME时，如果在这期间由于受外界干扰或者按键抖动，而使其中一个
* IO口突然瞬间触发成高电平，这个时候马上把延时计数器Su16CombinationKeyTimeCnt
* 清零了,这个过程非常巧妙，非常有效地去除瞬间的杂波干扰。
* 第三步：如果两个按键按下的时间超过了阀值KEY_FILTER_TIME，马上把自锁标志Su8CombinationKeyLock
* 置1，防止按住两个按键不松手后一直触发。并把按键编号vGu8CombinationKeySec赋值，
* 触发一次组合按键。
* 第四步：等其中一个按键松开后，自锁标志Su8CombinationKeyLock及时清零，为下一次自锁做准备。
*/
void KeyScan(void) //此函数放在定时中断里每1ms扫描一次
{
static unsigned char Su8KeyLock1;
static unsigned int Su16KeyCnt1;
static unsigned char Su8KeyLock2;
static unsigned int Su16KeyCnt2;
static unsigned char Su8CombinationKeyLock; //组合按键的自锁
static unsigned int Su16CombinationKeyCnt; //组合按键的计时器
//K1按键与K2按键的组合触发
if(0!=KEY_INPUT1||0!=KEY_INPUT2)//两个按键只要有一个按键没有按下，处于“非组合按键”的状态。
{
Su8CombinationKeyLock=0; //组合按键解锁
Su16CombinationKeyCnt=0; //组合按键去抖动延时计数器清零，此行非常巧妙，是全场的亮点。
}
else if(0==Su8CombinationKeyLock)//两个按键被同时按下，且是第一次被按下。此行请看专题分析。
{
Su16CombinationKeyCnt++; //累加定时中断次数
if(Su16CombinationKeyCnt>=KEY_FILTER_TIME) //滤波的“稳定时间”KEY_FILTER_TIME。
{
Su8CombinationKeyLock=1; //组合按键的自锁,避免一直触发
vGu8CombinationKeySec=1; //触发K1与K2的组合键操作
}
}
//K1按键的单击
if(0!=KEY_INPUT1)
{
Su8KeyLock1=0;
Su16KeyCnt1=0;
}
else if(0==Su8KeyLock1)
{
Su16KeyCnt1++;
if(Su16KeyCnt1>=KEY_FILTER_TIME)
{
Su8KeyLock1=1;
vGu8SingleKeySec=1; //触发K1的单击键
}
}
//K2按键的单击
if(0!=KEY_INPUT2)
{
Su8KeyLock2=0;
Su16KeyCnt2=0;
}
else if(0==Su8KeyLock2)
{
Su16KeyCnt2++;
if(Su16KeyCnt2>=KEY_FILTER_TIME)
{
Su8KeyLock2=1;
vGu8SingleKeySec=2; //触发K2的单击键
}
}
}
void CombinationKeyTask(void) //组合按键任务函数，放在主函数内
{
if(0==vGu8CombinationKeySec)
{
return; //按键的触发序号是0意味着无按键触发，直接退出当前函数，不执行此函数下面的代码
}
switch(vGu8CombinationKeySec) //根据不同的按键触发序号执行对应的代码
{
case 1: //K1与K2的组合按键任务
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //触发一次组合按键后，发出“嘀”一声
vGu8BeepTimerFlag=1;
vGu8CombinationKeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一致触发
break;
}
}
void SingleKeyTask(void) //单击按键任务函数，放在主函数内
{
if(0==vGu8SingleKeySec)
{
return; //按键的触发序号是0意味着无按键触发，直接退出当前函数，不执行此函数下面的代码
}
switch(vGu8SingleKeySec) //根据不同的按键触发序号执行对应的代码
{
case 1: //K1单击任务
LedOpen(); //LED亮
vGu8SingleKeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一致触发
break;
case 2: //K2单击任务
LedClose(); //LED灭
vGu8SingleKeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一致触发
break;
}
}

复制代码

【94.2 专题分析：else if(0==Su8CombinationKeyLock)。】

疑问：

if(0!=KEY_INPUT1||0!=KEY_INPUT2)
{
Su8CombinationKeyLock=0;
Su16CombinationKeyCnt=0;
}
else if(0==Su8CombinationKeyLock)//两个按键被同时按下，且是第一次被按下。为什么？
{
Su16CombinationKeyCnt++;
if(Su16CombinationKeyCnt>=KEY_FILTER_TIME)
{
Su8CombinationKeyLock=1;
vGu8CombinationKeySec=1;
}
}

复制代码

解答：
首先，我们要明白C语言的语法中，

if(条件1)
{
}
else if(条件2)
{
}

复制代码

以上语句是一对组合语句，不能分开来看。当（条件1）成立的时候，它是绝对不会判断（条件2）的。当（条件1）不成立的时候，才会判断（条件2）。
回到刚才的问题，当程序执行到（条件2） else if(0==Su8CombinationKeyLock)的时候，就已经默认了（条件1） if(0!=KEY_INPUT1||0!=KEY_INPUT2)不成立，这个条件不成立，就意味着0==KEY_INPUT1和0==KEY_INPUT2，也就是有两个按键被同时按下，因此，这里的else if(0==Su8CombinationKeyLock)等效于else if(0==Su8CombinationKeyLock&&0==KEY_INPUT1&&0==KEY_INPUT2)，而Su8CombinationKeyLock是一个自锁标志位，一旦组合按键被触发后，这个标志位会变1，防止两个按键按住不松手的时候不断触发组合按键。这样，组合按键只能同时按下一次触发一次，任意松开其中一个按键后再同时按下一次两个按键，又触发一次新的组合按键。

搜索历史

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

相关推荐

678 条评论

评论

精选推荐

热门帖

站长推荐 /6