jianhong_wu 发表于 2014-4-5 11:19
第三十八节：判断数据尾来接收一串数据的串口通用程序框架。
开场白：
同志们：
如果你们在看鸿哥的程序串口不懂的配置，可以参照我的，我刚开始没调出来是QQ群里的@小傅-惠州告诉我要在中间的单字符串 发送区就可以的
使用说明书如下
又一个暑假 发表于 2014-7-28 21:16
同志们：
如果你们在看鸿哥的程序串口不懂的配置，可以参照我的，我刚开始没调出来是QQ群里的 ...
很不错的分享精神。
jianhong_wu 发表于 2014-7-28 21:24
很不错的分享精神。
很不幸的是我之前没用世界上最好用的串口调试助手
很幸运的是碰到这个问题后让我知道了世界上最好用的串口调试助手http://www.dumenmen.com/forum.php?mod=viewthread&tid=223&extra=page%3D2
{:soso_e113:}{:soso_e113:}现在发现这个软件还不迟。
很好很强大，找工作就指望这个帖子了:lol:lol:lol
连载，这个讲的好，谢谢！
第六十一节：组合BCD码，非组合BCD码，以及数值三者之间的相互转换和关系。
开场白：
本来这一节打算讲大数据的加法运算的，但是考虑大数据运算的基础是非组合BCD码，所以多增加一节讲BCD码的内容。
计算机中的BCD码，经常使用的有两种格式，即组合BCD码，非组合BCD码。
组合BCD码，是将两位十进制数，存放在一个字节中，例如：十进制数51的存放格式是0101 0001。
非组合BCD码，是将一个字节的低四位编码表示十进制数的一位，而高4位都为0。例如：十进制数51的占用了两个字节的空间，存放格式为：00000101 00000001。
这一节要教大家两个知识点：
第一个：如何编写组合BCD码，非组合BCD码，以及数值三者之间的相互转换函数。
第二个：通过转换函数的编写，重温前面几节所讲到的指针用法。
具体内容，请看源代码讲解。
（1）硬件平台：
基于坚鸿51单片机学习板。
（2）实现功能：
波特率是：9600 。
通过电脑串口调试助手模拟上位机，往单片机发送EB 00 55 XX YY YY … YY YY指令，其中EB 00 55是数据头，XX 是指令类型。YY是具体的数据。
指令类型01代表发送的是数值，需要转成组合BCD码和非组合BCD码，并且返回上位机显示。
指令类型02代表发送的是组合BCD码，需要转成数值和非组合BCD码，并且返回上位机显示。
指令类型03代表发送的是非组合BCD码，需要转成数值和组合BCD码，并且返回上位机显示。
返回上位机的数据中，中间3个数据EE EE EE是分割线，为了方便观察，没实际意义。
例如：十进制的数据52013140，它的十六进制数据是03 19 A8 54。
（a）上位机发送数据：eb 00 55 01 03 19 a8 54
单片机返回：52 01 31 40 EE EE EE 05 02 00 01 03 01 04 00
（b）上位机发送组合BCD码：eb 00 55 02 52 01 31 40
单片机返回：03 19 A8 54 EE EE EE 05 02 00 01 03 01 04 00
（c）发送非组合BCD码：eb 00 55 03 05 02 00 01 03 01 04 00
单片机返回：03 19 A8 54 EE EE EE 52 01 31 40
（3）源代码讲解如下：
#include "REG52.H"
#define const_voice_short40 //蜂鸣器短叫的持续时间
/* 注释一：
* 注意，此处的const_rc_size是20，比之前章节的缓冲区稍微改大了一点。
*/
#define const_rc_size20//接收串口中断数据的缓冲区数组大小
#define const_receive_time5//如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完，这个时间根据实际情况来调整大小
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 number_to_BCD4(const unsigned char *p_ucNumber,unsigned char *p_ucBCD_bit4);//把数值转换成组合BCD码
void number_to_BCD8(const unsigned char *p_ucNumber,unsigned char *p_ucBCD_bit8);//把数值转换成非组合BCD码
void BCD4_to_number(const unsigned char *p_ucBCD_bit4,unsigned char *p_ucNumber); //组合BCD码转成数值
void BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4,unsigned char *p_ucBCD_bit8); //组合BCD码转成非组合BCD码
void BCD8_to_number(const unsigned char *p_ucBCD_bit8,unsigned char *p_ucNumber); //非组合BCD码转成数值
void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8,unsigned char *p_ucBCD_bit4); //非组合BCD码转成组合BCD码
sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
unsigned intuiSendCnt=0; //用来识别串口是否接收完一串数据的计时器
unsigned char ucSendLock=1; //串口服务程序的自锁变量，每次接收完一串数据只处理一次
unsigned intuiRcregTotal=0;//代表当前缓冲区已经接收了多少个数据
unsigned char ucRcregBuf; //接收串口中断数据的缓冲区数组
unsigned intuiRcMoveIndex=0;//用来解析数据协议的中间变量
/* 注释二：
* 注意，本程序规定数值的最大范围是0至99999999
* 数组中的数据。高位在数组下标大的方向，低位在数组下标小的方向。
*/
unsigned char ucBufferNumber; //数值，用4个字节表示long类型的数值
unsigned char ucBufferBCB_bit4; //组合BCD码
unsigned char ucBufferBCB_bit8; //非组合BCD码
void main()
{
initial_myself();
delay_long(100);
initial_peripheral();
while(1)
{
usart_service();//串口服务程序
}
}
void number_to_BCD4(const unsigned char *p_ucNumber,unsigned char *p_ucBCD_bit4)//把数值转换成组合BCD码
{
unsigned long ulNumberTemp=0;
unsigned char ucTemp=0;
ulNumberTemp=p_ucNumber;//把4个字节的数值合并成一个long类型数据
ulNumberTemp=ulNumberTemp<<8;
ulNumberTemp=ulNumberTemp+p_ucNumber;
ulNumberTemp=ulNumberTemp<<8;
ulNumberTemp=ulNumberTemp+p_ucNumber;
ulNumberTemp=ulNumberTemp<<8;
ulNumberTemp=ulNumberTemp+p_ucNumber;
p_ucBCD_bit4=ulNumberTemp%100000000/10000000;
p_ucBCD_bit4=p_ucBCD_bit4<<4; //前半4位存第8位组合BCD码
ucTemp=ulNumberTemp%10000000/1000000;
p_ucBCD_bit4=p_ucBCD_bit4+ucTemp; //后半4位存第7位组合BCD码
p_ucBCD_bit4=ulNumberTemp%1000000/100000;
p_ucBCD_bit4=p_ucBCD_bit4<<4; //前半4位存第6位组合BCD码
ucTemp=ulNumberTemp%100000/10000;
p_ucBCD_bit4=p_ucBCD_bit4+ucTemp;//后半4位存第5位组合BCD码
p_ucBCD_bit4=ulNumberTemp%10000/1000;
p_ucBCD_bit4=p_ucBCD_bit4<<4; //前半4位存第4位组合BCD码
ucTemp=ulNumberTemp%1000/100;
p_ucBCD_bit4=p_ucBCD_bit4+ucTemp;//后半4位存第3位组合BCD码
p_ucBCD_bit4=ulNumberTemp%100/10;
p_ucBCD_bit4=p_ucBCD_bit4<<4; //前半4位存第2位组合BCD码
ucTemp=ulNumberTemp%10;
p_ucBCD_bit4=p_ucBCD_bit4+ucTemp;//后半4位存第1位组合BCD码
}
void number_to_BCD8(const unsigned char *p_ucNumber,unsigned char *p_ucBCD_bit8)//把数值转换成非组合BCD码
{
unsigned long ulNumberTemp=0;
ulNumberTemp=p_ucNumber;//把4个字节的数值合并成一个long类型数据
ulNumberTemp=ulNumberTemp<<8;
ulNumberTemp=ulNumberTemp+p_ucNumber;
ulNumberTemp=ulNumberTemp<<8;
ulNumberTemp=ulNumberTemp+p_ucNumber;
ulNumberTemp=ulNumberTemp<<8;
ulNumberTemp=ulNumberTemp+p_ucNumber;
p_ucBCD_bit8=ulNumberTemp%100000000/10000000;//一个字节8位存储第8位非组合BCD码
p_ucBCD_bit8=ulNumberTemp%10000000/1000000;//一个字节8位存储第7位非组合BCD码
p_ucBCD_bit8=ulNumberTemp%1000000/100000;//一个字节8位存储第6位非组合BCD码
p_ucBCD_bit8=ulNumberTemp%100000/10000;//一个字节8位存储第5位非组合BCD码
p_ucBCD_bit8=ulNumberTemp%10000/1000;//一个字节8位存储第4位非组合BCD码
p_ucBCD_bit8=ulNumberTemp%1000/100;//一个字节8位存储第3位非组合BCD码
p_ucBCD_bit8=ulNumberTemp%100/10;//一个字节8位存储第2位非组合BCD码
p_ucBCD_bit8=ulNumberTemp%10;//一个字节8位存储第1位非组合BCD码
}
void BCD4_to_number(const unsigned char *p_ucBCD_bit4,unsigned char *p_ucNumber) //组合BCD码转成数值
{
unsigned long ulTmep;
unsigned long ulSum;
ulSum=0;//累加和数值清零
ulTmep=0;
ulTmep=p_ucBCD_bit4;
ulTmep=ulTmep>>4;//把组合BCD码第8位分解出来
ulTmep=ulTmep*10000000;
ulSum=ulSum+ulTmep; //累加各位数值
ulTmep=0;
ulTmep=p_ucBCD_bit4;
ulTmep=ulTmep&0x0000000f;//把组合BCD码第7位分解出来
ulTmep=ulTmep*1000000;
ulSum=ulSum+ulTmep; //累加各位数值
ulTmep=0;
ulTmep=p_ucBCD_bit4;
ulTmep=ulTmep>>4;//把组合BCD码第6位分解出来
ulTmep=ulTmep*100000;
ulSum=ulSum+ulTmep; //累加各位数值
ulTmep=0;
ulTmep=p_ucBCD_bit4;
ulTmep=ulTmep&0x0000000f;//把组合BCD码第5位分解出来
ulTmep=ulTmep*10000;
ulSum=ulSum+ulTmep; //累加各位数值
ulTmep=0;
ulTmep=p_ucBCD_bit4;
ulTmep=ulTmep>>4;//把组合BCD码第4位分解出来
ulTmep=ulTmep*1000;
ulSum=ulSum+ulTmep; //累加各位数值
ulTmep=0;
ulTmep=p_ucBCD_bit4;
ulTmep=ulTmep&0x0000000f;//把组合BCD码第3位分解出来
ulTmep=ulTmep*100;
ulSum=ulSum+ulTmep; //累加各位数值
ulTmep=0;
ulTmep=p_ucBCD_bit4;
ulTmep=ulTmep>>4;//把组合BCD码第2位分解出来
ulTmep=ulTmep*10;
ulSum=ulSum+ulTmep; //累加各位数值
ulTmep=0;
ulTmep=p_ucBCD_bit4;
ulTmep=ulTmep&0x0000000f;//把组合BCD码第1位分解出来
ulTmep=ulTmep*1;
ulSum=ulSum+ulTmep; //累加各位数值
//以上代码非常有规律，有兴趣的读者也可以自己想办法把它压缩成一个for循环的函数，可以极大节省容量。
p_ucNumber=ulSum>>24;//把long类型数据分解成4个字节
p_ucNumber=ulSum>>16;
p_ucNumber=ulSum>>8;
p_ucNumber=ulSum;
}
void BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4,unsigned char *p_ucBCD_bit8) //组合BCD码转成非组合BCD码
{
unsigned char ucTmep;
ucTmep=p_ucBCD_bit4;
p_ucBCD_bit8=ucTmep>>4; //把组合BCD码第8位分解出来
p_ucBCD_bit8=ucTmep&0x0f;//把组合BCD码第7位分解出来
ucTmep=p_ucBCD_bit4;
p_ucBCD_bit8=ucTmep>>4; //把组合BCD码第6位分解出来
p_ucBCD_bit8=ucTmep&0x0f;//把组合BCD码第5位分解出来
ucTmep=p_ucBCD_bit4;
p_ucBCD_bit8=ucTmep>>4; //把组合BCD码第4位分解出来
p_ucBCD_bit8=ucTmep&0x0f;//把组合BCD码第3位分解出来
ucTmep=p_ucBCD_bit4;
p_ucBCD_bit8=ucTmep>>4; //把组合BCD码第2位分解出来
p_ucBCD_bit8=ucTmep&0x0f;//把组合BCD码第1位分解出来
}
void BCD8_to_number(const unsigned char *p_ucBCD_bit8,unsigned char *p_ucNumber) //非组合BCD码转成数值
{
unsigned long ulTmep;
unsigned long ulSum;
ulSum=0;//累加和数值清零
ulTmep=0;
ulTmep=p_ucBCD_bit8;
ulTmep=ulTmep*10000000;
ulSum=ulSum+ulTmep; //累加各位数值
ulTmep=0;
ulTmep=p_ucBCD_bit8;
ulTmep=ulTmep*1000000;
ulSum=ulSum+ulTmep; //累加各位数值
ulTmep=0;
ulTmep=p_ucBCD_bit8;
ulTmep=ulTmep*100000;
ulSum=ulSum+ulTmep; //累加各位数值
ulTmep=0;
ulTmep=p_ucBCD_bit8;
ulTmep=ulTmep*10000;
ulSum=ulSum+ulTmep; //累加各位数值
ulTmep=0;
ulTmep=p_ucBCD_bit8;
ulTmep=ulTmep*1000;
ulSum=ulSum+ulTmep; //累加各位数值
ulTmep=0;
ulTmep=p_ucBCD_bit8;
ulTmep=ulTmep*100;
ulSum=ulSum+ulTmep; //累加各位数值
ulTmep=0;
ulTmep=p_ucBCD_bit8;
ulTmep=ulTmep*10;
ulSum=ulSum+ulTmep; //累加各位数值
ulTmep=0;
ulTmep=p_ucBCD_bit8;
ulTmep=ulTmep*1;
ulSum=ulSum+ulTmep; //累加各位数值
//以上代码非常有规律，有兴趣的读者也可以自己想办法把它压缩成一个for循环的函数，可以极大节省容量。
p_ucNumber=ulSum>>24;//把long类型数据分解成4个字节
p_ucNumber=ulSum>>16;
p_ucNumber=ulSum>>8;
p_ucNumber=ulSum;
}
void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8,unsigned char *p_ucBCD_bit4) //非组合BCD码转成组合BCD码
{
unsigned char ucTmep;
ucTmep=p_ucBCD_bit8; //把非组合BCD码第8位分解出来
p_ucBCD_bit4=ucTmep<<4;
p_ucBCD_bit4=p_ucBCD_bit4+p_ucBCD_bit8; //把非组合BCD码第7位分解出来
ucTmep=p_ucBCD_bit8; //把非组合BCD码第6位分解出来
p_ucBCD_bit4=ucTmep<<4;
p_ucBCD_bit4=p_ucBCD_bit4+p_ucBCD_bit8; //把非组合BCD码第5位分解出来
ucTmep=p_ucBCD_bit8; //把非组合BCD码第4位分解出来
p_ucBCD_bit4=ucTmep<<4;
p_ucBCD_bit4=p_ucBCD_bit4+p_ucBCD_bit8; //把非组合BCD码第3位分解出来
ucTmep=p_ucBCD_bit8; //把非组合BCD码第2位分解出来
p_ucBCD_bit4=ucTmep<<4;
p_ucBCD_bit4=p_ucBCD_bit4+p_ucBCD_bit8; //把非组合BCD码第1位分解出来
}
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==0xeb&&ucRcregBuf==0x00&&ucRcregBuf==0x55)//数据头eb 00 55的判断
{
switch(ucRcregBuf)//根据命令类型来进行不同的处理
{
case 1://接收到的是数值，需要转成组合BCD码和非组合BCD码
for(i=0;i<4;i++)
{
ucBufferNumber=ucRcregBuf; //从串口接收到的数据，注意，高位在数组下标大的方向
}
number_to_BCD4(ucBufferNumber,ucBufferBCB_bit4);//把数值转换成组合BCD码
number_to_BCD8(ucBufferNumber,ucBufferBCB_bit8);//把数值转换成非组合BCD码
for(i=0;i<4;i++)
{
eusart_send(ucBufferBCB_bit4);////把组合BCD码返回给上位机观察，注意，高位在数组下标大的方向
}
eusart_send(0xee);//为了方便上位机观察，多发送3个字节ee ee ee作为分割线
eusart_send(0xee);
eusart_send(0xee);
for(i=0;i<8;i++)
{
eusart_send(ucBufferBCB_bit8);////把非组合BCD码返回给上位机观察，注意，高位在数组下标大的方向
}
break;
case 2://接收到的是组合BCD码，需要转成数值和非组合BCD码
for(i=0;i<4;i++)
{
ucBufferBCB_bit4=ucRcregBuf; //从串口接收到的组合BCD码，注意，高位在数组下标大的方向
}
BCD4_to_number(ucBufferBCB_bit4,ucBufferNumber); //组合BCD码转成数值
BCD4_to_BCD8(ucBufferBCB_bit4,ucBufferBCB_bit8); //组合BCD码转成非组合BCD码
for(i=0;i<4;i++)
{
eusart_send(ucBufferNumber);////把数值返回给上位机观察，注意，高位在数组下标大的方向
}
eusart_send(0xee);//为了方便上位机观察，多发送3个字节ee ee ee作为分割线
eusart_send(0xee);
eusart_send(0xee);
for(i=0;i<8;i++)
{
eusart_send(ucBufferBCB_bit8);////把非组合BCD码返回给上位机观察，注意，高位在数组下标大的方向
}
break;
case 3://接收到的是非组合BCD码，需要转成数值和组合BCD码
for(i=0;i<8;i++)
{
ucBufferBCB_bit8=ucRcregBuf; //从串口接收到的非组合BCD码，注意，高位在数组下标大的方向
}
BCD8_to_number(ucBufferBCB_bit8,ucBufferNumber); //非组合BCD码转成数值
BCD8_to_BCD4(ucBufferBCB_bit8,ucBufferBCB_bit4); //非组合BCD码转成组合BCD码
for(i=0;i<4;i++)
{
eusart_send(ucBufferNumber);////把数值返回给上位机观察
}
eusart_send(0xee);//为了方便上位机观察，多发送3个字节ee ee ee作为分割线，注意，高位在数组下标大的方向
eusart_send(0xee);
eusart_send(0xee);
for(i=0;i<4;i++)
{
eusart_send(ucBufferBCB_bit4);////把组合BCD码返回给上位机观察，注意，高位在数组下标大的方向
}
break;
}
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=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; //启动定时中断
}
总结陈词：
有了这一节非组合BCD的基础知识，下一节就开始讲大数据的算法程序。这些算法程序经常要用在计算器，工控，以及高精度的仪器仪表等领域。C语言的语法中不是已经提供了+,-,*,/这些运算符号吗？为什么还要专门写算法程序？因为那些运算符只能进行简单的运算，一旦数据超过了unsigned long（4个字节）的范围就会出错。而这种大数据算法的程序是什么样的？欲知详情，请听下回分解----大数据的加法运算。
（未完待续，下节更精彩，不要走开哦）
第六十二节：大数据的加法运算。
开场白：
直接用C语言的“+”运算符进行加法运算时，“被加数”，“加数”，“和”，这三个数据的最大范围是unsigned long 类型，也就是数据最大范围是4个字节，十进制的范围是0至4294967295。一旦超过了这个范围，则运算会出错。因此，当进行大数据加法运算时，我们要额外编程序，实现大数据的算法。其实这种算法并不难，就是我们在小学里学的四则运算算法。
我们先要弄清楚一个新的概念。不考虑小数点的情况下，数据有两种表现形式。一种是常用的变量形式，另外一种是上一节讲到的BCD码数组形式。变量的最大范围有限，而BCD码数组的形式是无限的，正因为这个特点，所以我们可以进行大数据运算。
这一节要教大家两个知识点：
第一个：如何通过用for循环语句改写上一节的组合BCD码跟非组合BCD码的转换函数。
第二个：如何编写涉及到大数据加法运算的算法程序函数，同时也复习了指针的用途。
第三个：如何在串口程序中通过关键字来截取所需要的数据。
具体内容，请看源代码讲解。
（1）硬件平台：
基于坚鸿51单片机学习板。
（2）实现功能：
波特率是：9600 。
通过电脑串口调试助手模拟上位机，往单片机发送组合BCD码的被加数和加数。单片机把组合BCD码的运算结果返回到上位机。最大范围4位，从0到9999，如果超范围则返回EE EE EE报错。往单片机发送的数据格式：EB 00 55 XX XX 0d 0aYY YY0d 0a指令，其中EB 00 55是数据头，XX 是被加数，可以是1个字节，也可以是2个字节。YY是加数，可以是1个字节，也可以是2个字节。0d 0a是固定的结束标志。
例如：
（a）1234+5678=6912
上位机发送数据：eb 00 55 12 34 0d 0a 56 78 0d 0a
单片机返回：69 12
（b）9999+56=10055超过4位的9999，所以报错
上位机发送数据：eb 00 55 99 990d 0a 56 0d 0a
单片机返回：EE EE EE表示出错了
（3）源代码讲解如下：
#include "REG52.H"
/* 注释一：
* 本系统中，规定最大运算位数是4位。
* 由于STC89C52单片机的RAM只有256个，也就是说系统的变量数最大
* 不能超过256个，如果超过了这个极限，编译器就会报错。如果这个算法
* 移植到stm32或者PIC等RAM比较大的单片机上，那么就可以把这个运算位数
* 设置得更加大一点。
*/
#defineBCD4_MAX 2//本系统中，规定的组合BCD码最大字节数，一个字节包含2位，因此4位有效运算数
#defineBCD8_MAX (BCD4_MAX*2)//本系统中，规定的非组合BCD码最大字节数，一个字节包含1位，因此4位有效运算数
#define const_rc_size30//接收串口中断数据的缓冲区数组大小
#define const_receive_time5//如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完，这个时间根据实际情况来调整大小
#define uchar unsigned char //方便移植平台
#define ulong unsigned long //方便移植平台
//如果在VC的平台模拟此算法，则都定义成int类型，如下：
//#define uchar int
//#define ulong int
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 BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4,unsigned char ucBCD4_cnt,unsigned char *p_ucBCD_bit8,unsigned char *p_ucBCD8_cnt);
void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8,unsigned char ucBCD8_cnt,unsigned char *p_ucBCD_bit4,unsigned char *p_ucBCD4_cnt);
void ClearAllData(uchar ucARRAY_MAX,uchar *destData);
uchar GetDataLength(const uchar *destData,uchar ucARRAY_MAX);
uchar AddData(const uchar *destData,const uchar *sourceData,uchar *resultData);
sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
unsigned intuiSendCnt=0; //用来识别串口是否接收完一串数据的计时器
unsigned char ucSendLock=1; //串口服务程序的自锁变量，每次接收完一串数据只处理一次
unsigned intuiRcregTotal=0;//代表当前缓冲区已经接收了多少个数据
unsigned char ucRcregBuf; //接收串口中断数据的缓冲区数组
unsigned intuiRcMoveIndex=0;//用来解析数据协议的中间变量
unsigned char ucDataBCD4_1; //接收到的第1个数组合BCD码数组形式这里是指被加数
unsigned char ucDataBCD4_cnt_1=0;//接收到的第1个数组合BCD码数组的有效数据长度
unsigned char ucDataBCD4_2; //接收到的第2个数组合BCD码数组形式这里是指加数
unsigned char ucDataBCD4_cnt_2=0;//接收到的第2个数组合BCD码数组的有效数据长度
unsigned char ucDataBCD4_3; //接收到的第3个数组合BCD码数组形式这里是指和
unsigned char ucDataBCD4_cnt_3=0;//接收到的第3个数组合BCD码数组的有效数据长度
unsigned char ucDataBCD8_1; //接收到的第1个数非组合BCD码数组形式 这里是指被加数
unsigned char ucDataBCD8_cnt_1=0;//接收到的第1个数非组合BCD码数组的有效数据长度
unsigned char ucDataBCD8_2; //接收到的第2个数非组合BCD码数组形式 这里是指加数
unsigned char ucDataBCD8_cnt_2=0;//接收到的第2个数非组合BCD码数组的有效数据长度
unsigned char ucDataBCD8_3; //接收到的第3个数非组合BCD码数组形式 这里是指和
unsigned char ucDataBCD8_cnt_3=0;//接收到的第3个数非组合BCD码数组的有效数据长度
unsigned char ucResultFlag=11; //运算结果标志，10代表计算结果超出范围出错，11代表正常。
void main()
{
initial_myself();
delay_long(100);
initial_peripheral();
while(1)
{
usart_service();//串口服务程序
}
}
/* 注释二：
* 组合BCD码转成非组合BCD码。
* 这里的变量ucBCD4_cnt代表组合BCD码的有效字节数.
* 这里的变量*p_ucBCD8_cnt代表经过转换后，非组合BCD码的有效字节数，记得加地址符号&传址进去
* 本程序在上一节的基础上，略作修改，用循环for语句压缩了代码，
* 同时引进了组合BCD码的有效字节数变量。这样就不限定了数据的长度，
* 可以让我们根据数据的实际大小灵活运用。
*/
void BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4,unsigned char ucBCD4_cnt,unsigned char *p_ucBCD_bit8,unsigned char *p_ucBCD8_cnt)
{
unsigned char ucTmep;
unsigned char i;
for(i=0;i<BCD8_MAX;i++) //先把即将保存转换结果的缓冲区清零
{
p_ucBCD_bit8=0;
}
*p_ucBCD8_cnt=ucBCD4_cnt*2; //转换成非组合BCD码后的有效数据长度
for(i=0;i<ucBCD4_cnt;i++)
{
ucTmep=p_ucBCD_bit4;
p_ucBCD_bit8=ucTmep>>4;
p_ucBCD_bit8=ucTmep&0x0f;
}
}
/* 注释三：
* 非组合BCD码转成组合BCD码。
* 这里的变量ucBCD8_cnt代表非组合BCD码的有效字节数.
* 这里的变量*p_ucBCD4_cnt代表经过转换后，组合BCD码的有效字节数，记得加地址符号&传址进去
* 本程序在上一节的基础上，略作修改，用循环for语句压缩了代码，
* 同时引进了非组合BCD码的有效字节数变量。这样就不限定了数据的长度，
* 可以让我们根据数据的实际大小灵活运用。
*/
void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8,unsigned char ucBCD8_cnt,unsigned char *p_ucBCD_bit4,unsigned char *p_ucBCD4_cnt)
{
unsigned char ucTmep;
unsigned char i;
unsigned char ucBCD4_cnt;
for(i=0;i<BCD4_MAX;i++) //先把即将保存转换结果的缓冲区清零
{
p_ucBCD_bit4=0;
}
ucBCD4_cnt=(ucBCD8_cnt+1)/2; //非组合BCD码转化成组合BCD码的有效数,这里+1避免非组合数据长度是奇数位
*p_ucBCD4_cnt=ucBCD4_cnt; //把转换后的结果付给接口指针的数据，可以对外输出结果
for(i=0;i<ucBCD4_cnt;i++)
{
ucTmep=p_ucBCD_bit8; //把非组合BCD码第8位分解出来
p_ucBCD_bit4=ucTmep<<4;
p_ucBCD_bit4=p_ucBCD_bit4+p_ucBCD_bit8; //把非组合BCD码第7位分解出来
}
}
/* 注释四：
*函数介绍：清零数组的全部数组数据
*输入参数：ucARRAY_MAX代表数组定义的最大长度
*输入输出参数：*destData--被清零的数组。
*/
void ClearAllData(uchar ucARRAY_MAX,uchar *destData)
{
uchar i;
for(i=0;i<ucARRAY_MAX;i++)
{
destData=0;
}
}
/* 注释五：
*函数介绍：获取数组的有效长度
*输入参数：*destData--被获取的数组。
*输入参数：ucARRAY_MAX代表数组定义的最大长度
*返回值：返回数组的有效长度。比如58786这个数据的有效长度是5
*电子开发者作者：吴坚鸿
*/
uchar GetDataLength(const uchar *destData,uchar ucARRAY_MAX)
{
uchar i;
uchar DataLength=ucARRAY_MAX;
for(i=0;i<ucARRAY_MAX;i++)
{
if(0!=destData)
{
break;
}
else
{
DataLength--;
}
}
return DataLength;
}
/* 注释六：
*函数介绍：两个数相加
*输入参数：
*（1）*destData--被加数的数组。
*（2）*sourceData--加数的数组。
*（3）*resultData--和的数组。注意，调用本函数前，必须先把这个数组清零
*返回值：10代表计算结果超出范围出错，11代表正常。
*/
uchar AddData(const uchar *destData,const uchar *sourceData,uchar *resultData)
{
uchar addResult=11; //开始默认返回的运算结果是正常
uchar destCnt=0;
uchar sourceCnt=0;
uchar i;
uchar carryData=0;//进位
uchar maxCnt=0; //最大位数
uchar resultTemp=0; //存放临时运算结果的中间变量
//为什么不在本函数内先把resultData数组清零？因为后面章节中的乘法运算中要用到此函数实现连加功能。
//因此如果纯粹实现加法运算时，在调用本函数之前，必须先在外面把和的数组清零，否则会计算出错。
destCnt=GetDataLength(destData,BCD8_MAX); //获取被加数的有效位数
sourceCnt=GetDataLength(sourceData,BCD8_MAX);//获取加数的有效位数
if(destCnt>=sourceCnt)//找出两个运算数据中最大的有效位数
{
maxCnt=destCnt;
}
else
{
maxCnt=sourceCnt;
}
for(i=0;i<maxCnt;i++)
{
resultTemp=destData+sourceData+carryData; //按位相加
resultData=resultTemp%10; //截取最低位存放进保存结果的数组
carryData=resultTemp/10; //存放进位
}
resultData=carryData;
if((maxCnt==BCD8_MAX)&&(carryData==1))//如果数组的有效位是最大值并且最后的进位是1，则计算溢出报错
{
ClearAllData(BCD8_MAX,resultData);
addResult=10;//报错
}
return addResult;
}
void usart_service(void)//串口服务程序,在main函数里
{
unsigned char i=0;
unsigned char k=0;
unsigned char ucGetDataStep=0;
if(uiSendCnt>=const_receive_time&&ucSendLock==1) //说明超过了一定的时间内，再也没有新数据从串口来
{
ucSendLock=0; //处理一次就锁起来，不用每次都进来,除非有新接收的数据
//下面的代码进入数据协议解析和数据处理的阶段
uiRcMoveIndex=0; //由于是判断数据头，所以下标移动变量从数组的0开始向最尾端移动
while(uiRcMoveIndex<uiRcregTotal)//说明还没有把缓冲区的数据读取完
{
if(ucRcregBuf==0xeb&&ucRcregBuf==0x00&&ucRcregBuf==0x55)//数据头eb 00 55的判断
{
i=0;
ucGetDataStep=0;
ucDataBCD4_cnt_1=0;//第1个数组合BCD码数组的有效数据长度
ucDataBCD4_cnt_2=0;//第2个数组合BCD码数组的有效数据长度
ClearAllData(BCD4_MAX,ucDataBCD4_1);//清零第1个参与运算的数据
ClearAllData(BCD4_MAX,ucDataBCD4_2);//清零第2个参与运算的数据
//以下while循环是通过关键字0x0d 0x0a来截取第1个和第2个参与运算的数据。
while(i<(BCD8_MAX+4))//这里+4是因为有2对0x0d 0x0a结尾特殊符号，一个共4个字节
{
if(ucGetDataStep==0)//步骤0，相当于我平时用的case 0,获取第1个数，在这里是指被加数
{
if(ucRcregBuf==0x0d&&ucRcregBuf==0x0a) //结束标志
{
for(k=0;k<ucDataBCD4_cnt_1;k++) //提取第1个参与运算的数组数据
{
ucDataBCD4_1=ucRcregBuf; //注意，接收到的数组数据与实际存储的数组数据的下标方向是相反的
}
i=i+2; //跳过 0x0d 0x0a 这两个字节，进行下一轮的关键字提取
ucGetDataStep=1;//切换到下一个关键字提取的步骤
}
else
{
i++;
ucDataBCD4_cnt_1++;//统计第1个有效数据的长度
}
}
else if(ucGetDataStep==1) //步骤1，相当于我平时用的case 1,获取第2个参与运行的数，在这里是加数
{
if(ucRcregBuf==0x0d&&ucRcregBuf==0x0a) //结束标志
{
for(k=0;k<ucDataBCD4_cnt_2;k++) //提取第2个参与运算的数组数据
{
ucDataBCD4_2=ucRcregBuf; //注意，接收到的数组数据与实际存储的数组数据的下标方向是相反的
}
break; //截取数据完成。直接跳出截取数据的while(i<(BCD8_MAX+4))循环
}
else
{
i++;
ucDataBCD4_cnt_2++;//统计第2个有效数据的长度
}
}
}
//注意ucDataBCD8_cnt_1和ucDataBCD8_cnt_2要带地址符号&传址进去
BCD4_to_BCD8(ucDataBCD4_1,ucDataBCD4_cnt_1,ucDataBCD8_1,&ucDataBCD8_cnt_1); //把接收到的组合BCD码转换成非组合BCD码第1个数
BCD4_to_BCD8(ucDataBCD4_2,ucDataBCD4_cnt_2,ucDataBCD8_2,&ucDataBCD8_cnt_2); //把接收到的组合BCD码转换成非组合BCD码第2个数
ClearAllData(BCD8_MAX,ucDataBCD8_3);//清零第3个参与运算的数据,用来接收运行的结果
ucResultFlag=AddData(ucDataBCD8_1,ucDataBCD8_2,ucDataBCD8_3); //相加运算，结果放在ucDataBCD8_3数组里
if(ucResultFlag==11) //表示运算结果没有超范围
{
ucDataBCD8_cnt_3=GetDataLength(ucDataBCD8_3,BCD8_MAX);//获取和的有效字节数
BCD8_to_BCD4(ucDataBCD8_3,ucDataBCD8_cnt_3,ucDataBCD4_3,&ucDataBCD4_cnt_3); //把非组合BCD码转成组合BCD码。注意，&ucDataBCD4_cnt_3带地址符号&
for(k=0;k<ucDataBCD4_cnt_3;k++) //返回运算结果到上位机上观察。看到的是组合BCD码形式。返回的时候注意数组下标的顺序要反过来发送，先发高位的下标数组
{
eusart_send(ucDataBCD4_3); //往上位机发送一个字节的函数
}
}
else //运算结果超范围，返回EE EE EE
{
eusart_send(0xee); //往上位机发送一个字节的函数
eusart_send(0xee); //往上位机发送一个字节的函数
eusart_send(0xee); //往上位机发送一个字节的函数
}
break; //退出循环
}
uiRcMoveIndex++; //因为是判断数据头，游标向着数组最尾端的方向移动
}
ucRcregBuf=0; //把数据头清零，方便下次接收判断新数据
ucRcregBuf=0;
ucRcregBuf=0;
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=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语言的“-”运算符进行加法运算时，“被减数”，“ 减数”，“差”，这三个数据的最大范围是unsigned long 类型，也就是数据最大范围是4个字节，十进制的范围是0至4294967295。一旦超过了这个范围，则运算会出错。因此，当进行大数据减法运算时，我们要额外编程序，实现大数据的算法。其实这种算法并不难，就是我们在小学里学的四则运算算法。
我们先要弄清楚一个新的概念。不考虑小数点的情况下，数据有两种表现形式。一种是常用的变量形式，另外一种是BCD码数组形式。变量的最大范围有限，而BCD码数组的形式是无限的，正因为这个特点，所以我们可以进行大数据运算。
这一节要教大家两个知识点：
第一个：如何编写比较两个非组合BCD码数据的大小。
第二个：如何编写涉及到大数据减法运算的算法程序函数，同时也复习了指针的用途。
具体内容，请看源代码讲解。
（1）硬件平台：
基于坚鸿51单片机学习板。
（2）实现功能：
波特率是：9600 。
通过电脑串口调试助手模拟上位机，往单片机发送组合BCD码的被减数和减数。单片机把组合BCD码的运算结果返回到上位机。最大范围4位，从0到9999，如果被减数小于减数则返回EE EE EE报错。往单片机发送的数据格式：EB 00 55 XX XX 0d 0aYY YY0d 0a指令，其中EB 00 55是数据头，XX 是被减数，可以是1个字节，也可以是2个字节。YY是减数，可以是1个字节，也可以是2个字节。0d 0a是固定的结束标志。
例如：
（a）8259 – 5267 = 2992
上位机发送数据：eb 00 55 82 59 0d 0a52 67 0d 0a
单片机返回：29 92
（b）5267 - 8259=小于0所以报错
上位机发送数据：eb 00 5552 67 0d 0a82 59 0d 0a
单片机返回：EE EE EE表示出错了
（3）源代码讲解如下：
#include "REG52.H"
/* 注释一：
* 本系统中，规定最大运算位数是4位。
* 由于STC89C52单片机的RAM只有256个，也就是说系统的变量数最大
* 不能超过256个，如果超过了这个极限，编译器就会报错。如果这个算法
* 移植到stm32或者PIC等RAM比较大的单片机上，那么就可以把这个运算位数
* 设置得更加大一点。
*/
#defineBCD4_MAX 2//本系统中，规定的组合BCD码最大字节数，一个字节包含2位，因此4位有效运算数
#defineBCD8_MAX (BCD4_MAX*2)//本系统中，规定的非组合BCD码最大字节数，一个字节包含1位，因此4位有效运算数
#define const_rc_size30//接收串口中断数据的缓冲区数组大小
#define const_receive_time5//如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完，这个时间根据实际情况来调整大小
#define uchar unsigned char //方便移植平台
#define ulong unsigned long //方便移植平台
//如果在VC的平台模拟此算法，则都定义成int类型，如下：
//#define uchar int
//#define ulong int
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 BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4,unsigned char ucBCD4_cnt,unsigned char *p_ucBCD_bit8,unsigned char *p_ucBCD8_cnt);
void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8,unsigned char ucBCD8_cnt,unsigned char *p_ucBCD_bit4,unsigned char *p_ucBCD4_cnt);
void ClearAllData(uchar ucARRAY_MAX,uchar *destData);
uchar GetDataLength(const uchar *destData,uchar ucARRAY_MAX);
uchar CmpData(const uchar *destData,const uchar *sourceData); //比较两个数的大小
uchar SubData(const uchar *destData,const uchar *sourceData,uchar *resultData);//两个数相减
sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
unsigned intuiSendCnt=0; //用来识别串口是否接收完一串数据的计时器
unsigned char ucSendLock=1; //串口服务程序的自锁变量，每次接收完一串数据只处理一次
unsigned intuiRcregTotal=0;//代表当前缓冲区已经接收了多少个数据
unsigned char ucRcregBuf; //接收串口中断数据的缓冲区数组
unsigned intuiRcMoveIndex=0;//用来解析数据协议的中间变量
unsigned char ucDataBCD4_1; //接收到的第1个数组合BCD码数组形式这里是指被减数
unsigned char ucDataBCD4_cnt_1=0;//接收到的第1个数组合BCD码数组的有效数据长度
unsigned char ucDataBCD4_2; //接收到的第2个数组合BCD码数组形式这里是指减数
unsigned char ucDataBCD4_cnt_2=0;//接收到的第2个数组合BCD码数组的有效数据长度
unsigned char ucDataBCD4_3; //接收到的第3个数组合BCD码数组形式这里是指差
unsigned char ucDataBCD4_cnt_3=0;//接收到的第3个数组合BCD码数组的有效数据长度
unsigned char ucDataBCD8_1; //接收到的第1个数非组合BCD码数组形式 这里是指被减数
unsigned char ucDataBCD8_cnt_1=0;//接收到的第1个数非组合BCD码数组的有效数据长度
unsigned char ucDataBCD8_2; //接收到的第2个数非组合BCD码数组形式 这里是指减数
unsigned char ucDataBCD8_cnt_2=0;//接收到的第2个数非组合BCD码数组的有效数据长度
unsigned char ucDataBCD8_3; //接收到的第3个数非组合BCD码数组形式 这里是指差
unsigned char ucDataBCD8_cnt_3=0;//接收到的第3个数非组合BCD码数组的有效数据长度
unsigned char ucResultFlag=11; //运算结果标志，10代表计算结果超出范围出错，11代表正常。
void main()
{
initial_myself();
delay_long(100);
initial_peripheral();
while(1)
{
usart_service();//串口服务程序
}
}
/* 注释二：
* 组合BCD码转成非组合BCD码。
* 这里的变量ucBCD4_cnt代表组合BCD码的有效字节数.
* 这里的变量*p_ucBCD8_cnt代表经过转换后，非组合BCD码的有效字节数，记得加地址符号&传址进去
* 本程序在上一节的基础上，略作修改，用循环for语句压缩了代码，
* 同时引进了组合BCD码的有效字节数变量。这样就不限定了数据的长度，
* 可以让我们根据数据的实际大小灵活运用。
*/
void BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4,unsigned char ucBCD4_cnt,unsigned char *p_ucBCD_bit8,unsigned char *p_ucBCD8_cnt)
{
unsigned char ucTmep;
unsigned char i;
for(i=0;i<BCD8_MAX;i++) //先把即将保存转换结果的缓冲区清零
{
p_ucBCD_bit8=0;
}
*p_ucBCD8_cnt=ucBCD4_cnt*2; //转换成非组合BCD码后的有效数据长度
for(i=0;i<ucBCD4_cnt;i++)
{
ucTmep=p_ucBCD_bit4;
p_ucBCD_bit8=ucTmep>>4;
p_ucBCD_bit8=ucTmep&0x0f;
}
}
/* 注释三：
* 非组合BCD码转成组合BCD码。
* 这里的变量ucBCD8_cnt代表非组合BCD码的有效字节数.
* 这里的变量*p_ucBCD4_cnt代表经过转换后，组合BCD码的有效字节数，记得加地址符号&传址进去
* 本程序在上一节的基础上，略作修改，用循环for语句压缩了代码，
* 同时引进了非组合BCD码的有效字节数变量。这样就不限定了数据的长度，
* 可以让我们根据数据的实际大小灵活运用。
*/
void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8,unsigned char ucBCD8_cnt,unsigned char *p_ucBCD_bit4,unsigned char *p_ucBCD4_cnt)
{
unsigned char ucTmep;
unsigned char i;
unsigned char ucBCD4_cnt;
for(i=0;i<BCD4_MAX;i++) //先把即将保存转换结果的缓冲区清零
{
p_ucBCD_bit4=0;
}
ucBCD4_cnt=(ucBCD8_cnt+1)/2; //非组合BCD码转化成组合BCD码的有效数,这里+1避免非组合数据长度是奇数位
*p_ucBCD4_cnt=ucBCD4_cnt; //把转换后的结果付给接口指针的数据，可以对外输出结果
for(i=0;i<ucBCD4_cnt;i++)
{
ucTmep=p_ucBCD_bit8; //把非组合BCD码第8位分解出来
p_ucBCD_bit4=ucTmep<<4;
p_ucBCD_bit4=p_ucBCD_bit4+p_ucBCD_bit8; //把非组合BCD码第7位分解出来
}
}
/* 注释四：
*函数介绍：清零数组的全部数组数据
*输入参数：ucARRAY_MAX代表数组定义的最大长度
*输入输出参数：*destData--被清零的数组。
*/
void ClearAllData(uchar ucARRAY_MAX,uchar *destData)
{
uchar i;
for(i=0;i<ucARRAY_MAX;i++)
{
destData=0;
}
}
/* 注释五：
*函数介绍：获取数组的有效长度
*输入参数：*destData--被获取的数组。
*输入参数：ucARRAY_MAX代表数组定义的最大长度
*返回值：返回数组的有效长度。比如58786这个数据的有效长度是5
*电子开发者作者：吴坚鸿
*/
uchar GetDataLength(const uchar *destData,uchar ucARRAY_MAX)
{
uchar i;
uchar DataLength=ucARRAY_MAX;
for(i=0;i<ucARRAY_MAX;i++)
{
if(0!=destData)
{
break;
}
else
{
DataLength--;
}
}
return DataLength;
}
/* 注释六：
*函数介绍：比较两个数的大小
*输入参数：
*（1）*destData--被比较数的数组。
*（2）*sourceData--比较数的数组。
*返回值：9代表小于，10代表相等，11代表大于。
*/
uchar CmpData(const uchar *destData,const uchar *sourceData)
{
uchar cmpResult=10; //开始默认相等
uchar destCnt=0;
uchar sourceCnt=0;
uchar i;
destCnt=GetDataLength(destData,BCD8_MAX);
sourceCnt=GetDataLength(sourceData,BCD8_MAX);
if(destCnt>sourceCnt)//大于
{
cmpResult=11;
}
else if(destCnt<sourceCnt) //小于
{
cmpResult=9;
}
else if((destCnt==0)&&(sourceCnt==0))//如果都是等于0则等于
{
cmpResult=10;
}
else//否则就要继续判断
{
for(i=0;i<destCnt;i++)
{
if(destData>sourceData) //从最高位开始判断,如果最高位大于则大于
{
cmpResult=11;
break;
}
else if(destData<sourceData)//从最高位开始判断,如果最高位小于则小于
{
cmpResult=9;
break;
}
//否则继续判断下一位
}
}
return cmpResult;
}
/* 注释七：
*函数介绍：两个数相减
*输入参数：
*（1）*destData--被减数的数组。
*（2）*sourceData--减数的数组。
*（3）*resultData--差的数组。注意，调用本函数前，必须先把这个数组清零
*返回值：10代表计算结果是负数或者超出范围出错，11代表正常。
*/
uchar SubData(const uchar *destData,const uchar *sourceData,uchar *resultData)
{
uchar subResult=11; //开始默认正常
uchar destCnt=0;
uchar i;
uchar carryData=0;//进位
uchar maxCnt=0; //最大位数
uchar resultTemp=0; //存放临时运算结果的中间变量
//为什么不在本函数内先把resultData数组清零？因为后面章节中的除法运算中要用到此函数实现连减功能。
//因此如果纯粹实现减法运算时，在调用本函数之前，必须先在外面把差的数组清零，否则会计算出错。
if(CmpData(destData,sourceData)==9)//被减数小于减数，报错
{
subResult=10;
return subResult;//返回判断结果，并且退出本程序，不往下执行本程序余下代码
}
destCnt=GetDataLength(destData,BCD8_MAX);//获取被减数的有效数据长度
maxCnt=destCnt;
for(i=0;i<maxCnt;i++)
{
resultTemp=sourceData+carryData; //按位相加
if(resultTemp>destData)
{
resultData=destData+10-sourceData-carryData; //借位
carryData=1;
}
else
{
resultData=destData-sourceData-carryData; //不用借位
carryData=0;
}
}
return subResult;
}
void usart_service(void)//串口服务程序,在main函数里
{
unsigned char i=0;
unsigned char k=0;
unsigned char ucGetDataStep=0;
if(uiSendCnt>=const_receive_time&&ucSendLock==1) //说明超过了一定的时间内，再也没有新数据从串口来
{
ucSendLock=0; //处理一次就锁起来，不用每次都进来,除非有新接收的数据
//下面的代码进入数据协议解析和数据处理的阶段
uiRcMoveIndex=0; //由于是判断数据头，所以下标移动变量从数组的0开始向最尾端移动
while(uiRcMoveIndex<uiRcregTotal)//说明还没有把缓冲区的数据读取完
{
if(ucRcregBuf==0xeb&&ucRcregBuf==0x00&&ucRcregBuf==0x55)//数据头eb 00 55的判断
{
i=0;
ucGetDataStep=0;
ucDataBCD4_cnt_1=0;//第1个数组合BCD码数组的有效数据长度
ucDataBCD4_cnt_2=0;//第2个数组合BCD码数组的有效数据长度
ClearAllData(BCD4_MAX,ucDataBCD4_1);//清零第1个参与运算的数据
ClearAllData(BCD4_MAX,ucDataBCD4_2);//清零第2个参与运算的数据
//以下while循环是通过关键字0x0d 0x0a来截取第1个和第2个参与运算的数据。
while(i<(BCD8_MAX+4))//这里+4是因为有2对0x0d 0x0a结尾特殊符号，一个共4个字节
{
if(ucGetDataStep==0)//步骤0，相当于我平时用的case 0,获取第1个数，在这里是指被加数
{
if(ucRcregBuf==0x0d&&ucRcregBuf==0x0a) //结束标志
{
for(k=0;k<ucDataBCD4_cnt_1;k++) //提取第1个参与运算的数组数据
{
ucDataBCD4_1=ucRcregBuf; //注意，接收到的数组数据与实际存储的数组数据的下标方向是相反的
}
i=i+2; //跳过 0x0d 0x0a 这两个字节，进行下一轮的关键字提取
ucGetDataStep=1;//切换到下一个关键字提取的步骤
}
else
{
i++;
ucDataBCD4_cnt_1++;//统计第1个有效数据的长度
}
}
else if(ucGetDataStep==1) //步骤1，相当于我平时用的case 1,获取第2个参与运行的数，在这里是加数
{
if(ucRcregBuf==0x0d&&ucRcregBuf==0x0a) //结束标志
{
for(k=0;k<ucDataBCD4_cnt_2;k++) //提取第2个参与运算的数组数据
{
ucDataBCD4_2=ucRcregBuf; //注意，接收到的数组数据与实际存储的数组数据的下标方向是相反的
}
break; //截取数据完成。直接跳出截取数据的while(i<(BCD8_MAX+4))循环
}
else
{
i++;
ucDataBCD4_cnt_2++;//统计第2个有效数据的长度
}
}
}
//注意ucDataBCD8_cnt_1和ucDataBCD8_cnt_2要带地址符号&传址进去
BCD4_to_BCD8(ucDataBCD4_1,ucDataBCD4_cnt_1,ucDataBCD8_1,&ucDataBCD8_cnt_1); //把接收到的组合BCD码转换成非组合BCD码第1个数
BCD4_to_BCD8(ucDataBCD4_2,ucDataBCD4_cnt_2,ucDataBCD8_2,&ucDataBCD8_cnt_2); //把接收到的组合BCD码转换成非组合BCD码第2个数
ClearAllData(BCD8_MAX,ucDataBCD8_3);//清零第3个参与运算的数据,用来接收运行的结果
ucResultFlag=SubData(ucDataBCD8_1,ucDataBCD8_2,ucDataBCD8_3); //相减运算，结果放在ucDataBCD8_3数组里
if(ucResultFlag==11) //表示运算结果没有超范围
{
ucDataBCD8_cnt_3=GetDataLength(ucDataBCD8_3,BCD8_MAX);//获取运算结果的有效字节数
BCD8_to_BCD4(ucDataBCD8_3,ucDataBCD8_cnt_3,ucDataBCD4_3,&ucDataBCD4_cnt_3); //把非组合BCD码转成组合BCD码。注意，&ucDataBCD4_cnt_3带地址符号&
for(k=0;k<ucDataBCD4_cnt_3;k++) //返回运算结果到上位机上观察。看到的是组合BCD码形式。返回的时候注意数组下标的顺序要反过来发送，先发高位的下标数组
{
eusart_send(ucDataBCD4_3); //往上位机发送一个字节的函数
}
}
else //运算结果超范围，返回EE EE EE
{
eusart_send(0xee); //往上位机发送一个字节的函数
eusart_send(0xee); //往上位机发送一个字节的函数
eusart_send(0xee); //往上位机发送一个字节的函数
}
break; //退出循环
}
uiRcMoveIndex++; //因为是判断数据头，游标向着数组最尾端的方向移动
}
ucRcregBuf=0; //把数据头清零，方便下次接收判断新数据
ucRcregBuf=0;
ucRcregBuf=0;
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=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; //启动定时中断
}
总结陈词：
既然这节讲了减法程序，那么下一节接着讲常用的乘法程序，这种大数据的乘法程序是什么样的？欲知详情，请听下回分解----大数据的乘法运算。
（未完待续，下节更精彩，不要走开哦）
本帖最后由 又一个暑假 于 2014-8-21 10:37 编辑
jianhong_wu 发表于 2014-4-7 13:14
第四十节：常用的自定义串口通讯协议。
开场白：上一节讲了判断数据头的程序框架，但是在很多项目中，仅仅 ...
“其中第5,6位HH就是有效数据长度。高位在左，低位在右。“这句话没理解，鸿哥麻烦解释一下。“Led灯短亮发送：eb 00 55 02 00 02 00 28 6c”这里的“00 02”表示由“00 28”组成一个数据“0x0028”这样理解对吗
又一个暑假 发表于 2014-8-21 10:29
“其中第5,6位HH就是有效数据长度。高位在左，低位在右。“这句话没理解，鸿哥麻烦解释一下
表示有两个字节合成的int型数据，左边的是高位，右边的是低位。比如十六进制的两个字节 A29C ，相当于十六进制的int型数据0xA29C，十进制的41628
jianhong_wu 发表于 2014-8-21 10:39
表示有两个字节合成的int型数据，左边的是高位，右边的是低位。比如十六进制的两个字节 A29C ，相当于 ...
鸿哥用了2个字节来表示数据长度，那么有效数据“XXXXX。。。。YYYYY”可以达到65535个字节对吧
本帖最后由 又一个暑假 于 2014-8-21 11:57 编辑
jianhong_wu 发表于 2014-4-7 13:14
第四十节：常用的自定义串口通讯协议。
开场白：上一节讲了判断数据头的程序框架，但是在很多项目中，仅仅 ...
ucRcregBuf=0;//清零最后一个字节的累加和变量 这里都清零了
for(i=0;i<(3+1+2+uiRcSize);i++) //计算校验累加和
{
ucRcregBuf=ucRcregBuf+ucRcregBuf;//这里为什么ucRcregBuf不加为什么不行
}
又一个暑假 发表于 2014-8-21 10:59
鸿哥用了2个字节来表示数据长度，那么有效数据“XXXXX。。。。YYYYY”可以达到65535个字节对吧
是的，理论上是可以达到65535个字节，实际上我们的接收缓冲区没有定时那么大的接收数组。
本帖最后由 jianhong_wu 于 2014-8-21 13:42 编辑
又一个暑假 发表于 2014-8-21 11:55
ucRcregBuf=0;//清零最后一个字节的累加和变量 这里都清零了
for(i=0;i
它是一个累加和变量，前面已经清零了一次，后面当然不用清零了。比如：
sum=0; //清零一次
for(i=0;i<50;i++)
{
sum=sum+a;
}
这里的sum就是累加和。
jianhong_wu 发表于 2014-8-21 13:40
它是一个累加和变量，前面已经清零了一次，后面当然不用清零了。比如：
噢，看花眼了。问了如此低级的问题:funk:
鸿哥什么时候发一次鸿哥版的模块化编程呀
看花开花落 发表于 2014-8-21 20:53
鸿哥什么时候发一次鸿哥版的模块化编程呀
再过五节左右就会讲到多文件编程的。
jianhong_wu 发表于 2014-8-19 16:19
第六十三节：大数据的减法运算。
开场白：
鸿哥辛苦了，又更新了我刚看到三十三节 不知啥时候才能赶上来！
第六十四节：大数据的乘法运算。
开场白：
直接用C语言的“*”运算符进行乘法运算时，“被乘数”，“ 乘数”，“积”，这三个数据的最大范围是unsigned long 类型，也就是数据最大范围是4个字节，十进制的范围是0至4294967295。一旦超过了这个范围，则运算会出错。因此，当进行大数据乘法运算时，我们要额外编程序，实现大数据的算法。其实这种算法并不难，就是我们在小学里学的四则运算算法。
我们先要弄清楚一个新的概念。不考虑小数点的情况下，数据有两种表现形式。一种是常用的变量形式，另外一种是BCD码数组形式。变量的最大范围有限，而BCD码数组的形式是无限的，正因为这个特点，所以我们可以进行大数据运算。
这一节要教大家一个知识点：
第一个：如何编写涉及到大数据乘法运算的算法程序函数，同时也复习了指针的用途。
具体内容，请看源代码讲解。
（1）硬件平台：
基于坚鸿51单片机学习板。
（2）实现功能：
波特率是：9600 。
通过电脑串口调试助手模拟上位机，往单片机发送组合BCD码的被乘数和乘数，单片机把组合BCD码的运算结果返回到上位机。被乘数与乘数的最大范围都是从0到99，如果运算的乘积超过允许保存的最大位数范围则返回EE EE EE报错。
往单片机发送的数据格式：EB 00 55 XX0d0aYY0d0a指令，其中EB 00 55是数据头，XX 是被乘数，是1个字节的组合BCD码。YY是乘数，可以是1个字节的组合BCD码。0d 0a是固定的结束标志。
例如：
（a）83 x 98 = 8134
上位机发送数据：eb 00 55 83 0d 0a 98 0d 0a
单片机返回：81 34
（3）源代码讲解如下：
#include "REG52.H"
/* 注释一：
* 本系统中的乘法运算，规定两个乘数的最大范围是0至99.
* 由于STC89C52单片机的RAM只有256个，也就是说系统的变量数最大
* 不能超过256个，如果超过了这个极限，编译器就会报错。由于51单片机RAM资源有限，
* 因此规定乘数的最大范围不能超过99，如果这个算法移植到stm32或者PIC等RAM比较大
* 的单片机上，那么就可以把这个运算位数设置得更加大一点。调整下面 BCD4_MAX的大小，
* 可以调整运算的数据范围。
*/
#defineBCD4_MAX 3//为了让乘法的结果不超过范围，因此把组合BCD码最大字节数从上一节的2改成3，一个字节包含2位，因此可以保存6位有效数
#defineBCD8_MAX (BCD4_MAX*2)//本系统中，规定的非组合BCD码能保存的最大字节数，一个字节包含1位，因此能保存6位有效运算数
#define const_rc_size30//接收串口中断数据的缓冲区数组大小
#define const_receive_time5//如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完，这个时间根据实际情况来调整大小
#define uchar unsigned char //方便移植平台
#define ulong unsigned long //方便移植平台
//如果在VC的平台模拟此算法，则都定义成int类型，如下：
//#define uchar int
//#define ulong int
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 BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4,unsigned char ucBCD4_cnt,unsigned char *p_ucBCD_bit8,unsigned char *p_ucBCD8_cnt);
void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8,unsigned char ucBCD8_cnt,unsigned char *p_ucBCD_bit4,unsigned char *p_ucBCD4_cnt);
void ClearAllData(uchar ucARRAY_MAX,uchar *destData);
uchar GetDataLength(const uchar *destData,uchar ucARRAY_MAX);
uchar AddData(const uchar *destData,const uchar *sourceData,uchar *resultData);//两个数相加
void EnlargeData(uchar *destData,uchar enlarge_cnt); //数组向大索引值移位，移一位相当于放大10倍
uchar MultData(const uchar *destData,const uchar *sourceData,uchar *resultData); //两个数相乘
sbit beep_dr=P2^7; //蜂鸣器的驱动IO口
unsigned intuiSendCnt=0; //用来识别串口是否接收完一串数据的计时器
unsigned char ucSendLock=1; //串口服务程序的自锁变量，每次接收完一串数据只处理一次
unsigned intuiRcregTotal=0;//代表当前缓冲区已经接收了多少个数据
unsigned char ucRcregBuf; //接收串口中断数据的缓冲区数组
unsigned intuiRcMoveIndex=0;//用来解析数据协议的中间变量
unsigned char ucDataBCD4_1; //接收到的第1个数组合BCD码数组形式这里是指被乘数
unsigned char ucDataBCD4_cnt_1=0;//接收到的第1个数组合BCD码数组的有效数据长度
unsigned char ucDataBCD4_2; //接收到的第2个数组合BCD码数组形式这里是指乘数
unsigned char ucDataBCD4_cnt_2=0;//接收到的第2个数组合BCD码数组的有效数据长度
unsigned char ucDataBCD4_3; //接收到的第3个数组合BCD码数组形式这里是指积
unsigned char ucDataBCD4_cnt_3=0;//接收到的第3个数组合BCD码数组的有效数据长度
unsigned char ucDataBCD8_1; //接收到的第1个数非组合BCD码数组形式 这里是指被乘数
unsigned char ucDataBCD8_cnt_1=0;//接收到的第1个数非组合BCD码数组的有效数据长度
unsigned char ucDataBCD8_2; //接收到的第2个数非组合BCD码数组形式 这里是指乘数
unsigned char ucDataBCD8_cnt_2=0;//接收到的第2个数非组合BCD码数组的有效数据长度
unsigned char ucDataBCD8_3; //接收到的第3个数非组合BCD码数组形式 这里是指积
unsigned char ucDataBCD8_cnt_3=0;//接收到的第3个数非组合BCD码数组的有效数据长度
unsigned char ucResultFlag=11; //运算结果标志，10代表计算结果超出范围出错，11代表正常。
void main()
{
initial_myself();
delay_long(100);
initial_peripheral();
while(1)
{
usart_service();//串口服务程序
}
}
/* 注释二：
* 组合BCD码转成非组合BCD码。
* 这里的变量ucBCD4_cnt代表组合BCD码的有效字节数.
* 这里的变量*p_ucBCD8_cnt代表经过转换后，非组合BCD码的有效字节数，记得加地址符号&传址进去
* 本程序在上一节的基础上，略作修改，用循环for语句压缩了代码，
* 同时引进了组合BCD码的有效字节数变量。这样就不限定了数据的长度，
* 可以让我们根据数据的实际大小灵活运用。
*/
void BCD4_to_BCD8(const unsigned char *p_ucBCD_bit4,unsigned char ucBCD4_cnt,unsigned char *p_ucBCD_bit8,unsigned char *p_ucBCD8_cnt)
{
unsigned char ucTmep;
unsigned char i;
for(i=0;i<BCD8_MAX;i++) //先把即将保存转换结果的缓冲区清零
{
p_ucBCD_bit8=0;
}
*p_ucBCD8_cnt=ucBCD4_cnt*2; //转换成非组合BCD码后的有效数据长度
for(i=0;i<ucBCD4_cnt;i++)
{
ucTmep=p_ucBCD_bit4;
p_ucBCD_bit8=ucTmep>>4;
p_ucBCD_bit8=ucTmep&0x0f;
}
}
/* 注释三：
* 非组合BCD码转成组合BCD码。
* 这里的变量ucBCD8_cnt代表非组合BCD码的有效字节数.
* 这里的变量*p_ucBCD4_cnt代表经过转换后，组合BCD码的有效字节数，记得加地址符号&传址进去
* 本程序在上一节的基础上，略作修改，用循环for语句压缩了代码，
* 同时引进了非组合BCD码的有效字节数变量。这样就不限定了数据的长度，
* 可以让我们根据数据的实际大小灵活运用。
*/
void BCD8_to_BCD4(const unsigned char *p_ucBCD_bit8,unsigned char ucBCD8_cnt,unsigned char *p_ucBCD_bit4,unsigned char *p_ucBCD4_cnt)
{
unsigned char ucTmep;
unsigned char i;
unsigned char ucBCD4_cnt;
for(i=0;i<BCD4_MAX;i++) //先把即将保存转换结果的缓冲区清零
{
p_ucBCD_bit4=0;
}
ucBCD4_cnt=(ucBCD8_cnt+1)/2; //非组合BCD码转化成组合BCD码的有效数,这里+1避免非组合数据长度是奇数位
*p_ucBCD4_cnt=ucBCD4_cnt; //把转换后的结果付给接口指针的数据，可以对外输出结果
for(i=0;i<ucBCD4_cnt;i++)
{
ucTmep=p_ucBCD_bit8; //把非组合BCD码第8位分解出来
p_ucBCD_bit4=ucTmep<<4;
p_ucBCD_bit4=p_ucBCD_bit4+p_ucBCD_bit8; //把非组合BCD码第7位分解出来
}
}
/* 注释四：
*函数介绍：清零数组的全部数组数据
*输入参数：ucARRAY_MAX代表数组定义的最大长度
*输入输出参数：*destData--被清零的数组。
*/
void ClearAllData(uchar ucARRAY_MAX,uchar *destData)
{
uchar i;
for(i=0;i<ucARRAY_MAX;i++)
{
destData=0;
}
}
/* 注释五：
*函数介绍：获取数组的有效长度
*输入参数：*destData--被获取的数组。
*输入参数：ucARRAY_MAX代表数组定义的最大长度
*返回值：返回数组的有效长度。比如58786这个数据的有效长度是5
*电子开发者作者：吴坚鸿
*/
uchar GetDataLength(const uchar *destData,uchar ucARRAY_MAX)
{
uchar i;
uchar DataLength=ucARRAY_MAX;
for(i=0;i<ucARRAY_MAX;i++)
{
if(0!=destData)
{
break;
}
else
{
DataLength--;
}
}
return DataLength;
}
/* 注释六：
*函数介绍：两个数相加
*输入参数：
*（1）*destData--被加数的数组。
*（2）*sourceData--加数的数组。
*（3）*resultData--和的数组。注意，调用本函数前，必须先把这个数组清零
*返回值：10代表计算结果超出范围出错，11代表正常。
*/
uchar AddData(const uchar *destData,const uchar *sourceData,uchar *resultData)
{
uchar addResult=11; //开始默认返回的运算结果是正常
uchar destCnt=0;
uchar sourceCnt=0;
uchar i;
uchar carryData=0;//进位
uchar maxCnt=0; //最大位数
uchar resultTemp=0; //存放临时运算结果的中间变量
//为什么不在本函数内先把resultData数组清零？因为后面章节中的乘法运算中要用到此函数实现连加功能。
//因此如果纯粹实现加法运算时，在调用本函数之前，必须先在外面把和的数组清零，否则会计算出错。
destCnt=GetDataLength(destData,BCD8_MAX); //获取被加数的有效位数
sourceCnt=GetDataLength(sourceData,BCD8_MAX);//获取加数的有效位数
if(destCnt>=sourceCnt)//找出两个运算数据中最大的有效位数
{
maxCnt=destCnt;
}
else
{
maxCnt=sourceCnt;
}
for(i=0;i<maxCnt;i++)
{
resultTemp=destData+sourceData+carryData; //按位相加
resultData=resultTemp%10; //截取最低位存放进保存结果的数组
carryData=resultTemp/10; //存放进位
}
resultData=carryData;
if((maxCnt==BCD8_MAX)&&(carryData==1))//如果数组的有效位是最大值并且最后的进位是1，则计算溢出报错
{
ClearAllData(BCD8_MAX,resultData);
addResult=10;//报错
}
return addResult;
}
/* 注释七：
*函数介绍：数组向大索引值移位，移一位相当于放大10倍
*输入参数：*destData--被移位的数组。
*输入参数：enlarge_cnt--被移位的个数。
*/
void EnlargeData(uchar *destData,uchar enlarge_cnt)
{
uchar i;
if(enlarge_cnt!=0)
{
for(i=0;i<(BCD8_MAX-enlarge_cnt);i++)
{
destData=destData;
}
for(i=0;i<enlarge_cnt;i++) //最低位被移空的补上0
{
destData=0;
}
}
}
/* 注释八：
*函数介绍：两个数相乘
*输入参数：
*（1）*destData--被乘数的数组。
*（2）*sourceData--乘数的数组。
*（3）*resultData--积的数组。
*返回值：10代表计算结果超出范围出错，11代表正常。
*/
uchar MultData(const uchar *destData,const uchar *sourceData,uchar *resultData)
{
uchar multResult=11; //开始默认正常
uchar destCnt=0;
uchar sourceCnt=0;
uchar i;
uchar j;
uchar carryData=0;//进位
uchar resultTemp=0; //存放临时运算结果的中间变量
uchar nc_add_result;//接收相加的运算是否超出范围，这里不用判断，因为不会溢出
uchar multArrayTemp; //存放临时运算结果的数组中间变量
destCnt=GetDataLength(destData,BCD8_MAX); //获取被乘数的长度
sourceCnt=GetDataLength(sourceData,BCD8_MAX); //获取乘数的长度
ClearAllData(BCD8_MAX,resultData); //清零存储的结果
if((0==destCnt)||(0==sourceCnt)) //被乘数或者乘数为0，则结果为0
{
return multResult;
}
if((destCnt+sourceCnt+2)>BCD8_MAX)
{
multResult=10; //运算结果有可能超范围报错
return multResult;
}
for(i=0;i<sourceCnt;i++)//乘数
{
carryData=0; //清零进位
ClearAllData(BCD8_MAX,multArrayTemp); //清零一位乘数相乘的结果中间变量数组
for(j=0;j<destCnt;j++) //被乘数
{
resultTemp=destData*sourceData+carryData;//乘数的一位依次与被乘数各位相乘,并且加进位
multArrayTemp=resultTemp%10;//存储一位乘数相乘的结果
carryData=resultTemp/10; //保存进位
}
multArrayTemp=carryData; //存储最后的进位
EnlargeData(multArrayTemp,i); //移位。移一次相当于放大10倍。
nc_add_result=AddData(resultData,multArrayTemp,resultData); //把一位乘数相乘的结果存储进总结果
}
return multResult;
}
void usart_service(void)//串口服务程序,在main函数里
{
unsigned char i=0;
unsigned char k=0;
unsigned char ucGetDataStep=0;
if(uiSendCnt>=const_receive_time&&ucSendLock==1) //说明超过了一定的时间内，再也没有新数据从串口来
{
ucSendLock=0; //处理一次就锁起来，不用每次都进来,除非有新接收的数据
//下面的代码进入数据协议解析和数据处理的阶段
uiRcMoveIndex=0; //由于是判断数据头，所以下标移动变量从数组的0开始向最尾端移动
while(uiRcMoveIndex<uiRcregTotal)//说明还没有把缓冲区的数据读取完
{
if(ucRcregBuf==0xeb&&ucRcregBuf==0x00&&ucRcregBuf==0x55)//数据头eb 00 55的判断
{
i=0;
ucGetDataStep=0;
ucDataBCD4_cnt_1=0;//第1个数组合BCD码数组的有效数据长度
ucDataBCD4_cnt_2=0;//第2个数组合BCD码数组的有效数据长度
ClearAllData(BCD4_MAX,ucDataBCD4_1);//清零第1个参与运算的数据
ClearAllData(BCD4_MAX,ucDataBCD4_2);//清零第2个参与运算的数据
//以下while循环是通过关键字0x0d 0x0a来截取第1个和第2个参与运算的数据。
while(i<(BCD8_MAX+4))//这里+4是因为有2对0x0d 0x0a结尾特殊符号，一个共4个字节
{
if(ucGetDataStep==0)//步骤0，相当于我平时用的case 0,获取第1个数，在这里是指被乘数
{
if(ucRcregBuf==0x0d&&ucRcregBuf==0x0a) //结束标志
{
for(k=0;k<ucDataBCD4_cnt_1;k++) //提取第1个参与运算的数组数据
{
ucDataBCD4_1=ucRcregBuf; //注意，接收到的数组数据与实际存储的数组数据的下标方向是相反的
}
i=i+2; //跳过 0x0d 0x0a 这两个字节，进行下一轮的关键字提取
ucGetDataStep=1;//切换到下一个关键字提取的步骤
}
else
{
i++;
ucDataBCD4_cnt_1++;//统计第1个有效数据的长度
}
}
else if(ucGetDataStep==1) //步骤1，相当于我平时用的case 1,获取第2个参与运行的数，在这里是乘数
{
if(ucRcregBuf==0x0d&&ucRcregBuf==0x0a) //结束标志
{
for(k=0;k<ucDataBCD4_cnt_2;k++) //提取第2个参与运算的数组数据
{
ucDataBCD4_2=ucRcregBuf; //注意，接收到的数组数据与实际存储的数组数据的下标方向是相反的
}
break; //截取数据完成。直接跳出截取数据的while(i<(BCD8_MAX+4))循环
}
else
{
i++;
ucDataBCD4_cnt_2++;//统计第2个有效数据的长度
}
}
}
//注意ucDataBCD8_cnt_1和ucDataBCD8_cnt_2要带地址符号&传址进去
BCD4_to_BCD8(ucDataBCD4_1,ucDataBCD4_cnt_1,ucDataBCD8_1,&ucDataBCD8_cnt_1); //把接收到的组合BCD码转换成非组合BCD码第1个数
BCD4_to_BCD8(ucDataBCD4_2,ucDataBCD4_cnt_2,ucDataBCD8_2,&ucDataBCD8_cnt_2); //把接收到的组合BCD码转换成非组合BCD码第2个数
ClearAllData(BCD8_MAX,ucDataBCD8_3);//清零第3个参与运算的数据,用来接收运行的结果
ucResultFlag=MultData(ucDataBCD8_1,ucDataBCD8_2,ucDataBCD8_3); //相乘运算，结果放在ucDataBCD8_3数组里
if(ucResultFlag==11) //表示运算结果没有超范围
{
ucDataBCD8_cnt_3=GetDataLength(ucDataBCD8_3,BCD8_MAX);//获取运算结果的有效字节数
if(ucDataBCD8_cnt_3==0) //如果1个有效位数都没有，表示数组所有的数据都是0，这个时候的有效位数应该人为的默认是1,表示一个0
{
ucDataBCD8_cnt_3=1;
}
BCD8_to_BCD4(ucDataBCD8_3,ucDataBCD8_cnt_3,ucDataBCD4_3,&ucDataBCD4_cnt_3); //把非组合BCD码转成组合BCD码。注意，&ucDataBCD4_cnt_3带地址符号&
for(k=0;k<ucDataBCD4_cnt_3;k++) //返回运算结果到上位机上观察。看到的是组合BCD码形式。返回的时候注意数组下标的顺序要反过来发送，先发高位的下标数组
{
eusart_send(ucDataBCD4_3); //往上位机发送一个字节的函数
}
}
else //运算结果超范围，返回EE EE EE
{
eusart_send(0xee); //往上位机发送一个字节的函数
eusart_send(0xee); //往上位机发送一个字节的函数
eusart_send(0xee); //往上位机发送一个字节的函数
}
break; //退出循环
}
uiRcMoveIndex++; //因为是判断数据头，游标向着数组最尾端的方向移动
}
ucRcregBuf=0; //把数据头清零，方便下次接收判断新数据
ucRcregBuf=0;
ucRcregBuf=0;
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=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; //启动定时中断
}
总结陈词：
既然这节讲了乘法程序，那么下一节接着讲常用的除法程序，这种大数据的除法程序是什么样的？欲知详情，请听下回分解----大数据的除法运算。
（未完待续，下节更精彩，不要走开哦）