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

jianhong_wu · 发表于 2014-5-28 12:31:31

第四十九节：利用DS18B20做一个温控器  。

开场白：
   DS18B20是一款常用的温度传感器芯片，它只占用单片机一根IO口，使用起来也特别方便。需要特别注意的是，正因为它只用一根IO口跟单片机通讯，因此读取一次温度值的通讯时间比较长，而且时序要求严格，在通讯期间不允许被单片机其它的中断干扰，因此在实际项目中，系统一旦选用了这款传感器芯片，就千万不要选用动态扫描数码管的显示方式。否则在关闭中断读取温度的时候，数码管的显示会有略微的“闪烁”现象。
   DS18B20的测温范围是-55度至125度。在-10度至85度的温度范围内误差是+-0.5度，能满足大部分常用的测温要求。
这一节要教会大家三个知识点：
第一个：大概了解一下DS18B20的驱动程序。
第二个：做温控设备的时候，为了避免继电器在临界温度附近频繁跳动切换，应该设置一个缓冲温差。本程序的缓冲温差是2度。
第三个：继续加深了解按键，显示，传感器它们三者是如何紧密关联起来的程序框架。

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

（1）硬件平台.
基于坚鸿51单片机学习板。

（2）实现功能：
   本程序只有1个窗口。这个窗口有2个局部显示。
第1个局部是第7,6,5位数码管，显示设定的温度。
第2个局部是第4,3,2,1位数码管，显示实际环境温度。其中第4位数码管显示正负符号位。
S1按键是加键，S5按键是减键。通过它们可以直接设置“设定温度”。
一个LED灯用来模拟工控的继电器。
当实际温度低于或者等于设定温度2度以下时，模拟继电器的LED灯亮。
当实际温度等于或者大于设定温度时，模拟继电器的LED灯灭。
当实际温度处于设定温度和设定温度减去2度的范围内，模拟继电器的LED维持现状，这个2度范围用来做缓冲温差，避免继电器在临界温度附近频繁跳动切换。

（3）源代码讲解如下：

#include "REG52.H"
#define const_voice_short 40 //蜂鸣器短叫的持续时间
#define const_key_time1 20 //按键去抖动延时的时间
#define const_key_time2 20 //按键去抖动延时的时间
#define const_ds18b20_sampling_time 180 //累计主循环次数的时间，每次刷新采样时钟芯片的时间
void initial_myself(void);
void initial_peripheral(void);
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); //显示数码管字模的驱动函数
void display_service(void); //显示的窗口菜单服务程序
//驱动LED的74HC595
void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01);
void T0_time(void); //定时中断函数
void key_service(void); //按键服务的应用程序
void key_scan(void);//按键扫描函数放在定时中断里
void temper_control_service(void); //温控程序
void ds18b20_sampling(void); //ds18b20采样程序
void ds18b20_reset(); //复位ds18b20的时序
unsigned char ds_read_byte(void ); //读一字节
void ds_write_byte(unsigned char dat); //写一个字节
unsigned int get_temper(); //读取一次没有经过换算的温度数值
sbit dq_dr_sr=P2^6; //ds18b20的数据驱动线
sbit key_sr1=P0^0; //对应朱兆祺学习板的S1键
sbit key_sr2=P0^1; //对应朱兆祺学习板的S5键
sbit led_dr=P3^5; //LED灯，模拟工控中的继电器
sbit key_gnd_dr=P0^4; //模拟独立按键的地GND，因此必须一直输出低电平
sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
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 int uiSampingCnt=0; //采集Ds1302的计时器，每秒钟更新采集一次
unsigned char ucSignFlag=0; //正负符号。0代表正数，1代表负数，表示零下多少度。
unsigned long ulCurrentTemper=33; //实际温度
unsigned long ulSetTemper=26; //设定温度
unsigned int uiTemperTemp=0; //中间变量
unsigned char ucKeySec=0; //被触发的按键编号
unsigned int uiKeyTimeCnt1=0; //按键去抖动延时计数器
unsigned char ucKeyLock1=0; //按键触发后自锁的变量标志
unsigned int uiKeyTimeCnt2=0; //按键去抖动延时计数器
unsigned char ucKeyLock2=0; //按键触发后自锁的变量标志
unsigned int uiVoiceCnt=0; //蜂鸣器鸣叫的持续时间计数器
unsigned char ucVoiceLock=0; //蜂鸣器鸣叫的原子锁
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 ucWd=1; //因为本程序只有1个窗口，在实际项目中，此处的ucWd也可以省略不要
unsigned char ucWd1Part1Update=1; //在窗口1中，局部1的更新显示标志
unsigned char ucWd1Part2Update=1; //在窗口1中，局部2的更新显示标志
unsigned char ucTemp1=0; //中间过渡变量
unsigned char ucTemp2=0; //中间过渡变量
unsigned char ucTemp3=0; //中间过渡变量
unsigned char ucTemp4=0; //中间过渡变量
unsigned char ucTemp5=0; //中间过渡变量
unsigned char ucTemp6=0; //中间过渡变量
unsigned char ucTemp7=0; //中间过渡变量
unsigned char ucTemp8=0; //中间过渡变量
//根据原理图得出的共阴数码管字模表
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
};
void main()
{
initial_myself();
delay_long(100);
initial_peripheral();
while(1)
{
key_service(); //按键服务的应用程序
ds18b20_sampling(); //ds18b20采样程序
temper_control_service(); //温控程序
display_service(); //显示的窗口菜单服务程序
}
}
/* 注释一：
* 做温控设备的时候，为了避免继电器在临界温度附近频繁跳动切换，应该设置一个
* 缓冲温差。本程序的缓冲温差是2度。
*/
void temper_control_service(void) //温控程序
{
if(ucSignFlag==0) //是正数的前提下
{
if(ulCurrentTemper>=ulSetTemper) //当实际温度大于等于设定温度时
{
led_dr=0; //模拟继电器的LED灯熄灭
}
else if(ulCurrentTemper<=(ulSetTemper-2)) //当实际温度小于等于设定温度2读以下时，这里的2是缓冲温差2度
{
led_dr=1; //模拟继电器的LED灯点亮
}
}
else //是负数，说明是零下多少度的情况下
{
led_dr=1; //模拟继电器的LED灯点亮
}
}
void ds18b20_sampling(void) //ds18b20采样程序
{
++uiSampingCnt; //累计主循环次数的时间
if(uiSampingCnt>const_ds18b20_sampling_time) //每隔一段时间就更新采集一次Ds18b20数据
{
uiSampingCnt=0;
ET0=0; //禁止定时中断
uiTemperTemp=get_temper(); //读取一次没有经过换算的温度数值
ET0=1; //开启定时中断
if((uiTemperTemp&0xf800)==0xf800) //是负号
{
ucSignFlag=1;
uiTemperTemp=~uiTemperTemp; //求补码
uiTemperTemp=uiTemperTemp+1;
}
else //是正号
{
ucSignFlag=0;
}
ulCurrentTemper=0; //把int数据类型赋给long类型之前要先清零
ulCurrentTemper=uiTemperTemp;
ulCurrentTemper=ulCurrentTemper*10; //为了先保留一位小数点，所以放大10倍，
ulCurrentTemper=ulCurrentTemper>>4; //往右边移动4位，相当于乘以0.0625. 此时保留了1位小数点，
ulCurrentTemper=ulCurrentTemper+5; //四舍五入
ulCurrentTemper=ulCurrentTemper/10; //四舍五入后，去掉小数点
ucWd1Part2Update=1; //局部2更新显示实时温度
}
}
//ds18b20驱动程序
unsigned int get_temper() //读取一次没有经过换算的温度数值
{
unsigned char temper_H;
unsigned char temper_L;
unsigned int ds18b20_data=0;
ds18b20_reset(); //复位ds18b20的时序
ds_write_byte(0xCC);
ds_write_byte(0x44);
ds18b20_reset(); //复位ds18b20的时序
ds_write_byte(0xCC);
ds_write_byte(0xBE);
temper_L=ds_read_byte();
temper_H=ds_read_byte();
ds18b20_data=temper_H; //把两个字节合并成一个int数据类型
ds18b20_data=ds18b20_data<<8;
ds18b20_data=ds18b20_data|temper_L;
return ds18b20_data;
}
void ds18b20_reset() //复位ds18b20的时序
{
unsigned char x;
dq_dr_sr=1;
delay_short(8);
dq_dr_sr=0;
delay_short(80);
dq_dr_sr=1;
delay_short(14);
x=dq_dr_sr;
delay_short(20);
}
void ds_write_byte(unsigned char date) //写一个字节
{
unsigned char i;
for(i=0;i<8;i++)
{
dq_dr_sr=0;
dq_dr_sr=date&0x01;
delay_short(5);
dq_dr_sr=1;
date=date>>1;
}
}
unsigned char ds_read_byte(void ) //读一字节
{
unsigned char i;
unsigned char date=0;
for(i=0;i<8;i++)
{
dq_dr_sr=0;
date=date>>1;
dq_dr_sr=1;
if(dq_dr_sr)
{
date=date|0x80;
}
delay_short(5);
}
return (date);
}
void display_service(void) //显示的窗口菜单服务程序
{
switch(ucWd) //因为本程序只有1个窗口，在实际项目中，此处的ucWd也可以省略不要
{
case 1:
if(ucWd1Part1Update==1)//局部设定温度更新显示
{
ucWd1Part1Update=0;
ucTemp8=10; //显示空
if(ulSetTemper>=100)
{
ucTemp7=ulSetTemper%1000/100; //显示设定温度的百位
}
else
{
ucTemp7=10; //显示空
}
if(ulSetTemper>=10)
{
ucTemp6=ulSetTemper%100/10; //显示设定温度的十位
}
else
{
ucTemp6=10; //显示空
}
ucTemp5=ulSetTemper%10; //显示设定温度的个位
ucDigShow8=ucTemp8; //数码管显示实际内容
ucDigShow7=ucTemp7;
ucDigShow6=ucTemp6;
ucDigShow5=ucTemp5;
}
if(ucWd1Part2Update==1)//局部实际温度更新显示
{
if(ucSignFlag==0) //正数
{
ucTemp4=10; //显示空
}
else //负数，说明是零下多少度的情况下
{
ucTemp4=11; //显示负号-
}
if(ulCurrentTemper>=100)
{
ucTemp3=ulCurrentTemper%100/100; //显示实际温度的百位
}
else
{
ucTemp3=10; //显示空
}
if(ulCurrentTemper>=10)
{
ucTemp2=ulCurrentTemper%100/10; //显示实际温度的十位
}
else
{
ucTemp2=10; //显示空
}
ucTemp1=ulCurrentTemper%10; //显示实际温度的个数位
ucDigShow4=ucTemp4; //数码管显示实际内容
ucDigShow3=ucTemp3;
ucDigShow2=ucTemp2;
ucDigShow1=ucTemp1;
}
break;
}
}
void key_scan(void)//按键扫描函数放在定时中断里
{
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号键
}
}
}
void key_service(void) //按键服务的应用程序
{
switch(ucKeySec) //按键服务状态切换
{
case 1:// 加按键对应朱兆祺学习板的S1键
switch(ucWd) //因为本程序只有1个窗口，在实际项目中，此处的ucWd也可以省略不要
{
case 1: //在窗口1下设置设定温度
ulSetTemper++;
if(ulSetTemper>125)
{
ulSetTemper=125;
}
ucWd1Part1Update=1; //更新显示设定温度
break;
}
ucVoiceLock=1; //原子锁加锁，保护主函数与中断函数的共享变量uiVoiceCnt
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucVoiceLock=0; //原子锁解锁，保护主函数与中断函数的共享变量uiVoiceCnt
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
case 2:// 减按键对应朱兆祺学习板的S5键
switch(ucWd) //因为本程序只有1个窗口，在实际项目中，此处的ucWd也可以省略不要
{
case 1: //在窗口1下设置设定温度
if(ulSetTemper>2) //由于缓冲温差是2度，所以我人为规定最小允许设定的温度不能低于2度
{
ulSetTemper--;
}
ucWd1Part1Update=1; //更新显示设定温度
break;
}
ucVoiceLock=1; //原子锁加锁，保护主函数与中断函数的共享变量uiVoiceCnt
uiVoiceCnt=const_voice_short; //按键声音触发，滴一声就停。
ucVoiceLock=0; //原子锁解锁，保护主函数与中断函数的共享变量uiVoiceCnt
ucKeySec=0; //响应按键服务处理程序后，按键编号清零，避免一致触发
break;
}
}
void display_drive(void)
{
//以下程序，如果加一些数组和移位的元素，还可以压缩容量。但是鸿哥追求的不是容量，而是清晰的讲解思路
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 T0_time(void) interrupt 1 //定时中断
{
TF0=0; //清除中断标志
TR0=0; //关中断
if(ucVoiceLock==0) //原子锁判断
{
if(uiVoiceCnt!=0)
{
uiVoiceCnt--; //每次进入定时中断都自减1，直到等于零为止。才停止鸣叫
beep_dr=0; //蜂鸣器是PNP三极管控制，低电平就开始鸣叫。
}
else
{
; //此处多加一个空指令，想维持跟if括号语句的数量对称，都是两条指令。不加也可以。
beep_dr=1; //蜂鸣器是PNP三极管控制，高电平就停止鸣叫。
}
}
key_scan(); //按键扫描函数
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(void) //第一区初始化单片机
{
led_dr=0;//此处的LED灯模拟工控中的继电器
key_gnd_dr=0; //模拟独立按键的地GND，因此必须一直输出低电平
beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
hc595_drive(0x00,0x00); //关闭所有经过另外两个74HC595驱动的LED灯
TMOD=0x01; //设置定时器0为工作方式1
TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
TL0=0x0b;
}
void initial_peripheral(void) //第二区初始化外围
{
ucDigDot8=0; //小数点全部不显示
ucDigDot7=0;
ucDigDot6=0;
ucDigDot5=0;
ucDigDot4=0;
ucDigDot3=0;
ucDigDot2=0;
ucDigDot1=0;
EA=1; //开总中断
ET0=1; //允许定时中断
TR0=1; //启动定时中断
}

复制代码

总结陈词：
下一节开始讲单片机采集模拟信号的内容，欲知详情，请听下回分解-----利用ADC0832采集电压的模拟信号。

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

jianhong_wu · 发表于 2014-6-5 15:56:31

第五十节：利用ADC0832采集电压信号，用平均法和区间法进行软件滤波处理。

开场白：
ADC0832是一款常用的8位AD采样芯片，通过它可以把外部的模拟电压信号转换成数字信号，然后给单片机进行换算，显示等处理。
这一节要教会大家五个知识点：
第一个：分辨率的算法。有些书上说8位AD最高分辩可达到256级(0xff+1)，当输入电压是0---5V时，电压精度为19.53mV(5000mV除以256)，我认为这种说法是错误的。8位AD的最高分辨率应该是255级(0xff)，当输入电压是0---5V时，电压精度为19.61mV(5000mV除以255)。
第二个：用求平均值的滤波法，可以使AD采样的数据更加圆滑，去除小毛刺。
第三个：用区间滤波法，在一些干扰很大的场合，可以避免末尾小数点的数据频繁跳动。
第四个：如何使系统可以采集到更高的电压。由于ADC0832直接采集的电压最大不能超过5V，如果要采集的最大电压是25V该怎么办？我们只要在外部多增加1个10K的电阻和1个40K的电阻组成分压电路，把25V分压成5V，然后再让ADC0832采样，这时采样到的数据只要乘以5的系数，就可以得到超过5V的实际电压。选择分压电阻时，阻值尽量不要太小，一般要10K级别以上，阻值大一点，对被采样的系统干扰影响就越小。
第五个：如何有效保护AD通道口。我在一些电压不稳定的工控场合，一般是在AD通道口对负极反接一个瞬变二极管SA5.0A。当电压超过5V时，瞬变二极管会导通吸收掉多余的能量，把电压降下来，避免AD通道口烧坏。

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

（1）硬件平台.
基于坚鸿51单片机学习板。

（2）实现功能：
本程序有2个局部显示。
第1个局部是第8,7,6,5位数码管，显示没有经过滤波处理的实际电压值。此时能观察到未经滤波的数据不太稳定，末尾小数点数据会有跳动的现象
第2个局部是第4,3,2,1位数码管，显示经过平均法，区间法滤波的实际电压值。此时能观察到经过滤波后的数据很稳定，没有跳动的现象

系统保留3位小数点。手动调节可调电阻时，可以看到显示的数据在变化。

（3）源代码讲解如下：

#include "REG52.H"
#define const_voice_short 40 //蜂鸣器短叫的持续时间
void initial_myself(void);
void initial_peripheral(void);
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); //显示数码管字模的驱动函数
void display_service(void); //显示的窗口菜单服务程序
//驱动LED的74HC595
void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01);
void T0_time(void); //定时中断函数
void ad_sampling_service(void); //AD采样与处理的服务程序
sbit led_dr=P3^5; //LED灯
sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
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;
sbit adc0832_clk_dr = P1^2; // 定义adc0832的引脚
sbit adc0832_cs_dr = P1^0;
sbit adc0832_data_sr_dr = P1^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 ucTemp1=0; //中间过渡变量
unsigned char ucTemp2=0; //中间过渡变量
unsigned char ucTemp3=0; //中间过渡变量
unsigned char ucTemp4=0; //中间过渡变量
unsigned char ucTemp5=0; //中间过渡变量
unsigned char ucTemp6=0; //中间过渡变量
unsigned char ucTemp7=0; //中间过渡变量
unsigned char ucTemp8=0; //中间过渡变量
unsigned char ucAD=0; //AD值
unsigned char ucCheckAD=0; //用来做校验对比的AD值
unsigned long ulTemp=0; //参与换算的中间变量
unsigned long ulTempFilterV=0; //参与换算的中间变量
unsigned long ulBackupFilterV=5000; //备份最新采样数据的中间变量
unsigned char ucSamplingCnt=0; //统计采样的次数本程序采样8次后求平均值
unsigned long ulV=0; //未经滤波处理的实时电压值
unsigned long ulFilterV=0; //经过滤波后的实时电压值
//根据原理图得出的共阴数码管字模表
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
};
void main()
{
initial_myself();
delay_long(100);
initial_peripheral();
while(1)
{
ad_sampling_service(); //AD采样与处理的服务程序
display_service(); //显示的窗口菜单服务程序
}
}
void ad_sampling_service(void) //AD采样与处理的服务程序
{
unsigned char i;
ucAD=0; //AD值
ucCheckAD=0; //用来做校验对比的AD值
/* 片选信号置为低电平 */
adc0832_cs_dr = 0;
/* 第一个脉冲，开始位 */
adc0832_data_sr_dr = 1;
adc0832_clk_dr = 0;
delay_short(1);
adc0832_clk_dr = 1;
/* 第二个脉冲，选择通道 */
adc0832_data_sr_dr = 1;
adc0832_clk_dr = 0;
adc0832_clk_dr = 1;
/* 第三个脉冲，选择通道 */
adc0832_data_sr_dr = 0;
adc0832_clk_dr = 0;
adc0832_clk_dr = 1;
/* 数据线输出高电平 */
adc0832_data_sr_dr = 1;
delay_short(2);
/* 第一个下降沿 */
adc0832_clk_dr = 1;
adc0832_clk_dr = 0;
delay_short(1);
/* AD值开始送出 */
for (i = 0; i < 8; i++)
{
ucAD <<= 1;
adc0832_clk_dr = 1;
adc0832_clk_dr = 0;
if (adc0832_data_sr_dr==1)
{
ucAD |= 0x01;
}
}
/* 用于校验的AD值开始送出 */
for (i = 0; i < 8; i++)
{
ucCheckAD >>= 1;
if (adc0832_data_sr_dr==1)
{
ucCheckAD |= 0x80;
}
adc0832_clk_dr = 1;
adc0832_clk_dr = 0;
}
/* 片选信号置为高电平 */
adc0832_cs_dr = 1;
if(ucCheckAD==ucAD) //检验相等
{
ulTemp=0; //把char类型数据赋值给long类型数据之前，必须先清零
ulTemp=ucAD; //把char类型数据赋值给long类型数据,参与乘除法运算的数据，为了避免运算结果溢出，我都用long类型
/* 注释一：
* 因为保留3为小数点，这里的5000代表5.000V。ulTemp/255代表分辨率.
* 有些书上说8位AD最高分辩可达到256级(0xff+1)，我认为这种说法是错误的。
* 8位AD最高分辩应该是255级(0xff)，所以这里除以255，而不是256.
*/
ulTemp=5000*ulTemp/255; //进行电压换算
ulV=ulTemp; //得到未经滤波处理的实时电压值
ucWd1Part1Update=1; //局部更新显示未经滤波处理的电压
ulTempFilterV=ulTempFilterV+ulTemp; //累加8次后求平均值
ucSamplingCnt++; //统计已经采样累计的次数
if(ucSamplingCnt>=8)
{
/* 注释二：
* 求平均值滤波法，为了得到的数据更加圆滑，去除小毛刺。
* 向右边移动3位相当于除以8。
*/
ulTempFilterV=ulTempFilterV>>3; //求平均值滤波法
/* 注释三：
* 以下区间滤波法，为了避免末尾小数点的数据频繁跳动。
* 这里的20用于区间滤波法的正负偏差，这里的20代表0.020V。
* 意思是只要最近采集到的数据在正负0.020V偏差范围内，就不更新。
*/
if(ulBackupFilterV>=20) //最近备份的上一次数据大于等于0.02V的情况下
{
if(ulTempFilterV<(ulBackupFilterV-20)||ulTempFilterV>(ulBackupFilterV+20)) //在正负0.020V偏差范围外，更新
{
ulBackupFilterV=ulTempFilterV; //备份最新采样的数据,方便下一次对比判断
ulFilterV=ulTempFilterV; //得到经过滤波处理的实时电压值
ucWd1Part2Update=1; //局部更新显示经过滤波处理的电压
}
}
else //最近备份的上一次数据小于0.02V的情况下
{
if(ulTempFilterV>(ulBackupFilterV+20)) //在正0.020V偏差范围外，更新
{
ulBackupFilterV=ulTempFilterV; //备份最新采样的数据,方便下一次对比判断
ulFilterV=ulTempFilterV; //得到经过滤波处理的实时电压值
ucWd1Part2Update=1; //局部更新显示经过滤波处理的电压
}
}
ucSamplingCnt=0; //清零，为下一轮采样滤波作准备。
ulTempFilterV=0;
}
}
}
void display_service(void) //显示的窗口菜单服务程序
{
if(ucWd1Part1Update==1)//未经滤波处理的实时电压更新显示
{
ucWd1Part1Update=0;
ucTemp8=ulV%10000/1000; //显示电压值个位
ucTemp7=ulV%1000/100; //显示电压值小数点后第1位
ucTemp6=ulV%100/10; //显示电压值小数点后第2位
ucTemp5=ulV%10; //显示电压值小数点后第3位
ucDigShow8=ucTemp8; //数码管显示实际内容
ucDigShow7=ucTemp7;
ucDigShow6=ucTemp6;
ucDigShow5=ucTemp5;
}
if(ucWd1Part2Update==1)//经过滤波处理后的实时电压更新显示
{
ucWd1Part2Update=0;
ucTemp4=ulFilterV%10000/1000; //显示电压值个位
ucTemp3=ulFilterV%1000/100; //显示电压值小数点后第1位
ucTemp2=ulFilterV%100/10; //显示电压值小数点后第2位
ucTemp1=ulFilterV%10; //显示电压值小数点后第3位
ucDigShow4=ucTemp4; //数码管显示实际内容
ucDigShow3=ucTemp3;
ucDigShow2=ucTemp2;
ucDigShow1=ucTemp1;
}
}
void display_drive(void)
{
//以下程序，如果加一些数组和移位的元素，还可以压缩容量。但是鸿哥追求的不是容量，而是清晰的讲解思路
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 T0_time(void) interrupt 1 //定时中断
{
TF0=0; //清除中断标志
TR0=0; //关中断
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(void) //第一区初始化单片机
{
led_dr=0;//LED灯默认关闭
beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
hc595_drive(0x00,0x00); //关闭所有经过另外两个74HC595驱动的LED灯
TMOD=0x01; //设置定时器0为工作方式1
TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
TL0=0x0b;
}
void initial_peripheral(void) //第二区初始化外围
{
ucDigDot8=1; //显示未经过滤波电压的小数点
ucDigDot7=0;
ucDigDot6=0;
ucDigDot5=0;
ucDigDot4=1; //显示经过滤波后电压的小数点
ucDigDot3=0;
ucDigDot2=0;
ucDigDot1=0;
EA=1; //开总中断
ET0=1; //允许定时中断
TR0=1; //启动定时中断
}

复制代码

总结陈词：
这节用区间滤波法虽然可以解决小数点后面的数据出现频繁跳动的现象，但是也存在一个小问题，就是精度受到了影响，比如我们设置的正负偏差是0.02V，那就意味着系统存在0.02V的误差。有没有更好的办法解决这个问题？如果系统的末尾数据一直不断处于频繁跳动中，那么只能牺牲一点精度，我认为用区间法已经是最好的解决办法了，但是经过本次实验，我观察到未经过滤波处理的数据只是偶尔跳动，并非频繁跳动，所以下一节我会给大家介绍一种不用牺牲精度，又可以很好滤波的方法。欲知详情，请听下回分解-----利用ADC0832采集电压信号，用连续N次一致性的方法进行滤波处理。

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

jianhong_wu · 发表于 2014-6-15 12:21:25

第五十一节：利用ADC0832采集电压信号，用连续N次一致性的方法进行滤波处理。

开场白：
连续判断N次一致性的滤波法，是为了避免末尾小数点的数据偶尔跳动。这种滤波方法的原理跟我在按键扫描中去抖动的原理是一模一样的，被我频繁地应用在大量的工控项目中。
这一节要教会大家一个知识点：连续判断N次一致性的滤波法。
具体原理：当某个采样变量发生变化时，有两种可能，一种可能是外界的一个瞬间干扰。另一种可能是变量确实发生变化。为了有效去除干扰，当发现变量有变化时，我会连续采集N次，如果连续N次都是一致的结果，我才认为不是干扰。如果中间只要出现一次不一致，我会马上把计数器清零，这一步是精华，很关键。

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

（1）硬件平台.
基于坚鸿51单片机学习板。

（2）实现功能：
本程序有2个局部显示。
第1个局部是第8,7,6,5位数码管，显示没有经过滤波处理的实际电压值。此时能观察到未经滤波的数据不太稳定，末尾小数点数据会有跳动的现象
第2个局部是第4,3,2,1位数码管，显示经过特定算法滤波后的实际电压值。此时能观察到经过滤波后的数据很稳定，没有跳动的现象。而且显示的电压值跟未经过滤波的电压值几乎是完全一致，不会出现上一节用区间滤波法所留下的0.02V误差问题。
系统保留3位小数点。手动调节可调电阻时，可以看到显示的数据在变化。

（3）源代码讲解如下：

#include "REG52.H"
#define const_N 8 //连续判断N次一致性滤波方法中，N的取值
#define const_voice_short 40 //蜂鸣器短叫的持续时间
void initial_myself(void);
void initial_peripheral(void);
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); //显示数码管字模的驱动函数
void display_service(void); //显示的窗口菜单服务程序
//驱动LED的74HC595
void hc595_drive(unsigned char ucLedStatusTemp16_09,unsigned char ucLedStatusTemp08_01);
void T0_time(void); //定时中断函数
void ad_sampling_service(void); //AD采样与处理的服务程序
sbit led_dr=P3^5; //LED灯
sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
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;
sbit adc0832_clk_dr = P1^2; // 定义adc0832的引脚
sbit adc0832_cs_dr = P1^0;
sbit adc0832_data_sr_dr = P1^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 ucTemp1=0; //中间过渡变量
unsigned char ucTemp2=0; //中间过渡变量
unsigned char ucTemp3=0; //中间过渡变量
unsigned char ucTemp4=0; //中间过渡变量
unsigned char ucTemp5=0; //中间过渡变量
unsigned char ucTemp6=0; //中间过渡变量
unsigned char ucTemp7=0; //中间过渡变量
unsigned char ucTemp8=0; //中间过渡变量
unsigned char ucAD=0; //AD值
unsigned char ucCheckAD=0; //用来做校验对比的AD值
unsigned long ulTemp=0; //参与换算的中间变量
unsigned long ulTempFilterV=0; //参与换算的中间变量
unsigned long ulBackupFilterV=5000; //备份最新采样数据的中间变量
unsigned char ucSamplingCnt=0; //记录连续N次采样的计数器
unsigned long ulV=0; //未经滤波处理的实时电压值
unsigned long ulFilterV=0; //经过滤波后的实时电压值
//根据原理图得出的共阴数码管字模表
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
};
void main()
{
initial_myself();
delay_long(100);
initial_peripheral();
while(1)
{
ad_sampling_service(); //AD采样与处理的服务程序
display_service(); //显示的窗口菜单服务程序
}
}
void ad_sampling_service(void) //AD采样与处理的服务程序
{
unsigned char i;
ucAD=0; //AD值
ucCheckAD=0; //用来做校验对比的AD值
/* 片选信号置为低电平 */
adc0832_cs_dr = 0;
/* 第一个脉冲，开始位 */
adc0832_data_sr_dr = 1;
adc0832_clk_dr = 0;
delay_short(1);
adc0832_clk_dr = 1;
/* 第二个脉冲，选择通道 */
adc0832_data_sr_dr = 1;
adc0832_clk_dr = 0;
adc0832_clk_dr = 1;
/* 第三个脉冲，选择通道 */
adc0832_data_sr_dr = 0;
adc0832_clk_dr = 0;
adc0832_clk_dr = 1;
/* 数据线输出高电平 */
adc0832_data_sr_dr = 1;
delay_short(2);
/* 第一个下降沿 */
adc0832_clk_dr = 1;
adc0832_clk_dr = 0;
delay_short(1);
/* AD值开始送出 */
for (i = 0; i < 8; i++)
{
ucAD <<= 1;
adc0832_clk_dr = 1;
adc0832_clk_dr = 0;
if (adc0832_data_sr_dr==1)
{
ucAD |= 0x01;
}
}
/* 用于校验的AD值开始送出 */
for (i = 0; i < 8; i++)
{
ucCheckAD >>= 1;
if (adc0832_data_sr_dr==1)
{
ucCheckAD |= 0x80;
}
adc0832_clk_dr = 1;
adc0832_clk_dr = 0;
}
/* 片选信号置为高电平 */
adc0832_cs_dr = 1;
if(ucCheckAD==ucAD) //检验相等
{
ulTemp=0; //把char类型数据赋值给long类型数据之前，必须先清零
ulTemp=ucAD; //把char类型数据赋值给long类型数据,参与乘除法运算的数据，为了避免运算结果溢出，我都用long类型
/* 注释一：
* 因为保留3为小数点，这里的5000代表5.000V。ulTemp/255代表分辨率.
* 有些书上说8位AD最高分辩可达到256级(0xff+1)，我认为这种说法是错误的。
* 8位AD最高分辩应该是255级(0xff)，所以这里除以255，而不是256.
*/
ulTemp=5000*ulTemp/255; //进行电压换算
ulV=ulTemp; //得到未经滤波处理的实时电压值
ucWd1Part1Update=1; //局部更新显示未经滤波处理的电压
/* 注释二：
* 以下连续判断N次一致性的滤波法，为了避免末尾小数点的数据偶尔跳动。
* 这种滤波方法的原理跟我在按键扫描中的去抖动原理是一模一样的，被我频繁
* 地应用在大量的工控项目中。
* 具体原理：当某个采样变量发生变化时，有两种可能，一种可能是外界的一个瞬间干扰。
* 另一种可能是变量确实发生变化。为了有效去除干扰，当发现变量有变化时，
* 我会连续采集N次，如果连续N次都是一致的结果，我才认为不是干扰。如果中间
* 只要出现一次不一致，我会马上把计数器清零，这一步是精华，很关键。
*
*/
if(ulTempFilterV!=ulTemp) //发现变量有变化
{
ucSamplingCnt++; //计数器累加
if(ucSamplingCnt>const_N) //如果连续N次都是一致的，则认为不是干扰。确实有数据需要更新显示。这里的const_N取值是8
{
ucSamplingCnt=0;
ulTempFilterV=ulTemp; //及时保存更新了的数据，方便下一次有新数据对比做准备
ulFilterV=ulTempFilterV; //得到经过滤波处理的实时电压值
ucWd1Part2Update=1; //局部更新显示经过滤波处理的电压
}
}
else
{
ucSamplingCnt=0; //只要出现一次不一致，我会马上把计数器清零，这一步是精华，很关键。
}
}
}
void display_service(void) //显示的窗口菜单服务程序
{
if(ucWd1Part1Update==1)//未经滤波处理的实时电压更新显示
{
ucWd1Part1Update=0;
ucTemp8=ulV%10000/1000; //显示电压值个位
ucTemp7=ulV%1000/100; //显示电压值小数点后第1位
ucTemp6=ulV%100/10; //显示电压值小数点后第2位
ucTemp5=ulV%10; //显示电压值小数点后第3位
ucDigShow8=ucTemp8; //数码管显示实际内容
ucDigShow7=ucTemp7;
ucDigShow6=ucTemp6;
ucDigShow5=ucTemp5;
}
if(ucWd1Part2Update==1)//经过滤波处理后的实时电压更新显示
{
ucWd1Part2Update=0;
ucTemp4=ulFilterV%10000/1000; //显示电压值个位
ucTemp3=ulFilterV%1000/100; //显示电压值小数点后第1位
ucTemp2=ulFilterV%100/10; //显示电压值小数点后第2位
ucTemp1=ulFilterV%10; //显示电压值小数点后第3位
ucDigShow4=ucTemp4; //数码管显示实际内容
ucDigShow3=ucTemp3;
ucDigShow2=ucTemp2;
ucDigShow1=ucTemp1;
}
}
void display_drive(void)
{
//以下程序，如果加一些数组和移位的元素，还可以压缩容量。但是鸿哥追求的不是容量，而是清晰的讲解思路
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 T0_time(void) interrupt 1 //定时中断
{
TF0=0; //清除中断标志
TR0=0; //关中断
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(void) //第一区初始化单片机
{
led_dr=0;//LED灯默认关闭
beep_dr=1; //用PNP三极管控制蜂鸣器，输出高电平时不叫。
hc595_drive(0x00,0x00); //关闭所有经过另外两个74HC595驱动的LED灯
TMOD=0x01; //设置定时器0为工作方式1
TH0=0xfe; //重装初始值(65535-500)=65035=0xfe0b
TL0=0x0b;
}
void initial_peripheral(void) //第二区初始化外围
{
ucDigDot8=1; //显示未经过滤波电压的小数点
ucDigDot7=0;
ucDigDot6=0;
ucDigDot5=0;
ucDigDot4=1; //显示经过滤波后电压的小数点
ucDigDot3=0;
ucDigDot2=0;
ucDigDot1=0;
EA=1; //开总中断
ET0=1; //允许定时中断
TR0=1; //启动定时中断
}

复制代码

总结陈词：
在单片机AD采样的系统中，我常用的滤波方法有求平均值法，区间法，连续判断N次一致性这三种方法。读者可以根据不同的系统特点选择对应的滤波方法，有一些要求高的系统还可以把三种滤波方法混合在一起用。关于AD采样的知识到本节已经讲完，下一节会讲什么新内容呢？欲知详情，请听下回分解-----return语句鲜为人知的用法。

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

jianhong_wu · 发表于 2014-6-22 02:05:36

第五十二节：程序后续升级修改的利器，return语句鲜为人知的用法。

开场白：
return语句经常用在带参数返回的函数中，字面上理解就是返回的意思，因此很多单片机初学者很容易忽略了return语句还有中断强行退出的功能。利用这个强行退出的功能，在项目后续程序的升级修改上很方便，还可以有效减少if语句的嵌套层数，使程序阅读起来很简洁。这一节要教大家return语句三个鲜为人知的用法：
第一个鲜为人知的用法：在空函数里，可以插入很多个return语句，不仅仅是一个。
第二个鲜为人知的用法：return语句可以有效较少程序里条件判断语句的嵌套层数。
第三个鲜为人知的用法：return语句本身已经包含了类似break语句的功能,不管当前处于几层的内部循环嵌套，只要遇到return语句都可以强行退出全部循环，并且直接退出当前子程序，不执行当前子程序后面的任何语句，这个功能实在是太强大，太铁腕了。

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

（1）硬件平台：
基于坚鸿51单片机学习板。

（2）实现功能：
本程序实现的功能跟第三十九节是一摸一样的，唯一的差别就是在第三十九节的基础上，插入了几个return语句，用新的return语句替代原来的条件和循环判断语句。

波特率是：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,那么蜂鸣器鸣叫一声表示接收的数据头和有效数据都是正确的。

也就是说，当在串口助手往单片机发送十六进制数据串:  eb 00 55 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(); //串口服务程序
}
}
/* 注释一：
* 以下函数说明了，在空函数里，可以插入很多个return语句。
* 用return语句非常便于后续程序的升级修改。
*/
void usart_service(void) //串口服务程序,在main函数里
{
// if(uiSendCnt>=const_receive_time&&ucSendLock==1) //原来的语句，现在被两个return语句替代了
// {
if(uiSendCnt<const_receive_time) //延时还没超过规定时间，直接退出本程序，不执行return后的任何语句。
{
return; //强行退出本子程序，不执行以下任何语句
}
if(ucSendLock==0) //不是最新一次接收到串口数据，直接退出本程序，不执行return后的任何语句。
{
return; //强行退出本子程序，不执行以下任何语句
}
/* 注释二：
* 以上两条return语句就相当于原来的一条if(uiSendCnt>=const_receive_time&&ucSendLock==1)语句。
* 用了return语句后，就明显减少了一个if嵌套。
*/
ucSendLock=0; //处理一次就锁起来，不用每次都进来,除非有新接收的数据
//下面的代码进入数据协议解析和数据处理的阶段
uiRcMoveIndex=0; //由于是判断数据头，所以下标移动变量从数组的0开始向最尾端移动
// while(uiRcregTotal>=5&&uiRcMoveIndex<=(uiRcregTotal-5)) //原来的语句，现在被两个return语句替代了
while(1) //死循环可以被以下return或者break语句中断，return本身已经包含了break语句功能。
{
if(uiRcregTotal<5) //串口接收到的数据太少
{
uiRcregTotal=0; //清空缓冲的下标，方便下次重新从0下标开始接受新数据
return; //强行退出while(1)循环嵌套，直接退出本程序，不执行以下任何语句
}
if(uiRcMoveIndex>(uiRcregTotal-5)) //数组缓冲区的数据已经处理完
{
uiRcregTotal=0; //清空缓冲的下标，方便下次重新从0下标开始接受新数据
return; //强行退出while(1)循环嵌套，直接退出本程序，不执行以下任何语句
}
/* 注释三：
* 以上两条return语句就相当于原来的一条while(uiRcregTotal>=5&&uiRcMoveIndex<=(uiRcregTotal-5))语句。
* 以上两个return语句的用法，同时说明了return本身已经包含了break语句功能,不管当前处于几层的内部循环嵌套，
* 都可以强行退出循环，并且直接退出本程序。
*/
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; //退出while(1)循环
}
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; //启动定时中断
}

复制代码

总结陈词：
我在第一节就告诉读者了，搞单片机开发如果不会C语言的指针也没关系，不会影响做项目。我本人平时做项目时，也很少用指针，只有在三种场合下我才会用指针，因为在这三种场合下，用了指针感觉程序阅读起来更加清爽了。所以，指针还是有它独到的好处，有哪三种好处？欲知详情，请听下回分解-----指针的第一大好处，让一个函数可以封装多个相当于return语句返回的参数。

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

jianhong_wu · 发表于 2014-6-29 07:32:57

第五十三节：指针的第一大好处，让一个函数可以封装多个相当于return语句返回的参数。

开场白：
当我们想把某种算法通过一个函数来实现的时候，如果不会指针，那么只有两种方法。
第1种：用不带参数返回的空函数。这是最原始的做法，也是我当年刚毕业就开始做项目的时候经常用的方法。它完全依靠全局变量作为函数的输入和输出口。我们要用到这个函数，就要把参与运算的变量直接赋给对应的输入全局变量，调用一次函数之后，再找到对应的输出变量，这些输出变量就是我们要的结果。这种方法的缺点是阅读不直观，封装性不强，没有面对用户的输入输出接口。
第2种：用return返回参数和带输入形参的函数，这种方法已经具备了完整的输入和输出性能，比第1种方法直观多了。但是这种方法有它的局限性，因为return只能返回一个变量，如果要用在返回多个输出结果的函数中，就无能为力了，这时候该怎么办？就必须用指针了，也就是我下面讲到的第3种方法。
这一节要教大家一个知识点：通过指针，让函数可以返回多个变量。

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

（1）硬件平台：
基于坚鸿51单片机学习板。

（2）实现功能：
通过电脑串口调试助手，往单片机发送EB 00 55 XX YY 指令，其中EB 00 55是数据头， XX是被除数，YY是除数。单片机收到指令后就会返回6个数据，最前面两个数据是第1种运算方式的商和余数，中间两个数据是第2种运算方式的商和余数，最后两个数据是第3种运算方式的商和余数。
比如电脑发送：EB 00 55 08 02
单片机就返回：04 00 04 00 04 00 (04是商，00是余数)

串口程序的接收部分请参考第39节。串口程序的发送部分请参考第42节。

波特率是：9600 。

（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 delay_short(unsigned int uiDelayShort);
void T0_time(void); //定时中断函数
void usart_receive(void); //串口接收中断函数
void usart_service(void); //串口服务程序,在main函数里
void eusart_send(unsigned char ucSendData);
void chu_fa_yun_suan_1(void);//第1种方法求商和余数
unsigned char get_shang_2(unsigned char ucBeiChuShuTemp,unsigned char ucChuShuTemp); //第2种方法求商
unsigned char get_yu_2(unsigned char ucBeiChuShuTemp,unsigned char ucChuShuTemp); //第2种方法求余数
void chu_fa_yun_suan_3(unsigned char ucBeiChuShuTemp,unsigned char ucChuShuTemp,unsigned char *p_ucShangTemp,unsigned char *p_ucYuTemp);//第3种方法求商和余数
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; //蜂鸣器鸣叫的持续时间计数器
unsigned char ucBeiChuShu_1=0; //第1种方法中的被除数
unsigned char ucChuShu_1=1; //第1种方法中的除数
unsigned char ucShang_1=0; //第1种方法中的商
unsigned char ucYu_1=0; //第1种方法中的余数
unsigned char ucBeiChuShu_2=0; //第2种方法中的被除数
unsigned char ucChuShu_2=1; //第2种方法中的除数
unsigned char ucShang_2=0; //第2种方法中的商
unsigned char ucYu_2=0; //第2种方法中的余数
unsigned char ucBeiChuShu_3=0; //第3种方法中的被除数
unsigned char ucChuShu_3=1; //第3种方法中的除数
unsigned char ucShang_3=0; //第3种方法中的商
unsigned char ucYu_3=0; //第3种方法中的余数
void main()
{
initial_myself();
delay_long(100);
initial_peripheral();
while(1)
{
usart_service(); //串口服务程序
}
}
/* 注释一：
* 第1种方法，用不带参数返回的空函数，这是最原始的做法，也是我当年刚毕业
* 就开始做项目的时候经常用的方法。它完全依靠全局变量作为函数的输入和输出口。
* 我们要用到这个函数，就要把参与运算的变量直接赋给对应的输入全局变量，
* 调用一次函数之后，再找到对应的输出变量，这些输出变量就是我们要的结果。
* 在本函数中，被除数ucBeiChuShu_1和除数ucChuShu_1就是输入全局变量，
* 商ucShang_1和余数ucYu_1就是输出全局变量。这种方法的缺点是阅读不直观，
* 封装性不强，没有面对用户的输入输出接口，
*/
void chu_fa_yun_suan_1(void)//第1种方法求商和余数
{
if(ucChuShu_1==0) //如果除数为0，则商和余数都为0
{
ucShang_1=0;
ucYu_1=0;
}
else
{
ucShang_1=ucBeiChuShu_1/ucChuShu_1; //求商
ucYu_1=ucBeiChuShu_1%ucChuShu_1; //求余数
}
}
/* 注释二：
* 第2种方法，用return返回参数和带输入形参的函数，这种方法已经具备了完整的输入和输出性能，
* 比第1种方法直观多了。但是这种方法有它的局限性，因为return只能返回一个变量，
* 如果要用在返回多个输出结果的函数中，就无能为力了。比如本程序，就不能同时输出
* 商和余数，只能分两个函数来做。如果要在一个函数中同时输出商和余数，该怎么办？
* 这个时候就必须用指针了，也就是我下面讲到的第3种方法。
*/
unsigned char get_shang_2(unsigned char ucBeiChuShuTemp,unsigned char ucChuShuTemp) //第2种方法求商
{
unsigned char ucShangTemp;
if(ucChuShuTemp==0) //如果除数为0，则商为0
{
ucShangTemp=0;
}
else
{
ucShangTemp=ucBeiChuShuTemp/ucChuShuTemp; //求商
}
return ucShangTemp; //返回运算后的结果商
}
unsigned char get_yu_2(unsigned char ucBeiChuShuTemp,unsigned char ucChuShuTemp) //第2种方法求余数
{
unsigned char ucYuTemp;
if(ucChuShuTemp==0) //如果除数为0，则余数为0
{
ucYuTemp=0;
}
else
{
ucYuTemp=ucBeiChuShuTemp%ucChuShuTemp; //求余数
}
return ucYuTemp; //返回运算后的结果余数
}
/* 注释三：
* 第3种方法，用带指针的函数，就可以顺心所欲，不受return的局限，想输出多少个
* 运算结果都可以，赞一个！在本函数中，ucBeiChuShuTemp和ucChuShuTemp是输入变量，
* 它们不是指针，所以不具备输出接口属性。*p_ucShangTemp和*p_ucYuTemp是输出变量，
* 因为它们是指针，所以具备输出接口属性。
*/
void chu_fa_yun_suan_3(unsigned char ucBeiChuShuTemp,unsigned char ucChuShuTemp,unsigned char *p_ucShangTemp,unsigned char *p_ucYuTemp)//第3种方法求商和余数
{
if(ucChuShuTemp==0) //如果除数为0，则商和余数都为0
{
*p_ucShangTemp=0;
*p_ucYuTemp=0;
}
else
{
*p_ucShangTemp=ucBeiChuShuTemp/ucChuShuTemp; //求商
*p_ucYuTemp=ucBeiChuShuTemp%ucChuShuTemp; //求余数
}
}
void usart_service(void) //串口服务程序,在main函数里
{
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的判断
{
//第1种运算方法，依靠全局变量
ucBeiChuShu_1=ucRcregBuf[uiRcMoveIndex+3]; //被除数
ucChuShu_1=ucRcregBuf[uiRcMoveIndex+4]; //除数
chu_fa_yun_suan_1(); //调用一次空函数就出结果了，结果保存在ucShang_1和ucYu_1全局变量中
eusart_send(ucShang_1); //把运算结果返回给上位机观察
eusart_send(ucYu_1);//把运算结果返回给上位机观察
//第2种运算方法，依靠两个带return语句的返回函数
ucBeiChuShu_2=ucRcregBuf[uiRcMoveIndex+3]; //被除数
ucChuShu_2=ucRcregBuf[uiRcMoveIndex+4]; //除数
ucShang_2=get_shang_2(ucBeiChuShu_2,ucChuShu_2); //第2种方法求商
ucYu_2=get_yu_2(ucBeiChuShu_2,ucChuShu_2); //第2种方法求余数
eusart_send(ucShang_2); //把运算结果返回给上位机观察
eusart_send(ucYu_2);//把运算结果返回给上位机观察
//第3种运算方法，依靠指针
ucBeiChuShu_3=ucRcregBuf[uiRcMoveIndex+3]; //被除数
ucChuShu_3=ucRcregBuf[uiRcMoveIndex+4]; //除数
/* 注释四：
* 注意，由于商和余数是指针形参，我们代入的变量必须带地址符号& 。比如&ucShang_3和&ucYu_3。
* 因为我们是把变量的地址传递进去的。
*/
chu_fa_yun_suan_3(ucBeiChuShu_3,ucChuShu_3,&ucShang_3,&ucYu_3);//第3种方法求商和余数
eusart_send(ucShang_3); //把运算结果返回给上位机观察
eusart_send(ucYu_3);//把运算结果返回给上位机观察
break; //退出循环
}
uiRcMoveIndex++; //因为是判断数据头，游标向着数组最尾端的方向移动
}
uiRcregTotal=0; //清空缓冲的下标，方便下次重新从0下标开始接受新数据
}
}
void eusart_send(unsigned char ucSendData) //往上位机发送一个字节的函数
{
ES = 0; //关串口中断
TI = 0; //清零串口发送完成中断请求标志
SBUF =ucSendData; //发送一个字节
delay_short(400); //每个字节之间的延时，这里非常关键，也是最容易出错的地方。延时的大小请根据实际项目来调整
TI = 0; //清零串口发送完成中断请求标志
ES = 1; //允许串口中断
}
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 //发送中断，及时把发送中断标志位清零
{
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 delay_short(unsigned int uiDelayShort)
{
unsigned int i;
for(i=0;i<uiDelayShort;i++)
{
; //一个分号相当于执行一条空语句
}
}
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; //启动定时中断
}

复制代码

总结陈词：
这节讲了指针的第一大好处，它的第二大好处是什么？欲知详情，请听下回分解-----指针的第二大好处，指针作为数组在函数内部的化身。

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

jianhong_wu · 发表于 2014-7-6 11:26:01

第五十四节：指针的第二大好处，指针作为数组在函数中的输入接口。

开场白：
如果不会指针，当我们想把一个数组的数据传递进某个函数内部的时候，只能通过全局变量的方式，这种方法的缺点是阅读不直观，封装性不强，没有面对用户的输入接口。
针对以上问题，这一节要教大家一个知识点：通过指针，为函数增加一个数组输入接口。

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

（1）硬件平台：
基于坚鸿51单片机学习板。

（2）实现功能：
把5个随机数据按从大到小排序，用冒泡法来排序。
通过电脑串口调试助手，往单片机发送EB 00 55 08 06 09 05 07 指令，其中EB 00 55是数据头，08 06 09 05 07 是参与排序的5个随机原始数据。单片机收到指令后就会返回13个数据，最前面5个数据是第1种方法的排序结果，中间3个数据EE EE EE是第1种和第2种的分割线，为了方便观察，没实际意义。最后5个数据是第2种方法的排序结果.

比如电脑发送：EB 00 55 08 06 09 05 07
单片机就返回：09 08 07 06 05 EE EE EE 09 08 07 06 05

串口程序的接收部分请参考第39节。串口程序的发送部分请参考第42节。

波特率是：9600 。

（3）源代码讲解如下：

#include "REG52.H"
#define const_array_size 5 //参与排序的数组大小
#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 delay_short(unsigned int uiDelayShort);
void T0_time(void); //定时中断函数
void usart_receive(void); //串口接收中断函数
void usart_service(void); //串口服务程序,在main函数里
void eusart_send(unsigned char ucSendData);
void big_to_small_sort_1(void);//第1种方法把一个数组从大小小排序
void big_to_small_sort_2(unsigned char *p_ucInputBuffer);//第2种方法把一个数组从大小小排序
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 ucUsartBuffer[const_array_size]; //从串口接收到的需要排序的原始数据
unsigned char ucGlobalBuffer_1[const_array_size]; //第1种方法，参与具体排序算法的全局变量数组
unsigned char ucGlobalBuffer_2[const_array_size]; //第2种方法，参与具体排序算法的全局变量数组
void main()
{
initial_myself();
delay_long(100);
initial_peripheral();
while(1)
{
usart_service(); //串口服务程序
}
}
/* 注释一：
* 第1种方法，用不带输入输出接口的空函数，这是最原始的做法，它完全依靠
* 全局变量作为函数的输入和输出口。我们要用到这个函数，就要把参与运算
* 的变量直接赋给对应的输入全局变量，调用一次函数之后，再找到对应的
* 输出全局变量，这些输出全局变量就是我们要的结果。
* 在本函数中，ucGlobalBuffer_1[const_array_size]既是输入全局变量，也是输出全局变量，
* 这种方法的缺点是阅读不直观，封装性不强，没有面对用户的输入输出接口，
*/
void big_to_small_sort_1(void)//第1种方法把一个数组从大小小排序
{
unsigned char i;
unsigned char k;
unsigned char ucTemp; //在两两交换数据的过程中，用于临时存放交换的某个变量
/* 注释二：
* 以下就是著名的冒泡法排序。这个方法几乎所有的C语言大学教材都讲过了。大家在百度上可以直接
* 搜索到它的工作原理和详细的讲解步骤，我就不再详细讲解了。
*/
for(i=0;i<(const_array_size-1);i++) //冒泡的次数是(const_array_size-1)次
{
for(k=0;k<(const_array_size-1-i);k++) //每次冒泡的过程中，需要两两比较的次数是(const_array_size-1-i)
{
if(ucGlobalBuffer_1[const_array_size-1-k]>ucGlobalBuffer_1[const_array_size-1-1-k]) //后一个与前一个数据两两比较
{
ucTemp=ucGlobalBuffer_1[const_array_size-1-1-k]; //通过一个中间变量实现两个数据交换
ucGlobalBuffer_1[const_array_size-1-1-k]=ucGlobalBuffer_1[const_array_size-1-k];
ucGlobalBuffer_1[const_array_size-1-k]=ucTemp;
}
}
}
}
/* 注释三：
* 第2种方法，为了改进第1种方法的用户体验，用指针为函数增加一个输入接口。
* 为什么要用指针？因为C语言的函数中，数组不能直接用来做函数的形参，只能用指针作为数组的形参。
* 比如，你不能这样写一个函数void big_to_small_sort_2(unsigned char a[5])，否则编译就会出错不通过。
* 在本函数中，*p_ucInputBuffer指针就是输入接口，而输出接口仍然是全局变量数组ucGlobalBuffer_2。
* 这种方法由于为函数多增加了一个数组输入接口，已经比第1种方法更加直观了。
*/
void big_to_small_sort_2(unsigned char *p_ucInputBuffer)//第2种方法把一个数组从大小小排序
{
unsigned char i;
unsigned char k;
unsigned char ucTemp; //在两两交换数据的过程中，用于临时存放交换的某个变量
for(i=0;i<const_array_size;i++)
{
ucGlobalBuffer_2[i]=p_ucInputBuffer[i]; //参与排序算法之前，先把输入接口的数据全部搬移到全局变量数组中。
}
//以下就是著名的冒泡法排序。详细讲解请找百度。
for(i=0;i<(const_array_size-1);i++) //冒泡的次数是(const_array_size-1)次
{
for(k=0;k<(const_array_size-1-i);k++) //每次冒泡的过程中，需要两两比较的次数是(const_array_size-1-i)
{
if(ucGlobalBuffer_2[const_array_size-1-k]>ucGlobalBuffer_2[const_array_size-1-1-k]) //后一个与前一个数据两两比较
{
ucTemp=ucGlobalBuffer_2[const_array_size-1-1-k]; //通过一个中间变量实现两个数据交换
ucGlobalBuffer_2[const_array_size-1-1-k]=ucGlobalBuffer_2[const_array_size-1-k];
ucGlobalBuffer_2[const_array_size-1-k]=ucTemp;
}
}
}
}
void usart_service(void) //串口服务程序,在main函数里
{
unsigned char i=0;
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的判断
{
for(i=0;i<const_array_size;i++)
{
ucUsartBuffer[i]=ucRcregBuf[uiRcMoveIndex+3+i]; //从串口接收到的需要被排序的原始数据
}
//第1种运算方法，依靠全局变量
for(i=0;i<const_array_size;i++)
{
ucGlobalBuffer_1[i]=ucUsartBuffer[i]; //把需要被排列的数据放进输入全局变量数组
}
big_to_small_sort_1(); //调用一次空函数就出结果了，结果还是保存在ucGlobalBuffer_1全局变量数组中
for(i=0;i<const_array_size;i++)
{
eusart_send(ucGlobalBuffer_1[i]); ////把用第1种方法排序后的结果返回给上位机观察
}
eusart_send(0xee); //为了方便上位机观察，多发送3个字节ee ee ee作为第1种方法与第2种方法的分割线
eusart_send(0xee);
eusart_send(0xee);
//第2种运算方法，依靠指针为函数增加一个数组的输入接口
//通过指针输入接口，直接把ucUsartBuffer数组的首地址传址进去，排序后输出的结果还是保存在ucGlobalBuffer_2全局变量数组中
big_to_small_sort_2(ucUsartBuffer);
for(i=0;i<const_array_size;i++)
{
eusart_send(ucGlobalBuffer_2[i]); //把用第2种方法排序后的结果返回给上位机观察
}
break; //退出循环
}
uiRcMoveIndex++; //因为是判断数据头，游标向着数组最尾端的方向移动
}
uiRcregTotal=0; //清空缓冲的下标，方便下次重新从0下标开始接受新数据
}
}
void eusart_send(unsigned char ucSendData) //往上位机发送一个字节的函数
{
ES = 0; //关串口中断
TI = 0; //清零串口发送完成中断请求标志
SBUF =ucSendData; //发送一个字节
delay_short(400); //每个字节之间的延时，这里非常关键，也是最容易出错的地方。延时的大小请根据实际项目来调整
TI = 0; //清零串口发送完成中断请求标志
ES = 1; //允许串口中断
}
void T0_time(void) interrupt 1 //定时中断
{
TF0=0; //清除中断标志
TR0=0; //关中断
if(uiSendCnt<const_receive_time) //如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完
{
uiSendCnt++; //表面上这个数据不断累加，但是在串口中断里，每接收一个字节它都会被清零，除非这个中间没有串口数据过来
ucSendLock=1; //开自锁标志
}
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 //发送中断，及时把发送中断标志位清零
{
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 delay_short(unsigned int uiDelayShort)
{
unsigned int i;
for(i=0;i<uiDelayShort;i++)
{
; //一个分号相当于执行一条空语句
}
}
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; //启动定时中断
}

复制代码

总结陈词：
第2种方法通过指针，为函数增加了一个数组输入接口，已经比第1种纯粹用全局变量的方法直观多了，但是还有一个小小的遗憾，因为它的输出排序结果仍然要靠全局变量。为了让函数更加完美，我们能不能为函数再增加一个输出接口？当然可以。欲知详情，请听下回分解-----指针的第三大好处，指针作为数组在函数中的输出接口。

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

jianhong_wu · 发表于 2014-7-10 15:42:28

第五十五节：指针的第三大好处，指针作为数组在函数中的输出接口。

开场白：
上一节介绍的第2种方法，由于为函数多增加了一个数组输入接口，已经比第1种方法更加直观了，但是由于只有输入接口，没有输出接口，输出接口仍然要靠全局变量数组，所以还是有一个小小的遗憾，这节介绍的第3种方法就是为了改变这个遗憾，为数组在函数中多增加一个输出接口，这样，函数既有输入接口，又有输出接口，这样的函数才算完美直观。这一节要教大家一个知识点：通过指针，为函数增加一个数组输出接口。

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

（1）硬件平台：
基于坚鸿51单片机学习板。

（2）实现功能：
把5个随机数据按从大到小排序，用冒泡法来排序。
通过电脑串口调试助手，往单片机发送EB 00 55 08 06 09 05 07 指令，其中EB 00 55是数据头，08 06 09 05 07 是参与排序的5个随机原始数据。单片机收到指令后就会返回13个数据，最前面5个数据是第2种方法的排序结果，中间3个数据EE EE EE是第2种和第3种的分割线，为了方便观察，没实际意义。最后5个数据是第3种方法的排序结果.

比如电脑发送：EB 00 55 08 06 09 05 07
单片机就返回：09 08 07 06 05 EE EE EE 09 08 07 06 05

串口程序的接收部分请参考第39节。串口程序的发送部分请参考第42节。

波特率是：9600 。

（3）源代码讲解如下：

#include "REG52.H"
#define const_array_size 5 //参与排序的数组大小
#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 delay_short(unsigned int uiDelayShort);
void T0_time(void); //定时中断函数
void usart_receive(void); //串口接收中断函数
void usart_service(void); //串口服务程序,在main函数里
void eusart_send(unsigned char ucSendData);
void big_to_small_sort_2(unsigned char *p_ucInputBuffer);//第2种方法把一个数组从大到小排序
void big_to_small_sort_3(unsigned char *p_ucInputBuffer,unsigned char *p_ucOutputBuffer);//第3种方法把一个数组从大到小排序
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 ucUsartBuffer[const_array_size]; //从串口接收到的需要排序的原始数据
unsigned char ucGlobalBuffer_2[const_array_size]; //第2种方法，参与具体排序算法的全局变量数组
unsigned char ucGlobalBuffer_3[const_array_size]; //第3种方法，用来接收输出接口数据的全局变量数组
void main()
{
initial_myself();
delay_long(100);
initial_peripheral();
while(1)
{
usart_service(); //串口服务程序
}
}
/* 注释一：
* 第2种方法，为了改进第1种方法的用户体验，用指针为函数增加一个输入接口。
* 为什么要用指针？因为C语言的函数中，数组不能直接用来做函数的形参，只能用指针作为数组的形参。
* 比如，你不能这样写一个函数void big_to_small_sort_2(unsigned char a[5])，否则编译就会出错不通过。
* 在本函数中，*p_ucInputBuffer指针就是输入接口，而输出接口仍然是全局变量数组ucGlobalBuffer_2。
* 这种方法由于为函数多增加了一个数组输入接口，已经比第1种方法更加直观了，但是由于只有输入接口，
* 没有输出接口，输出接口仍然要靠全局变量，所以还是有点小遗憾，以下第3种方法就是为了改变这个遗憾。
*/
void big_to_small_sort_2(unsigned char *p_ucInputBuffer)//第2种方法把一个数组从大到小排序
{
unsigned char i;
unsigned char k;
unsigned char ucTemp; //在两两交换数据的过程中，用于临时存放交换的某个变量
for(i=0;i<const_array_size;i++)
{
ucGlobalBuffer_2[i]=p_ucInputBuffer[i]; //参与排序算法之前，先把输入接口的数据全部搬移到全局变量数组中。
}
//以下就是著名的冒泡法排序。详细讲解请找百度。
for(i=0;i<(const_array_size-1);i++) //冒泡的次数是(const_array_size-1)次
{
for(k=0;k<(const_array_size-1-i);k++) //每次冒泡的过程中，需要两两比较的次数是(const_array_size-1-i)
{
if(ucGlobalBuffer_2[const_array_size-1-k]>ucGlobalBuffer_2[const_array_size-1-1-k]) //后一个与前一个数据两两比较
{
ucTemp=ucGlobalBuffer_2[const_array_size-1-1-k]; //通过一个中间变量实现两个数据交换
ucGlobalBuffer_2[const_array_size-1-1-k]=ucGlobalBuffer_2[const_array_size-1-k];
ucGlobalBuffer_2[const_array_size-1-k]=ucTemp;
}
}
}
}
/* 注释二：
* 第3种方法，为了改进第2种方法的用户体验，用指针为函数多增加一个数组输出接口。
* 这样，函数的数组既有输入接口，又有输出接口，已经堪称完美了。
* 本程序中*p_ucInputBuffer输入接口，*p_ucOutputBuffer是输出接口。
*/
void big_to_small_sort_3(unsigned char *p_ucInputBuffer,unsigned char *p_ucOutputBuffer)//第3种方法把一个数组从大到小排序
{
unsigned char i;
unsigned char k;
unsigned char ucTemp; //在两两交换数据的过程中，用于临时存放交换的某个变量
unsigned char ucBuffer_3[const_array_size]; //第3种方法，参与具体排序算法的局部变量数组
for(i=0;i<const_array_size;i++)
{
ucBuffer_3[i]=p_ucInputBuffer[i]; //参与排序算法之前，先把输入接口的数据全部搬移到局部变量数组中。
}
//以下就是著名的冒泡法排序。详细讲解请找百度。
for(i=0;i<(const_array_size-1);i++) //冒泡的次数是(const_array_size-1)次
{
for(k=0;k<(const_array_size-1-i);k++) //每次冒泡的过程中，需要两两比较的次数是(const_array_size-1-i)
{
if(ucBuffer_3[const_array_size-1-k]>ucBuffer_3[const_array_size-1-1-k]) //后一个与前一个数据两两比较
{
ucTemp=ucBuffer_3[const_array_size-1-1-k]; //通过一个中间变量实现两个数据交换
ucBuffer_3[const_array_size-1-1-k]=ucBuffer_3[const_array_size-1-k];
ucBuffer_3[const_array_size-1-k]=ucTemp;
}
}
}
for(i=0;i<const_array_size;i++)
{
p_ucOutputBuffer[i]=ucBuffer_3[i]; //参与排序算法之后，把运算结果的数据全部搬移到输出接口中，方便外面程序调用
}
}
void usart_service(void) //串口服务程序,在main函数里
{
unsigned char i=0;
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的判断
{
for(i=0;i<const_array_size;i++)
{
ucUsartBuffer[i]=ucRcregBuf[uiRcMoveIndex+3+i]; //从串口接收到的需要被排序的原始数据
}
//第2种运算方法，依靠指针为函数增加一个数组的输入接口
//通过指针输入接口，直接把ucUsartBuffer数组的首地址传址进去，排序后输出的结果还是保存在ucGlobalBuffer_2全局变量数组中
big_to_small_sort_2(ucUsartBuffer);
for(i=0;i<const_array_size;i++)
{
eusart_send(ucGlobalBuffer_2[i]); //把用第2种方法排序后的结果返回给上位机观察
}
eusart_send(0xee); //为了方便上位机观察，多发送3个字节ee ee ee作为第2种方法与第3种方法的分割线
eusart_send(0xee);
eusart_send(0xee);
//第3种运算方法，依靠指针为函数增加一个数组的输出接口
//通过指针输出接口，排序运算后的结果直接从这个输出口中导出到ucGlobalBuffer_3数组中
big_to_small_sort_3(ucUsartBuffer,ucGlobalBuffer_3); //ucUsartBuffer是输入的数组，ucGlobalBuffer_3是接收排序结果的数组
for(i=0;i<const_array_size;i++)
{
eusart_send(ucGlobalBuffer_3[i]); //把用第3种方法排序后的结果返回给上位机观察
}
break; //退出循环
}
uiRcMoveIndex++; //因为是判断数据头，游标向着数组最尾端的方向移动
}
uiRcregTotal=0; //清空缓冲的下标，方便下次重新从0下标开始接受新数据
}
}
void eusart_send(unsigned char ucSendData) //往上位机发送一个字节的函数
{
ES = 0; //关串口中断
TI = 0; //清零串口发送完成中断请求标志
SBUF =ucSendData; //发送一个字节
delay_short(400); //每个字节之间的延时，这里非常关键，也是最容易出错的地方。延时的大小请根据实际项目来调整
TI = 0; //清零串口发送完成中断请求标志
ES = 1; //允许串口中断
}
void T0_time(void) interrupt 1 //定时中断
{
TF0=0; //清除中断标志
TR0=0; //关中断
if(uiSendCnt<const_receive_time) //如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完
{
uiSendCnt++; //表面上这个数据不断累加，但是在串口中断里，每接收一个字节它都会被清零，除非这个中间没有串口数据过来
ucSendLock=1; //开自锁标志
}
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 //发送中断，及时把发送中断标志位清零
{
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 delay_short(unsigned int uiDelayShort)
{
unsigned int i;
for(i=0;i<uiDelayShort;i++)
{
; //一个分号相当于执行一条空语句
}
}
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; //启动定时中断
}

复制代码

总结陈词：
通过本节程序的讲解，一部分细心的读者可能会发现一个规律，其实所谓指针作为数组在函数中的输入接口和输出接口，输入接口的指针跟输出接口的指针在语法上没有任何区别，我没有用到C语言中专门的关键词去限定某个指针是输入，某个指针是输出，因此，这个告诉我们什么道理？指针在函数的接口中，天生就是既可以做输入，也可以是做输出，它是双向性的，不像普通的函数变量形参只能做输入。发现了这个秘密，我们可不可以把本节程序中的输入接口和输出接口合并成一个输入输出接口呢？当然可以。欲知详情，请听下回分解-----指针的第四大好处，指针作为数组在函数中的输入输出接口。

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

jianhong_wu · 发表于 2014-7-10 17:52:19

第五十六节：指针的第四大好处，指针作为数组在函数中的输入输出接口。

开场白：
通过前面几个章节的学习，我们知道指针在函数的接口中，天生就是既可以做输入，也可以是做输出，它是双向性的，类似全局变量的特点。我们根据实际项目的情况，在必要的时候可以直接把输入接口和输出接口合并在一起，这种方法的缺点是没有把输入和输出分开，没有那么直观。但是优点也是很明显的，就是比较省程序ROM容量和数据RAM容量，而且运行效率也比较快。这一节要教大家一个知识点：指针作为数组在函数中输入输出接口的特点。

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

（1）硬件平台：
基于坚鸿51单片机学习板。

（2）实现功能：
把5个随机数据按从大到小排序，用冒泡法来排序。
通过电脑串口调试助手，往单片机发送EB 00 55 08 06 09 05 07 指令，其中EB 00 55是数据头，08 06 09 05 07 是参与排序的5个随机原始数据。单片机收到指令后就会返回13个数据，最前面5个数据是第3种方法的排序结果，中间3个数据EE EE EE是第3种和第4种的分割线，为了方便观察，没实际意义。最后5个数据是第4种方法的排序结果.

比如电脑发送：EB 00 55 08 06 09 05 07
单片机就返回：09 08 07 06 05 EE EE EE 09 08 07 06 05

串口程序的接收部分请参考第39节。串口程序的发送部分请参考第42节。

波特率是：9600 。

（3）源代码讲解如下：

#include "REG52.H"
#define const_array_size 5 //参与排序的数组大小
#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 delay_short(unsigned int uiDelayShort);
void T0_time(void); //定时中断函数
void usart_receive(void); //串口接收中断函数
void usart_service(void); //串口服务程序,在main函数里
void eusart_send(unsigned char ucSendData);
void big_to_small_sort_3(unsigned char *p_ucInputBuffer,unsigned char *p_ucOutputBuffer);//第3种方法把一个数组从大到小排序
void big_to_small_sort_4(unsigned char *p_ucInputAndOutputBuffer);//第4种方法把一个数组从大到小排序
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 ucUsartBuffer[const_array_size]; //从串口接收到的需要排序的原始数据
unsigned char ucGlobalBuffer_3[const_array_size]; //第3种方法，用来接收输出接口数据的全局变量数组
unsigned char ucGlobalBuffer_4[const_array_size]; //第4种方法，用来输入和输出接口数据的全局变量数组
void main()
{
initial_myself();
delay_long(100);
initial_peripheral();
while(1)
{
usart_service(); //串口服务程序
}
}
/* 注释一：
* 第3种方法，为了改进第2种方法的用户体验，用指针为函数多增加一个数组输出接口。
* 这样，函数的数组既有输入接口，又有输出接口，已经堪称完美了。
* 本程序中*p_ucInputBuffer输入接口，*p_ucOutputBuffer是输出接口。
*/
void big_to_small_sort_3(unsigned char *p_ucInputBuffer,unsigned char *p_ucOutputBuffer)//第3种方法把一个数组从大到小排序
{
unsigned char i;
unsigned char k;
unsigned char ucTemp; //在两两交换数据的过程中，用于临时存放交换的某个变量
unsigned char ucBuffer_3[const_array_size]; //第3种方法，参与具体排序算法的局部变量数组
for(i=0;i<const_array_size;i++)
{
ucBuffer_3[i]=p_ucInputBuffer[i]; //参与排序算法之前，先把输入接口的数据全部搬移到局部变量数组中。
}
//以下就是著名的冒泡法排序。详细讲解请找百度。
for(i=0;i<(const_array_size-1);i++) //冒泡的次数是(const_array_size-1)次
{
for(k=0;k<(const_array_size-1-i);k++) //每次冒泡的过程中，需要两两比较的次数是(const_array_size-1-i)
{
if(ucBuffer_3[const_array_size-1-k]>ucBuffer_3[const_array_size-1-1-k]) //后一个与前一个数据两两比较
{
ucTemp=ucBuffer_3[const_array_size-1-1-k]; //通过一个中间变量实现两个数据交换
ucBuffer_3[const_array_size-1-1-k]=ucBuffer_3[const_array_size-1-k];
ucBuffer_3[const_array_size-1-k]=ucTemp;
}
}
}
for(i=0;i<const_array_size;i++)
{
p_ucOutputBuffer[i]=ucBuffer_3[i]; //参与排序算法之后，把运算结果的数据全部搬移到输出接口中，方便外面程序调用
}
}
/* 注释二：
* 第4种方法.指针在函数的接口中，天生就是既可以做输入，也可以是做输出，它是双向性的，类似全局变量的特点。
* 我们可以根据实际项目的情况，在必要的时候可以直接把输入接口和输出接口合并在一起，
* 这种方法的缺点是没有把输入和输出分开，没有那么直观。但是优点也是很明显的，就是比较
* 省程序ROM容量和数据RAM容量，而且运行效率也比较快。现在介绍给大家。
* 本程序的*p_ucInputAndOutputBuffer是输入输出接口。
*/
void big_to_small_sort_4(unsigned char *p_ucInputAndOutputBuffer)//第4种方法把一个数组从大到小排序
{
unsigned char i;
unsigned char k;
unsigned char ucTemp; //在两两交换数据的过程中，用于临时存放交换的某个变量
//以下就是著名的冒泡法排序。详细讲解请找百度。
for(i=0;i<(const_array_size-1);i++) //冒泡的次数是(const_array_size-1)次
{
for(k=0;k<(const_array_size-1-i);k++) //每次冒泡的过程中，需要两两比较的次数是(const_array_size-1-i)
{
if(p_ucInputAndOutputBuffer[const_array_size-1-k]>p_ucInputAndOutputBuffer[const_array_size-1-1-k]) //后一个与前一个数据两两比较
{
ucTemp=p_ucInputAndOutputBuffer[const_array_size-1-1-k]; //通过一个中间变量实现两个数据交换
p_ucInputAndOutputBuffer[const_array_size-1-1-k]=p_ucInputAndOutputBuffer[const_array_size-1-k];
p_ucInputAndOutputBuffer[const_array_size-1-k]=ucTemp;
}
}
}
}
void usart_service(void) //串口服务程序,在main函数里
{
unsigned char i=0;
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的判断
{
for(i=0;i<const_array_size;i++)
{
ucUsartBuffer[i]=ucRcregBuf[uiRcMoveIndex+3+i]; //从串口接收到的需要被排序的原始数据
}
//第3种运算方法，依靠指针为函数增加一个数组的输出接口
//通过指针输出接口，排序运算后的结果直接从这个输出口中导出到ucGlobalBuffer_3数组中
big_to_small_sort_3(ucUsartBuffer,ucGlobalBuffer_3); //ucUsartBuffer是输入的数组，ucGlobalBuffer_3是接收排序结果的数组
for(i=0;i<const_array_size;i++)
{
eusart_send(ucGlobalBuffer_3[i]); //把用第3种方法排序后的结果返回给上位机观察
}
eusart_send(0xee); //为了方便上位机观察，多发送3个字节ee ee ee作为第2种方法与第3种方法的分割线
eusart_send(0xee);
eusart_send(0xee);
//第4种运算方法，依靠一个指针作为函数的输入输出接口。
//通过这个指针输入输出接口，ucGlobalBuffer_4数组既是输入数组，也是输出数组，排序运算后的结果直接存放在它本身，类似于全局变量的特点。
for(i=0;i<const_array_size;i++)
{
ucGlobalBuffer_4[i]=ucUsartBuffer[i]; //把需要被排序的原始数据传递给接收输入输出数组ucGlobalBuffer_4，
}
big_to_small_sort_4(ucGlobalBuffer_4);
for(i=0;i<const_array_size;i++)
{
eusart_send(ucGlobalBuffer_4[i]); //把用第4种方法排序后的结果返回给上位机观察
}
break; //退出循环
}
uiRcMoveIndex++; //因为是判断数据头，游标向着数组最尾端的方向移动
}
uiRcregTotal=0; //清空缓冲的下标，方便下次重新从0下标开始接受新数据
}
}
void eusart_send(unsigned char ucSendData) //往上位机发送一个字节的函数
{
ES = 0; //关串口中断
TI = 0; //清零串口发送完成中断请求标志
SBUF =ucSendData; //发送一个字节
delay_short(400); //每个字节之间的延时，这里非常关键，也是最容易出错的地方。延时的大小请根据实际项目来调整
TI = 0; //清零串口发送完成中断请求标志
ES = 1; //允许串口中断
}
void T0_time(void) interrupt 1 //定时中断
{
TF0=0; //清除中断标志
TR0=0; //关中断
if(uiSendCnt<const_receive_time) //如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完
{
uiSendCnt++; //表面上这个数据不断累加，但是在串口中断里，每接收一个字节它都会被清零，除非这个中间没有串口数据过来
ucSendLock=1; //开自锁标志
}
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 //发送中断，及时把发送中断标志位清零
{
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 delay_short(unsigned int uiDelayShort)
{
unsigned int i;
for(i=0;i<uiDelayShort;i++)
{
; //一个分号相当于执行一条空语句
}
}
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; //启动定时中断
}

复制代码

总结陈词：
通过本章的学习，我们知道指针在函数接口中的双向性，这个双向性是一把双刃剑，既给我们带来便捷，也给我们在以下两个场合中带来隐患。
第一个场合：当需要把输入接口和输出接口分开时，我们希望输入接口的参数不要被意外改变，改变的仅仅只能是输出接口的数据。但是指针的双向性，就有可能导致我们在写函数内部代码的时候一不小心改变而没有发觉。
第二个场合：如果是一个现成封装好的函数直接给我们调用，当我们发现是指针作为接口的时候，我们就不敢确定这个接口是输入接口，还是输出接口，或者是输入输出接口，我们传递进去的参数可能会更改，除非用之前进行数据备份，否则是没有安全感可言的。
有没有办法巧妙的解决以上两个问题？当然有。欲知详情，请听下回分解-----为指针加上紧箍咒const，避免意外修改了只做输入接口的数据。

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

jianhong_wu · 发表于 2014-7-13 08:31:13

第五十七节：为指针加上紧箍咒const，避免意外修改了只做输入接口的数据。

开场白：
通过上一节的学习，我们知道指针在函数接口中具有双向性，这个双向性是一把双刃剑，既给我们带来便捷，也给我们带来隐患。这一节要教大家以下知识点：
凡是做输入接口的指针，都应该加上const标签来标识,它可以让原来双向性的接口变成了单向性接口，它有两个好处：
第一个：如果你是用别人已经封装好的函数，你发现接口指针带了const标签，就足以说明这个指针只能做输入接口，你用了它，不用担心输入数据被修改。
第二个：如果是你自己写的函数，你在输入接口处的指针加了const标签，它可以预防你在写函数内部代码时不小心修改了输入接口的数据。比如，你试着在函数内部更改带const标签的输入接口数据，当你点击编译时，会编译不过，出现错误提示：error C183: unmodifiable lvalue。这就是一道防火墙啊！

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

（1）硬件平台：
基于坚鸿51单片机学习板。

（2）实现功能：
我只是把第55节中凡是输入接口数据的指针都加了const关键字标签，其它代码内容没变。
把5个随机数据按从大到小排序，用冒泡法来排序。
通过电脑串口调试助手，往单片机发送EB 00 55 08 06 09 05 07 指令，其中EB 00 55是数据头，08 06 09 05 07 是参与排序的5个随机原始数据。单片机收到指令后就会返回13个数据，最前面5个数据是第3种方法的排序结果，中间3个数据EE EE EE是第3种和第4种的分割线，为了方便观察，没实际意义。最后5个数据是第4种方法的排序结果.

比如电脑发送：EB 00 55 08 06 09 05 07
单片机就返回：09 08 07 06 05 EE EE EE 09 08 07 06 05

波特率是：9600 。

（3）源代码讲解如下：

#include "REG52.H"
#define const_array_size 5 //参与排序的数组大小
#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 delay_short(unsigned int uiDelayShort);
void T0_time(void); //定时中断函数
void usart_receive(void); //串口接收中断函数
void usart_service(void); //串口服务程序,在main函数里
void eusart_send(unsigned char ucSendData);
void big_to_small_sort_2(const unsigned char *p_ucInputBuffer);//第2种方法把一个数组从大到小排序
void big_to_small_sort_3(const unsigned char *p_ucInputBuffer,unsigned char *p_ucOutputBuffer);//第3种方法把一个数组从大到小排序
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 ucUsartBuffer[const_array_size]; //从串口接收到的需要排序的原始数据
unsigned char ucGlobalBuffer_2[const_array_size]; //第2种方法，参与具体排序算法的全局变量数组
unsigned char ucGlobalBuffer_3[const_array_size]; //第3种方法，用来接收输出接口数据的全局变量数组
void main()
{
initial_myself();
delay_long(100);
initial_peripheral();
while(1)
{
usart_service(); //串口服务程序
}
}
void big_to_small_sort_2(const unsigned char *p_ucInputBuffer)//第2种方法把一个数组从大到小排序
{
unsigned char i;
unsigned char k;
unsigned char ucTemp; //在两两交换数据的过程中，用于临时存放交换的某个变量
for(i=0;i<const_array_size;i++)
{
ucGlobalBuffer_2[i]=p_ucInputBuffer[i]; //参与排序算法之前，先把输入接口的数据全部搬移到全局变量数组中。
}
//以下就是著名的冒泡法排序。详细讲解请找百度。
for(i=0;i<(const_array_size-1);i++) //冒泡的次数是(const_array_size-1)次
{
for(k=0;k<(const_array_size-1-i);k++) //每次冒泡的过程中，需要两两比较的次数是(const_array_size-1-i)
{
if(ucGlobalBuffer_2[const_array_size-1-k]>ucGlobalBuffer_2[const_array_size-1-1-k]) //后一个与前一个数据两两比较
{
ucTemp=ucGlobalBuffer_2[const_array_size-1-1-k]; //通过一个中间变量实现两个数据交换
ucGlobalBuffer_2[const_array_size-1-1-k]=ucGlobalBuffer_2[const_array_size-1-k];
ucGlobalBuffer_2[const_array_size-1-k]=ucTemp;
}
}
}
}
/* 注释一：
* 凡是做输入接口的指针，都应该加上const标签来标识,它可以让原来双向性的接口变成了单向性接口，它有两个好处：
* 第一个：如果你是用别人已经封装好的函数，你发现接口指针带了const标签，就足以说明
* 这个指针只能做输入接口，你用了它，不用担心输入数据被修改。
* 第二个：如果是你自己写的函数，你在输入接口处的指针加了const标签，它可以预防你在写函数内部代码时
* 不小心修改了输入接口的数据。比如，你试着在以下函数最后的地方加一条更改输入接口数据的指令，
* 当你点击编译时，会编译不过，出现错误提示：error C183: unmodifiable lvalue。
*/
void big_to_small_sort_3(const unsigned char *p_ucInputBuffer,unsigned char *p_ucOutputBuffer)//第3种方法把一个数组从大到小排序
{
unsigned char i;
unsigned char k;
unsigned char ucTemp; //在两两交换数据的过程中，用于临时存放交换的某个变量
unsigned char ucBuffer_3[const_array_size]; //第3种方法，参与具体排序算法的局部变量数组
for(i=0;i<const_array_size;i++)
{
ucBuffer_3[i]=p_ucInputBuffer[i]; //参与排序算法之前，先把输入接口的数据全部搬移到局部变量数组中。
}
//以下就是著名的冒泡法排序。详细讲解请找百度。
for(i=0;i<(const_array_size-1);i++) //冒泡的次数是(const_array_size-1)次
{
for(k=0;k<(const_array_size-1-i);k++) //每次冒泡的过程中，需要两两比较的次数是(const_array_size-1-i)
{
if(ucBuffer_3[const_array_size-1-k]>ucBuffer_3[const_array_size-1-1-k]) //后一个与前一个数据两两比较
{
ucTemp=ucBuffer_3[const_array_size-1-1-k]; //通过一个中间变量实现两个数据交换
ucBuffer_3[const_array_size-1-1-k]=ucBuffer_3[const_array_size-1-k];
ucBuffer_3[const_array_size-1-k]=ucTemp;
}
}
}
for(i=0;i<const_array_size;i++)
{
p_ucOutputBuffer[i]=ucBuffer_3[i]; //参与排序算法之后，把运算结果的数据全部搬移到输出接口中，方便外面程序调用
}
/* 注释二：
* 以下这条是企图修改输入接口数据的指令，如果不屏蔽，编译的时候就会出错提醒：error C183: unmodifiable lvalue?
*/
//p_ucInputBuffer[0]=0; //修改输入接口数据的指令
}
void usart_service(void) //串口服务程序,在main函数里
{
unsigned char i=0;
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的判断
{
for(i=0;i<const_array_size;i++)
{
ucUsartBuffer[i]=ucRcregBuf[uiRcMoveIndex+3+i]; //从串口接收到的需要被排序的原始数据
}
//第2种运算方法，依靠指针为函数增加一个数组的输入接口
//通过指针输入接口，直接把ucUsartBuffer数组的首地址传址进去，排序后输出的结果还是保存在ucGlobalBuffer_2全局变量数组中
big_to_small_sort_2(ucUsartBuffer);
for(i=0;i<const_array_size;i++)
{
eusart_send(ucGlobalBuffer_2[i]); //把用第2种方法排序后的结果返回给上位机观察
}
eusart_send(0xee); //为了方便上位机观察，多发送3个字节ee ee ee作为第2种方法与第3种方法的分割线
eusart_send(0xee);
eusart_send(0xee);
//第3种运算方法，依靠指针为函数增加一个数组的输出接口
//通过指针输出接口，排序运算后的结果直接从这个输出口中导出到ucGlobalBuffer_3数组中
big_to_small_sort_3(ucUsartBuffer,ucGlobalBuffer_3); //ucUsartBuffer是输入的数组，ucGlobalBuffer_3是接收排序结果的数组
for(i=0;i<const_array_size;i++)
{
eusart_send(ucGlobalBuffer_3[i]); //把用第3种方法排序后的结果返回给上位机观察
}
break; //退出循环
}
uiRcMoveIndex++; //因为是判断数据头，游标向着数组最尾端的方向移动
}
uiRcregTotal=0; //清空缓冲的下标，方便下次重新从0下标开始接受新数据
}
}
void eusart_send(unsigned char ucSendData) //往上位机发送一个字节的函数
{
ES = 0; //关串口中断
TI = 0; //清零串口发送完成中断请求标志
SBUF =ucSendData; //发送一个字节
delay_short(400); //每个字节之间的延时，这里非常关键，也是最容易出错的地方。延时的大小请根据实际项目来调整
TI = 0; //清零串口发送完成中断请求标志
ES = 1; //允许串口中断
}
void T0_time(void) interrupt 1 //定时中断
{
TF0=0; //清除中断标志
TR0=0; //关中断
if(uiSendCnt<const_receive_time) //如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完
{
uiSendCnt++; //表面上这个数据不断累加，但是在串口中断里，每接收一个字节它都会被清零，除非这个中间没有串口数据过来
ucSendLock=1; //开自锁标志
}
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 //发送中断，及时把发送中断标志位清零
{
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 delay_short(unsigned int uiDelayShort)
{
unsigned int i;
for(i=0;i<uiDelayShort;i++)
{
; //一个分号相当于执行一条空语句
}
}
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; //启动定时中断
}

复制代码

总结陈词：
通过前面几节的学习，我们知道了指针在函数接口中的输入输出用途，以及const关键字的作用。下一节将要讲指针的第五大好处。欲知详情，请听下回分解-----指针的第五大好处，指针在众多数组中的中转站作用。

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

primer · 发表于 2014-7-17 14:11:38

很不错。继续努力。

primer · 发表于 2014-7-17 14:19:44

本帖最后由 primer 于 2014-7-17 14:21 编辑

12345678910

ceshi · 发表于 2014-7-17 14:42:13

12123123123

黑夜之狼 · 发表于 2014-7-17 14:50:28

持续关注

tiantan153 · 发表于 2014-7-17 16:12:31

鸿哥好样的！

jianhong_wu · 发表于 2014-7-17 16:21:52

tiantan153 发表于 2014-7-17 16:12
鸿哥好样的！

感谢大家支持。

Mr.Caiii · 发表于 2014-7-19 10:53:17

特地过来顶下鸿哥，我坚信，坚持看下去，肯定会有很大的收获，谢谢鸿哥~！！！

jianhong_wu · 发表于 2014-7-19 14:17:33

Mr.Caiii 发表于 2014-7-19 10:53
特地过来顶下鸿哥，我坚信，坚持看下去，肯定会有很大的收获，谢谢鸿哥~！！！

非常感谢。我后续会继续更新。

jianhong_wu · 发表于 2014-7-20 06:45:50

本帖最后由 jianhong_wu 于 2014-7-20 12:53 编辑

第五十八节：指针的第五大好处，指针在众多数组中的中转站作用。

开场白：

单个变量数据之间可以通过一条指令任意自由赋值转移，但是数组之间不能通过一条指令直接赋值转移，必须用for等循环指令挨个把数组的数据一个一个来赋值转移，如果一个函数中，有很多数组需要赋值转移，那就非常麻烦了，要用很多for语句，耗时。还好C语言里有个指针，它可以非常高效地来切换我们所需要的数组，起到很好的中转站作用。这一节要教大家一个知识点：指针在众多数组中的中转站作用。

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

（1）硬件平台：

基于朱兆祺51单片机学习板。

（2）实现功能：

在第57节的串口收发程序基础上修改。在串口接收函数中，以下代码有略微修改：

while(uiRcregTotal>=4&&uiRcMoveIndex<=(uiRcregTotal-4))//注意，这里是4，不是上一节的5，因为只有eb 00 55 xx这4个数据

通过上位机来调用下位机对应的数组数据。

通过电脑串口调试助手，往单片机发送EB 00 55 XX 指令，其中EB 00 55是数据头，XX的取值范围是0x01 至 0x05，每个不同的值代表调用下位机不同的数组数据。0x01调用第1组数据，0x02调用第2组数据，0x05调用第5组数据。

第1组：11 12 13 14 15

第2组：21 22 23 24 25

第3组：31 32 33 34 35

第4组：41 42 43 44 45

第5组：51 52 53 54 55

下位机返回21个数据，前面5个是第1种不带指针函数返回的数据。中间5个是第2种不带指针函数返回的数据。最后5个是第3种带指针函数返回的数据。期间2组EE EE EE是各函数返回的数据分割线，为了方便观察，没实际意义。

比如电脑发送：EB 0055 02

单片机就返回：21 2223 24 25 EE EE EE 21 22 23 24 25 EE EE EE 21 22 23 24 25

波特率是：9600 。

（3）源代码讲解如下：

#include "REG52.H"
#define const_array_size 5 //参与排序的数组大小
#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 delay_short(unsigned int uiDelayShort);
void T0_time(void); //定时中断函数
void usart_receive(void); //串口接收中断函数
void usart_service(void); //串口服务程序,在main函数里
void send_array_1(unsigned char ucArraySec); //第1种函数，不带指针
void send_array_2(unsigned char ucArraySec); //第2种函数，不带指针
void send_array_3(unsigned char ucArraySec); //第3种函数，带指针
void eusart_send(unsigned char ucSendData);
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; //用来解析数据协议的中间变量
const unsigned char array_0x01[]={0x11,0x12,0x13,0x14,0x15}; //第1个常量数组
const unsigned char array_0x02[]={0x21,0x22,0x23,0x24,0x25}; //第2个常量数组
const unsigned char array_0x03[]={0x31,0x32,0x33,0x34,0x35}; //第3个常量数组
const unsigned char array_0x04[]={0x41,0x42,0x43,0x44,0x45}; //第4个常量数组
const unsigned char array_0x05[]={0x51,0x52,0x53,0x54,0x55}; //第5个常量数组
void main()
{
initial_myself();
delay_long(100);
initial_peripheral();
while(1)
{
usart_service(); //串口服务程序
}
}
/* 注释一：
* 第1种函数，内部不带指针，根据上位机相关的指令，
* 直接返回对应的数组。由于不带指针，因此多用了5个for循环来搬运数组。
* 比较耗程序ROM容量，也不够简洁清晰。
*/
void send_array_1(unsigned char ucArraySec)
{
unsigned int i;
switch(ucArraySec)
{
case 1: //直接返回第1个常量数组
for(i=0;i<5;i++)
{
eusart_send(array_0x01[i]);
}
break;
case 2: //直接返回第2个常量数组
for(i=0;i<5;i++)
{
eusart_send(array_0x02[i]);
}
break;
case 3: //直接返回第3个常量数组
for(i=0;i<5;i++)
{
eusart_send(array_0x03[i]);
}
break;
case 4: //直接返回第4个常量数组
for(i=0;i<5;i++)
{
eusart_send(array_0x04[i]);
}
break;
case 5: //直接返回第5个常量数组
for(i=0;i<5;i++)
{
eusart_send(array_0x05[i]);
}
break;
}
}
/* 注释二：
* 第2种函数，内部不带指针，根据上位机相关的指令，
* 先转移对应的数组放到一个中间变量数组，然后发送数组。
* 由于不带指针，因此多用了6个for循环来搬运数组。
* 跟第1种函数一样，比较耗程序ROM容量，也不够简洁清晰。
*/
void send_array_2(unsigned char ucArraySec) //第2种函数，不带指针
{
unsigned int i;
unsigned char array_temp[5]; //临时中间数组
switch(ucArraySec)
{
case 1: //直接返回第1个常量数组
for(i=0;i<5;i++)
{
array_temp[i]=array_0x01[i]; //先挨个把对应的数组数据转移到中间数组里
}
break;
case 2: //直接返回第2个常量数组
for(i=0;i<5;i++)
{
array_temp[i]=array_0x02[i]; //先挨个把对应的数组数据转移到中间数组里
}
break;
case 3: //直接返回第3个常量数组
for(i=0;i<5;i++)
{
array_temp[i]=array_0x03[i]; //先挨个把对应的数组数据转移到中间数组里
}
break;
case 4: //直接返回第4个常量数组
for(i=0;i<5;i++)
{
array_temp[i]=array_0x04[i]; //先挨个把对应的数组数据转移到中间数组里
}
break;
case 5: //直接返回第5个常量数组
for(i=0;i<5;i++)
{
array_temp[i]=array_0x05[i]; //先挨个把对应的数组数据转移到中间数组里
}
break;
}
for(i=0;i<5;i++)
{
eusart_send(array_temp[i]); //把临时存放在中间数组的数据全部发送出去
}
}
/* 注释三：
* 第3种函数，内部带指针，根据上位机相关的指令，
* 先把对应的数组首地址传递给一个中间指针，然后再通过
* 指针把整个数组的数据发送出去，由于带指针，切换转移数组的数据非常快，
* 只需传递一下首地址给指针就可以，非常高效，整个函数只用了1个for循环。
* 跟前面第1,2种函数相比，更加节省程序容量，处理速度更加快，更加简洁。
*/
void send_array_3(unsigned char ucArraySec) //第3种函数，带指针
{
unsigned int i;
unsigned char *p_array; //临时中间指针，作为数组的中转站，非常高效
switch(ucArraySec)
{
case 1: //直接返回第1个常量数组
p_array=array_0x01; //把数组的首地址传递给指针，一个指令就可以，不用for来挨个搬移数据，高效!
break;
case 2: //直接返回第2个常量数组
p_array=array_0x02; //把数组的首地址传递给指针，一个指令就可以，不用for来挨个搬移数据，高效!
break;
case 3: //直接返回第3个常量数组
p_array=array_0x03; //把数组的首地址传递给指针，一个指令就可以，不用for来挨个搬移数据，高效!
break;
case 4: //直接返回第4个常量数组
p_array=array_0x04; //把数组的首地址传递给指针，一个指令就可以，不用for来挨个搬移数据，高效!
break;
case 5: //直接返回第5个常量数组
p_array=array_0x05; //把数组的首地址传递给指针，一个指令就可以，不用for来挨个搬移数据，高效!
break;
}
for(i=0;i<5;i++)
{
eusart_send(p_array[i]); //通过指针把数组的数据全部发送出去
}
}
void usart_service(void) //串口服务程序,在main函数里
{
unsigned char i=0;
unsigned char ucWhichArray;
if(uiSendCnt>=const_receive_time&&ucSendLock==1) //说明超过了一定的时间内，再也没有新数据从串口来
{
ucSendLock=0; //处理一次就锁起来，不用每次都进来,除非有新接收的数据
//下面的代码进入数据协议解析和数据处理的阶段
uiRcMoveIndex=0; //由于是判断数据头，所以下标移动变量从数组的0开始向最尾端移动
while(uiRcregTotal>=4&&uiRcMoveIndex<=(uiRcregTotal-4)) //注意，这里是4，不是上一节的5，因为只有eb 00 55 xx这4个数据
{
if(ucRcregBuf[uiRcMoveIndex+0]==0xeb&&ucRcregBuf[uiRcMoveIndex+1]==0x00&&ucRcregBuf[uiRcMoveIndex+2]==0x55) //数据头eb 00 55的判断
{
ucWhichArray=ucRcregBuf[uiRcMoveIndex+3]; //上位机需要返回的某个数组
send_array_1(ucWhichArray); //第1种函数返回数组的5个数据，不带指针
eusart_send(0xee); //为了方便上位机观察，多发送3个字节ee ee ee作为分割线
eusart_send(0xee);
eusart_send(0xee);
send_array_2(ucWhichArray); //第2种函数返回数组的5个数据，不带指针
eusart_send(0xee); //为了方便上位机观察，多发送3个字节ee ee ee作为分割线
eusart_send(0xee);
eusart_send(0xee);
send_array_3(ucWhichArray); //第3种函数返回数组的5个数据，带指针
break; //退出循环
}
uiRcMoveIndex++; //因为是判断数据头，游标向着数组最尾端的方向移动
}
uiRcregTotal=0; //清空缓冲的下标，方便下次重新从0下标开始接受新数据
}
}
void eusart_send(unsigned char ucSendData) //往上位机发送一个字节的函数
{
ES = 0; //关串口中断
TI = 0; //清零串口发送完成中断请求标志
SBUF =ucSendData; //发送一个字节
delay_short(400); //每个字节之间的延时，这里非常关键，也是最容易出错的地方。延时的大小请根据实际项目来调整
TI = 0; //清零串口发送完成中断请求标志
ES = 1; //允许串口中断
}
void T0_time(void) interrupt 1 //定时中断
{
TF0=0; //清除中断标志
TR0=0; //关中断
if(uiSendCnt<const_receive_time) //如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完
{
uiSendCnt++; //表面上这个数据不断累加，但是在串口中断里，每接收一个字节它都会被清零，除非这个中间没有串口数据过来
ucSendLock=1; //开自锁标志
}
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 //发送中断，及时把发送中断标志位清零
{
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 delay_short(unsigned int uiDelayShort)
{
unsigned int i;
for(i=0;i<uiDelayShort;i++)
{
; //一个分号相当于执行一条空语句
}
}
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; //启动定时中断
}

复制代码

总结陈词：

通过前面几节的学习，基本上讲完了我平时用指针的所有心得体会。

下一节开始讲新内容。在前面一些章节中，我提到为了防止中断函数把某些共享数据破坏，在主函数中更改某个数据变量时，应该先关闭中断，修改完后再打开中断；我也提到了网友“红金龙吸味”关于原子锁的建议。经过这段时间的思考和总结，我发现不管是关中断开中断，还是原子锁，其实本质上都是程序在多进程中临界点的数据处理，原子锁在程序员中有个专用名词叫互斥量，而我引以为豪的状态机程序框架，主函数的switch语句，外加一个定时中断，本质上就是2个独立进程在不断切换并行运行。我觉得这个临界点处理的知识很重要，也很容易忽略，所以我决定专门用两节内容来讲讲这方面的知识应用。欲知详情，请听下回分解-----关中断和开中断在多进程临界点的应用。

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

jianhong_wu · 发表于 2014-7-21 00:40:36

第五十九节：串口程序第40,44,45节中存在一个bug，特此紧急公告。

经过网友“intech2008”的提醒，在我之前发表的第40,44,45节串口接收程序中，在计算检验和的地方，存在一个不容易发觉的bug。
原来的是：

  for(i=0;i<(3+1+2+uiRcSize);i++) //计算校验累加和
  {
   ucRcregBuf[uiRcMoveIndex+6+uiRcSize]=ucRcregBuf[uiRcMoveIndex+6+uiRcSize]+ucRcregBuf[i];
  }

  应该改成:
  for(i=0;i<(3+1+2+uiRcSize);i++) //计算校验累加和
  {
   ucRcregBuf[uiRcMoveIndex+6+uiRcSize]=ucRcregBuf[uiRcMoveIndex+6+uiRcSize]+ucRcregBuf[uiRcMoveIndex+i];
  }

  由于本连载技术文章在各大论坛发布和被转载，我没法做到处处提醒，不得不专门用一节内容来告知各位读者。

  下节预告-----关中断和开中断在多进程临界点的应用。

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

ggg · 发表于 2014-7-23 13:24:01

支持。非常好的文章。

帐号		自动登录	找回密码
密码			立即注册

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

浏览过的版块