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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › LCD1602简易计算器实物与仿真
返回列表 发新帖
查看: 6455|回复: 8
打印 上一主题 下一主题
收起左侧

LCD1602简易计算器实物与仿真

[复制链接]
跳转到指定楼层
楼主
ID:372961 发表于 2018-7-26 22:45 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
proteus仿真：


实物：


  1. /*******************************************************************************
  2. *  标题:                       LCD1602简易计算器                               *
  3. *  时间                      2018年7月26日22:32:18                                                   *
  4. *                                                                                                                                                           *
  5. *  实验说明：1602简易计算器，可以实现四位数以内的加减乘除，                                     *                                                      
  6. ********************************************************************************
  7. * 实验心得：当内部ram不够用的时候，可以定义成xdata，使用外部ram，但是有一个问题*
  8. 就是在用proteus仿真的时候，如果有xdata的代码，可能仿真会出现点问题，因为peoteus*
  9. 不支持外部扩展ram                                                               *
  10. ********************************************************************************/
  11. #include<reg51.h>       
  12. #include"lcd.h"
  13. #include"math.h"

  15. //--定义使用的IO口--//       
  16. #define GPIO_KEY P1

  18. //--定义全局变量--//
  19. unsigned char code XuJian[16]="01470258=369+-x/";
  20. long value[16];
  21. unsigned char Num[8];//此处写成unsigend char xdata Num[8]时，实物可以用，但是仿真有点问题，因为proteus不支持外部扩展ram.
  22. unsigned long result;//运算结果
  23. unsigned int flag=0;//标志位
  24. unsigned int  m;
  25. unsigned int c=0;
  26. long First=0;//输入的第一位数
  27. long Second=0;//输入的第二位数
  28. unsigned int Key;//符号判断，如果key=12,为+，13，为-，14为×，15为/。
  29. unsigned char KeyValue=-1;
  30. //用来存放读取到的键值

  32. //--声明全局函数--//
  33. int KeyScan(void);//键值判断函数
  34. void Delay10ms(unsigned int c);   //误差 0us
  35. void RES();//结果运算函数

  37. /*******************************************************************************
  38. * 函 数 名         : main
  39. * 函数功能                   : 主函数
  40. * 输    入         : 无
  41. * 输    出         : 无
  42. *******************************************************************************/
  43. void main(void)
  44. {
  45.         LcdInit();
  46. //        for(i=0;i<7;i++)
  47. //        {
  48. //                LcdWriteData(TiShi[i]);
  49. //        }

  51.         while(1)
  52.         {
  53.             KeyValue=KeyScan();
  54.                 switch(KeyValue)
  55.                 {
  56.                         case(0):
  57.                         LcdWriteCom(0x01);
  58.                         KeyValue=-1;
  59.                         First=0;
  60.                         Second=0;
  61.                         c=0;
  62.                         break;

  64.                         case(1):                       
  65.                         if(flag==0)//flag为0时，正常计算
  66.                         {
  67.                         LcdWriteData(XuJian[1]);
  68.                         KeyValue=-1;
  69.                         if(c==0)
  70.                         First=10*First+1;
  71.                         else if(c==1)
  72.                         Second=10*Second+1;
  73.                         }

  75.                         else if(flag==1)//flag为1时，可以在第一次运算好后，继续输入数字，开始第二次计算
  76.                         {
  77.                     LcdWriteCom(0x01);
  78.                         LcdWriteData(XuJian[1]);
  79.                         KeyValue=-1;
  80.                         First=0;
  81.                         Second=0;
  82.                         c=0;
  83.                         flag=0;
  84.                        
  85.                         if(c==0)
  86.                         First=10*First+1;
  87.                         else if(c==1)
  88.                         Second=10*Second+1;       
  89.                         }
  90.                         break;

  92.                         case(2):
  93.                         if(flag==0)
  94.                         {
  95.                         LcdWriteData(XuJian[2]);
  96.                         KeyValue=-1;
  97.                         if(c==0)
  98.                         First=10*First+4;
  99.                         else if(c==1)
  100.                         Second=10*Second+4;       
  101.                         }

  103.                         else if(flag==1)
  104.                         {
  105.                         LcdWriteCom(0x01);
  106.                         LcdWriteData(XuJian[2]);
  107.                         KeyValue=-1;
  108.                         First=0;
  109.                         Second=0;
  110.                         c=0;
  111.                         flag=0;
  112.                        
  113.                         if(c==0)
  114.                         First=10*First+4;
  115.                         else if(c==1)
  116.                         Second=10*Second+4;               
  117.                         }
  118.                         break;

  120.                         case(3):
  121.                         if(flag==0)
  122.                         {
  123.                         LcdWriteData(XuJian[3]);
  124.                         KeyValue=-1;
  125.                         if(c==0)
  126.                         First=10*First+7;
  127.                         else if(c==1)
  128.                         Second=10*Second+7;
  129.                         }

  131.                         else if(flag==1)
  132.                         {
  133.                         LcdWriteCom(0x01);
  134.                         LcdWriteData(XuJian[3]);
  135.                         KeyValue=-1;
  136.                         First=0;
  137.                         Second=0;
  138.                         c=0;
  139.                         flag=0;
  140.                        
  141.                         if(c==0)
  142.                         First=10*First+7;
  143.                         else if(c==1)
  144.                         Second=10*Second+7;               
  145.                         }
  146.                         break;

  148.                         case(4):
  149.                         if(flag==0)
  150.                         {
  151.                         LcdWriteData(XuJian[4]);
  152.                         KeyValue=-1;
  153.                         if(c==0)
  154.                     First=10*First+0;
  155.                         else if(c==1)
  156.                     Second=10*Second+0;
  157.                         }

  159.                         else if(flag==1)
  160.                         {
  161.                         LcdWriteCom(0x01);
  162.                         LcdWriteData(XuJian[4]);
  163.                         KeyValue=-1;
  164.                         First=0;
  165.                         Second=0;
  166.                         c=0;
  167.                         flag=0;
  168.                        
  169.                         if(c==0)
  170.                         First=10*First+0;
  171.                         else if(c==1)
  172.                         Second=10*Second+0;       
  173.                         }
  174.                         break;

  176.                         case(5):
  177.                         if(flag==0)
  178.                         {
  179.                         LcdWriteData(XuJian[5]);
  180.                         KeyValue=-1;
  181.                         if(c==0)
  182.                         First=10*First+2;
  183.                         else if(c==1)
  184.                         Second=10*Second+2;
  185.                         }

  187.                         else if(flag==1)
  188.                         {
  189.                         LcdWriteCom(0x01);
  190.                         LcdWriteData(XuJian[5]);
  191.                         KeyValue=-1;
  192.                         First=0;
  193.                         Second=0;
  194.                         c=0;
  195.                         flag=0;
  196.                        
  197.                         if(c==0)
  198.                         First=10*First+2;
  199.                         else if(c==1)
  200.                         Second=10*Second+2;       
  201.                         }
  202.                         break;

  204.                         case(6):
  205.                         if(flag==0)
  206.                         {
  207.                         LcdWriteData(XuJian[6]);
  208.                         KeyValue=-1;
  209.                         if(c==0)
  210.                         First=10*First+5;
  211.                         else if(c==1)
  212.                         Second=10*Second+5;
  213.                         }
  214.                        
  215.                         else if(flag==1)
  216.                         {
  217.                         LcdWriteCom(0x01);
  218.                         LcdWriteData(XuJian[6]);
  219.                         KeyValue=-1;
  220.                         First=0;
  221.                         Second=0;
  222.                         c=0;
  223.                         flag=0;
  224.                        
  225.                         if(c==0)
  226.                         First=10*First+5;
  227.                         else if(c==1)
  228.                         Second=10*Second+5;       
  229.                         }
  230.                         break;

  232.                         case(7):
  233.                         if(flag==0)
  234.                         {
  235.                         LcdWriteData(XuJian[7]);
  236.                         KeyValue=-1;
  237.                         if(c==0)
  238.                         First=10*First+8;
  239.                         else if(c==1)
  240.                         First=10*Second+8;
  241.                         }

  243.                         else if(flag==1)
  244.                         {
  245.                         LcdWriteCom(0x01);
  246.                         LcdWriteData(XuJian[7]);
  247.                         KeyValue=-1;
  248.                         First=0;
  249.                         Second=0;
  250.                         c=0;
  251.                         flag=0;
  252.                        
  253.                         if(c==0)
  254.                         First=10*First+8;
  255.                         else if(c==1)
  256.                         Second=10*Second+8;               
  257.                         }
  258.                         break;

  260.                         case(8):
  261.                         flag=1;
  262.                         LcdWriteCom(0xc0);
  263.                         LcdWriteData(XuJian[8]);
  264.                         LcdWriteCom(0x0c);
  265.                         RES();
  266.                         KeyValue=-1;
  267.                         break;

  269.                         case(9):
  270.                         if(flag==0)
  271.                         {
  272.                         LcdWriteData(XuJian[9]);
  273.                         KeyValue=-1;
  274.                         if(c==0)
  275.                         First=10*First+3;
  276.                         else if(c==1)
  277.                         Second=10*Second+3;
  278.                         }

  280.                         else if(flag==1)
  281.                         {
  282.                         LcdWriteCom(0x01);
  283.                         LcdWriteData(XuJian[9]);
  284.                         KeyValue=-1;
  285.                         First=0;
  286.                         Second=0;
  287.                         c=0;
  288.                         flag=0;
  289.                        
  290.                         if(c==0)
  291.                         First=10*First+3;
  292.                         else if(c==1)
  293.                         Second=10*Second+3;               
  294.                         }
  295.                         break;

  297.                         case(10):
  298.                         if(flag==0)
  299.                         {
  300.                         LcdWriteData(XuJian[10]);
  301.                         KeyValue=-1;
  302.                         if(c==0)
  303.                         First=10*First+6;
  304.                         else if(c==1)
  305.                         Second=10*Second+6;
  306.                         }

  308.                         else if(flag==1)
  309.                         {
  310.                         LcdWriteCom(0x01);
  311.                         LcdWriteData(XuJian[10]);
  312.                         KeyValue=-1;
  313.                         First=0;
  314.                         Second=0;
  315.                         c=0;
  316.                         flag=0;
  317.                        
  318.                         if(c==0)
  319.                         First=10*First+6;
  320.                         else if(c==1)
  321.                         Second=10*Second+6;       
  322.                         }
  323.                         break;

  325.                         case(11):
  326.                         if(flag==0)
  327.                         {
  328.                         LcdWriteData(XuJian[11]);
  329.                         KeyValue=-1;
  330.                         if(c==0)
  331.                     First=10*First+9;
  332.                         else if(c==1)
  333.                         Second=10*Second+9;
  334.                         }

  336.                         else if(flag==1)
  337.                         {
  338.                         LcdWriteCom(0x01);
  339.                         LcdWriteData(XuJian[11]);
  340.                         KeyValue=-1;
  341.                         First=0;
  342.                         Second=0;
  343.                         c=0;
  344.                         flag=0;
  345.                        
  346.                         if(c==0)
  347.                         First=10*First+9;
  348.                         else if(c==1)
  349.                         Second=10*Second+9;       
  350.                         }
  351.                         break;

  353.                         case(12):
  354.                         LcdWriteData(XuJian[12]);
  355.                         Key=12;
  356.                         KeyValue=-1;
  357.                         c=1;
  358.                         break;

  360.                         case(13):
  361.                         LcdWriteData(XuJian[13]);
  362.                         Key=13;
  363.                         KeyValue=-1;
  364.                         c=1;
  365.                         break;

  367.                         case(14):
  368.                         LcdWriteData(XuJian[14]);
  369.                         Key=14;
  370.                         KeyValue=-1;
  371.                         c=1;
  372.                         break;

  374.                         case(15):
  375.                         LcdWriteData(XuJian[15]);
  376.                         Key=15;
  377.                         KeyValue=-1;
  378.                         c=1;
  379.                         break;

  381.                 }
  382.         }                       
  383. }

  385. void RES()
  386. {

  388.     unsigned int i,j;

  390.         i=0;

  392.         if(Key==12)
  393.         {
  394.                 result=First+Second;
  395.         }

  397.         else if(Key==13)
  398.         {
  399.                 result=First-Second;
  400.         }

  402.         else if(Key==14)
  403.         {
  404.                 result=First*Second;
  405.         }

  407.         else if(Key==15)
  408.         {
  409.                 result=First/Second;
  410.         }

  412.         do
  413.         {
  414.         value[i]=result%10;
  415.         result/=10;
  416.         i++;
  417.         }while((result/10)!=0);

  419.         value[i]=result;
  420.         m=i;

  422.         for(j=0;j<=i;j++) //for循环如果是for(j=i;j>=0;j++)就会出现不同的结果，很奇怪
  423.         {
  424.                   Num[j]=value[j]+'0';
  425.         }

  427.         for(i=0;i<=m;i++)//这里的for循环也是和上面一样的结果，改成for(i=m;i>=0;i--)就会出现奇怪的结果，有兴趣的可以试试。
  428.     {
  429.                 LcdWriteData(Num[m-i]);
  430.         }
  431.        

  433. }


  436. /*******************************************************************************
  437. * 函 数 名         : KeyScan
  438. * 函数功能                   : 检测有按键按下并读取键值
  439. * 输    入         : 无
  440. * 输    出         : 无
  441. *******************************************************************************/

  443. int KeyScan(void)          //测试行（row）的时候就是线是竖着的的那一列为1，测试列(col)的时候就是线是横着的那几行为1
  444. {
  445.         char a = 0;
  446.         GPIO_KEY=0x0f;
  447.         if(GPIO_KEY!=0x0f)//读取按键是否按下
  448.         {
  449.                 Delay10ms(1);//延时10ms进行消抖
  450.                 if(GPIO_KEY!=0x0f)//再次检测键盘是否按下
  451.                 {
  452.                        
  453.                         //测试列
  454.                         GPIO_KEY=0X0F;
  455.                         switch(GPIO_KEY)
  456.                         {
  457.                                 case(0X07):        KeyValue=0;break;
  458.                                 case(0X0b):        KeyValue=4;break;
  459.                                 case(0X0d): KeyValue=8;break;
  460.                                 case(0X0e):        KeyValue=12;break;
  461.                         }
  462.                         //测试行
  463.                         GPIO_KEY=0XF0;
  464.                         switch(GPIO_KEY)
  465.                         {
  466.                                 case(0X70):        KeyValue=KeyValue+3;break;
  467.                                 case(0Xb0):        KeyValue=KeyValue+2;break;
  468.                                 case(0Xd0): KeyValue=KeyValue+1;break;
  469.                                 case(0Xe0):        KeyValue=KeyValue;break;
  470.                         }
  471.                         while((a<50) && (GPIO_KEY!=0xf0))         //检测按键松手检测
  472.                         {
  473.                                 Delay10ms(1);
  474.                                 a++;
  475.                         }
  476.                 }
  477.         }
  478.         return KeyValue;

  480. }

  482. /*******************************************************************************
  483. * 函 数 名         : Delay10ms
  484. * 函数功能                   : 延时函数，延时10ms
  485. * 输    入         : 无
  486. * 输    出         : 无
  487. *******************************************************************************/

  489. void Delay10ms(unsigned int c)   //误差 0us
  490. {
  491.     unsigned char a, b;

  493.         //--c已经在传递过来的时候已经赋值了，所以在for语句第一句就不用赋值了--//
  494.     for (;c>0;c--)
  495.         {
  496.                 for (b=38;b>0;b--)
  497.                 {
  498.                         for (a=130;a>0;a--);
  499.                 }         
  500.         }      
  501. }
  502. //因为有.h文件，所以复制上来会出错，需要的在附件里下载
复制代码



LCD1602简易计算器.rar

63.74 KB, 下载次数: 209, 下载积分: 黑币 -5

评分

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

查看全部评分

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

使用道具 举报

沙发
ID:661338 发表于 2019-12-23 15:23 | 只看该作者
谢谢大神 学到了很多
回复

使用道具 举报

板凳
ID:670990 发表于 2019-12-24 15:31 来自手机 | 只看该作者
楼主实物图能拍的再详细一些吗 对我很有用！
回复

使用道具 举报

地板
ID:672877 发表于 2019-12-25 19:46 | 只看该作者
复制进去有错误怎修改啊
回复

使用道具 举报

5#
ID:814018 发表于 2020-8-13 23:24 | 只看该作者
请问下，这里面的C是个什么意思啊
回复

使用道具 举报

6#
ID:814033 发表于 2020-8-14 07:11 来自手机 | 只看该作者
厉害了，长知识了
回复

使用道具 举报

7#
ID:837654 发表于 2020-11-2 11:16 | 只看该作者
有错
回复

使用道具 举报

8#
ID:787495 发表于 2020-12-18 16:58 | 只看该作者
有大神能做汇编语言吗
回复

使用道具 举报

9#
ID:881846 发表于 2021-2-2 14:51 | 只看该作者
国有化 发表于 2020-8-13 23:24
请问下，这里面的C是个什么意思啊

对啊 c是什么
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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