找回密码
 立即注册

QQ登录

只需一步,快速开始

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

基于51单片机的计算器源码和原理图

[复制链接]
跳转到指定楼层
楼主
源程序:
  1. #include<reg52.h>
  2. #define  uchar unsigned char
  3. #define  ulong  unsigned long
  4.                            
  5. //uchar code num[]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f,0x00,0x40};                        //共阴极
  6.                //   0    1           2    3         4    5    6    7    8     9   熄灭  -
  7. //uchar code loc[]={0xff,0xfe,0xfd,0xfb,0xf7};        
  8. //uchar code ero[]={0x79,0x50,0x5c};

  9. uchar code num[]={0xc0,0xf9,0xa4,0xb0,0x99,0x92,0x82,0xf8,0x80,0x90,0xff,0x40};                        //共阳极
  10. uchar code loc[]={~0x00,~0x10,~0x20,~0x40,~0x80,~0x08,~0x04,~0x02,~0x01};        
  11. uchar code ero[]={~0x79,~0x77,~0x3f};
  12.                                 
  13. ulong  n=0,n1=0,n2=0;           //赋初值                                                                                                                        
  14.                                           
  15. uchar flag=0;               //计算类型选择关键字

  16. void delay(int t);
  17. void display(int n);
  18. void error();

  19. main()
  20. {
  21.         
  22.         while(1)
  23.         {        
  24.                 uchar temp;
  25.             //第一行检测
  26.             P1=0xfe;
  27.                 temp=P1;
  28.                 temp=temp&0xf0;
  29.                 if(temp!=0xf0)
  30.                 {
  31.                         delay(10);
  32.                         temp=P1;
  33.                         temp=temp&0xfe;
  34.                         if(temp!=0xfe)
  35.                         {
  36.                                 temp=P1;
  37.                                 switch(temp)
  38.                                 {
  39.                                         case 0xee:n1=0;n2=0;n=0;flag=0;break;                                //清零
  40.                                         case 0xde:n1=10*n1+0;n=n1;break;                                                             //0
  41.                                         case 0xbe: if(flag==1)n=n2+n1;                                        //=
  42.                                                           if(flag==2)n=n2-n1;
  43.                                                           if(flag==3)n=n2*n1;
  44.                                                           if(flag==4)n=n2/n1;
  45.                                                             n1=0;                        
  46.                                                       break;
  47.                                         case 0x7e:                                                            // +
  48.                                              n2=n1;n1=0;
  49.                                                      flag=1;break;
  50.                                 }
  51.                                 while(temp!=0xf0)
  52.                                 {
  53.                                                 temp=P1;
  54.                                                 temp=temp&0xf0;
  55.                                 
  56.                             }        
  57.                         
  58.                         }
  59.                
  60.         
  61.                 }
  62.         //扫描第二行
  63.                 P1=0xfd;
  64.                 temp=P1;
  65.                 temp=temp&0xf0;
  66.                 if(temp!=0xf0)
  67.                 {
  68.                         delay(10);
  69.                         temp=P1;
  70.                         temp=temp&0xf0;
  71.                         if(temp!=0xf0)
  72.                         {
  73.                                 temp=P1;
  74.                                 switch(temp)
  75.                                 {
  76.                                         case 0xed:n1=10*n1+1;n=n1;break;                                //4
  77.                                         case 0xdd:n1=10*n1+2;n=n1;break;                        //5
  78.                                         case 0xbd:n1=10*n1+3;n=n1;break;                                //6
  79.                                         case 0x7d:                                      // -        
  80.                                                           n2=n1;n1=0;
  81.                                                           flag=2;break;
  82.                                                         
  83.                                 }
  84.                                 while(temp!=0xf0)
  85.                                 {
  86.                                 temp=P1;
  87.                                 temp=temp&0xf0;
  88.                                 }               
  89.                
  90.                         }
  91.                         
  92.                
  93.                 }
  94.         //扫描第三行
  95.           P1=0xfb;
  96.                 temp=P1;
  97.                 temp=temp&0xf0;
  98.                 if(temp!=0xf0)
  99.                 {
  100.                         delay(10);
  101.                         temp=P1;
  102.                         temp=temp&0xf0;
  103.                         if(temp!=0xf0)
  104.                         {
  105.                                 temp=P1;
  106.                                 switch(temp)
  107.                                 {
  108.                                         case 0xeb:n1=10*n1+4;n=n1;break;
  109.                                         case 0xdb:n1=10*n1+5;n=n1;break;
  110.                                         case 0xbb:n1=10*n1+6;n=n1;break;
  111.                                         case 0x7b:                                                     // *                                                                                
  112.                                                       n2=n1;n1=0;
  113.                                                   flag=3;break;
  114.                                 }               
  115.                                 while(temp!=0xf0)
  116.                                 {
  117.                                         temp=P1;
  118.                                         temp=temp&0xf0;
  119.                                 }        
  120.                         }
  121.                 }
  122.         //扫描第四行
  123.                 P1=0xf7;
  124.                 temp=P1;
  125.                 temp=temp&0xf0;
  126.                 if(temp!=0xf0)
  127.                 {
  128.                         delay(10);
  129.                         temp=P1;
  130.                         temp=temp&0xf0;
  131.                         if(temp!=0xf0)
  132.                         {
  133.                                 temp=P1;
  134.                                 switch(temp)
  135.                                 {
  136.                                         case 0xe7:n1=10*n1+7;n=n1;break;                           //7
  137.                                         case 0xd7:n1=10*n1+8;n=n1;break;                           //8
  138.                                         case 0xb7:n1=10*n1+9;n=n1;break;                           //9
  139.                                                          
  140.                                         case 0x77:                                    // /        
  141.                                                       n2=n1;n1=0;
  142.                                                   flag=4;break;                                                        
  143.                                                         
  144.                                 }
  145.                                 while(temp!=0xf0)
  146.                                 {
  147.                                         temp=P1;
  148.                                         temp=temp&0xf0;
  149.                                 }                        
  150.                     }
  151.             }
  152.                 display(n);
  153.         }
  154. }


  155. //延时函数
  156. void delay(int t)
  157. {
  158.         int x,y;
  159.         for(x=0;x<t;x++)
  160.                 for(y=0;y<t;y++);        
  161. }



  162. //数码管显示
  163. void display(int n)
  164. {
  165.                 //溢出处理
  166.                 uchar g,s,b,q,a,c;
  167.                 int abs;
  168.                 if((n>999999)||(n<-99999))
  169.                 error();
  170.         
  171.                 //正数
  172.                 if((n>=0)&&(n<=999999))               
  173.                 {
  174.                                 g=n%10;
  175.                                 s=n/10%10;
  176.                                 b=n/100%10;
  177.                                 q=n/1000%10;
  178.                                 a=n/10000%10;
  179.                                 c=n/100000%10;
  180.                                 P0=num[g];
  181.                                 delay(5);            
  182.                                 P2=loc[4];     
  183.                                 delay(2);      
  184.                                 P2=loc[0];
  185.                                 delay(3);
  186.                                 if(n>=10)        
  187.                                 {
  188.                                         P0=num[s];
  189.                                         P2=loc[3];
  190.                                         delay(2);
  191.                                         P2=loc[0];
  192.                                         delay(3);
  193.                                 }                                            
  194.                                 
  195.                                 if(n>=100)        
  196.                                 {
  197.                                         P0=num[b];
  198.                                         P2=loc[2];
  199.                                         delay(2);
  200.                                         P2=loc[0];
  201.                                         delay(3);
  202.                                 }
  203.                         
  204.                                 if(n>=1000)        
  205.                                 {        
  206.                                         P0=num[q];
  207.                                         P2=loc[1];
  208.                                         delay(2);
  209.                                         P2=loc[0];
  210.                                         delay(3);
  211.                                 }
  212.                                         if(n>=10000)        
  213.                                 {
  214.                                         P0=num[a];
  215.                                         P2=loc[5];
  216.                                         delay(2);
  217.                                         P2=loc[0];
  218.                                         delay(3);
  219.                                 }
  220.                                 if(n>=100000)        
  221.                                 {
  222.                                         P0=num[c];
  223.                                         P2=loc[6];
  224.                                         delay(2);
  225.                                         P2=loc[0];
  226.                                         delay(3);
  227.                                 }
  228.                 }
  229.                
  230.                 //负数
  231.                 if((n<0)&&(n>=-999))
  232.                 {
  233.                         abs=-n;
  234.                         g=abs%10;
  235.                         s=abs/10%10;
  236.                         b=abs/100%10;
  237.                         q=abs/1000%10;
  238.                         P0=num[g];        
  239.                         P2=loc[4];
  240.                         delay(2);
  241.                         P2=loc[0];
  242.                         delay(2);
  243.                         if((abs/10%10>0)||(abs/100%10>0))        
  244.                                 {
  245.                                         P0=num[s];
  246.                                         P2=loc[3];;
  247.                                         delay(2);
  248.                                         P2=loc[0];
  249.                                         delay(2);
  250.                                 if((abs/100%10>0))        
  251.                                         {
  252.                                                 P0=num[b];
  253.                                                 P2=loc[2];
  254.                                                 delay(2);
  255.                                                 P2=loc[0];
  256.                                                 delay(2);
  257.                                                 if((abs/1000%10>0))        
  258.                                                         {        
  259.                                                                 P0=num[q];
  260.                                                                 P2=loc[1];
  261.                                                                 delay(2);
  262.                                                                 P2=loc[0];
  263.                                                                 delay(2);

  264.                                                         }
  265.                                                 else
  266.                                                         {
  267.                                                                 P0=num[11];
  268.                                                                 P2=loc[1];
  269.                                                                 delay(2);
  270.                                                                 P2=loc[0];
  271.                                                                 delay(2);
  272.                                                         }
  273.                                         }
  274.                                 else
  275.                                         {
  276.                                                 P0=num[11];
  277.                                                 P2=loc[2];
  278.                                                 delay(2);
  279.                                                 P2=loc[0];
  280.                                                 delay(2);
  281.                                         }
  282.          
  283.                                 }
  284.                         else
  285.                                 {
  286.                                         P0=num[11];
  287.                                         P2=loc[3];
  288.                                         delay(2);
  289.                                         P2=loc[0];
  290.                                         delay(2);
  291.                                 }
  292.                
  293.                 }

  294. }

  295. //溢出显示
  296. void error()
  297. {
  298.                 P2=loc[5];
  299.                 P0=ero[0];
  300.                 delay(2);
  301.                 P2=loc[0];
  302.                 delay(3);
  303.         
  304.                 P2=loc[1];
  305.                 P0=ero[1];
  306.                 delay(2);
  307.                 P2=loc[0];
  308.                 delay(3);

  309.                 P2=loc[2];
  310.                 P0=ero[1];
  311.                 delay(2);
  312.                 P2=loc[0];
  313.                 delay(3);

  314.                 P2=loc[3];
  315.                 P0=ero[2];
  316.                 delay(2);
  317.                 P2=loc[0];
  318.                 delay(3);

  319.                 P2=loc[4];
  320.                 P0=ero[1];
  321.                 delay(2);
  322.                 P2=loc[0];
  323.                 delay(3);

  324. }

复制代码



QQ截图20170220152147.png (324.65 KB, 下载次数: 152)

原理图

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

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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