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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 单片机+1602制作一个能四则运算，连续运算的小型算术型 ...
返回列表 发新帖
查看: 6479|回复: 4
收起左侧

单片机+1602制作一个能四则运算，连续运算的小型算术型计算器

  [复制链接]
ID:500784 发表于 2019-10-10 18:39 | 显示全部楼层 |阅读模式
摘要：计算器是我们生活中常用的工具，在我们生活中不可或缺。本次设计是设计一个算术型计算器，该计算器能够完成简单的四则运算，还可以实现连续运算。本次是以51单片机为运算核心，以LCD1602为显示的进行硬件上的设计，在软件上以Keil4进行软件编程，以Proteus进行仿真调试，设计出一个能够完成简单的四则运算，实现连续运算的小型算术型计算器。

正文：
一、设计概述
1. 课题意义
    计算器有键盘部分、单片机、显示部分三部分组成，键盘部分主要完成输入功能；单片机主要完成数据处理功能，包括确定按键，完成运算，以及输出数据；显示器部分主要完成单片机输出的显示。基本掌握计算器的设计原理和LCD1602的显示原理，进而熟悉C51的编程和调试方法。
2. 系统功能
   能够完成简单的四则运算，还可以实现连续运算的小型算术型计算器。
   硬件设计上通过Proteus进行电路原理图和仿真运行图的设计，软件设计上以Keil4为基础进行软件编程，将编程生成的.hex文件放入在Proteus已画好的原理图中调试，观察设计结果，并对代码进行修改。

二、硬件设计
                             [size=9.0000pt] 图1 [size=9.0000pt]总原理图 图片15.png
     
1.按键设计
矩阵键盘的原理是见I/O口分为行线和列线，按键设置在跨接行线和列线的交点上，列线通过上拉电阻接正电源，进而形成基本的4x4行列式键盘。本次设计以矩阵键盘为基本的输入按键分别为1，2，3，+，4，5，6，-，7，8，9，x，0，CLR，=，/ 形成计算器对应的基本的数字键和功能键     



图片14.png
显示设计

LCD1602是一种专门用来显示字母、数字、符号等的点阵型液晶模块，它由若干个5X7或者5X11等点阵字符位组成，每个点阵字符位都可以显示一个字符，每位之间有一个点距的间隔，每行之间也有间隔，起到了字符间距和行间距的作用，因此它比较适合用在计算器的显示。
图片13.png
三、软件设计
1. 按键扫描
   本次设计中在软件上使用了反转法进行按键的扫描，其过程为先让行输出全为0列输出全为1读取与按键相接的P1口的状态，读取按键的列值，然后让行输出全为1列输出全为0读取与按键相接的P1口的状态，读取按键的行值，根据行值和列值可知其键值。
0.jpg
                           [size=9.0000pt]    图4按键扫描流程图[size=9.0000pt]          

2.显示设计
LCD1602是一个16字双行的显示模块，在使用LCD1602之前我们应该先对其进行初始化，其初始化的内容有光标设置、显示设置和清屏指令等。初始化完成后从其参考手册可知LCD1602中已经存储有基本字模数据，所以想要在LCD1602中显示字符，只需要对LCD1602写入该字符相对应的ASCII码即可显示出相应的字符。LCD1602的写入可分为写数据和写命令，当要写入数据时其对应的状态为RS=1，RW=0，E为下降沿，然后通过单片机I/O口写入相应的数据。当要写入命令时其对应的状态为RS=0，RW=0，E为下降沿，然后通过单片机I/O口写入相应的命令。 0.jpg
                             [size=9.0000pt]图5  LCD1602写指令图
3.键值处理
     首先我们初始化液晶显示器，然后显示出第一个被按下的数，并且使光标右移，如果有第二个数按下，则据继续显示，以此类推，然后把所有显示出来的数换算成一个数，如果按下“+”号，则显示出“+”，并且同理显示出“+”号后面按下的数字，然后调用加子程序，运算出结果，如果按下的是“-”,则调用减子程序，如果按下“*”，则调用乘子程序，如果按下“/”，则调用除子程序。然后再调用显示结果子程序，显示出结果。
0.jpg
                          图6键值运算流程图


四、系统测试
1.加法测试
   图片9.png


2.减法测试
图片8.png

3.乘法测试
图片7.png


4.除法测试
图片5.png

5.连续运算测试
图片4.png 图片3.png


五、结论
经过调试可知此次设计已经基本达到要求，该计算器能够完成简单的四则运算，还可以实现连续运算。但只能进行整数的运算，无法进行浮点型数据运算，运算的连续运行需要一个个数的连续运算，无法做到一次性连续运算。
七、附录
1.系统电路图
         

2.实物运行图
0.png

单片机源程序如下:
  1. /* 实现两个数的运算，每个数的位数至少可以八位  */
  2. #include<reg52.h>        
  3. #include<math.h>               
  4. typedef unsigned char uint8;
  5. typedef unsigned int uint16;
  6. #define GPIO_KEY P1
  7. sbit rw=P2^5;
  8. sbit rs=P2^6;
  9. sbit e=P2^7;
  10. sbit k1=P3^0;
  11. uint8  num='N';                      //键值
  12. uint16 k0,k2,k3;          // 数组位
  13. uint8 fuhao;                //定义具体的那个符号，是加减还是乘除。
  14. uint8 flag,r;               //定义符号键标志位，小数点标志位和继续运算标志位 这个是统称
  15. float a,b,c,zheng,xiao;         //定义运算数据的第一个和第二个及等于的数变量
  16. uint8  shuzi1[5]={0},shuzi2[5]={0},shuzi3[4]={0};
  17. uint8 code dat1[]={1,2,3,0x2b-0x30, 4,5,6,0x2d-0x30, 7,8,9,0x78-0x30, 0,0x2e-0x30,0x3d-0x30,0xfd-0x30 };//保存显示的数据 123+ 456- 789* 0.CLR /
  18. void delay(uint16 i)
  19. {  uint16 x,y;
  20. for(x=0;x<i;x++)
  21. for(y=0;y<114;y++);        
  22. }
  23. void lcdcommand(uint8 m)   //写命令
  24. {
  25.         delay(1);
  26.         rs=0;
  27.         rw=0;
  28.         e=0;
  29.         P0=m;
  30.         e=1;
  31.         delay(1);
  32.         e=0;
  33. }
  34. void lcddata(uint8 dat)          //写数据
  35. {
  36.         delay(1);
  37.         rs=1;
  38.         rw=0;
  39.         e=0;
  40.         P0=dat;
  41.         e=1;
  42.         delay(1);
  43.         e=0;
  44.         rs=0;
  45. }
  46. void lcdcsh()        //初始化         
  47. {
  48.         delay(5);
  49.         lcdcommand(0x38); //功能设定 8位总线 两行 5X7点阵
  50.         delay(5);
  51.         lcdcommand(0x38);
  52.         lcdcommand(0x38);
  53.         lcdcommand(0x0c); // 开显示 无光标
  54.         lcdcommand(0x06); //光标左移
  55.         lcdcommand(0x01); // 清屏
  56.         lcdcommand(0x80);//数据从左上开始
  57.         num='N';
  58.         flag=0;
  59.         fuhao=0;
  60.         a=0;
  61.         b=0;
  62.         c=0;
  63.    zheng=xiao=0;;
  64.         k0=0;k2=0;k3=0;

  66. }
  67. void shuchu(float e)                                        //在屏幕上显示数值e
  68. {
  69. char shuzu[10];
  70.   long z;  
  71.   int x=0;
  72.   float f;
  73.          
  74.     (long)z=e;                          //整数处理
  75.         if(z==0)
  76.         lcddata('0');

  78.         while(z!=0)
  79.         {        shuzu[x]=z%10;
  80.             z=z/10;
  81.                 x++;
  82.         }
  83.   for(x=x-1;x>=0;x--)
  84.         lcddata(shuzu[x]+0x30);

  86.         (long)z=e;                                                    //小数处理
  87. (float)f=e-z;

  89. if(f>0.000)
  90. {        x=0;
  91.    lcddata('.');
  92.    z=f*1000;
  93.           while(z!=0)
  94.         {        shuzu[x]=z%10;
  95.             z=z/10;
  96.                 x++;
  97.         }
  98.   for(x=x-1;x>=0;x--)
  99.         lcddata(shuzu[x]+0x30);

  101. }
  102. }

  104. void fuzhi()        // 显示与向数组赋值
  105. {        
  106.                         
  107.                         if(flag==0)         //是否按下符号键
  108.                            {
  109.                              delay(50);
  110.                  if(dat1[num]=='.')
  111.                                  r=1;
  112.                        if((r==0)&&(k0<5))
  113.                            {
  114.                             shuzi1[k0]=dat1[num];
  115.                                 k0++;
  116.                                 lcddata(0x30+dat1[num]);
  117.                                 }
  118.                            else if((r==1)&&(k3<4))
  119.                           {
  120.                           
  121.                             shuzi3[k3]=dat1[num];
  122.                                 k3++;
  123.                                 lcddata(0x30+dat1[num]);
  124.                                 }
  125.                           }
  126.          r=0;
  127.                  if(flag==1)         //是否按下符号键
  128.                            {
  129.                              delay(50);
  130.                  if(dat1[num]=='.')
  131.                                  r=1;
  132.                        if((r==0)&&(k2<5))
  133.                            {
  134.                             shuzi2[k2]=dat1[num];
  135.                                 k2++;
  136.                                 lcddata(0x30+dat1[num]);
  137.                                 }
  138.                            else if((r==1)&&(k3<4))
  139.                           {
  140.                           
  141.                             shuzi3[k3]=dat1[num];
  142.                                 k3++;
  143.                                 lcddata(0x30+dat1[num]);
  144.                                 }
  145.                         }

  147. }                  
  148. void  sz(uint8 s[8],int x)                                                  //数组转为数值
  149. {
  150.   int i,j;
  151.   zheng=0;
  152.   xiao=0;
  153.   i=0;                                         //整数
  154.   while(x>0)                                   
  155.    {
  156.          zheng=zheng*10+s[i];
  157.             i++;
  158.          x--;
  159.    }
  160. i=1;                                                   //小数
  161. j=k3;  
  162. while(j>0)
  163. {
  164. xiao=xiao*10+s[i];
  165. i++;
  166. j--;
  167. }
  168.   
  169. for(;k3>0;k3--)
  170. xiao=xiao/10;
  171. zheng=zheng+xiao;
  172. k0=k2=k3=0;         
  173. }         
  174. void KeyDown(void)
  175. {
  176.         char L=0;
  177.         GPIO_KEY=0x0f;
  178.         if(GPIO_KEY!=0x0f)//读取按键是否按下
  179.         {
  180.                 delay(10);//延时10ms进行消抖
  181.                 if(GPIO_KEY!=0x0f)//再次检测键盘是否按下
  182.                 {        
  183.                         //测试列
  184.                         GPIO_KEY=0X0F;
  185.                         switch(GPIO_KEY)
  186.                         {
  187.                                 case(0X07):        num=0;break;
  188.                                 case(0X0b):        num=1;break;
  189.                                 case(0X0d): num=2;break;
  190.                                 case(0X0e):        num=3;break;
  191.                         }
  192.                         //测试行
  193.                         GPIO_KEY=0XF0;
  194.                         switch(GPIO_KEY)
  195.                         {
  196.                                 case(0X70):        num=num;break;
  197.                                 case(0Xb0):        num=num+4;break;
  198.                                 case(0Xd0): num=num+8;break;
  199.                                 case(0Xe0):        num=num+12;break;
  200.                         }
  201.                         while((L<50)&&(GPIO_KEY!=0xf0))         //检测按键松手检测
  202.                         {
  203.                                 delay(10);
  204.                                 L++;
  205.                         }
  206.                 }
  207.         }
  208. }
  209. void banduan()
  210. {         
  211.    switch(fuhao)
  212.    {
  213.    case 0:                     
  214.                      sz(shuzi1,k0);
  215.                                        a=zheng;
  216.                                 lcdcommand(0x01);
  217.                                                   lcdcommand(0x40+0x80);
  218.                             shuchu(a);
  219.                                                 b=0;
  220.                                                 flag=0;
  221.                                                 fuhao=0;     //全部清除为0
  222.                                                 zheng=0;
  223.                                                 xiao=0;         
  224.                                                 break;



  228.     case 1:                  
  229.                              
  230.                             lcdcommand(0x40+0x80);
  231.                                                 c=a+b;
  232.                                                 lcddata(0x3d); //显示等于号=
  233.                                                 shuchu(c);
  234.                                                 a=0;
  235.                                                 b=0;
  236.                                                 flag=0;
  237.                                                 fuhao=0;     //全部清除为0
  238.                                                 zheng=0;
  239.                                                 xiao=0;   
  240.                                                 break;

  242.      case 2:               
  243.                                   lcdcommand(0x40+0x80);
  244.                                        
  245.                                                 if(a>b)
  246.                                         {        c=a-b;
  247.                                         lcddata(0x3d);         //显示等于号=
  248.                                         }
  249.                                                 else if(a<b)
  250.                                                 {
  251.                                                 c=b-a;
  252.                                                 lcddata(0x3d);                                    //显示等于号=
  253.                                                 lcddata(0x2d);                             //显示负号-
  254.                                                  }
  255.                                                  if(a==b)
  256.                                                  c=0;
  257.                                                 shuchu(c);
  258.                                                 a=0;
  259.                                                 b=0;
  260.                                                 flag=0;
  261.                                                 fuhao=0;  //全部清除为0
  262.                                                 zheng=0;
  263.                                                 xiao=0;        
  264.                                                 break;

  266.      case 3:               
  267.                                                 lcdcommand(0x40+0x80);
  268.                                                 c=a*b;
  269.                                                 lcddata(0x3d); //显示等于号=
  270.                                                 shuchu(c);
  271.                                                 a=0;
  272.                                                 b=0;
  273.                                                 flag=0;
  274.                                                 fuhao=0; //全部清除为0
  275.                                                 zheng=0;
  276.                                                 xiao=0;        
  277.                                                 break;

  279.      case 4:                        
  280.                                                 lcdcommand(0x40+0x80);
  281.                                                 c=a/b;                                                         
  282.                                                 lcddata(0x3d); //显示等号
  283.                                                 shuchu(c);
  284.                                                 a=0;
  285.                                                 b=0;
  286.                                                 flag=0;
  287.                                                 fuhao=0; //全部清除为0
  288.                                                 zheng=0;
  289.                                                 xiao=0;
  290.                                        
  291.                                                 break;
  292.         }

  294. }

  296. void main()
  297. {         
  298.   
  299.   
  300.   
  301.     lcdcsh();

  303. while(1)
  304. { num='N';
  305.    KeyDown();
  306.    if(num==13)
  307.    {
  308.        lcdcommand(0x01);//清零
  309.                                                   
  310.                    flag=0;
  311.                    fuhao=0;
  312.                     a=0;
  313.                      b=0;
  314.                        c=0;
  315.                zheng=xiao=0;
  316.                            k0=k2=k3=0;
  317.    }
  318. while(1)
  319. {         
  320.   num='N';
  321.      KeyDown();
  322.   if(num==0||num==1||num==2||num==4||num==5||num==6||num==8||num==9||num==10||num==12||num==16)        //1-9-0-.
  323.          fuzhi();
  324.      if(num==13)
  325.    {
  326.        lcdcommand(0x01);//清零
  327.                                                   
  328.                    flag=0;
  329.                    fuhao=0;
  330.                     a=0;
  331.                      b=0;
  332.                        c=0;
  333.                zheng=xiao=0;
  334.                            k0=k2=k3=0;
  335.                                break;
  336.         }


  339.    if(num==3||num==7||num==11||num==15)
  340.    {
  341.    
  342.         flag=1;
  343.         switch(num)
  344.         {   case 3: fuhao=1;    break;
  345.         case 7:          fuhao=2;  break;
  346.                 case 11: fuhao=3;   break;
  347.                 case 15: fuhao=4;   break;

  349.         }
  350.                 sz(shuzi1,k0);
  351.                 c=zheng;

  353. loop:                a=c;        
  354.                         lcdcommand(0x01);
  355.                         lcdcommand(0x80);
  356.                         shuchu(a);
  357.                         lcddata(0x30+dat1[num]);
  358.                         break;
  359.      }
  360.    }
  361.    
  362.   while(1)
  363.   {                    
  364.    num='N';
  365.      KeyDown();
  366.   if(num==0||num==1||num==2||num==4||num==5||num==6||num==8||num==9||num==10||num==12)        //1-9-0
  367.          fuzhi();
  368.           if(num==13)
  369.    {
  370.        lcdcommand(0x01);//清零
  371.                                                   
  372.                    flag=0;
  373.                    fuhao=0;
  374.                     a=0;
  375.                      b=0;
  376.                        c=0;
  377.                zheng=xiao=0;
  378.                            k0=k2=k3=0;
  379.               break;
  380.    
  381. ……………………

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

所有程序51hei提供下载:
1.c.zip (2.41 KB, 下载次数: 129)



单片机制作小型计算器
图片6.png

评分

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

查看全部评分

回复

使用道具 举报

ID:572991 发表于 2019-11-15 21:41 | 显示全部楼层
你的程序不能用，我亲测
回复

使用道具 举报

ID:860860 发表于 2020-12-15 19:29 来自手机 | 显示全部楼层
这个是只能1位数4则运算吗
回复

使用道具 举报

ID:861681 发表于 2020-12-19 12:39 来自手机 | 显示全部楼层
可以混合四则运算吗？比如1+2*2
回复

使用道具 举报

ID:904193 发表于 2022-12-8 19:15 | 显示全部楼层
写的好仔细
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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