第65节：大数据的除法运算

开场白：
直接用C言语的“/”运算符进行除法运算时，“被除数”，“ 除数”，“商”，这三个数据的最大规模是unsigned long 类型，也便是数据最大规模是4个字节，十进制的规模是0至4294967295。一旦超越了这个规模，则运算会犯错。因而，当进行大数据除法运算时，咱们要额定编程序，完结大数据的算法。其实这种算法并不难，便是咱们在小学里学的四则运算算法。
咱们先要弄清楚一个新的概念。不考虑小数点的情况下，数据有两种表现方式。一种是常用的变量方式，别的一种是BCD码数组方式。变量的最大规模有限，而BCD码数组的方式是无限的，正由于这个特色，所以咱们能够进行大数据运算。
这一节要教咱们一个知识点：
榜首个：怎么编写涉及到大数据除法运算的算法程序函数，一起也温习了指针的用处。

详细内容，请看源代码解说。

（1）硬件渠道：
依据朱兆祺51单片机学习板。

（2）完结功用：
波特率是：9600 。
经过电脑串口调试帮手模仿上位机，往单片机发送组合BCD码的被除数和除数，单片机把组合BCD码的运算成果回来到上位机。被除数与除数的最大规模都是从0到9999，假如运算的商超越答应保存的最大位数规模或许除数为0，则回来EE EE EE报错。
往单片机发送的数据格式：EB 00 55 XX XX 0d0aYY YY 0d0a指令，其间EB 00 55是数据头，XX XX是被除数，是1到2个字节的组合BCD码。YY YY是除数，是1到2个字节的组合BCD码。0d 0a是固定的结束标志。
例如：
（a）9816 ÷ 8= 1227
上位机发送数据：eb 00 55 98 16 0d 0a 08 0d 0a
单片机回来：12 27
（b）9816 ÷ 0= 犯错了，除数不能为0。
上位机发送数据：eb 00 55 98 16 0d 0a 00 0d 0a
单片机回来：EE EE EE

（3）源代码解说如下：

#include “REG52.H”
/* 注释一：
* 本体系中的除法运算，规则被除数和除数的最大规模是0至9999.
* 由于STC89C52单片机的RAM只需256个，也便是说体系的变量数最大
* 不能超越256个，假如超越了这个极限，编译器就会报错。由于51单片机RAM资源有限，
* 因而规则除数的最大规模不能超越9999，假如这个算法移植到stm32或许PIC等RAM比较大
* 的单片机上，那么就能够把这个运算位数设置得愈加大一点。调整下面 BCD4_MAX的巨细，
* 能够调整运算的数据规模。
*/
#defineBCD4_MAX 3//调整BCD4_MAX的巨细，能够调整运算的数据规模。
#defineBCD8_MAX (BCD4_MAX*2)//本体系中，规则的非组合BCD码能保存的最大字节数，一个字节包括1位有用运管用
#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);//两个数相加
uchar CmpData(const uchar *destData,const uchar *sourceData); //比较两个数的巨细
uchar SubData(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); //两个数相乘
uchar DivLessTenData(const uchar *destData,const uchar *sourceData,uchar *resultData,uchar *remData);//部分两个数相除，商不超越10。当商为0时，余数等于被除数
uchar Div(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[const_rc_size]; //接纳串口中止数据的缓冲区数组
unsigned intuiRcMoveIndex=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
{
p_ucBCD_bit8[i]=0;
}
*p_ucBCD8_cnt=ucBCD4_cnt*2; //转化成非组合BCD码后的有用数据长度
for(i=0;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
{
p_ucBCD_bit4[i]=0;
}
ucBCD4_cnt=(ucBCD8_cnt+1)/2; //非组合BCD码转化成组合BCD码的有用数,这儿+1防止非组合数据长度是奇数位
*p_ucBCD4_cnt=ucBCD4_cnt; //把转化后的成果交给接口指针的数据，能够对外输出成果
for(i=0;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
{
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
{
if(0!=destData[ucARRAY_MAX-1-i])
{
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
{
cmpResult=9;
}
else if((destCnt==0)&&(sourceCnt==0))//假如都是等于0则等于
{
cmpResult=10;
}
else//不然就要持续判别
{
for(i=0;i
{
if(destData[destCnt-1-i]>sourceData[destCnt-1-i]) //从最高位开端判别,假如最高位大于则大于
{
cmpResult=11;
break;
}
else if(destData[destCnt-1-i]
{
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
{
resultTemp=sourceData[i]+carryData; //按位相加
if(resultTemp>destData[i])
{
resultData[i]=destData[i]+10-sourceData[i]-carryData; //借位
carryData=1;
}
else
{
resultData[i]=destData[i]-sourceData[i]-carryData; //不必借位
carryData=0;
}
}
return subResult;
}
/* 注释八：
*函数介绍：两个数相加
*输入参数：
*（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
{
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
{
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
{
carryData=0; //清零进位
ClearAllData(BCD8_MAX,multArrayTemp); //清零一位乘数相乘的成果中心变量数组
for(j=0;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;
}
/* 注释十一：
*函数介绍：部分两个数相除，商不超越10。当商为0时，余数是被除数
*原理精华：依据手艺除法的原理，咱们都是从高位开端借位相除，此刻是部分相除，因而商都不超越10，剩余的余数持续借位
*顺次除下去。这个程序的除法原理是挨个猜值，横竖商是从0，1,2.。。。9这10个数中的其间一个，为了快速找到咱们想要的那个商，我是
*使用中心规律进行寻觅，先猜是5，然后判别一下是大了仍是小了，假如是大了，就猜是3，假如小了就猜是7，最终肯定会找到商。
*输入参数：
*（1）*destData–被除数的数组。
*（2）*sourceData–除数的数组。
*（3）*resultData–商的数,不是数组，传址进去，是0,1,2到9中的某个数
*（4）*remData–余数的数组。
*回来值：10代表核算成果超出规模犯错，11代表正常。
*/
uchar DivLessTenData(const uchar *destData,const uchar *sourceData,uchar *resultData,uchar *remData)
{
uchar DivLessTenResult=11; //开端默许正常
uchar destCnt=0;
uchar sourceCnt=0;
uchar i;
uchar resultRunStep=5;
uchar cmpError=10;
uchar DivLessTenArrayTemp[BCD8_MAX]; //寄存暂时运算成果的数组中心变量
uchar DivLessTenArrayResult[BCD8_MAX]; //寄存暂时运算成果的数组中心变量的成果
uchar DivLessTenArrayBackup[BCD8_MAX]; //寄存暂时运算成果的数组中心变量的备份
uchar while_flag=0;//结束猜算的中心变量
uchar multError=11;
uchar subError=11;
destCnt=GetDataLength(destData,BCD8_MAX); //获取被除数的数据有用长度
sourceCnt=GetDataLength(sourceData,BCD8_MAX); //获取除数的数据有用长度
cmpError=CmpData(destData,sourceData); //比较被除数和除数的巨细
ClearAllData(BCD8_MAX,remData); //清空余数,余数为0
if(cmpError==9) //被除数比除数小
{
*resultData=0; //商肯定为0
for(i=0;i
{
remData[i]=destData[i]; //余数等于被除数
}
return DivLessTenResult;
}
else if(cmpError==10) //被除数与除数持平
{
*resultData=1; //商等于1余数为0
return DivLessTenResult;
}
else//开端猜值
{
resultRunStep=5;//先猜是5,从这儿开端直接看以下 case 5 的详细解说，其他case原理相同
while_flag=0;
while(1)
{
switch(resultRunStep)
{
case 1:
ClearAllData(BCD8_MAX,DivLessTenArrayTemp);
ClearAllData(BCD8_MAX,DivLessTenArrayResult);
DivLessTenArrayTemp[0]=resultRunStep;
multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);
subError=SubData(destData,DivLessTenArrayResult,remData);//求余数
*resultData=1; //商等于1
while_flag=1; //退出循环
break;
case 2:
ClearAllData(BCD8_MAX,DivLessTenArrayTemp);
ClearAllData(BCD8_MAX,DivLessTenArrayResult);
DivLessTenArrayTemp[0]=resultRunStep;
multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);
cmpError=CmpData(DivLessTenArrayResult,destData);
if(cmpError==10) //等于
{
*resultData=2; //商等于2余数为0
while_flag=1; //退出循环
}
else if(cmpError==11) //大于
{
resultRunStep=1;
}
else //小于
{
subError=SubData(destData,DivLessTenArrayResult,remData);//求余数
*resultData=2; //商等于2
while_flag=1; //退出循环
}
break;
case 3:
ClearAllData(BCD8_MAX,DivLessTenArrayTemp);
ClearAllData(BCD8_MAX,DivLessTenArrayResult);
DivLessTenArrayTemp[0]=resultRunStep;
multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);
cmpError=CmpData(DivLessTenArrayResult,destData);
if(cmpError==10) //等于
{
*resultData=3; //商等于3余数为0
while_flag=1; //退出循环
}
else if(cmpError==11) //大于
{
resultRunStep=2;
}
else //小于
{
resultRunStep=4;
ClearAllData(BCD8_MAX,DivLessTenArrayBackup);
for(i=0;i
{
DivLessTenArrayBackup[i]=DivLessTenArrayResult[i];
}
}
break;
case 4:
ClearAllData(BCD8_MAX,DivLessTenArrayTemp);
ClearAllData(BCD8_MAX,DivLessTenArrayResult);
DivLessTenArrayTemp[0]=resultRunStep;
multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);
cmpError=CmpData(DivLessTenArrayResult,destData);
if(cmpError==10) //等于
{
*resultData=4; //商等于4余数为0
while_flag=1; //退出循环
}
else if(cmpError==11) //大于
{
subError=SubData(destData,DivLessTenArrayBackup,remData);//求余数
*resultData=3; //商等于3
while_flag=1; //退出循环
}
else //小于
{
subError=SubData(destData,DivLessTenArrayResult,remData);//求余数
*resultData=4; //商等于4
while_flag=1; //退出循环
}
break;
case 5: //要点解说一下case 5，其它case 原理相同，不多讲
ClearAllData(BCD8_MAX,DivLessTenArrayTemp); //清空运算中需求用到的中心数组变量
ClearAllData(BCD8_MAX,DivLessTenArrayResult); //清空运算中需求用到的中心数组变量
DivLessTenArrayTemp[0]=resultRunStep;//把猜的变量方式的商传递给数组方式的变量
multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);//猜的商跟除数像乘，看看成果跟被除数谁大。
cmpError=CmpData(DivLessTenArrayResult,destData); //猜的商跟除数像乘，看看成果跟被除数谁大。
if(cmpError==10) //等于祝贺猜中是5
{
*resultData=5; //商等于5余数为0
while_flag=1; //退出循环
}
else if(cmpError==11) //大于猜不中，大了，就持续往小的猜，看看有没有或许是3
{
resultRunStep=3;
}
else //小于猜不中，小了，就持续往大的猜，看看有没有或许是7
{
resultRunStep=7;
ClearAllData(BCD8_MAX,DivLessTenArrayBackup);
for(i=0;i
{
DivLessTenArrayBackup[i]=DivLessTenArrayResult[i];
}
}
break;
case 6:
ClearAllData(BCD8_MAX,DivLessTenArrayTemp);
ClearAllData(BCD8_MAX,DivLessTenArrayResult);
DivLessTenArrayTemp[0]=resultRunStep;
multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);
cmpError=CmpData(DivLessTenArrayResult,destData);
if(cmpError==10) //等于
{
*resultData=6; //商等于6余数为0
while_flag=1; //退出循环
}
else if(cmpError==11) //大于
{
subError=SubData(destData,DivLessTenArrayBackup,remData);//求余数
*resultData=5; //商等于5
while_flag=1; //退出循环
}
else //小于
{
subError=SubData(destData,DivLessTenArrayResult,remData);//求余数
*resultData=6; //商等于6
while_flag=1; //退出循环
}
break;
case 7:
ClearAllData(BCD8_MAX,DivLessTenArrayTemp);
ClearAllData(BCD8_MAX,DivLessTenArrayResult);
DivLessTenArrayTemp[0]=resultRunStep;
multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);
cmpError=CmpData(DivLessTenArrayResult,destData);
if(cmpError==10) //等于
{
*resultData=7; //商等于7余数为0
while_flag=1; //退出循环
}
else if(cmpError==11) //大于
{
resultRunStep=6;
}
else //小于
{
resultRunStep=8;
ClearAllData(BCD8_MAX,DivLessTenArrayBackup);
for(i=0;i
{
DivLessTenArrayBackup[i]=DivLessTenArrayResult[i];
}
}
break;
case 8:
ClearAllData(BCD8_MAX,DivLessTenArrayTemp);
ClearAllData(BCD8_MAX,DivLessTenArrayResult);
DivLessTenArrayTemp[0]=resultRunStep;
multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);
cmpError=CmpData(DivLessTenArrayResult,destData);
if(cmpError==10) //等于
{
*resultData=8; //商等于8余数为0
while_flag=1; //退出循环
}
else if(cmpError==11) //大于
{
subError=SubData(destData,DivLessTenArrayBackup,remData);//求余数
*resultData=7; //商等于7
while_flag=1; //退出循环
}
else //小于
{
resultRunStep=9;
ClearAllData(BCD8_MAX,DivLessTenArrayBackup);
for(i=0;i
{
DivLessTenArrayBackup[i]=DivLessTenArrayResult[i];
}
}
break;
case 9:
ClearAllData(BCD8_MAX,DivLessTenArrayTemp);
ClearAllData(BCD8_MAX,DivLessTenArrayResult);
DivLessTenArrayTemp[0]=resultRunStep;
multError=MultData(sourceData,DivLessTenArrayTemp,DivLessTenArrayResult);
cmpError=CmpData(DivLessTenArrayResult,destData);
if(cmpError==10) //等于
{
*resultData=9; //商等于9余数为0
while_flag=1; //退出循环
}
else if(cmpError==11) //大于
{
subError=SubData(destData,DivLessTenArrayBackup,remData);//求余数
*resultData=8; //商等于8
while_flag=1; //退出循环
}
else //小于
{
subError=SubData(destData,DivLessTenArrayResult,remData);//求余数
*resultData=9; //商等于9
while_flag=1; //退出循环
}
break;
}
if(while_flag==1)//猜中了就退出循环
{
break;
}
}
}
return DivLessTenResult;
}
/* 注释十二：
*函数介绍：两个数相除
*输入参数：
*（1）*destData–被除数的数组。
*（2）*sourceData–除数的数组。
*（3）*resultData–商的数组
*回来值：10代表核算成果超出规模犯错，11代表正常。
*/
uchar Div(const uchar *destData,const uchar *sourceData,uchar *resultData)
{
uchar DivResult=11; //开端默许正常
uchar destCnt=0;
uchar sourceCnt=0;
uchar i;
uchar j;
uchar resultTemp=0; //寄存暂时运算成果的中心变量
uchar DivArrayTemp[BCD8_MAX]; //寄存暂时运算成果的数组中心变量
uchar DivArrayResult[BCD8_MAX]; //寄存暂时运算成果的数组中心变量的成果
uchar divError=11;
destCnt=GetDataLength(destData,BCD8_MAX); //获取被除数的数据有用长度
sourceCnt=GetDataLength(sourceData,BCD8_MAX); //获取除数的数据有用长度
ClearAllData(BCD8_MAX,resultData); //把成果清零
if(sourceCnt==0)//除数为0，报错
{
DivResult=10; //报错
}
else
{
ClearAllData(BCD8_MAX,DivArrayTemp); //清零部分被除数的数组
for(i=0;i
{
DivArrayTemp[0]=destData[destCnt-1-i];//从被除数的高位开端借位,放到部分被除数的个位
divError=DivLessTenData(DivArrayTemp,sourceData,&resultTemp,DivArrayResult);//部分相除，求商resultTemp，此商resultTemp不超越10
if(divError==10)//报错
{
DivResult=10;
break;
}
else
{
resultData[destCnt-1-i]=resultTemp;//保存商
for(j=0;j<(destCnt-1);j++)//把余数移一次位,适当于扩大十倍,从头放进DivArrayTemp数组对应的位
{
DivArrayTemp[j+1]=DivArrayResult[j];
}
}
}
}
return DivResult;
}
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
{
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_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_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=Div(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
{
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
{
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
{
for(j=0;j<500;j++)//内嵌循环的空指令数量
{
; //一个分号适当于履行一条空句子
}
}
}
void delay_short(unsigned int uiDelayShort)
{
unsigned int i;
for(i=0;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; //发动守时中止
}

总结陈词：
前面四个章节讲完了四则运算的大数据算法，下一节讲单片机的外部中止功用。外部中止是单片机十分重要的内部资源，使用很广，它是单片机的高速开关感应器输入接口，它能够检测脉冲输入，能够接纳红外遥控器的输入信号，能够检测高速工作的车轮或许电机圆周运动的反应信号，能够检测输液器里瞬间即逝的水滴信号，能够接纳模仿串口的数据信息，等等。单片机外部中止的有什么特色？欲知概况，请听下回分化—-单片机外部中止的根底。

扫一扫打开手机网站

微信扫一扫关注我们

第65节：大数据的除法运算

联系我们

微信扫一扫关注我们

为您推荐

小漫电子到货泰科TE连接器外壳206037-1 、206070-8

小漫电子到货YANGJIE(扬杰)GBJ3506 整流桥 3000只

聊聊逆变器：进军绿色能源市场，你绕不开的技术门槛！

电化学感知技术的新时代

红外线接收组件引脚极性识别

模拟设计中的布局相关和 LOD 效果

联系我们

微信扫一扫关注我们