找回密码
 立即注册

QQ登录

只需一步,快速开始

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

基于单片机数码管显示的闹钟

[复制链接]
跳转到指定楼层
楼主
ID:512872 发表于 2019-10-3 10:46 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
  1. /***********************************************************
  2. 名称:基于AT89S52数码管系统测试程序
  3. 要求:流水灯电路测试,数码管电路测试,独立式键盘电路测试,蜂鸣器电路测试
  4. 作者:刘杨
  5. 时间:2012年12月12日
  6. 电路描述:S1到S8一键一功能;P3口连接LED流水灯;数码管驱动电路采用74HC573;P1口连接独立式键盘;P0口,P2口分别控制数码管位和段;
  7. ************************************************************/

  8. #include<reg52.h>
  9. #include<intrins.h>
  10. #define uint unsigned int
  11. #define uchar unsigned char

  12. sbit S1=P1^0;  //流水灯顺时针流水
  13. sbit S2=P1^1;  //流水灯逆时针
  14. sbit S3=P1^2;  //数码管显示数字0-7
  15. sbit S4=P1^3;  //显示数字钟
  16. sbit S5=P1^4;  //流水灯逆时针
  17. sbit S6=P1^5;  //数码管显示数字0-7
  18. sbit S7=P1^6;
  19. sbit S8=P1^7;  //显示数字钟
  20. sbit P3_1=P3^1;          //蜂鸣器报警控制端

  21. uchar code discode[]={0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,0xBF};
  22. uchar code discode0[]={0x92,0x86,0xC6,0xC6,0xC1,0x92};
  23. uchar code discode1[]={0xC0,0xF9,0xA4,0xB0,0x99,0x92,0x82,0xF8,0x80,0x90,0x3F};
  24. uchar disbitcode[]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};
  25. uchar disbuf[8]={0,0,10,0,0,10,0,0};
  26. uchar disbuf0[8]={0,0,10,0,0,10,0,0};
  27. uchar disbuf1[8]={0,0,10,0,0,10,0,0};//显示缓冲区
  28. uchar cent,second,minite,hour,second1,minite1,hour1;

  29. /*函数申明*/
  30. void display(void);                       
  31. void ini(void);
  32. void t0(void);

  33. /*************延时程序**************/                                                                                         
  34. void delay(uint m)                 
  35.   {
  36.           while(--m);
  37.   }

  38. /*************初始化程序**************/
  39. void ini(void)                               
  40.          {
  41.                      TMOD=0x01;
  42.                   TH0=(65536-46082)/256;
  43.                   TL0=(65536-46082)%256;
  44.                   ET0=1;
  45.                   EA=1;
  46.          }
  47. /************缓存程序****************/
  48. void hccx()
  49. {
  50. disbuf1[0]=disbuf[0]=second%10;
  51. disbuf1[1]=disbuf[1]=second/10;
  52. disbuf1[3]=disbuf[3]=minite%10;
  53. disbuf1[4]=disbuf[4]=minite/10;
  54. disbuf1[6]=disbuf[6]=hour%10;
  55. disbuf1[7]=disbuf[7]=hour/10;
  56.                
  57. }
  58. /***********暂停程序****************/
  59. void zd (void)                               
  60.          {          
  61.            uchar i;
  62.                 //hccx();
  63.           for(i=0;i<8;i++)
  64.          {
  65.                 P0=discode[disbuf[i]];
  66.                 P2=disbitcode[i];
  67.                 delay(100);       
  68.          }
  69.         }
  70.   /************闹钟初始化程序*********/
  71.         void naozhong (void)                               
  72.          {         
  73.          uchar i;
  74.             disbuf0[0]=second1%10;  //更新显示缓冲区
  75.                 disbuf0[1]=second1/10;
  76.                 disbuf0[3]=minite1%10;
  77.             disbuf0[4]=minite1/10;
  78.                 disbuf0[6]=hour1%10;       
  79.                 disbuf0[7]=hour1/10;                        
  80.           for(i=0;i<8;i++)
  81.          {
  82.                 P0=discode[disbuf0[i]];
  83.                 P2=disbitcode[i];
  84.                 delay(100);       
  85.          }
  86.         }
  87. /***********开机显示画面********/
  88. void shuma()
  89. {  
  90.            while((S1==1)&&(S2==1))
  91.         {
  92.         P0=0X8C;
  93.         P2=0X01;
  94.         }
  95. }
  96. /*************显示程序**************/
  97. void display(void)                  
  98.   {
  99.           uchar i;
  100.           for(i=0;i<8;i++)
  101.          {
  102.                 P0=discode[disbuf[i]];
  103.                 P2=disbitcode[i];
  104.                 delay(100);       
  105.         }
  106.   }
  107.   /*******设置成功画面***********/
  108.   void succer(void)                  
  109.   {
  110.           uchar i;
  111.             disbuf0[0]=second1%10;  //更新显示缓冲区
  112.                 disbuf0[1]=second1/10;
  113.                 disbuf0[3]=minite1%10;
  114.             disbuf0[4]=minite1/10;
  115.                 disbuf0[6]=hour1%10;       
  116.                 disbuf0[7]=hour1/10;
  117.           for(i=0;i<6;i++)
  118.          {
  119.                 P0=discode0[i];
  120.                 P2=disbitcode[i];
  121.                 delay(100);       
  122.         }
  123.   }
  124. /**************闹钟显示程序*********/
  125.         void naoxian(void)                  
  126.   {
  127.           uchar i;
  128.           for(i=0;i<8;i++)
  129.          {
  130.                 P0=0xff;
  131.                 P0=discode1[disbuf[i]];
  132.                 P2=disbitcode[i];
  133.                 delay(100);       
  134.         }
  135.   }
  136.   /***********调整显示程序**********/
  137.   void tzcx0()
  138.   {
  139.           uchar i;
  140.           for(i=0;i<8;i++)
  141.          {
  142.                 P0=discode[disbuf1[i]];
  143.                 P2=disbitcode[i];
  144.                 delay(100);       
  145.         }
  146.   }


  147. /*************中断程序**************/
  148. void t0(void) interrupt 1 using 0     //用第0组寄存器
  149.          {
  150.                   cent++;
  151.                  if(cent==20)
  152.                          {
  153.                            cent=0;
  154.                            second++;
  155.                            if(second==60)
  156.                                         {
  157.                                           second=0;
  158.                                           minite++;
  159.                                                            if(minite==60)
  160.                                                                 {
  161.                                                                         minite=0;
  162.                                                                         hour++;
  163.                                                                                 if(hour==24)
  164.                                                                                         {
  165.                                                                                                 hour=0;
  166.                                                                                         }
  167.                                                                 }
  168.                                                 }
  169.                                 disbuf[0]=second%10;  //更新显示缓冲区
  170.                             disbuf[1]=second/10;
  171.                                 disbuf[3]=minite%10;
  172.                                 disbuf[4]=minite/10;
  173.                                   disbuf[6]=hour%10;       
  174.                                 disbuf[7]=hour/10;                  
  175.                         }

  176.                   TH0=(65536-46082)/256;
  177.                   TL0=(65536-46082)%256;
  178.          }                                                       
  179. /************按键扫描程序*****************/
  180. uchar keyscan()
  181. {
  182. uchar tmp;                         //列号,行号
  183. P1=0xff;               //发全行0扫描码
  184. if((P1&0xff)!=0xff)     //若有键按下
  185.   {
  186.    delay(1000);          // 延时去抖   
  187.    if((P1&0xff)!=0xff)          //有键按下
  188.        {
  189.                 tmp=(P1&0xff);
  190.             do{}while((P1&0xff)!=0xff);
  191.                 tmp=~tmp;                  
  192.         return (tmp);                         //还回键值
  193.                            }                        
  194.     }                                                                                                                       
  195.    return (0);                                //无键按下,还回0
  196. }  
  197. /**************主程序************/
  198. void main(void)
  199. {                                                                                           
  200.          uchar i,a=0,b=0,c=0,d=0,e=0,f=0,v,nu=0,num=0,n=0;
  201.          ini();
  202.          shuma();
  203.           v=keyscan();
  204.          if(v==1||v==2||v==16||v==32||v==64||v==128)
  205.          {
  206.          while(1)
  207.          {
  208.            v=keyscan();
  209.      switch(v)
  210.            {
  211.             case 1:          
  212.                                   P3=0xff;
  213.                                   P2=0x00;
  214.                                   TR0=1;                                           /*开始时钟测试*/
  215.                           while(v==1||v==0)
  216.                               {
  217.                                          
  218.                               delay(10);
  219.                                           display();
  220.                                       v=keyscan();                 //调键扫描程序
  221.                                         }
  222.                                    break;

  223.                  case 2:  
  224.                          while(v==2||v==0)                                  /*暂停测试*/
  225.                              {
  226.                                       ET0=0;
  227.                               delay(10);
  228.                                           hccx();
  229.                                           zd();
  230.                                       v=keyscan();                            //调键扫描程序
  231.                                     }
  232.                                    break;
  233.          
  234.           case 16:       
  235.                     while(v==16||(v==0))                   /*调整测试*/
  236.               {
  237.                                           if(num<3) num++;
  238.                                         else {num=1;}
  239.                                          v=0;
  240.                                          while((num==1)&&(v==0))
  241.                          {               
  242.                                    hccx();
  243.                                 while(a==0)
  244.                                 {         
  245.                                      for(i=0;i<8;i++)
  246.                          {
  247.                              P0=discode[disbuf1[i]];
  248.                                     P2=disbitcode[i];
  249.                                        delay(100);       
  250.                                         }
  251.                                        
  252.                                                              a=keyscan();
  253.                                     
  254.                                 }  
  255.                               while(a==4)                                /*数码管显示数字0-7测试*/
  256.                                  {
  257.                                        second++;
  258.                                        if(second==60)
  259.                                                     {
  260.                                                        second=0;
  261.                                                        minite++;
  262.                                                                   if(minite==60)
  263.                                                                      {
  264.                                                                              minite=0;
  265.                                                                              hour++;
  266.                                                                                     if(hour==24)
  267.                                                                                         {
  268.                                                                                                 hour=0;
  269.                                                                                         }
  270.                                                                     }
  271.                                                        }
  272.                                                                hccx();
  273.                                                        tzcx0();                  //扫描间隙延时
  274.                                                        a=keyscan();                           //调键扫描程序
  275.                                       }
  276.                                        while(a==8)                           /*显示数字钟测试*/
  277.                                 {
  278.                                          second--;
  279.                                         if(second<=0)
  280.                                                   {
  281.                                                     second=59;
  282.                                                      minite--;
  283.                                                                   if(minite<=0)
  284.                                                                      {
  285.                                                                             minite=59;
  286.                                                                             hour--;
  287.                                                                                   if(hour<=0)
  288.                                                                                         {
  289.                                                                                                 hour=23;
  290.                                                                                         }
  291.                                                                     }
  292.                                                      }
  293.                                                              hccx();
  294.                                                    tzcx0();                  //扫描间隙延时
  295.                                                   a=keyscan();                           //调键扫描程序
  296.                                     }
  297.                                                      v=keyscan();                  
  298.                     }
  299.                  
  300.                                          while(num==2&&v==0)
  301.                                 {               
  302.                                         hccx();
  303.                                             while(b==0)
  304.                                     {         
  305.                                      for(i=0;i<8;i++)
  306.                          {
  307.                              P0=discode[disbuf1[i]];
  308.                                     P2=disbitcode[i];
  309.                                        delay(100);       
  310.                                         }
  311.                                          
  312.                                                           b=keyscan();
  313.                                         }
  314.                                          while(b==4)                                /*数码管显示数字0-7测试*/
  315.                                                         {
  316.                                                                            minite++;
  317.                                                                         if(minite==60)
  318.                                                                          {
  319.                                                                               minite=0;
  320.                                                                                hour++;
  321.                                                                                      if(hour==24)
  322.                                                                                            {
  323.                                                                                                 hour=0;
  324.                                                                                         }
  325.                                                                        }
  326.                                                                        hccx();
  327.                                                               tzcx0();                  //扫描间隙延时
  328.                                                               b=keyscan();                           //调键扫描程序
  329.                                                    }
  330.                                                  while(b==8)                           /*显示数字钟测试*/
  331.                                                            {
  332.                                                                             minite--;
  333.                                                                         if(minite<=0)
  334.                                                                     {
  335.                                                                               minite=59;
  336.                                                                               hour--;
  337.                                                                                      if(hour<=0)
  338.                                                                                         {
  339.                                                                                                 hour=23;
  340.                                                                                         }
  341.                                                                         }
  342.                                                               
  343.                                                                                 hccx();
  344.                                                                 tzcx0();                  //扫描间隙延时
  345.                                                                 b=keyscan();                           //调键扫描程序
  346.                                                       }                            
  347.                                                 v=keyscan();
  348.                                 }
  349.                                         while(num==3&&v==0)
  350.                                 {       
  351.                                            
  352.                                                  hccx();
  353.                                                  while(c==0)
  354.                                 {         
  355.                                      for(i=0;i<8;i++)
  356.                          {
  357.                              P0=discode[disbuf1[i]];
  358.                                     P2=disbitcode[i];
  359.                                        delay(100);       
  360.                                          }
  361.                                        
  362.                                                           c=keyscan();
  363.                           }
  364.                                                     while(c==4)                                /*数码管显示数字0-7测试*/
  365.                                                                      {       
  366.                                                                            hour++;
  367.                                                                                     if(hour==24)
  368.                                                                                         {
  369.                                                                                                 hour=0;
  370.                                                                                         }
  371.                                                                   hccx();
  372.                                                                                           tzcx0();                  //扫描间隙延时
  373.                                                                    c=keyscan();                           //调键扫描程序
  374.                                                      }
  375.                                                       while(c==8)                           /*显示数字钟测试*/
  376.                                                         {
  377.                                                                                  hour--;
  378.                                                                                      if(hour<=0)
  379.                                                                                         {
  380.                                                                                                 hour=23;
  381.                                                                                         }
  382.                                                                                                 hccx();
  383.                                                                    tzcx0();                  //扫描间隙延时
  384.                                                                    c=keyscan();                           //调键扫描程序
  385.                                                    }                                       
  386.                                v=keyscan();
  387.                     }
  388.                 }
  389.                                    break;

  390.           case 32:                                              /*数码管各段循环测试*/       
  391.                             while(v==32||v==0)
  392.                             {
  393.                                     ET0=1;
  394.                                         num=0;
  395.                                         a=b=c=0;
  396.                                         display();
  397.                                    v=keyscan();                            //调键扫描程序
  398.                                  }
  399.                            break;
  400.           
  401.          case 64:  
  402.                            while(v==64||v==0)
  403.                            {
  404.                                           if(nu<3) nu++;
  405.                                         else {nu=1;}
  406.                                          v=0;
  407.                                          while(nu==1&&v==0)
  408.                                          {
  409.                                            while(d==0)
  410.                                            {
  411.                                                   naozhong();
  412.                                                              d=keyscan();
  413.                                            }
  414.                                                             
  415.                                      while(d==4)                                /*数码管显示数字0-7测试*/
  416.                                       {
  417.                                              second1++;
  418.                                                if(second1==60)
  419.                                                       {
  420.                                                          second1=0;
  421.                                                          minite1++;
  422.                                                                      if(minite1==60)
  423.                                                                     {
  424.                                                                              minite1=0;
  425.                                                                             hour1++;
  426.                                                                                 if(hour1==24)
  427.                                                                                         {
  428.                                                                                                 hour1=0;
  429.                                                                                         }
  430.                                                                    }
  431.                                                           }
  432.                                                 naozhong();
  433.                                                         //naoxian();                  //扫描间隙延时
  434.                                                 d=keyscan();                           //调键扫描程序
  435.                                          }
  436.                                             while(d==8)                           /*显示数字钟测试*/
  437.                                      {
  438.                                                   second1--;
  439.                                              if(second1<=0)
  440.                                                      {
  441.                                                          second1=59;
  442.                                                          minite1--;
  443.                                                                      if(minite1<=0)
  444.                                                                      {
  445.                                                                               minite1=59;
  446.                                                                             hour1--;
  447.                                                                                 if(hour1<=0)
  448.                                                                                         {
  449.                                                                                                 hour1=23;
  450.                                                                                         }
  451.                                                                    }
  452.                                                        }
  453.                                           naozhong();
  454.                                           //naoxian();                  //扫描间隙延时
  455.                                          d=keyscan();                           //调键扫描程序
  456.                                         }
  457.                                         v=keyscan();                          
  458.                       }
  459.                         
  460.                                          while(nu==2&&v==0)
  461.                                          {
  462.                                           while(e==0)
  463.                                            {
  464.                                                   naozhong();
  465.                                                              e=keyscan();
  466.                                            }
  467.                                                  
  468.                                          while(e==4)                                /*数码管显示数字0-7测试*/
  469.                                                 {          
  470.                                                    minite1++;
  471.                                                                 if(minite1==60)
  472.                                                                {
  473.                                                                               minite1=0;
  474.                                                                             hour1++;
  475.                                                                                 if(hour1==24)
  476.                                                                                         {
  477.                                                                                                 hour1=0;
  478.                                                                                         }
  479.                                                                   }
  480.                                                         naozhong();
  481.                                                                 //        naoxian();                          //扫描间隙延时
  482.                                                         e=keyscan();                           //调键扫描程序
  483.                                               }
  484.                                                   while(e==8)                           /*显示数字钟测试*/
  485.                                                     {
  486.                                                           minite1--;
  487.                                                                 if(minite1<=0)
  488.                                                                    {
  489.                                                                             minite1=59;
  490.                                                                             hour1--;
  491.                                                                                 if(hour1<=0)
  492.                                                                                         {
  493.                                                                                                 hour1=23;
  494.                                                                                         }
  495.                                                                   }
  496.                                                  naozhong();
  497.                                                                          //naoxian();                 //扫描间隙延时
  498.                                                     e=keyscan();                           //调键扫描程序
  499.                                               }                            
  500.                                                 v=keyscan();                  
  501.                            }
  502.                                          
  503.                                        while(nu==3&&v==0)
  504.                                          {
  505.                                                   while(f==0)
  506.                                            {
  507.                                                   naozhong();
  508.                                                              f=keyscan();
  509.                                            }
  510.                                                             while(f==4)                                /*数码管显示数字0-7测试*/
  511.                                                                               {       
  512.                                                                              hour1++;
  513.                                                                                       if(hour1==24)
  514.                                                                                            {
  515.                                                                                                 hour1=0;
  516.                                                                                            }
  517.                                                                
  518.                                                                    naozhong();
  519.                                                                                         //naoxian();                  //扫描间隙延时
  520.                                                                 f=keyscan();                           //调键扫描程序
  521.                                                             }
  522.                                                             while(f==8)                           /*显示数字钟测试*/
  523.                                                               {
  524.                                                                                       hour1--;
  525.                                                                                       if(hour1<=0)
  526.                                                                                         {
  527.                                                                                                 hour1=23;
  528.                                                                                         }
  529.                                                        
  530.                                                              naozhong();
  531.                                                                                    //naoxian();                  //扫描间隙延时
  532.                                                               f=keyscan();                           //调键扫描程序
  533.                                                         }                             
  534.                                                v=keyscan();  
  535.                                              }
  536.                                                                                                 
  537.                           }
  538.                
  539.                            break;
  540.                   
  541.    case 128:  
  542.                P3=0XFF;
  543.                   while(v==128||v==0)
  544.                   {
  545.                                    if(n<2) n++;
  546.                                         else { n=1;}
  547.                                 v=0;
  548.                                 while(n==1&&v==0)
  549.                                 {
  550.                                       succer();
  551.                                 v=keyscan();
  552.                                        
  553.                                 }
  554.                                 while(n==2&&v==0)
  555.                                 {         
  556.                                     hccx();       
  557.                                 if(( disbuf0[0]==disbuf[0])&&(disbuf0[1]==disbuf[1])&&(disbuf0[3]==disbuf[3])&&(disbuf0[4]==disbuf[4])&&(disbuf0[6]==disbuf[6])&&(disbuf0[7]==disbuf[7]))
  558.                                   P3_1=0;
  559.                                    naoxian();
  560.                                  v=keyscan();
  561.                                 }
  562.                                                     
  563.                         }             
  564.                           break;
  565.                 }  
  566.     }
  567.   }
  568. }
  569.   
复制代码

闹钟.zip

48.65 KB, 下载次数: 4, 下载积分: 黑币 -5

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

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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