標(biāo)題: 基于單片機+RTX51 tiny編寫的LCD1602計算器程序與仿真 [打印本頁]
作者: 想進步要學(xué)習(xí)    時間: 2020-3-26 01:03
標(biāo)題: 基于單片機+RTX51 tiny編寫的LCD1602計算器程序與仿真
  首先得說明的是，這個計算器是數(shù)組之間的運算，而不是簡單的a+b或者a*b就得出來結(jié)果了的那種，這樣子運算也不精準(zhǔn)啊。以前也發(fā)過一個計算器程序，不滿意，所以想著重寫一個，但一個東西再寫一遍有意思嗎？起碼要加點新東西進去，才能有所長進嘛。為什么不滿意呢？程序中你中有我我中有你就會顯得亂，再加上沒有實物玩，如果是我自己下載了一個別人的這樣的一個程序，我想我是不會完完整整的看的。我總是想把我想要說的東西說的很詳細的那種，讓人一看就懂。但就目前來說，火候還是欠佳，最突出的一點就是，當(dāng)我寫完程序后再反過來注釋的話，我的心會浮躁。以后，我務(wù)必要寫一段程序注釋一段。所以這次我痛改前非，盡量使程序劃分的比較清晰，我是用實物直接試驗的，本來我是不會再用仿真的，但考慮到?jīng)]有實物的程序也不太好看，我還是弄了個仿真圖，試了下還行，這樣程序好看了點。從寫第一個RTX51 tiny程序到“完整計算器”文件都壓縮了，除了文件“完整計算器”我做了有限測試，其他文件都只是試了下，其中“四則計算器”就存在漏洞。本人水平雖然有限，但分享資料的心天地可鑒，如果我這資料能給他人覺得有所收獲，我很滿足。

仿真原理圖如下（proteus仿真工程文件可到本帖附件中下載）


全部資料51hei下載地址：
RTX51 tiny.rar (9.25 MB, 下載次數(shù): 66)

作者: 51hei團團    時間: 2020-3-26 02:48
好資料，51黑有你更精彩!!!樓主的主程序:
  1. #include "yunsuan.h"

  3. u8 jshcq[16]={0};                                    //計算結(jié)果緩存區(qū)
  4. _SU shushu1={0,0,{0,0,0,0,0,0,0,0,0,0,0,0,0,0}};     //前數(shù)
  5. _SU shushu2={0,0,{0,0,0,0,0,0,0,0,0,0,0,0,0,0}};     //后數(shù)

  7. extern u8 da;    //定義靜態(tài)變量da,對應(yīng)LCD顯示字符位置

  9. /**********************************************
  10. *功能：LCD顯示數(shù)組清零
  11. **********************************************/
  12. void Lcd_qinpin(void)
  13. {
  14.   u8 i;                  //定義變量i
  15.         for(i=0;i<16;i++){     //循環(huán)16次
  16.           lcdxs[i]=' ';        //LCD顯示字符數(shù)組清空
  17.         }
  18. }

  20. /**********************************************************************************************************************************
  21. *功能：LCD輸入顯示算式限制函數(shù)
  22. 目的：限制字符的輸入顯示。
  23. 情況分析：1、兩個數(shù)首位都不能是無意義的0。  例如，00.12。
  24.           2、兩個數(shù)的小數(shù)點最多都只能有1個。例如，12.3.4。
  25.           3、兩個數(shù)首位只能是數(shù)字。         例如，.5898。
  26.           4、兩個數(shù)尾位都不能是無效的0。    例如，65.30。
  27.           5、算式中運算符必須有1個。        例如，567。
  28.           （情況分析后補,具體看程序）
  29. zhuangtai對應(yīng)位說明：
  30.   bit[2-0] ：  前個顯示字符對應(yīng)的標(biāo)號(fenzu)。
  31.   bit[3]   ：  0)當(dāng)前輸入數(shù)首位數(shù)字不是0,  1)當(dāng)前輸入數(shù)首位數(shù)字是0。                
  32.   bit[4]   ：  0)字符不顯示,               1)顯示字符。
  33.   bit[5]   ：  0)算式后數(shù)沒小數(shù)點,         1)算式后數(shù)有小數(shù)點。
  34.   bit[6]   ：  0)算式前數(shù)沒小數(shù)點,         1)算式前數(shù)有小數(shù)點。
  35.   bit[7]   ：  0)當(dāng)前算式?jīng)]有輸入過運算符, 1)當(dāng)前算式有輸入過運算符。
  36. 輸入算式滿了的情況下,只能按等號鍵有效,通過da判斷實現(xiàn)。
  37. **********************************************************************************************************************************/
  38. u8 Shizhe_Xianzhi(u8 x)
  39. {
  40.         static u8 zhuangtai=0x04;    //給定zhuangtai的初值0x04,為什么是0x04?分析知道首位的限制情況和前一個字符是運算符類似
  41.         u8 fenzu=0;                  //定義變量fenzu,作用如下
  42.         //-------------給輸入按鍵情況分類-------------                    
  43.         if(x=='0'){                  //輸入'0'
  44.                 if(da<16){                 
  45.             fenzu=1;                 //fenzu=1
  46.                 }
  47.         }else{
  48.            if(x>'0'){               
  49.                          if(x=='='){             //輸入'='
  50.                                  fenzu=5;              //fenzu=5
  51.                          }else{                  //輸入'123456789'
  52.                                   if(da<16){
  53.                                     fenzu=2;           //fenzu=2
  54.                                         }
  55.                                 }             
  56.                  }else{
  57.                     if(x=='.'){            //輸入'.'
  58.                                         if(da<16){
  59.                                     fenzu=3;           //fenzu=3
  60.                                         }
  61.                                 }else{                 //輸入'+-*/'       
  62.                                          if(da<16){
  63.              fenzu=4;          //fenzu=4
  64.                                          }                                                 
  65.                                  }
  66.                   }
  67.          }
  68.         zhuangtai&=0xef;                     //zhuangtai字符顯示標(biāo)志位置0       
  69.         //---------------------按等號鍵的后續(xù)處理-----------------------------------------
  70.         if((zhuangtai&0x07)==0x06){    //上一個狀態(tài)是清除'='按下
  71.           zhuangtai=0x04;              //zhuangtai恢復(fù)初始值
  72.         }
  73.         if((zhuangtai&0x07)==0x05){    //上一個狀態(tài)是計算'='按下
  74.                 if(fenzu==5){                //計算完算式,需再次按'='清屏處理,不然不執(zhí)行任何操作
  75.                   zhuangtai=0x06;            //zhuangtai恢復(fù)初始值
  76.                         zhuangtai|=0x10;           //zhuangtai字符顯示標(biāo)志位置1       
  77.                         return zhuangtai;          //跳出準(zhǔn)備執(zhí)行清屏與相關(guān)數(shù)據(jù)初始化工作
  78.                 }else{
  79.                    return zhuangtai;         //跳出,無操作
  80.                  }  
  81.         }       
  82.   //-------------------------------------按fenzu分類處理--------------------------------------------------------------------------
  83.         switch(fenzu)
  84.         {
  85.                 case 1:
  86.                         if((zhuangtai&0x0f)!=0x09){           //排除一種情況：當(dāng)前輸入數(shù)首位數(shù)字是0,并且前一個字符是'0'
  87.                                 if((zhuangtai&0x07)==0x04){         //兩種情況：剛開始輸入、前一個字符是運算符
  88.                                   zhuangtai|=0x08;                  //zhuangtai第3位置位
  89.                                 }
  90.                                 zhuangtai&=0xf8;                    //zhuangtai清零后3位
  91.                                 zhuangtai|=0x11;                                            //zhuangtai字符顯示標(biāo)志位置1、zhuangtai添加后3位狀態(tài)值(1)      
  92.                         }
  93.                         break;
  94.                 case 2:
  95.                         if((zhuangtai&0x0f)!=0x09){           //排除一種情況：當(dāng)前輸入數(shù)首位數(shù)字是0,并且前一個字符是'0'
  96.                           zhuangtai&=0xf8;                    //zhuangtai清零后3位
  97.         zhuangtai|=0x12;                                            //zhuangtai字符顯示標(biāo)志位置1、zhuangtai添加后3位狀態(tài)值(2)                    
  98.                         }
  99.                         break;
  100.                 case 3:
  101.                         //排除情況：前一個字符是小數(shù)點、前一個字符是運算符、當(dāng)前算式有小數(shù)點沒有運算符、當(dāng)前算式有運算符有小數(shù)點
  102.                         if(((zhuangtai&0x07)!=0x03)&&((zhuangtai&0x07)!=0x04)&&((zhuangtai&0xc0)!=0x40)&&((zhuangtai&0xa0)!=0xa0)){
  103.                           zhuangtai&=0xf8;                    //zhuangtai清零后3位
  104.                                 if(zhuangtai&0x80){                 //當(dāng)前算式有運算符
  105.                                   zhuangtai|=0x20;                  //zhuangtai第5位置位
  106.                                 }else{                              //當(dāng)前算式?jīng)]有運算符
  107.                                    zhuangtai|=0x40;                 //zhuangtai第6位置位
  108.                                  }
  109.                                 zhuangtai&=0xf7;                    //zhuangtai第3位（首位數(shù)字0標(biāo)志位）清零（有小數(shù)點后，首位是不是0，對輸入數(shù)字字符沒影響）
  110.         zhuangtai|=0x13;                                            //zhuangtai字符顯示標(biāo)志位置1、zhuangtai添加后3位狀態(tài)值(3)   
  111.                         }
  112.                         break;
  113.                 case 4:
  114.                         //排除情況：前一個字符是小數(shù)點、前一個字符是運算符、前數(shù)有小數(shù)點前一個字符是0、算式輸入過一次運算符
  115.                         if(((zhuangtai&0x07)!=0x03)&&((zhuangtai&0x07)!=0x04)&&((zhuangtai&0xc7)!=0x41)&&((zhuangtai&0x80)!=0x80)){
  116.                           zhuangtai&=0xf8;                    //zhuangtai清零后3位
  117.                                 zhuangtai&=0xf7;                    //zhuangtai第3位（首位數(shù)字0標(biāo)志位）清零
  118.         zhuangtai|=0x94;                                            //zhuangtai字符顯示標(biāo)志位置1、zhuangtai第7位置位、zhuangtai添加后3位狀態(tài)值(4)
  119.                         }
  120.                         break;
  121.                 case 5:
  122.                         //排除情況：前一個字符是小數(shù)點、前一個字符是運算符、后數(shù)有小數(shù)點前一個字符是0、算式?jīng)]輸入過運算符
  123.                         if(((zhuangtai&0x07)!=0x03)&&((zhuangtai&0x07)!=0x04)&&((zhuangtai&0xa7)!=0xa1)&&(zhuangtai&0x80)){
  124.                           zhuangtai&=0xf8;                    //zhuangtai清零后3位
  125.         zhuangtai|=0x15;                                            //zhuangtai字符顯示標(biāo)志位置1、zhuangtai添加后3位狀態(tài)值(5)
  126.                         }else{
  127.                                  //輸入算式不合理的情況下
  128.                            zhuangtai=0x16;                    //zhuangtai字符顯示標(biāo)志位置1、zhuangtai添加后3位狀態(tài)值(6)
  129.                          }
  130.                         break;
  131.                 default:
  132.                         break;
  133.         }
  134.         //--------------------------------------------------------------------------------------------------------------------------------
  135.         return zhuangtai;                         //返回按鍵狀態(tài)值
  136. }

  138. /**********************************************************************************************************
  139. *功能：結(jié)構(gòu)體數(shù)據(jù)隨輸入字符改變
  140. 目的：隨著輸入字符,改變相應(yīng)的結(jié)構(gòu)體數(shù)據(jù)(用于四則運算)。
  141. 具體情況：記錄,shushu1.zscd           //前數(shù)整數(shù)個數(shù)     
  142.                shushu1.sscd           //前數(shù)小數(shù)個數(shù)
  143.                shushu1.shujuabc[]     //去除小數(shù)點后的前數(shù)數(shù)據(jù)
  144.                shushu2.zscd           //后數(shù)整數(shù)個數(shù)
  145.                shushu2.sscd           //后數(shù)小數(shù)個數(shù)
  146.                shushu2.shujuabc[]     //去除小數(shù)點后的后數(shù)數(shù)據(jù)
  147. **********************************************************************************************************/
  148. void Jiegou_Chuli(u8 xcu)
  149. {
  150.         static u8 i=0,xs=0,ys=0;                  //定義變量i對應(yīng)shujuabc[]標(biāo)號,變量xs對應(yīng)小數(shù)點,變量ys對應(yīng)運算符
  151.         if(xcu!='='){                             //按下的不是等號鍵
  152.           if(xcu>='0'){                           //輸入數(shù)字
  153.       if(xs==0){                                     
  154.                                 if(ys==0){                          //(輸入算式?jīng)]小數(shù)點、沒運算符)前數(shù)整數(shù)部分       
  155.                                   shushu1.zscd++;                   //前數(shù)整數(shù)對應(yīng)個數(shù)加一
  156.                       shushu1.shujuabc[i]=xcu-0x30;     //輸入字符數(shù)字存入shushu1.shujuabc[]
  157.                                 }else{                              //(輸入算式?jīng)]小數(shù)點、有運算符)后數(shù)整數(shù)部分       
  158.                                    shushu2.zscd++;                  //后數(shù)整數(shù)對應(yīng)個數(shù)加一
  159.                        shushu2.shujuabc[i]=xcu-0x30;    //輸入字符數(shù)字存入shushu2.shujuabc[]
  160.                                  }
  161.                   }else{
  162.                      if(xs==1){                     
  163.                              if(ys==0){                       //(輸入算式有一個小數(shù)點、沒運算符)前數(shù)小數(shù)部分       
  164.                                            shushu1.sscd++;                //前數(shù)小數(shù)對應(yīng)個數(shù)加一
  165.                                      shushu1.shujuabc[i]=xcu-0x30;  //輸入字符數(shù)字存入shushu1.shujuabc[]
  166.                                    }else{                           //(輸入算式前數(shù)有小數(shù)點、有運算符)后數(shù)整數(shù)部分
  167.                                       shushu2.zscd++;               //后數(shù)整數(shù)對應(yīng)個數(shù)加一
  168.                           shushu2.shujuabc[i]=xcu-0x30; //輸入字符數(shù)字存入shushu2.shujuabc[]
  169.                                     }
  170.                            }else{                             //(輸入算式后數(shù)有小數(shù)點、有運算符)后數(shù)小數(shù)部分
  171.                               shushu2.sscd++;                 //后數(shù)小數(shù)對應(yīng)個數(shù)加一
  172.                                     shushu2.shujuabc[i]=xcu-0x30;   //輸入字符數(shù)字存入shushu2.shujuabc[]
  173.                             }
  174.                    }                          
  175.                   i++;                                  //變量i加一
  176.           }else{
  177.                    if(xcu=='.'){                        //是小數(shù)點
  178.                            if(ys==0){                         //當(dāng)前沒有運算符
  179.                              xs=1;                            //xs=1,表示前數(shù)有小數(shù)點了
  180.                            }else{                             //當(dāng)前有運算符
  181.                               xs=2;                           //xs=2,表示后數(shù)有小數(shù)點了
  182.                             }                                 
  183.                    }else{                               //是運算符
  184.                                   i=0;                              //變量i置零,開始對應(yīng)后數(shù)存儲數(shù)組shujuabc[]
  185.                       ys=1;                             //ys=1,表示運算符有了
  186.                     }
  187.            }
  188.         }else{                                    //按下的是等號鍵
  189.            i=0;                                   //變量初始化,準(zhǔn)備下次運算
  190.                  xs=0;
  191.                  ys=0;
  192.          }
  193. }

  195. /*********************************************************************************************
  196. *功能：結(jié)構(gòu)體數(shù)據(jù)初始化
  197. 目的：結(jié)構(gòu)體數(shù)據(jù)和計算結(jié)果存儲數(shù)組初始化,為下次運算準(zhǔn)備。
  198. *********************************************************************************************/
  199. void Jiegou_Csh(void)
  200. {
  201. //---------初始化結(jié)構(gòu)體數(shù)據(jù)和計算結(jié)果存儲數(shù)組---------       
  202.   u8 i;                               //定義變量i
  203.         shushu1.zscd=0;              //前數(shù)整數(shù)個數(shù)置零
  204.         shushu1.sscd=0;              //前數(shù)小數(shù)個數(shù)置零
  205.         shushu2.zscd=0;              //后數(shù)整數(shù)個數(shù)置零
  206.         shushu2.sscd=0;              //后數(shù)小數(shù)個數(shù)置零
  207.         for(i=0;i<14;i++){           //循環(huán)14次  
  208.                 shushu1.shujuabc[i]=0;     //前數(shù)數(shù)據(jù)清零
  209.                 shushu2.shujuabc[i]=0;     //后數(shù)數(shù)據(jù)清零
  210.                 jshcq[i]=0;                //計算結(jié)果存儲數(shù)組前14位清零
  211.         }
  212.         jshcq[14]=0;                 //計算結(jié)果存儲數(shù)組15位清零
  213.         jshcq[15]=0;                 //計算結(jié)果存儲數(shù)組16位清零
  214. }

  216. /********************************************************************************************************************
  217. *功能：運算符判斷
  218. 目的：以運算符分類處理四則運算。
  219. ********************************************************************************************************************/
  220. u8 Yunsf_Jl(void)
  221. {
  222.         u8 ysf;                                    //ysf用作運算符記錄
  223.         if(shushu1.sscd==0){                       //沒有小數(shù)部分
  224.           ysf=lcdxs[shushu1.zscd];                 //前數(shù)的整數(shù)部分長度就是運算符在lcdxs[]中的位置
  225.         }else{                                     //有小數(shù)部分
  226.            ysf=lcdxs[shushu1.zscd+shushu1.sscd+1]; //前數(shù)的整數(shù)部分加前數(shù)的小數(shù)部分長度再加小數(shù)位就是運算符在lcdxs[]中的位置
  227.          }
  228.         return ysf;                                //返回ysf
  229. }

  231. /**********************************************************************************************************************************************************
  232. *功能：乘法函數(shù)
  233. **********************************************************************************************************************************************************/
  234. u8 Chengfa(void)
  235. {
  236.         u8 ic=0,jc=0,nc=0,mc=0;                                                            //前數(shù)開始運算位,后數(shù)開始運算位,計算結(jié)果存儲位置變量,計算結(jié)果存儲起始位
  237.         ic=shushu1.zscd+shushu1.sscd-1;                                                    //賦值“前數(shù)的的尾位在shushu1.shujuabc[]中的位置”給ic
  238.         jc=shushu2.zscd+shushu2.sscd-1;                                                    //賦值“后數(shù)的的尾位在shushu2.shujuabc[]中的位置”給jc
  239.         if(((ic==0)&&(shushu1.shujuabc[ic]==0))||((jc==0)&&(shushu2.shujuabc[jc]==0))){    //前數(shù)和后數(shù)中至少一個是0
  240.                 jshcq[0]=0;                                                                      //顯示計算結(jié)果'0'
  241.                 return 0xf0;                                                                     //跳出
  242.         }
  243.         //----------------------------循環(huán)0---------------------------------------------------------
  244.         do
  245.         {
  246.           jshcq[nc]+=shushu2.shujuabc[jc]*shushu1.shujuabc[ic];     //存儲兩數(shù)運算結(jié)果
  247.           if(jshcq[nc]>9){                                          //兩數(shù)運算結(jié)果是2位數(shù)
  248.                         jshcq[nc+1]+=jshcq[nc]/10;                              //高位累加進位
  249.                         jshcq[nc]%=10;                                          //低位取個位
  250.                 }
  251.                 if(ic!=0){                                                //前數(shù)數(shù)據(jù)沒取完
  252.                   ic--;                                                   //前數(shù)運算位左移
  253.                         nc++;                                                   //運算結(jié)果存儲位右移
  254.                 }else{                                                    //前數(shù)數(shù)據(jù)取完了
  255.                    if(jc!=0){                                             //后數(shù)數(shù)據(jù)沒取完
  256.          ic=shushu1.zscd+shushu1.sscd-1;                      //前數(shù)起始位初始值                         
  257.                            jc--;                                                //后數(shù)運算位左移
  258.                                  mc++;                                                //存儲結(jié)果起始位右移
  259.                                  nc=mc;                                                                        //賦值給nc
  260.                          }else{                                                 //后數(shù)數(shù)據(jù)取完了
  261.                                   if(jshcq[nc+1]!=0){                                 //如果計算完有進位
  262.                                           nc++;                                             //相應(yīng)的nc加一
  263.                                         }
  264.                             break;                                              //跳出循環(huán)   <<<====（循環(huán)0,出口）
  265.                           }
  266.                  }                 
  267.         }while(1);
  268.         //--------------------------------------------------------------------------------------------
  269.         jc=15;                                          //jc賦值15,作用不同上面
  270.         if((shushu1.sscd!=0)||(shushu2.sscd!=0)){       //前數(shù)和后數(shù)中至少有一個有小數(shù)點
  271.           jc=nc-(shushu1.sscd+shushu2.sscd);            //計算結(jié)果總長度(不算小數(shù)點)-兩個數(shù)小數(shù)部分長度和。jc是小數(shù)點在lcdxs[]中的位置
  272.         }       
  273.         mc=(jc<<4)+nc;                                  //高四位存小數(shù)點位,低四位存計算結(jié)果長度
  274.   return mc;                                      //帶出mc
  275. }

  277. /***************************************************************************************************************************************
  278. *功能：加法函數(shù)
  279. ***************************************************************************************************************************************/
  280. u8 Jiafa(void)
  281. {
  282.   u8 ic=0,jc=0,nc=0,mc=0;                        //前數(shù)開始運算位,后數(shù)開始運算位,計算結(jié)果存儲位置變量,計算結(jié)果存儲起始位
  283.         ic=shushu1.zscd+shushu1.sscd-1;                //賦值“前數(shù)的的尾位在shushu1.shujuabc[]中的位置”給ic
  284.         jc=shushu2.zscd+shushu2.sscd-1;                //賦值“后數(shù)的的尾位在shushu2.shujuabc[]中的位置”給jc
  285.         //-------------------處理前數(shù)和后數(shù)小數(shù)位較長的部分--------------------------
  286.         if(shushu1.sscd>shushu2.sscd){                 //前數(shù)的小數(shù)部分比后數(shù)的小數(shù)部分長
  287.                 do
  288.                 {
  289.                         if(ic-shushu1.zscd==jc-shushu2.zscd){      //直到取到小數(shù)位一樣長后
  290.                           break;                                   //跳出         <<<====（出口）
  291.                         }else{
  292.                                  jshcq[nc]+=shushu1.shujuabc[ic];        //小數(shù)位長的直接賦值給jshcq[]
  293.                            nc++;                                   //存儲位遞加
  294.                                  ic--;                                   //移位取下一位小數(shù)位
  295.                          }
  296.                 }while(1);
  297.     mc=shushu1.sscd;                                         //小數(shù)點位置計算用到
  298.         }else{
  299.                  if(shushu1.sscd!=shushu2.sscd){             //小數(shù)位等長不用處理
  300.                    do
  301.                    {
  302.                            if(ic-shushu1.zscd==jc-shushu2.zscd){   //直到取到小數(shù)位一樣長后
  303.                              break;                                //跳出         <<<====（出口）
  304.                            }else{
  305.                                           jshcq[nc]+=shushu2.shujuabc[jc];     //小數(shù)位長的直接賦值給jshcq[]
  306.                               nc++;                                //存儲位遞加
  307.                                     jc--;                                //移位取下一位小數(shù)位
  308.                             }
  309.                    }while(1);
  310.                  }
  311.                  mc=shushu2.sscd;                            //小數(shù)點位置計算用到
  312.          }
  313.         //-------------------處理另一部分--------------------------------------------------
  314.         do
  315.         {
  316.                 jshcq[nc]+=shushu1.shujuabc[ic]+shushu2.shujuabc[jc];    //兩數(shù)中間部分相加
  317.     if(jshcq[nc]>9){                                         //兩數(shù)運算結(jié)果是2位數(shù)
  318.                         jshcq[nc+1]+=jshcq[nc]/10;                             //高位累加進位
  319.                         jshcq[nc]%=10;                                         //低位取個位
  320.                 }               
  321.                 if((ic!=0)&&(jc!=0)){                                    //兩個數(shù)數(shù)據(jù)都沒取完            
  322.                         nc++;
  323.                         ic--;
  324.                         jc--;
  325.                 }else{
  326.                    if((ic==0)&&(jc==0)){                                 //兩個數(shù)數(shù)據(jù)都取完
  327.                            break;                                              //跳出     <<<====（出口）
  328.                          }else{
  329.                             if(ic==0){                                         //前數(shù)數(shù)據(jù)取完
  330.                                                 //-------------------后數(shù)整數(shù)部分長出的部分處理---------------------------
  331.                                                 do{
  332.                                                         if(jc==0){
  333.                                                                 break;                                       //跳出     <<<====（出口）
  334.                                                         }else{         
  335.                                                            nc++;
  336.                                                                  jc--;
  337.                                                          }
  338.                                                         jshcq[nc]+=shushu2.shujuabc[jc];               //后數(shù)整數(shù)長的部分再取
  339.                                                         if(jshcq[nc]>9){                               //兩數(shù)運算結(jié)果是2位數(shù)
  340.                                   jshcq[nc+1]+=jshcq[nc]/10;                   //高位累加進位
  341.                                   jshcq[nc]%=10;                               //低位取個位
  342.                           }         
  343.                                                 }while(1);
  344.                                                 //------------------------------------------------------------------------
  345.                                         }else{                                             //后數(shù)數(shù)據(jù)取完
  346.                                                  //-------------------前數(shù)整數(shù)部分長出的部分處理---------------------------
  347.                                                  do{
  348.                                                          if(ic==0){
  349.                                                            break;                                      //跳出     <<<====（出口）
  350.                                                          }else{         
  351.                                                             nc++;
  352.                                                                   ic--;
  353.                                                           }
  354.                                                          jshcq[nc]+=shushu1.shujuabc[ic];              //前數(shù)整數(shù)長的部分再取
  355.                                                          if(jshcq[nc]>9){                              //兩數(shù)運算結(jié)果是2位數(shù)
  356.                                    jshcq[nc+1]+=jshcq[nc]/10;                  //高位累加進位
  357.                                    jshcq[nc]%=10;                              //低位取個位
  358.                            }
  359.                                                  }while(1);
  360.                                                  //------------------------------------------------------------------------                                  
  361.                                          }
  362.                                         break;                                             //跳出
  363.                           }
  364.                  }
  365.         }while(1);
  366.         if(jshcq[nc+1]>0){                                         //高位有進位的情況
  367.                 nc++;
  368.         }
  369.   //------------------------------------------------------------------------------------
  370.         jc=15;
  371.         if((shushu1.sscd!=0)||(shushu2.sscd!=0)){
  372.           jc=nc-mc;                                                //計算結(jié)果總長度(不算小數(shù)點)-小數(shù)部分長度。小數(shù)點在lcdxs[]中的位置
  373.         }       
  374.         mc=(jc<<4)+nc;                                             //高四位存小數(shù)點位,低四位存計算結(jié)果長度
  375.   return mc;
  376. }

  378. /******************************************************************************************************************************************
  379. *功能：減法函數(shù)
  380. ******************************************************************************************************************************************/
  381. u8 Jianfa(void)
  382. {
  383.   u8 ic=0,jc=0,nc=0,mc=0;
  384.         //-----------------------------比較前數(shù)和后數(shù)的大小---------------------------------------------------------------------
  385.         if(shushu1.zscd>shushu2.zscd){                                 //前數(shù)整數(shù)部分比后數(shù)整數(shù)部分長
  386.           mc=1;                                 //前數(shù)比后數(shù)大
  387.         }else{
  388.            if(shushu1.zscd!=shushu2.zscd){                            //前數(shù)整數(shù)部分比后數(shù)整數(shù)部分短
  389.                    mc=2;                              //后數(shù)比前數(shù)大
  390.                  }else{                                                     //前數(shù)整數(shù)部分和后數(shù)整數(shù)部分一樣長
  391.                     do
  392.                                 {
  393.                             if(shushu1.shujuabc[ic]>shushu2.shujuabc[jc]){        //前數(shù)高位比后數(shù)高位大
  394.                                     mc=1;
  395.                                                 break;                  //跳出
  396.                                   }else{
  397.                                      if(shushu1.shujuabc[ic]!=shushu2.shujuabc[jc]){    //前數(shù)高位比后數(shù)高位小
  398.                                              mc=2;
  399.                                                          break;               //跳出
  400.                                            }else{                                             //前數(shù)高位和后數(shù)高位一樣大
  401.                                               if((ic!=shushu1.zscd+shushu1.sscd-1)&&(jc!=shushu2.zscd+shushu2.sscd-1)){       //前數(shù)和后數(shù)數(shù)據(jù)都沒有取完
  402.                               ic++;
  403.                                                                         jc++;
  404.                                                                 }else{                                         
  405.                                                                    if((ic==shushu1.zscd+shushu1.sscd-1)&&(jc==shushu2.zscd+shushu2.sscd-1)){    //前數(shù)和后數(shù)數(shù)據(jù)都取完
  406.                                                                            mc=0;          //前數(shù)和后數(shù)一樣大
  407.                                                                                  break;         //跳出
  408.                                                                          }else{
  409.                                                                             if(ic==shushu1.zscd+shushu1.sscd-1){      //前數(shù)數(shù)據(jù)取完,后數(shù)沒取完
  410.                                                                                           mc=2;
  411.                                                                                                 break;                        //跳出                                                               
  412.                                                                                         }else{                                    //后數(shù)數(shù)據(jù)取完,前數(shù)沒取完
  413.                                                                                            mc=1;
  414.                                                                                                  break;     //跳出
  415.                                                                                          }
  416.                                                                           }                                                                        
  417.                                                                  }                                                       
  418.                                             }
  419.                                    }
  420.                           }while(1);
  421.                   }
  422.          }
  423.         //-----------------------------------------------------------------------------------------------------------------------
  424.         ic=shushu1.zscd+shushu1.sscd-1;
  425.         jc=shushu2.zscd+shushu2.sscd-1;
  426.         switch(mc)
  427.         {
  428.           case 0:
  429.                   jshcq[0]=0;                                                   //顯示計算結(jié)果'0'
  430.                         break;
  431.                 case 1:     //與下面mc=2是一樣的,下面?zhèn)渥⒃敿汓c
  432.                         if(shushu1.sscd>=shushu2.sscd){                               //前數(shù)不比后數(shù)小數(shù)部分短
  433.                           do
  434.                                 {
  435.                                         if(ic-shushu1.zscd==jc-shushu2.zscd){                     //直到取到小數(shù)位一樣長后                     
  436.                                                 break;                                                  //跳出
  437.                             }else{
  438.                                      jshcq[nc]=shushu1.shujuabc[ic];                        //小數(shù)位長的直接賦值給jshcq[]
  439.                                nc++;                                                  //存儲位遞加
  440.                                      ic--;                                                  //移位取下一位小數(shù)位
  441.                              }
  442.                                  }while(1);                       
  443.                   }else{                                                        //前數(shù)比后數(shù)小數(shù)部分短
  444.                                  shushu1.shujuabc[ic]--;                                    //減一
  445.                                  jshcq[nc]=10-shushu2.shujuabc[jc];
  446.                                  nc++;
  447.                                  jc--;
  448.                                  do
  449.                                  {
  450.                              if(ic-shushu1.zscd==jc-shushu2.zscd){                    //直到取到小數(shù)位一樣長后                     
  451.                                                  break;                                                 //跳出
  452.                              }else{
  453.                                       jshcq[nc]=9-shushu2.shujuabc[jc];
  454.                                 nc++;                                                 //存儲位遞加
  455.                                       jc--;                                                 //移位取下一位小數(shù)位
  456.                               }
  457.                                  }while(1);                                         
  458.                          }                 
  459.                         do
  460.                         {
  461.                                 if(shushu1.shujuabc[ic]>=shushu2.shujuabc[jc]){             //前數(shù)不比后數(shù)小
  462.                                         jshcq[nc]+=shushu1.shujuabc[ic]-shushu2.shujuabc[jc];     //前數(shù)-后數(shù)
  463.                                         if(jc==0){                                                //后數(shù)取完了                                             
  464.                                                 do
  465.                                                 {
  466.               if(ic!=0){                                            //前數(shù)沒取完
  467.                                                           nc++;                  
  468.                                                                 ic--;       
  469.                                                         }else{
  470.                                                                  break;
  471.                                                          }       
  472.               jshcq[nc]+=shushu1.shujuabc[ic];                                                        
  473.                                                 }while(1);       
  474.                                                 break;                                                  //前數(shù)取完跳出循環(huán)                                                                               
  475.                                         }else{
  476.                                                  ic--;
  477.                                                  jc--;
  478.                                                  nc++;
  479.                                          }
  480.                                 }else{                                                      //前數(shù)比后數(shù)小
  481.                                          shushu1.shujuabc[ic]+=10;                                //加10
  482.                                          if(shushu1.shujuabc[ic-1]!=0){                           //當(dāng)前運算前數(shù)的前一位不等于0
  483.                                                  shushu1.shujuabc[ic-1]--;                              //減一位
  484.                                                  
  485.                                          }else{                                                   //當(dāng)前運算前數(shù)的前一位等于0
  486.                                                         mc=ic;                                                //mc的作用變了
  487.                                                         ic--;
  488.                                                         do
  489.                                                         {                                                                    
  490.                                                                 shushu1.shujuabc[ic]=9;                             //0位置9
  491.                                                                 if(shushu1.shujuabc[ic-1]!=0){                      //找可以減的位
  492.                                                                         shushu1.shujuabc[ic-1]--;                                                                                            //減一
  493.                                                                         break;                                            //跳出
  494.                                                           }else{                                                                                                          //再找
  495.                                                                          ic--;                                       
  496.                                                                  }
  497.                                                         }while(1);
  498.               ic=mc;                                                                               
  499.                                                 }
  500.                                  }                                                       
  501.                         }while(1);
  502.                         break;
  503.                 case 2:       
  504.                         if(shushu2.sscd>=shushu1.sscd){                               //后數(shù)不比前數(shù)小數(shù)部分短  <<<=====（分情況實現(xiàn)）
  505.                           //---------------------------------------------------------------------------------------------------
  506.                                 do
  507.                                 {
  508.                                         if(ic-shushu1.zscd==jc-shushu2.zscd){                     //直到取到小數(shù)位一樣長后        <<<=====（目的）     
  509.                                                 break;                                                  //跳出
  510.                             }else{
  511.                                      jshcq[nc]=shushu2.shujuabc[jc];                        //小數(shù)位長的直接賦值給jshcq[]
  512.                                nc++;                                                  //存儲位遞加
  513.                                      jc--;                                                  //移位取下一位小數(shù)位
  514.                              }
  515.                                  }while(1);                       
  516.                                 //---------------------------------------------------------------------------------------------------
  517.                   }else{                                                        //后數(shù)比前數(shù)小數(shù)部分短
  518.                                  //--------------------------------------------------------------------------------------------------
  519.                                  shushu2.shujuabc[jc]--;                                    //減一
  520.                                  jshcq[nc]=10-shushu1.shujuabc[ic];
  521.                                  nc++;
  522.                                  ic--;
  523.                                  do
  524.                                  {
  525.                              if(ic-shushu1.zscd==jc-shushu2.zscd){                    //直到取到小數(shù)位一樣長后        <<<=====（目的）             
  526.                                                  break;                                                 //跳出
  527.                              }else{
  528.                                       jshcq[nc]=9-shushu1.shujuabc[ic];
  529.                                 nc++;                                                 //存儲位遞加
  530.                                       ic--;                                                 //移位取下一位小數(shù)位
  531.                               }
  532.                                  }while(1);       
  533.          //--------------------------------------------------------------------------------------------------                                 
  534.                          }
  535.       //-----------------------------循環(huán)0-------------------------------------------------------------------                       
  536.                         do
  537.                         {
  538.                                 if(shushu2.shujuabc[jc]>=shushu1.shujuabc[ic]){             //后數(shù)不比前數(shù)小
  539.                                         jshcq[nc]+=shushu2.shujuabc[jc]-shushu1.shujuabc[ic];     //后數(shù)-前數(shù)
  540.                                         if(ic==0){                                                //前數(shù)取完了                                         
  541.                                                 //------------------------循環(huán)2-----------------------------------------------------
  542.                                                 do
  543.                                                 {
  544.               if(jc!=0){                                            //后數(shù)沒取完
  545.                                                                 nc++;                  
  546.                                                                 jc--;                  
  547.                                                         }else{                                                //后數(shù)取完了           
  548.                                                                  break;                                             //跳出  <<<====（循環(huán)2,出口）
  549.                                                          }
  550.                jshcq[nc]+=shushu2.shujuabc[jc];                                                                
  551.                                           }while(1);
  552.             //----------------------------------------------------------------------------------                                       
  553.                                                 nc++;
  554.                                                 jshcq[nc]='-'-0x30;                                                        //負號先記上
  555.                                                 break;                                                  //后數(shù)取完跳出循環(huán)   <<<=====（循環(huán)0,出口）                                                                               
  556.                                         }else{
  557.                                                  ic--;
  558.                                                  jc--;
  559.                                                  nc++;
  560.                                          }
  561.                                 }else{                                                      //后數(shù)比前數(shù)小
  562.                                          shushu2.shujuabc[jc]+=10;                                //加10
  563.                                          if(shushu2.shujuabc[jc-1]!=0){                           //當(dāng)前運算后數(shù)的前一位不等于0
  564.                                                  shushu2.shujuabc[jc-1]--;                              //減一位
  565.                                                  
  566.                                          }else{                                                   //當(dāng)前運算后數(shù)的前一位等于0
  567.                                                         //-------------------------------循環(huán)1---------------------------------------------------------
  568.                                                   mc=jc;                                                //mc的作用變了
  569.                                                         jc--;
  570.                                                         do
  571.                                                         {                                                                    
  572.                                                                 shushu2.shujuabc[jc]=9;                             //0位置9
  573.                                                                 if(shushu2.shujuabc[jc-1]!=0){                      //找可以減的位
  574.                                                                         shushu2.shujuabc[jc-1]--;                                                                                            //不夠減,高位要         <<<=====（循環(huán)1,目的）       
  575.                                                                         break;                                            //跳出
  576.                                                           }else{                                                                                                          //再找
  577.                                                                          ic--;                                       
  578.                                                                  }
  579.                                                         }while(1);
  580.               jc=mc;       
  581.               //---------------------------------------------------------------------------------------------                                                       
  582.                                                 }
  583.                                  }                                                       
  584.                         }while(1);
  585.                         //-----------------------------------------------------------------------------------------------------       
  586.                         break;
  587.                 default:
  588.                         break;
  589.         }
  590.         jc=15;
  591.         if(shushu1.sscd>=shushu2.sscd){                 //沒有多余變量可以利用,只能再判斷一次小數(shù)部分長短
  592.           mc=shushu1.sscd;
  593.         }else{
  594.            mc=shushu2.sscd;
  595.          }
  596.         if((shushu1.sscd!=0)||(shushu2.sscd!=0)){
  597.           jc=nc-mc;                                     //計算結(jié)果總長度(不算小數(shù)點)-小數(shù)部分長度。小數(shù)點在lcdxs[]中的位置
  598.         }       
  599.         mc=(jc<<4)+nc;                                  //高四位存小數(shù)點位,低四位存計算結(jié)果長度
  600.   return mc;
  601. }

  603. /*********************************************************************************************************
  604. *功能：除法函數(shù)
  605. *********************************************************************************************************/
  606. u8 Chufa(void)
  607. {
  608.         u8 ic=0,jc=0,nc=0,mc=0,gc=0,xc=0;       
  609.         //--------------------------------特殊情況處理-----------------------------------------------------------
  610.         if((shushu2.shujuabc[0]==0)&&(shushu2.zscd==1)&&(shushu2.sscd==0)){   //后數(shù)是0的情況,不進行運算
  611.                 Lcd_qinpin();                                                       //LCD顯示數(shù)組清零
  612.                 lcdxs[0]='x';                                                       //無法計算結(jié)果
  613.                 return 0xff;
  614.         }
  615.         if((shushu1.shujuabc[0]==0)&&(shushu1.zscd==1)&&(shushu1.sscd==0)){   //前數(shù)是0的情況
  616.                 Lcd_qinpin();                                                       //LCD顯示數(shù)組清零,準(zhǔn)備存儲計算結(jié)果
  617.                 lcdxs[0]='0';                                                       //計算結(jié)果是0
  618.                 return 0xff;
  619.         }
  620.         //--------------------------------------------------------------------------------------------------------
  621.         while(shushu1.shujuabc[ic]==0){             //前數(shù)是0的位不用運算   
  622.           ic++;
  623.         }
  624.         while(shushu2.shujuabc[jc]==0){             //后數(shù)是0的位不用運算   
  625.           jc++;
  626.         }
  627.         xc=shushu2.zscd-shushu1.zscd+ic-jc+15;      //小數(shù)點位置
  628.         mc=jc<<4;                                   //當(dāng)前jc值存入mc高四位,jc最大13,4位足以存儲
  629.         //---------------------------------大循環(huán)0號,直到計算出16位計算結(jié)果才跳出------------------------------------------------
  630.         do
  631.         {               
  632.                 mc&=0xf0;                                          //清除低四位
  633.                 mc|=ic;                                            //記錄ic的值,存入mc低四位 （關(guān)鍵點：mc之前的數(shù)據(jù)一定是0）
  634.                 if(nc!=16){                                        //計算結(jié)果沒滿16位
  635.                         if((mc&0x0f)>=14-shushu2.zscd-shushu2.sscd){     //“前數(shù)截取部分的長度首位置之后的剩余的長度”不會比“后數(shù)的長度”長
  636.                     //----------------------------------循環(huán)1號,為了能計算出足有16位的結(jié)果----------------------------------------------
  637.                                 jc=0;                                          //這里jc的作用是一個起始值為0的變量
  638.                     do
  639.                     {
  640.                       shushu1.shujuabc[jc]=shushu1.shujuabc[ic];   //將剩余的有效數(shù)字重新以shushu1.shujuabc[0]為起始順序存儲
  641.                             shushu1.shujuabc[ic]=0;                      //清除
  642.                             if(ic==13){                                  //數(shù)據(jù)重存完
  643.                               break;                                     //跳出
  644.                             }else{                                       //繼續(xù)轉(zhuǎn)存有效數(shù)據(jù)
  645.                                jc++;
  646.                                      ic++;
  647.                              }
  648.                     }while(1);
  649.                     ic=0;                                          //相應(yīng)的變量值也將改變,實現(xiàn)一個14位數(shù)據(jù)的數(shù)組當(dāng)一個28位數(shù)據(jù)的數(shù)組使用    <<<====（循環(huán)1號,目的）
  650.                     mc&=0xf0;                                      //清除低四位,mc低四位清零,同步ic值
  651.                     jc=mc>>4;                                      //jc恢復(fù)初始值
  652.                                 //-----------------------------------------------------------------------------------------------------------------
  653.                         }
  654.           }else{                           //得到16位計算結(jié)果                                                                         <<<====（大循環(huán)0號,目的）
  655.              break;                        //跳出
  656.            }
  657.                 //-----------------------循環(huán)2號,截取前數(shù)(可減后數(shù),即必須比后數(shù)大)部分-------------------------------------------------------------------------------
  658.           do
  659.           {
  660.                   if(shushu1.shujuabc[ic]>shushu2.shujuabc[jc]){         //從高位開始比較  
  661.         ic=(mc&0x0f)+shushu2.zscd+shushu2.sscd-1;                         //前數(shù)截取長度和后數(shù)等長
  662.                           break;              //跳出（大的時候會跳出）                                                                 <<<====（出口1）
  663.                   }else{
  664.                            if(shushu1.shujuabc[ic]!=shushu2.shujuabc[jc]){     //前數(shù)比后數(shù)小                         
  665.                                    if(shushu1.shujuabc[ic]!=0){                      //該位不是0,前數(shù)截取長度比后數(shù)多1位肯定比后數(shù)大
  666.                                      ic=(mc&0x0f)+shushu2.zscd+shushu2.sscd;         //前數(shù)截取比后數(shù)多1位數(shù)
  667.                                                  if(!(gc&0x80)){                                 //gc最高位是0,在gc最高位是1的情況下nc不能加加
  668.                                                    nc++;                                         //計算結(jié)果位置移位
  669.                                                          gc|=0x80;                                     //最高位置1,表示前數(shù)截取部分比后數(shù)長1位數(shù)
  670.                                                  }                                                 
  671.                                    }else{                                            //該位是0
  672.                                                   if(ic==mc){                                    //0是前數(shù)截取部分第一位
  673.                                                                 ic++;                                        //判斷位移位
  674.                                                     mc++;                                        //mc低四位加一同步ic
  675.                                               jc=mc>>4;                                    //后數(shù)回到起始位置
  676.                                                     gc&=0x7f;                                    //高位置0,表示
  677.                                               gc|=0x01;                                    //gc最低位作為這一情況的標(biāo)志,表示不用運算
  678.                                                                 nc++;
  679.                                                         }else{                                         //0是前數(shù)截取部分非首位,首位肯定不是0,這種情況是前數(shù)截取部分減了后數(shù)若干次后的結(jié)果小于后數(shù)了
  680.                                                            ic=(mc&0x0f)+shushu2.zscd+shushu2.sscd;     //前數(shù)截取比后數(shù)多1位數(shù)
  681.                                                                  if(!(gc&0x80)){                             //gc最高位是0,在gc最高位是1的情況下nc不能加加,比如,4480-452=4028,4028-452這種情況nc不能加
  682.                                                        nc++;                                     //計算結(jié)果位置移位
  683.                                                              gc|=0x80;                                 //最高位置1,表示前數(shù)截取部分比后數(shù)長1位數(shù)
  684.                                                      }                       
  685.                                                          }
  686.                                     }       
  687.             break;                                         //跳出（小的時候跳出）                                                                   <<<====（出口2）
  688.                      }else{                                              //前數(shù)和后數(shù)高位一樣大
  689.                                     if(jc!=shushu2.zscd+shushu2.sscd-1){             //后數(shù)數(shù)據(jù)沒有取完,繼續(xù)下位比較
  690.                           ic++;
  691.                                             jc++;
  692.                                     }else{                                           //前數(shù)和后數(shù)一樣大
  693.                                                    ic=(mc&0x0f)+shushu2.zscd+shushu2.sscd-1;                 //前數(shù)截取長度和后數(shù)等長
  694.                break;                                 //跳出（相等的時候跳出）                                                                 <<<====（出口3）
  695.                                      }                                                       
  696.                             }
  697.              }
  698.     }while(1);       
  699.     //----------------------------------------------------------------------------------------------------------------------------------------------------               
  700.           if(!(gc&0x01)){                                                 //gc最低位是1的時候,不進行運算
  701.             jc=shushu2.zscd+shushu2.sscd-1;                               //后數(shù)尾數(shù)開始運算
  702.             //------------------------------------循環(huán)3號,前數(shù)截取部分-后數(shù),求得可減次數(shù),化除法為減法----------------------------------------------
  703.             do
  704.                         {
  705.                     if(shushu1.shujuabc[ic]>=shushu2.shujuabc[jc]){             //前數(shù)不比后數(shù)小                                          
  706.                             shushu1.shujuabc[ic]-=shushu2.shujuabc[jc];               //前數(shù)-后數(shù)
  707.                             if(jc==mc>>4){                                            //后數(shù)取完了
  708.                                                 if(ic!=(mc&0x0f)){                                      //前數(shù)截取部分沒取完       
  709.                                                   if(shushu1.shujuabc[ic-1]==0){                        //前數(shù)多的一位是0
  710.                                                           gc&=0x7f;                                           //最高位置0,表示如果減后的前數(shù)截取部分長度比后數(shù)小的話,存儲位置nc需要加加
  711.                                                         }else{                                                //這里說明肯定比后數(shù)還大,存儲位置nc不能移位
  712.                                                            ic--;
  713.                                                         }                                                               
  714.                                                 }         
  715.                                     break;                        //跳出循環(huán)                                           <<<====（循環(huán)3號,出口）                                                                       
  716.                             }else{
  717.                                      ic--;
  718.                                      jc--;
  719.                              }
  720.                     }else{                                                      //前數(shù)比后數(shù)小
  721.           //----------------------------------只進行數(shù)據(jù)改變,不運算-----------------------------------------------------------
  722.                             shushu1.shujuabc[ic]+=10;                                 //加10
  723.                                         if(shushu1.shujuabc[ic-1]!=0){                            //當(dāng)前運算前數(shù)的前一位不等于0
  724.                                      shushu1.shujuabc[ic-1]--;                              //減一位
  725.                              }else{                                                   //當(dāng)前運算前數(shù)的前一位等于0
  726.                                             //-----------------------------循環(huán)4號,尋找可借位高位-----------------------------------------------------------
  727.                                                   gc|=ic;                                               //gc這里的作用是保存當(dāng)前ic的值,ic最大值13,用gc的低四位足夠
  728.                                             ic--;
  729.                                             do
  730.                                       {                                                                    
  731.                                                     shushu1.shujuabc[ic]=9;                             //0位置9
  732.                                                     if(shushu1.shujuabc[ic-1]!=0){                      //找可以減的位    <<<====（循環(huán)4號,目的）
  733.                                                       shushu1.shujuabc[ic-1]--;                                                                                            //減一
  734.                                                             break;                                            //跳出
  735.                                               }else{                                                                                                          //再找
  736.                                                              ic--;                                       
  737.                                                }
  738.                                             }while(1);
  739.               ic=gc&0x7f;                                           //ic恢復(fù)原保存值
  740.                     gc&=0x80;                                             //保留最高位,清除其他位                                           
  741.               //--------------------------------------------------------------------------------------------------------------                                               
  742.                                     }
  743.                                          //-----------------------------------------------------------------------------------------------------------------
  744.                      }                                                       
  745.             }while(1);
  746.                         //------------------------------------------------------------------------------------------------------------------------------------
  747.             jshcq[nc]++;                                                  //前數(shù)截取部分和后數(shù)減一次,計算結(jié)果累加一次                       
  748.           }
  749.                 gc&=0x80;                                                       //最高位不變,其他位清零
  750.         }while(1);
  751.         //-------------------------------------------------------------------------------------------------------------------------
  752.         Lcd_qinpin();                          //LCD顯示數(shù)組清零,準(zhǔn)備存儲計算結(jié)果
  753.         jc=0;
  754.         gc=0;
  755.         //-------------------計算結(jié)果和顯示轉(zhuǎn)換--------------------------
  756.         if(xc<16){
  757.                 //-----計算結(jié)果大于等于1（還有0.幾的情況在內(nèi)）-----------------
  758.           nc=16-xc;
  759.                 //-------------------計算結(jié)果數(shù)據(jù)處理--------------------------
  760.                 if(jshcq[0]==0&&nc!=1){              //計算結(jié)果首位數(shù)字是0,并且不是0.
  761.                   jc++;                              //起始數(shù)據(jù)位置加一
  762.                         nc--;                              //小數(shù)點位置同步
  763.                 }
  764.                 //-------------------存入顯示數(shù)組------------------------------
  765.                 for(ic=0;ic<16;ic++){                //計算結(jié)果轉(zhuǎn)換為顯示數(shù)據(jù)
  766.                         if(ic==nc){                        //小數(shù)點位置
  767.                           lcdxs[ic]='.';
  768.                         }else{                             //數(shù)字位置
  769.                            lcdxs[ic]=jshcq[jc]+0x30;
  770.                      jc++;
  771.                          }  
  772.     }
  773.                 //---------刪除計算結(jié)果后面無效的0----------------------------
  774.                 ic=15;
  775.                 do
  776.                 {
  777.                   if(lcdxs[ic]=='0'||lcdxs[ic]=='.'){   //這里存在一種情況,如果一個計算結(jié)果是無理數(shù)并且顯示尾部是0,那么0也會被不顯示,這雖然不是想要的結(jié)果,但還可以接受
  778.                     lcdxs[ic]=' ';
  779.                                 ic--;
  780.                   }else{
  781.                            break;
  782.                          }
  783.                 }while(1);
  784.         //---------------------------------------------------------------
  785.         }else{                                
  786.                  //-------------------計算結(jié)果小于1-------------------------------------------
  787.            nc=xc-14;          
  788.      //------------計算結(jié)果小于等于0.001采用科學(xué)計數(shù)法----------------------------
  789.                  if((nc==4&&jshcq[0]==0)||nc>4){   
  790.                          if(jshcq[0]!=0){                   //沒算小數(shù)點的計算結(jié)果首位不是0,nc要減一
  791.                            nc--;                                                
  792.                          }else{                             //首位0不用顯示
  793.                             jc++;
  794.                           }
  795.                          //-------------------固定顯示部分------------------------------------------
  796.                          lcdxs[1]='.';                                                                           
  797.                          if(nc<10){
  798.                                  lcdxs[13]='e';
  799.                            lcdxs[14]='-';
  800.                            lcdxs[15]=nc+0x30;
  801.                                  mc=12;                           //下面刪除無效0不顯示有用
  802.                          }else{
  803.                             lcdxs[12]='e';
  804.                             lcdxs[13]='-';
  805.                             lcdxs[14]=nc/10+0x30;
  806.                                   lcdxs[15]=nc%10+0x30;
  807.                                   mc=11;                          //下面刪除無效0不顯示有用
  808.                           }       
  809.        //-------------------存入顯示數(shù)組------------------------------------------                 
  810.                    for(ic=0;ic<14;ic++){              //計算結(jié)果轉(zhuǎn)換為顯示數(shù)據(jù)
  811.                            if(lcdxs[ic]==' '){              //lcdxs[]沒有賦值
  812.                                    lcdxs[ic]=jshcq[jc]+0x30;
  813.                        jc++;
  814.                                          if(lcdxs[ic]!='0'){            //lcdxs[]只要有一位數(shù)不是0,gc就賦值1
  815.                                            gc=1;                                                  
  816.                                          }
  817.                                  }                  
  818.                          }
  819.                          //-----------------------特殊情況------------------------------------------
  820.        if(gc==0){                                //全是0,表示計算結(jié)果無效
  821.                            Lcd_qinpin();
  822.                                  lcdxs[0]='x';                           //顯示x,表示計算不出來,當(dāng)計算結(jié)果小于1/9999999999999時
  823.                          }else{
  824.                             do
  825.                       {
  826.                         if(lcdxs[mc]=='0'||lcdxs[mc]=='.'){  //這里存在一種情況,如果一個計算結(jié)果是無理數(shù)并且顯示尾部是0,那么0也會被不顯示,這雖然不是想要的結(jié)果,但還可以接受,比如,計算結(jié)果9.99000999000e-4會顯示9.99000999e-4
  827.                           lcdxs[mc]=' ';
  828.                                       mc--;
  829.                         }else{
  830.                                  break;
  831.                                }
  832.                       }while(1);
  833.                           }       
  834.      //----------------------------------------------------------------------------                 
  835.                  }else{       
  836.         //------------計算結(jié)果大于0.001-----------------------------------------                         
  837.                     for(ic=0;ic<16;ic++){                    //0和小數(shù)點部分
  838.                             if(ic<nc){
  839.             if(ic==1){
  840.                                       lcdxs[ic]='.';
  841.                                     }else{
  842.                                        lcdxs[ic]='0';
  843.                                      }                                                          
  844.                             }else{                                 //其余部分
  845.                                            lcdxs[ic]=jshcq[jc]+0x30;
  846.                                      jc++;
  847.                              }                       
  848.         }
  849.                                 ic=15;
  850.                                 do
  851.                     {
  852.                       if(lcdxs[ic]=='0'||lcdxs[ic]=='.'){    //這里存在一種情況,如果一個計算結(jié)果是無理數(shù)并且顯示尾部是0,那么0也會被不顯示,這雖然不是想要的結(jié)果,但還可以接受
  853.                         lcdxs[ic]=' ';
  854.                                     ic--;
  855.                       }else{
  856.                                break;
  857.                              }
  858.                     }while(1);
  859.                         }
  860.             //-------------------------------------------------------------------------
  861.          }
  862.         //----------------------------------------------------------------------------
  863.   return 0xff;
  864. }

  866. /*************************************************************************************************
  867. *功能：四則運算
  868. *************************************************************************************************/
  869. void Jisuan(void)
  870. {
  871.         u8 yun,u=0;
  872.         yun=Yunsf_Jl();
  873.         switch(yun)
  874.         {
  875.                 case '+':
  876.                         yun=Jiafa();                           //yun的作用變了
  877.                         break;
  878.                 case '-':
  879.                         yun=Jianfa();
  880.                         break;
  881.                 case '*':
  882.                         yun=Chengfa();
  883.                         break;
  884.                 case '/':
  885.                         yun=Chufa();
  886.                         break;
  887.                 default:
  888.                         break;
  889.         }
  890.         if(yun!=0xff){                             //排除除法,其他3種算法需執(zhí)行的程序
  891.           Lcd_qinpin();                            //LCD顯示數(shù)組清零,準(zhǔn)備存儲計算結(jié)果
  892.           do
  893.                 {
  894.                         lcdxs[u]=jshcq[yun%16]+0x30;           //計算結(jié)果存儲數(shù)組中的數(shù)據(jù)以字符形式放入LCD顯示數(shù)組
  895.                         if(yun%16!=0){
  896.                                 if(u==yun/16){                       //小數(shù)位處理
  897.                                         u++;
  898.                                         lcdxs[u]='.';
  899.                                 }                               
  900.                                 yun--;                               //jshcq[]存放形式低位到高位
  901.                                 u++;                                 //lcdxs[]存放形式高位到低位
  902.                         }else{                                 //跳出循壞條件：數(shù)據(jù)取完
  903.                                 break;
  904.                         }
  905.                 }while(1);
  906.                 //--------------去掉計算結(jié)果后面沒用的0---------------------------比如,34.00
  907.                 if(yun/16!=15){                       //有小數(shù)點時
  908.                         do
  909.                         {
  910.                                 if(lcdxs[u]=='0'){                //碰到'0'
  911.                                         lcdxs[u]=' ';                   //空格符代替
  912.                                 }else{
  913.                                          if(lcdxs[u]=='.'){             //碰到'.'
  914.                                                  lcdxs[u]=' ';                //空格符代替
  915.                                          }
  916.                                    break;                         //碰到非'0'數(shù)字字符跳出                                           
  917.                                  }
  918.         u--;                                                //移位,判斷下一位
  919.                   }while(1);
  920.           }
  921.                 //-----------去掉計算結(jié)果前面沒用的0------------------------------比如,00.34
  922.                 u=0;                              
  923.                 do
  924.                 {
  925.                         if(lcdxs[u]=='0'){           
  926.                                 if(lcdxs[u+1]=='.'){      
  927.                                         break;                      //當(dāng)計算結(jié)果是'0''.'的時候,跳出循環(huán)
  928.                                 }else{
  929.                                          if(lcdxs[u+1]==' '){       //計算結(jié)果是'0'的時候
  930.                                                  break;
  931.                                    }
  932.                              lcdxs[u]=' ';              //如果'0'后面沒跟'.'
  933.                                    u++;                       //移位,準(zhǔn)備下一位判斷
  934.                            }                 
  935.                   }else{
  936.                            if(lcdxs[u]!='-'){           
  937.                              break;                     //碰到不是'-',跳出循環(huán)
  938.                            }else{
  939.                               u++;
  940.                             }
  941.                    }
  942.           }while(1);
  943.         }  
  944. }
復(fù)制代碼
作者: 51hei團團    時間: 2020-5-15 18:59
好資料，51黑有你更精彩!!!
作者: dhz0105    時間: 2020-5-15 19:45

好厲害，51黑有你更精彩!!!
作者: 羅程峰8200    時間: 2020-5-16 11:51


好厲害，51黑有你更精彩!!!
作者: meiwen141    時間: 2020-6-10 21:31
膜拜，大師級別的了，我是看不懂的。



歡迎光臨 (http://www.torrancerestoration.com/bbs/) Powered by Discuz! X3.1