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

单片机

1653343207.965700 · 2018-6-21 10:35:39

谢谢辛勤付出，支持

吴坚鸿 · 2018-6-21 14:39:28

第一百二十一节：可调参数的数码管倒计时。

【121.1 可调参数的数码管倒计时。】

            上图121.1.1  数码管


            上图121.1.2  独立按键


            上图121.1.3  有源蜂鸣器

   上节讲如何设置数据，本节讲“数据”如何关联“某种功能”，本节的“可调参数”就是“数据”，“倒计时”就是“某种功能”。程序功能如下：
   （1）倒计时范围从0.00秒到99.99秒，范围可调。开机默认是:10.00秒。
   （2）K1［设置键］。当数码管“没有闪烁”时，“长按”K1键则进入“闪烁模式”，某位数码管开始闪烁，闪烁的位代表可修改的位数据，此时再“短按”K1按键可以使数码管在位之间切换闪烁。当数码管处于“闪烁模式”时，“长按”K1按键，代表数据修改完成并停止闪烁。
   （3）K2［加键］与［复位健］。当数码管某位正在闪烁时，此时K2是［加键］，按K2会使位数据“自加1”。当数码管“没有闪烁”时，此时K2是［复位键］，按K2会使当前倒计时数据恢复“设置值”。
   （4）K3［减键］与［开始健］。当数码管某位正在闪烁时，此时K3是［减键］，按K3会使位数据“自减1”。当数码管“没有闪烁”时，此时K3是［开始键］，按K3开始倒计时。
   代码如下：

#include "REG52.H"
#define KEY_FILTER_TIME 25 //按键的“短按”兼“滤波”的“稳定时间”
#define KEY_LONG_TIME 500 //按键的“长按”兼“滤波”的“稳定时间”
#define SCAN_TIME 1
#define VOICE_TIME 50
#define BLINK_TIME 250 //数码管闪烁跳动的时间的间隔
void T0_time();
void SystemInitial(void) ;
void Delay(unsigned long u32DelayTime) ;
void PeripheralInitial(void) ;
void KeyScan(void);
void KeyTask(void);
void VoiceScan(void);
void DisplayScan(void);
void DisplayTask(void); //上层显示的任务函数
void RunTask(void); //倒计时的应用程序
void Wd1(void); //窗口1显示函数。用来设置参数。
void Wd2(void); //窗口2显示函数。倒计时的运行显示窗口
void PartUpdate(unsigned char u8Part); //局部选择对应的某个局部变量更新显示输出
void BeepOpen(void);
void BeepClose(void);
***it KEY_INPUT1=P2^2;
***it KEY_INPUT2=P2^1;
***it KEY_INPUT3=P2^0;
***it P1_0=P1^0;
***it P1_1=P1^1;
***it P1_2=P1^2;
***it P1_3=P1^3;
***it P3_4=P3^4;
//数码管转换表
code unsigned char Cu8DigTable[]=
{
0x3f, //0 序号0
0x06, //1 序号1
0x5b, //2 序号2
0x4f, //3 序号3
0x66, //4 序号4
0x6d, //5 序号5
0x7d, //6 序号6
0x07, //7 序号7
0x7f, //8 序号8
0x6f, //9 序号9
0x00, //不显示序号10
0x40, //横杠- 序号11
};
volatile unsigned char vGu8ScanTimerFlag=0;
volatile unsigned int vGu16ScanTimerCnt=0;
volatile unsigned char vGu8BeepTimerFlag=0;
volatile unsigned int vGu16BeepTimerCnt=0;
volatile unsigned char vGu8BlinkTimerFlag=0; //数码管闪烁跳动的定时器
volatile unsigned int vGu16BlinkTimerCnt=0;
//倒计时的软件定时器，注意，这里是unsigned long类型，范围是0到4294967295毫秒
volatile unsigned char vGu8CountdownTimerFlag=0;
volatile unsigned long vGu32CountdownTimerCnt=10000; //当前倒计时的计时值
unsigned long Gu32SetData_Countdown=10000; //倒计时的设置值
//数码管上层每10ms就定时刷新一次显示的软件定时器。用于及时更新显示秒表当前的实时数值
volatile unsigned char vGu8UpdateTimerFlag=0;
volatile unsigned int vGu16UpdateTimerCnt=0;
unsigned char Gu8RunStart=0; //应用程序的总启动
unsigned char Gu8RunStep=0; //应用程序的总运行步骤。建议跟vGu8RunStart成双成对出现
unsigned char Gu8RunStatus=0; //当前倒计时的状态。0代表停止，1代表正在工作中
unsigned char Gu8EditData_4=0; //对应显示右起第4位数码管的“位”数据，是中间变量。
unsigned char Gu8EditData_3=0; //对应显示右起第3位数码管的“位”数据，是中间变量。
unsigned char Gu8EditData_2=0; //对应显示右起第2位数码管的“位”数据，是中间变量。
unsigned char Gu8EditData_1=0; //对应显示右起第1位数码管的“位”数据，是中间变量。
unsigned char Gu8Wd=1; //窗口选择变量。人机交互程序框架的支点。初始化开机后显示第1个窗口。
unsigned char Gu8WdUpdate=1; //整屏更新变量。初始化为1开机后整屏更新一次显示。
unsigned char Gu8Part=0; //局部选择变量。0代表当前窗口下没有数据被选中。
unsigned char Gu8PartUpdate_1=0; //局部1的更新变量,
unsigned char Gu8PartUpdate_2=0; //局部2的更新变量
unsigned char Gu8PartUpdate_3=0; //局部3的更新变量,
unsigned char Gu8PartUpdate_4=0; //局部4的更新变量
volatile unsigned char vGu8Display_Righ_4=1; //显示“1”，跟vGu32CountdownTimerCnt高位一致
volatile unsigned char vGu8Display_Righ_3=0;
volatile unsigned char vGu8Display_Righ_2=0;
volatile unsigned char vGu8Display_Righ_1=0;
volatile unsigned char vGu8Display_Righ_Dot_4=0;
volatile unsigned char vGu8Display_Righ_Dot_3=1; //开机默认保留显示2个小数点
volatile unsigned char vGu8Display_Righ_Dot_2=0;
volatile unsigned char vGu8Display_Righ_Dot_1=0;
volatile unsigned char vGu8KeySec=0;
void main()
{
SystemInitial();
Delay(10000);
PeripheralInitial();
while(1)
{
KeyTask(); //按键的任务函数
DisplayTask(); //数码管显示的上层任务函数
RunTask(); //倒计时的应用程序
}
}
void PartUpdate(unsigned char u8Part) //局部选择对应的某个局部变量更新显示输出
{
switch(u8Part)
{
case 1:
Gu8PartUpdate_1=1;
break;
case 2:
Gu8PartUpdate_2=1;
break;
case 3:
Gu8PartUpdate_3=1;
break;
case 4:
Gu8PartUpdate_4=1;
break;
}
}
void RunTask(void) //倒计时的应用程序
{
if(0==Gu8RunStart)
{
return; // 如果总开关处于停止状态，则直接退出当前函数，不执行该函数以下的其它代码
}
switch(Gu8RunStep)
{
case 0: //在这个步骤里，主要用来初始化一些参数
vGu8UpdateTimerFlag=0;
vGu16UpdateTimerCnt=10; //每10ms更新显示一次当前倒计时的时间
vGu8UpdateTimerFlag=1;
Gu8RunStep=1; //跳转到每10ms更新显示一次的步骤里
break;
case 1: //每10ms更新一次显示，确保实时显示当前倒计时的时间
if(0==vGu16UpdateTimerCnt) //每10ms更新显示一次当前倒计时的时间
{
vGu8UpdateTimerFlag=0;
vGu16UpdateTimerCnt=10; //重置定时器，为下一个10ms更新做准备
vGu8UpdateTimerFlag=1;
Gu8WdUpdate=1; //整屏更新一次显示当前倒计时的时间
if(0==vGu32CountdownTimerCnt) //如果倒计时的时间到，则跳转到结束的步骤
{
Gu8RunStep=2; //跳转到倒计时结束的步骤
}
}
break;
case 2: //倒计时结束的步骤
//Gu8RunStatus=0; //这行代码注释掉，让每次新启动之前都必须按一次K1复位按键才有效
Gu8RunStart=0; //倒计时的运行步骤的停止
Gu8RunStep=0; //总运行步骤归零。建议跟vGu8RunStart成双成对出现
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=VOICE_TIME; //蜂鸣器发出“滴”一声
vGu8BeepTimerFlag=1;
Gu8WdUpdate=1; //整屏更新一次显示当前倒计时的时间
break;
}
}
void KeyTask(void) //按键的任务函数
{
if(0==vGu8KeySec)
{
return;
}
if(0!=Gu8RunStatus) //在“非停止”状态下，用return来拦截一些“不该响应”的按键
{
if(2==vGu8KeySec) //在“非停止”状态下，只响应[复位]这个按键
{
; //这里没有return语句，表示可以继续往下扫描本函数余下的代码，没有被拦截。
}
else
{
return; //其余的按键则拦截退出
}
}
switch(vGu8KeySec)
{
case 1: //按键K1的“短按”。切换数码管闪烁的位。
switch(Gu8Wd) //在某个窗口下
{
case 1: //在窗口1下
if(0!=Gu8Part) //处于“闪烁模式”的时候，是“切换局部”
{
PartUpdate(Gu8Part); //切换之前的局部进行更新。
Gu8Part++; //切换局部
if(Gu8Part>4)
{
Gu8Part=1;
}
PartUpdate(Gu8Part); //切换之后的局部进行更新。
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=VOICE_TIME; //蜂鸣器发出“滴”一声
vGu8BeepTimerFlag=1;
}
break;
}
vGu8KeySec=0;
break;
case 2: //按键K2［加键］与［复位健］
if(0!=Gu8Part) //处于“闪烁模式”的时候，是［加键］
{
switch(Gu8Wd) //在某个窗口下
{
case 1: //在窗口1下
switch(Gu8Part) //二级支点的局部选择
{
case 1: //局部1被选中，代表右起第4位数码管被选中。
if(Gu8EditData_4<9)
{
Gu8EditData_4++; //编辑“千位”个体的中间变量
}
PartUpdate(Gu8Part); //当前局部更新显示输出到数码管
break;
case 2: //局部2被选中，代表右起第3位数码管被选中。
if(Gu8EditData_3<9)
{
Gu8EditData_3++; //编辑“百位”个体的中间变量
}
PartUpdate(Gu8Part); //当前局部更新显示输出到数码管
break;
case 3: //局部3被选中，代表右起第2位数码管被选中。
if(Gu8EditData_2<9)
{
Gu8EditData_2++; //编辑“十位”个体的中间变量
}
PartUpdate(Gu8Part); //当前局部更新显示输出到数码管
break;
case 4: //局部4被选中，代表右起第1位数码管被选中。
if(Gu8EditData_1<9)
{
Gu8EditData_1++; //编辑“个位”个体的中间变量
}
PartUpdate(Gu8Part); //当前局部更新显示输出到数码管
break;
}
break;
}
}
else //处于“没有闪烁”的时候，是［复位健］
{
Gu8EditData_4=Gu32SetData_Countdown/10000%10; //分解成“十秒”个体
Gu8EditData_3=Gu32SetData_Countdown/1000%10; //分解成“个秒”个体
Gu8EditData_2=Gu32SetData_Countdown/100%10; //分解成“百毫秒”个体
Gu8EditData_1=Gu32SetData_Countdown/10%10; //分解成“十毫秒”个体
Gu8RunStatus=0; //倒计时返回停止的状态
Gu8RunStart=0; //倒计时的运行步骤的停止
Gu8RunStep=0; //总运行步骤归零。建议跟vGu8RunStart成双成对出现
Gu8Wd=1; //返回设置数据的窗口
Gu8WdUpdate=1; //整屏更新一次显示
}
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=VOICE_TIME; //蜂鸣器发出“滴”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0;
break;
case 3: //按键K3［减键］与［开始健］
if(0!=Gu8Part) //处于“闪烁模式”的时候，是［减键］
{
switch(Gu8Wd) //在某个窗口下
{
case 1: //在窗口1下
switch(Gu8Part) //二级支点的局部选择
{
case 1: //局部1被选中，代表右起第4位数码管被选中。
if(Gu8EditData_4>0)
{
Gu8EditData_4--; //编辑“十秒”个体的中间变量
}
PartUpdate(Gu8Part); //当前局部更新显示输出到数码管
break;
case 2: //局部2被选中，代表右起第3位数码管被选中。
if(Gu8EditData_3>0)
{
Gu8EditData_3--; //编辑“个秒”个体的中间变量
}
PartUpdate(Gu8Part); //当前局部更新显示输出到数码管
break;
case 3: //局部3被选中，代表右起第2位数码管被选中。
if(Gu8EditData_2>0)
{
Gu8EditData_2--; //编辑“百毫秒”个体的中间变量
}
PartUpdate(Gu8Part); //当前局部更新显示输出到数码管
break;
case 4: //局部4被选中，代表右起第1位数码管被选中。
if(Gu8EditData_1>0)
{
Gu8EditData_1--; //编辑“十毫位”个体的中间变量
}
PartUpdate(Gu8Part); //当前局部更新显示输出到数码管
break;
}
break;
}
}
else //处于“没有闪烁”的时候，是［开始健］
{
if(0==Gu8RunStatus) //在停止状态下
{
vGu8CountdownTimerFlag=0;
vGu32CountdownTimerCnt=Gu32SetData_Countdown; //从“设置值”开始倒计时
vGu8CountdownTimerFlag=1; //允许倒计时的软件定时器的启动
Gu8RunStatus=1; //倒计时处于工作状态（并且，这一瞬间才正式启动倒计时）
Gu8RunStart=1; //倒计时的运行步骤的总开关开启
Gu8RunStep=0; //总运行步骤归零。建议跟vGu8RunStart成双成对出现
Gu8Wd=2; //进入倒计时运行的窗口
Gu8WdUpdate=1; //整屏更新一次显示，确保在启动的时候能显示到最新的数据
}
}
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=VOICE_TIME; //蜂鸣器发出“滴”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0;
break;
case 4: //K1按键的“长按”,具有进入和退出“闪烁模式”的功能。“退出”隐含“确定”
switch(Gu8Wd) //在某个窗口下
{
case 1: //在窗口1下
if(0==Gu8Part) //处于“没有闪烁”的时候，将进入“闪烁模式”
{
Gu8EditData_4=Gu32SetData_Countdown/10000%10; //分解成“十秒”个体
Gu8EditData_3=Gu32SetData_Countdown/1000%10; //分解成“个秒”个体
Gu8EditData_2=Gu32SetData_Countdown/100%10; //分解成“百毫秒”个体
Gu8EditData_1=Gu32SetData_Countdown/10%10; //分解成“十毫秒”个体
Gu8Part=1; //进入“闪烁模式”，从“局部1”开始闪烁
}
else //处于“闪烁模式”的时候，将退出到“没有闪烁”，隐含“确定”功能
{
//把个体合并还原成数据
Gu32SetData_Countdown=Gu8EditData_4*10000+Gu8EditData_3*1000;
Gu32SetData_Countdown=Gu32SetData_Countdown+Gu8EditData_2*100;
Gu32SetData_Countdown=Gu32SetData_Countdown+Gu8EditData_1*10;
Gu8Part=0; //退出“闪烁模式”
Gu8WdUpdate=1; //整屏更新
}
break;
}
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=VOICE_TIME; //蜂鸣器发出“滴”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0;
break;
}
}
void DisplayTask(void) //数码管显示的上层任务函数
{
switch(Gu8Wd) //以窗口选择Gu8Wd为支点，去执行对应的窗口显示函数。又一次用到switch语句
{
case 1:
Wd1(); //窗口1显示函数。用来设置参数。
break;
case 2:
Wd2(); //窗口2显示函数。倒计时的运行显示窗口。
break;
}
}
void Wd1(void) //窗口1显示函数。用来设置参数。
{
//需要借用的中间变量，用来拆分数据位。
static unsigned char Su8Temp_4,Su8Temp_3,Su8Temp_2,Su8Temp_1; //需要借用的中间变量
static unsigned char Su8BlinkFlag=0; //两种状态的切换判断的中间变量
if(1==Gu8WdUpdate) //如果需要整屏更新
{
Gu8WdUpdate=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
//属于静态数据，起“装饰”作用，切换窗口后只扫描一次的代码。
vGu8Display_Righ_Dot_4=0;
vGu8Display_Righ_Dot_3=1; //保留显示2位小数点
vGu8Display_Righ_Dot_2=0;
vGu8Display_Righ_Dot_1=0;
Gu8PartUpdate_1=1; //局部1更新显示
Gu8PartUpdate_2=1 ;//局部2更新显示
Gu8PartUpdate_3=1 ;//局部3更新显示
Gu8PartUpdate_4=1 ;//局部4更新显示
}
if(1==Gu8PartUpdate_1) //局部1更新显示
{
Gu8PartUpdate_1=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
if(Gu32SetData_Countdown<10000)
{
Su8Temp_4=10; //显示“无”
}
else
{
Su8Temp_4=Gu8EditData_4; //显示“十秒”的临时中间个体，属于动态数据。
}
vGu8Display_Righ_4=Su8Temp_4; //过渡需要显示的数据到底层驱动变量
}
if(1==Gu8PartUpdate_2) //局部2更新显示
{
Gu8PartUpdate_2=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
Su8Temp_3=Gu8EditData_3; //显示“个秒”的临时中间个体，属于动态数据。
vGu8Display_Righ_3=Su8Temp_3; //过渡需要显示的数据到底层驱动变量
}
if(1==Gu8PartUpdate_3) //局部3更新显示
{
Gu8PartUpdate_3=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
Su8Temp_2=Gu8EditData_2; //显示“百毫秒”的临时中间个体，属于动态数据。
vGu8Display_Righ_2=Su8Temp_2; //过渡需要显示的数据到底层驱动变量
}
if(1==Gu8PartUpdate_4) //局部4更新显示
{
Gu8PartUpdate_4=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
Su8Temp_1=Gu8EditData_1; //显示“十毫秒”的临时中间个体，属于动态数据。
vGu8Display_Righ_1=Su8Temp_1; //过渡需要显示的数据到底层驱动变量
}
if(0==vGu16BlinkTimerCnt) //某位被选中的数码管跳动闪烁的定时器
{
vGu8BlinkTimerFlag=0;
vGu16BlinkTimerCnt=BLINK_TIME; //重设定时器的定时时间
vGu8BlinkTimerFlag=1;
switch(Gu8Part) //某个局部被选中，则闪烁跳动
{
case 1:
if(0==Su8BlinkFlag) //两种状态的切换判断
{
Su8BlinkFlag=1;
Su8Temp_4=10; //右起第4个显示“不显示”（10代表不显示）
}
else
{
Su8BlinkFlag=0;
Su8Temp_4=Gu8EditData_4; //显示“十秒”的临时中间个体，属于动态数据。
}
break;
case 2:
if(0==Su8BlinkFlag) //两种状态的切换判断
{
Su8BlinkFlag=1;
Su8Temp_3=10; //右起第3个显示“不显示”（10代表不显示）
}
else
{
Su8BlinkFlag=0;
Su8Temp_3=Gu8EditData_3; //显示“个秒”的临时中间个体，属于动态数据。
}
break;
case 3:
if(0==Su8BlinkFlag) //两种状态的切换判断
{
Su8BlinkFlag=1;
Su8Temp_2=10; //右起第2个显示“不显示”（10代表不显示）
}
else
{
Su8BlinkFlag=0;
Su8Temp_2=Gu8EditData_2; //显示“百毫秒”的临时中间个体，属于动态数据。
}
break;
case 4:
if(0==Su8BlinkFlag) //两种状态的切换判断
{
Su8BlinkFlag=1;
Su8Temp_1=10; //右起第1个显示“不显示”（10代表不显示）
}
else
{
Su8BlinkFlag=0;
Su8Temp_1=Gu8EditData_1; //显示“十毫秒”的临时中间个体，属于动态数据。
}
break;
default: //都没有被选中的时候
if(Gu32SetData_Countdown<10000)
{
Su8Temp_4=10; //显示“无”
}
else
{
Su8Temp_4=Gu8EditData_4; //显示“十秒”的临时中间个体，属于动态数据。
}
Su8Temp_3=Gu8EditData_3; //显示“个秒”的临时中间个体，属于动态数据。
Su8Temp_2=Gu8EditData_2; //显示“百毫秒”的临时中间个体，属于动态数据。
Su8Temp_1=Gu8EditData_1; //显示“十毫秒”的临时中间个体，属于动态数据。
break;
}
vGu8Display_Righ_4=Su8Temp_4; //过渡需要显示的数据到底层驱动变量
vGu8Display_Righ_3=Su8Temp_3; //过渡需要显示的数据到底层驱动变量
vGu8Display_Righ_2=Su8Temp_2; //过渡需要显示的数据到底层驱动变量
vGu8Display_Righ_1=Su8Temp_1; //过渡需要显示的数据到底层驱动变量
}
}
void Wd2(void) //窗口2显示函数。倒计时的运行显示窗口。
{
//需要借用的中间变量，用来拆分数据位。
static unsigned char Su8Temp_4,Su8Temp_3,Su8Temp_2,Su8Temp_1; //需要借用的中间变量
if(1==Gu8WdUpdate) //如果需要整屏更新
{
Gu8WdUpdate=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
//先分解数据，注意，这里分解的时候，“先整除后求余”必须用一行代码一气呵成，不能拆
//分成两行代码，否则会有隐患会有bug。除非，把四个临时变都改成unsigned long类型。
//Su8Temp_4提取“十秒”位。
Su8Temp_4=vGu32CountdownTimerCnt/10000%10; //实际精度是0.001秒,但显示精度是0.01秒
//Su8Temp_3提取“个秒”位。
Su8Temp_3=vGu32CountdownTimerCnt/1000%10; //实际精度是0.001秒,但显示精度是0.01秒
//Su8Temp_2提取“百毫秒”位。
Su8Temp_2=vGu32CountdownTimerCnt/100%10; //实际精度是0.001秒,但显示精度是0.01秒
//Su8Temp_1提取“十毫秒”位。
Su8Temp_1=vGu32CountdownTimerCnt/10%10; //实际精度是0.001秒,但显示精度是0.01秒
//判断数据范围，来决定最高位数码管是否需要显示。
if(vGu32CountdownTimerCnt<10000) //10.000秒。实际4位数码管最大只能显示99.99秒
{
Su8Temp_4=10; //在数码管转换表里，10代表一个“不显示”的数据
}
//上面先分解数据之后，再过渡需要显示的数据到底层驱动变量里，让过渡的时间越短越好
vGu8Display_Righ_4=Su8Temp_4; //过渡需要显示的数据到底层驱动变量
vGu8Display_Righ_3=Su8Temp_3;
vGu8Display_Righ_2=Su8Temp_2;
vGu8Display_Righ_1=Su8Temp_1;
vGu8Display_Righ_Dot_4=0;
vGu8Display_Righ_Dot_3=1; //保留显示2位小数点
vGu8Display_Righ_Dot_2=0;
vGu8Display_Righ_Dot_1=0;
}
}
void KeyScan(void) //按键底层的驱动扫描函数，放在定时中断函数里
{
static unsigned char Su8KeyShortFlag=0; //按键“短按”触发的标志
static unsigned char Su8KeyLock1;
static unsigned int Su16KeyCnt1;
static unsigned char Su8KeyLock2;
static unsigned int Su16KeyCnt2;
static unsigned char Su8KeyLock3;
static unsigned int Su16KeyCnt3;
//需要详细分析以下这段“短按”与“长按”代码的朋友，请参考第96节。
if(0!=KEY_INPUT1)
{
Su8KeyLock1=0;
Su16KeyCnt1=0;
if(1==Su8KeyShortFlag)
{
Su8KeyShortFlag=0;
vGu8KeySec=1; //触发K1的“短按”
}
}
else if(0==Su8KeyLock1)
{
Su16KeyCnt1++;
if(Su16KeyCnt1>=KEY_FILTER_TIME)
{
Su8KeyShortFlag=1;
}
if(Su16KeyCnt1>=KEY_LONG_TIME)
{
Su8KeyLock1=1;
Su8KeyShortFlag=0;
vGu8KeySec=4; //触发K1的“长按”
}
}
if(0!=KEY_INPUT2)
{
Su8KeyLock2=0;
Su16KeyCnt2=0;
}
else if(0==Su8KeyLock2)
{
Su16KeyCnt2++;
if(Su16KeyCnt2>=KEY_FILTER_TIME)
{
Su8KeyLock2=1;
vGu8KeySec=2;
}
}
if(0!=KEY_INPUT3)
{
Su8KeyLock3=0;
Su16KeyCnt3=0;
}
else if(0==Su8KeyLock3)
{
Su16KeyCnt3++;
if(Su16KeyCnt3>=KEY_FILTER_TIME)
{
Su8KeyLock3=1;
vGu8KeySec=3;
}
}
}
void DisplayScan(void) //数码管底层的驱动扫描函数，放在定时中断函数里
{
static unsigned char Su8GetCode;
static unsigned char Su8ScanStep=1;
if(0==vGu16ScanTimerCnt)
{
P0=0x00;
P1_0=1;
P1_1=1;
P1_2=1;
P1_3=1;
switch(Su8ScanStep)
{
case 1:
Su8GetCode=Cu8DigTable[vGu8Display_Righ_1];
if(1==vGu8Display_Righ_Dot_1)
{
Su8GetCode=Su8GetCode|0x80;
}
P0=Su8GetCode;
P1_0=0;
P1_1=1;
P1_2=1;
P1_3=1;
break;
case 2:
Su8GetCode=Cu8DigTable[vGu8Display_Righ_2];
if(1==vGu8Display_Righ_Dot_2)
{
Su8GetCode=Su8GetCode|0x80;
}
P0=Su8GetCode;
P1_0=1;
P1_1=0;
P1_2=1;
P1_3=1;
break;
case 3:
Su8GetCode=Cu8DigTable[vGu8Display_Righ_3];
if(1==vGu8Display_Righ_Dot_3)
{
Su8GetCode=Su8GetCode|0x80;
}
P0=Su8GetCode;
P1_0=1;
P1_1=1;
P1_2=0;
P1_3=1;
break;
case 4:
Su8GetCode=Cu8DigTable[vGu8Display_Righ_4];
if(1==vGu8Display_Righ_Dot_4)
{
Su8GetCode=Su8GetCode|0x80;
}
P0=Su8GetCode;
P1_0=1;
P1_1=1;
P1_2=1;
P1_3=0;
break;
}
Su8ScanStep++;
if(Su8ScanStep>4)
{
Su8ScanStep=1;
}
vGu8ScanTimerFlag=0;
vGu16ScanTimerCnt=SCAN_TIME;
vGu8ScanTimerFlag=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 BeepOpen(void)
{
P3_4=0;
}
void BeepClose(void)
{
P3_4=1;
}
void T0_time() interrupt 1
{
VoiceScan(); //蜂鸣器的驱动函数
KeyScan(); //按键底层的驱动扫描函数
DisplayScan(); //数码管底层的驱动扫描函数
if(1==vGu8ScanTimerFlag&&vGu16ScanTimerCnt>0)
{
vGu16ScanTimerCnt--; //递减式的软件定时器
}
if(1==vGu8BlinkTimerFlag&&vGu16BlinkTimerCnt>0) //数码管闪烁跳动的定时器
{
vGu16BlinkTimerCnt--; //递减式的软件定时器
}
//每10ms就定时更新一次显示的软件定时器
if(1==vGu8UpdateTimerFlag&&vGu16UpdateTimerCnt>0)
{
vGu16UpdateTimerCnt--; //递减式的软件定时器
}
//倒计时实际走的时间的软件定时器，注意，这里还附加了启动状态的条件“&&1==Gu8RunStatus”
if(1==vGu8CountdownTimerFlag&&vGu32CountdownTimerCnt>0&&1==Gu8RunStatus)
{
vGu32CountdownTimerCnt--; //递减式的软件定时器
}
TH0=0xfd; //此参数可根据具体的时间来修改，尽量确保每定时中断一次接近1ms
TL0=0x40; //此参数可根据具体的时间来修改，尽量确保每定时中断一次接近1ms
}
void SystemInitial(void)
{
P0=0x00;
P1_0=1;
P1_1=1;
P1_2=1;
P1_3=1;
TMOD=0x01;
TH0=0xfd; //此参数可根据具体的时间来修改，尽量确保每定时中断一次接近1ms
TL0=0x40; //此参数可根据具体的时间来修改，尽量确保每定时中断一次接近1ms
EA=1;
ET0=1;
TR0=1;
//上电初始化开机显示的窗口
Gu8EditData_4=Gu32SetData_Countdown/10000%10; //分解成“十秒”个体
Gu8EditData_3=Gu32SetData_Countdown/1000%10; //分解成“个秒”个体
Gu8EditData_2=Gu32SetData_Countdown/100%10; //分解成“百毫秒”个体
Gu8EditData_1=Gu32SetData_Countdown/10%10; //分解成“十毫秒”个体
Gu8Wd=1; //返回设置数据的窗口
Gu8WdUpdate=1; //整屏更新一次显示
}
void Delay(unsigned long u32DelayTime)
{
for(;u32DelayTime>0;u32DelayTime--);
}
void PeripheralInitial(void)
{
}

复制代码

李谢 · 2018-6-25 17:39:38

从老帖一直追到这个新帖，从头看到结尾，真的感谢吴哥的无私奉献，虽然还有很多代码看不懂，但是基本理解吴哥的用意，在单片机的学习旅途中，感谢、庆幸有吴哥这样经验丰富的大神指导，少走很多弯路，真心感谢！！！

郑涛 · 2018-6-26 16:26:50

jianhong_wu 发表于 2017-10-17 17:54
第九十一节：蜂鸣器的“非阻塞”驱动。

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

感谢楼主分享,受益匪浅

郑涛 · 2018-6-26 16:27:55

jianhong_wu 发表于 2017-10-25 11:30
第九十二节：独立按键的四大要素（自锁，消抖，非阻塞，清零式滤波）。

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

感谢楼主分享,受益匪浅

郑涛 · 2018-6-26 16:28:35

jianhong_wu 发表于 2017-10-29 10:53
第九十三节：独立按键鼠标式的单击与双击。

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

感谢楼主分享,受益匪浅

郑涛 · 2018-6-26 16:29:03

jianhong_wu 发表于 2017-11-5 11:19
第九十四节：两个独立按键构成的组合按键。

【94.1 组合按键。】

感谢楼主分享,受益匪浅

郑涛 · 2018-6-26 16:55:17

jianhong_wu 发表于 2017-5-29 11:24
第七十一节：结构体的内存和赋值。
【71.1 结构体的内存生效。】

{:23:}{:23:}{:23:}{:23:}{:23:}

吴坚鸿 · 2018-7-1 12:38:55

第一百二十二节：利用定时中断做的“时分秒”数显时钟。

【122.1 利用定时中断做的“时分秒”数显时钟。】

            上图122.1.1  数码管

            上图122.1.2  独立按键


            上图122.1.3  有源蜂鸣器

   本节的数显时钟小项目，意在人机界面程序框架的综合训练。程序功能如下：
   （1）只有“时分秒”，没有“年月日”。
   （2）平时时钟正常工作的时候，四位数码管的显示格式是这样的“HH.MM”，其中HH代表“时”，MM代表“分”，而中间的小数点“.”每隔一秒闪烁一次。
   （3）K1［设置键］与[切换窗口键]。当数码管“没有闪烁”时（处于正常工作模式），“长按”K1键则进入“闪烁模式”（修改时钟模式），“闪烁模式”一共有3个窗口，分别是“1-HH”，“2-MM”，“3-SS”。其中“HH”“MM”“SS”分别代表可修改的“时”“分”“秒”，它们处于“闪烁”的状态，代表可编辑。此时，“短按”K1按键代表[切换窗口键]，可以使数码管在“1-HH”，“2-MM”，“3-SS”三个窗口之间依次切换。修改完毕后，只需“长按”K1键代表确定完成并且退出当前“闪烁模式”返回到时钟的“正常工作模式”。
   （4）K2［加键］。当数码管某位正在闪烁时，此时K2是［加键］，按K2会使数据“自加1”。
   （5）K3［减键］。当数码管某位正在闪烁时，此时K3是［减键］，按K3会使数据“自减1”。
   （6）处于“闪烁模式”时的3个窗口的数据范围。处于修改“时”的“1-HH”窗口时，HH的范围是：0到23；处于修改“分”的“2-MM”窗口时，MM的范围是：0到59；处于修改“秒”的“3-SS”窗口时，SS的范围是：0到59。
   代码如下：

#include "REG52.H"
#define KEY_FILTER_TIME 25
#define KEY_LONG_TIME 500
#define SCAN_TIME 1
#define VOICE_TIME 50
#define BLINK_TIME 250
void T0_time();
void SystemInitial(void) ;
void Delay(unsigned long u32DelayTime) ;
void PeripheralInitial(void) ;
void KeyScan(void);
void KeyTask(void);
void VoiceScan(void);
void DisplayScan(void);
void DisplayTask(void);
void Wd1(void); //窗口1。时钟正常工作的窗口“HH.MM”。小数点在闪烁跳动。
void Wd2(void); //窗口2。闪烁模式，修改“时”的“1-HH”的窗口。
void Wd3(void); //窗口3。闪烁模式，修改“分”的“2-MM”的窗口。
void Wd4(void); //窗口4。闪烁模式，修改“秒”的“3-SS”的窗口。
void BeepOpen(void);
void BeepClose(void);
***it KEY_INPUT1=P2^2;
***it KEY_INPUT2=P2^1;
***it KEY_INPUT3=P2^0;
***it P1_0=P1^0;
***it P1_1=P1^1;
***it P1_2=P1^2;
***it P1_3=P1^3;
***it P3_4=P3^4;
//数码管转换表
code unsigned char Cu8DigTable[]=
{
0x3f, //0 序号0
0x06, //1 序号1
0x5b, //2 序号2
0x4f, //3 序号3
0x66, //4 序号4
0x6d, //5 序号5
0x7d, //6 序号6
0x07, //7 序号7
0x7f, //8 序号8
0x6f, //9 序号9
0x00, //不显示序号10
0x40, //横杠- 序号11
};
volatile unsigned char vGu8ScanTimerFlag=0;
volatile unsigned int vGu16ScanTimerCnt=0;
volatile unsigned char vGu8BeepTimerFlag=0;
volatile unsigned int vGu16BeepTimerCnt=0;
volatile unsigned char vGu8BlinkTimerFlag=0;
volatile unsigned int vGu16BlinkTimerCnt=0;
//时钟的软件定时器，注意，这里是unsigned long类型，范围是0到4294967295毫秒
volatile unsigned char vGu8ClockTimerFlag=0;
volatile unsigned long vGu32ClockTimerCnt=0;
//时钟正常工作的时候，每500ms更新显示一次
volatile unsigned char vGu8UpdateTimerFlag=0;
volatile unsigned int vGu16UpdateTimerCnt=0;
unsigned char Gu8EditData_1=0; //是中间变量，用于编辑窗口“1-HH”下的HH数据。
unsigned char Gu8EditData_2=0; //是中间变量，用于编辑窗口“2-MM”下的MM数据。
unsigned char Gu8EditData_3=0; //是中间变量，用于编辑窗口“3-SS”下的SS数据。
unsigned char Gu8Wd=0; //窗口选择变量。人机交互程序框架的支点。
unsigned char Gu8WdUpdate=0; //整屏更新变量。
unsigned char Gu8PartUpdate_1=0; //局部1的更新变量,
unsigned char Gu8PartUpdate_2=0; //局部2的更新变量
unsigned char Gu8PartUpdate_3=0; //局部3的更新变量,
volatile unsigned char vGu8Display_Righ_4=0;
volatile unsigned char vGu8Display_Righ_3=0;
volatile unsigned char vGu8Display_Righ_2=0;
volatile unsigned char vGu8Display_Righ_1=0;
volatile unsigned char vGu8Display_Righ_Dot_4=0;
volatile unsigned char vGu8Display_Righ_Dot_3=1; //开机默认保留显示2个小数点
volatile unsigned char vGu8Display_Righ_Dot_2=0;
volatile unsigned char vGu8Display_Righ_Dot_1=0;
volatile unsigned char vGu8KeySec=0;
void main()
{
SystemInitial();
Delay(10000);
PeripheralInitial();
while(1)
{
KeyTask(); //按键的任务函数
DisplayTask(); //数码管显示的上层任务函数
}
}
void KeyTask(void) //按键的任务函数
{
if(0==vGu8KeySec)
{
return;
}
switch(vGu8KeySec)
{
case 1: //按键K1的“短按”。在“闪烁模式”下切换数码管的窗口。
switch(Gu8Wd) //在某个窗口下
{
case 2: //窗口2。修改“时”的“1-HH”窗口。
Gu8Wd=3; //切换到窗口3的“2-MM”窗口
Gu8WdUpdate=1; //整屏更新
break;
case 3: //窗口3。修改“分”的“2-MM”窗口。
Gu8Wd=4; //切换到窗口4的“3-SS”窗口
Gu8WdUpdate=1; //整屏更新
break;
case 4: //窗口4。修改“秒”的“3-SS”窗口。
Gu8Wd=2; //切换到窗口2的“1-HH”窗口
Gu8WdUpdate=1; //整屏更新
break;
}
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=VOICE_TIME; //蜂鸣器发出“滴”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0;
break;
case 2: //按键K2［加键］
switch(Gu8Wd) //在某个窗口下
{
case 2: //窗口2。修改“时”的“1-HH”窗口。
if(Gu8EditData_1<23) //“时”的范围是0到23
{
Gu8EditData_1++;
}
Gu8PartUpdate_1=1; //局部1更新显示
break;
case 3: //窗口3。修改“分”的“2-MM”窗口。
if(Gu8EditData_2<59) //“分”的范围是0到59
{
Gu8EditData_2++;
}
Gu8PartUpdate_1=1; //局部1更新显示
break;
case 4: //窗口4。修改“秒”的“3-SS”窗口。
if(Gu8EditData_3<59) //“秒”的范围是0到59
{
Gu8EditData_3++;
}
Gu8PartUpdate_1=1; //局部1更新显示
break;
}
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=VOICE_TIME; //蜂鸣器发出“滴”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0;
break;
case 3: //按键K3［减键］与［开始健］
switch(Gu8Wd) //在某个窗口下
{
case 2: //窗口2。修改“时”的“1-HH”窗口。
if(Gu8EditData_1>0)
{
Gu8EditData_1--;
}
Gu8PartUpdate_1=1; //局部1更新显示
break;
case 3: //窗口3。修改“分”的“2-MM”窗口。
if(Gu8EditData_2>0)
{
Gu8EditData_2--;
}
Gu8PartUpdate_1=1; //局部1更新显示
break;
case 4: //窗口4。修改“秒”的“3-SS”窗口。
if(Gu8EditData_3>0)
{
Gu8EditData_3--;
}
Gu8PartUpdate_1=1; //局部1更新显示
break;
}
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=VOICE_TIME; //蜂鸣器发出“滴”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0;
break;
case 4: //K1按键的“长按”,具有进入和退出“闪烁模式”的功能。“退出”隐含“确定”
switch(Gu8Wd) //在某个窗口下
{
case 1: //窗口1。时钟正常工作的窗口。
vGu8ClockTimerFlag=0; //停止时钟的定时器
Gu8EditData_1=vGu32ClockTimerCnt/3600000; //分解成“时”个体
Gu8EditData_2=vGu32ClockTimerCnt%3600000/60000; //分解成“分”个体
Gu8EditData_3=vGu32ClockTimerCnt%3600000%60000/1000; //分解成“秒”个体
Gu8Wd=2; //切换到窗口2的“1-HH”的闪烁窗口
Gu8WdUpdate=1; //整屏更新
break;
case 2: //窗口2。修改时钟时间的“1-HH”的闪烁窗口
case 3: //窗口3。修改时钟时间的“2-MM”的闪烁窗口
case 4: //窗口4。修改时钟时间的“3-SS”的闪烁窗口
//把个体合并还原成当前时钟时间的数据
vGu32ClockTimerCnt=Gu8EditData_1*3600000+Gu8EditData_2*60000+Gu8EditData_3*1000;
vGu8ClockTimerFlag=1; //启动时钟的定时器
Gu8Wd=1; //切换到窗口1的正常工作的窗口
Gu8WdUpdate=1; //整屏更新
break;
}
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=VOICE_TIME; //蜂鸣器发出“滴”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0;
break;
}
}
void DisplayTask(void) //数码管显示的上层任务函数
{
switch(Gu8Wd) //以窗口选择Gu8Wd为支点，去执行对应的窗口显示函数。又一次用到switch语句
{
case 1:
Wd1(); //窗口1。时钟正常运行的窗口
break;
case 2:
Wd2(); //窗口2。修改“时”的“1-HH”窗口
break;
case 3:
Wd3(); //窗口3。修改“分”的“2-MM”窗口
break;
case 4:
Wd4(); //窗口4。修改“秒”的“3-SS”窗口
break;
}
}
void Wd1(void) //窗口1。时钟正常运行的窗口
{
//需要借用的中间变量，用来拆分数据位。
static unsigned char Su8Temp_4,Su8Temp_3,Su8Temp_2,Su8Temp_1; //需要借用的中间变量
static unsigned char Su8BlinkFlag=0; //两种状态的切换判断的中间变量
if(1==Gu8WdUpdate) //如果需要整屏更新
{
Gu8WdUpdate=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
//属于静态数据，起“装饰”作用，切换窗口后只扫描一次的代码。
vGu8Display_Righ_Dot_4=0;
vGu8Display_Righ_Dot_3=1; //保留显示2位小数点
vGu8Display_Righ_Dot_2=0;
vGu8Display_Righ_Dot_1=0;
Gu8PartUpdate_1=1; //局部1更新显示
}
if(1==Gu8PartUpdate_1) //局部1更新显示，更新显示一次数据和闪烁的的小数点
{
Gu8PartUpdate_1=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
Su8Temp_4=vGu32ClockTimerCnt/3600000/10; //时的十位
Su8Temp_3=vGu32ClockTimerCnt/3600000%10; //时的个位
Su8Temp_2=vGu32ClockTimerCnt%3600000/60000/10; //分的十位
Su8Temp_1=vGu32ClockTimerCnt%3600000/60000%10; //秒的个位
//小数点的闪烁
if(0==Su8BlinkFlag)
{
Su8BlinkFlag=1;
vGu8Display_Righ_Dot_3=1; //显示第2位小数点。
}
else
{
Su8BlinkFlag=0;
vGu8Display_Righ_Dot_3=0; //不显示第2位小数点
}
vGu8Display_Righ_4=Su8Temp_4; //过渡需要显示的数据到底层驱动变量
vGu8Display_Righ_3=Su8Temp_3; //过渡需要显示的数据到底层驱动变量
vGu8Display_Righ_2=Su8Temp_2; //过渡需要显示的数据到底层驱动变量
vGu8Display_Righ_1=Su8Temp_1; //过渡需要显示的数据到底层驱动变量
}
if(0==vGu16UpdateTimerCnt) //每隔500ms就更新显示一次数据和闪烁的的小数点
{
vGu8UpdateTimerFlag=0;
vGu16UpdateTimerCnt=500; //重设定时器的定时时间
vGu8UpdateTimerFlag=1;
Gu8PartUpdate_1=1; //局部1更新显示
}
}
void Wd2(void) //窗口2。修改“时”的“1-HH”窗口。
{
//需要借用的中间变量，用来拆分数据位。
static unsigned char Su8Temp_2,Su8Temp_1; //需要借用的中间变量
static unsigned char Su8BlinkFlag=0; //两种状态的切换判断的中间变量
if(1==Gu8WdUpdate) //如果需要整屏更新
{
Gu8WdUpdate=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
//属于静态数据，起“装饰”作用，切换窗口后只扫描一次的代码。
vGu8Display_Righ_4=1; //显示数字“1”
vGu8Display_Righ_3=11; //显示横杠“-”
vGu8Display_Righ_Dot_4=0;
vGu8Display_Righ_Dot_3=0;
vGu8Display_Righ_Dot_2=0;
vGu8Display_Righ_Dot_1=0;
Gu8PartUpdate_1=1; //局部1更新显示
}
if(1==Gu8PartUpdate_1) //局部1更新显示
{
Gu8PartUpdate_1=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
Su8Temp_2=Gu8EditData_1/10; //显示“时”的十位
Su8Temp_1=Gu8EditData_1%10; //显示“时”的个位
vGu8Display_Righ_2=Su8Temp_2; //过渡需要显示的数据到底层驱动变量
vGu8Display_Righ_1=Su8Temp_1; //过渡需要显示的数据到底层驱动变量
}
if(0==vGu16BlinkTimerCnt) //某位被选中的数码管跳动闪烁的定时器
{
vGu8BlinkTimerFlag=0;
vGu16BlinkTimerCnt=BLINK_TIME; //重设定时器的定时时间
vGu8BlinkTimerFlag=1;
if(0==Su8BlinkFlag) //两种状态的切换判断
{
Su8BlinkFlag=1;
Su8Temp_2=10; //10代表不显示
Su8Temp_1=10; //10代表不显示
}
else
{
Su8BlinkFlag=0;
Su8Temp_2=Gu8EditData_1/10; //显示“时”的十位
Su8Temp_1=Gu8EditData_1%10; //显示“时”的个位
}
vGu8Display_Righ_2=Su8Temp_2; //过渡需要显示的数据到底层驱动变量
vGu8Display_Righ_1=Su8Temp_1; //过渡需要显示的数据到底层驱动变量
}
}
void Wd3(void) //窗口3。修改“分”的“2-MM”窗口。
{
//需要借用的中间变量，用来拆分数据位。
static unsigned char Su8Temp_2,Su8Temp_1; //需要借用的中间变量
static unsigned char Su8BlinkFlag=0; //两种状态的切换判断的中间变量
if(1==Gu8WdUpdate) //如果需要整屏更新
{
Gu8WdUpdate=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
//属于静态数据，起“装饰”作用，切换窗口后只扫描一次的代码。
vGu8Display_Righ_4=2; //显示数字“2”
vGu8Display_Righ_3=11; //显示横杠“-”
vGu8Display_Righ_Dot_4=0;
vGu8Display_Righ_Dot_3=0;
vGu8Display_Righ_Dot_2=0;
vGu8Display_Righ_Dot_1=0;
Gu8PartUpdate_1=1; //局部1更新显示
}
if(1==Gu8PartUpdate_1) //局部1更新显示
{
Gu8PartUpdate_1=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
Su8Temp_2=Gu8EditData_2/10; //显示“分”的十位
Su8Temp_1=Gu8EditData_2%10; //显示“分”的个位
vGu8Display_Righ_2=Su8Temp_2; //过渡需要显示的数据到底层驱动变量
vGu8Display_Righ_1=Su8Temp_1; //过渡需要显示的数据到底层驱动变量
}
if(0==vGu16BlinkTimerCnt) //某位被选中的数码管跳动闪烁的定时器
{
vGu8BlinkTimerFlag=0;
vGu16BlinkTimerCnt=BLINK_TIME; //重设定时器的定时时间
vGu8BlinkTimerFlag=1;
if(0==Su8BlinkFlag) //两种状态的切换判断
{
Su8BlinkFlag=1;
Su8Temp_2=10; //10代表不显示
Su8Temp_1=10; //10代表不显示
}
else
{
Su8BlinkFlag=0;
Su8Temp_2=Gu8EditData_2/10; //显示“分”的十位
Su8Temp_1=Gu8EditData_2%10; //显示“分”的个位
}
vGu8Display_Righ_2=Su8Temp_2; //过渡需要显示的数据到底层驱动变量
vGu8Display_Righ_1=Su8Temp_1; //过渡需要显示的数据到底层驱动变量
}
}
void Wd4(void) //窗口4。修改“秒”的“3-SS”窗口。
{
//需要借用的中间变量，用来拆分数据位。
static unsigned char Su8Temp_2,Su8Temp_1; //需要借用的中间变量
static unsigned char Su8BlinkFlag=0; //两种状态的切换判断的中间变量
if(1==Gu8WdUpdate) //如果需要整屏更新
{
Gu8WdUpdate=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
//属于静态数据，起“装饰”作用，切换窗口后只扫描一次的代码。
vGu8Display_Righ_4=3; //显示数字“3”
vGu8Display_Righ_3=11; //显示横杠“-”
vGu8Display_Righ_Dot_4=0;
vGu8Display_Righ_Dot_3=0;
vGu8Display_Righ_Dot_2=0;
vGu8Display_Righ_Dot_1=0;
Gu8PartUpdate_1=1; //局部1更新显示
}
if(1==Gu8PartUpdate_1) //局部1更新显示
{
Gu8PartUpdate_1=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
Su8Temp_2=Gu8EditData_3/10; //显示“秒”的十位
Su8Temp_1=Gu8EditData_3%10; //显示“秒”的个位
vGu8Display_Righ_2=Su8Temp_2; //过渡需要显示的数据到底层驱动变量
vGu8Display_Righ_1=Su8Temp_1; //过渡需要显示的数据到底层驱动变量
}
if(0==vGu16BlinkTimerCnt) //某位被选中的数码管跳动闪烁的定时器
{
vGu8BlinkTimerFlag=0;
vGu16BlinkTimerCnt=BLINK_TIME; //重设定时器的定时时间
vGu8BlinkTimerFlag=1;
if(0==Su8BlinkFlag) //两种状态的切换判断
{
Su8BlinkFlag=1;
Su8Temp_2=10; //10代表不显示
Su8Temp_1=10; //10代表不显示
}
else
{
Su8BlinkFlag=0;
Su8Temp_2=Gu8EditData_3/10; //显示“秒”的十位
Su8Temp_1=Gu8EditData_3%10; //显示“秒”的个位
}
vGu8Display_Righ_2=Su8Temp_2; //过渡需要显示的数据到底层驱动变量
vGu8Display_Righ_1=Su8Temp_1; //过渡需要显示的数据到底层驱动变量
}
}
void KeyScan(void) //按键底层的驱动扫描函数，放在定时中断函数里
{
static unsigned char Su8KeyShortFlag=0; //按键“短按”触发的标志
static unsigned char Su8KeyLock1;
static unsigned int Su16KeyCnt1;
static unsigned char Su8KeyLock2;
static unsigned int Su16KeyCnt2;
static unsigned char Su8KeyLock3;
static unsigned int Su16KeyCnt3;
//需要详细分析以下这段“短按”与“长按”代码的朋友，请参考第96节。
if(0!=KEY_INPUT1)
{
Su8KeyLock1=0;
Su16KeyCnt1=0;
if(1==Su8KeyShortFlag)
{
Su8KeyShortFlag=0;
vGu8KeySec=1; //触发K1的“短按”
}
}
else if(0==Su8KeyLock1)
{
Su16KeyCnt1++;
if(Su16KeyCnt1>=KEY_FILTER_TIME)
{
Su8KeyShortFlag=1;
}
if(Su16KeyCnt1>=KEY_LONG_TIME)
{
Su8KeyLock1=1;
Su8KeyShortFlag=0;
vGu8KeySec=4; //触发K1的“长按”
}
}
if(0!=KEY_INPUT2)
{
Su8KeyLock2=0;
Su16KeyCnt2=0;
}
else if(0==Su8KeyLock2)
{
Su16KeyCnt2++;
if(Su16KeyCnt2>=KEY_FILTER_TIME)
{
Su8KeyLock2=1;
vGu8KeySec=2;
}
}
if(0!=KEY_INPUT3)
{
Su8KeyLock3=0;
Su16KeyCnt3=0;
}
else if(0==Su8KeyLock3)
{
Su16KeyCnt3++;
if(Su16KeyCnt3>=KEY_FILTER_TIME)
{
Su8KeyLock3=1;
vGu8KeySec=3;
}
}
}
void DisplayScan(void) //数码管底层的驱动扫描函数，放在定时中断函数里
{
static unsigned char Su8GetCode;
static unsigned char Su8ScanStep=1;
if(0==vGu16ScanTimerCnt)
{
P0=0x00;
P1_0=1;
P1_1=1;
P1_2=1;
P1_3=1;
switch(Su8ScanStep)
{
case 1:
Su8GetCode=Cu8DigTable[vGu8Display_Righ_1];
if(1==vGu8Display_Righ_Dot_1)
{
Su8GetCode=Su8GetCode|0x80;
}
P0=Su8GetCode;
P1_0=0;
P1_1=1;
P1_2=1;
P1_3=1;
break;
case 2:
Su8GetCode=Cu8DigTable[vGu8Display_Righ_2];
if(1==vGu8Display_Righ_Dot_2)
{
Su8GetCode=Su8GetCode|0x80;
}
P0=Su8GetCode;
P1_0=1;
P1_1=0;
P1_2=1;
P1_3=1;
break;
case 3:
Su8GetCode=Cu8DigTable[vGu8Display_Righ_3];
if(1==vGu8Display_Righ_Dot_3)
{
Su8GetCode=Su8GetCode|0x80;
}
P0=Su8GetCode;
P1_0=1;
P1_1=1;
P1_2=0;
P1_3=1;
break;
case 4:
Su8GetCode=Cu8DigTable[vGu8Display_Righ_4];
if(1==vGu8Display_Righ_Dot_4)
{
Su8GetCode=Su8GetCode|0x80;
}
P0=Su8GetCode;
P1_0=1;
P1_1=1;
P1_2=1;
P1_3=0;
break;
}
Su8ScanStep++;
if(Su8ScanStep>4)
{
Su8ScanStep=1;
}
vGu8ScanTimerFlag=0;
vGu16ScanTimerCnt=SCAN_TIME;
vGu8ScanTimerFlag=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 BeepOpen(void)
{
P3_4=0;
}
void BeepClose(void)
{
P3_4=1;
}
void T0_time() interrupt 1
{
VoiceScan(); //蜂鸣器的驱动函数
KeyScan(); //按键底层的驱动扫描函数
DisplayScan(); //数码管底层的驱动扫描函数
if(1==vGu8ScanTimerFlag&&vGu16ScanTimerCnt>0)
{
vGu16ScanTimerCnt--; //递减式的软件定时器
}
if(1==vGu8BlinkTimerFlag&&vGu16BlinkTimerCnt>0) //数码管闪烁跳动的定时器
{
vGu16BlinkTimerCnt--; //递减式的软件定时器
}
//在正常工作的窗口下，每500ms就定时更新一次显示的软件定时器
if(1==vGu8UpdateTimerFlag&&vGu16UpdateTimerCnt>0)
{
vGu16UpdateTimerCnt--; //递减式的软件定时器
}
//时钟实际走的时间的软件定时器，注意，这里是递增式的软件定时器
if(1==vGu8ClockTimerFlag)
{
vGu32ClockTimerCnt++; //递增式的软件定时器
if(vGu32ClockTimerCnt>=86400000) //86400000毫秒代表24时
{
vGu32ClockTimerCnt=0;
}
}
TH0=0xfd; //此参数可根据具体的时间来修改，尽量确保每定时中断一次接近1ms
TL0=0x40; //此参数可根据具体的时间来修改，尽量确保每定时中断一次接近1ms
}
void SystemInitial(void)
{
P0=0x00;
P1_0=1;
P1_1=1;
P1_2=1;
P1_3=1;
TMOD=0x01;
TH0=0xfd; //此参数可根据具体的时间来修改，尽量确保每定时中断一次接近1ms
TL0=0x40; //此参数可根据具体的时间来修改，尽量确保每定时中断一次接近1ms
EA=1;
ET0=1;
TR0=1;
//上电初始化一些关键的数据
Gu8Wd=1; //窗口1。开机默认处于正常工作的窗口
Gu8WdUpdate=1; //整屏更新变量
vGu8ClockTimerFlag=0;
vGu32ClockTimerCnt=43200000; //43200000毫秒开机默认12:00点。12时就是43200000毫秒
vGu8ClockTimerFlag=1; //启动时钟的定时器
//时钟正常工作的时候，每500ms更新显示一次
vGu16UpdateTimerCnt=500;
vGu8UpdateTimerFlag=1; //启动小数点闪烁的定时器
}
void Delay(unsigned long u32DelayTime)
{
for(;u32DelayTime>0;u32DelayTime--);
}
void PeripheralInitial(void)
{
}

复制代码

吴坚鸿 · 2018-7-9 10:11:50

第一百二十三节：一种能省去一个lock自锁变量的按键驱动程序。

【123.1 一种能省去一个lock自锁变量的按键驱动程序。】

一位群友给我提到了一个按键的改进建议，能巧妙的省去一个lock自锁变量。这个建议引起了我对“变量的分工要专一，一个变量尽量只用在一类事物上，尽量不取巧兼容”的思考。

第一种：带lock自锁变量，也是我一直在用的代码。

if(0!=KEY_INPUT1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
{
Su8KeyLock1=0; //按键解锁
Su16KeyCnt1=0; //按键去抖动延时计数器清零，此行非常巧妙，是全场的亮点。
}
else if(0==Su8KeyLock1)//有按键按下，且是第一次被按下。这行如果有疑问，请看92节的专题分析。
{
Su16KeyCnt1++; //累加定时中断次数
if(Su16KeyCnt1>=KEY_FILTER_TIME) //滤波的“稳定时间”KEY_FILTER_TIME，长度是25ms。
{
Su8KeyLock1=1; //按键的自锁,避免一直触发
vGu8KeySec=1; //触发1号键
}
}

复制代码

第二种：省略掉一个lock自锁变量，群友提出的改进建议。

if(0!=KEY_INPUT1)
{
Su16KeyCnt1=0;
}
else if(Su16KeyCnt1
{
Su16KeyCnt1++;
if(KEY_FILTER_TIME==Su16KeyCnt1) //巧妙的利用了Su16KeyCnt1等于滤波时间时，只执行一次
{
vGu8KeySec=1;
}
}

复制代码

分析：
不得不佩服群友的智慧，第二种改进后看起来非常巧妙，犹如蜻蜓点水般轻盈洒脱。但是，为此代码狂欢片刻后，我又有了新的思考和看法。“计时器Su16KeyCnt1”和“自锁变量Su8KeyLock1”是两个不同的事物，是两个不同的范畴，就应该用两个不同的变量进行区分。如果逞一时之巧，把两种不同范畴的事物巧妙合并成一个变量，势必会导致程序的“易读性”和“后续维护的可扩展性”大打折扣。“自锁变量Su8KeyLock1”真的是可有可无吗？假设，如果“计时器Su16KeyCnt1”的消抖时间KEY_FILTER_TIME要求等于0，那么第二种改进后的代码立刻暴露出了问题，行不通。而第一种代码，因为有“自锁变量Su8KeyLock1”的存在，即使消抖时间KEY_FILTER_TIME等于0，也不影响代码功能的完整性，因为第一种代码的理念是“自锁与计时器是两种不同的功能范畴，用两个不同的变量进行分开隔离，各自管理两种不同的事物，计时器即使为0也不影响代码本该有的自锁功能”。通过此例子，给初学者一个建议，在代码的“队形感，易读性，扩展性，分类清晰”和“巧妙，节省代码”两者之间，建议大家优先考虑“队形感，易读性，扩展性，分类清晰”，追求一种原则上的“工整，不出奇兵，扎硬寨，打呆仗，步步为营”，这样阵脚不易乱，能走得更远，驾驭更多千军万马的代码。

lzhiaohiua · 2018-7-9 13:29:52

谢谢楼主的分享

吴坚鸿 · 2018-7-16 10:33:13

第一百二十四节：数显仪表盘显示“速度、方向、计数器”的跑马灯。

【124.1 数显仪表盘显示“速度、方向、计数器”的跑马灯。】

            上图124.1.1  数码管

            上图124.1.2  独立按键


            上图124.1.3  有源蜂鸣器


            上图124.1.4  LED电路

   本节小项目，意在“人机界面”与“过程控制”如何关联的练习。
   程序功能如下：
   （1）数码管显示的格式是“S.D.CC”。其中S是代表3档速度，能显示的数字范围是“1、2、3”，分别代表“慢、中、快”3档速度。D代表方向，往右跑显示符号“r”（right的首字母），往左跑显示符号“L”（Left的首字母）。CC代表计数器，跑马灯每跑完一次，计数器自动加1，范围是0到99。
   （2）【速度】按键K1。每按一次【速度】按键K1，速度档位显示的数字在“1、2、3”之间切换。
   （3）【方向】按键K2。跑马灯上电后默认处于“往右跑”的方向,默认显示字符“r”。每按一次【方向】按键K2，跑马灯就在“往右跑”与“往左跑”两个方向之间切换，显示的字符在“r、L”之间切换。
   （4）【启动暂停】按键K3。上电后，按下【启动暂停】按键K3启动之后，跑马灯处于“启动”状态，4个LED灯挨个依次循环的变亮，给人“跑”起来的感觉，此时再按一次【启动暂停】按键K3，则跑马灯处于“暂停”状态，接着又按一次【启动暂停】按键K3，跑马灯又变回“启动”状态。因此，【启动暂停】按键K3是专门用来切换“启动”和“暂停”这两种状态。
   代码如下：

#include "REG52.H"
#define KEY_FILTER_TIME 25
#define SCAN_TIME 1
#define VOICE_TIME 50
#define RUN_TIME_SLOW 500 //“慢”档速度的时间参数
#define RUN_TIME_MIDDLE 300 //“中”档速度的时间参数
#define RUN_TIME_FAST 100 //“快”档速度的时间参数
void T0_time();
void SystemInitial(void) ;
void Delay(unsigned long u32DelayTime) ;
void PeripheralInitial(void) ;
void KeyScan(void);
void KeyTask(void);
void RunTask(void); //跑马灯的任务函数
void VoiceScan(void);
void DisplayScan(void);
void DisplayTask(void);
void Wd1(void); //窗口1。
void BeepOpen(void);
void BeepClose(void);
***it KEY_INPUT1=P2^2;
***it KEY_INPUT2=P2^1;
***it KEY_INPUT3=P2^0;
***it P1_0=P1^0;
***it P1_1=P1^1;
***it P1_2=P1^2;
***it P1_3=P1^3;
***it P3_4=P3^4;
//4个跑马灯的输出口
***it P1_4=P1^4;
***it P1_5=P1^5;
***it P1_6=P1^6;
***it P3_3=P3^3;
//数码管转换表
code unsigned char Cu8DigTable[]=
{
0x3f, //0 序号0
0x06, //1 序号1
0x5b, //2 序号2
0x4f, //3 序号3
0x66, //4 序号4
0x6d, //5 序号5
0x7d, //6 序号6
0x07, //7 序号7
0x7f, //8 序号8
0x6f, //9 序号9
0x00, //不显示序号10
0x40, //横杠- 序号11
0x38, //字符L 序号12
0x70, //字符r 序号13
};
volatile unsigned char vGu8ScanTimerFlag=0;
volatile unsigned int vGu16ScanTimerCnt=0;
volatile unsigned char vGu8BeepTimerFlag=0;
volatile unsigned int vGu16BeepTimerCnt=0;
unsigned char Gu8Wd=0; //窗口选择变量。人机交互程序框架的支点。
unsigned char Gu8WdUpdate=0; //整屏更新变量。
unsigned char Gu8PartUpdate_1=0; //局部1的更新变量,
unsigned char Gu8PartUpdate_2=0; //局部2的更新变量
unsigned char Gu8PartUpdate_3=0; //局部3的更新变量,
volatile unsigned char vGu8Display_Righ_4=0;
volatile unsigned char vGu8Display_Righ_3=0;
volatile unsigned char vGu8Display_Righ_2=0;
volatile unsigned char vGu8Display_Righ_1=0;
volatile unsigned char vGu8Display_Righ_Dot_4=1; //需要显示的小数点
volatile unsigned char vGu8Display_Righ_Dot_3=1; //需要显示的小数点
volatile unsigned char vGu8Display_Righ_Dot_2=0;
volatile unsigned char vGu8Display_Righ_Dot_1=0;
volatile unsigned char vGu8KeySec=0;
unsigned char Gu8RunCounter=0; //计数器，范围是0到99
unsigned char Gu8RunStep=0; //运行的步骤
unsigned char Gu8RunStart=0; //控制跑马灯启动的总开关
unsigned char Gu8RunStatus=0; //标识跑马灯当前的状态。0代表停止，1代表启动，2代表暂停。
unsigned char Gu8RunDirection=0; //标识跑马灯当前的方向。0代表往右跑，1代表往左跑。
unsigned char Gu8RunSpeed=1; //当前的速度档位。1代表“慢”，2代表“中”，3代表“快”。
unsigned int Gu16RunSpeedTimeDate=0; //承接各速度档位的时间参数的变量
volatile unsigned char vGu8RunTimerFlag=0; //用于控制跑马灯跑动速度的定时器
volatile unsigned int vGu16RunTimerCnt=0;
void main()
{
SystemInitial();
Delay(10000);
PeripheralInitial();
while(1)
{
KeyTask(); //按键的任务函数
DisplayTask(); //数码管显示的上层任务函数
RunTask(); //跑马灯的任务函数
}
}
void RunTask(void) //跑马灯的任务函数，放在主函数内
{
if(0==Gu8RunStart) //如果是停止的状态
{
return; //如果是停止的状态，退出当前函数，不扫描余下代码。
}
switch(Gu8RunStep) //屡见屡爱的switch又来了
{
case 0:
vGu8RunTimerFlag=0;
vGu16RunTimerCnt=0; //定时器清零
Gu8RunStep=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=Gu16RunSpeedTimeDate; //速度时间参数变量的大小，决定了速度
vGu8RunTimerFlag=1; //启动定时器
//灵活切换“步骤变量”
if(0==Gu8RunDirection) //往右跑
{
Gu8RunStep=2;
}
else //往左跑
{
if(Gu8RunCounter<99)
{
Gu8RunCounter++; //往左边跑完一次，运行的计数器自加1
}
Gu8PartUpdate_3=1; //局部3的更新变量，更新显示计数器
Gu8RunStep=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=Gu16RunSpeedTimeDate; //速度时间参数变量的大小，决定了速度
vGu8RunTimerFlag=1; //启动定时器
//灵活切换“步骤变量”
if(0==Gu8RunDirection) //往右跑
{
Gu8RunStep=3;
}
else //往左跑
{
Gu8RunStep=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=Gu16RunSpeedTimeDate; //速度时间参数变量的大小，决定了速度
vGu8RunTimerFlag=1; //启动定时器
//灵活切换“步骤变量”
if(0==Gu8RunDirection) //往右跑
{
Gu8RunStep=4;
}
else //往左跑
{
Gu8RunStep=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=Gu16RunSpeedTimeDate; //速度时间参数变量的大小，决定了速度
vGu8RunTimerFlag=1; //启动定时器
//灵活切换“步骤变量”
if(0==Gu8RunDirection) //往右跑
{
if(Gu8RunCounter<99)
{
Gu8RunCounter++; //往右边跑完一次，运行的计数器自加1
}
Gu8PartUpdate_3=1; //局部3的更新变量，更新显示计数器
Gu8RunStep=1;
}
else //往左跑
{
Gu8RunStep=3;
}
}
break;
}
}
void KeyTask(void) //按键的任务函数
{
if(0==vGu8KeySec)
{
return;
}
switch(vGu8KeySec)
{
case 1: //【速度】按键K1
switch(Gu8Wd) //在某个窗口下
{
case 1: //窗口1。
//每按一次K1按键，Gu8RunSpeed就在1、2、3三者之间切换,
//并且根据Gu8RunSpeed的数值，对Gu16RunSpeedTimeDate赋值
//不同的速度时间参数，从而控制速度档位。
if(1==Gu8RunSpeed)
{
Gu8RunSpeed=2; //“中”档
Gu16RunSpeedTimeDate=RUN_TIME_MIDDLE; //赋值“中”档的时间参数
}
else if(2==Gu8RunSpeed)
{
Gu8RunSpeed=3; //“快”档
Gu16RunSpeedTimeDate=RUN_TIME_FAST; //赋值“快”档的时间参数
}
else
{
Gu8RunSpeed=1; //“慢”档
Gu16RunSpeedTimeDate=RUN_TIME_SLOW; //赋值“慢”档的时间参数
}
Gu8PartUpdate_1=1; //局部1的更新变量，更新显示“速度”
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=VOICE_TIME; //蜂鸣器发出“滴”一声
vGu8BeepTimerFlag=1;
break;
}
vGu8KeySec=0;
break;
case 2: //【方向】按键K2
switch(Gu8Wd) //在某个窗口下
{
case 1: //窗口1。
//每按一次K2按键，Gu8RunDirection就在0和1之间切换,从而控制方向
if(0==Gu8RunDirection)
{
Gu8RunDirection=1;
}
else
{
Gu8RunDirection=0;
}
Gu8PartUpdate_2=1; //局部2更新显示，更新显示“方向”
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=VOICE_TIME; //蜂鸣器发出“滴”一声
vGu8BeepTimerFlag=1;
break;
}
vGu8KeySec=0;
break;
case 3: //【启动暂停】按键K3
switch(Gu8Wd) //在某个窗口下
{
case 1: //窗口1。
if(0==Gu8RunStatus) //当跑马灯处于“停止”状态时
{
Gu8RunStep=0; //运行步骤从0开始
Gu8RunStart=1; //总开关“打开”。
Gu8RunStatus=1; //状态切换到“启动”状态
}
else if(1==Gu8RunStatus) //当跑马灯处于“启动”状态时
{
Gu8RunStatus=2; //状态切换到“暂停”状态
}
else //当跑马灯处于“暂停”状态时
{
Gu8RunStatus=1; //状态切换到“启动”状态
}
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=VOICE_TIME; //蜂鸣器发出“滴”一声
vGu8BeepTimerFlag=1;
break;
}
vGu8KeySec=0;
break;
}
}
void DisplayTask(void) //数码管显示的上层任务函数
{
switch(Gu8Wd) //以窗口选择Gu8Wd为支点，去执行对应的窗口显示函数。又一次用到switch语句
{
case 1:
Wd1(); //窗口1。
break;
}
}
void Wd1(void) //窗口1。
{
//需要借用的中间变量，用来拆分数据位。
static unsigned char Su8Temp_4,Su8Temp_3,Su8Temp_2,Su8Temp_1; //需要借用的中间变量
if(1==Gu8WdUpdate) //如果需要整屏更新
{
Gu8WdUpdate=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
//属于静态数据，起“装饰”作用，切换窗口后只扫描一次的代码。
vGu8Display_Righ_Dot_4=1; //显示小数点
vGu8Display_Righ_Dot_3=1; //显示小数点
vGu8Display_Righ_Dot_2=0;
vGu8Display_Righ_Dot_1=0;
Gu8PartUpdate_1=1; //局部1更新显示
Gu8PartUpdate_2=1; //局部2更新显示
Gu8PartUpdate_3=1; //局部3更新显示
}
if(1==Gu8PartUpdate_1) //局部1更新显示，速度
{
Gu8PartUpdate_1=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
Su8Temp_4=Gu8RunSpeed;
vGu8Display_Righ_4=Su8Temp_4; //过渡需要显示的数据到底层驱动变量
}
if(1==Gu8PartUpdate_2) //局部2更新显示，方向
{
Gu8PartUpdate_2=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
if(0==Gu8RunDirection) //往右跑
{
Su8Temp_3=13; //数码管的字模转换表序号13代表显示字符“r”
}
else
{
Su8Temp_3=12; //数码管的字模转换表序号12代表显示字符“L”
}
vGu8Display_Righ_3=Su8Temp_3; //过渡需要显示的数据到底层驱动变量
}
if(1==Gu8PartUpdate_3) //局部3更新显示，计数器
{
Gu8PartUpdate_3=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
Su8Temp_2=Gu8RunCounter%100/10; //提取十位
Su8Temp_1=Gu8RunCounter%10/1; //提取个位
vGu8Display_Righ_2=Su8Temp_2; //过渡需要显示的数据到底层驱动变量
vGu8Display_Righ_1=Su8Temp_1; //过渡需要显示的数据到底层驱动变量
}
}
void KeyScan(void) //按键底层的驱动扫描函数，放在定时中断函数里
{
static unsigned char Su8KeyLock1;
static unsigned int Su16KeyCnt1;
static unsigned char Su8KeyLock2;
static unsigned int Su16KeyCnt2;
static unsigned char Su8KeyLock3;
static unsigned int Su16KeyCnt3;
if(0!=KEY_INPUT1)
{
Su8KeyLock1=0;
Su16KeyCnt1=0;
}
else if(0==Su8KeyLock1)
{
Su16KeyCnt1++;
if(Su16KeyCnt1>=KEY_FILTER_TIME)
{
Su8KeyLock1=1;
vGu8KeySec=1;
}
}
if(0!=KEY_INPUT2)
{
Su8KeyLock2=0;
Su16KeyCnt2=0;
}
else if(0==Su8KeyLock2)
{
Su16KeyCnt2++;
if(Su16KeyCnt2>=KEY_FILTER_TIME)
{
Su8KeyLock2=1;
vGu8KeySec=2;
}
}
if(0!=KEY_INPUT3)
{
Su8KeyLock3=0;
Su16KeyCnt3=0;
}
else if(0==Su8KeyLock3)
{
Su16KeyCnt3++;
if(Su16KeyCnt3>=KEY_FILTER_TIME)
{
Su8KeyLock3=1;
vGu8KeySec=3;
}
}
}
void DisplayScan(void) //数码管底层的驱动扫描函数，放在定时中断函数里
{
static unsigned char Su8GetCode;
static unsigned char Su8ScanStep=1;
if(0==vGu16ScanTimerCnt)
{
P0=0x00;
P1_0=1;
P1_1=1;
P1_2=1;
P1_3=1;
switch(Su8ScanStep)
{
case 1:
Su8GetCode=Cu8DigTable[vGu8Display_Righ_1];
if(1==vGu8Display_Righ_Dot_1)
{
Su8GetCode=Su8GetCode|0x80;
}
P0=Su8GetCode;
P1_0=0;
P1_1=1;
P1_2=1;
P1_3=1;
break;
case 2:
Su8GetCode=Cu8DigTable[vGu8Display_Righ_2];
if(1==vGu8Display_Righ_Dot_2)
{
Su8GetCode=Su8GetCode|0x80;
}
P0=Su8GetCode;
P1_0=1;
P1_1=0;
P1_2=1;
P1_3=1;
break;
case 3:
Su8GetCode=Cu8DigTable[vGu8Display_Righ_3];
if(1==vGu8Display_Righ_Dot_3)
{
Su8GetCode=Su8GetCode|0x80;
}
P0=Su8GetCode;
P1_0=1;
P1_1=1;
P1_2=0;
P1_3=1;
break;
case 4:
Su8GetCode=Cu8DigTable[vGu8Display_Righ_4];
if(1==vGu8Display_Righ_Dot_4)
{
Su8GetCode=Su8GetCode|0x80;
}
P0=Su8GetCode;
P1_0=1;
P1_1=1;
P1_2=1;
P1_3=0;
break;
}
Su8ScanStep++;
if(Su8ScanStep>4)
{
Su8ScanStep=1;
}
vGu8ScanTimerFlag=0;
vGu16ScanTimerCnt=SCAN_TIME;
vGu8ScanTimerFlag=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 BeepOpen(void)
{
P3_4=0;
}
void BeepClose(void)
{
P3_4=1;
}
void T0_time() interrupt 1
{
VoiceScan(); //蜂鸣器的驱动函数
KeyScan(); //按键底层的驱动扫描函数
DisplayScan(); //数码管底层的驱动扫描函数
if(1==vGu8ScanTimerFlag&&vGu16ScanTimerCnt>0)
{
vGu16ScanTimerCnt--;
}
if(1==vGu8RunTimerFlag&&vGu16RunTimerCnt>0) //用于控制跑马灯跑动速度的定时器
{
vGu16RunTimerCnt--;
}
TH0=0xfd; //此参数可根据具体的时间来修改，尽量确保每定时中断一次接近1ms
TL0=0x40; //此参数可根据具体的时间来修改，尽量确保每定时中断一次接近1ms
}
void SystemInitial(void)
{
P0=0x00;
P1_0=1;
P1_1=1;
P1_2=1;
P1_3=1;
TMOD=0x01;
TH0=0xfd; //此参数可根据具体的时间来修改，尽量确保每定时中断一次接近1ms
TL0=0x40; //此参数可根据具体的时间来修改，尽量确保每定时中断一次接近1ms
EA=1;
ET0=1;
TR0=1;
//上电初始化一些关键的数据
Gu8Wd=1; //窗口1。开机默认处于正常工作的窗口
Gu8WdUpdate=1; //整屏更新变量
//跑马灯处于初始化的状态
P1_4=0; //第1个灯亮
P1_5=1; //第2个灯灭
P1_6=1; //第3个灯灭
P3_3=1; //第4个灯灭
//根据当前的速度档位Gu8RunSpeed，来初始化速度时间参数Gu16RunSpeedTimeDate
if(1==Gu8RunSpeed)
{
Gu16RunSpeedTimeDate=RUN_TIME_SLOW; //赋值“慢”档的时间参数
}
else if(2==Gu8RunSpeed)
{
Gu16RunSpeedTimeDate=RUN_TIME_MIDDLE; //赋值“中”档的时间参数
}
else
{
Gu16RunSpeedTimeDate=RUN_TIME_FAST; //赋值“快”档的时间参数
}
}
void Delay(unsigned long u32DelayTime)
{
for(;u32DelayTime>0;u32DelayTime--);
}
void PeripheralInitial(void)
{
}

复制代码

吴坚鸿 · 2018-7-24 11:16:14

本帖最后由 jianhong_wu 于 2018-8-5 08:54 编辑

第一百二十五节： “双线”的肢体接触通信。

【125.1 “双线”的肢体接触通信。】

   芯片之间通信，都离不开“数据信号”和“时钟信号”，缺一不可。“数据信号”和“时钟信号”是什么关系，它们是怎样相互配合来实现通信的功能？其实原理也很简单。打个比喻，甲乙两个人，规定只能靠一只“手”和一只“脚”进行肢体接触的通信，他们之间如何传输数据？“手”可以产生“两种”状态“握紧”和“松开”，“脚”可以产生“一种”状态“踢一脚”。他们之间约定，甲发送数据给乙，乙每被甲“踢一脚”就去记录一次手的状态是“握紧”还是“松开”，“握紧”代表二进制的0，“松开”代表二进制的1，这样，如果他们之间想传输一个字节的十六进制数据0x59，只需把十六进制的数据0x59展开成二进制01011001，从右到左（从低位到高位）以“位”为单位挨个发送，过程如下：
   第一次“踢一脚”：手的状态是“松开”，记录1。
   第二次“踢一脚”：手的状态是“握紧”，记录0。
   第三次“踢一脚”：手的状态是“握紧”，记录0。
   第四次“踢一脚”：手的状态是“松开”，记录1。
   第五次“踢一脚”：手的状态是“松开”，记录1。
   第六次“踢一脚”：手的状态是“握紧”，记录0。
   第七次“踢一脚”：手的状态是“松开”，记录1。
   第八次“踢一脚”：手的状态是“握紧”，记录0。
   上述肢体接触的通信过程，其实一只“手”就代表了一根“数据线”，可以产生高电平“1”和低电平“0”这两种状态，而一只“脚”代表了一根“时钟线”，但是“踢一脚”代表了“时钟线”上的一种什么状态呢？注意，“踢一脚”既不是高电平“1”也不是低电平“0”，而是瞬间只产生一次的“上升沿”或者“下降沿”。何谓“上升沿”何谓“下降沿”？“上升沿”是代表“时钟线从低电平跳变到高电平的瞬间”，“下升沿”是代表“时钟线从高电平跳变到低电平的瞬间”。“踢一脚”、“上升沿”、“下降沿”此三者都可以统一理解成“节拍”。
   芯片之间通信，“时钟信号”只需1个足矣，而“数据信号”却可以不止1个。1个“数据信号”往往叫“串行”通信，一个节拍只能传输1位数据。8个以上并列的“数据信号”往往叫“并行”通信，一个节拍能传输8位以上的数据。可见，并行的“数据信号”越多，传输的速率越快。
   常见的系统中，串口，IIC，SPI，USB，CAN这类都是“串行”通信。而32位单片机与外部的nandflash,norflash,sdram,sram这些芯片通信往往是“并行”通信，并行的数据信号多达8个16个甚至32个。
   本节标题之所以强调“双线”，是因为“手”代表数据线，“脚”代表时钟线，一共两条线因此为“双线”。现在把上述的肢体通信过程翻译成C语言代码，如下：

***it Hand_DATA=P2^6; //手的数据线
***it Foot_CLK=P2^7; //脚的时钟线
void SendByte(unsiged char u8Data) //肢体接触通信发送一个字节的数据的发送函数
{
static unsigned char i;
for(i=0;i<8;i++) //一个字节包含8个位数据，需要循环8次
{
if(0==(u8Data&0x01)) //根据数据的每一位状态，发送对应的位数据。
{
Hand_DATA=0; //0代表“握紧”
}
else
{
Hand_DATA=1; //1代表“松开”
}
Foot_CLK=1;
Delay(); //为产生均匀的脉冲节拍，时钟线的高电平先延时一会
Foot_CLK=0; //从高电平跳变到低电平，产生瞬间的“下降沿”，代表“踢一脚”
Delay(); //为产生均匀的脉冲节拍，时钟线的低电平先延时一会
u8Data=u8Data>>1; //右移一位，为即将发送下一位做准备
}
}

复制代码

吴坚鸿 · 2018-8-5 12:37:51

第一百二十六节： “单线”的肢体接触通信。

【126.1 同步通信与异步通信。】

   既然芯片之间通信离不开“数据”和“时钟”这两种信号，那么是不是说，通信必须至少两根线（双线）以上？不是。单线也可以通信，继续拿甲乙两人的肢体通信做比喻，这一次只允许用一只“手”不许用“脚”，“手”继续做数据信号，那么时钟信号在哪？时钟信号在甲乙两人各自的“心跳”。用两个人的“心跳”作为时钟信号就有两个时钟节拍，初学者可能在这里会有疑惑，这两人的“心跳”频率可能不一致，时钟节拍可能不同步，怎么能进行通信呢？说到这里，恰好通讯界有两个专业的概念，一个是“同步通信”另一个是“异步通信”。像上一节讲那种用脚的动作“踢一脚”作为时钟信号，这个时钟信号只有一个，对于通讯的甲乙双方是实时“同步的”时钟信号，因此这种通信叫做“同步通信”。而本节提到的用两个人各自的“心跳”做时钟信号，有两个时钟源，时钟信号是“不同步的”，这种通信叫做“异步通信”。

【126.2 异步通信的原理。】

   既然两人各自的“心跳”不同步（异步），而且“心跳”是从甲乙两人出生开始就一直持续存在不停跳动的，那么发送一个字节的数据是从什么时候开始到什么时候结束就必须事先有一个约定。他们是这样约定的：
   （一）平时的待命状态。甲是发送方，乙是接收方，平时待命没有发送数据的时候，甲手的状态一直是“松开”的（电平1）。
   （二）1个开始位与8个数据位。当甲要发送数据给乙的时候，第1个心跳甲先“握紧”（电平0）代表“开始位”，“开始位”用来通知乙方请做好接收数据的准备，然后第2个到第9个心跳甲依次靠手的状态发送8个位的字节数据（数据位），乙方因为“甲的开始位”的存在已经做好了接收第2个心跳数据的准备，因此乙方能完全接收第2个心跳至第9个心跳的数据位的数据。
   （三）1个停止位。甲发送了第9个心跳的数据后，必须马上恢复到待命的状态“松开”（电平1），以便为下一次发送数据时能正确发送“开始位”，但是这个待命的状态“松开”至少应该持续多长的时间呢？至少持续1个“心跳”的时间以上。这样，虽然两个人的“心跳”不同步并且频率也不一样，但是只要8个“心跳”的累加误差不超过1个“心跳”的停止位时间，数据就肯定不会错位。这个至少持续1个“心跳”的待命状态就起到消除累加误差的作用。

【126.3 异步的肢体通信的例子。】

   “手”可以产生“两种”状态“握紧”和“松开”，甲发送数据给乙，乙每“心跳”一次就去判断一次手的状态，“握紧”代表二进制的0，“松开”代表二进制的1，这样，如果他们之间想传输一个字节的十六进制数据0x59，只需把十六进制的数据0x59展开成二进制01011001，从右到左（从低位到高位）以“位”为单位挨个发送，过程如下：
   平时手的状态一直处于“松开”的待命状态，直到手第一次出现“握紧”的状态......
   第一次“心跳”：手的状态是“握紧”，开始位，通知乙作好接收即将过来的8个“心跳”数据位。
   第二次“心跳”：手的状态是“松开”，数据位bit0，记录1。
   第三次“心跳”：手的状态是“握紧”，数据位bit1，记录0。
   第四次“心跳”：手的状态是“握紧”，数据位bit2，记录0。
   第五次“心跳”：手的状态是“松开”，数据位bit3，记录1。
   第六次“心跳”：手的状态是“松开”，数据位bit4，记录1。
   第七次“心跳”：手的状态是“握紧”，数据位bit5，记录0。
   第八次“心跳”：手的状态是“松开”，数据位bit6，记录1。
   第九次“心跳”：手的状态是“握紧”，数据位bit7，记录0。
   第十次“心跳”：手的状态是“松开”，停止位，至少持续1个“心跳”的待命状态。
   现在把上述的“单线”（异步）的肢体通信过程翻译成C语言代码，甲发送数据的代码如下：

***it Hand_DATA=P2^6; //手的数据线
void SendByte(unsiged char u8Data) //甲发送数据的发送函数
{
static unsigned char i;
Hand_DATA=0; //开始位。0代表“握紧”
Delay(); //甲的心跳间隔时间
for(i=0;i<8;i++) //发送8个数据位
{
if(0==(u8Data&0x01)) //根据数据的每一位状态，发送对应的位数据。
{
Hand_DATA=0; //0代表“握紧”
}
else
{
Hand_DATA=1; //1代表“松开”
}
Delay(); //甲的心跳间隔时间
u8Data=u8Data>>1; //右移一位，为即将发送下一位做准备
}
Hand_DATA=1; //停止位。1代表“松开”
Delay(); //甲的心跳间隔时间
}

复制代码

尹兵 · 2018-8-8 13:50:30

谢谢老师能不能把学习文档打包发出来呀！

微笑、搁浅 · 2018-8-8 16:13:54

哈哈哈哈或或或或或或或

2003hjw · 2018-8-13 22:30:09

请教鸿哥，此功能是：用K1代表C这类“字符数字键”，用K2代表Ctrl这类“辅助按键”，因此，要触发组合键（K2+K1），必须先按住K2再按K1才有效。为什么程序不是先判断K2先是按下，再判断K1的动作，而是反过来编程？？

2003hjw · 2018-8-13 23:05:12

另外还请教i鸿哥，用K1与K2组成密码键：先按K1一次松手，再按一次K2松手,再按一次K2松手,再按一次K1松手的有顺序组成组合程序应该怎么写？

马冬亚 · 2018-8-16 14:35:32

看不同大神的书，每次看都会有收获，写书和录视频各有各的难处，这本书一开始看就感觉内容的整体规划跟程序的规划一样，条理清晰，简洁。篇幅简短，分节合理。非常不错。看起来也不觉的枯燥

吴坚鸿 · 2018-8-26 13:16:23

第一百二十七节：单片机串口接收数据的机制。

【127.1 单片机串口接收数据的底层时序。】

上一节“单线的肢体接触通信”其实是为本节打基础的，通信线只用了一根“数据”线，没有用到“时钟”线，属于异步通信方式，还分析时序中的“1个开始位，8个数据位，1个停止位”等细节内容，这些时序其实就是本节单片机串口通信的底层时序，一模一样。继续上一节的内容（很有必要重新温习一次上一节的异步通信原理），继续沿用甲乙双方靠各自“心跳”的节拍来异步通信的例子，本节单片机串口接收数据是代表乙方，我把乙方串口接收数据的过程翻译成C语言，代码如下：

***it USART_RX=P3^0; //用来接收串口数据的数据线
unsigned char Gu8ReceiveData=0; //串口接收到的8位数据
unsigned char i; //连续接收8位数据的循环变量
void main()
{
Gu8ReceiveData=0;
while(1)
{
USART_RX=1; //51单片机的规则，每次读取数据前都执行一条“置1”指令
Delay(); //乙的心跳间隔时间，待机时，每一个节拍监控一次数据线的状态
if(0==USART_RX) //如果监控到甲发送的“开始位0”，从下一个节拍开始连续接收8位数据
{
for(i=0;i<8;i++) //连续循环接收8个“数据位”
{
USART_RX=1; //51单片机的规则，每次读取数据前都执行一条“置1”指令
Delay(); //乙的心跳间隔时间，每个节拍判断读取一位数据
if(1==USART_RX) //判断读取数据线上的状态
{
Gu8ReceiveData=Gu8ReceiveData | 0x80;
}
else
{
Gu8ReceiveData=Gu8ReceiveData & 0x7F;
}
Gu8ReceiveData=Gu8ReceiveData>>1; //右移一位，为即将接收下一位做准备
}
Delay(); //乙的心跳间隔时间，这里额外增加一个节拍，作为“停止位”的开销。
}
}
}

复制代码

【127.2 单片机内置的“硬件串口模块”。】

   很显然，上面【127.1】分享的时序代码会占用单片机大量的时间，单片机每接收一个字节的数据都会被束缚一次手脚，耽误了其它大事，怎么办？为了把单片机从底层繁琐的时序中解放出来，单片机内置了很多“硬货”，俗称“硬件资源”，“硬件串口模块”便是其中之一。何谓“硬件”，单片机内置的“硬件”可以看作是另外一个独立运行的“核”，这个“核”可以看作是另外一个CPU，可以独立工作，相当于单片机主人在某个领域的一个专用助手。单片机只需要跟这个“核”通信发指令就可以，具体的执行过程由这个“核”独立去完成，这个“核”完成工作之后再把处理结果反馈给单片机。那么，单片机是如何跟这些内置“硬件资源”通信呢?其实它们的通信接口是“寄存器”，不管是单片机给“硬件资源”发送指令，还是单片机从“硬件资源”里读取所需要的结果数据，都是通过“寄存器”来完成。

【127.3 单片机与硬件串口通信的接口“寄存器”。】

   硬件串口的寄存器主要涉及：串口的方式选择，波特率，允许串口接收数据，中断的优先级，中断的允许，等等。比如，51单片机的串口是兼容很多种方式的，可以同步通信，也可以异步通信，异步通信还可以兼容10位（1开始位、8数据位、1停止），11位（1开始位、8数据位、1校验位、1停止），等等，这些就是多选题，我们要在某个特定的寄存器里面做出选择。波特率，是用来衡量通信的速度，比如波特率是9600，就意味着1秒钟能收发9600个二进制的位数据，也就是1秒钟能产生9600个时钟节拍，波特率越高通信的速度越快，这些也需要我们往相关的寄存器填入相应的数据，来告知“硬件串口”以哪种波特率进行通信。
   那么，对于初学者，寄存器如何配置呢？主要有这些思路：查看芯片手册（datasheet），产看C编译器的手册，查看芯片相关的C语言的头文件(比如51单片机的REG.H)，在网上参考别人已经配置好的代码，或者购买相关芯片的学习板时所配套的程序例程。
   本节用到的串口，是10位数据长度的异步通信，波特率9600，相关配置的代码如下：

unsigned char u8_TMOD_Temp=0;
//串口的波特率与内置的定时器1直接相关，因此配置此定时器1就等效于配置波特率。
u8_TMOD_Temp=0x20; //即将把定时器1设置为：工作方式2，初值自动重装的8位定时器。
TMOD=TMOD&0x0f; /此寄存器低4位是跟定时器0相关，高4位是跟定时器1相关。先清零定时器1。
TMOD=TMOD|u8_TMOD_Temp; //往高4位的定时器1填入0x2，低4位的定时器0保持不变。
TH1=256-(11059200L/12/32/9600); //波特率为9600。11059200代表晶振11.0592MHz，
TL1=256-(11059200L/12/32/9600); //L代表long的长类型数据。根据芯片手册提供的计算公式。
TR1=1; //开启定时器1
SM0=0;
SM1=1; //SM0与SM1的设置：选择10位异步通信，波特率根据定时器1可变
REN=1; //允许串口接收数据
//为了保证串口中断接收的数据不丢失，必须设置IP = 0x10，相当于把串口中断设置为最高优先级，
//这个时候，串口中断可以打断任何其他的中断服务函数，实现嵌套的功能，
IP =0x10; //把串口中断设置为最高优先级，必须的。
ES=1; //允许串口中断
EA=1; //允许总中断

复制代码

【127.4 硬件串口的中断函数。】

硬件串口接收完一个字节的数据之后，会及时产生一个串口中断去通知单片机接收数据。单片机在串口中断函数里直接读取“串口专用缓存寄存器”SBUF的数据，就可以直接获得一个完整的8位宽度的数据，省去了繁琐的驱动时序底层。
串口的中断函数跟定时器的中断函数很类似，只不过中断号不一样而已，比如我们前面章节用的定时器0的中断号是“1”，而本节串口的中断号是“4”。这些其实是C编译器定的游戏规则，我们只要根据它提供的数据手册遵守它的游戏规则就好了。串口中断函数里还有一个地方要注意，硬件串口“接收完一个字节”的数据后产生一次中断，而硬件串口“发送完一个字节”的数据后也产生一次中断，这两个一“收”一“发”的中断都是共用中断号为“4”的中断函数，因此，我们必须在中断函数里通过判断寄存器的RI和TI的标志位来判断到底是“收”的中断，还是“发”的中断，并且软件上要及时把RI或者TI及时清零，避免不断进入中断的情况。参考代码如下：

unsigned char Gu8ReceiveData=0; //接收到一个字节的数据
void usart(void) interrupt 4 //串口接发的中断，中断号为4
{
if(1==RI) //接收完一个字节后引起的中断
{
RI = 0; //及时清零，避免一直无缘无故的进入中断。
Gu8ReceiveData=SBUF; //直接读取“串口专用缓存寄存器”SBUF的8位数据。
}
else //发送数据引起的中断
{
TI = 0; //及时清除发送中断的标志，避免一直无缘无故的进入中断。
//以下可以添加一个全局变量的标志位的相关代码，通知主函数已经发送完一个字节的数据了。
}
}

复制代码

【127.5 上位机与单片机的串口通信例程。】


   上图127.5.1  灌入式驱动8个LED

   程序功能如下：
   波特率9600，校验位NONE（无），数据位8，停止位1。在上位机的串口助手里，发送一个十六进制（HEX模式）的01，让单片机的一颗LED“亮”。发送一个十六进制（HEX模式）的00，让单片机的一颗LED“灭”。上位机的串口助手的使用，请参考前面第11节的相关内容，或者自己在网上查找串口助手软件的使用方法，串口助手软件网上很多，我们的使用要求不高，随便选用一家都可以。代码如下：

#include "REG52.H"
void usart(void);
***it P0_0=P0^0; //一颗LED灯
unsigned char Gu8ReceiveData=0; //接收到一个字节的数据
void main()
{
unsigned char u8_TMOD_Temp=0;
P0_0=1; //LED灭。1代表LED灭， 0代表亮
//串口的波特率与内置的定时器1直接相关，因此配置此定时器1就等效于配置波特率。
u8_TMOD_Temp=0x20; //即将把定时器1设置为：工作方式2，初值自动重装的8位定时器。
TMOD=TMOD&0x0f; //此寄存器低4位是跟定时器0相关，高4位是跟定时器1相关。先清零定时器1。
TMOD=TMOD|u8_TMOD_Temp; //把高4位的定时器1填入0x2，低4位的定时器0保持不变。
TH1=256-(11059200L/12/32/9600); //波特率为9600。11059200代表晶振11.0592MHz，
TL1=256-(11059200L/12/32/9600); //L代表long的长类型数据。根据芯片手册提供的计算公式。
TR1=1; //开启定时器1
SM0=0;
SM1=1; //SM0与SM1的设置：选择10位异步通信，波特率根据定时器1可变
REN=1; //允许串口接收数据
//为了保证串口中断接收的数据不丢失，必须设置IP = 0x10，相当于把串口中断设置为最高优先级，
//这个时候，串口中断可以打断任何其他的中断服务函数实现嵌套，
IP =0x10; //把串口中断设置为最高优先级，必须的。
ES=1; //允许串口中断
EA=1; //允许总中断
while(1) //主循环
{
}
}
void usart(void) interrupt 4 //串口接发的中断函数，中断号为4
{
if(1==RI) //接收完一个字节后引起的中断
{
RI = 0; //及时清零，避免一直无缘无故的进入中断。
Gu8ReceiveData=SBUF; //直接读取“串口专用缓存寄存器”SBUF的8位数据。
if(0x01==Gu8ReceiveData)
{
P0_0=0; //LED亮。1代表LED灭， 0代表亮
}
else
{
P0_0=1; //LED灭。1代表LED灭， 0代表亮
}
}
else //发送数据引起的中断
{
TI = 0; //及时清除发送中断的标志，避免一直无缘无故的进入中断。
//以下可以添加一个全局变量的标志位的相关代码，通知主函数已经发送完一个字节的数据了。
}
}

复制代码

【127.6 单片机串口电路的简易分析。】

   上图127.6.1  232串口电路

      单片机串口对外的引脚是与IO口的“P3.1、P3.0”共用的。P3.1是串口的TX引脚，即对外发送数据的引脚。P3.0是串口的RX引脚，即接收外部数据的引脚。一旦项目中用了串口，那么这两个引脚就必须“专脚专用”，只给串口单独使用，不再做IO口。平时通信的时候，跟其它单片机或者系统进行串口通信，除了接TX和RX这两根数据线之外，必须一定把双方的负极GND也“共地”接上，否则双方建立不了同样的电压参考点，通信毕然失败。因此，串口通信最低标配是3根线：RX,TX,GND。
      如果两个甲乙单片机都布在一块板子上，距离不超过半米，他们两个要进行串口通信，怎么接线？把他们的GND连起来，然后RX与TX“交叉”对接，甲的RX接到乙的TX，甲的TX接到乙的RX。这种在短距离通信的时候，不用增加任何外部辅助压差信号放大芯片，这种方式叫做“串口的TTL”接线方式。
      如果两个系统串口通信的距离比较远，比如在不同的板子上，1米以上10米以下的距离，这时就不能采用原始的“串口的TTL”接线方式，因为线缆越长电阻越大，本身就要消耗一些压降，而3.3V的压降很容易就会被消耗完，通信的可靠度和抗扰能力就会降低。为了解决这个问题，可以引用232标准的接线方式，外部需接一个压差放大的芯片，把从原来3.3V的压差放大到一两倍左右，通信的距离就大大提高。具体232的细节，大家可以网上搜搜“RS232”。注意，采用232协议通信，也要注意“共地”和数据线“交叉”的两个问题，232通信的最低标配也是3根线：R,T,GND。上图SP232E就是一个压差信号放大的通信专用芯片。

搜索历史

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

相关推荐

678 条评论

评论

精选推荐

热门帖

站长推荐 /6