从业将近十年！手把手教你单片机程序框架（连载）

cuiliang1984 · 发表于 2014-4-1 18:54:01

挺好的，适合初学者们

名海2012 · 发表于 2014-4-2 09:54:40

不错。。。支持下！

doujiang · 发表于 2014-4-2 10:01:04

支持楼主，无私分享！欢迎

多多 · 发表于 2014-4-2 11:12:57

标记，后续留看

longwjsz · 发表于 2014-4-2 11:28:14

写的不错

hyf88 · 发表于 2014-4-2 14:08:42

先mark，单片机还是挺有意思的，

hyf88 · 发表于 2014-4-2 16:10:50

我把程序全部复制下来了，谢谢分享，要是我在大学那会刚学习单片机的时候，有这个资料就好了，

wildcat7261 · 发表于 2014-4-2 20:18:03

学习了

jeoo8888 · 发表于 2014-4-2 23:09:06

写得很好，大力支持，正在学习中，本来在论坛里看到个，新型单片机操作系统TreeOS 1.0 ，有打算学一下TreeOS 1.0 但是现在看了吴坚鸿前辈写得这么好
就先学这个.

hqjin · 发表于 2014-4-2 23:54:24

非常的好啊

吴坚鸿 · 发表于 2014-4-3 01:29:54

第三十七节：数码管作为仪表盘显示跑马灯的方向，速度和运行状态。

开场白：
我在第24节中讲过按键控制跑马灯的方向，速度和运行状态的项目程序，只可惜那个程序不能直观地显示运行中的三种状态，这节我决定在24节的基础上，增加一个数码管显示作为类似汽车仪表盘的界面，实时显示跑马灯的方向，速度，和运行状态。
这一节要教会大家一个知识点：继续加深理解运动，按键与数码管三者之间的关联程序框架。

具体内容，请看源代码讲解。

（1）硬件平台：
基于朱兆祺51单片机学习板。用S1键作为控制跑马灯的方向按键，S5键作为控制跑马灯方向的加速度按键，S9键作为控制跑马灯方向的减速度按键，S13键作为控制跑马灯方向的启动或者暂停按键。记得把输出线P0.4一直输出低电平，模拟独立按键的触发地GND。

（2）实现功能：
跑马灯运行：第1个至第8个LED灯一直不亮。在第9个至第16个LED灯，依次逐个亮灯并且每次只能亮一个灯。每按一次独立按键S13键，原来运行的跑马灯会暂停，原来暂停的跑马灯会运行。用S1来改变方向。用S5和S9来改变速度，每按一次按键的递增或者递减以10为单位。
数码管显示：本程序只有1个窗口，这个窗口分成3个局部显示。8，7，6位数码管显示运行状态，启动时显示“on”，停止时显示“oFF”。5位数码管显示数码管方向，正向显示“n”，反向显示“U”。4,3,2,1位数码管显示速度。数值越大速度越慢，最慢的速度是550，最快的速度是50。

（3）源代码讲解如下：

#include "REG52.H"
#define const_voice_short 40 //蜂鸣器短叫的持续时间
#define const_key_time1 20 //按键去抖动延时的时间
#define const_key_time2 20 //按键去抖动延时的时间
#define const_key_time3 20 //按键去抖动延时的时间
#define const_key_time4 20 //按键去抖动延时的时间
void initial_myself();
void initial_peripheral();
void delay_short(unsigned int uiDelayShort);
void delay_long(unsigned int uiDelaylong);
//驱动数码管的74HC595
void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01);
void display_drive(); //显示数码管字模的驱动函数
void display_service(); //显示的窗口菜单服务程序
//驱动LED的74HC595
void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01);
void led_flicker_09_16(); //第9个至第16个LED的跑马灯程序，逐个亮并且每次只能亮一个.
void led_update(); //LED更新函数
void T0_time(); //定时中断函数
void key_service(); //按键服务的应用程序
void key_scan();//按键扫描函数放在定时中断里
sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键
sbit key_sr3=P0^2; //对应朱兆祺学习板的S9键
sbit key_sr4=P0^3; //对应朱兆祺学习板的S13键
sbit key_gnd_dr=P0^4; //模拟独立按键的地GND，因此必须一直输出低电平
sbit led_dr=P3^5;
sbit dig_hc595_sh_dr=P2^0; //数码管的74HC595程序
sbit dig_hc595_st_dr=P2^1;
sbit dig_hc595_ds_dr=P2^2;
sbit hc595_sh_dr=P2^3; //LED灯的74HC595程序
sbit hc595_st_dr=P2^4;
sbit hc595_ds_dr=P2^5;
unsigned char ucKeySec=0; //被触发的按键编号
unsigned int uiKeyTimeCnt1=0; //按键去抖动延时计数器
unsigned char ucKeyLock1=0; //按键触发后自锁的变量标志
unsigned int uiKeyTimeCnt2=0; //按键去抖动延时计数器
unsigned char ucKeyLock2=0; //按键触发后自锁的变量标志
unsigned int uiKeyTimeCnt3=0; //按键去抖动延时计数器
unsigned char ucKeyLock3=0; //按键触发后自锁的变量标志
unsigned int uiKeyTimeCnt4=0; //按键去抖动延时计数器
unsigned char ucKeyLock4=0; //按键触发后自锁的变量标志
unsigned int uiVoiceCnt=0; //蜂鸣器鸣叫的持续时间计数器
unsigned char ucLed_dr1=0; //代表16个灯的亮灭状态，0代表灭，1代表亮
unsigned char ucLed_dr2=0;
unsigned char ucLed_dr3=0;
unsigned char ucLed_dr4=0;
unsigned char ucLed_dr5=0;
unsigned char ucLed_dr6=0;
unsigned char ucLed_dr7=0;
unsigned char ucLed_dr8=0;
unsigned char ucLed_dr9=0;
unsigned char ucLed_dr10=0;
unsigned char ucLed_dr11=0;
unsigned char ucLed_dr12=0;
unsigned char ucLed_dr13=0;
unsigned char ucLed_dr14=0;
unsigned char ucLed_dr15=0;
unsigned char ucLed_dr16=0;
unsigned char ucLed_update=0; //刷新变量。每次更改LED灯的状态都要更新一次。
unsigned char ucLedStep_09_16=0; //第9个至第16个LED跑马灯的步骤变量
unsigned int uiTimeCnt_09_16=0; //第9个至第16个LED跑马灯的统计定时中断次数的延时计数器
unsigned char ucLedStatus16_09=0; //代表底层74HC595输出状态的中间变量
unsigned char ucLedStatus08_01=0; //代表底层74HC595输出状态的中间变量
unsigned char ucLedDirFlag=0; //方向变量，把按键与跑马灯关联起来的核心变量,0代表正方向，1代表反方向
unsigned int uiSetTimeLevel_09_16=300; //速度变量，此数值越大速度越慢，此数值越小速度越快。
unsigned char ucLedStartFlag=1; //启动和暂停的变量，0代表暂停，1代表启动
unsigned char ucDigShow8; //第8位数码管要显示的内容
unsigned char ucDigShow7; //第7位数码管要显示的内容
unsigned char ucDigShow6; //第6位数码管要显示的内容
unsigned char ucDigShow5; //第5位数码管要显示的内容
unsigned char ucDigShow4; //第4位数码管要显示的内容
unsigned char ucDigShow3; //第3位数码管要显示的内容
unsigned char ucDigShow2; //第2位数码管要显示的内容
unsigned char ucDigShow1; //第1位数码管要显示的内容
unsigned char ucDigDot8; //数码管8的小数点是否显示的标志
unsigned char ucDigDot7; //数码管7的小数点是否显示的标志
unsigned char ucDigDot6; //数码管6的小数点是否显示的标志
unsigned char ucDigDot5; //数码管5的小数点是否显示的标志
unsigned char ucDigDot4; //数码管4的小数点是否显示的标志
unsigned char ucDigDot3; //数码管3的小数点是否显示的标志
unsigned char ucDigDot2; //数码管2的小数点是否显示的标志
unsigned char ucDigDot1; //数码管1的小数点是否显示的标志
unsigned char ucDigShowTemp=0; //临时中间变量
unsigned char ucDisplayDriveStep=1; //动态扫描数码管的步骤变量
unsigned char ucWd1Part1Update=1; //窗口1的局部1更新显示变量
unsigned char ucWd1Part2Update=1; //窗口1的局部2更新显示变量
unsigned char ucWd1Part3Update=1; //窗口1的局部3更新显示变量
//根据原理图得出的共阴数码管字模表
code unsigned char dig_table[]=
{
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
0x73, //P 序号12
0x5c, //o 序号13
0x71, //F 序号14
0x3e, //U 序号15
0x37, //n 序号16
};
void main()
{
initial_myself();
delay_long(100);
initial_peripheral();
while(1)
{
key_service(); //按键服务的应用程序
display_service(); //显示的窗口菜单服务程序
led_flicker_09_16(); //第9个至第16个LED的跑马灯程序，逐个亮并且每次只能亮一个.
led_update(); //LED更新函数
}
}
/* 注释一：
* 由于本程序只有1个窗口，而这个窗口又分成3个局部，因此可以省略去窗口变量uWd，
* 只用三个局部变量ucWdxPartyUpdate就可以了。
*/
void display_service() //显示的窗口菜单服务程序
{
if(ucWd1Part1Update==1) //更新显示当前系统是处于运行还是暂停的状态
{
ucWd1Part1Update=0; //及时把更新变量清零，防止一直进来更新
if(ucLedStartFlag==1) //启动，显示on
{
ucDigShow8=13; //显示o
ucDigShow7=16; //显示n
ucDigShow6=10; //显示空
}
else //暂停，显示oFF
{
ucDigShow8=13; //显示o
ucDigShow7=14; //显示F
ucDigShow6=14; //显示F
}
}
if(ucWd1Part2Update==1) //更新显示当前系统是处于正方向还是反方向
{
ucWd1Part2Update=0; //及时把更新变量清零，防止一直进来更新
if(ucLedDirFlag==0) //正方向，向上，显示n
{
ucDigShow5=16; //显示n
}
else //反方向，向下，显示U
{
ucDigShow5=15; //显示U
}
}
if(ucWd1Part3Update==1) //更新显示当前系统的速度，此数值越大速度越慢，此数值越小速度越快。
{
ucWd1Part3Update=0; //及时把更新变量清零，防止一直进来更新
ucDigShow4=10; //显示空这一位不用，作为空格
if(uiSetTimeLevel_09_16>=100)
{
ucDigShow3=uiSetTimeLevel_09_16/100; //显示速度的百位
}
else
{
ucDigShow3=10; //显示空
}
if(uiSetTimeLevel_09_16>=10)
{
ucDigShow2=uiSetTimeLevel_09_16%100/10; //显示速度的十位
}
else
{
ucDigShow2=10; //显示空
}
ucDigShow1=uiSetTimeLevel_09_16%10; //显示速度的个位
}
}
void key_scan()//按键扫描函数放在定时中断里
{
if(key_sr1==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
{
ucKeyLock1=0; //按键自锁标志清零
uiKeyTimeCnt1=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。
}
else if(ucKeyLock1==0)//有按键按下，且是第一次被按下
{
uiKeyTimeCnt1++; //累加定时中断次数
if(uiKeyTimeCnt1>const_key_time1)
{
uiKeyTimeCnt1=0;
ucKeyLock1=1; //自锁按键置位,避免一直触发
ucKeySec=1; //触发1号键
}
}
if(key_sr2==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
{
ucKeyLock2=0; //按键自锁标志清零
uiKeyTimeCnt2=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。
}
else if(ucKeyLock2==0)//有按键按下，且是第一次被按下
{
uiKeyTimeCnt2++; //累加定时中断次数
if(uiKeyTimeCnt2>const_key_time2)
{
uiKeyTimeCnt2=0;
ucKeyLock2=1; //自锁按键置位,避免一直触发
ucKeySec=2; //触发2号键
}
}
if(key_sr3==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
{
ucKeyLock3=0; //按键自锁标志清零
uiKeyTimeCnt3=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。
}
else if(ucKeyLock3==0)//有按键按下，且是第一次被按下
{
uiKeyTimeCnt3++; //累加定时中断次数
if(uiKeyTimeCnt3>const_key_time3)
{
uiKeyTimeCnt3=0;
ucKeyLock3=1; //自锁按键置位,避免一直触发
ucKeySec=3; //触发3号键
}
}
if(key_sr4==1)//IO是高电平，说明按键没有被按下，这时要及时清零一些标志位
{
ucKeyLock4=0; //按键自锁标志清零
uiKeyTimeCnt4=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。
}
else if(ucKeyLock4==0)//有按键按下，且是第一次被按下
{
uiKeyTimeCnt4++; //累加定时中断次数
if(uiKeyTimeCnt4>const_key_time4)
{
uiKeyTimeCnt4=0;
ucKeyLock4=1; //自锁按键置位,避免一直触发
ucKeySec=4; //触发4号键
}
}
}
void key_service() //按键服务的应用程序
{
switch(ucKeySec) //按键服务状态切换
{
case 1:// 改变跑马灯方向的按键对应朱兆祺学习板的S1键
if(ucLedDirFlag==0) //通过中间变量改变跑马灯的方向
{
ucLedDirFlag=1;
}
else
{
ucLedDirFlag=0;
}
ucWd1Part2Update=1; //及时更新显示方向
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 2:// 加速按键对应朱兆祺学习板的S5键 uiSetTimeLevel_09_16越小速度越快
uiSetTimeLevel_09_16=uiSetTimeLevel_09_16-10;
if(uiSetTimeLevel_09_16<50) //最快限定在50
{
uiSetTimeLevel_09_16=50;
}
ucWd1Part3Update=1; //及时更新显示速度
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 3:// 减速按键对应朱兆祺学习板的S9键 uiSetTimeLevel_09_16越大速度越慢
uiSetTimeLevel_09_16=uiSetTimeLevel_09_16+10;
if(uiSetTimeLevel_09_16>550) //最慢限定在550
{
uiSetTimeLevel_09_16=550;
}
ucWd1Part3Update=1; //及时更新显示速度
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 4:// 启动和暂停按键对应朱兆祺学习板的S13键 ucLedStartFlag为0时代表暂停，为1时代表启动
if(ucLedStartFlag==1) //启动和暂停两种状态循环切换
{
ucLedStartFlag=0;
}
else //启动和暂停两种状态循环切换
{
ucLedStartFlag=1;
}
ucWd1Part1Update=1; //及时更新显示系统的运行状态，是运行还是暂停.
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
}
}
void led_update() //LED更新函数
{
if(ucLed_update==1)
{
ucLed_update=0; //及时清零，让它产生只更新一次的效果，避免一直更新。
if(ucLed_dr1==1)
{
ucLedStatus08_01=ucLedStatus08_01|0x01;
}
else
{
ucLedStatus08_01=ucLedStatus08_01&0xfe;
}
if(ucLed_dr2==1)
{
ucLedStatus08_01=ucLedStatus08_01|0x02;
}
else
{
ucLedStatus08_01=ucLedStatus08_01&0xfd;
}
if(ucLed_dr3==1)
{
ucLedStatus08_01=ucLedStatus08_01|0x04;
}
else
{
ucLedStatus08_01=ucLedStatus08_01&0xfb;
}
if(ucLed_dr4==1)
{
ucLedStatus08_01=ucLedStatus08_01|0x08;
}
else
{
ucLedStatus08_01=ucLedStatus08_01&0xf7;
}
if(ucLed_dr5==1)
{
ucLedStatus08_01=ucLedStatus08_01|0x10;
}
else
{
ucLedStatus08_01=ucLedStatus08_01&0xef;
}
if(ucLed_dr6==1)
{
ucLedStatus08_01=ucLedStatus08_01|0x20;
}
else
{
ucLedStatus08_01=ucLedStatus08_01&0xdf;
}
if(ucLed_dr7==1)
{
ucLedStatus08_01=ucLedStatus08_01|0x40;
}
else
{
ucLedStatus08_01=ucLedStatus08_01&0xbf;
}
if(ucLed_dr8==1)
{
ucLedStatus08_01=ucLedStatus08_01|0x80;
}
else
{
ucLedStatus08_01=ucLedStatus08_01&0x7f;
}
if(ucLed_dr9==1)
{
ucLedStatus16_09=ucLedStatus16_09|0x01;
}
else
{
ucLedStatus16_09=ucLedStatus16_09&0xfe;
}
if(ucLed_dr10==1)
{
ucLedStatus16_09=ucLedStatus16_09|0x02;
}
else
{
ucLedStatus16_09=ucLedStatus16_09&0xfd;
}
if(ucLed_dr11==1)
{
ucLedStatus16_09=ucLedStatus16_09|0x04;
}
else
{
ucLedStatus16_09=ucLedStatus16_09&0xfb;
}
if(ucLed_dr12==1)
{
ucLedStatus16_09=ucLedStatus16_09|0x08;
}
else
{
ucLedStatus16_09=ucLedStatus16_09&0xf7;
}
if(ucLed_dr13==1)
{
ucLedStatus16_09=ucLedStatus16_09|0x10;
}
else
{
ucLedStatus16_09=ucLedStatus16_09&0xef;
}
if(ucLed_dr14==1)
{
ucLedStatus16_09=ucLedStatus16_09|0x20;
}
else
{
ucLedStatus16_09=ucLedStatus16_09&0xdf;
}
if(ucLed_dr15==1)
{
ucLedStatus16_09=ucLedStatus16_09|0x40;
}
else
{
ucLedStatus16_09=ucLedStatus16_09&0xbf;
}
if(ucLed_dr16==1)
{
ucLedStatus16_09=ucLedStatus16_09|0x80;
}
else
{
ucLedStatus16_09=ucLedStatus16_09&0x7f;
}
hc595_drive(ucLedStatus16_09,ucLedStatus08_01); //74HC595底层驱动函数
}
}
void display_drive()
{
//以下程序，如果加一些数组和移位的元素，还可以压缩容量。但是鸿哥追求的不是容量，而是清晰的讲解思路
switch(ucDisplayDriveStep)
{
case 1: //显示第1位
ucDigShowTemp=dig_table[ucDigShow1];
if(ucDigDot1==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xfe);
break;
case 2: //显示第2位
ucDigShowTemp=dig_table[ucDigShow2];
if(ucDigDot2==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xfd);
break;
case 3: //显示第3位
ucDigShowTemp=dig_table[ucDigShow3];
if(ucDigDot3==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xfb);
break;
case 4: //显示第4位
ucDigShowTemp=dig_table[ucDigShow4];
if(ucDigDot4==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xf7);
break;
case 5: //显示第5位
ucDigShowTemp=dig_table[ucDigShow5];
if(ucDigDot5==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xef);
break;
case 6: //显示第6位
ucDigShowTemp=dig_table[ucDigShow6];
if(ucDigDot6==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xdf);
break;
case 7: //显示第7位
ucDigShowTemp=dig_table[ucDigShow7];
if(ucDigDot7==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0xbf);
break;
case 8: //显示第8位
ucDigShowTemp=dig_table[ucDigShow8];
if(ucDigDot8==1)
{
ucDigShowTemp=ucDigShowTemp|0x80; //显示小数点
}
dig_hc595_drive(ucDigShowTemp,0x7f);
break;
}
ucDisplayDriveStep++;
if(ucDisplayDriveStep>8) //扫描完8个数码管后，重新从第一个开始扫描
{
ucDisplayDriveStep=1;
}
}
//数码管的74HC595驱动函数
void dig_hc595_drive(unsigned char ucDigStatusTemp16_09,unsigned char ucDigStatusTemp08_01)
{
unsigned char i;
unsigned char ucTempData;
dig_hc595_sh_dr=0;
dig_hc595_st_dr=0;
ucTempData=ucDigStatusTemp16_09; //先送高8位
for(i=0;i<8;i++)
{
if(ucTempData>=0x80)dig_hc595_ds_dr=1;
else dig_hc595_ds_dr=0;
dig_hc595_sh_dr=0; //SH引脚的上升沿把数据送入寄存器
delay_short(1);
dig_hc595_sh_dr=1;
delay_short(1);
ucTempData=ucTempData<<1;
}
ucTempData=ucDigStatusTemp08_01; //再先送低8位
for(i=0;i<8;i++)
{
if(ucTempData>=0x80)dig_hc595_ds_dr=1;
else dig_hc595_ds_dr=0;
dig_hc595_sh_dr=0; //SH引脚的上升沿把数据送入寄存器
delay_short(1);
dig_hc595_sh_dr=1;
delay_short(1);
ucTempData=ucTempData<<1;
}
dig_hc595_st_dr=0; //ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
delay_short(1);
dig_hc595_st_dr=1;
delay_short(1);
dig_hc595_sh_dr=0; //拉低，抗干扰就增强
dig_hc595_st_dr=0;
dig_hc595_ds_dr=0;
}
//LED灯的74HC595驱动函数
void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01)
{
unsigned char i;
unsigned char ucTempData;
hc595_sh_dr=0;
hc595_st_dr=0;
ucTempData=ucLedStatusTemp16_09; //先送高8位
for(i=0;i<8;i++)
{
if(ucTempData>=0x80)hc595_ds_dr=1;
else hc595_ds_dr=0;
hc595_sh_dr=0; //SH引脚的上升沿把数据送入寄存器
delay_short(1);
hc595_sh_dr=1;
delay_short(1);
ucTempData=ucTempData<<1;
}
ucTempData=ucLedStatusTemp08_01; //再先送低8位
for(i=0;i<8;i++)
{
if(ucTempData>=0x80)hc595_ds_dr=1;
else hc595_ds_dr=0;
hc595_sh_dr=0; //SH引脚的上升沿把数据送入寄存器
delay_short(1);
hc595_sh_dr=1;
delay_short(1);
ucTempData=ucTempData<<1;
}
hc595_st_dr=0; //ST引脚把两个寄存器的数据更新输出到74HC595的输出引脚上并且锁存起来
delay_short(1);
hc595_st_dr=1;
delay_short(1);
hc595_sh_dr=0; //拉低，抗干扰就增强
hc595_st_dr=0;
hc595_ds_dr=0;
}
void led_flicker_09_16() //第9个至第16个LED的跑马灯程序，逐个亮并且每次只能亮一个.
{
if(ucLedStartFlag==1) //此变量为1时代表启动
{
switch(ucLedStep_09_16)
{
case 0:
if(uiTimeCnt_09_16>=uiSetTimeLevel_09_16) //时间到
{
uiTimeCnt_09_16=0; //时间计数器清零
if(ucLedDirFlag==0) //正方向
{
ucLed_dr16=0; //第16个灭
ucLed_dr9=1; //第9个亮
ucLed_update=1; //更新显示
ucLedStep_09_16=1; //切换到下一个步骤
}
else //反方向
{
ucLed_dr15=1; //第15个亮
ucLed_dr16=0; //第16个灭
ucLed_update=1; //更新显示
ucLedStep_09_16=7; //返回上一个步骤
}
}
break;
case 1:
if(uiTimeCnt_09_16>=uiSetTimeLevel_09_16) //时间到
{
uiTimeCnt_09_16=0; //时间计数器清零
if(ucLedDirFlag==0) //正方向
{
ucLed_dr9=0; //第9个灭
ucLed_dr10=1; //第10个亮
ucLed_update=1; //更新显示
ucLedStep_09_16=2; //切换到下一个步骤
}
else //反方向
{
ucLed_dr16=1; //第16个亮
ucLed_dr9=0; //第9个灭
ucLed_update=1; //更新显示
ucLedStep_09_16=0; //返回上一个步骤
}
}
break;
case 2:
if(uiTimeCnt_09_16>=uiSetTimeLevel_09_16) //时间到
{
uiTimeCnt_09_16=0; //时间计数器清零
if(ucLedDirFlag==0) //正方向
{
ucLed_dr10=0; //第10个灭
ucLed_dr11=1; //第11个亮
ucLed_update=1; //更新显示
ucLedStep_09_16=3; //切换到下一个步骤
}
else //反方向
{
ucLed_dr9=1; //第9个亮
ucLed_dr10=0; //第10个灭
ucLed_update=1; //更新显示
ucLedStep_09_16=1; //返回上一个步骤
}
}
break;
case 3:
if(uiTimeCnt_09_16>=uiSetTimeLevel_09_16) //时间到
{
uiTimeCnt_09_16=0; //时间计数器清零
if(ucLedDirFlag==0) //正方向
{
ucLed_dr11=0; //第11个灭
ucLed_dr12=1; //第12个亮
ucLed_update=1; //更新显示
ucLedStep_09_16=4; //切换到下一个步骤
}
else //反方向
{
ucLed_dr10=1; //第10个亮
ucLed_dr11=0; //第11个灭
ucLed_update=1; //更新显示
ucLedStep_09_16=2; //返回上一个步骤
}
}
break;
case 4:
if(uiTimeCnt_09_16>=uiSetTimeLevel_09_16) //时间到
{
uiTimeCnt_09_16=0; //时间计数器清零
if(ucLedDirFlag==0) //正方向
{
ucLed_dr12=0; //第12个灭
ucLed_dr13=1; //第13个亮
ucLed_update=1; //更新显示
ucLedStep_09_16=5; //切换到下一个步骤
}
else //反方向
{
ucLed_dr11=1; //第11个亮
ucLed_dr12=0; //第12个灭
ucLed_update=1; //更新显示
ucLedStep_09_16=3; //返回上一个步骤
}
}
break;
case 5:
if(uiTimeCnt_09_16>=uiSetTimeLevel_09_16) //时间到
{
uiTimeCnt_09_16=0; //时间计数器清零
if(ucLedDirFlag==0) //正方向
{
ucLed_dr13=0; //第13个灭
ucLed_dr14=1; //第14个亮
ucLed_update=1; //更新显示
ucLedStep_09_16=6; //切换到下一个步骤
}
else //反方向
{
ucLed_dr12=1; //第12个亮
ucLed_dr13=0; //第13个灭
ucLed_update=1; //更新显示
ucLedStep_09_16=4; //返回上一个步骤
}
}
break;
case 6:
if(uiTimeCnt_09_16>=uiSetTimeLevel_09_16) //时间到
{
uiTimeCnt_09_16=0; //时间计数器清零
if(ucLedDirFlag==0) //正方向
{
ucLed_dr14=0; //第14个灭
ucLed_dr15=1; //第15个亮
ucLed_update=1; //更新显示
ucLedStep_09_16=7; //切换到下一个步骤
}
else //反方向
{
ucLed_dr13=1; //第13个亮
ucLed_dr14=0; //第14个灭
ucLed_update=1; //更新显示
ucLedStep_09_16=5; //返回上一个步骤
}
}
break;
case 7:
if(uiTimeCnt_09_16>=uiSetTimeLevel_09_16) //时间到
{
uiTimeCnt_09_16=0; //时间计数器清零
if(ucLedDirFlag==0) //正方向
{
ucLed_dr15=0; //第15个灭
ucLed_dr16=1; //第16个亮
ucLed_update=1; //更新显示
ucLedStep_09_16=0; //返回到开始处，重新开始新的一次循环
}
else //反方向
{
ucLed_dr14=1; //第14个亮
ucLed_dr15=0; //第15个灭
ucLed_update=1; //更新显示
ucLedStep_09_16=6; //返回上一个步骤
}
}
break;
}
}
}
void T0_time() interrupt 1
{
TF0=0; //清除中断标志
TR0=0; //关中断
if(uiTimeCnt_09_16<0xffff) //设定这个条件，防止uiTimeCnt超范围。
{
if(ucLedStartFlag==1) //此变量为1时代表启动
{
uiTimeCnt_09_16++; //累加定时中断的次数，
}
}
key_scan(); //按键扫描函数
if(uiVoiceCnt!=0)
{
uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
beep_dr=0; //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
// beep_dr=1; //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
}
else
{
; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
beep_dr=1; //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
// beep_dr=0; //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
}
display_drive(); //数码管字模的驱动函数
TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
TL0=0x0b;
TR0=1; //开中断
}
void delay_short(unsigned int uiDelayShort)
{
unsigned int i;
for(i=0;i<uiDelayShort;i++)
{
; //一个分号相当于执行一条空语句
}
}
void delay_long(unsigned int uiDelayLong)
{
unsigned int i;
unsigned int j;
for(i=0;i<uiDelayLong;i++)
{
for(j=0;j<500;j++) //内嵌循环的空指令数量
{
; //一个分号相当于执行一条空语句
}
}
}
void initial_myself() //第一区初始化单片机
{
/* 注释二：
* 矩阵键盘也可以做独立按键，前提是把某一根公共输出线输出低电平，
* 模拟独立按键的触发地，本程序中，把key_gnd_dr输出低电平。
* 朱兆祺51学习板的S1就是本程序中用到的一个独立按键。
*/
key_gnd_dr=0; //模拟独立按键的地GND，因此必须一直输出低电平
led_dr=0; //关闭独立LED灯
beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
TMOD=0x01; //设置定时器0为工作方式1
TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
TL0=0x0b;
}
void initial_peripheral() //第二区初始化外围
{
ucDigDot8=0; //小数点全部不显示
ucDigDot7=0;
ucDigDot6=0;
ucDigDot5=0;
ucDigDot4=0;
ucDigDot3=0;
ucDigDot2=0;
ucDigDot1=0;
EA=1; //开总中断
ET0=1; //允许定时中断
TR0=1; //启动定时中断
}

复制代码

总结陈词：
前面花了大量的章节在讲数码管显示，按键，运动的关联程序框架，从下一节开始，我将会用八节内容来讲我常用的串口程序框架，内容非常精彩和震撼，思路非常简单而又实用
。欲知详情，请听下回分解-----判断数据尾来接收一串数据的串口通用程序框架。

（未完待续，下节更精彩，不要走开哦）

yanghc · 发表于 2014-4-3 09:53:31

标记一下，有空看看。

261854681 · 发表于 2014-4-3 13:07:42

花了一上午的时间终于把20节读完了，下到手机上没网也能读，顺便把文字复制下来了。方便其它的读者。

jiwx2011 · 发表于 2014-4-3 13:18:32

欢迎欢迎。。

jiwx2011 · 发表于 2014-4-3 13:19:04

欢迎欢迎！！

gaobao_1 · 发表于 2014-4-3 16:21:54

好强大，牛人啊！学习！

biying · 发表于 2014-4-3 23:49:46

吴坚鸿发表于 2014-3-10 15:06
第十一节：同一个按键短按与长按的区别触发。

开场白：

我是个新手，刚来学avr，看了楼主以下代码4个小时了，硬是没有理解怎么没有：key_sr1==0 ? 这句话：else if(ucKeyLock1==0)//有按键按下，且是第一次被按下    *****怎么就能说明按下按键了呢，也就是key_sr1=0？请楼主能否指导一下,谢谢！
if(key_sr1==1)//IO是高电平，说明两个按键没有全部被按下，这时要及时清零一些标志位
  {
   ucKeyLock1=0; //按键自锁标志清零
   uiKeyTimeCnt1=0;//按键去抖动延时计数器清零，此行非常巧妙，是我实战中摸索出来的。
         if(ucShortTouchFlag1==1)  //短按触发标志
      {
         ucShortTouchFlag1=0;
               ucKeySec=1; //触发一号键的短按
      }
  }
  else if(ucKeyLock1==0)//有按键按下，且是第一次被按下
  {
   uiKeyTimeCnt1++; //累加定时中断次数
   if(uiKeyTimeCnt1>const_key_time_short1)
   {
         ucShortTouchFlag1=1; //激活按键短按的有效标志
   }

   if(uiKeyTimeCnt1>const_key_time_long1)
   {
         ucShortTouchFlag1=0;  //清除按键短按的有效标志

      uiKeyTimeCnt1=0;
      ucKeyLock1=1;  //自锁按键置位,避免一直触发

      ucKeySec=2; //触发1号键的长按

   }

  }

biying · 发表于 2014-4-4 09:43:03

睡了一觉，我似乎想明白了，如果key_sr1=0，也就是按下后，就不会执行f(key_sr1==1)后面这句了。转因为ucKeyLock1==0之前被设置，而执行else if(ucKeyLock1==0)后面的，也就等同检测到key_sr1=0。我搜索了一下if语句解释，原来if(key_sr1==1)这句执行以后就不会再执行 else if(ucKeyLock1==0)这句了，而是执行下一句：if(key_sr2==1)。

吴坚鸿 · 发表于 2014-4-4 11:15:45

biying 发表于 2014-4-4 09:43
睡了一觉，我似乎想明白了，如果key_sr1=0，也就是按下后，就不会执行f(key_sr1==1)后面这句了。转因为ucKe ...

没错。就是这样理解的。

ZHW0117 · 发表于 2014-4-4 11:27:34

好资料啊！学习了！谢谢楼主啊！

brwang1983 · 发表于 2014-4-4 12:05:43

留名收下

biying · 发表于 2014-4-4 12:22:00

吴坚鸿发表于 2014-4-4 11:15
没错。就是这样理解的。

谢谢指导！吃透你这节，正好为我的单键密码锁程序做好按键准备

吴坚鸿 · 发表于 2014-4-4 13:03:23

biying 发表于 2014-4-4 12:22
谢谢指导！吃透你这节，正好为我的单键密码锁程序做好按键准备

想做密码锁程序，你还可以顺便参考一下我的第三十四节：在数码管中实现iphone4S开机密码锁的程序。

xssr123 · 发表于 2014-4-4 13:43:08

谢谢LZ，等着你些串口的相关程序

张正一号 · 发表于 2014-4-4 13:53:28

感谢楼主无私奉献

胖班长 · 发表于 2014-4-5 10:17:27

谢谢楼主分享谢谢楼主

胖班长 · 发表于 2014-4-5 10:42:59

谢谢楼主分享

吴坚鸿 · 发表于 2014-4-5 11:10:41

第三十八节：判断数据尾来接收一串数据的串口通用程序框架。

开场白：
在实际项目中，串口通讯不可能一次通讯只发送或接收一个字节，大部分的项目都是一次发送或者接受一串的数据。我们还要在这一串数据里解析数据协议，提取有用的数据。
这一节要教会大家三个知识点：
第一个：如何识别一串数据已经发送接收完毕。
第二个：如何在已经接收到的一串数据中解析数据尾协议并且提取有效数据。
第三个：接收一串数据的通用程序框架涉及到main循环里的串口服务程序，定时器的计时程序，串口接收中断程序的密切配合。大家要理解它们三者之间是如何关联起来的。

具体内容，请看源代码讲解。

（1）硬件平台：
基于朱兆祺51单片机学习板。

（2）实现功能：
通讯协议：XX YY  EB 00 55
         其中后三位 EB 00 55就是我所说的数据尾，它的有效数据XX YY在数据尾的前面。
      任意时刻，单片机从电脑“串口调试助手”上位机收到的一串数据中，只要此数据中包含关键字EB 00 55 ，并且此关键字前面两个字节的数据XX YY 分别为01 02,那么蜂鸣器鸣叫一声表示接收的数据尾和有效数据都是正确的。

（3）源代码讲解如下：

#include "REG52.H"
#define const_voice_short 40 //蜂鸣器短叫的持续时间
#define const_rc_size 10 //接收串口中断数据的缓冲区数组大小
#define const_receive_time 5 //如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完，这个时间根据实际情况来调整大小
void initial_myself(void);
void initial_peripheral(void);
void delay_long(unsigned int uiDelaylong);
void T0_time(void); //定时中断函数
void usart_receive(void); //串口接收中断函数
void usart_service(void); //串口服务程序,在main函数里
sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
unsigned int uiSendCnt=0; //用来识别串口是否接收完一串数据的计时器
unsigned char ucSendLock=1; //串口服务程序的自锁变量，每次接收完一串数据只处理一次
unsigned int uiRcregTotal=0; //代表当前缓冲区已经接收了多少个数据
unsigned char ucRcregBuf[const_rc_size]; //接收串口中断数据的缓冲区数组
unsigned int uiRcMoveIndex=0; //用来解析数据协议的中间变量
unsigned int uiVoiceCnt=0; //蜂鸣器鸣叫的持续时间计数器
void main()
{
initial_myself();
delay_long(100);
initial_peripheral();
while(1)
{
usart_service(); //串口服务程序
}
}
void usart_service(void) //串口服务程序,在main函数里
{
/* 注释一：
* 识别一串数据是否已经全部接收完了的原理:
* 在规定的时间里，如果没有接收到任何一个字节数据，那么就认为一串数据被接收完了，然后就进入数据协议
* 解析和处理的阶段。这个功能的实现要配合定时中断，串口中断的程序一起阅读，要理解他们之间的关系。
*/
if(uiSendCnt>=const_receive_time&&ucSendLock==1) //说明超过了一定的时间内，再也没有新数据从串口来
{
ucSendLock=0; //处理一次就锁起来，不用每次都进来,除非有新接收的数据
//下面的代码进入数据协议解析和数据处理的阶段
uiRcMoveIndex=uiRcregTotal; //由于是判断数据尾，所以下标移动变量从数组的最尾端开始向0移动
while(uiRcMoveIndex>=5) //如果处理的数据量大于等于5（2个有效数据，3个数据头）说明还没有把缓冲区的数据处理完
{
if(ucRcregBuf[uiRcMoveIndex-3]==0xeb&&ucRcregBuf[uiRcMoveIndex-2]==0x00&&ucRcregBuf[uiRcMoveIndex-1]==0x55) //数据尾eb 00 55的判断
{
if(ucRcregBuf[uiRcMoveIndex-5]==0x01&&ucRcregBuf[uiRcMoveIndex-4]==0x02) //有效数据01 02的判断
{
uiVoiceCnt=const_voice_short; //蜂鸣器发出声音，说明数据尾和有效数据都接收正确
}
break; //退出循环
}
uiRcMoveIndex--; //因为是判断数据尾，下标向着0的方向移动
}
uiRcregTotal=0; //清空缓冲的下标，方便下次重新从0下标开始接受新数据
}
}
void T0_time(void) interrupt 1 //定时中断
{
TF0=0; //清除中断标志
TR0=0; //关中断
if(uiSendCnt<const_receive_time) //如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完
{
uiSendCnt++; //表面上这个数据不断累加，但是在串口中断里，每接收一个字节它都会被清零，除非这个中间没有串口数据过来
ucSendLock=1; //开自锁标志
}
if(uiVoiceCnt!=0)
{
uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
beep_dr=0; //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
}
else
{
; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
beep_dr=1; //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
}
TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
TL0=0x0b;
TR0=1; //开中断
}
void usart_receive(void) interrupt 4 //串口接收数据中断
{
if(RI==1)
{
RI = 0;
++uiRcregTotal;
if(uiRcregTotal>const_rc_size) //超过缓冲区
{
uiRcregTotal=const_rc_size;
}
ucRcregBuf[uiRcregTotal-1]=SBUF; //将串口接收到的数据缓存到接收缓冲区里
uiSendCnt=0; //及时喂狗，虽然main函数那边不断在累加，但是只要串口的数据还没发送完毕，那么它永远也长不大,因为每个中断都被清零。
}
else //我在其它单片机上都不用else这段代码的，可能在51单片机上多增加" TI = 0;"稳定性会更好吧。
{
TI = 0;
}
}
void delay_long(unsigned int uiDelayLong)
{
unsigned int i;
unsigned int j;
for(i=0;i<uiDelayLong;i++)
{
for(j=0;j<500;j++) //内嵌循环的空指令数量
{
; //一个分号相当于执行一条空语句
}
}
}
void initial_myself(void) //第一区初始化单片机
{
beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
//配置定时器
TMOD=0x01; //设置定时器0为工作方式1
TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
TL0=0x0b;
//配置串口
SCON=0x50;
TMOD=0X21;
TH1=TL1=-(11059200L/12/32/9600); //这段配置代码具体是什么意思，我也不太清楚，反正是跟串口波特率有关。
TR1=1;
}
void initial_peripheral(void) //第二区初始化外围
{
EA=1; //开总中断
ES=1; //允许串口中断
ET0=1; //允许定时中断
TR0=1; //启动定时中断
}

复制代码

总结陈词：
这一节讲了判断数据尾的程序框架，但是在大部分的项目中，都是通过判断数据头来接收数据的，这样的程序该怎么写？欲知详情，请听下回分解-----判断数据头来接收一串数据的串口通用程序框架。

（未完待续，下节更精彩，不要走开哦）

吴坚鸿 · 发表于 2014-4-5 11:13:57

xssr123 发表于 2014-4-4 13:43
谢谢LZ，等着你些串口的相关程序

你所期待的串口程序今天已经开讲了。

夜尽天明 · 发表于 2014-4-5 11:23:29

必须得顶一下

mcu_lover · 发表于 2014-4-5 11:41:00

吴坚鸿发表于 2014-4-5 11:10
第三十八节：判断数据尾来接收一串数据的串口通用程序框架。

开场白：

注意变量的保护，这里有隐患。
中断和主程序同时访问了共享变量，需要做好保护。

busterace · 发表于 2014-4-5 12:15:03

mark一下

机器人天空 · 发表于 2014-4-5 13:05:27

哈哈，谢谢鸿哥

吴坚鸿 · 发表于 2014-4-5 14:56:04

mcu_lover 发表于 2014-4-5 11:41
注意变量的保护，这里有隐患。
中断和主程序同时访问了共享变量，需要做好保护。 ...

感谢提醒。我以这样的程序框架做过很多项目了，感觉非常稳定，目前尚未发现隐患，请问，你平时是怎样有效保护共享变量的，是在临界处关闭相关中断还是用中间变量替代判断的方式，请跟我们分享一下，让我也学习学习。谢谢。

mcu_lover · 发表于 2014-4-5 16:14:59

吴坚鸿发表于 2014-4-5 14:56
感谢提醒。我以这样的程序框架做过很多项目了，感觉非常稳定，目前尚未发现隐患，请问，你平时是怎样有效 ...

兄弟，写程序可不能只凭感觉稳定。首先原理上要分析的清楚了，再去实践，这与做的项目多少没有关系。
共享变量不保护出问题的几率小，但是并不代表没有问题，串口丢几个字节，或者蜂鸣器少叫一会儿没有关系，如果是生命攸关的设备呢？
共享变量存在读写不一致的情况，在8位机里尤其严重。当增减变量值会导致高8位数据产生变化时候，这个时候会有一定几率出现读取的值与实际的不一致。
解决办法可以使用临界区保护，如关中断。或者加原子锁保护。

EnterCriticalSection();

//DoSomething();

ExitCriticalSection();

if(!g_Lock)
{
   g_Lock = 1;

   //DoSomething();

   g_Lock = 0;
}

吴坚鸿 · 发表于 2014-4-5 17:39:51

本帖最后由吴坚鸿于 2014-4-5 18:32 编辑

mcu_lover 发表于 2014-4-5 16:14
兄弟，写程序可不能只凭感觉稳定。首先原理上要分析的清楚了，再去实践，这与做的项目多少没有关系。
共 ...

作为一个从业将近十年的单片机工程师，我写程序在一些核心关键的问题上当然不是靠感觉，比如你提到的共享变量保护的问题，其实我在一开始的“第四节：累计定时中断次数使LED灯闪烁。”里面就明确的告诉初学者了，对于要求非常高的项目，一定要在临界点保护数据，而且还附有示范程序代码，不信你可以看看我第四节的内容。但是大部分的项目，其实没必要非要那么做，不然就会把程序写的很繁琐，而且一旦在程序里大量应用这种共享数据保护方法，就会严重影响程序的运行效率，会让程序寸步难行。就像你所说，蜂鸣器的声音就没必要那么严格。其实做一个项目不要指望单片机能方方面面都能照顾到，因为单片机的资源有限，往往顾此失彼，只有把好钢用在刀刃上，去关注这个项目最重要最致命的地方，其它的尽可能越简单越好，我平时就是这样建议我的客户的。就像一台电脑，当你任务运行越多的时候，它的速度和效率必然会下降。

xuehu5808 · 发表于 2014-4-5 18:19:46

吴坚鸿发表于 2014-3-10 13:57
第七节：在主函数中利用累计定时中断的次数来实现独立按键的检测。

开场白：

我处理按键的原理和你相同，这种方法确实抗干扰能力非常强的

吴坚鸿 · 发表于 2014-4-5 18:24:32

本帖最后由吴坚鸿于 2014-4-5 18:37 编辑

xuehu5808 发表于 2014-4-5 18:19
我处理按键的原理和你相同，这种方法确实抗干扰能力非常强的

是的。这种按键的处理方法，让我在大量的工控项目上应用得游刃有余。

fengyunyu · 发表于 2014-4-5 18:37:41

本帖最后由 fengyunyu 于 2014-4-5 18:58 编辑

mcu_lover 发表于 2014-4-5 16:14
兄弟，写程序可不能只凭感觉稳定。首先原理上要分析的清楚了，再去实践，这与做的项目多少没有关系。
共 ...

if(!g_Lock)
{
   g_Lock = 1;

   //DoSomething();

   g_Lock = 0;
}

这种加锁机制，g_lock会不会被中断、高优先级的任务等干扰了？

xuehu5808 · 发表于 2014-4-5 18:41:30

吴坚鸿发表于 2014-4-5 18:24
是的。这种按键的处理方法，让我在大量的工控项目上应用得游刃有余。

不错不错，我以前一直采用延时抗干扰和小抖动，但是机器偶尔会出现误动作，后来才想了这个办法。

吴坚鸿 · 发表于 2014-4-5 18:45:32

xuehu5808 发表于 2014-4-5 18:41
不错不错，我以前一直采用延时抗干扰和小抖动，但是机器偶尔会出现误动作，后来才想了这个办法。{:handsh ...

英雄所见略同，我们都是在实战中遇到过同样类似的问题，然后自己动脑筋想办法解决，所以我们很有共鸣。

zhong1035 · 发表于 2014-4-5 19:15:22

mark 一下

mcu_lover · 发表于 2014-4-5 20:09:57

吴坚鸿发表于 2014-4-5 17:39
作为一个从业将近十年的单片机工程师，我写程序在一些核心关键的问题上当然不是靠感觉，比如你提到的共享 ...

这种观点我认为是不对的，如果一个程序明知道有问题，还自己安慰自己说，没事，顶多就是蜂鸣器叫的时间时长时短，或者时不时的串口数据解析不对。我想也没有用户能够接受。
不会因为说你做了数据的保护，程序就会变得繁琐，更不会出现你说的影响执行效率。
如果效率有问题，一定是程序结构设计的有问题。

mcu_lover · 发表于 2014-4-5 20:10:56

fengyunyu 发表于 2014-4-5 18:37
if(!g_Lock)
{
g_Lock = 1;

没有关系，g_Lock本身就是原子访问的

ddaitt999复活 · 发表于 2014-4-5 20:12:07

这得支持

ddaitt999复活 · 发表于 2014-4-5 20:12:35

这得真心支持

sync765 · 发表于 2014-4-5 22:03:01

进来膜拜学习
先收藏了

吴坚鸿 · 发表于 2014-4-5 23:26:05

mcu_lover 发表于 2014-4-5 20:09
这种观点我认为是不对的，如果一个程序明知道有问题，还自己安慰自己说，没事，顶多就是蜂鸣器叫的时间时 ...

比如我现在这种蜂鸣器程序的写法，估计运行一年也不会发现一次蜂鸣器时长时短的问题，客户是肯定可以接受的。我平时的做法是，一般不加所谓的共享数据保护，除非是非常核心和致命的变量我才加。最后，要感谢你的热心建议，让我知道了那种临界保护数据方法的名称叫“原子锁”，感觉这个名字取得很好听，很好记。

fengyunyu · 发表于 2014-4-6 08:45:15

mcu_lover 发表于 2014-4-5 20:10
没有关系，g_Lock本身就是原子访问的

应该还是有些问题。if (!g_lock)到g_lock=1可能被中断？

mcu_lover · 发表于 2014-4-6 09:00:42

本帖最后由 mcu_lover 于 2014-4-6 09:02 编辑

fengyunyu 发表于 2014-4-6 08:45
应该还是有些问题。if (!g_lock)到g_lock=1可能被中断？

被中断了没有关系啊，中断优先级本来就高于主循环。

ISR里面：
if(!g_Lock)
{
g_Lock = 1;
//修改变量
g_Lock = 0;
}

主程序里：
if(!g_Lock)
{
g_Lock = 1;
//修改变量
g_Lock = 0;
}

关键点在于g_Lock 的访问是原子的，主程序不管在什么地方被中断，都能保证在修改变量的时候，中断是无法修改的。

261854681 · 发表于 2014-4-6 09:50:45

吴坚鸿发表于 2014-3-10 13:56
第六节：在主函数中利用累计主循环次数来实现独立按键的检测。

开场白：

请教一下子:为什么这里的else if(ucKeyLock1==0)//有按键按下，且是第一次被按下 ???
为何不是else if (key_sr1 == 0) ??

吴坚鸿 · 发表于 2014-4-6 12:12:35

本帖最后由吴坚鸿于 2014-4-7 10:22 编辑

mcu_lover 发表于 2014-4-6 09:00
被中断了没有关系啊，中断优先级本来就高于主循环。

ISR里面：

你介绍的原子锁方法还是值得借鉴的。但是如果在定时中断里，就不应该更改g_Lock，否则就会跟主程

序相互干扰。我把你的原子锁修改成以下方案,并且应用在以后的项目上，感谢你的分享。
ISR里面：
if(!g_Lock)
{
//g_Lock = 1; 注意：不要这句,否则会跟主循环相互干扰
//修改变量
//g_Lock = 0; 注意：也不要这句,否则会跟主循环相互干扰
}

主程序里：
if(!g_Lock)
{
g_Lock = 1;
//修改变量
g_Lock = 0;
}

10xjzheng · 发表于 2014-4-6 12:12:58

好人。。。。。。。。。。。。。。。。。

吴坚鸿 · 发表于 2014-4-6 12:18:47

261854681 发表于 2014-4-6 09:50
请教一下子:为什么这里的else if(ucKeyLock1==0)//有按键按下，且是第一次被按下 ???
为何不是else if ( ...

你要把else if(ucKeyLock1==0)前面的语句if(key_sr==1)连起来看就会明白。首先你必须理解C语言中
if(条件)
{ }
else if(条件)
{ }
的具体语法，它们是一对的，不能拆开。
如果if(key_sr==1)这个条件满足，就说明没有按键被按下，就不会再执行后面else if的语句。
如果if(key_sr==1)这个条件不满足，就说明有按键被按下，就必然会执行后面else if的语句。

吴坚鸿 · 发表于 2014-4-6 12:19:38

本帖最后由吴坚鸿于 2014-4-7 08:46 编辑

第三十九节：判断数据头来接收一串数据的串口通用程序框架。

开场白：
上一节讲了判断数据尾的程序框架，但是在大部分的项目中，都是通过判断数据头来接收数据的，这一节要教会大家两个知识点：
第一个：如何在已经接收到的一串数据中解析数据头协议并且提取有效数据。
第二个：无论是判断数据头还是判断数据尾，无论是单片机还是上位机，最好在固定协议前多发送一个填充的无效字节0x00，因为硬件原因，第一个字节往往容易丢失。

具体内容，请看源代码讲解。

（1）硬件平台：
基于朱兆祺51单片机学习板。

（2）实现功能：

波特率是：9600 。
通讯协议：EB 00 55  XX YY
加无效填充字节后,上位机实际上应该发送：00  EB 00 55  XX YY
其中第1位00是无效填充字节，防止由于硬件原因丢失第一个字节。
其中第2,3,4位EB 00 55就是数据头
         后2位XX YY就是有效数据
任意时刻，单片机从电脑“串口调试助手”上位机收到的一串数据中，只要此数据中包含关键字EB 00 55 ，并且此关键字后面两个字节的数据XX YY 分别为01 02,那么蜂鸣器鸣叫一声表示接收的数据头和有效数据都是正确的。

（3）源代码讲解如下：

#include "REG52.H"
#define const_voice_short 40 //蜂鸣器短叫的持续时间
#define const_rc_size 10 //接收串口中断数据的缓冲区数组大小
#define const_receive_time 5 //如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完，这个时间根据实际情况来调整大小
void initial_myself(void);
void initial_peripheral(void);
void delay_long(unsigned int uiDelaylong);
void T0_time(void); //定时中断函数
void usart_receive(void); //串口接收中断函数
void usart_service(void); //串口服务程序,在main函数里
sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
unsigned int uiSendCnt=0; //用来识别串口是否接收完一串数据的计时器
unsigned char ucSendLock=1; //串口服务程序的自锁变量，每次接收完一串数据只处理一次
unsigned int uiRcregTotal=0; //代表当前缓冲区已经接收了多少个数据
unsigned char ucRcregBuf[const_rc_size]; //接收串口中断数据的缓冲区数组
unsigned int uiRcMoveIndex=0; //用来解析数据协议的中间变量
unsigned int uiVoiceCnt=0; //蜂鸣器鸣叫的持续时间计数器
void main()
{
initial_myself();
delay_long(100);
initial_peripheral();
while(1)
{
usart_service(); //串口服务程序
}
}
void usart_service(void) //串口服务程序,在main函数里
{
/* 注释一：
* 识别一串数据是否已经全部接收完了的原理:
* 在规定的时间里，如果没有接收到任何一个字节数据，那么就认为一串数据被接收完了，然后就进入数据协议
* 解析和处理的阶段。这个功能的实现要配合定时中断，串口中断的程序一起阅读，要理解他们之间的关系。
*/
if(uiSendCnt>=const_receive_time&&ucSendLock==1) //说明超过了一定的时间内，再也没有新数据从串口来
{
ucSendLock=0; //处理一次就锁起来，不用每次都进来,除非有新接收的数据
//下面的代码进入数据协议解析和数据处理的阶段
uiRcMoveIndex=0; //由于是判断数据头，所以下标移动变量从数组的0开始向最尾端移动
/* 注释二：
* 判断数据头，进入循环解析数据协议必须满足两个条件:
* 第一：最大接收缓冲数据必须大于一串数据的长度（这里是5。包括2个有效数据，3个数据头）
* 第二：游标uiRcMoveIndex必须小于等于最大接收缓冲数据减去一串数据的长度（这里是5。包括2个有效数据，3个数据头）
*/
while(uiRcregTotal>=5&&uiRcMoveIndex<=(uiRcregTotal-5))
{
if(ucRcregBuf[uiRcMoveIndex+0]==0xeb&&ucRcregBuf[uiRcMoveIndex+1]==0x00&&ucRcregBuf[uiRcMoveIndex+2]==0x55) //数据头eb 00 55的判断
{
if(ucRcregBuf[uiRcMoveIndex+3]==0x01&&ucRcregBuf[uiRcMoveIndex+4]==0x02) //有效数据01 02的判断
{
uiVoiceCnt=const_voice_short; //蜂鸣器发出声音，说明数据头和有效数据都接收正确
}
break; //退出循环
}
uiRcMoveIndex++; //因为是判断数据头，游标向着数组最尾端的方向移动
}
uiRcregTotal=0; //清空缓冲的下标，方便下次重新从0下标开始接受新数据
}
}
void T0_time(void) interrupt 1 //定时中断
{
TF0=0; //清除中断标志
TR0=0; //关中断
if(uiSendCnt<const_receive_time) //如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完
{
uiSendCnt++; //表面上这个数据不断累加，但是在串口中断里，每接收一个字节它都会被清零，除非这个中间没有串口数据过来
ucSendLock=1; //开自锁标志
}
if(uiVoiceCnt!=0)
{
uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
beep_dr=0; //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
}
else
{
; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
beep_dr=1; //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
}
TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
TL0=0x0b;
TR0=1; //开中断
}
void usart_receive(void) interrupt 4 //串口接收数据中断
{
if(RI==1)
{
RI = 0;
++uiRcregTotal;
if(uiRcregTotal>const_rc_size) //超过缓冲区
{
uiRcregTotal=const_rc_size;
}
ucRcregBuf[uiRcregTotal-1]=SBUF; //将串口接收到的数据缓存到接收缓冲区里
uiSendCnt=0; //及时喂狗，虽然main函数那边不断在累加，但是只要串口的数据还没发送完毕，那么它永远也长不大,因为每个中断都被清零。
}
else //我在其它单片机上都不用else这段代码的，可能在51单片机上多增加" TI = 0;"稳定性会更好吧。
{
TI = 0;
}
}
void delay_long(unsigned int uiDelayLong)
{
unsigned int i;
unsigned int j;
for(i=0;i<uiDelayLong;i++)
{
for(j=0;j<500;j++) //内嵌循环的空指令数量
{
; //一个分号相当于执行一条空语句
}
}
}
void initial_myself(void) //第一区初始化单片机
{
beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
//配置定时器
TMOD=0x01; //设置定时器0为工作方式1
TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
TL0=0x0b;
//配置串口
SCON=0x50;
TMOD=0X21;
TH1=TL1=-(11059200L/12/32/9600); //这段配置代码具体是什么意思，我也不太清楚，反正是跟串口波特率有关。
TR1=1;
}
void initial_peripheral(void) //第二区初始化外围
{
EA=1; //开总中断
ES=1; //允许串口中断
ET0=1; //允许定时中断
TR0=1; //启动定时中断
}

复制代码

总结陈词：
这一节讲了常用的判断数据头来接收一串数据的程序框架，但是在很多项目中，仅仅靠判断数据头还是不够的，必须要有更加详细的通讯协议，比如可以包含数据类型，有效数据长度，有效数据，数据校验的通讯协议。这样的程序该怎么写？欲知详情，请听下回分解-----常用的自定义串口通讯协议。

（未完待续，下节更精彩，不要走开哦）

ZJSXHWL000000 · 发表于 2014-4-7 06:28:11

谢谢分享

牛东 · 发表于 2014-4-7 07:26:39

谢谢分享，楼主辛苦了！

ndk · 发表于 2014-4-7 10:13:17

热烈欢迎

吴坚鸿 · 发表于 2014-4-7 10:23:53

mcu_lover 发表于 2014-4-6 09:00
被中断了没有关系啊，中断优先级本来就高于主循环。

ISR里面：

你介绍的原子锁方法还是值得借鉴的。但是如果在定时中断里，就不应该更改g_Lock，否则就会跟主程

序相互干扰。我把你的原子锁修改成以下方案,并且应用在以后的项目上，感谢你的分享。
ISR里面：
if(!g_Lock)
{
//g_Lock = 1; 注意：不要这句,否则会跟主循环相互干扰
//修改变量
//g_Lock = 0; 注意：也不要这句,否则会跟主循环相互干扰
}

主程序里：
if(!g_Lock)
{
g_Lock = 1;
//修改变量
g_Lock = 0;
}

mcu_lover · 发表于 2014-4-7 10:54:02

吴坚鸿发表于 2014-4-7 10:23
你介绍的原子锁方法还是值得借鉴的。但是如果在定时中断里，就不应该更改g_Lock，否则就会跟主程

序相互 ...

有什么干扰呢？
如果有更高优先级中断打断当前中断呢，同时这个高优先级中断也需要修改这个变量呢？考虑过了吗？

吴坚鸿 · 发表于 2014-4-7 12:59:07

mcu_lover 发表于 2014-4-7 10:54
有什么干扰呢？
如果有更高优先级中断打断当前中断呢，同时这个高优先级中断也需要修改这个变量呢？考虑 ...

经过你的提醒，我仔细思考了一下，我觉得你说的很有道理。你的那种写法确实考虑更全面。
我一般不会同时在多个中断里修改变量，为了书写方便，因此我把你的原子锁简化成以下方案,并且应用在以后的项目上，感谢你的分享。
ISR里面：
if(!g_Lock)
{
//g_Lock = 1; 针对我个人用在单个定时中断修改变量的项目中，我省去这句
//直接在这里修改变量
//g_Lock = 0; 针对我个人用在单个定时中断修改变量的项目中，我省去这句
}

主程序里：
//if(!g_Lock) 针对我个人用在单个定时中断修改变量的项目中，我省去这句判断
//{
g_Lock = 1;
//直接在这里修改变量
g_Lock = 0;
//}

吴坚鸿 · 发表于 2014-4-7 13:01:16

本帖最后由吴坚鸿于 2014-4-7 15:31 编辑

第四十节：常用的自定义串口通讯协议。

开场白：
上一节讲了判断数据头的程序框架，但是在很多项目中，仅仅靠判断数据头还是不够的，必须要有更加详细的通讯协议，比如可以包含数据类型，数据地址，有效数据长度，有效数据，数据校验的通讯协议。这一节要教会大家三个知识点：
第一个：常用自定义串口通讯协议的程序框架。
第二个：累加校验和的校验方法。累加和的意思是前面所有字节的数据相加，超过一个字节的溢出部分会按照固定的规则自动丢弃，不用我们管。比如以下数据：
   eb 00 55 01 00 02 00 28 6b
   其中eb 00 55为数据头，01为数据类型，00 02为有效数据长度，00 28 分别为具体的有效数据，6b为前面所有字节的累加和。累加和可以用电脑系统自带的计算器来验证。打开电脑上的计算器，点击“查看”下拉的菜单，选“科学型”，然后选左边的“十六进制”，最后选右边的“字节”，然后把前面所有的字节相加，它们的和就是6b，没错吧。
第三个：原子锁的使用方法，实际上是借鉴了"红金龙吸味"关于原子锁的建议，专门用来保护中断与主函数的共享数据。

具体内容，请看源代码讲解。

（1）硬件平台：
基于朱兆祺51单片机学习板。

（2）实现功能：
  波特率是：9600.
通讯协议：EB 00 55  GG HH HH XX XX …YY YY CY
其中第1,2,3位EB 00 55就是数据头
其中第4位GG就是数据类型。01代表驱动奉命，02代表驱动Led灯。
其中第5,6位HH就是有效数据长度。高位在左，低位在右。
其中第5,6位HH就是有效数据长度。高位在左，低位在右。
其中从第7位开始，到最后一个字节Cy之前，XX..YY都是具体的有效数据。
在本程序中，当数据类型是01时，有效数据代表蜂鸣器鸣叫的时间长度。当数据类型是02时，有效数据代表Led灯点亮的时间长度。
最后一个字节CY是累加和，前面所有字节的累加。
发送以下测试数据，将会分别控制蜂鸣器和Led灯的驱动时间长度。
蜂鸣器短叫发送：eb 00 55 01 00 02 00 28 6b
蜂鸣器长叫发送：eb 00 55 01 00 02 00 fa 3d
Led灯短亮发送：eb 00 55 02 00 02 00 28 6c
Led灯长亮发送：eb 00 55 02 00 02 00 fa 3e

（3）源代码讲解如下：

#include "REG52.H"
/* 注释一：
* 请评估实际项目中一串数据的最大长度是多少，并且留点余量，然后调整const_rc_size的大小。
* 本节程序把上一节的缓冲区数组大小10改成了20
*/
#define const_rc_size 20 //接收串口中断数据的缓冲区数组大小
#define const_receive_time 5 //如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完，这个时间根据实际情况来调整大小
void initial_myself(void);
void initial_peripheral(void);
void delay_long(unsigned int uiDelaylong);
void T0_time(void); //定时中断函数
void usart_receive(void); //串口接收中断函数
void usart_service(void); //串口服务程序,在main函数里
void led_service(void); //Led灯的服务程序。
sbit led_dr=P3^5; //Led的驱动IO口
sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
unsigned int uiSendCnt=0; //用来识别串口是否接收完一串数据的计时器
unsigned char ucSendLock=1; //串口服务程序的自锁变量，每次接收完一串数据只处理一次
unsigned int uiRcregTotal=0; //代表当前缓冲区已经接收了多少个数据
unsigned char ucRcregBuf[const_rc_size]; //接收串口中断数据的缓冲区数组
unsigned int uiRcMoveIndex=0; //用来解析数据协议的中间变量
/* 注释二：
* 为串口计时器多增加一个原子锁，作为中断与主函数共享数据的保护，实际上是借鉴了"红金龙吸味"关于原子锁的建议.
*/
unsigned char ucSendCntLock=0; //串口计时器的原子锁
unsigned int uiVoiceCnt=0; //蜂鸣器鸣叫的持续时间计数器
unsigned char ucVoiceLock=0; //蜂鸣器鸣叫的原子锁
unsigned char ucRcType=0; //数据类型
unsigned int uiRcSize=0; //数据长度
unsigned char ucRcCy=0; //校验累加和
unsigned int uiRcVoiceTime=0; //蜂鸣器发出声音的持续时间
unsigned int uiRcLedTime=0; //在串口服务程序中，Led灯点亮时间长度的中间变量
unsigned int uiLedTime=0; //Led灯点亮时间的长度
unsigned int uiLedCnt=0; //Led灯点亮的计时器
unsigned char ucLedLock=0; //Led灯点亮时间的原子锁
void main()
{
initial_myself();
delay_long(100);
initial_peripheral();
while(1)
{
usart_service(); //串口服务程序
led_service(); //Led灯的服务程序
}
}
void led_service(void)
{
if(uiLedCnt<uiLedTime)
{
led_dr=1; //开Led灯
}
else
{
led_dr=0; //关Led灯
}
}
void usart_service(void) //串口服务程序,在main函数里
{
/* 注释三：
* 我借鉴了朱兆祺的变量命名习惯，单个字母的变量比如i,j,k,h，这些变量只用作局部变量，直接在函数内部定义。
*/
unsigned int i;
if(uiSendCnt>=const_receive_time&&ucSendLock==1) //说明超过了一定的时间内，再也没有新数据从串口来
{
ucSendLock=0; //处理一次就锁起来，不用每次都进来,除非有新接收的数据
//下面的代码进入数据协议解析和数据处理的阶段
uiRcMoveIndex=0; //由于是判断数据头，所以下标移动变量从数组的0开始向最尾端移动
while(uiRcregTotal>=5&&uiRcMoveIndex<=(uiRcregTotal-5))
{
if(ucRcregBuf[uiRcMoveIndex+0]==0xeb&&ucRcregBuf[uiRcMoveIndex+1]==0x00&&ucRcregBuf[uiRcMoveIndex+2]==0x55) //数据头eb 00 55的判断
{
ucRcType=ucRcregBuf[uiRcMoveIndex+3]; //数据类型一个字节
uiRcSize=ucRcregBuf[uiRcMoveIndex+4]; //数据长度两个字节
uiRcSize=uiRcSize<<8;
uiRcSize=uiRcSize+ucRcregBuf[uiRcMoveIndex+5];
ucRcCy=ucRcregBuf[uiRcMoveIndex+6+uiRcSize]; //记录最后一个字节的校验
ucRcregBuf[uiRcMoveIndex+6+uiRcSize]=0; //清零最后一个字节的累加和变量
/* 注释四：
* 计算校验累加和的方法:除了最后一个字节，其它前面所有的字节累加起来，
* 溢出的不用我们管,C语言编译器会按照固定的规则自动处理。
* 以下for循环里的(3+1+2+uiRcSize)，其中3代表3个字节数据头，1代表1个字节数据类型，
* 2代表2个字节的数据长度变量，uiRcSize代表实际上一串数据中的有效数据个数。
*/
for(i=0;i<(3+1+2+uiRcSize);i++) //计算校验累加和
{
ucRcregBuf[uiRcMoveIndex+6+uiRcSize]=ucRcregBuf[uiRcMoveIndex+6+uiRcSize]+ucRcregBuf[i];
}
if(ucRcCy==ucRcregBuf[uiRcMoveIndex+6+uiRcSize]) //如果校验正确，则进入以下数据处理
{
switch(ucRcType) //根据不同的数据类型来做不同的数据处理
{
case 0x01: //驱动蜂鸣器发出声音，并且可以控制蜂鸣器持续发出声音的时间长度
uiRcVoiceTime=ucRcregBuf[uiRcMoveIndex+6]; //把两个字节合并成一个int类型的数据
uiRcVoiceTime=uiRcVoiceTime<<8;
uiRcVoiceTime=uiRcVoiceTime+ucRcregBuf[uiRcMoveIndex+7];
ucVoiceLock=1; //共享数据的原子锁加锁
uiVoiceCnt=uiRcVoiceTime; //蜂鸣器发出声音
ucVoiceLock=0; //共享数据的原子锁解锁
break;
case 0x02: //点亮一个LED灯，并且可以控制LED灯持续亮的时间长度
uiRcLedTime=ucRcregBuf[uiRcMoveIndex+6]; //把两个字节合并成一个int类型的数据
uiRcLedTime=uiRcLedTime<<8;
uiRcLedTime=uiRcLedTime+ucRcregBuf[uiRcMoveIndex+7];
ucLedLock=1; //共享数据的原子锁加锁
uiLedTime=uiRcLedTime; //更改点亮Led灯的时间长度
uiLedCnt=0; //在本程序中，清零计数器就等于自动点亮Led灯
ucLedLock=0; //共享数据的原子锁解锁
break;
}
}
break; //退出循环
}
uiRcMoveIndex++; //因为是判断数据头，游标向着数组最尾端的方向移动
}
uiRcregTotal=0; //清空缓冲的下标，方便下次重新从0下标开始接受新数据
}
}
void T0_time(void) interrupt 1 //定时中断
{
TF0=0; //清除中断标志
TR0=0; //关中断
/* 注释五：
* 此处多增加一个原子锁，作为中断与主函数共享数据的保护，实际上是借鉴了"红金龙吸味"关于原子锁的建议.
*/
if(ucSendCntLock==0) //原子锁判断
{
ucSendCntLock=1; //加锁
if(uiSendCnt<const_receive_time) //如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完
{
uiSendCnt++; //表面上这个数据不断累加，但是在串口中断里，每接收一个字节它都会被清零，除非这个中间没有串口数据过来
ucSendLock=1; //开自锁标志
}
ucSendCntLock=0; //解锁
}
if(ucVoiceLock==0) //原子锁判断
{
if(uiVoiceCnt!=0)
{
uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
beep_dr=0; //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
}
else
{
; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
beep_dr=1; //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
}
}
if(ucLedLock==0) //原子锁判断
{
if(uiLedCnt<uiLedTime)
{
uiLedCnt++; //Led灯点亮的时间计时器
}
}
TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
TL0=0x0b;
TR0=1; //开中断
}
void usart_receive(void) interrupt 4 //串口接收数据中断
{
if(RI==1)
{
RI = 0;
++uiRcregTotal;
if(uiRcregTotal>const_rc_size) //超过缓冲区
{
uiRcregTotal=const_rc_size;
}
ucRcregBuf[uiRcregTotal-1]=SBUF; //将串口接收到的数据缓存到接收缓冲区里
if(ucSendCntLock==0) //原子锁判断
{
ucSendCntLock=1; //加锁
uiSendCnt=0; //及时喂狗，虽然在定时中断那边此变量会不断累加，但是只要串口的数据还没发送完毕，那么它永远也长不大,因为每个串口接收中断它都被清零。
ucSendCntLock=0; //解锁
}
}
else //我在其它单片机上都不用else这段代码的，可能在51单片机上多增加" TI = 0;"稳定性会更好吧。
{
TI = 0;
}
}
void delay_long(unsigned int uiDelayLong)
{
unsigned int i;
unsigned int j;
for(i=0;i<uiDelayLong;i++)
{
for(j=0;j<500;j++) //内嵌循环的空指令数量
{
; //一个分号相当于执行一条空语句
}
}
}
void initial_myself(void) //第一区初始化单片机
{
led_dr=0; //关Led灯
beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
//配置定时器
TMOD=0x01; //设置定时器0为工作方式1
TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
TL0=0x0b;
//配置串口
SCON=0x50;
TMOD=0X21;
TH1=TL1=-(11059200L/12/32/9600); //这段配置代码具体是什么意思，我也不太清楚，反正是跟串口波特率有关。
TR1=1;
}
void initial_peripheral(void) //第二区初始化外围
{
EA=1; //开总中断
ES=1; //允许串口中断
ET0=1; //允许定时中断
TR0=1; //启动定时中断
}

复制代码

总结陈词：
这一节讲了常用的自定义串口通讯协议的程序框架，这种框架在判断一串数据是否接收完毕的时候，都是靠“超过规定的时间内，没有发现串口数据”来判定的，这是我做绝大多数项目的串口程序框架，但是在少数要求实时反应非常快的项目中，我会用另外一种响应速度更快的串口程序框架，这种程序框架是什么样的？欲知详情，请听下回分解-----在串口接收中断里即时解析数据头的特殊程序框架。

（未完待续，下节更精彩，不要走开哦）

Pupil · 发表于 2014-4-7 21:58:32

吴坚鸿发表于 2014-4-6 12:18
你要把else if(ucKeyLock1==0)前面的语句if(key_sr==1)连起来看就会明白。首先你必须理解C语言中
if(条件 ...

else if(ucKeyLock1==0)
若这句成立表明之前没有按键按下,此语句中在计时变量到达设定值后,置位ucKeyLock1,表明有按键了.主程序完成设定操作后,清0.
之后又开始一次新的按键检测

Pupil · 发表于 2014-4-7 21:59:59

吴坚鸿发表于 2014-4-7 13:01
第四十节：常用的自定义串口通讯协议。

开场白：

快点哟,鸿哥,等你

.

asong14437546 · 发表于 2014-4-8 00:38:53

让无数单片机初学者都获益，
非常感谢楼主分享经验

，搬个板凳，认真学习！

jeoo8888 · 发表于 2014-4-9 10:29:37

写得很好，看了都是用数码管来做显示的，现在很多产品都是用定做的段码 HT1621 + LCD 来做显示了，希望鸿哥有时间可以写一些段码 HT1621 + LCD 这方面的。现在很多市面上的产品我都看到了是用定做的段码做显示了。

u123321 · 发表于 2014-4-9 11:03:15

很好的设计思想和程序，学习中，谢谢奉献

sangreal · 发表于 2014-4-9 12:47:24

支持一下

signal_12345 · 发表于 2014-4-9 12:55:18

强悍啊！太高瞻远瞩了！

吴坚鸿 · 发表于 2014-4-9 16:18:29

jeoo8888 发表于 2014-4-9 10:29
写得很好，看了都是用数码管来做显示的，现在很多产品都是用定做的段码 HT1621 + LCD 来做显示了，希望 ...

段码定制的液晶屏项目我做过很多，只要是显示界面的，不管是用数码管，还是液晶屏模块，它的基本程序框架都是一样的。后续我会分享ht1621的驱动程序代码。但是程序框架，你可以借鉴我的数码管或者以后的12864液晶屏的程序框架。

吴坚鸿 · 发表于 2014-4-9 16:23:05

signal_12345 发表于 2014-4-9 12:55
强悍啊！太高瞻远瞩了！

呵呵，感谢你给的好评。

波波维奇 · 发表于 2014-4-9 16:37:14

谢谢奉献

4058665 · 发表于 2014-4-9 16:53:10

支持一下

wangfei1956 · 发表于 2014-4-9 17:20:03

谢谢楼主分享，学习

261854681 · 发表于 2014-4-10 00:15:43

哥，能告诉我们怎样才能练就你这般神奇机巧的算法来？

261854681 · 发表于 2014-4-10 00:24:41

跟着你的思路学到按键和一二级菜单来，确实很巧妙，但如菜单纵深到三级四级时，switch语句似乎不怎么灵光了，前后级跳够让人头晕的，可否有更好的方式来解呢

吴坚鸿 · 发表于 2014-4-10 10:24:02

261854681 发表于 2014-4-10 00:15
哥，能告诉我们怎样才能练就你这般神奇机巧的算法来？

我06年一毕业就开始做项目，那时候没有任何人带，没有任何人教，而且我那时候才第一次知道可以用C语言写单片机程序，于是我自学了C语言，就开始天马行空编写程序，那时从按键，数码管最底层的程序开始不断摸索调试，我的第一个程序没有任何框架可言，想到什么就写什么，糟糕透了。在后续长年累月的项目中，我不断改进程序框架，不断优化程序框架，不断总结它的规律，终于成了你所说的“这般神奇机巧的算法”。

吴坚鸿 · 发表于 2014-4-10 10:29:04

261854681 发表于 2014-4-10 00:24
跟着你的思路学到按键和一二级菜单来，确实很巧妙，但如菜单纵深到三级四级时，switch语句似乎不怎么灵光了 ...

我不赞成你的观点。switch语句是万能的。2级菜单的时候，我就用2个窗口变量。如果有5级菜单的时候，我就用5个窗口变量。它的切换是非常清晰和灵光的，我一直以来就是这么干的。当然，在实际项目中，用的菜单级数越少越好，菜单级数越少就意味着用户体验越好，操作越简单，一般不要玩太花俏的多级菜单。

hgy_tom · 发表于 2014-4-10 10:32:31

不错,顶!

mhw · 发表于 2014-4-10 10:36:00

楼主以前被拍砖很惨……现在清理了一下注释里无处不在的大名，感觉好多了……

mcu_lover · 发表于 2014-4-10 10:58:43

吴坚鸿发表于 2014-4-10 10:29
我不赞成你的观点。switch语句是万能的。2级菜单的时候，我就用2个窗口变量。如果有5级菜单的时候，我就 ...

这样就谈不上结构了，更不能称之为框架。只能叫做代码示例。
也注定只能适应小的应用。而且每次应用都需要重新构建。
人机交互是一门很深很深的学问。可以多了解一下MVC模式，对如何编写合格的人机交互代码大有裨益。
如果一个程序可以称之为框架，则一定是你设计应用代码，框架来调用。这样框架就可以复用，框架才有框架存在的意义。你也写过VC的程序，应该知道这点。
另外，关于状态机，这个坛子里有非常多精彩的的例子和讲解。switch只是最基础的一式，并不是万能的。这一点上你需要多了解下。
程序讲究低耦合，高内聚，你这样写出来的程序，复用性为0.

我是专门负责拍砖头的，不要介意。

sdlibin007 · 发表于 2014-4-10 11:07:16

楼主也是高手！！

吴坚鸿 · 发表于 2014-4-10 12:04:39

mhw 发表于 2014-4-10 10:36
楼主以前被拍砖很惨……现在清理了一下注释里无处不在的大名，感觉好多了…… ...

那是我个人的心态在转变。以前就是想过过出名的瘾。

吴坚鸿 · 发表于 2014-4-10 12:11:22

本帖最后由吴坚鸿于 2014-4-10 12:14 编辑

mcu_lover 发表于 2014-4-10 10:58
这样就谈不上结构了，更不能称之为框架。只能叫做代码示例。
也注定只能适应小的应用。而且每次应用都需 ...

我这里所说的框架，就是有规律的编程思路，我认为这种编程思路是可以复用的，我现在做什么项目都是按照这种思路来编程的，实践已经证明了这一点，包括很多初学我这种程序框架的网友，他们的反馈都非常好。我现在分享的表面上是代码示例，实际上我把我固有的编程模式融进了每个程序示例里，让初学者更加容易学习理解。至于你所说的，我觉得很专业，虽然我看不懂你讲的是什么意思，但是等我有时间的时候还是会去学习学习。

dahai168 · 发表于 2014-4-10 12:17:31

很好,学习下

机器人天空 · 发表于 2014-4-10 12:27:41

mark......

huangsiyu · 发表于 2014-4-10 12:42:18

记号，留着以后慢慢看

wildone · 发表于 2014-4-10 13:40:03

欢迎牛人

heiyuu1 · 发表于 2014-4-10 19:18:32

精彩纷呈，让我写了几年程序的受益匪浅啊，不顶不是人

oner · 发表于 2014-4-10 21:41:47

看了下部分代码，思路都很清晰呢，不错。Mark。

allenjwb · 发表于 2014-4-10 22:32:56

这个可以有

吴坚鸿 · 发表于 2014-4-10 23:17:04

heiyuu1 发表于 2014-4-10 19:18
精彩纷呈，让我写了几年程序的受益匪浅啊，不顶不是人

感谢你给的好评，让我倍受鼓舞。

jeoo8888 · 发表于 2014-4-11 08:55:45

一直都想写一个可以通用的按键程序，在网上找了很多都感觉不是很好，有些看不明，有些用了delay，自从看了鸿哥的这个贴后
让我很快就心领神会.。学鸿哥的这个贴可以说是让我们这些入门不久的学者有一种座飞机的感觉。以前是走路现在可以座飞机了。
鸿哥这种写法很好，以后我就学鸿哥的这样写法了，不用再棵跑了。真心感谢鸿哥。

qinshiysb · 发表于 2014-4-11 14:24:06

吴坚鸿发表于 2014-3-10 12:32
谁说“一女不可以侍二夫”？
我到处混，没有许身于任何论坛网站。
我是很开放的，目的就是分 ...

赞一个！！！

caizhiwei · 发表于 2014-4-11 16:21:18

diao!!支持支持

吴坚鸿 · 发表于 2014-4-11 17:23:46

jeoo8888 发表于 2014-4-11 08:55
一直都想写一个可以通用的按键程序，在网上找了很多都感觉不是很好，有些看不明，有些用了delay，自从看了 ...

呵呵，让每个单片机初学者都能“坐上飞机”是我最大的梦想

。希望你能把我的程序介绍给更多初学者。

ericdai · 发表于 2014-4-11 18:52:08

楼主是那个辞职创业的兄弟吗

电子小生 · 发表于 2014-4-11 19:55:45

mark

Feco · 发表于 2014-4-11 22:27:31

支持一下，mark学习!

吴坚鸿 · 发表于 2014-4-11 22:59:55

本帖最后由吴坚鸿于 2014-4-11 23:01 编辑

ericdai 发表于 2014-4-11 18:52
楼主是那个辞职创业的兄弟吗

你说的那个辞职创业的兄弟是不是发明液晶万能测试仪并且获得了国家发明专利那个牛人？没错，那个兄弟就是我本人。

从业将近十年！手把手教你单片机程序框架（连载）

本帖子中包含更多资源

本帖子中包含更多资源