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

单片机

单枪舞九州 · 2018-2-10 08:37:56

谢谢分享支持楼主

单枪舞九州 · 2018-2-10 08:38:32

谢谢分享支持楼主

单枪舞九州 · 2018-2-10 08:39:44

谢谢分享支持楼主

单枪舞九州 · 2018-2-10 08:40:44

谢谢分享支持楼主

单枪舞九州 · 2018-2-10 08:41:33

谢谢分享支持楼主

单枪舞九州 · 2018-2-10 08:42:03

谢谢分享支持楼主

单枪舞九州 · 2018-2-10 08:42:25

谢谢分享支持楼主

单枪舞九州 · 2018-2-10 08:42:56

谢谢分享支持楼主

单枪舞九州 · 2018-2-10 08:43:37

谢谢分享支持楼主

单枪舞九州 · 2018-2-10 08:43:57

谢谢分享支持楼主

单枪舞九州 · 2018-2-10 08:44:41

谢谢分享支持楼主

吴坚鸿 · 2018-2-11 11:04:57

第一百零七节：开关感应器的识别与软件滤波。

【107.1 开关感应器的识别与软件滤波。】


            上图107.1.1  独立按键模拟开关感应器


            上图107.1.2  LED电路

   什么叫开关感应器？凡是只能输出0和1这两种状态的感应器都可以统称为开关感应器。前面花了大量的章节讲按键，按键的识别主要是识别电平变化状态的“下降沿”，程序代码中有1个特别的变量标志叫“自锁标志”，还有1个用来消除抖动的“计时器”。本节讲的开关感应器跟按键很相似，差别在于，开关感应器是识别电平变化状态的“电平”，程序代码中没有“自锁标志”，但是多增加了1个用来消除抖动的“计时器”，也就是一共有两个用来消除抖动的“计时器”，这两个“计时器”相互“清零”相互“抗衡”，从而实现了开关感应器的“消抖”处理，专业术语也叫“软件滤波”。消抖的时间跟按键差不多，我的经验值是20ms到30ms之间，我平时在项目中喜欢用20ms。
   在显示框架方面，除了之前讲过Gu8DisplayUpdate这类“显示刷新变量”，本节介绍另外一种常用的显示框架，原理是“某数值跟上一次对比，如果发生了变化（两数值不一样），则自动刷新显示,并及时记录当前值”。
   本节例程实现的功能如下：用K1独立按键模拟开关感应器，K1独立按键“没有被按下”时是高电平，单片机识别到这种“高电平”，就让P1.4所在的LED灯发亮；K1独立按键“被按下”时是低电平，单片机识别到这种“低电平”，就让P1.4所在的LED灯熄灭。

#include "REG52.H"
#define SENSOR_TIME 20 //开关感应器的“滤波”时间
void T0_time();
void SystemInitial(void) ;
void Delay(unsigned long u32DelayTime) ;
void PeripheralInitial(void) ;
void VoiceScan(void);
void SensorScan(void);
void DisplayTask(void); //显示的任务函数（LED显示状态）
***it P1_4=P1^4;
***it Sensor_K1_sr=P2^2; //开关感应器K1所在的引脚
volatile unsigned char vGu8Sensor_K1=0; //K1开关感应器的当前电平状态。
void main()
{
SystemInitial();
Delay(10000);
PeripheralInitial();
while(1)
{
DisplayTask(); //显示的任务函数（LED显示状态）
}
}
/* 注释一：
* 后缀为_Last这类“对比上一次数值发生变化而自动刷新显示”在“显示框架”里是很常见的，
* 目的是，既能及时刷新显示，又能避免主函数“不断去执行显示代码”而影响程序效率。
*/
void DisplayTask(void) //显示的任务函数（LED显示状态）
{
// Su8Sensor_K1_Last初始化取值255，只要不为0或者1就行，目的是让上电就发生第一次刷新。
static unsigned char Su8Sensor_K1_Last=255; //记录K1开关感应器上一次的电平状态。
if(Su8Sensor_K1_Last!=vGu8Sensor_K1) //如果当前值与上一次值不一样，就自动刷新
{
Su8Sensor_K1_Last=vGu8Sensor_K1; //及时记录最新值，避免主函数“不断去执行显示代码”
if(0==vGu8Sensor_K1) //如果当前电平状态为“低电平”，LED熄灭
{
P1_4=1; //LED熄灭
}
else //如果当前电平状态为“高电平”，LED发亮
{
P1_4=0; //LED发亮
}
}
}
/* 注释二：
* 本节破题的关键：
* 两个“计时器”相互“清零”相互“抗衡”，从而实现了开关感应器的“消抖”处理，
* 专业术语也叫“软件滤波”。这种滤波方式，不管是从“高转成低”，还是“低转成高”，
* 如果在某个瞬间出现干扰抖动，某个计数器都会及时被“清零”，从而起到非常高效的消抖滤波作用。
*/
void SensorScan(void) //此函数放在定时中断里每1ms扫描一次，用来识别和滤波开关感应器
{
static unsigned int Su16Sensor_K1_H_Cnt=0; //判断高电平的计时器
static unsigned int Su16Sensor_K1_L_Cnt=0; //判断低电平的计时器
if(0==Sensor_K1_sr)
{
Su16Sensor_K1_H_Cnt=0; //在判断低电平的时候，高电平的计时器被清零，巧妙极了!
Su16Sensor_K1_L_Cnt++;
if(Su16Sensor_K1_L_Cnt>=SENSOR_TIME)
{
Su16Sensor_K1_L_Cnt=0;
vGu8Sensor_K1=0; //此全局变量反馈当前电平的状态
}
}
else
{
Su16Sensor_K1_L_Cnt=0; //在判断高电平的时候，低电平的计时器被清零，巧妙极了!
Su16Sensor_K1_H_Cnt++;
if(Su16Sensor_K1_H_Cnt>=SENSOR_TIME)
{
Su16Sensor_K1_H_Cnt=0;
vGu8Sensor_K1=1; //此全局变量反馈当前电平的状态
}
}
}
void T0_time() interrupt 1
{
SensorScan(); //开关感应器的识别与软件滤波处理
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)
{
}

复制代码

单枪舞九州 · 2018-2-11 11:47:36

鸿哥更新了，第一时间来看

单枪舞九州 · 2018-2-11 11:47:55

继续支持鸿哥加油

kkfy888 · 2018-2-11 16:26:40

快过年了还在忙更新,支持鸿哥!

kkfy888 · 2018-2-11 16:42:52

谢谢鸿哥,为了方便学习,年后打几块样板回来验证下

陆伟 · 2018-2-20 11:27:04

谢谢分享，支持一下

吴坚鸿 · 2018-2-23 14:35:48

第一百零八节：按键控制跑马灯的启动和暂停和停止。

【108.1 按键控制跑马灯的启动和暂停和停止。】

            上图108.1.1  独立按键


            上图108.1.2  LED电路


            上图108.1.3  有源蜂鸣器的电路

   在我眼里，按键不仅仅是按键，跑马灯不仅仅是跑马灯。按键是输入设备，跑马灯是应用程序。本节表面上讲按键控制跑马灯的简单项目，实际上作者用心良苦立意深远，试图通过按键与跑马灯，来分享一种输入设备如何关联应用程序的程序框架。
   本节例程实现的功能如下：
   （1）【启动暂停】按键K1。按下【启动暂停】按键K1启动之后，跑马灯处于“启动”状态，4个LED灯从左到右依次循环的变亮，给人“跑”起来的感觉。此时如果再按一次【启动暂停】按键K1，则跑马灯处于“暂停”状态，如果再按一次【启动暂停】按键K1，跑马灯又变回“启动”状态。因此，【启动暂停】按键K1是专门用来切换“启动”和“暂停”这两种状态。
   （2）【停止】按键K2。当跑马灯处于“启动”或者“暂停”或者“停止”的状态时，只要按下【停止】按键K2，当前的运动状态就终止，强制变回初始的“停止”状态，类似“复位”按键的作用。当跑马灯处于“停止”状态时，此时再按下【启动暂停】按键K1之后，跑马灯又处于“启动”状态。

#include "REG52.H"
#define KEY_VOICE_TIME 50
#define KEY_FILTER_TIME 25
#define RUN_TIME 200 //跑马灯的跑动速度的时间参数
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 RunTask(void); //跑马灯的任务函数
//4个跑马灯的输出口
***it P1_4=P1^4;
***it P1_5=P1^5;
***it P1_6=P1^6;
***it P3_3=P3^3;
//蜂鸣器的输出口
***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;
unsigned char Gu8RunStart=0; //控制跑马灯启动的总开关
unsigned char Gu8RunStatus=0; //标识跑马灯当前的状态。0代表停止，1代表启动，2代表暂停。
volatile unsigned char vGu8RunTimerFlag=0; //用于控制跑马灯跑动速度的定时器
volatile unsigned int vGu16RunTimerCnt=0;
void main()
{
SystemInitial();
Delay(10000);
PeripheralInitial();
while(1)
{
KeyTask(); //按键的任务函数
RunTask(); //跑马灯的任务函数
}
}
void T0_time() interrupt 1
{
VoiceScan();
KeyScan();
if(1==vGu8RunTimerFlag&&vGu16RunTimerCnt>0) //用于控制跑马灯跑动速度的定时器
{
vGu16RunTimerCnt--;
}
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)
{
//跑马灯处于初始化的状态
P1_4=0; //第1个灯亮
P1_5=1; //第2个灯灭
P1_6=1; //第3个灯灭
P3_3=1; //第4个灯灭
}
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();
}
}
}
}
void KeyScan(void) //此函数放在定时中断里每1ms扫描一次
{
static unsigned char Su8KeyLock1;
static unsigned int Su16KeyCnt1;
static unsigned char Su8KeyLock2;
static unsigned int Su16KeyCnt2;
//【启动暂停】按键K1的扫描识别
if(0!=KEY_INPUT1)
{
Su8KeyLock1=0;
Su16KeyCnt1=0;
}
else if(0==Su8KeyLock1)
{
Su16KeyCnt1++;
if(Su16KeyCnt1>=KEY_FILTER_TIME)
{
Su8KeyLock1=1;
vGu8KeySec=1; //触发1号键
}
}
//【停止】按键K2的扫描识别
if(0!=KEY_INPUT2)
{
Su8KeyLock2=0;
Su16KeyCnt2=0;
}
else if(0==Su8KeyLock2)
{
Su16KeyCnt2++;
if(Su16KeyCnt2>=KEY_FILTER_TIME)
{
Su8KeyLock2=1;
vGu8KeySec=2; //触发2号键
}
}
}
/* 注释一：
* 本节破题的关键：
* 在KeyTask和RunTask两个任务函数之间，主要是靠Gu8RunStart和Gu8RunStatus这两个
* 全局变量来传递信息。
*/
void KeyTask(void) //按键的任务函数，放在主函数内
{
if(0==vGu8KeySec)
{
return; //按键的触发序号是0意味着无按键触发，直接退出当前函数，不执行此函数下面的代码
}
switch(vGu8KeySec) //根据不同的按键触发序号执行对应的代码
{
case 1: //1号按键。【启动暂停】按键K1
if(0==Gu8RunStatus) //当跑马灯处于“停止”状态时
{
Gu8RunStart=1; //总开关“打开”。
Gu8RunStatus=1; //状态切换到“启动”状态
}
else if(1==Gu8RunStatus) //当跑马灯处于“启动”状态时
{
Gu8RunStatus=2; //状态切换到“暂停”状态
}
else //当跑马灯处于“暂停”状态时
{
Gu8RunStatus=1; //状态切换到“启动”状态
}
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //触发按键后，发出固定长度的声音
vGu8BeepTimerFlag=1;
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一直触发
break;
case 2: //2号按键。【停止】按键K2
Gu8RunStart=0; //总开关“关闭”。
Gu8RunStatus=0; //状态切换到“停止”状态
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //触发按键后，发出固定长度的声音
vGu8BeepTimerFlag=1;
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一直触发
break;
}
}
void RunTask(void) //跑马灯的任务函数，放在主函数内
{
static unsigned char Su8RunStep=0; //运行的步骤
//当总开关处于“停止”并且“步骤不为0”时，强制把步骤归零,跑马灯初始化。
if(0!=Su8RunStep&&0==Gu8RunStart)
{
Su8RunStep=0; //步骤归零
//跑马灯处于初始化的状态
P1_4=0; //第1个灯亮
P1_5=1; //第2个灯灭
P1_6=1; //第3个灯灭
P3_3=1; //第4个灯灭
}
switch(Su8RunStep) //屡见屡爱的switch又来了
{
case 0:
if(1==Gu8RunStart) //总开关“打开”
{
vGu8RunTimerFlag=0;
vGu16RunTimerCnt=0; //定时器清零
Su8RunStep=1; //切换到下一步，启动
}
break;
case 1:
if(1==Gu8RunStatus&&0==vGu16RunTimerCnt) //当前处于“启动”状态，并且定时器等于0
{
P1_4=0; //第1个灯亮
P1_5=1; //第2个灯灭
P1_6=1; //第3个灯灭
P3_3=1; //第4个灯灭
vGu8RunTimerFlag=0;
vGu16RunTimerCnt=RUN_TIME; //用于控制跑马灯跑动速度的定时器
vGu8RunTimerFlag=1; //启动定时器
Su8RunStep=2; //切换到下一步
}
break;
case 2:
if(1==Gu8RunStatus&&0==vGu16RunTimerCnt) //当前处于“启动”状态，并且定时器等于0
{
P1_4=1; //第1个灯灭
P1_5=0; //第2个灯亮
P1_6=1; //第3个灯灭
P3_3=1; //第4个灯灭
vGu8RunTimerFlag=0;
vGu16RunTimerCnt=RUN_TIME; //用于控制跑马灯跑动速度的定时器
vGu8RunTimerFlag=1; //启动定时器
Su8RunStep=3; //切换到下一步
}
break;
case 3:
if(1==Gu8RunStatus&&0==vGu16RunTimerCnt) //当前处于“启动”状态，并且定时器等于0
{
P1_4=1; //第1个灯灭
P1_5=1; //第2个灯灭
P1_6=0; //第3个灯亮
P3_3=1; //第4个灯灭
vGu8RunTimerFlag=0;
vGu16RunTimerCnt=RUN_TIME; //用于控制跑马灯跑动速度的定时器
vGu8RunTimerFlag=1; //启动定时器
Su8RunStep=4; //切换到下一步
}
break;
case 4:
if(1==Gu8RunStatus&&0==vGu16RunTimerCnt) //当前处于“启动”状态，并且定时器等于0
{
P1_4=1; //第1个灯灭
P1_5=1; //第2个灯灭
P1_6=1; //第3个灯灭
P3_3=0; //第4个灯亮
vGu8RunTimerFlag=0;
vGu16RunTimerCnt=RUN_TIME; //用于控制跑马灯跑动速度的定时器
vGu8RunTimerFlag=1; //启动定时器
Su8RunStep=1; //返回到第1步，重新开始下一轮的循环!!!
}
break;
}
}

复制代码

吴坚鸿 · 2018-3-1 09:20:35

第一百零九节：按键控制跑马灯的方向。

【109.1 按键控制跑马灯的方向。】

            上图109.1.1  独立按键


            上图109.1.2  LED电路


            上图109.1.3  有源蜂鸣器的电路

   之前108节讲到跑马灯的启动、暂停、停止，本节在此基础上，增加一个“方向”的控制，除了加深理解输入设备如何关联应用程序的程序框架之外，还有一个知识点值得一提，就是如何通过灵活切换switch的“步骤变量”来达到随心所欲的过程控制，本节的“方向”的控制就用到这个方法。
   本节例程的功能如下：
   （1）【启动暂停】按键K1。按下【启动暂停】按键K1启动之后，跑马灯处于“启动”状态，4个LED灯挨个依次循环的变亮，给人“跑”起来的感觉。此时如果再按一次【启动暂停】按键K1，则跑马灯处于“暂停”状态，如果再按一次【启动暂停】按键K1，跑马灯又变回“启动”状态。因此，【启动暂停】按键K1是专门用来切换“启动”和“暂停”这两种状态。
   （2）【停止】按键K2。当跑马灯处于“启动”或者“暂停”或者“停止”的状态时，只要按下【停止】按键K2，当前的运动状态就终止，强制变回初始的“停止”状态，类似“复位”按键的作用。当跑马灯处于“停止”状态时，此时再按下【启动暂停】按键K1之后，跑马灯又处于“启动”状态。
   （3）【方向】按键K3。跑马灯上电后默认处于“往右跑”的方向。每按一次【方向】按键K3，跑马灯就在“往右跑”与“往左跑”两个方向之间切换。

#include "REG52.H"
#define KEY_VOICE_TIME 50
#define KEY_FILTER_TIME 25
#define RUN_TIME 200 //跑马灯的跑动速度的时间参数
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 RunTask(void); //跑马灯的任务函数
//4个跑马灯的输出口
***it P1_4=P1^4;
***it P1_5=P1^5;
***it P1_6=P1^6;
***it P3_3=P3^3;
//蜂鸣器的输出口
***it P3_4=P3^4;
***it KEY_INPUT1=P2^2; //【启动暂停】按键K1的输入口。
***it KEY_INPUT2=P2^1; //【停止】按键K2的输入口。
***it KEY_INPUT3=P2^0; //【方向】按键K3的输入口。
volatile unsigned char vGu8BeepTimerFlag=0;
volatile unsigned int vGu16BeepTimerCnt=0;
volatile unsigned char vGu8KeySec=0;
unsigned char Gu8RunStart=0; //控制跑马灯启动的总开关
unsigned char Gu8RunStatus=0; //标识跑马灯当前的状态。0代表停止，1代表启动，2代表暂停。
unsigned char Gu8RunDirection=0; //标识跑马灯当前的方向。0代表往右跑，1代表往左跑。
volatile unsigned char vGu8RunTimerFlag=0; //用于控制跑马灯跑动速度的定时器
volatile unsigned int vGu16RunTimerCnt=0;
void main()
{
SystemInitial();
Delay(10000);
PeripheralInitial();
while(1)
{
KeyTask(); //按键的任务函数
RunTask(); //跑马灯的任务函数
}
}
void T0_time() interrupt 1
{
VoiceScan();
KeyScan();
if(1==vGu8RunTimerFlag&&vGu16RunTimerCnt>0) //用于控制跑马灯跑动速度的定时器
{
vGu16RunTimerCnt--;
}
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)
{
//跑马灯处于初始化的状态
P1_4=0; //第1个灯亮
P1_5=1; //第2个灯灭
P1_6=1; //第3个灯灭
P3_3=1; //第4个灯灭
}
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();
}
}
}
}
void KeyScan(void) //此函数放在定时中断里每1ms扫描一次
{
static unsigned char Su8KeyLock1;
static unsigned int Su16KeyCnt1;
static unsigned char Su8KeyLock2;
static unsigned int Su16KeyCnt2;
static unsigned char Su8KeyLock3;
static unsigned int Su16KeyCnt3;
//【启动暂停】按键K1的扫描识别
if(0!=KEY_INPUT1)
{
Su8KeyLock1=0;
Su16KeyCnt1=0;
}
else if(0==Su8KeyLock1)
{
Su16KeyCnt1++;
if(Su16KeyCnt1>=KEY_FILTER_TIME)
{
Su8KeyLock1=1;
vGu8KeySec=1; //触发1号键
}
}
//【停止】按键K2的扫描识别
if(0!=KEY_INPUT2)
{
Su8KeyLock2=0;
Su16KeyCnt2=0;
}
else if(0==Su8KeyLock2)
{
Su16KeyCnt2++;
if(Su16KeyCnt2>=KEY_FILTER_TIME)
{
Su8KeyLock2=1;
vGu8KeySec=2; //触发2号键
}
}
//【方向】按键K3的扫描识别
if(0!=KEY_INPUT3)
{
Su8KeyLock3=0;
Su16KeyCnt3=0;
}
else if(0==Su8KeyLock3)
{
Su16KeyCnt3++;
if(Su16KeyCnt3>=KEY_FILTER_TIME)
{
Su8KeyLock3=1;
vGu8KeySec=3; //触发3号键
}
}
}
/* 注释一：
* 本节破题的关键：
* 在KeyTask和RunTask两个任务函数之间，主要是靠Gu8RunStart、Gu8RunStatus、Gu8RunDirection
* 这三个全局变量来传递信息。
*/
void KeyTask(void) //按键的任务函数，放在主函数内
{
if(0==vGu8KeySec)
{
return; //按键的触发序号是0意味着无按键触发，直接退出当前函数，不执行此函数下面的代码
}
switch(vGu8KeySec) //根据不同的按键触发序号执行对应的代码
{
case 1: //1号按键。【启动暂停】按键K1
if(0==Gu8RunStatus) //当跑马灯处于“停止”状态时
{
Gu8RunStart=1; //总开关“打开”。
Gu8RunStatus=1; //状态切换到“启动”状态
}
else if(1==Gu8RunStatus) //当跑马灯处于“启动”状态时
{
Gu8RunStatus=2; //状态切换到“暂停”状态
}
else //当跑马灯处于“暂停”状态时
{
Gu8RunStatus=1; //状态切换到“启动”状态
}
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //触发按键后，发出固定长度的声音
vGu8BeepTimerFlag=1;
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一直触发
break;
case 2: //2号按键。【停止】按键K2
Gu8RunStart=0; //总开关“关闭”。
Gu8RunStatus=0; //状态切换到“停止”状态
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //触发按键后，发出固定长度的声音
vGu8BeepTimerFlag=1;
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一直触发
break;
case 3: //3号按键。【方向】按键K3
//每按一次K3按键，Gu8RunDirection就在0和1之间切换,从而控制方向
if(0==Gu8RunDirection)
{
Gu8RunDirection=1;
}
else
{
Gu8RunDirection=0;
}
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=KEY_VOICE_TIME; //触发按键后，发出固定长度的声音
vGu8BeepTimerFlag=1;
vGu8KeySec=0; //响应按键服务处理程序后，按键编号必须清零，避免一直触发
break;
}
}
/* 注释二：
* “方向”的控制，是通过Gu8RunDirection的判断，来灵活切换switch的“步骤变量”来达到
* 随心所欲的过程控制。
*/
void RunTask(void) //跑马灯的任务函数，放在主函数内
{
static unsigned char Su8RunStep=0; //运行的步骤
//当总开关处于“停止”并且“步骤不为0”时，强制把步骤归零,跑马灯初始化。
if(0!=Su8RunStep&&0==Gu8RunStart)
{
Su8RunStep=0; //步骤归零
//跑马灯处于初始化的状态
P1_4=0; //第1个灯亮
P1_5=1; //第2个灯灭
P1_6=1; //第3个灯灭
P3_3=1; //第4个灯灭
}
switch(Su8RunStep) //屡见屡爱的switch又来了
{
case 0:
if(1==Gu8RunStart) //总开关“打开”
{
vGu8RunTimerFlag=0;
vGu16RunTimerCnt=0; //定时器清零
Su8RunStep=1; //切换到下一步，启动
}
break;
case 1:
if(1==Gu8RunStatus&&0==vGu16RunTimerCnt) //当前处于“启动”状态，并且定时器等于0
{
P1_4=0; //第1个灯亮
P1_5=1; //第2个灯灭
P1_6=1; //第3个灯灭
P3_3=1; //第4个灯灭
vGu8RunTimerFlag=0;
vGu16RunTimerCnt=RUN_TIME; //用于控制跑马灯跑动速度的定时器
vGu8RunTimerFlag=1; //启动定时器
//灵活切换“步骤变量”
if(0==Gu8RunDirection) //往右跑
{
Su8RunStep=2;
}
else //往左跑
{
Su8RunStep=4;
}
}
break;
case 2:
if(1==Gu8RunStatus&&0==vGu16RunTimerCnt) //当前处于“启动”状态，并且定时器等于0
{
P1_4=1; //第1个灯灭
P1_5=0; //第2个灯亮
P1_6=1; //第3个灯灭
P3_3=1; //第4个灯灭
vGu8RunTimerFlag=0;
vGu16RunTimerCnt=RUN_TIME; //用于控制跑马灯跑动速度的定时器
vGu8RunTimerFlag=1; //启动定时器
//灵活切换“步骤变量”
if(0==Gu8RunDirection) //往右跑
{
Su8RunStep=3;
}
else //往左跑
{
Su8RunStep=1;
}
}
break;
case 3:
if(1==Gu8RunStatus&&0==vGu16RunTimerCnt) //当前处于“启动”状态，并且定时器等于0
{
P1_4=1; //第1个灯灭
P1_5=1; //第2个灯灭
P1_6=0; //第3个灯亮
P3_3=1; //第4个灯灭
vGu8RunTimerFlag=0;
vGu16RunTimerCnt=RUN_TIME; //用于控制跑马灯跑动速度的定时器
vGu8RunTimerFlag=1; //启动定时器
//灵活切换“步骤变量”
if(0==Gu8RunDirection) //往右跑
{
Su8RunStep=4;
}
else //往左跑
{
Su8RunStep=2;
}
}
break;
case 4:
if(1==Gu8RunStatus&&0==vGu16RunTimerCnt) //当前处于“启动”状态，并且定时器等于0
{
P1_4=1; //第1个灯灭
P1_5=1; //第2个灯灭
P1_6=1; //第3个灯灭
P3_3=0; //第4个灯亮
vGu8RunTimerFlag=0;
vGu16RunTimerCnt=RUN_TIME; //用于控制跑马灯跑动速度的定时器
vGu8RunTimerFlag=1; //启动定时器
//灵活切换“步骤变量”
if(0==Gu8RunDirection) //往右跑
{
Su8RunStep=1;
}
else //往左跑
{
Su8RunStep=3;
}
}
break;
}
}

复制代码

吴坚鸿 · 2018-3-4 10:17:44

第一百一十节：按键控制跑马灯的速度。

【110.1 按键控制跑马灯的速度。】


            上图110.1.1  独立按键


            上图110.1.2  LED电路


            上图110.1.3  有源蜂鸣器的电路

   之前109节讲到跑马灯的启动、暂停、停止、方向，本节在此基础上，把原来的“停止”更改为“速度”，
加深理解输入设备如何关联应用程序的程序框架。
   本节例程的功能如下：
   （1）【启动暂停】按键K1。上电后，按下【启动暂停】按键K1启动之后，跑马灯处于“启动”状态，4个LED灯挨个依次循环的变亮，给人“跑”起来的感觉。此时如果再按一次【启动暂停】按键K1，则跑马灯处于“暂停”状态，如果再按一次【启动暂停】按键K1，跑马灯又变回“启动”状态。因此，【启动暂停】按键K1是专门用来切换“启动”和“暂停”这两种状态。
   （2）【速度】按键K2。每按一次【速度】按键K2，跑马灯就在“慢”、“中”、“快”三档速度之间切换。
   （3）【方向】按键K3。跑马灯上电后默认处于“往右跑”的方向。每按一次【方向】按键K3，跑马灯就在“往右跑”与“往左跑”两个方向之间切换。