第六十四节：大数据的乘法运算。
开场白：
直接用C语言的“*”运算符进行乘法运算时，“被乘数”，“ 乘数”，“积”，这三个数据的最大范围是unsigned long 类型，也就是数据最大范围是4个字节，十进制的范围是0至4294967295。一旦超过了这个范围，则运算会出错。因此，当进行大数据乘法运算时，我们要额外编程序，实现大数据的算法。其实这种算法并不难，就是我们在小学里学的四则运算算法。
我们先要弄清楚一个新的概念。不考虑小数点的情况下，数据有两种表现形式。一种是常用的变量形式，另外一种是BCD码数组形式。变量的最大范围有限，而BCD码数组的形式是无限的，正因为这个特点，所以我们可以进行大数据运算。
这一节要教大家一个知识点：
第一个：如何编写涉及到大数据乘法运算的算法程序函数，同时也复习了指针的用途。
具体内容，请看源代码讲解。
（1）硬件平台：
基于朱兆祺51单片机学习板。
（2）实现功能：
波特率是：9600 。
通过电脑串口调试助手模拟上位机，往单片机发送组合BCD码的被乘数和乘数，单片机把组合BCD码的运算结果返回到上位机。被乘数与乘数的最大范围都是从0到99，如果运算的乘积超过允许保存的最大位数范围则返回EE EE EE报错。
往单片机发送的数据格式：EB 00 55 XX 0d 0a YY 0d
0a指令，其中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的大小，
* 可以调整运算的数据范围。
*/
#define BCD4_MAX 3 //为了让乘法的结果不超过范围，因此把组合BCD码最大字节数从上一节的2改成3，一个字节包含2位，因此可以保存6位有效数
#define BCD8_MAX (BCD4_MAX*2) //本系统中，规定的非组合BCD码能保存的最大字节数，一个字节包含1位，因此能保存6位有效运算数
#define const_rc_size 30 //接收串口中断数据的缓冲区数组大小
#define const_receive_time 5 //如果超过这个时间没有串口数据过来，就认为一串数据已经全部接收完，这个时间根据实际情况来调整大小
#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 int uiSendCnt=0; //用来识别串口是否接收完一串数据的计时器
unsigned char ucSendLock=1; //串口服务程序的自锁变量，每次接收完一串数据只处理一次
unsigned int uiRcregTotal=0; //代表当前缓冲区已经接收了多少个数据
unsigned char ucRcregBuf[const_rc_size]; //接收串口中断数据的缓冲区数组
unsigned int uiRcMoveIndex=0; //用来解析数据协议的中间变量
unsigned char ucDataBCD4_1[BCD4_MAX]; //接收到的第1个数组合BCD码数组形式 这里是指被乘数
unsigned char ucDataBCD4_cnt_1=0; //接收到的第1个数组合BCD码数组的有效数据长度
unsigned char ucDataBCD4_2[BCD4_MAX]; //接收到的第2个数组合BCD码数组形式 这里是指乘数
unsigned char ucDataBCD4_cnt_2=0; //接收到的第2个数组合BCD码数组的有效数据长度
unsigned char ucDataBCD4_3[BCD4_MAX]; //接收到的第3个数组合BCD码数组形式 这里是指积
unsigned char ucDataBCD4_cnt_3=0; //接收到的第3个数组合BCD码数组的有效数据长度
unsigned char ucDataBCD8_1[BCD8_MAX]; //接收到的第1个数非组合BCD码数组形式 这里是指被乘数
unsigned char ucDataBCD8_cnt_1=0; //接收到的第1个数非组合BCD码数组的有效数据长度
unsigned char ucDataBCD8_2[BCD8_MAX]; //接收到的第2个数非组合BCD码数组形式 这里是指乘数
unsigned char ucDataBCD8_cnt_2=0; //接收到的第2个数非组合BCD码数组的有效数据长度
unsigned char ucDataBCD8_3[BCD8_MAX]; //接收到的第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[i]=0;
}
*p_ucBCD8_cnt=ucBCD4_cnt*2; //转换成非组合BCD码后的有效数据长度
for(i=0;i<ucBCD4_cnt;i++)
{
ucTmep=p_ucBCD_bit4[ucBCD4_cnt-1-i];
p_ucBCD_bit8[ucBCD4_cnt*2-i*2-1]=ucTmep>>4;
p_ucBCD_bit8[ucBCD4_cnt*2-i*2-2]=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[i]=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[ucBCD4_cnt*2-1-i*2]; //把非组合BCD码第8位分解出来
p_ucBCD_bit4[ucBCD4_cnt-1-i]=ucTmep<<4;
p_ucBCD_bit4[ucBCD4_cnt-1-i]=p_ucBCD_bit4[ucBCD4_cnt-1-i]+p_ucBCD_bit8[ucBCD4_cnt*2-2-i*2]; //把非组合BCD码第7位分解出来
}
}
/* 注释四：
*函数介绍：清零数组的全部数组数据
*输入参数：ucARRAY_MAX代表数组定义的最大长度
*输入输出参数：*destData--被清零的数组。
*/
void ClearAllData(uchar ucARRAY_MAX,uchar *destData)
{
uchar i;
for(i=0;i<ucARRAY_MAX;i++)
{
destData[i]=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[ucARRAY_MAX-1-i])
{
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[i]+sourceData[i]+carryData; //按位相加
resultData[i]=resultTemp%10; //截取最低位存放进保存结果的数组
carryData=resultTemp/10; //存放进位
}
resultData[i]=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[BCD8_MAX-1-i]=destData[BCD8_MAX-1-enlarge_cnt-i];
}
for(i=0;i<enlarge_cnt;i++) //最低位被移空的补上0
{
destData[i]=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[BCD8_MAX]; //存放临时运算结果的数组中间变量
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[j]*sourceData[i]+carryData; //乘数的一位依次与被乘数各位相乘,并且加进位
multArrayTemp[j]=resultTemp%10; //存储一位乘数相乘的结果
carryData=resultTemp/10; //保存进位
}
multArrayTemp[j]=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[uiRcMoveIndex+0]==0xeb&&ucRcregBuf[uiRcMoveIndex+1]==0x00&&ucRcregBuf[uiRcMoveIndex+2]==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[uiRcMoveIndex+3+i]==0x0d&&ucRcregBuf[uiRcMoveIndex+4+i]==0x0a) //结束标志
{
for(k=0;k<ucDataBCD4_cnt_1;k++) //提取第1个参与运算的数组数据
{
ucDataBCD4_1[k]=ucRcregBuf[uiRcMoveIndex+3+i-1-k]; //注意，接收到的数组数据与实际存储的数组数据的下标方向是相反的
}
i=i+2; //跳过 0x0d 0x0a 这两个字节，进行下一轮的关键字提取
ucGetDataStep=1; //切换到下一个关键字提取的步骤
}
else
{
i++;
ucDataBCD4_cnt_1++; //统计第1个有效数据的长度
}
}
else if(ucGetDataStep==1) //步骤1，相当于我平时用的case 1,获取第2个参与运行的数，在这里是乘数
{
if(ucRcregBuf[uiRcMoveIndex+3+i]==0x0d&&ucRcregBuf[uiRcMoveIndex+4+i]==0x0a) //结束标志
{
for(k=0;k<ucDataBCD4_cnt_2;k++) //提取第2个参与运算的数组数据
{
ucDataBCD4_2[k]=ucRcregBuf[uiRcMoveIndex+3+i-1-k]; //注意，接收到的数组数据与实际存储的数组数据的下标方向是相反的
}
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[ucDataBCD4_cnt_3-1-k]); //往上位机发送一个字节的函数
}
}
else //运算结果超范围，返回EE EE EE
{
eusart_send(0xee); //往上位机发送一个字节的函数
eusart_send(0xee); //往上位机发送一个字节的函数
eusart_send(0xee); //往上位机发送一个字节的函数
}
break; //退出循环
}
uiRcMoveIndex++; //因为是判断数据头，游标向着数组最尾端的方向移动
}
ucRcregBuf[0]=0; //把数据头清零，方便下次接收判断新数据
ucRcregBuf[1]=0;
ucRcregBuf[2]=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[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; //启动定时中断
}
总结陈词：
既然这节讲了乘法程序，那么下一节接着讲常用的除法程序，这种大数据的除法程序是什么样的？欲知详情，请听下回分解----大数据的除法运算。
（未完待续，下节更精彩，不要走开哦）
座前排了 
我要赚赏金
STM32
MCU
通讯及无线技术
物联网技术
电子DIY
板卡试用
基础知识
软件与操作系统
我爱生活
小e食堂
