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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 单片机矩阵键盘实现简易计算器的仿真源码与实物制作
返回列表 发新帖
查看: 6391|回复: 3
收起左侧

单片机矩阵键盘实现简易计算器的仿真源码与实物制作

[复制链接]
ID:372961 发表于 2018-7-22 16:26 | 显示全部楼层 |阅读模式
protues仿真：

原理图

原理图

被加数

被加数

加号

加号

加数

加数

结果

结果
IMG_0205.JPG IMG_0206.JPG IMG_0208.JPG


  1. /*******************************************************************************
  2. *  标题:                     矩阵键盘实现简易计算器                            *
  3. *  时间                      2018年7月22日15:53:57                                                   *
  4. *                                                                                                                                                           *
  5. *  实验说明：用矩阵键盘实现简易计算器，可以进行四位数的加减乘除，数字显示在动态*
  6. 数码管，+、-、*、/显示在静态数码管上，每次必须输入四个数字数码管才会亮，例如， *
  7. 要计算 6+7,那么第一步是输入0006，才会在数码管上显示0006，第二步是+，静态数码管 *
  8. 上就会出现一个类似+的符号，接着输入0007,步骤同上，最后按=,得出结果                       *                                                      
  9. ********************************************************************************
  10. * 实验心得：做这个简易计算器一共做了快四天，碰到了许多问题，时间浪费最多的是在 *
  11. 数组定义那里，如果定义成unsigned int code[].那么该数组就不能进行值的改变，所以 *
  12. 需要                                                                                                                                               *
  13. 定义成unsigned int[]。还有一个问题就是很奇怪的一个，就是把xianshi()这个函数放在*
  14. while(1)                                                                                                                                           *
  15.            {                                                                                                                                           *
  16.                    Two();                                                                                                                                   *
  17.                 if(KeyScan()==8)                                                                                                           *
  18.                 {                                                                                                                                       *
  19.                         KeyValue=12;                                                                                                           *
  20.                     RES();                                                                                                                           *
  21.                         First[0]=16;                                                                                                           *
  22.                         First[1]=16;                                                                                                           *
  23.                         First[2]=16;                                                                                                           *
  24.                         First[3]=16;                                                                                                           *
  25.                         KeyValue=8;                                                                                                                   *
  26.                     break;                                                                                                                           *
  27.                 }这个里面，就输出不了结果，很奇怪？？？现在还不知道为什么会这样，如果有*
  28.                 知道                                                                                                                                   *
  29. 的，评论啊。                                                                                                                                   *
  30. 最后一个就是protues仿真那里，keypad的线怎么接？？？，一直不行                  *
  31. ********************************************************************************/

  33. #include <reg52.h>
  34. #include <math.h>
  35. unsigned int result,m,n;//result为计算结果，m为被X数,n为X数
  36. unsigned int KeyValue=-1;//相当于一个flag的作用
  37. unsigned char code DIG_CODE[16]={0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07,
  38.                                  0x7F, 0x6F, 0x70, 0x40, 0x76, 0x49,0x09};//数码管上显示编码（0~9，+、-、*、/、=)
  39. unsigned int code change[17]={0x3F,0x06,0x66,0x07,0x3F,0x5B,0x6D,0x7F,0x09,0x4F,0x7D,0x6F,0x70,0x40,0x76,0x49,0x00};
  40. unsigned int code changenumber[16]={0,1,4,7,0,2,5,8,14,3,6,9,10,11,12,13};


  43. unsigned int First[4];//定义一个有4个单元的数组，如果定义成 unsigned int code First[4],这个数组就不能修改值
  44. unsigned int Second[4];
  45. unsigned int value[8];//给计算出来的result存放值

  47. #define GPIO_SHOW P0
  48. #define GPIO_KEY P1
  49. #define GPIO_DIG P2

  51. sbit LSA = P3^0;
  52. sbit LSB = P3^1;
  53. sbit LSC = P3^2;

  55. void RES();//返回计算结果函数
  56. void xianshi();        //显示最终的计算结果
  57. void caculate();//计算第一个数和最后一数
  58. void Rejudge();//判断第二个数的函数
  59. void judge();//判断第一个数的函数
  60. int KeyScan(void);//按键扫描函数
  61. void Delay10ms(unsigned int c);//延迟函数
  62. void One();//被X数
  63. void Two();//X数

  65. void main()
  66. {
  67.         while(1)
  68.         {
  69.         judge();
  70.         while(1)
  71.         {
  72.           One();
  73.          
  74.           if(KeyValue==8)
  75.           {
  76.                  GPIO_DIG=change[8];
  77.                   xianshi();
  78.                 if(KeyScan()==0)
  79.                 break;
  80.            
  81.           }

  83.           if(KeyScan()==0)
  84.           {
  85.           GPIO_SHOW=0x00;
  86.           KeyValue=-1;
  87.           break;
  88.           }
  89.          
  90.           else if(KeyScan()==12)
  91.           {
  92.          
  93.            GPIO_DIG=change[12];
  94.            KeyValue=-1;
  95.            Rejudge();
  96.            while(1)
  97.            {
  98.                    Two();
  99.                 if(KeyScan()==8)
  100.                 {
  101.                         KeyValue=12;        
  102.                     RES();
  103.                         First[0]=16;
  104.                         First[1]=16;
  105.                         First[2]=16;
  106.                         First[3]=16;
  107.                         KeyValue=8;
  108.                     break;
  109.                 }
  110.         
  111.            }
  112.          
  113.            }
  114.                         

  116.           else if(KeyScan()==13)
  117.           {
  118.            GPIO_DIG=change[13];
  119.            KeyValue=-1;
  120.            Rejudge();
  121.            while(1)
  122.            {
  123.                    Two();

  125.                 if(KeyScan()==8)
  126.                 {
  127.                     KeyValue=13;        
  128.                     RES();
  129.                         First[0]=16;
  130.                         First[1]=16;
  131.                         First[2]=16;
  132.                         First[3]=16;
  133.                         KeyValue=8;
  134.                     break;
  135.                 }
  136.            }
  137.           }

  139.           else if(KeyScan()==14)
  140.           {
  141.            GPIO_DIG=change[14];
  142.            KeyValue=-1;
  143.            Rejudge();
  144.            while(1)
  145.            {
  146.             Two();
  147.             if(KeyScan()==8)
  148.                 {
  149.                     KeyValue=14;        
  150.                     RES();
  151.                         First[0]=16;
  152.                         First[1]=16;
  153.                         First[2]=16;
  154.                         First[3]=16;
  155.                         KeyValue=8;
  156.                     break;
  157.             }
  158.            }
  159.            
  160.           }

  162.           else if(KeyScan()==15)
  163.           {
  164.            GPIO_DIG=change[15];
  165.            KeyValue=-1;
  166.            Rejudge();
  167.            while(1)
  168.            {
  169.                    Two();
  170.                 if(KeyScan()==8)
  171.                 {
  172.                     KeyValue=15;        
  173.                     RES();
  174.                         First[0]=16;
  175.                         First[1]=16;
  176.                         First[2]=16;
  177.                         First[3]=16;
  178.                         KeyValue=8;
  179.                     break;
  180.                 }
  181.            }
  182.          
  183.           }
  184.         }
  185.         }
  186. }


  189. void One ()
  190. {
  191.     unsigned char j;
  192.         unsigned char i;
  193.         for(i=0;i<4;i++)
  194.         {
  195.                  switch(i)
  196.                 {
  197.             case(0):
  198.                         LSA=0;LSB=0;LSC=1;        
  199.                         break;//显示第4位
  200.                 case(1):
  201.                         LSA=1;LSB=0;LSC=1;
  202.                     break;//显示第5位
  203.                 case(2):
  204.                         LSA=0;LSB=1;LSC=1;
  205.                         break;//显示第6位
  206.                 case(3):
  207.                         LSA=1;LSB=1;LSC=1;
  208.                         break;//显示第7位
  209.                 }
  210.                 GPIO_SHOW=change[First[i]];
  211.                 j=10;                                                 //扫描间隔时间设定
  212.                 while(j--);        
  213.                 GPIO_SHOW=0x00;//消隐
  214.         }
  215. }

  217. void judge()
  218. {
  219.         unsigned int i;
  220.         for(i=0;i<4;i++)
  221.         {
  222.                 do
  223.                 {
  224.                         KeyScan();
  225.                         First[i]=KeyScan();
  226.                 }while(KeyValue==-1);
  227.                 KeyValue=-1;
  228.       
  229.         
  230.         }
  231.         m = 1000*changenumber[First[0]]+100*changenumber[First[1]]+10*changenumber[First[2]]+changenumber[First[3]]; //;m为被X数
  232. }

  234. void Two()
  235. {
  236.     unsigned char j;
  237.         unsigned char i;

  239.         for(i=0;i<4;i++)
  240.         {
  241.                  switch(i)
  242.                 {
  243.             case(0):
  244.                         LSA=0;LSB=0;LSC=1;        
  245.                         break;//显示第4位
  246.                 case(1):
  247.                         LSA=1;LSB=0;LSC=1;
  248.                     break;//显示第5位
  249.                 case(2):
  250.                         LSA=0;LSB=1;LSC=1;
  251.                         break;//显示第6位
  252.                 case(3):
  253.                         LSA=1;LSB=1;LSC=1;
  254.                         break;//显示第7位
  255.                 }
  256.                 GPIO_SHOW=change[Second[i]];
  257.                 j=10;                                                 //扫描间隔时间设定
  258.                 while(j--);        
  259.                 GPIO_SHOW=0x00;//消隐
  260.         }
  261. }

  263. void Rejudge()
  264. {
  265.     unsigned int i;
  266.         for(i=0;i<4;i++)
  267.         {
  268.                 do
  269.                 {
  270.                         KeyScan();
  271.                         Second[i]=KeyScan();
  272.                 }while(KeyValue==-1);
  273.                 KeyValue=-1;
  274.       
  275.         
  276.         }
  277.         n = 1000*changenumber[Second[0]]+100*changenumber[Second[1]]+10*changenumber[Second[2]]+changenumber[Second[3]]; //;n为X数        
  278. }

  280. void RES()
  281. {
  282.         if(KeyValue==12)
  283.                 {
  284.                 result=m+n;
  285.             caculate();
  286.                 }
  287.                 else if(KeyValue==13)
  288.                 {
  289.                 result=m-n;
  290.                 caculate();
  291.                 }
  292.                 else if(KeyValue==14)
  293.                 {
  294.                 result=m*n;
  295.                 caculate();
  296.                 }
  297.                 else if(KeyValue==15)
  298.                 {
  299.                 result=m/n;
  300.                 caculate();
  301.                 }
  302.         

  304. }

  306. void caculate()
  307. {
  308. //    unsigned int i;
  309. //        for(i=0;i<8;i++)
  310. //        {
  311. //                value[i]=(result%(int)(pow(10,(8-i))))/((int)pow(10,(7-i)));
  312. //        }

  314.     value[0]=result/10000000;
  315.         value[1]=(result%10000000)/1000000;
  316.         value[2]=(result%1000000)/100000;
  317.         value[3]=(result%100000)/10000;
  318.         value[4]=(result%10000)/1000;
  319.         value[5]=(result%1000)/100;
  320.         value[6]=(result%100)/10;
  321.         value[7]=(result%10);
  322.         
  323. }

  325. void xianshi()
  326. {
  327.     unsigned char j;
  328.         unsigned char i;
  329.         for(i=0;i<8;i++)
  330.         {
  331.                  switch(i)
  332.                 {
  333.         case(0):
  334.             LSA=0;LSB=0;LSC=0; break;//显示第0位
  335.                 case(1):
  336.                         LSA=1;LSB=0;LSC=0; break;//显示第1位
  337.                 case(2):
  338.                         LSA=0;LSB=1;LSC=0; break;//显示第2位
  339.                 case(3):
  340.                         LSA=1;LSB=1;LSC=0; break;//显示第3位
  341.                 case(4):
  342.                         LSA=0;LSB=0;LSC=1; break;//显示第4位
  343.                 case(5):
  344.                         LSA=1;LSB=0;LSC=1; break;//显示第5位
  345.                 case(6):
  346.                         LSA=0;LSB=1;LSC=1; break;//显示第6位
  347.                 case(7):
  348.                         LSA=1;LSB=1;LSC=1; break;//显示第7位        
  349.                 }
  350.                 GPIO_SHOW=DIG_CODE[value[i]];
  351.                 j=10;                                                 //扫描间隔时间设定
  352.                 while(j--);        
  353.                 GPIO_SHOW=0x00;//消隐
  354.         }
  355.         
  356. }

  358. int KeyScan(void)          //测试行（row）的时候就是线是竖着的的那一列为1，测试列(col)的时候就是线是横着的那几行为1
  359. {
  360.         char a = 0;
  361.         GPIO_KEY=0x0f;
  362.         if(GPIO_KEY!=0x0f)//读取按键是否按下
  363.         {
  364.                 Delay10ms(1);//延时10ms进行消抖
  365.                 if(GPIO_KEY!=0x0f)//再次检测键盘是否按下
  366.                 {
  367.                         //测试列
  368.                         GPIO_KEY=0X0F;
  369.                         switch(GPIO_KEY)
  370.                         {
  371.                                 case(0X07):        KeyValue=0;break;
  372.                                 case(0X0b):        KeyValue=4;break;
  373.                                 case(0X0d): KeyValue=8;break;
  374.                                 case(0X0e):        KeyValue=12;break;
  375.                         }
  376.                         //测试行
  377.                         GPIO_KEY=0XF0;
  378.                         switch(GPIO_KEY)
  379.                         {
  380.                                 case(0X70):        KeyValue=KeyValue+3;break;
  381.                                 case(0Xb0):        KeyValue=KeyValue+2;break;
  382.                                 case(0Xd0): KeyValue=KeyValue+1;break;
  383.                                 case(0Xe0):        KeyValue=KeyValue;break;
  384.                         }
  385.                         while((a<50) && (GPIO_KEY!=0xf0))         //检测按键松手检测
  386.                         {
  387.                                 Delay10ms(1);
  388.                                 a++;
  389.                         }
  390.                         
  391.                 }
  392.         }

  394.         return KeyValue;//这一步的return值很重要，需要等KeyValue值准确的出来后，才能返回，不用return的话就是一个中途的KeyValue值(刚行扫描完就赋值给数组)。
  395.         
  396. }



  400. void Delay10ms(unsigned int c)   //误差 0us
  401. {
  402.     unsigned char a, b;

  404.         //--c已经在传递过来的时候已经赋值了，所以在for语句第一句就不用赋值了--//
  405.     for (;c>0;c--)
  406.         {
  407.                 for (b=38;b>0;b--)
  408.                 {
  409.                         for (a=130;a>0;a--);
  410.                 }         
  411.         }      
  412. }
复制代码

0.png

全部资料51hei下载地址：
protues版.rar (73.05 KB, 下载次数: 38)

评分

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

查看全部评分

回复

使用道具 举报

ID:1 发表于 2018-7-23 02:20 | 显示全部楼层
好资料，51黑有你更精彩!!!
回复

使用道具 举报

ID:372961 发表于 2018-7-23 03:19 来自手机 | 显示全部楼层
admin 发表于 2018-7-23 02:20
好资料，51黑有你更精彩!!!

哈哈，是51黑让我变得更优秀。所以，我也要呈现自己满意的，学习过程中的项目给51黑。
回复

使用道具 举报

ID:538077 发表于 2019-5-14 16:25 | 显示全部楼层
兄弟 怎么接线的能发一下吗
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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