设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 基于51单片机的多功能计算机程序与Proteus仿真图设计
返回列表 发新帖
查看: 1755|回复: 2
收起左侧

基于51单片机的多功能计算机程序与Proteus仿真图设计

[复制链接]
ID:398204 发表于 2022-5-9 19:40 | 显示全部楼层 |阅读模式
资料包括：
1.Proteus仿真文件，Proteus软件版本为8.9
2.程序源代码，C语言编译器为keilv4
3.实现的功能：
   主要是计算器的基本功能和科学计算器许多功能，用最少的按键实现最多的计算功能，包括三角函数、指数、开根号以及天文数字、角度转换的运算，此外还带有记忆功能。
   系统用20个按键实现这些功能。
仿真原理图如下（proteus仿真工程文件可到本帖附件中下载）
51hei.gif
仿真截图.png

单片机源程序如下:
  1. #include<reg52.h>
  2. #include<stdlib.h>//包含atof(),字符串->实数
  3. #include<stdio.h>
  4. #include<string.h>
  5. #include<math.h>
  6. #define uchar unsigned char
  7. #define uint unsigned int
  8. uchar num;
  9. /**********LCD*********/
  10. sbit lcdrs=P3^7;   //LCD控制脚
  11. sbit lcdrw=P3^6;
  12. sbit lcden=P3^5;
  13. sbit beep=P0^7;

  15. bit form;  //LCD切换方式
  16. uchar idata state;
  17. /********计算器*******/
  18. sbit reset=P3^0;
  19. sbit back=P3^1;
  20. sbit save=P3^2;
  21. sbit sfyong=P3^3;
  22. bit eqsign;
  23. bit press;
  24. bit savesign;
  25. bit sc;

  27. uchar idata process[30],proc;
  28. uchar idata continu=0;
  29. uchar idata pai[2][2];
  30. uchar idata ferror;
  31. uchar idata ywei;
  32. uchar idata count=0;
  33. uchar idata count_num=0;//组号计数
  34. uchar idata result[15];//计算结果立存，save
  35. uchar idata saveresult[15];//存储结果数组,sc+save
  36. uchar idata jieguo[15];//结果字符串
  37. uchar idata bdate[2][14];//待计算字符串二维组
  38. uchar idata on_symbol; //运算符号
  39. uchar idata fsym[2];     //函数前符号
  40. uchar idata ssym[2];  //存储组前符号
  41. uchar idata bfun[2];   //计算值调用函数选择
  42. uchar idata futojiao[2];  //幅度?to?角度变换
  43. double idata date[2];    //计算值双精度变量组
  44. double idata resultdate;    //双精度结果值
  45. /*******************函数声明******************/

  47. /****************延时******************/
  48. void delay(uchar z);
  49. /*************lcd写命令***************/  
  50. void write_com(uchar com);
  51. /*************lcd写数据***************/  
  52. void write_date(uchar date);
  53. /*************lcd读状态***************/  
  54. void read_date(void);
  55. /*************lcd写字符串*************/  
  56. void write_str(uchar *str);
  57. /************液晶初始化***************/  
  58. void init(void );   
  59. /**********移屏*******************/  
  60. void write();
  61. /**********复用提示开关***************/  
  62. void shift(void);
  63. /**************键盘扫描***************/  
  64. uchar keyscan(void);
  65. /*************计算器复位**************/  
  66. void fuwei();
  67. /************error处理****************/  
  68. void callerror(void);
  69. /***************撤销键入**************/  
  70. void huifu(void);
  71. /**********函数组前符号处理***********/  
  72. uchar funqian(void);
  73. /************运算符预处理*************/  
  74. void  cullars(uchar);
  75. /***********输出存储数据预处理********/  
  76. char  memory(void);
  77. /***********按键功能主处理************/  
  78. void process_date(uchar press_date);
  79. /***********按键功能子处理************/  
  80. void calculator(uchar press_date);  
  81. /************************************************/  
  82. void write()  
  83. {     
  84.      for(num=0;num<16;num++)        
  85.         {         
  86.             write_com(0x18);         
  87.             delay(200);        
  88.         }  
  89. }
  90. /*************LCD程序****************/

  92. /**************延时******************/  
  93. void delay(uchar z)        
  94. {        
  95.     uchar  x,y;        
  96.     for(x=z;x>0;x--)        
  97.     for(y=100;y>0;y--);  
  98. }   

  100. /**************写命令*****************/  
  101. void write_com(uchar com)  
  102. {        
  103.     lcdrs=0;        
  104.     lcdrw=0;        
  105.     lcden=0;        
  106.     P1=com;        
  107.     delay(5);        
  108.     lcden=1;        
  109.     delay(5);        
  110.     lcden=0;  
  111. }
  112.    
  113. /*************写数据******************/  
  114. void write_date(uchar date)  
  115. {        
  116.     lcdrs=1;        
  117.     lcdrw=0;        
  118.     lcden=0;        
  119.     P1=date;        
  120.     delay(5);        
  121.     lcden=1;        
  122.     delay(5);        
  123.     lcden=0;  
  124. }
  125. /*************读AC 地址*****************/  
  126. void read_date(void)  
  127. {        
  128.     lcdrs=0;        
  129.     lcdrw=1;     
  130.     delay(5);     
  131.     P1=0xff;        
  132.     lcden=1;        
  133.     delay(5);        
  134.     state=P1;        
  135.     delay(5);        
  136.     lcden=0;delay(5);     
  137.     state=state&127;  
  138. }

  140. /*************写字符串******************/  
  141. void write_str(uchar *str)  
  142. {        
  143.     uchar idata i;        
  144.     for(i=0;str[i]!='\0';i++)           
  145.     write_date(str[i]);  
  146. }
  147. /***********液晶初始化***************/  
  148. void init(void )  
  149. {
  150.     write_com(0x38);  //模式：8位数据，两行，5*7字体
  151.     write_com(0x0c); //开显示，无光标
  152.     write_com(0x06);//向左增量移动
  153.     write_com(0x01);       //清屏  
  154. }   
  155. /**********复用提示开关***************/  
  156. void shift(void)  
  157. {     
  158.     if(sc==1)     
  159.     {        
  160.         read_date();   //读状态        
  161.         write_com(0xc0); //显示复用提示，左下角's'     
  162.         write_date('s');     
  163.         write_com(state+0x80);//光标还回原来位置
  164.     }   
  165.     else   
  166.     {        
  167.     read_date();        
  168.     write_com(0xc0);    //关闭复用提示     
  169.     write_date(' ');     
  170.     write_com(state+0x80);   
  171.     }   
  172.     return;  
  173. }   
  174. /**************键盘扫描*************/

  176. //  s1~s4   .    0    =    +
  177. //  s5~8    1    2    3    -
  178. //    s9~s12  4    5    6    *
  179. //  s13~s16 7    8    9    /
  180. //    k1~k4   C    DEL  M=   FS&S
  181. //
  182. uchar keyscan(void)          //按行扫描，有键按下则返回键符号，否则返回null  
  183. {     
  184.     uchar idata key0,key1,keyment=0;        
  185.     P2=0XFe;        //行1        
  186.     key0=P2;        
  187.     key0=key0&0xf0;        
  188.     key1=key0;        
  189.     if(key0!=0xf0)        
  190.     {
  191.         delay(5);               //键抖动处理
  192.         P2=0XFe;            
  193.         key0=P2;            
  194.         key0=key0&0xf0;            
  195.         if(key0==key1)            
  196.         {
  197.             beep=1;
  198.             delay(200);
  199.             beep=0;                  
  200.             switch(key0)                  
  201.             {                    
  202.                 case 0xe0:keyment='7';break;
  203.                 case 0xd0:keyment='8';break;
  204.                 case 0xb0:keyment='9';break;
  205.                 case 0x70:keyment=0xfd;break;  //0xfd除号在1602液晶中的代码                  
  206.             }
  207.             while(key0!=0xf0)  //键释放处理  
  208.             {                    
  209.             key0=P2;                    
  210.             key0=key0&0xf0;                  
  211.             }                  
  212.             press=1;     //键按标志置1   
  213.             return(keyment);            
  214.         }        
  215.     }        
  216.     P2=0XFd;       //行2        
  217.     key0=P2;        
  218.     key0=key0&0xf0;        
  219.     key1=key0;        
  220.     if(key0!=0xf0)        
  221.     {            
  222.         delay(5);            
  223.         P2=0XFd;            
  224.         key0=P2;            
  225.         key0=key0&0xf0;            
  226.         if(key0==key1)            
  227.         {   
  228.             beep=1;
  229.             delay(200);
  230.             beep=0;              
  231.             switch(key0)                 
  232.             {                    
  233.                 case 0xe0:keyment='4';break;
  234.                 case 0xd0:keyment='5';break;
  235.                 case 0xb0:keyment='6';break;  
  236.                 case 0x70:keyment='*';break;
  237.             }                 
  238.             while(key0!=0xf0)              
  239.             {                    
  240.             key0=P2;                    
  241.             key0=key0&0xf0;
  242.             }
  243.             press=1;                 
  244.             return(keyment);            
  245.         }        
  246.     }        
  247.     P2=0XFb;       //行3        
  248.     key0=P2;        
  249.     key0=key0&0xf0;        
  250.     key1=key0;        
  251.     if(key0!=0xf0)        
  252.     {            
  253.         delay(5);            
  254.         P2=0XFb;            
  255.         key0=P2;            
  256.         key0=key0&0xf0;            
  257.         if(key0==key1)            
  258.         {   
  259.             beep=1;
  260.             delay(200);
  261.             beep=0;              
  262.             switch(key0)                 
  263.             {                    
  264.                 case 0xe0:keyment='1';break;
  265.                 case 0xd0:keyment='2';break;  
  266.                 case 0xb0:keyment='3';break;
  267.                 case 0x70:keyment='-';break;
  268.             }                 
  269.             while(key0!=0xf0)               
  270.             {                     
  271.             key0=P2;                     
  272.             key0=key0&0xf0;                 
  273.             }                 
  274.             press=1;                 
  275.             return(keyment) ;            
  276.         }        
  277.     }        
  278.     P2=0XF7;       //行4        
  279.     key0=P2;        
  280.     key0=key0&0xf0;        
  281.     key1=key0;        
  282.     if(key0!=0xf0)        
  283.     {   
  284.         beep=1;
  285.         delay(200);
  286.         beep=0;           
  287.         delay(5);            
  288.         P2=0XF7;            
  289.         key0=P2;            
  290.         key0=key0&0xf0;            
  291.         if(key0==key1)            
  292.         {   
  293.             switch(key0)                 
  294.             {                  
  295.                 case 0xe0:keyment='.';break;   
  296.                 case 0xd0:keyment='0';break;                  
  297.                 case 0xb0:keyment='=';break;                  
  298.                 case 0x70:keyment='+';break;                 
  299.             }                 
  300.             while(key0!=0xf0)                 
  301.             {                  
  302.             key0=P2;                  
  303.             key0=key0&0xf0;                 
  304.             }                 
  305.             press=1;                 
  306.             return(keyment);            
  307.         }      
  308.     }
  309.     if(reset==0)          //复位键         
  310.         {   
  311.             beep=1;
  312.             delay(200);
  313.             beep=0;               
  314.             keyment=' ';            
  315.             press=1;
  316.             while(reset==0);//键释放            
  317.             return(keyment);   
  318.         }      
  319.     else if(back==0)        //撤销前次输入
  320.         {   
  321.             beep=1;
  322.             delay(200);
  323.             beep=0;   
  324.             keyment='c';            
  325.             press=1;            
  326.             while(back==0);            
  327.             shift();            
  328.             return(keyment);   
  329.         }      
  330.     else  if(save==0)     //储存数据键           
  331.         {      
  332.             delay(5);      
  333.             if(save==0)      
  334.             {
  335.                 beep=1;
  336.                 delay(200);
  337.                 beep=0;
  338.                 if(sc==0)    //输出前次计算结果键   
  339.                 {         
  340.                     keyment='m';               
  341.                     press=1;               
  342.                     while(save==0);               
  343.                     return(keyment);      
  344.                 }      
  345.                 else      //更新存储的数据或输出存储的数据
  346.                 {               
  347.                     keyment='n';               
  348.                     press=1;
  349.                     sc=0;      
  350.                     shift();               
  351.                     while(save==0);         
  352.                     return(keyment);      
  353.                 }   
  354.             }      
  355.         }
  356.         else if(sfyong==0)     //计算器时为复用功能键      
  357.         {               
  358.             delay(5);      
  359.             if(sfyong==0)      
  360.             {  
  361.                 beep=1;
  362.                 delay(200);
  363.                 beep=0;
  364.                 keyment='h';              
  365.                 press=1;              
  366.                 while(sfyong==0);         
  367.                 return(keyment);     
  368.             }return(0);      
  369.         }else return(0);    //无键按下返回null
  370.         return(0);
  371. }

  373.    
  374. /**************计算器复位****************/  
  375. void fuwei()  
  376. {   
  377.     uchar idata j,i;      
  378.     write_com(0x0f);     //lcd设置      
  379.     write_com(0x01);      
  380.     write_com(0x80);      
  381.     resultdate=0;      
  382.     for(i=0;i<2;i++)   
  383.     {
  384.         date[i]=0;bfun[i]=0;pai[0][i]=0;pai[1][i]=0;fsym[i]=0;futojiao[i]=0; //各标志置 0     
  385.         for(j=0;j<14;j++)  //字符数组初始化  
  386.         {         
  387.             bdate[i][j]='\0';        
  388.         }   
  389.     }      
  390.     count=0;    //各标志置0      
  391.     count_num=0;   
  392.     proc=0;      
  393.     ferror=0;      
  394.     eqsign=0;   
  395.     sc=0;   
  396.     savesign=0;   
  397.     ywei=0;   
  398.     press=0;   
  399.     on_symbol=0;  
  400. }

  402.   
  403. /**************error处理******************/
  404. void callerror(void)  
  405. {   
  406.     uchar idata i;      
  407.     write_com(0x01);      
  408.     write_com(0x80);      
  409.     write_str("     error!     ");
  410.     for(i=0;i<200;i++)
  411.     delay(25); //持续显示 1s  
  412. }
  413. /*************函数组前符号处理************/
  414. uchar funqian(void)    //输入函数前检查是否错误  
  415. {  
  416.     if((bdate[ferror][0]=='+'||bdate[ferror][0]=='-')&&count==1)     
  417.     {      
  418.         fsym[ferror]=bdate[ferror][0];      
  419.         bdate[ferror][0]='\0';   
  420.         bdate[ferror][1]='\0';   
  421.         count=0;     
  422.     }
  423.     if(bdate[ferror][0]!='\0'||bfun[ferror]!=0)//错误输入方式处理     
  424.     {
  425.         callerror();         
  426.         huifu();   
  427.         return(1);     
  428.     }     
  429.     return(0);  
  430. }
  431. /****************撤销上次输入****************/
  432. void huifu(void)  
  433. {      
  434.     uchar j,pro;    //pro变量用于恢复proc
  435.     if(proc!=0)proc--;   
  436.     pro=proc;   
  437.     fuwei();   
  438.     proc=pro;   
  439.     for(j=0;j<proc;j++)calculator(process[j]); //依次恢复之前的操作   
  440.     return;  
  441. }
  442. /*****************运算符预处理*****************/  
  443. void  cullars(uchar csym)  
  444. {
  445.     read_date();     //看第二组是否有输入   
  446.     ferror++;              //检错标志+1   
  447.     continu=csym;     //存储运算符号   
  448.     if(ferror==2&&state<0x43){callerror();huifu();return;}// 第二组无输入且ferror=2，错误   
  449.     if(ferror==2&&state>0x42) //第二组有输入且ferror=2，则进行连续计算   
  450.     {      
  451.         press=1;     //模拟按键'='和'M+'；将本次的计算结果作为下一次计算的第一组
  452.         process_date('=');      
  453.         press=1;      
  454.         process_date('m');      
  455.         ferror=1;    //恢复现场，避免变化      
  456.         if(continu=='^'||continu=='%'){process[proc]='h';
  457.                proc++;process[proc]=continu;proc++;}
  458.         else{process[proc]=continu;proc++;}   //恢复连续计算过程   
  459.     }   
  460.     if(continu=='%'){write_str(" f");}else write_date(' ');
  461.     write_date(continu);//将用与连续计算的运算符号取出   
  462.     ywei=0;   
  463.     savesign=0;   
  464.     count_num=1;     //组标志加1   
  465.     count=0;   //输入计数清零   
  466.     on_symbol=continu;  //运算符号调用   
  467.     write_com(0xc2);   
  468.     return;  
  469. }
  470. /*************输出存储数据预处理************/
  471. char  memory(void)  
  472. {
  473.     if((bdate[count_num][0]=='+'||bdate[count_num][0]=='-')&&count==1)//符号处理      
  474.     {
  475.          ssym[count_num]=bdate[count_num][0];
  476.          bdate[count_num][0]='\0';   
  477.          bdate[count_num][1]='\0';   
  478.          count=0;
  479.     }      
  480.     if(bdate[count_num][0]!='\0'){callerror();huifu();return(1);} //错误输入方式处理   
  481.     return(0);  
  482. }
  483. /**************按键功能主处理****************/
  484. void process_date(uchar press_date)  
  485. {
  486.     if(form==0){write_com(0x0f);form=1;}   //显示方式切换 光标闪烁      
  487.     if(eqsign==1&&press==1)fuwei();  //复位再次计算，记忆过程清零   
  488.     press=0;   
  489.     if(press_date=='c'){huifu();press_date=0;}   
  490.     if(press_date==0)return;          //无按键   
  491.     process[proc]=press_date;   
  492.     proc++;   
  493.     calculator(press_date);   
  494.     return;  
  495. }
  496. /***************按键功能子处理***************/
  497. void calculator(uchar press_date)  
  498. {
  499.     uchar idata j=0;   
  500.     /*************************************/   
  501.     if(press_date==('h'))    //复用键   
  502.     {        
  503.         sc=~sc;     //按键功能切换，sc为1时调用函数     
  504.         shift();     //显示与关闭复用提示   
  505.     }      
  506.     /*************************************/
  507.     else if((press_date<='9'&&press_date>='0')||(press_date=='.')) //数字键处理      
  508.     {
  509.         savesign=0;     //不可更新存储数据         
  510.         if(sc==0)     //是否为复用sc为0，是数字         
  511.         {
  512.             if(count<14-ywei)  //未调用函数时最多输入14位数，包括小数点            
  513.             {            
  514.                 write_date(press_date);
  515.                 bdate[count_num][count]=press_date; //储存键值                     
  516.                 count++;            
  517.             }
  518.             else {callerror();huifu();}  //超出14位出错,恢复
  519.         }
  520.         else switch(press_date)   //复用时         
  521.         {             //     排错   置函数标志符号 复用清零  移位，此时数据只能(14-ywei)位            
  522.             case '7':  j=funqian();if(j==1)return;bfun[ferror]='s';sc=0;shift();ywei=4;write_str("sin ");break; //函数sin            
  523.             case '8':  j=funqian();if(j==1)return;bfun[ferror]='c';sc=0;shift();ywei=4;write_str("cos ");break; //函数cos            
  524.             case '9':  j=funqian();if(j==1)return;bfun[ferror]='t';sc=0;shift();ywei=4;write_str("tan ");break; //函数tan      
  525.             case '4':  j=funqian();if(j==1)return;bfun[ferror]='e';sc=0;shift();ywei=4;write_str("exp ");break; //函数exp      
  526.             case '5':  j=funqian();if(j==1)return;bfun[ferror]='l';sc=0;shift();ywei=3;write_str("ln ");break;  //函数ln      
  527.             case '6':  j=funqian();if(j==1)return;bfun[ferror]='g';sc=0;shift();ywei=3;write_str("Lg ");break;  //函数Lg      
  528.             case '1':  j=funqian();if(j==1)return;bfun[ferror]='q';sc=0;shift();ywei=5;write_str("sqrt ");break;//函数sqrt      
  529.             case '0':  j=funqian();if(j==1)return;bfun[ferror]='d';sc=0;shift();ywei=4;write_str("dao ");break; //函数dao(倒数)
  530.             case '.': if(count==0){ pai[count_num][0]=1;count=14-ywei;     }   //圆周率 pai处理    π前面无加权        
  531.             else{ pai[count_num][1]=1;count=14;}   //  π前面可以有加权，后面不能跟数据        
  532.             write_date(247);sc=0;shift();break;      
  533.     /************************2和3是双参数函数 当运算符使用 *************************/      
  534.             case '2':  //x^y x的y次方        
  535.             cullars('^');   //调用运算符号处理程序        
  536.             sc=0;shift();        
  537.             break;      
  538.             case '3': //A/B的余数（双精度）        
  539.             cullars('%');   //调用运算符号处理程序        
  540.             sc=0;shift();        
  541.             break;           
复制代码

Keil5代码与Proteus8.8仿真下载: 仿真代码.7z (141.67 KB, 下载次数: 28)

评分

参与人数 1黑币 +50 收起 理由
admin + 50 共享资料的黑币奖励！

查看全部评分

回复

使用道具 举报

ID:262 发表于 2022-5-10 23:55 | 显示全部楼层
好资料，51黑有你更精彩!!!
回复

使用道具 举报

ID:398204 发表于 2022-5-15 01:34 | 显示全部楼层
heicad 发表于 2022-5-10 23:55
好资料，51黑有你更精彩!!!

近期会分享很多本科时做的各种仿真，希望和大家一起学习
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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