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

单片机

王工 · 2018-4-18 11:33:55

感谢分享，万分感谢

*582*^#

提示: 该帖被管理员或版主屏蔽

王工 · 2018-4-18 13:36:45

不错，下载下来看看

吴坚鸿 · 2018-4-22 11:43:03

第一百一十五节：按键控制数码管的秒表。

【115.1 按键控制数码管的秒表。】

            上图115.1.1  数码管


            上图115.1.2  独立按键

   本节通过一个秒表的小项目，让大家学会以下4个知识点：
   （1）上层的界面显示框架几乎都要用到更新变量，更新变量包括整屏更新和局部更新，本节只用到整屏更新。更新变量是用全局变量在函数之间传递信息。作用是，当有某个需要显示的数据发生改变的时候，就要给更新变量置1，让显示函数重新更新一次显示，确保最新的数据能及时显示出来，平时没有数据更新改变的时候不用频繁更新显示避免占用CPU过多的时间。
   （2）凡是需要显示数字的地方，都必须涉及如何把一个数据按“个十百千万...”的位逐个提取出来的算法。这个算法比较简单，主要用“求余”和“求商”这两个运算语句就可以随心所欲的把数据位提取出来。除此之外，还要学会如何用if语句判断数据的范围，来把高位尚未用到的某个数码管屏蔽，让该位数码管只显示一个“不显示”的数据（避免直接显示一个0）。
   （3）我常把单片机程序简化成4个代表：按键（人机输入），数码管（人机界面），跑马灯（应用程序），串口（通信）。本节的“应用程序”不是跑马灯，而是秒表。不管是跑马灯，还是秒表，都要用到一个总启动Gu8RunStart和一个总运行步骤Gu8RunStep。建议大家，总启动Gu8RunStart和总运行步骤Gu8RunStep应该成双成对的出现（这样关断响应更及时，并且结构更紧凑，漏洞更少），比如，凡是总启动Gu8RunStart发生改变的时候，总运行步骤Gu8RunStep都复位归零一下。
   （4）一个硬件的定时器中断，可以衍生出N个软件定时器，之前跟大家介绍的是“递减式”的软件定时器，而且实际应用中，“递减式”的软件定时器也是用得最多。本节因为项目的需要，需要用到的是“累加式”的软件定时器。不管是哪种软件定时器，大家都要注意定时器变量在定义时所用到的数据类型，这个数据类型决定了定时时间的长度，比如在51单片机中，unsigned int的范围是0到65535，最大一次性定时65.535秒。而unsigned long的范围是0到4294967295，最大一次性定时4294967.295秒。本节秒表的时间超过65.535秒，因此需要用到unsigned long类型的定时器变量。
本节秒表程序的功能：K1按键是复位按键，每按一次，秒表都停止并且重新归零。K2按键是启动和暂停按键，当秒表处于复位后停止的状态时按一次则开始启动，当秒表处于正在工作的状态时按一次则处于暂停状态，当秒表处于暂停的状态时按一次则继续处于工作的状态。本节4位数码管，显示的时间是带2位小数点的，能显示的时间范围是：0.00秒到99.99秒。代码如下：

#include "REG52.H"
#define KEY_FILTER_TIME 25
#define SCAN_TIME 1
void T0_time();
void SystemInitial(void) ;
void Delay(unsigned long u32DelayTime) ;
void PeripheralInitial(void) ;
void KeyScan(void);
void KeyTask(void);
void DisplayScan(void); //底层显示的驱动函数
void DisplayTask(void); //上层显示的任务函数
void RunTask(void); //秒表的应用程序
***it KEY_INPUT1=P2^2;
***it KEY_INPUT2=P2^1;
***it P1_0=P1^0;
***it P1_1=P1^1;
***it P1_2=P1^2;
***it P1_3=P1^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
};
//数码管底层驱动扫描的软件定时器
volatile unsigned char vGu8ScanTimerFlag=0;
volatile unsigned int vGu16ScanTimerCnt=0;
//秒表的软件定时器，注意，这里是unsigned long类型，范围是0到4294967295毫秒
volatile unsigned char vGu8StopWatchTimerFlag=0;
volatile unsigned long vGu32StopWatchTimerCnt=0;
//数码管上层每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代表正在工作中，2代表暂停
unsigned char Gu8WdUpdate=1; //开机默认整屏更新一次显示。此变量在显示框架中是非常重要的变量
volatile unsigned char vGu8Display_Righ_4=10; //开机默认最高位数码管显示一个“不显示”数据
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 KeyTask(void) //按键的任务函数
{
if(0==vGu8KeySec)
{
return;
}
switch(vGu8KeySec)
{
case 1: //复位按键
Gu8RunStatus=0; //秒表返回停止的状态
Gu8RunStart=0; //秒表停止
Gu8RunStep=0; //总运行步骤归零。建议跟vGu8RunStart成双成对出现
vGu8StopWatchTimerFlag=0;
vGu32StopWatchTimerCnt=0; //秒表的软件定时器清零
Gu8WdUpdate=1; //整屏更新一次显示
vGu8KeySec=0;
break;
case 2: //启动与暂停的按键
if(0==Gu8RunStatus) //在停止状态下
{
Gu8RunStatus=1; //秒表处于工作状态
vGu8StopWatchTimerFlag=0;
vGu32StopWatchTimerCnt=0;
vGu8StopWatchTimerFlag=1; //启动秒表的软件定时器
Gu8RunStart=1; //秒表总开关启动
Gu8RunStep=0; //总运行步骤归零。建议跟vGu8RunStart成双成对出现
}
else if(1==Gu8RunStatus) //在工作状态下
{
Gu8RunStatus=2; //秒表处于暂停状态
}
else //在暂停状态下
{
Gu8RunStatus=1; //秒表处于工作状态
}
Gu8WdUpdate=1; //整屏更新一次显示，确保在暂停的时候能显示到最新的数据
vGu8KeySec=0;
break;
}
}
void DisplayTask(void) //数码管显示的上层任务函数
{
//需要借用的中间变量，用来拆分数据位
static unsigned char Su8Temp_4,Su8Temp_3,Su8Temp_2,Su8Temp_1; //需要借用的中间变量
/* 注释一：
* 此处为什么要多加4个中间过渡变量Su8Temp_X？是因为vGu32StopWatchTimerCnt分解数据的时候
* 需要进行除法和求余数的运算，就会用到好多条指令，就会耗掉一点时间，类似延时了一会。我们
* 的定时器每隔一段时间都会产生中断，然后在中断里驱动数码管显示，当vGu32StopWatchTimerCnt
* 还没完全分解出4位有效数据时，这个时候来的定时中断，就有可能导致显示的数据瞬间产生不完整,
* 影响显示效果。因此，为了把需要显示的数据过渡最快，所以采取了先分解，再过渡显示的方法。
*/
if(1==Gu8WdUpdate) //如果需要整屏更新
{
Gu8WdUpdate=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
//先分解数据
//Su8Temp_4提取“十秒”位。
Su8Temp_4=vGu32StopWatchTimerCnt/10000; //实际精度是0.0001秒,但显示精度是0.01秒
Su8Temp_4=Su8Temp_4%10;
//Su8Temp_3提取“个秒”位。
Su8Temp_3=vGu32StopWatchTimerCnt/1000; //实际精度是0.0001秒,但显示精度是0.01秒
Su8Temp_3=Su8Temp_3%10;
//Su8Temp_2提取“百毫秒”位。
Su8Temp_2=vGu32StopWatchTimerCnt/100; //实际精度是0.0001秒,但显示精度是0.01秒
Su8Temp_2=Su8Temp_2%10;
//Su8Temp_1提取“十毫秒”位。
Su8Temp_1=vGu32StopWatchTimerCnt/10; //实际精度是0.0001秒,但显示精度是0.01秒
Su8Temp_1=Su8Temp_1%10;
//判断数据范围，来决定最高位数码管是否需要显示。
if(vGu32StopWatchTimerCnt<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 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; //整屏更新一次显示当前秒表的时间
}
break;
}
}
void KeyScan(void) //按键底层的驱动扫描函数，放在定时中断函数里
{
static unsigned char Su8KeyLock1;
static unsigned int Su16KeyCnt1;
static unsigned char Su8KeyLock2;
static unsigned int Su16KeyCnt2;
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;
}
}
}
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 T0_time() interrupt 1
{
KeyScan(); //按键底层的驱动扫描函数
DisplayScan(); //数码管底层的驱动扫描函数
if(1==vGu8ScanTimerFlag&&vGu16ScanTimerCnt>0)
{
vGu16ScanTimerCnt--; //递减式的软件定时器
}
//每10ms就定时更新一次显示的软件定时器
if(1==vGu8UpdateTimerFlag&&vGu16UpdateTimerCnt>0)
{
vGu16UpdateTimerCnt--; //递减式的软件定时器
}
//秒表实际走的时间的软件定时器，注意，这里是“累加式”的软件定时器
if(1==vGu8StopWatchTimerFlag&&1==Gu8RunStatus) //秒表处于工作的状态
{
vGu32StopWatchTimerCnt++; //累加式的软件定时器
}
TH0=0xfc;
TL0=0x66;
}
void SystemInitial(void)
{
P0=0x00;
P1_0=1;
P1_1=1;
P1_2=1;
P1_3=1;
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-4-23 22:36:58

jianhong_wu 发表于 2018-4-22 11:43
第一百一十五节：按键控制数码管的秒表。

【115.1 按键控制数码管的秒表。】

鸿哥，我想问一下，我现在开始学习单片机，我是从你之前的连载中学习呢，还是看这个基础呢

吴坚鸿 · 2018-4-30 11:47:29

第一百一十六节：按键控制数码管的倒计时。

【116.1 按键控制数码管的倒计时。】

            上图116.1.1  数码管



            上图116.1.2  独立按键


            上图116.1.3  有源蜂鸣器

   上一节讲“累加式”的秒表，这一节讲“递减式”的倒计时。通过此小项目，加深理解在显示框架中常用的更新变量（整屏更新和局部更新），以及应用程序与按键是如何关联的框架。同时，在拆分“个十百千万...”的时候，有一处地方必须注意，“先整除后求余”必须用一行代码一气呵成，不能拆分成两行代码“先整除；后求余”，否则会有隐患会有bug。除非，把四个临时变都改成unsigned long类型。上一节在此处残留了一个bug我发帖后还来不及修改过来，敬请大家注意。比如：

      以下这样是对的：

static unsigned char Su8Temp_1;
Su8Temp_1=vGu32CountdownTimerCnt/10%10; //一气呵成，没毛病。

复制代码

以下这样是有隐患有bug的（除非把Su8Temp_1改成unsigned long类型）：

static unsigned char Su8Temp_1;
Su8Temp_1=vGu32CountdownTimerCnt/10;
Su8Temp_1=Su8Temp_1%10; //拆分成两行代码后，有隐患有bug。数据溢出的原因引起。

复制代码

本节倒计时程序的功能：K1按键是复位按键，每按一次，倒计时停止并且重新恢复初始值10.00秒。K2按键是启动按键，当秒表处于复位后停止的状态时按一次则开始启动倒计时，当倒计时变为0.00秒的时候，蜂鸣器发出一次“滴”的提示声。此时，如果想启动新一轮的倒计时，只需按一次K1复位键，然后再按K2启动按键，就可以启动新一轮10.00秒的倒计时。代码如下：

#include "REG52.H"
#define KEY_FILTER_TIME 25
#define SCAN_TIME 1
#define VOICE_TIME 50 //蜂鸣器一次“滴”的声音长度 50ms
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 BeepOpen(void);
void BeepClose(void);
***it KEY_INPUT1=P2^2;
***it KEY_INPUT2=P2^1;
***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
};
//数码管底层驱动扫描的软件定时器
volatile unsigned char vGu8ScanTimerFlag=0;
volatile unsigned int vGu16ScanTimerCnt=0;
//倒计时的软件定时器，注意，这里是unsigned long类型，范围是0到4294967295毫秒
volatile unsigned char vGu8CountdownTimerFlag=0;
volatile unsigned long vGu32CountdownTimerCnt=10000; //开机默认显示初始值10.000秒
//数码管上层每10ms就定时刷新一次显示的软件定时器。用于及时更新显示秒表当前的实时数值
volatile unsigned char vGu8UpdateTimerFlag=0;
volatile unsigned int vGu16UpdateTimerCnt=0;
//蜂鸣器的软件定时器
volatile unsigned char vGu8BeepTimerFlag=0;
volatile unsigned int vGu16BeepTimerCnt=0;
unsigned char Gu8RunStart=0; //应用程序的总启动
unsigned char Gu8RunStep=0; //应用程序的总运行步骤。建议跟vGu8RunStart成双成对出现
unsigned char Gu8RunStatus=0; //当前倒计时的状态。0代表停止，1代表正在工作中
unsigned char Gu8WdUpdate=1; //开机默认整屏更新一次显示。此变量在显示框架中是非常重要的变量
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 KeyTask(void) //按键的任务函数
{
if(0==vGu8KeySec)
{
return;
}
switch(vGu8KeySec)
{
case 1: //复位按键
Gu8RunStatus=0; //倒计时返回停止的状态
Gu8RunStart=0; //倒计时的运行步骤的停止
Gu8RunStep=0; //总运行步骤归零。建议跟vGu8RunStart成双成对出现
vGu8CountdownTimerFlag=0; //禁止倒计时开始(而Gu8RunStart是启动开关，不矛盾)
vGu32CountdownTimerCnt=10000; //倒计时的软件定时器恢复初始值10.000秒
Gu8WdUpdate=1; //整屏更新一次显示
vGu8KeySec=0;
break;
case 2: //启动的按键
if(0==Gu8RunStatus) //在停止状态下
{
vGu8CountdownTimerFlag=0;
vGu32CountdownTimerCnt=10000; //初始值是10.000秒
vGu8CountdownTimerFlag=1; //允许倒计时的软件定时器的启动
Gu8RunStatus=1; //倒计时处于工作状态（并且，这一瞬间才正式启动倒计时）
Gu8RunStart=1; //倒计时的运行步骤的总开关开启
Gu8RunStep=0; //总运行步骤归零。建议跟vGu8RunStart成双成对出现
Gu8WdUpdate=1; //整屏更新一次显示，确保在启动的时候能显示到最新的数据
}
vGu8KeySec=0;
break;
}
}
void DisplayTask(void) //数码管显示的上层任务函数
{
//需要借用的中间变量，用来拆分数据位。
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 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 KeyScan(void) //按键底层的驱动扫描函数，放在定时中断函数里
{
static unsigned char Su8KeyLock1;
static unsigned int Su16KeyCnt1;
static unsigned char Su8KeyLock2;
static unsigned int Su16KeyCnt2;
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;
}
}
}
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--; //递减式的软件定时器
}
//每10ms就定时更新一次显示的软件定时器
if(1==vGu8UpdateTimerFlag&&vGu16UpdateTimerCnt>0)
{
vGu16UpdateTimerCnt--; //递减式的软件定时器
}
//倒计时实际走的时间的软件定时器，注意，这里还附加了启动状态的条件“&&1==Gu8RunStatus”
if(1==vGu8CountdownTimerFlag&&vGu32CountdownTimerCnt>0&&1==Gu8RunStatus)
{
vGu32CountdownTimerCnt--; //递减式的软件定时器
}
TH0=0xfc;
TL0=0x66;
}
void SystemInitial(void)
{
P0=0x00;
P1_0=1;
P1_1=1;
P1_2=1;
P1_3=1;
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-5-4 20:43:21

都是精华，谢谢分享，辛苦了楼主。

郁郁葱葱梓 · 2018-5-4 20:44:48

都是精华，谢谢分享，辛苦了楼主。

陈亮 · 2018-5-5 17:01:31

支持，学习了。。。。。

xiang3245756 · 2018-5-9 14:47:53

感谢吴老师的分享，受益匪浅

吴坚鸿 · 2018-5-12 10:33:19

第一百一十七节：按键切换数码管窗口来设置参数。

【117.1 按键切换数码管窗口来设置参数。】

            上图117.1.1  数码管


            上图117.1.2  独立按键


            上图117.1.3  有源蜂鸣器

      单片机是“数据”驱动型的。按什么逻辑跑，以什么方式跑，都是“数据”决定的。人机交互的核心就是“人”以什么渠道去更改“机”内部的某些“数据”。在程序框架层面，按键更改或者编辑某些数据，我的核心思路都是“在某个窗口下去更改某个特定的数据”，如果某个窗口的数据很多，就需要在此窗口下进一步细分，细分为“某个窗口下的某个局部（子菜单、光标选择）”。可见，“窗口”是支点，“局部”是支点中再细分出来的支点。窗口对应一个名叫 “窗口选择”的全局变量Gu8Wd，局部（子菜单、光标选择）对应一个名叫“局部选择”的全局变量Gu8Part。数据发生变化的时候，才需要更新显示到数码管上，平时不用一直更新显示，因此，与“窗口选择”Gu8Wd还对应一个名叫“整屏更新”的全局变量Gu8WdUpdate，与“局部选择”Gu8Part还对应一个名叫“局部更新”的全局变量Gu8PartUpdate。本节的小项目程序只用到“窗口”，没有用到“局部”。
      本节小项目的程序功能，利用按键与数码管的人机交互，可以对单片机内部三个参数Gu8SetData_1，Gu8SetData_2，Gu8SetData_3进行编辑。这三个参数分别在三个窗口下进行编辑，这三个窗口是数码管显示“1-XX”，“2-YY”，“3-ZZ”。其中，XX代表Gu8SetData_1数据，YY代表Gu8SetData_2数据，ZZ代表Gu8SetData_3数据，这三个数据的范围是从0到99。K1是窗口切换按键，每按一次，窗口会在“1-XX”，“2-YY”，“3-ZZ”三个窗口之间进行切换。K2是数字累加按键，每按一次，显示的数字会累加1。K3是数字递减按键，每按一次，显示的数字会递减1。代码如下：

#include "REG52.H"
#define KEY_FILTER_TIME 25
#define SCAN_TIME 1
#define VOICE_TIME 50
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显示函数
void Wd2(void); //窗口2显示函数
void Wd3(void); //窗口3显示函数
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;
unsigned char Gu8SetData_1=0; //单片机内部第1个可编辑的参数
unsigned char Gu8SetData_2=0; //单片机内部第2个可编辑的参数
unsigned char Gu8SetData_3=0; //单片机内部第3个可编辑的参数
unsigned char Gu8Wd=1; //窗口选择变量。人机交互程序框架的支点。初始化开机后显示第1个窗口。
unsigned char Gu8WdUpdate=1; //整屏更新变量。初始化为1开机后整屏更新一次显示。
volatile unsigned char vGu8Display_Righ_4=1; //显示窗口“1”
volatile unsigned char vGu8Display_Righ_3=11; //显示横杠“-”
volatile unsigned char vGu8Display_Righ_2=0; //显示十位数值“0”
volatile unsigned char vGu8Display_Righ_1=0; //显示个位数值“0”
volatile unsigned char vGu8Display_Righ_Dot_4=0;
volatile unsigned char vGu8Display_Righ_Dot_3=0;
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: //窗口切换的按键
Gu8Wd++; //窗口切换到下一个窗口
if(Gu8Wd>3) //一共3个窗口。切换第3个窗口之后，继续返回到第1个窗口
{
Gu8Wd=1; //返回到第1个窗口
}
Gu8WdUpdate=1; //整屏更新一次显示
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=VOICE_TIME; //蜂鸣器发出“滴”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0;
break;
case 2: //累加的按键
switch(Gu8Wd) //以窗口选择Gu8Wd为支点，去编辑对应的数据。又一次用到switch语句
{
case 1: //在第1个窗口下编辑Gu8SetData_1数据
Gu8SetData_1++;
if(Gu8SetData_1>99) //把最大范围限定在99
{
Gu8SetData_1=99;
}
Gu8WdUpdate=1; //整屏更新一次显示
break;
case 2: //在第2个窗口下编辑Gu8SetData_2数据
Gu8SetData_2++;
if(Gu8SetData_2>99) //把最大范围限定在99
{
Gu8SetData_2=99;
}
Gu8WdUpdate=1; //整屏更新一次显示
break;
case 3: //在第3个窗口下编辑Gu8SetData_3数据
Gu8SetData_3++;
if(Gu8SetData_3>99) //把最大范围限定在99
{
Gu8SetData_3=99;
}
Gu8WdUpdate=1; //整屏更新一次显示
break;
}
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=VOICE_TIME; //蜂鸣器发出“滴”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0;
break;
case 3: //递减的按键
switch(Gu8Wd) //以窗口选择Gu8Wd为支点，去编辑对应的数据。又一次用到switch语句
{
case 1: //在第1个窗口下编辑Gu8SetData_1数据
if(Gu8SetData_1>0) //把最小范围限定在0
{
Gu8SetData_1--;
}
Gu8WdUpdate=1; //整屏更新一次显示
break;
case 2: //在第2个窗口下编辑Gu8SetData_2数据
if(Gu8SetData_2>0) //把最小范围限定在0
{
Gu8SetData_2--;
}
Gu8WdUpdate=1; //整屏更新一次显示
break;
case 3: //在第3个窗口下编辑Gu8SetData_3数据
if(Gu8SetData_3>0) //把最小范围限定在0
{
Gu8SetData_3--;
}
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;
case 3:
Wd3(); //窗口3显示函数
break;
}
}
void Wd1(void) //窗口1显示函数
{
//需要借用的中间变量，用来拆分数据位。
static unsigned char Su8Temp_4,Su8Temp_3,Su8Temp_2,Su8Temp_1; //需要借用的中间变量
if(1==Gu8WdUpdate) //如果需要整屏更新
{
Gu8WdUpdate=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
Su8Temp_4=1; //窗口“1”
Su8Temp_3=11; //横杠“-”
Su8Temp_2=Gu8SetData_1/10%10; //十位数值
Su8Temp_1=Gu8SetData_1/1%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=0;
vGu8Display_Righ_Dot_2=0;
vGu8Display_Righ_Dot_1=0;
}
}
void Wd2(void) //窗口2显示函数
{
//需要借用的中间变量，用来拆分数据位。
static unsigned char Su8Temp_4,Su8Temp_3,Su8Temp_2,Su8Temp_1; //需要借用的中间变量
if(1==Gu8WdUpdate) //如果需要整屏更新
{
Gu8WdUpdate=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
Su8Temp_4=2; //窗口“2”
Su8Temp_3=11; //横杠“-”
Su8Temp_2=Gu8SetData_2/10%10; //十位数值
Su8Temp_1=Gu8SetData_2/1%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=0;
vGu8Display_Righ_Dot_2=0;
vGu8Display_Righ_Dot_1=0;
}
}
void Wd3(void) //窗口3显示函数
{
//需要借用的中间变量，用来拆分数据位。
static unsigned char Su8Temp_4,Su8Temp_3,Su8Temp_2,Su8Temp_1; //需要借用的中间变量
if(1==Gu8WdUpdate) //如果需要整屏更新
{
Gu8WdUpdate=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
Su8Temp_4=3; //窗口“3”
Su8Temp_3=11; //横杠“-”
Su8Temp_2=Gu8SetData_3/10%10; //十位数值
Su8Temp_1=Gu8SetData_3/1%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=0;
vGu8Display_Righ_Dot_2=0;
vGu8Display_Righ_Dot_1=0;
}
}
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--; //递减式的软件定时器
}
TH0=0xfc;
TL0=0x66;
}
void SystemInitial(void)
{
P0=0x00;
P1_0=1;
P1_1=1;
P1_2=1;
P1_3=1;
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-5-13 17:04:53

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

【94.1 组合按键。】

这样在触发组合按键的时候也应该同时会触发单个按键，应该要组合按键时不触发单个按键

JRui · 2018-5-14 13:00:12

真是牛人啊，童鞋学习了

李会全 · 2018-5-16 22:22:58

第一：吴先生的程序，都是实战的结晶，貌似简单无用，其实内涵深刻，如果初学者能做到举一反三，闻一知十，就能如虎添翼。第二：特别是开篇的知识点提示和结束语，都能起到画龙点睛的作用。第三：他的程序和知识点有一定的不厌其烦的重复性，让初学者在接触新知识点时，又能温故，我认为这是吴先生的有意为之，用意良苦。第四：表面上看吴先生的程序有些冗余，其实代码也在不自觉的渗透者反复中的逻辑伸展，让初学者自然会将代码延伸到下一个逻辑。第五：吴先生将一个问题用多种手段刻划，让初学者能够更立体多层次的理解处理问题的方法。第六：吴先生的变量定义保留了一定的相对稳定性，对于初学者读程序带来了不少方便性。第七：我认为吴先生的程序深得哲学的精髓，越是这样初学者更要努力，不厌其烦的反复的读程序，在读程序的同时深刻领会领悟吴先生深刻的架构思想。第八：吴先生的程序里没有新奇的语法，就像简单的说明文一样，平铺直叙，没有辞藻堆砌，可是却能直抒胸臆，简单的语法是神，能灵活运用简单的语法那是大神。第九：吴先生能做到无私，把自己在实际工程业务创造中所积累的经验贡献给大家，真的难能可贵！第十：期盼吴先生能继续不遗余力的给大家贡献力作，真的很感谢吴先生！祝技术精进生意兴隆！

吴坚鸿 · 2018-5-17 11:08:33

lihuiquan315 发表于 2018-5-16 22:22
第一：吴先生的程序，都是实战的结晶，貌似简单无用，其实内涵深刻，如果初学者能做到举一反三，闻一知十，就能如虎添翼。第二：特别是开篇的知识点提示和结束语，都能起到画龙点睛的作用。第三：他的程序和知识点有一定的不厌其烦的重复性，让初学者在接触新知识点时，又能温故，我认为这是吴先生的有意为之，用意良苦。第 ...

看到你的回复。感觉挺感动。谢谢。

wenwq · 2018-5-21 14:28:06

先收着，感谢！！！！！！！！！！！

李谢 · 2018-5-22 16:27:42

虽然具体的代码有些地方还是不太懂，或者说让我写肯定写不出来，但是基本了解楼主思路了，要想把单片机玩溜，挖掘单片机的计算力潜能，就要学好框架思维，定时器，switch语句，受益匪浅，能全部消化掉单片机也就算毕业了

，感谢楼主无私奉献

吴坚鸿 · 2018-5-29 10:02:13

第一百一十八节：按键让某位数码管闪烁跳动来设置参数。

【118.1 按键让某位数码管闪烁跳动来设置参数。】

            上图118.1.1  数码管

            上图118.1.2  独立按键


            上图118.1.3  有源蜂鸣器

   当一个窗口只有一个数据的时候，只需以“窗口”为支点，切换到某个窗口下去设置某个数据即可。但是，当某个窗口有几个数据时，就必须在以“窗口”为支点的前提下，再细分出一个二级的支点，这个二级支点就是“局部”（或者称为子菜单）。“窗口”对应一个“窗口选择”的全局变量Gu8Wd，“局部”对应一个“局部选择”的全局变量Gu8Part。数据需要更新显示输出到屏幕（数码管）时，有两种更新方式，一种是“整屏更新”，另一种是“局部更新”。“整屏更新”只有一个整屏的更新变量Gu8WdUpdate，而“局部更新”有N个更新变量Gu8PartUpdate_x（Gu8PartUpdate_1，Gu8PartUpdate_2，Gu8PartUpdate_3），一个窗口下有多少个数据就存在多少个局部的更新变量Gu8PartUpdate_x，这些局部的更新变量在不同的窗口下是可以共用的。当某个局部被选中的时候，可以有很多种表现方式，比如在液晶屏上，常见的有光标跳动，某行文字的底色变色（反显），本节例程用的数码管，当某个局部被选中的时候，用某位数码管闪烁跳动的方式。
   本节小项目的程序功能，在一个窗口下，对单片机内部四个参数Gu8SetData_4，Gu8SetData_3，Gu8SetData_2，Gu8SetData_1进行编辑。这四个参数的范围是从0到9，从左到右分别显示在四位数码管上，每一位数码管对应一个数据。比如左起第1位是Gu8SetData_4，左起第2位是Gu8SetData_3，左起第3位是Gu8SetData_2，左起第4位是Gu8SetData_1。K1是局部选择的切换按键，每按一次，数码管从左到右，依次闪烁跳动，表示某个数据被选中。K2是数字累加按键，每按一次，闪烁跳动的数字会累加1。K3是数字递减按键，每按一次，闪烁跳动的数字会递减1。代码如下：

#include "REG52.H"
#define KEY_FILTER_TIME 25
#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显示函数
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 char Gu8SetData_4=0; //单片机内部第4个可编辑的参数
unsigned char Gu8SetData_3=0; //单片机内部第3个可编辑的参数
unsigned char Gu8SetData_2=0; //单片机内部第2个可编辑的参数
unsigned char Gu8SetData_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=0; //左起第1位初始化显示数值“0”
volatile unsigned char vGu8Display_Righ_3=0; //左起第2位初始化显示数值“0”
volatile unsigned char vGu8Display_Righ_2=0; //左起第3位初始化显示数值“0”
volatile unsigned char vGu8Display_Righ_1=0; //左起第4位初始化显示数值“0”
volatile unsigned char vGu8Display_Righ_Dot_4=0;
volatile unsigned char vGu8Display_Righ_Dot_3=0;
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 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 KeyTask(void) //按键的任务函数
{
if(0==vGu8KeySec)
{
return;
}
switch(vGu8KeySec)
{
case 1: //局部切换的按键
switch(Gu8Wd) //在某个窗口下
{
case 1: //在窗口1下
//以下之所以有两个PartUpdate(Gu8Part)，是因为相邻的两个局部发生了变化。
PartUpdate(Gu8Part); //切换之前的局部进行更新。
Gu8Part++; //切换到下一个局部
if(Gu8Part>4)
{
Gu8Part=0;
}
PartUpdate(Gu8Part); //切换之后的局部进行更新。
break;
}
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=VOICE_TIME; //蜂鸣器发出“滴”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0;
break;
case 2: //累加的按键
switch(Gu8Wd) //在某个窗口下
{
case 1: //在窗口1下
switch(Gu8Part) //二级支点的局部选择
{
case 1: //局部1被选中，代表左起第1位数据Gu8SetData_4被选中。
Gu8SetData_4++;
if(Gu8SetData_4>9)
{
Gu8SetData_4=9;
}
PartUpdate(Gu8Part); //当前局部更新显示输出到数码管
break;
case 2: //局部2被选中，代表左起第2位数据Gu8SetData_3被选中。
Gu8SetData_3++;
if(Gu8SetData_3>9)
{
Gu8SetData_3=9;
}
PartUpdate(Gu8Part); //当前局部更新显示输出到数码管
break;
case 3: //局部3被选中，代表左起第3位数据Gu8SetData_2被选中。
Gu8SetData_2++;
if(Gu8SetData_2>9)
{
Gu8SetData_2=9;
}
PartUpdate(Gu8Part); //当前局部更新显示输出到数码管
break;
case 4: //局部4被选中，代表左起第4位数据Gu8SetData_1被选中。
Gu8SetData_1++;
if(Gu8SetData_1>9)
{
Gu8SetData_1=9;
}
PartUpdate(Gu8Part); //当前局部更新显示输出到数码管
break;
}
break;
case 2: //在窗口2下（本节只用到窗口1）
break;
}
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=VOICE_TIME; //蜂鸣器发出“滴”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0;
break;
case 3: //递减的按键
switch(Gu8Wd) //在某个窗口下
{
case 1: //在窗口1下
switch(Gu8Part) //二级支点的局部选择
{
case 1: //局部1被选中，代表左起第1位数据Gu8SetData_4被选中。
if(Gu8SetData_4>0)
{
Gu8SetData_4--;
}
PartUpdate(Gu8Part); //当前局部更新显示输出到数码管
break;
case 2: //局部2被选中，代表左起第2位数据Gu8SetData_3被选中。
if(Gu8SetData_3>0)
{
Gu8SetData_3--;
}
PartUpdate(Gu8Part); //当前局部更新显示输出到数码管
break;
case 3: //局部3被选中，代表左起第3位数据Gu8SetData_2被选中。
if(Gu8SetData_2>0)
{
Gu8SetData_2--;
}
PartUpdate(Gu8Part); //当前局部更新显示输出到数码管
break;
case 4: //局部4被选中，代表左起第4位数据Gu8SetData_1被选中。
if(Gu8SetData_1>0)
{
Gu8SetData_1--;
}
PartUpdate(Gu8Part); //当前局部更新显示输出到数码管
break;
}
break;
case 2: //在窗口2下（本节只用到窗口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: //窗口2显示选择（本节只用到窗口1）
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=0;
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; //及时清零，只更新一次显示即可，避免一直进来更新显示
Su8Temp_4=Gu8SetData_4; //显示左起第1个数据Gu8SetData_4
//上面先分解数据之后，再过渡需要显示的数据到底层驱动变量里，让过渡的时间越短越好
vGu8Display_Righ_4=Su8Temp_4; //过渡需要显示的数据到底层驱动变量
}
if(1==Gu8PartUpdate_2) //局部2更新显示
{
Gu8PartUpdate_2=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
Su8Temp_3=Gu8SetData_3; //显示左起第2个数据Gu8SetData_3
//上面先分解数据之后，再过渡需要显示的数据到底层驱动变量里，让过渡的时间越短越好
vGu8Display_Righ_3=Su8Temp_3; //过渡需要显示的数据到底层驱动变量
}
if(1==Gu8PartUpdate_3) //局部3更新显示
{
Gu8PartUpdate_3=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
Su8Temp_2=Gu8SetData_2; //显示左起第3个数据Gu8SetData_2
//上面先分解数据之后，再过渡需要显示的数据到底层驱动变量里，让过渡的时间越短越好
vGu8Display_Righ_2=Su8Temp_2; //过渡需要显示的数据到底层驱动变量
}
if(1==Gu8PartUpdate_4) //局部4更新显示
{
Gu8PartUpdate_4=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
Su8Temp_1=Gu8SetData_1; //显示左起第4个数据Gu8SetData_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; //左起第1个显示“不显示”（10代表不显示）
}
else
{
Su8BlinkFlag=0;
Su8Temp_4=Gu8SetData_4; //左起第1个显示数据Gu8SetData_4
}
break;
case 2:
if(0==Su8BlinkFlag) //两种状态的切换判断
{
Su8BlinkFlag=1;
Su8Temp_3=10; //左起第2个显示“不显示”（10代表不显示）
}
else
{
Su8BlinkFlag=0;
Su8Temp_3=Gu8SetData_3; //左起第2个显示数据Gu8SetData_3
}
break;
case 3:
if(0==Su8BlinkFlag) //两种状态的切换判断
{
Su8BlinkFlag=1;
Su8Temp_2=10; //左起第3个显示“不显示”（10代表不显示）
}
else
{
Su8BlinkFlag=0;
Su8Temp_2=Gu8SetData_2; //左起第3个显示数据Gu8SetData_2
}
break;
case 4:
if(0==Su8BlinkFlag) //两种状态的切换判断
{
Su8BlinkFlag=1;
Su8Temp_1=10; //左起第3个显示“不显示”（10代表不显示）
}
else
{
Su8BlinkFlag=0;
Su8Temp_1=Gu8SetData_1; //左起第4个显示数据Gu8SetData_1
}
break;
default: //都没有被选中的时候
Su8Temp_4=Gu8SetData_4; //左起第1个显示数据Gu8SetData_4
Su8Temp_3=Gu8SetData_3; //左起第2个显示数据Gu8SetData_3
Su8Temp_2=Gu8SetData_2; //左起第3个显示数据Gu8SetData_2
Su8Temp_1=Gu8SetData_1; //左起第4个显示数据Gu8SetData_1
break;
}
vGu8Display_Righ_4=Su8Temp_4; //过渡需要显示的数据到底层驱动变量
vGu8Display_Righ_3=Su8Temp_3; //过渡需要显示的数据到底层驱动变量
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==vGu8BlinkTimerFlag&&vGu16BlinkTimerCnt>0) //数码管闪烁跳动的定时器
{
vGu16BlinkTimerCnt--; //递减式的软件定时器
}
TH0=0xfc;
TL0=0x66;
}
void SystemInitial(void)
{
P0=0x00;
P1_0=1;
P1_1=1;
P1_2=1;
P1_3=1;
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-6-3 10:31:53

第一百一十九节：一个完整的人机界面的程序框架的脉络。

【119.1 一个完整的人机界面的程序框架的脉络。】

   前面两节例子告诉我们，一个完整的人机界面的程序框架包含两个要素，分别是“支点”与“更新”。“支点”包括“窗口选择”和“局部选择”，“更新”包括“整屏更新”和“局部更新”。
   “支点”的作用是把显示函数与按键函数完美无缝的关联起来，两个函数同样的“支点”促使同样的“话语体系”，让“所见即所得”实时同步，确保按键操作的数据就是当前显示被选中的数据。
   “静态数据”与“动态数据”的概念。被窗口显示的数据通常有两种：一种是静态数据，比如装饰门面的数据，只能显示不能更改的数据，以及图片图标这类数据；另外一种是动态数据，这种数据在窗口显示上是活动的可编辑的，是需要经常修改的，往往也是系统核心的数据，需要保存或者需要跟某些关键运动密切相关的数据。比如，在前面章节中，数码管要显示三个窗口“1-XX”,“2-YY”,“3-ZZ”，其中“1-”、“2-”、“3-”是属于静态数据，它们是起“装饰”作用的。而“XX”、“YY”、“ZZ”则是动态数据，它们是可编辑的，也是单片机系统内部核心的数据。
   “整屏更新”与“局部更新”的分工。“整屏更新”主要负责在切换新窗口时，把“静态数据”一次性显示到当前窗口。而“局部更新”主要负责在当前窗口下显示“动态数据”。
   下面，我把一个完整的人机界面的程序框架的脉络勾勒出来，让大家有一个整体的观感，这种人机界面的程序框架放之四海而皆准，我已把它应用在各种数码管，单色液晶屏，彩屏，电脑上位机等项目上。假设某个项目中只有两个”窗口”只有两个“局部”，程序框架的脉络如下:

   显示部分：

void DisplayTask(void) //数码管显示的上层任务函数
{
switch(Gu8Wd) //以“窗口选择”Gu8Wd为支点
{
case 1:
Wd1(); //窗口1显示函数
break;
case 2:
Wd2(); //窗口2显示函数
break;
}
}
void Wd1(void) //窗口1显示函数
{
if(1==Gu8WdUpdate) //整屏更新
{
Gu8WdUpdate=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
...... //此处省略N行代码，用来显示静态的数据，比如图片图标，或者装饰的数据
//以下，“整屏更新”必然是要把所有的“局部更新”都触发一次
Gu8PartUpdate_1=1; //局部1更新显示
Gu8PartUpdate_2=1 ;//局部2更新显示
}
if(1==Gu8PartUpdate_1) //局部1更新显示
{
Gu8PartUpdate_1=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
...... //此处省略N行代码，用来显示动态的数据。比如可编辑的数据，实时变化的数据
}
if(1==Gu8PartUpdate_2) //局部2更新显示
{
Gu8PartUpdate_2=0; //及时清零，只更新一次显示即可，避免一直进来更新显示
...... //此处省略N行代码，用来显示动态的数据。比如可编辑的数据，实时变化的数据
}
if(0==vGu16BlinkTimerCnt) //跳动的光标，或者动态闪烁的某位被选中的数据
{
vGu8BlinkTimerFlag=0;
vGu16BlinkTimerCnt=BLINK_TIME; //重设定时器的定时时间
vGu8BlinkTimerFlag=1;
...... //此处省略N行代码，用来制作跳动的光标或者某位被选中而闪烁的数据
}
}
void Wd2(void) //窗口2显示函数
{
...... //此处省略N行代码，窗口2显示函数的代码跟窗口1类似
}

复制代码

按键部分：

void KeyTask(void) //按键的任务函数
{
if(0==vGu8KeySec)
{
return;
}
switch(vGu8KeySec)
{
case 1: //1号按键
switch(Gu8Wd) //以“窗口选择”Gu8Wd为支点
{
case 1: //在窗口1下
switch(Gu8Part) //以“局部选择”Gu8Part为支点
{
case 1:
...... //此处省略N行代码
break;
case 2: //局部2被选中
...... //此处省略N行代码
break;
}
break;
case 2: //在窗口2下
switch(Gu8Part) //以“局部选择”Gu8Part为支点
{
case 1:
...... //此处省略N行代码
break;
case 2: //局部2被选中
...... //此处省略N行代码
break;
}
break;
}
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=VOICE_TIME; //蜂鸣器发出“滴”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0;
break;
case 2: //2号按键
...... //此处省略N行代码，跟1号按键的代码类似
vGu8BeepTimerFlag=0;
vGu16BeepTimerCnt=VOICE_TIME; //蜂鸣器发出“滴”一声
vGu8BeepTimerFlag=1;
vGu8KeySec=0;
break;
}
}

复制代码

吴坚鸿 · 2018-6-10 12:10:22

第一百二十节：按键切换窗口切换局部来设置参数。

【120.1 按键切换窗口切换局部来设置参数。】

            上图120.1.1  数码管


            上图120.1.2  独立按键


            上图120.1.3  有源蜂鸣器

   为了更好理解上一节提出的人机界面程序框架的脉络，本节程序恰好包含了整屏更新与局部更新的应用，同时也引入了一个新的知识点：在人机界面的程序框架中，常常会遇到需要以“位”来编辑某个数据的情况，这种情况实际上是先把“待编辑数据”分解成几个“位”中间临时个体，然后显示并且编辑这些“位”中间临时个体，编辑结束后，再把这些“位”中间临时个体合并成一个完整的数据赋值给“待编辑数据”。
   本节程序功能如下：
   （1）有3个窗口1-XX，2-YY，3-ZZ，其中XX，YY，ZZ分别代表3个可编辑的数据Gu8SetDate_1，Gu8SetDate_2，Gu8SetDate_3。数据范围是从0到99。
   （2）K1按键。含“短按”与“长按”复合双功能。当数码管“没有闪烁”时，“短按”K1按键可以切换窗口，而“长按”K1按键会使数码管从“没有闪烁”进入到“闪烁模式”。当数码管处于“闪烁模式”时，“短按”K1可以使数码管在十位和个位之间切换“闪烁”的“局部位”，而“长按”K1表示更改完毕当前窗口数据并从“闪烁模式”退出到“没有闪烁”。
   （3）K2按键。当数码管处于“闪烁模式”时，每按一次K2按键就可以使当前闪烁的某位数码管“递增1”。
   （4）K3按键。当数码管处于“闪烁模式”时，每按一次K2按键就可以使当前闪烁的某位数码管“递减1”。
   上述功能，在窗口切换和退出“闪烁模式”时用到整屏更新，在闪烁的某位数码管切换“局部”时用到局部更新。代码如下：