找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 6503|回复: 4
打印 上一主题 下一主题
收起左侧

51单片机计算器制作 可开根,解方程,算二阶矩阵 已做出实物

  [复制链接]
跳转到指定楼层
楼主
可以常规运算和开根,解方程,和算二阶矩阵,代码挺简单的


Altium Designer画的原理图和PCB图如下:(51hei附件中可下载工程文件)



单片机源程序如下:
  1. #include<reg52.h>
  2. #include<math.h>
  3. typedef unsigned char uint8;
  4. typedef unsigned int uint16;
  5. sbit rs=P2^5;
  6. sbit rw=P2^6;
  7. sbit e=P2^7;
  8. sbit led=P3^7;
  9. sbit k4=P2^0;
  10. sbit k2=P2^1;
  11. sbit k3=P2^2;
  12. sbit k1=P2^3;

  13. sbit beep=P2^0;
  14. uint8 key,num;
  15. uint8 fuhao;
  16. uint8 flag;       
  17. long a,b,c,d,f,g;       
  18. uint8 k;
  19. uint8 biao;
  20. float n,x;
  21. int i,j=0;

  22. uint8 dat1[]={1,2,3,0x2b-0x30,
  23.               4,5,6,0x2d-0x30,
  24.               7,8,9,0x2a-0x30,
  25.               0,0x48+0x30,0x3d-0x30,0x2f-0x30 };

  26. void delay(uint16 i)
  27. {
  28.         while(i--);
  29. }
  30. void lcdwrc(uint8 c)
  31. {
  32.         delay(1000);
  33.         rs=0;
  34.         rw=0;
  35.         e=0;
  36.         P0=c;
  37.         e=1;
  38.         delay(1000);
  39.         e=0;
  40. }
  41. void lcdwrd(uint8 dat)
  42. {
  43.         delay(1000);
  44.         rs=1;
  45.         rw=0;
  46.         e=0;
  47.         P0=dat;
  48.         e=1;
  49.         delay(1000);
  50.         e=0;
  51.         rs=0;
  52. }

  53. void lcdinit()
  54. {
  55.         delay(1500);
  56.         lcdwrc(0x38);
  57.         delay(500);
  58.         lcdwrc(0x38);
  59.         delay(500);
  60.         lcdwrc(0x38);
  61.         delay(500);
  62.         lcdwrc(0x38);
  63.         lcdwrc(0x08);
  64.         lcdwrc(0x01);
  65.         lcdwrc(0x06);
  66.         lcdwrc(0x0c);
  67.         key=0;
  68.         num=0;
  69.         flag=0;
  70.         fuhao=0;
  71.         a=0;
  72.         b=0;
  73.         c=0;
  74.         d=0;
  75.         biao=0;
  76.         led=0;

  77. }
  78. void keyscan()
  79. {
  80.        
  81.         if(k1==0)                  //检测按键K1是否按下
  82.         {       
  83.                 delay(1000);   //消除抖动 一般大约10ms
  84.                 if(k1==0)         //再次判断按键是否按下
  85.                 {
  86.                         k=0;
  87.                                                 lcdwrc(0x4f+0x80);
  88.                                                 lcdwrc(0x04);//设置光标左移,屏幕不移动
  89.                                                 c=(long)(((float)sqrt(a))*1000);
  90.                                                 while(c!=0)         //一位一位显示
  91.                                                 {
  92.                                                         k++;
  93.                                                         lcdwrd(0x30+c%10);//显示结果的最后一位在0x4f的位置
  94.                                                         c=c/10;//取前面的结果数据
  95.                                                         //lcdwrd(0x3d);
  96.                                                        
  97.                                                         if(k==3)
  98.                                                         {
  99.                                                                 lcdwrd(0x2e);
  100.                                                                 k=0;
  101.                                                         }               
  102.                                                 }
  103.                                                 lcdwrd(0x3d); //显示等于号=
  104.                              
  105.                 }
  106.                 while(!k1);         //检测按键是否松开
  107.         }               
  108.        
  109.        
  110.         if(k2==0)                  
  111.         {       
  112.                 delay(1000);   
  113.                 if(k2==0)         
  114.                 {
  115.                         j++;
  116.                 }
  117.                
  118.                 if(j==1)
  119.         {
  120.                 lcdwrd(0x50-0x30);
  121.     flag=1;               
  122.         }
  123.         if(j==2)
  124.         {

  125.                 lcdwrc(0x40+0x80);
  126.                 flag=2;
  127.         }
  128.         if(j==3)
  129.         {
  130.                 lcdwrd(0x50-0x30);
  131.                 flag=3;
  132.         }
  133.         if(j==4)
  134.         {
  135.                
  136.                         lcdwrc(0x4f+0x80);
  137.                                                 lcdwrc(0x04);                                               
  138.                         c=(a*g)-(b*f);                                               
  139.                                                 while(c!=0)         
  140.                                                 {
  141.                                                         lcdwrd(0x30+c%10);
  142.                                                         c=c/10;
  143.                                                 }
  144.                                                 if((a*g)<(b*f))
  145.                                                 {
  146.                                                         lcdwrd(0x2d);
  147.                                                 }
  148.                                                 lcdwrd(0x3d);
  149.                                                 a=0;
  150.                                                 b=0;
  151.                                                 flag=0;
  152.                                                 fuhao=0;
  153.                
  154.        
  155.         }
  156.                 while(!k2);       
  157.         }               
  158.        
  159.        
  160.        
  161.         if(k3==0)                 
  162.         {       
  163.                 delay(1000);  
  164.                 if(k3==0)         
  165.                 {
  166.                        
  167.                             if(fuhao==1)//加
  168.                                         {

  169.                                                 lcdwrc(0x4f+0x80);
  170.                                                 lcdwrc(0x04);//设置光标左移,屏幕不移动
  171.                                                 c=(long)(((float)b/a)*1000);
  172.                                                 //c=a+b;
  173.                                                 while(c!=0)       
  174.                                                 {
  175.                                                         k++;
  176.                                                         lcdwrd(0x30+c%10);
  177.                                                         c=c/10;
  178.                                                         if(k==3)
  179.                                                         {
  180.                                                                 lcdwrd(0x2e);
  181.                                                                 k=0;
  182.                                                         }               
  183.                                                 }
  184.                                                 lcdwrd(0x2d);
  185.                                                 lcdwrd(0x3d);
  186.                                                 lcdwrd(0x48+0x30);//显示x
  187.                                                 a=0;
  188.                                                 b=0;
  189.                                                 flag=0;
  190.                                                 fuhao=0;//全部清除为0
  191.                                         }
  192.                                         if(fuhao==2)   //减
  193.                                         {
  194.                                                 lcdwrc(0x4f+0x80);
  195.                                                 lcdwrc(0x04);
  196.                                                 /*if(a>b)
  197.                                                         c=a-b;
  198.                                                 else
  199.                                                         c=b-a;
  200.                                                 */
  201.                                                 c=(long)(((float)b/a)*1000);
  202.                                                 while(c!=0)       
  203.                                                 {
  204.                                                         k++;
  205.                                                         lcdwrd(0x30+c%10);
  206.                                                         c=c/10;
  207.                                                         if(k==3)
  208.                                                         {
  209.                                                                 lcdwrd(0x2e);
  210.                                                                 k=0;
  211.                                                         }               
  212.                                                 }
  213.                                                
  214.                                                 /*if(a<b)       
  215.                                                 {
  216.                                           lcdwrd(0x2d); //显示-号
  217.                                                 }
  218.                                                 */
  219.                                                 lcdwrd(0x3d); //显示等于号=
  220.                                                 lcdwrd(0x48+0x30);//显示x
  221.                                                 a=0;
  222.                                                 b=0;
  223.                                                 flag=0;
  224.                                                 fuhao=0;//全部清除为0
  225.                                         }

  226.                 }
  227.      while(!k3);       
  228.         }

  229.         if(k4==0)                  //检测按键K1是否按下
  230.         {       
  231.                 delay(1000);   //消除抖动 一般大约10ms
  232.                 if(k4==0)         //再次判断按键是否按下
  233.                 {
  234.                         lcdwrc(0x01);        //清屏指令                       
  235.                                         a=0;
  236.                                         b=0;
  237.                                         flag=0;
  238.                                         fuhao=0;
  239.                                        
  240.                 }
  241.                 while(!k4);         //检测按键是否松开
  242.         }               
  243.        

  244.         P1=0xfe;  
  245.         if(P1!=0xfe)
  246.         {
  247.                 delay(1000);
  248.                 if(P1!=0xfe)
  249.                 {
  250.                         key=P1&0xf0;
  251.                         switch(key)
  252.                         {
  253.                                 case 0xe0: num=0;break;          //1
  254.                                 case 0xd0: num=1;break;          //2
  255.                                 case 0xb0: num=2;break;          //3
  256.                                 case 0x70: num=3;break;          //加
  257.                         }
  258.                 }
  259.                 while(P1!=0xfe);
  260.                 if(num==0||num==1||num==2)         //确认第一行的数1,2,3
  261.                 {
  262.                         if(flag==0)         //没有按下符号键
  263.                         {
  264.                                 //led=1;
  265.                                 a=a*10+dat1[num];       
  266.                         }
  267.                         if(flag==1)
  268.                         {
  269.                                 //led=1;
  270.                                 b=b*10+dat1[num];
  271.                         }
  272.                         if(flag==2)
  273.                         {
  274.                                 f=f*10+dat1[num];
  275.                         }
  276.                         if(flag==3)
  277.                         {
  278.                                 g=g*10+dat1[num];
  279.                         }
  280.                
  281.                 }
  282.                 if(num==3)
  283.                 {
  284.                         //led=0;
  285.                         flag=1;
  286.                         fuhao=1;//加号+       
  287.                 }
  288.                 lcdwrd(0x30+dat1[num]);
  289.         }


  290.         P1=0xfd;                                //令第二行为0
  291.         if(P1!=0xfd)
  292.         {
  293.                 delay(1000);
  294.                 if(P1!=0xfd)
  295.                 {
  296.                         key=P1&0xf0;
  297.                         switch(key)
  298.                         {
  299.                                 case 0xe0: num=4;break;          //4
  300.                                 case 0xd0: num=5;break;          //5
  301.                                 case 0xb0: num=6;break;          //6
  302.                                 case 0x70: num=7;break;          //减—
  303.                         }       
  304.                 }
  305.                 while(P1!=0xfd);
  306.                 if(num==4||num==5||num==6)
  307.                 {
  308.                         if(flag==0)         //没有按下符号键
  309.                         {
  310.                                 //led=1;
  311.                                 a=a*10+dat1[num];       
  312.                         }
  313.                         if(flag==1)
  314.                         {
  315.                                 //led=1;
  316.                                 b=b*10+dat1[num];
  317.                         }       
  318.       if(flag==2)
  319.                         {
  320.                                 f=f*10+dat1[num];
  321.                         }
  322.                         if(flag==3)
  323.                         {
  324.                                 g=g*10+dat1[num];
  325.                         }                       
  326.                 }
  327.                 else
  328.                 {
  329.                         flag=1;
  330.                         fuhao=2;//带表减号
  331.                 }
  332.                 lcdwrd(0x30+dat1[num]);
  333.         }


  334.         P1=0xfb;               
  335.         if(P1!=0xfb)
  336.         {
  337.                 delay(1000);
  338.                 if(P1!=0xfb)
  339.                 {
  340.                         key=P1&0xf0;
  341.                         switch(key)
  342.                         {
  343.                                 case 0xe0: num=8;break;          //7
  344.                                 case 0xd0: num=9;break;          //8
  345.                                 case 0xb0: num=10;break;  //9
  346.                                 case 0x70: num=11;break;  //乘*
  347.                         }       
  348.                 }
  349.                 while(P1!=0xfb);
  350.                 if(num==8||num==9||num==10)
  351.                 {
  352.                         if(flag==0)         //没有按下符号键
  353.                         {
  354.                                 //led=1;
  355.                                 a=a*10+dat1[num];       
  356.                         }
  357.                         if(flag==1)
  358.                         {
  359.                                 //led=1;
  360.                                 b=b*10+dat1[num];
  361.                         }
  362.       if(flag==2)
  363.                         {
  364.                                 f=f*10+dat1[num];
  365.                         }
  366.                         if(flag==3)
  367.                         {
  368.                                 g=g*10+dat1[num];
  369.                         }                       
  370.                 }
  371.                 else
  372.                 {
  373.                         flag=1;
  374.                         fuhao=3;//带表乘号*
  375.                 }
  376.                 lcdwrd(0x30+dat1[num]);
  377.         }


  378.         P1=0xf7;                 
  379.         if(P1!=0xf7)
  380.         {
  381.                 delay(1000);
  382.                 if(P1!=0xf7)
  383.                 {
  384.                         key=P1&0xf0;
  385.                         switch(key)
  386.                         {
  387.                                 case 0xe0: num=12;break;  //0
  388.                                 case 0xd0: num=13;break;  // x
  389.                                 case 0xb0: num=14;break;  //等号=
  390.                                 case 0x70: num=15;break;  //除/
  391.                         }       
  392.                 }
  393.                 while(P1!=0xf7);
  394.                 switch(num)
  395.                 {
  396.                         case 12:
  397.                                         if(flag==0)         //没有按下符号键
  398.                                         {
  399.                                                 //led=1;
  400.                                                 a=a*10+dat1[num];
  401.                                                 lcdwrd(0x30);       
  402.                                         }
  403.                                         if(flag==1)
  404.                                         {
  405.                                                 //led=1;
  406.                                                 b=b*10+dat1[num];
  407.                                                 lcdwrd(0x30);
  408.                                         }if(flag==2)
  409.                         {
  410.                                 f=f*10+dat1[num];
  411.                                 lcdwrd(0x30);
  412.                         }
  413.                         if(flag==3)
  414.                         {
  415.                                 g=g*10+dat1[num];
  416.                                 lcdwrd(0x30);
  417.                         }
  418.                                         break;
  419.                        
  420.                         case 13:
  421.                                 lcdwrd(0x48+0x30);
  422.                
  423.                                         break;
  424.                                        
  425.                         case 15:
  426.                        
  427.                                         flag=1;
  428.                                         fuhao=4;
  429.                                         lcdwrd(0x2f);//除号/
  430.                                         break;
  431.                                        
  432.                         case 14:
  433.                                         if(fuhao==1)//加
  434.                                         {
  435.                                                 lcdwrc(0x4f+0x80);
  436.                                                 lcdwrc(0x04);
  437.                                                 c=a+b;
  438.                                                 while(c!=0)         //一位一位显示
  439.                                                 {
  440.                                                         lcdwrd(0x30+c%10);//显示结果的最后一位在0x4f的位置
  441.                                                         c=c/10;
  442.                                                 }
  443.                                                 lcdwrd(0x3d); //显示等于号=
  444.                                                 a=0;
  445.                                                 b=0;
  446.                                                 flag=0;
  447.                                                 fuhao=0;//全部清除为0
  448.                                         }
  449.                                         if(fuhao==2)   //减
  450.                                         {
  451.                                                 lcdwrc(0x4f+0x80);
  452.                                                 lcdwrc(0x04);
  453.                                                 if(a>b)
  454.                                                         c=a-b;
  455.                                                 else
  456.                                                         c=b-a;
  457.                                                
  458.                                                 while(c!=0)         //一位一位显示
  459.                                                 {
  460.                                                         lcdwrd(0x30+c%10);//显示结果的最后一位在0x4f的位置
  461.                                                         c=c/10;
  462.                                                 }
  463.                                                
  464.                                                 if(a<b)       
  465.                                                 lcdwrd(0x2d); //显示-号
  466.                                                 lcdwrd(0x3d); //显示等于号=
  467.                                                 a=0;
  468.                                                 b=0;
  469.                                                 flag=0;
  470.                                                 fuhao=0;//全部清除为0
  471.                                         }
  472.                                         if(fuhao==3)//乘法               
  473.                                         {
  474.                                                 lcdwrc(0x4f+0x80);
  475.                                                 lcdwrc(0x04);
  476.                                                 c=a*b;
  477.                                                 while(c!=0)         
  478.                                                 {
  479.                                                         lcdwrd(0x30+c%10);
  480.                                                         c=c/10;
  481.                                                 }
  482.                                                 lcdwrd(0x3d); //显示等于号=
  483.                                                 a=0;
  484.                                                 b=0;
  485.                                                 flag=0;
  486.                                                 fuhao=0;//全部清除为0       
  487.                                         }
  488.                                         if(fuhao==3)//乘法               
  489.                                         {
  490.                                                 lcdwrc(0x4f+0x80);
  491. ……………………

  492. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
原理图和pcb.rar (1.04 MB, 下载次数: 84)
计计计算器程序.zip (57.06 KB, 下载次数: 99)


分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏16 分享淘帖 顶 踩
回复

使用道具 举报

沙发
ID:165276 发表于 2017-9-17 17:01 | 只看该作者
强大的计算器啊,厉害。
回复

使用道具 举报

板凳
ID:226990 发表于 2017-9-19 18:40 | 只看该作者
1965501205 发表于 2017-9-17 17:01
强大的计算器啊,厉害。

那个pcb是错的,是另一个,管理员截错了
回复

使用道具 举报

地板
ID:649892 发表于 2019-12-11 10:33 来自手机 | 只看该作者
1965501205 发表于 2017-9-17 17:01
强大的计算器啊,厉害。

按照这个pcb图可以出程序吗
回复

使用道具 举报

5#
ID:401343 发表于 2019-12-16 22:02 | 只看该作者
厉害,学习学习
回复

使用道具 举报

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

Powered by 单片机教程网

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