标题: 基于单片机的智能计算器 1602液晶显示 [打印本页]
作者: mingo    时间: 2016-12-20 13:49
标题: 基于单片机的智能计算器 1602液晶显示
基于单片机的智能计算器，采用1602液晶显示


  1. /*  S16 S12 S8 S4分别是123+
  2.         S15 S11 S7 S3分别是456-
  3.         S14 S10 S6 S2分别是789*
  4.         S13 S9 S5 S1分别是0 CLR = /
  5. */

  7. /* 实现两个数的运算，每个数的位数至少可以八位  */
  8. #include<reg52.h>                        
  9. typedef unsigned char uint8;
  10. typedef unsigned int uint16;

  12. sbit rw=P2^5;
  13. sbit rs=P2^6;
  14. sbit e=P2^7;
  15. sbit led=P3^7;

  17. sbit beep=P2^0;
  18. uint8 key,num;
  19. uint8 fuhao;//定义具体的那个符号，是加减还是乘除。
  20. uint8 flag;        //定义有没有按下符号键，这个是统称
  21. long a,b,c,d;        //定义运算数据的第一个和第二个及等于的数变量
  22. uint8 k; //定义小数点后面显示的位数
  23. uint8 biao;

  25. uint8 dat1[]={1,2,3,0x2b-0x30, 4,5,6,0x2d-0x30, 7,8,9,0x2a-0x30, 0,0x01-0x30,0x3d-0x30,0x2b-0x30 };//保存显示的数据

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

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

  80. }

  82. void keyscan()
  83. {
  84.         P1=0xfe;   //令第一行为0，然后判断是哪一列按下
  85.         if(P1!=0xfe)
  86.         {
  87.                 delay(1000);
  88.                 if(P1!=0xfe)
  89.                 {
  90.                         key=P1&0xf0;
  91.                         switch(key)
  92.                         {
  93.                                 case 0xe0: num=0;break;          //1
  94.                                 case 0xd0: num=1;break;          //2
  95.                                 case 0xb0: num=2;break;          //3
  96.                                 case 0x70: num=3;break;          //加
  97.                         }
  98.                 }
  99.                 while(P1!=0xfe);
  100.                 if(num==0||num==1||num==2)         //确认第一行的数1,2,3
  101.                 {
  102.                         if(flag==0)         //没有按下符号键
  103.                         {
  104.                                 //led=1;
  105.                                 a=a*10+dat1[num];        
  106.                         }
  107.                         else
  108.                         {
  109.                                 //led=1;
  110.                                 b=b*10+dat1[num];
  111.                         }
  112.                
  113.                 }
  114.                 if(num==3)
  115.                 {
  116.                         //led=0;
  117.                         flag=1;
  118.                         fuhao=1;//加号+        
  119.                 }
  120.                 lcdwrd(0x30+dat1[num]);
  121.         }


  124.         P1=0xfd;                                //令第二行为0，判断是哪一列按下
  125.         if(P1!=0xfd)
  126.         {
  127.                 delay(1000);
  128.                 if(P1!=0xfd)
  129.                 {
  130.                         key=P1&0xf0;
  131.                         switch(key)
  132.                         {
  133.                                 case 0xe0: num=4;break;          //4
  134.                                 case 0xd0: num=5;break;          //5
  135.                                 case 0xb0: num=6;break;          //6
  136.                                 case 0x70: num=7;break;          //减—
  137.                         }        
  138.                 }
  139.                 while(P1!=0xfd);
  140.                 if(num==4||num==5||num==6)
  141.                 {
  142.                         if(flag==0)         //没有按下符号键
  143.                         {
  144.                                 //led=1;
  145.                                 a=a*10+dat1[num];        
  146.                         }
  147.                         else
  148.                         {
  149.                                 //led=1;
  150.                                 b=b*10+dat1[num];
  151.                         }                        
  152.                 }
  153.                 else
  154.                 {
  155.                         flag=1;
  156.                         fuhao=2;//带表减号
  157.                 }
  158.                 lcdwrd(0x30+dat1[num]);
  159.         }


  162.         P1=0xfb;                 //令第三行为0，判断哪一列按下
  163.         if(P1!=0xfb)
  164.         {
  165.                 delay(1000);
  166.                 if(P1!=0xfb)
  167.                 {
  168.                         key=P1&0xf0;
  169.                         switch(key)
  170.                         {
  171.                                 case 0xe0: num=8;break;          //7
  172.                                 case 0xd0: num=9;break;          //8
  173.                                 case 0xb0: num=10;break;  //9
  174.                                 case 0x70: num=11;break;  //乘*
  175.                         }        
  176.                 }
  177.                 while(P1!=0xfb);
  178.                 if(num==8||num==9||num==10)
  179.                 {
  180.                         if(flag==0)         //没有按下符号键
  181.                         {
  182.                                 //led=1;
  183.                                 a=a*10+dat1[num];        
  184.                         }
  185.                         else
  186.                         {
  187.                                 //led=1;
  188.                                 b=b*10+dat1[num];
  189.                         }                        
  190.                 }
  191.                 else
  192.                 {
  193.                         flag=1;
  194.                         fuhao=3;//带表乘号*
  195.                 }
  196.                 lcdwrd(0x30+dat1[num]);
  197.         }


  200.         P1=0xf7;                 //令第四行为0，判断哪一列按下
  201.         if(P1!=0xf7)
  202.         {
  203.                 delay(1000);
  204.                 if(P1!=0xf7)
  205.                 {
  206.                         key=P1&0xf0;
  207.                         switch(key)
  208.                         {
  209.                                 case 0xe0: num=12;break;  //0
  210.                                 case 0xd0: num=13;break;  //清除rst
  211.                                 case 0xb0: num=14;break;  //等号=
  212.                                 case 0x70: num=15;break;  //除/
  213.                         }        
  214.                 }
  215.                 while(P1!=0xf7);
  216.                 switch(num)
  217.                 {
  218.                         case 12:
  219.                                         if(flag==0)         //没有按下符号键
  220.                                         {
  221.                                                 //led=1;
  222.                                                 a=a*10+dat1[num];
  223.                                                 lcdwrd(0x30);        
  224.                                         }
  225.                                         else
  226.                                         {
  227.                                                 //led=1;
  228.                                                 b=b*10+dat1[num];
  229.                                                 lcdwrd(0x30);
  230.                                         }
  231.                                         break;
  232.                         
  233.                         case 13:
  234.                                         lcdwrc(0x01);        //清屏指令                        
  235.                                         a=0;
  236.                                         b=0;
  237.                                         flag=0;
  238.                                         fuhao=0;
  239.                                         break;

  241.                         case 15:
  242.                         
  243.                                         flag=1;
  244.                                         fuhao=4;
  245.                                         lcdwrd(0x2f);//除号/
  246.                                         break;
  247.                                        
  248.                         case 14:
  249.                                         if(fuhao==1)//加
  250.                                         {
  251.                                                 lcdwrc(0x4f+0x80);
  252.                                                 lcdwrc(0x04);//设置光标左移，屏幕不移动
  253.                                                 c=a+b;
  254.                                                 while(c!=0)         //一位一位显示
  255.                                                 {
  256.                                                         lcdwrd(0x30+c%10);//显示结果的最后一位在0x4f的位置
  257.                                                         c=c/10;//取前面的结果数据        
  258.                                                 }
  259.                                                 lcdwrd(0x3d); //显示等于号=
  260.                                                 a=0;
  261.                                                 b=0;
  262.                                                 flag=0;
  263.                                                 fuhao=0;//全部清除为0
  264.                                         }
  265.                                         if(fuhao==2)   //减
  266.                                         {
  267.                                                 lcdwrc(0x4f+0x80);
  268.                                                 lcdwrc(0x04);//设置光标左移，屏幕不移动
  269.                                                 if(a>b)
  270.                                                         c=a-b;
  271.                                                 else
  272.                                                         c=b-a;
  273.                                                 
  274.                                                 while(c!=0)         //一位一位显示
  275.                                                 {
  276.                                                         lcdwrd(0x30+c%10);//显示结果的最后一位在0x4f的位置
  277.                                                         c=c/10;//取前面的结果数据        
  278.                                                 }
  279.                                                 if(a<b)        lcdwrd(0x2d); //显示-号
  280.                                                 lcdwrd(0x3d); //显示等于号=
  281.                                                 a=0;
  282.                                                 b=0;
  283.                                                 flag=0;
  284.                                                 fuhao=0;//全部清除为0
  285.                                         }
  286.                                         if(fuhao==3)//乘法               
  287.                                         {
  288.                                                 lcdwrc(0x4f+0x80);
  289.                                                 lcdwrc(0x04);//设置光标左移，屏幕不移动
  290.                                                 c=a*b;
  291.                                                 while(c!=0)         //一位一位显示
  292.                                                 {
  293.                                                         lcdwrd(0x30+c%10);//显示结果的最后一位在0x4f的位置
  294.                                                         c=c/10;//取前面的结果数据        
  295.                                                 }
  296.                                                 lcdwrd(0x3d); //显示等于号=
  297.                                                 a=0;
  298.                                                 b=0;
  299.                                                 flag=0;
  300.                                                 fuhao=0;//全部清除为0        
  301.                                         }
  302.                                         if(fuhao==3)//乘法               
  303.                                         {
  304.                                                 lcdwrc(0x4f+0x80);
  305.                                                 lcdwrc(0x04);//设置光标左移，屏幕不移动
  306.                                                 c=a*b;
  307.                                                 while(c!=0)         //一位一位显示
  308.                                                 {
  309.                                                         lcdwrd(0x30+c%10);//显示结果的最后一位在0x4f的位置
  310.                                                         c=c/10;//取前面的结果数据        
  311.                                                 }
  312.                                                 lcdwrd(0x3d); //显示等于号=
  313.                                                 a=0;
  314.                                                 b=0;
  315.                                                 flag=0;
  316.                                                 fuhao=0;//全部清除为0        
  317.                                         }
  318.                                         if(fuhao==4)
  319.                                         {
  320.                                                 k=0;
  321.                                                 lcdwrc(0x4f+0x80);
  322.                                                 lcdwrc(0x04);//设置光标左移，屏幕不移动
  323.                                                 c=(long)(((float)a/b)*1000);//强制转换为long。
  324.                                                 while(c!=0)         //一位一位显示
  325.                                                 {
  326.                                                         k++;
  327.                                                         lcdwrd(0x30+c%10);//显示结果的最后一位在0x4f的位置
  328.                                                         c=c/10;//取前面的结果数据
  329.                                                         if(k==3)
  330.                                                         {
  331.                                                                 lcdwrd(0x2e);
  332.                                                                 k=0;
  333.                                                         }               
  334.                                                 }
  335.                                                 if(a/b<0)          //如果a比b小的话那么除的结果最高位是0
  336.                                                 {
  337.                                                         lcdwrd(0x30);        
  338.                                                 }
  339.                                                 lcdwrd(0x3d); //显示等号
  340.                                                 a=0;
  341.                                                 b=0;
  342.                                                 flag=0;
  343.                                                 fuhao=0;//全部清除为0
  344.                                         }
  345.                                         break;

  347.                 }
  348.         }

  350. }



  354. void main()
  355. {
  356.         lcdinit();
  357.         while(1)
  358.         {
  359.                 keyscan();        
  360.         }
  361. }
复制代码


基于单片机的智能计算器.rar

392.12 KB, 下载次数: 34, 下载积分: 黑币 -5

基于单片机的智能计算器
作者: cruliang    时间: 2017-6-27 13:24
线在单片机上怎么接？
作者: 等风来丶    时间: 2020-5-13 10:03
有仿真原理图吗？



欢迎光临 (http://www.51hei.com/bbs/) Powered by Discuz! X3.1