设为首页收藏本站
开启辅助访问

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 基于单片机+RTX51 tiny编写的LCD1602计算器程序与仿真

基于单片机+RTX51 tiny编写的LCD1602计算器程序与仿真

查看数: 4540 | 评论数: 5 | 收藏 7
关灯 | 提示：支持键盘翻页<-左 右->
帖子模式
    组图打开中，请稍候......
想进步要学习
发布时间: 2020-3-26 01:03

正文摘要:

  首先得说明的是，这个计算器是数组之间的运算，而不是简单的a+b或者a*b就得出来结果了的那种，这样子运算也不精准啊。以前也发过一个计算器程序，不满意，所以想着重写一个，但一个东西再写一遍有意思吗 ...

回复

ID:546698 发表于 2020-6-10 21:31
膜拜，大师级别的了，我是看不懂的。
ID:89217 发表于 2020-5-16 11:51


好厉害，51黑有你更精彩!!!
ID:546568 发表于 2020-5-15 19:45

好厉害，51黑有你更精彩!!!
ID:328014 发表于 2020-5-15 18:59
好资料，51黑有你更精彩!!!
ID:328014 发表于 2020-3-26 02:48
好资料，51黑有你更精彩!!!楼主的主程序:
  1. #include "yunsuan.h"

  3. u8 jshcq[16]={0};                                    //计算结果缓存区
  4. _SU shushu1={0,0,{0,0,0,0,0,0,0,0,0,0,0,0,0,0}};     //前数
  5. _SU shushu2={0,0,{0,0,0,0,0,0,0,0,0,0,0,0,0,0}};     //后数

  7. extern u8 da;    //定义静态变量da,对应LCD显示字符位置

  9. /**********************************************
  10. *功能：LCD显示数组清零
  11. **********************************************/
  12. void Lcd_qinpin(void)
  13. {
  14.   u8 i;                  //定义变量i
  15.         for(i=0;i<16;i++){     //循环16次
  16.           lcdxs[i]=' ';        //LCD显示字符数组清空
  17.         }
  18. }

  20. /**********************************************************************************************************************************
  21. *功能：LCD输入显示算式限制函数
  22. 目的：限制字符的输入显示。
  23. 情况分析：1、两个数首位都不能是无意义的0。  例如，00.12。
  24.           2、两个数的小数点最多都只能有1个。例如，12.3.4。
  25.           3、两个数首位只能是数字。         例如，.5898。
  26.           4、两个数尾位都不能是无效的0。    例如，65.30。
  27.           5、算式中运算符必须有1个。        例如，567。
  28.           （情况分析后补,具体看程序）
  29. zhuangtai对应位说明：
  30.   bit[2-0] ：  前个显示字符对应的标号(fenzu)。
  31.   bit[3]   ：  0)当前输入数首位数字不是0,  1)当前输入数首位数字是0。                
  32.   bit[4]   ：  0)字符不显示,               1)显示字符。
  33.   bit[5]   ：  0)算式后数没小数点,         1)算式后数有小数点。
  34.   bit[6]   ：  0)算式前数没小数点,         1)算式前数有小数点。
  35.   bit[7]   ：  0)当前算式没有输入过运算符, 1)当前算式有输入过运算符。
  36. 输入算式满了的情况下,只能按等号键有效,通过da判断实现。
  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字符显示标志位置0       
  69.         //---------------------按等号键的后续处理-----------------------------------------
  70.         if((zhuangtai&0x07)==0x06){    //上一个状态是清除'='按下
  71.           zhuangtai=0x04;              //zhuangtai恢复初始值
  72.         }
  73.         if((zhuangtai&0x07)==0x05){    //上一个状态是计算'='按下
  74.                 if(fenzu==5){                //计算完算式,需再次按'='清屏处理,不然不执行任何操作
  75.                   zhuangtai=0x06;            //zhuangtai恢复初始值
  76.                         zhuangtai|=0x10;           //zhuangtai字符显示标志位置1       
  77.                         return zhuangtai;          //跳出准备执行清屏与相关数据初始化工作
  78.                 }else{
  79.                    return zhuangtai;         //跳出,无操作
  80.                  }  
  81.         }       
  82.   //-------------------------------------按fenzu分类处理--------------------------------------------------------------------------
  83.         switch(fenzu)
  84.         {
  85.                 case 1:
  86.                         if((zhuangtai&0x0f)!=0x09){           //排除一种情况：当前输入数首位数字是0,并且前一个字符是'0'
  87.                                 if((zhuangtai&0x07)==0x04){         //两种情况：刚开始输入、前一个字符是运算符
  88.                                   zhuangtai|=0x08;                  //zhuangtai第3位置位
  89.                                 }
  90.                                 zhuangtai&=0xf8;                    //zhuangtai清零后3位
  91.                                 zhuangtai|=0x11;                                            //zhuangtai字符显示标志位置1、zhuangtai添加后3位状态值(1)      
  92.                         }
  93.                         break;
  94.                 case 2:
  95.                         if((zhuangtai&0x0f)!=0x09){           //排除一种情况：当前输入数首位数字是0,并且前一个字符是'0'
  96.                           zhuangtai&=0xf8;                    //zhuangtai清零后3位
  97.         zhuangtai|=0x12;                                            //zhuangtai字符显示标志位置1、zhuangtai添加后3位状态值(2)                    
  98.                         }
  99.                         break;
  100.                 case 3:
  101.                         //排除情况：前一个字符是小数点、前一个字符是运算符、当前算式有小数点没有运算符、当前算式有运算符有小数点
  102.                         if(((zhuangtai&0x07)!=0x03)&&((zhuangtai&0x07)!=0x04)&&((zhuangtai&0xc0)!=0x40)&&((zhuangtai&0xa0)!=0xa0)){
  103.                           zhuangtai&=0xf8;                    //zhuangtai清零后3位
  104.                                 if(zhuangtai&0x80){                 //当前算式有运算符
  105.                                   zhuangtai|=0x20;                  //zhuangtai第5位置位
  106.                                 }else{                              //当前算式没有运算符
  107.                                    zhuangtai|=0x40;                 //zhuangtai第6位置位
  108.                                  }
  109.                                 zhuangtai&=0xf7;                    //zhuangtai第3位（首位数字0标志位）清零（有小数点后，首位是不是0，对输入数字字符没影响）
  110.         zhuangtai|=0x13;                                            //zhuangtai字符显示标志位置1、zhuangtai添加后3位状态值(3)   
  111.                         }
  112.                         break;
  113.                 case 4:
  114.                         //排除情况：前一个字符是小数点、前一个字符是运算符、前数有小数点前一个字符是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位（首位数字0标志位）清零
  118.         zhuangtai|=0x94;                                            //zhuangtai字符显示标志位置1、zhuangtai第7位置位、zhuangtai添加后3位状态值(4)
  119.                         }
  120.                         break;
  121.                 case 5:
  122.                         //排除情况：前一个字符是小数点、前一个字符是运算符、后数有小数点前一个字符是0、算式没输入过运算符
  123.                         if(((zhuangtai&0x07)!=0x03)&&((zhuangtai&0x07)!=0x04)&&((zhuangtai&0xa7)!=0xa1)&&(zhuangtai&0x80)){
  124.                           zhuangtai&=0xf8;                    //zhuangtai清零后3位
  125.         zhuangtai|=0x15;                                            //zhuangtai字符显示标志位置1、zhuangtai添加后3位状态值(5)
  126.                         }else{
  127.                                  //输入算式不合理的情况下
  128.                            zhuangtai=0x16;                    //zhuangtai字符显示标志位置1、zhuangtai添加后3位状态值(6)
  129.                          }
  130.                         break;
  131.                 default:
  132.                         break;
  133.         }
  134.         //--------------------------------------------------------------------------------------------------------------------------------
  135.         return zhuangtai;                         //返回按键状态值
  136. }

  138. /**********************************************************************************************************
  139. *功能：结构体数据随输入字符改变
  140. 目的：随着输入字符,改变相应的结构体数据(用于四则运算)。
  141. 具体情况：记录,shushu1.zscd           //前数整数个数     
  142.                shushu1.sscd           //前数小数个数
  143.                shushu1.shujuabc[]     //去除小数点后的前数数据
  144.                shushu2.zscd           //后数整数个数
  145.                shushu2.sscd           //后数小数个数
  146.                shushu2.shujuabc[]     //去除小数点后的后数数据
  147. **********************************************************************************************************/
  148. void Jiegou_Chuli(u8 xcu)
  149. {
  150.         static u8 i=0,xs=0,ys=0;                  //定义变量i对应shujuabc[]标号,变量xs对应小数点,变量ys对应运算符
  151.         if(xcu!='='){                             //按下的不是等号键
  152.           if(xcu>='0'){                           //输入数字
  153.       if(xs==0){                                     
  154.                                 if(ys==0){                          //(输入算式没小数点、没运算符)前数整数部分       
  155.                                   shushu1.zscd++;                   //前数整数对应个数加一
  156.                       shushu1.shujuabc[i]=xcu-0x30;     //输入字符数字存入shushu1.shujuabc[]
  157.                                 }else{                              //(输入算式没小数点、有运算符)后数整数部分       
  158.                                    shushu2.zscd++;                  //后数整数对应个数加一
  159.                        shushu2.shujuabc[i]=xcu-0x30;    //输入字符数字存入shushu2.shujuabc[]
  160.                                  }
  161.                   }else{
  162.                      if(xs==1){                     
  163.                              if(ys==0){                       //(输入算式有一个小数点、没运算符)前数小数部分       
  164.                                            shushu1.sscd++;                //前数小数对应个数加一
  165.                                      shushu1.shujuabc[i]=xcu-0x30;  //输入字符数字存入shushu1.shujuabc[]
  166.                                    }else{                           //(输入算式前数有小数点、有运算符)后数整数部分
  167.                                       shushu2.zscd++;               //后数整数对应个数加一
  168.                           shushu2.shujuabc[i]=xcu-0x30; //输入字符数字存入shushu2.shujuabc[]
  169.                                     }
  170.                            }else{                             //(输入算式后数有小数点、有运算符)后数小数部分
  171.                               shushu2.sscd++;                 //后数小数对应个数加一
  172.                                     shushu2.shujuabc[i]=xcu-0x30;   //输入字符数字存入shushu2.shujuabc[]
  173.                             }
  174.                    }                          
  175.                   i++;                                  //变量i加一
  176.           }else{
  177.                    if(xcu=='.'){                        //是小数点
  178.                            if(ys==0){                         //当前没有运算符
  179.                              xs=1;                            //xs=1,表示前数有小数点了
  180.                            }else{                             //当前有运算符
  181.                               xs=2;                           //xs=2,表示后数有小数点了
  182.                             }                                 
  183.                    }else{                               //是运算符
  184.                                   i=0;                              //变量i置零,开始对应后数存储数组shujuabc[]
  185.                       ys=1;                             //ys=1,表示运算符有了
  186.                     }
  187.            }
  188.         }else{                                    //按下的是等号键
  189.            i=0;                                   //变量初始化,准备下次运算
  190.                  xs=0;
  191.                  ys=0;
  192.          }
  193. }

  195. /*********************************************************************************************
  196. *功能：结构体数据初始化
  197. 目的：结构体数据和计算结果存储数组初始化,为下次运算准备。
  198. *********************************************************************************************/
  199. void Jiegou_Csh(void)
  200. {
  201. //---------初始化结构体数据和计算结果存储数组---------       
  202.   u8 i;                               //定义变量i
  203.         shushu1.zscd=0;              //前数整数个数置零
  204.         shushu1.sscd=0;              //前数小数个数置零
  205.         shushu2.zscd=0;              //后数整数个数置零
  206.         shushu2.sscd=0;              //后数小数个数置零
  207.         for(i=0;i<14;i++){           //循环14次  
  208.                 shushu1.shujuabc[i]=0;     //前数数据清零
  209.                 shushu2.shujuabc[i]=0;     //后数数据清零
  210.                 jshcq[i]=0;                //计算结果存储数组前14位清零
  211.         }
  212.         jshcq[14]=0;                 //计算结果存储数组15位清零
  213.         jshcq[15]=0;                 //计算结果存储数组16位清零
  214. }

  216. /********************************************************************************************************************
  217. *功能：运算符判断
  218. 目的：以运算符分类处理四则运算。
  219. ********************************************************************************************************************/
  220. u8 Yunsf_Jl(void)
  221. {
  222.         u8 ysf;                                    //ysf用作运算符记录
  223.         if(shushu1.sscd==0){                       //没有小数部分
  224.           ysf=lcdxs[shushu1.zscd];                 //前数的整数部分长度就是运算符在lcdxs[]中的位置
  225.         }else{                                     //有小数部分
  226.            ysf=lcdxs[shushu1.zscd+shushu1.sscd+1]; //前数的整数部分加前数的小数部分长度再加小数位就是运算符在lcdxs[]中的位置
  227.          }
  228.         return ysf;                                //返回ysf
  229. }

  231. /**********************************************************************************************************************************************************
  232. *功能：乘法函数
  233. **********************************************************************************************************************************************************/
  234. u8 Chengfa(void)
  235. {
  236.         u8 ic=0,jc=0,nc=0,mc=0;                                                            //前数开始运算位,后数开始运算位,计算结果存储位置变量,计算结果存储起始位
  237.         ic=shushu1.zscd+shushu1.sscd-1;                                                    //赋值“前数的的尾位在shushu1.shujuabc[]中的位置”给ic
  238.         jc=shushu2.zscd+shushu2.sscd-1;                                                    //赋值“后数的的尾位在shushu2.shujuabc[]中的位置”给jc
  239.         if(((ic==0)&&(shushu1.shujuabc[ic]==0))||((jc==0)&&(shushu2.shujuabc[jc]==0))){    //前数和后数中至少一个是0
  240.                 jshcq[0]=0;                                                                      //显示计算结果'0'
  241.                 return 0xf0;                                                                     //跳出
  242.         }
  243.         //----------------------------循环0---------------------------------------------------------
  244.         do
  245.         {
  246.           jshcq[nc]+=shushu2.shujuabc[jc]*shushu1.shujuabc[ic];     //存储两数运算结果
  247.           if(jshcq[nc]>9){                                          //两数运算结果是2位数
  248.                         jshcq[nc+1]+=jshcq[nc]/10;                              //高位累加进位
  249.                         jshcq[nc]%=10;                                          //低位取个位
  250.                 }
  251.                 if(ic!=0){                                                //前数数据没取完
  252.                   ic--;                                                   //前数运算位左移
  253.                         nc++;                                                   //运算结果存储位右移
  254.                 }else{                                                    //前数数据取完了
  255.                    if(jc!=0){                                             //后数数据没取完
  256.          ic=shushu1.zscd+shushu1.sscd-1;                      //前数起始位初始值                         
  257.                            jc--;                                                //后数运算位左移
  258.                                  mc++;                                                //存储结果起始位右移
  259.                                  nc=mc;                                                                        //赋值给nc
  260.                          }else{                                                 //后数数据取完了
  261.                                   if(jshcq[nc+1]!=0){                                 //如果计算完有进位
  262.                                           nc++;                                             //相应的nc加一
  263.                                         }
  264.                             break;                                              //跳出循环   <<<====（循环0,出口）
  265.                           }
  266.                  }                 
  267.         }while(1);
  268.         //--------------------------------------------------------------------------------------------
  269.         jc=15;                                          //jc赋值15,作用不同上面
  270.         if((shushu1.sscd!=0)||(shushu2.sscd!=0)){       //前数和后数中至少有一个有小数点
  271.           jc=nc-(shushu1.sscd+shushu2.sscd);            //计算结果总长度(不算小数点)-两个数小数部分长度和。jc是小数点在lcdxs[]中的位置
  272.         }       
  273.         mc=(jc<<4)+nc;                                  //高四位存小数点位,低四位存计算结果长度
  274.   return mc;                                      //带出mc
  275. }

  277. /***************************************************************************************************************************************
  278. *功能：加法函数
  279. ***************************************************************************************************************************************/
  280. u8 Jiafa(void)
  281. {
  282.   u8 ic=0,jc=0,nc=0,mc=0;                        //前数开始运算位,后数开始运算位,计算结果存储位置变量,计算结果存储起始位
  283.         ic=shushu1.zscd+shushu1.sscd-1;                //赋值“前数的的尾位在shushu1.shujuabc[]中的位置”给ic
  284.         jc=shushu2.zscd+shushu2.sscd-1;                //赋值“后数的的尾位在shushu2.shujuabc[]中的位置”给jc
  285.         //-------------------处理前数和后数小数位较长的部分--------------------------
  286.         if(shushu1.sscd>shushu2.sscd){                 //前数的小数部分比后数的小数部分长
  287.                 do
  288.                 {
  289.                         if(ic-shushu1.zscd==jc-shushu2.zscd){      //直到取到小数位一样长后
  290.                           break;                                   //跳出         <<<====（出口）
  291.                         }else{
  292.                                  jshcq[nc]+=shushu1.shujuabc[ic];        //小数位长的直接赋值给jshcq[]
  293.                            nc++;                                   //存储位递加
  294.                                  ic--;                                   //移位取下一位小数位
  295.                          }
  296.                 }while(1);
  297.     mc=shushu1.sscd;                                         //小数点位置计算用到
  298.         }else{
  299.                  if(shushu1.sscd!=shushu2.sscd){             //小数位等长不用处理
  300.                    do
  301.                    {
  302.                            if(ic-shushu1.zscd==jc-shushu2.zscd){   //直到取到小数位一样长后
  303.                              break;                                //跳出         <<<====（出口）
  304.                            }else{
  305.                                           jshcq[nc]+=shushu2.shujuabc[jc];     //小数位长的直接赋值给jshcq[]
  306.                               nc++;                                //存储位递加
  307.                                     jc--;                                //移位取下一位小数位
  308.                             }
  309.                    }while(1);
  310.                  }
  311.                  mc=shushu2.sscd;                            //小数点位置计算用到
  312.          }
  313.         //-------------------处理另一部分--------------------------------------------------
  314.         do
  315.         {
  316.                 jshcq[nc]+=shushu1.shujuabc[ic]+shushu2.shujuabc[jc];    //两数中间部分相加
  317.     if(jshcq[nc]>9){                                         //两数运算结果是2位数
  318.                         jshcq[nc+1]+=jshcq[nc]/10;                             //高位累加进位
  319.                         jshcq[nc]%=10;                                         //低位取个位
  320.                 }               
  321.                 if((ic!=0)&&(jc!=0)){                                    //两个数数据都没取完            
  322.                         nc++;
  323.                         ic--;
  324.                         jc--;
  325.                 }else{
  326.                    if((ic==0)&&(jc==0)){                                 //两个数数据都取完
  327.                            break;                                              //跳出     <<<====（出口）
  328.                          }else{
  329.                             if(ic==0){                                         //前数数据取完
  330.                                                 //-------------------后数整数部分长出的部分处理---------------------------
  331.                                                 do{
  332.                                                         if(jc==0){
  333.                                                                 break;                                       //跳出     <<<====（出口）
  334.                                                         }else{         
  335.                                                            nc++;
  336.                                                                  jc--;
  337.                                                          }
  338.                                                         jshcq[nc]+=shushu2.shujuabc[jc];               //后数整数长的部分再取
  339.                                                         if(jshcq[nc]>9){                               //两数运算结果是2位数
  340.                                   jshcq[nc+1]+=jshcq[nc]/10;                   //高位累加进位
  341.                                   jshcq[nc]%=10;                               //低位取个位
  342.                           }         
  343.                                                 }while(1);
  344.                                                 //------------------------------------------------------------------------
  345.                                         }else{                                             //后数数据取完
  346.                                                  //-------------------前数整数部分长出的部分处理---------------------------
  347.                                                  do{
  348.                                                          if(ic==0){
  349.                                                            break;                                      //跳出     <<<====（出口）
  350.                                                          }else{         
  351.                                                             nc++;
  352.                                                                   ic--;
  353.                                                           }
  354.                                                          jshcq[nc]+=shushu1.shujuabc[ic];              //前数整数长的部分再取
  355.                                                          if(jshcq[nc]>9){                              //两数运算结果是2位数
  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;                                                //计算结果总长度(不算小数点)-小数部分长度。小数点在lcdxs[]中的位置
  373.         }       
  374.         mc=(jc<<4)+nc;                                             //高四位存小数点位,低四位存计算结果长度
  375.   return mc;
  376. }

  378. /******************************************************************************************************************************************
  379. *功能：减法函数
  380. ******************************************************************************************************************************************/
  381. u8 Jianfa(void)
  382. {
  383.   u8 ic=0,jc=0,nc=0,mc=0;
  384.         //-----------------------------比较前数和后数的大小---------------------------------------------------------------------
  385.         if(shushu1.zscd>shushu2.zscd){                                 //前数整数部分比后数整数部分长
  386.           mc=1;                                 //前数比后数大
  387.         }else{
  388.            if(shushu1.zscd!=shushu2.zscd){                            //前数整数部分比后数整数部分短
  389.                    mc=2;                              //后数比前数大
  390.                  }else{                                                     //前数整数部分和后数整数部分一样长
  391.                     do
  392.                                 {
  393.                             if(shushu1.shujuabc[ic]>shushu2.shujuabc[jc]){        //前数高位比后数高位大
  394.                                     mc=1;
  395.                                                 break;                  //跳出
  396.                                   }else{
  397.                                      if(shushu1.shujuabc[ic]!=shushu2.shujuabc[jc]){    //前数高位比后数高位小
  398.                                              mc=2;
  399.                                                          break;               //跳出
  400.                                            }else{                                             //前数高位和后数高位一样大
  401.                                               if((ic!=shushu1.zscd+shushu1.sscd-1)&&(jc!=shushu2.zscd+shushu2.sscd-1)){       //前数和后数数据都没有取完
  402.                               ic++;
  403.                                                                         jc++;
  404.                                                                 }else{                                         
  405.                                                                    if((ic==shushu1.zscd+shushu1.sscd-1)&&(jc==shushu2.zscd+shushu2.sscd-1)){    //前数和后数数据都取完
  406.                                                                            mc=0;          //前数和后数一样大
  407.                                                                                  break;         //跳出
  408.                                                                          }else{
  409.                                                                             if(ic==shushu1.zscd+shushu1.sscd-1){      //前数数据取完,后数没取完
  410.                                                                                           mc=2;
  411.                                                                                                 break;                        //跳出                                                               
  412.                                                                                         }else{                                    //后数数据取完,前数没取完
  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;                                                   //显示计算结果'0'
  430.                         break;
  431.                 case 1:     //与下面mc=2是一样的,下面备注详细点
  432.                         if(shushu1.sscd>=shushu2.sscd){                               //前数不比后数小数部分短
  433.                           do
  434.                                 {
  435.                                         if(ic-shushu1.zscd==jc-shushu2.zscd){                     //直到取到小数位一样长后                     
  436.                                                 break;                                                  //跳出
  437.                             }else{
  438.                                      jshcq[nc]=shushu1.shujuabc[ic];                        //小数位长的直接赋值给jshcq[]
  439.                                nc++;                                                  //存储位递加
  440.                                      ic--;                                                  //移位取下一位小数位
  441.                              }
  442.                                  }while(1);                       
  443.                   }else{                                                        //前数比后数小数部分短
  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){                    //直到取到小数位一样长后                     
  451.                                                  break;                                                 //跳出
  452.                              }else{
  453.                                       jshcq[nc]=9-shushu2.shujuabc[jc];
  454.                                 nc++;                                                 //存储位递加
  455.                                       jc--;                                                 //移位取下一位小数位
  456.                               }
  457.                                  }while(1);                                         
  458.                          }                 
  459.                         do
  460.                         {
  461.                                 if(shushu1.shujuabc[ic]>=shushu2.shujuabc[jc]){             //前数不比后数小
  462.                                         jshcq[nc]+=shushu1.shujuabc[ic]-shushu2.shujuabc[jc];     //前数-后数
  463.                                         if(jc==0){                                                //后数取完了                                             
  464.                                                 do
  465.                                                 {
  466.               if(ic!=0){                                            //前数没取完
  467.                                                           nc++;                  
  468.                                                                 ic--;       
  469.                                                         }else{
  470.                                                                  break;
  471.                                                          }       
  472.               jshcq[nc]+=shushu1.shujuabc[ic];                                                        
  473.                                                 }while(1);       
  474.                                                 break;                                                  //前数取完跳出循环                                                                               
  475.                                         }else{
  476.                                                  ic--;
  477.                                                  jc--;
  478.                                                  nc++;
  479.                                          }
  480.                                 }else{                                                      //前数比后数小
  481.                                          shushu1.shujuabc[ic]+=10;                                //加10
  482.                                          if(shushu1.shujuabc[ic-1]!=0){                           //当前运算前数的前一位不等于0
  483.                                                  shushu1.shujuabc[ic-1]--;                              //减一位
  484.                                                  
  485.                                          }else{                                                   //当前运算前数的前一位等于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){                               //后数不比前数小数部分短  <<<=====（分情况实现）
  505.                           //---------------------------------------------------------------------------------------------------
  506.                                 do
  507.                                 {
  508.                                         if(ic-shushu1.zscd==jc-shushu2.zscd){                     //直到取到小数位一样长后        <<<=====（目的）     
  509.                                                 break;                                                  //跳出
  510.                             }else{
  511.                                      jshcq[nc]=shushu2.shujuabc[jc];                        //小数位长的直接赋值给jshcq[]
  512.                                nc++;                                                  //存储位递加
  513.                                      jc--;                                                  //移位取下一位小数位
  514.                              }
  515.                                  }while(1);                       
  516.                                 //---------------------------------------------------------------------------------------------------
  517.                   }else{                                                        //后数比前数小数部分短
  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){                    //直到取到小数位一样长后        <<<=====（目的）             
  526.                                                  break;                                                 //跳出
  527.                              }else{
  528.                                       jshcq[nc]=9-shushu1.shujuabc[ic];
  529.                                 nc++;                                                 //存储位递加
  530.                                       ic--;                                                 //移位取下一位小数位
  531.                               }
  532.                                  }while(1);       
  533.          //--------------------------------------------------------------------------------------------------                                 
  534.                          }
  535.       //-----------------------------循环0-------------------------------------------------------------------                       
  536.                         do
  537.                         {
  538.                                 if(shushu2.shujuabc[jc]>=shushu1.shujuabc[ic]){             //后数不比前数小
  539.                                         jshcq[nc]+=shushu2.shujuabc[jc]-shushu1.shujuabc[ic];     //后数-前数
  540.                                         if(ic==0){                                                //前数取完了                                         
  541.                                                 //------------------------循环2-----------------------------------------------------
  542.                                                 do
  543.                                                 {
  544.               if(jc!=0){                                            //后数没取完
  545.                                                                 nc++;                  
  546.                                                                 jc--;                  
  547.                                                         }else{                                                //后数取完了           
  548.                                                                  break;                                             //跳出  <<<====（循环2,出口）
  549.                                                          }
  550.                jshcq[nc]+=shushu2.shujuabc[jc];                                                                
  551.                                           }while(1);
  552.             //----------------------------------------------------------------------------------                                       
  553.                                                 nc++;
  554.                                                 jshcq[nc]='-'-0x30;                                                        //负号先记上
  555.                                                 break;                                                  //后数取完跳出循环   <<<=====（循环0,出口）                                                                               
  556.                                         }else{
  557.                                                  ic--;
  558.                                                  jc--;
  559.                                                  nc++;
  560.                                          }
  561.                                 }else{                                                      //后数比前数小
  562.                                          shushu2.shujuabc[jc]+=10;                                //加10
  563.                                          if(shushu2.shujuabc[jc-1]!=0){                           //当前运算后数的前一位不等于0
  564.                                                  shushu2.shujuabc[jc-1]--;                              //减一位
  565.                                                  
  566.                                          }else{                                                   //当前运算后数的前一位等于0
  567.                                                         //-------------------------------循环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]--;                                                                                            //不够减,高位要         <<<=====（循环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){                 //没有多余变量可以利用,只能再判断一次小数部分长短
  592.           mc=shushu1.sscd;
  593.         }else{
  594.            mc=shushu2.sscd;
  595.          }
  596.         if((shushu1.sscd!=0)||(shushu2.sscd!=0)){
  597.           jc=nc-mc;                                     //计算结果总长度(不算小数点)-小数部分长度。小数点在lcdxs[]中的位置
  598.         }       
  599.         mc=(jc<<4)+nc;                                  //高四位存小数点位,低四位存计算结果长度
  600.   return mc;
  601. }

  603. /*********************************************************************************************************
  604. *功能：除法函数
  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)){   //后数是0的情况,不进行运算
  611.                 Lcd_qinpin();                                                       //LCD显示数组清零
  612.                 lcdxs[0]='x';                                                       //无法计算结果
  613.                 return 0xff;
  614.         }
  615.         if((shushu1.shujuabc[0]==0)&&(shushu1.zscd==1)&&(shushu1.sscd==0)){   //前数是0的情况
  616.                 Lcd_qinpin();                                                       //LCD显示数组清零,准备存储计算结果
  617.                 lcdxs[0]='0';                                                       //计算结果是0
  618.                 return 0xff;
  619.         }
  620.         //--------------------------------------------------------------------------------------------------------
  621.         while(shushu1.shujuabc[ic]==0){             //前数是0的位不用运算   
  622.           ic++;
  623.         }
  624.         while(shushu2.shujuabc[jc]==0){             //后数是0的位不用运算   
  625.           jc++;
  626.         }
  627.         xc=shushu2.zscd-shushu1.zscd+ic-jc+15;      //小数点位置
  628.         mc=jc<<4;                                   //当前jc值存入mc高四位,jc最大13,4位足以存储
  629.         //---------------------------------大循环0号,直到计算出16位计算结果才跳出------------------------------------------------
  630.         do
  631.         {               
  632.                 mc&=0xf0;                                          //清除低四位
  633.                 mc|=ic;                                            //记录ic的值,存入mc低四位 （关键点：mc之前的数据一定是0）
  634.                 if(nc!=16){                                        //计算结果没满16位
  635.                         if((mc&0x0f)>=14-shushu2.zscd-shushu2.sscd){     //“前数截取部分的长度首位置之后的剩余的长度”不会比“后数的长度”长
  636.                     //----------------------------------循环1号,为了能计算出足有16位的结果----------------------------------------------
  637.                                 jc=0;                                          //这里jc的作用是一个起始值为0的变量
  638.                     do
  639.                     {
  640.                       shushu1.shujuabc[jc]=shushu1.shujuabc[ic];   //将剩余的有效数字重新以shushu1.shujuabc[0]为起始顺序存储
  641.                             shushu1.shujuabc[ic]=0;                      //清除
  642.                             if(ic==13){                                  //数据重存完
  643.                               break;                                     //跳出
  644.                             }else{                                       //继续转存有效数据
  645.                                jc++;
  646.                                      ic++;
  647.                              }
  648.                     }while(1);
  649.                     ic=0;                                          //相应的变量值也将改变,实现一个14位数据的数组当一个28位数据的数组使用    <<<====（循环1号,目的）
  650.                     mc&=0xf0;                                      //清除低四位,mc低四位清零,同步ic值
  651.                     jc=mc>>4;                                      //jc恢复初始值
  652.                                 //-----------------------------------------------------------------------------------------------------------------
  653.                         }
  654.           }else{                           //得到16位计算结果                                                                         <<<====（大循环0号,目的）
  655.              break;                        //跳出
  656.            }
  657.                 //-----------------------循环2号,截取前数(可减后数,即必须比后数大)部分-------------------------------------------------------------------------------
  658.           do
  659.           {
  660.                   if(shushu1.shujuabc[ic]>shushu2.shujuabc[jc]){         //从高位开始比较  
  661.         ic=(mc&0x0f)+shushu2.zscd+shushu2.sscd-1;                         //前数截取长度和后数等长
  662.                           break;              //跳出（大的时候会跳出）                                                                 <<<====（出口1）
  663.                   }else{
  664.                            if(shushu1.shujuabc[ic]!=shushu2.shujuabc[jc]){     //前数比后数小                         
  665.                                    if(shushu1.shujuabc[ic]!=0){                      //该位不是0,前数截取长度比后数多1位肯定比后数大
  666.                                      ic=(mc&0x0f)+shushu2.zscd+shushu2.sscd;         //前数截取比后数多1位数
  667.                                                  if(!(gc&0x80)){                                 //gc最高位是0,在gc最高位是1的情况下nc不能加加
  668.                                                    nc++;                                         //计算结果位置移位
  669.                                                          gc|=0x80;                                     //最高位置1,表示前数截取部分比后数长1位数
  670.                                                  }                                                 
  671.                                    }else{                                            //该位是0
  672.                                                   if(ic==mc){                                    //0是前数截取部分第一位
  673.                                                                 ic++;                                        //判断位移位
  674.                                                     mc++;                                        //mc低四位加一同步ic
  675.                                               jc=mc>>4;                                    //后数回到起始位置
  676.                                                     gc&=0x7f;                                    //高位置0,表示
  677.                                               gc|=0x01;                                    //gc最低位作为这一情况的标志,表示不用运算
  678.                                                                 nc++;
  679.                                                         }else{                                         //0是前数截取部分非首位,首位肯定不是0,这种情况是前数截取部分减了后数若干次后的结果小于后数了
  680.                                                            ic=(mc&0x0f)+shushu2.zscd+shushu2.sscd;     //前数截取比后数多1位数
  681.                                                                  if(!(gc&0x80)){                             //gc最高位是0,在gc最高位是1的情况下nc不能加加,比如,4480-452=4028,4028-452这种情况nc不能加
  682.                                                        nc++;                                     //计算结果位置移位
  683.                                                              gc|=0x80;                                 //最高位置1,表示前数截取部分比后数长1位数
  684.                                                      }                       
  685.                                                          }
  686.                                     }       
  687.             break;                                         //跳出（小的时候跳出）                                                                   <<<====（出口2）
  688.                      }else{                                              //前数和后数高位一样大
  689.                                     if(jc!=shushu2.zscd+shushu2.sscd-1){             //后数数据没有取完,继续下位比较
  690.                           ic++;
  691.                                             jc++;
  692.                                     }else{                                           //前数和后数一样大
  693.                                                    ic=(mc&0x0f)+shushu2.zscd+shushu2.sscd-1;                 //前数截取长度和后数等长
  694.                break;                                 //跳出（相等的时候跳出）                                                                 <<<====（出口3）
  695.                                      }                                                       
  696.                             }
  697.              }
  698.     }while(1);       
  699.     //----------------------------------------------------------------------------------------------------------------------------------------------------               
  700.           if(!(gc&0x01)){                                                 //gc最低位是1的时候,不进行运算
  701.             jc=shushu2.zscd+shushu2.sscd-1;                               //后数尾数开始运算
  702.             //------------------------------------循环3号,前数截取部分-后数,求得可减次数,化除法为减法----------------------------------------------
  703.             do
  704.                         {
  705.                     if(shushu1.shujuabc[ic]>=shushu2.shujuabc[jc]){             //前数不比后数小                                          
  706.                             shushu1.shujuabc[ic]-=shushu2.shujuabc[jc];               //前数-后数
  707.                             if(jc==mc>>4){                                            //后数取完了
  708.                                                 if(ic!=(mc&0x0f)){                                      //前数截取部分没取完       
  709.                                                   if(shushu1.shujuabc[ic-1]==0){                        //前数多的一位是0
  710.                                                           gc&=0x7f;                                           //最高位置0,表示如果减后的前数截取部分长度比后数小的话,存储位置nc需要加加
  711.                                                         }else{                                                //这里说明肯定比后数还大,存储位置nc不能移位
  712.                                                            ic--;
  713.                                                         }                                                               
  714.                                                 }         
  715.                                     break;                        //跳出循环                                           <<<====（循环3号,出口）                                                                       
  716.                             }else{
  717.                                      ic--;
  718.                                      jc--;
  719.                              }
  720.                     }else{                                                      //前数比后数小
  721.           //----------------------------------只进行数据改变,不运算-----------------------------------------------------------
  722.                             shushu1.shujuabc[ic]+=10;                                 //加10
  723.                                         if(shushu1.shujuabc[ic-1]!=0){                            //当前运算前数的前一位不等于0
  724.                                      shushu1.shujuabc[ic-1]--;                              //减一位
  725.                              }else{                                                   //当前运算前数的前一位等于0
  726.                                             //-----------------------------循环4号,寻找可借位高位-----------------------------------------------------------
  727.                                                   gc|=ic;                                               //gc这里的作用是保存当前ic的值,ic最大值13,用gc的低四位足够
  728.                                             ic--;
  729.                                             do
  730.                                       {                                                                    
  731.                                                     shushu1.shujuabc[ic]=9;                             //0位置9
  732.                                                     if(shushu1.shujuabc[ic-1]!=0){                      //找可以减的位    <<<====（循环4号,目的）
  733.                                                       shushu1.shujuabc[ic-1]--;                                                                                            //减一
  734.                                                             break;                                            //跳出
  735.                                               }else{                                                                                                          //再找
  736.                                                              ic--;                                       
  737.                                                }
  738.                                             }while(1);
  739.               ic=gc&0x7f;                                           //ic恢复原保存值
  740.                     gc&=0x80;                                             //保留最高位,清除其他位                                           
  741.               //--------------------------------------------------------------------------------------------------------------                                               
  742.                                     }
  743.                                          //-----------------------------------------------------------------------------------------------------------------
  744.                      }                                                       
  745.             }while(1);
  746.                         //------------------------------------------------------------------------------------------------------------------------------------
  747.             jshcq[nc]++;                                                  //前数截取部分和后数减一次,计算结果累加一次                       
  748.           }
  749.                 gc&=0x80;                                                       //最高位不变,其他位清零
  750.         }while(1);
  751.         //-------------------------------------------------------------------------------------------------------------------------
  752.         Lcd_qinpin();                          //LCD显示数组清零,准备存储计算结果
  753.         jc=0;
  754.         gc=0;
  755.         //-------------------计算结果和显示转换--------------------------
  756.         if(xc<16){
  757.                 //-----计算结果大于等于1（还有0.几的情况在内）-----------------
  758.           nc=16-xc;
  759.                 //-------------------计算结果数据处理--------------------------
  760.                 if(jshcq[0]==0&&nc!=1){              //计算结果首位数字是0,并且不是0.
  761.                   jc++;                              //起始数据位置加一
  762.                         nc--;                              //小数点位置同步
  763.                 }
  764.                 //-------------------存入显示数组------------------------------
  765.                 for(ic=0;ic<16;ic++){                //计算结果转换为显示数据
  766.                         if(ic==nc){                        //小数点位置
  767.                           lcdxs[ic]='.';
  768.                         }else{                             //数字位置
  769.                            lcdxs[ic]=jshcq[jc]+0x30;
  770.                      jc++;
  771.                          }  
  772.     }
  773.                 //---------删除计算结果后面无效的0----------------------------
  774.                 ic=15;
  775.                 do
  776.                 {
  777.                   if(lcdxs[ic]=='0'||lcdxs[ic]=='.'){   //这里存在一种情况,如果一个计算结果是无理数并且显示尾部是0,那么0也会被不显示,这虽然不是想要的结果,但还可以接受
  778.                     lcdxs[ic]=' ';
  779.                                 ic--;
  780.                   }else{
  781.                            break;
  782.                          }
  783.                 }while(1);
  784.         //---------------------------------------------------------------
  785.         }else{                                
  786.                  //-------------------计算结果小于1-------------------------------------------
  787.            nc=xc-14;          
  788.      //------------计算结果小于等于0.001采用科学计数法----------------------------
  789.                  if((nc==4&&jshcq[0]==0)||nc>4){   
  790.                          if(jshcq[0]!=0){                   //没算小数点的计算结果首位不是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.        //-------------------存入显示数组------------------------------------------                 
  810.                    for(ic=0;ic<14;ic++){              //计算结果转换为显示数据
  811.                            if(lcdxs[ic]==' '){              //lcdxs[]没有赋值
  812.                                    lcdxs[ic]=jshcq[jc]+0x30;
  813.                        jc++;
  814.                                          if(lcdxs[ic]!='0'){            //lcdxs[]只要有一位数不是0,gc就赋值1
  815.                                            gc=1;                                                  
  816.                                          }
  817.                                  }                  
  818.                          }
  819.                          //-----------------------特殊情况------------------------------------------
  820.        if(gc==0){                                //全是0,表示计算结果无效
  821.                            Lcd_qinpin();
  822.                                  lcdxs[0]='x';                           //显示x,表示计算不出来,当计算结果小于1/9999999999999时
  823.                          }else{
  824.                             do
  825.                       {
  826.                         if(lcdxs[mc]=='0'||lcdxs[mc]=='.'){  //这里存在一种情况,如果一个计算结果是无理数并且显示尾部是0,那么0也会被不显示,这虽然不是想要的结果,但还可以接受,比如,计算结果9.99000999000e-4会显示9.99000999e-4
  827.                           lcdxs[mc]=' ';
  828.                                       mc--;
  829.                         }else{
  830.                                  break;
  831.                                }
  832.                       }while(1);
  833.                           }       
  834.      //----------------------------------------------------------------------------                 
  835.                  }else{       
  836.         //------------计算结果大于0.001-----------------------------------------                         
  837.                     for(ic=0;ic<16;ic++){                    //0和小数点部分
  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]=='.'){    //这里存在一种情况,如果一个计算结果是无理数并且显示尾部是0,那么0也会被不显示,这虽然不是想要的结果,但还可以接受
  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种算法需执行的程序
  891.           Lcd_qinpin();                            //LCD显示数组清零,准备存储计算结果
  892.           do
  893.                 {
  894.                         lcdxs[u]=jshcq[yun%16]+0x30;           //计算结果存储数组中的数据以字符形式放入LCD显示数组
  895.                         if(yun%16!=0){
  896.                                 if(u==yun/16){                       //小数位处理
  897.                                         u++;
  898.                                         lcdxs[u]='.';
  899.                                 }                               
  900.                                 yun--;                               //jshcq[]存放形式低位到高位
  901.                                 u++;                                 //lcdxs[]存放形式高位到低位
  902.                         }else{                                 //跳出循坏条件：数据取完
  903.                                 break;
  904.                         }
  905.                 }while(1);
  906.                 //--------------去掉计算结果后面没用的0---------------------------比如,34.00
  907.                 if(yun/16!=15){                       //有小数点时
  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'数字字符跳出                                           
  917.                                  }
  918.         u--;                                                //移位,判断下一位
  919.                   }while(1);
  920.           }
  921.                 //-----------去掉计算结果前面没用的0------------------------------比如,00.34
  922.                 u=0;                              
  923.                 do
  924.                 {
  925.                         if(lcdxs[u]=='0'){           
  926.                                 if(lcdxs[u+1]=='.'){      
  927.                                         break;                      //当计算结果是'0''.'的时候,跳出循环
  928.                                 }else{
  929.                                          if(lcdxs[u+1]==' '){       //计算结果是'0'的时候
  930.                                                  break;
  931.                                    }
  932.                              lcdxs[u]=' ';              //如果'0'后面没跟'.'
  933.                                    u++;                       //移位,准备下一位判断
  934.                            }                 
  935.                   }else{
  936.                            if(lcdxs[u]!='-'){           
  937.                              break;                     //碰到不是'-',跳出循环
  938.                            }else{
  939.                               u++;
  940.                             }
  941.                    }
  942.           }while(1);
  943.         }  
  944. }
复制代码

小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表