第64節：大數據的乘法運算

作者：時間：2016-11-22 來源：網絡

加入技術交流群
- 掃碼加入
  和技術大咖面對面交流
  海量資料庫查詢

開場白：
直接用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[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--加數的數組。
*（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;
}
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=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
{
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; //啟動定時中斷
}

總結陳詞：
既然這節講了乘法程序，那么下一節接著講常用的除法程序，這種大數據的除法程序是什么樣的？欲知詳情，請聽下回分解----大數據的除法運算。

久久ER99热精品一区二区-久久精品99国产精品日本-久久精品免费一区二区三区-久久综合九色综合欧美狠狠

新聞中心

第64節：大數據的乘法運算

評論

相關推薦

技術專區