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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 单片机蓝桥杯第八届省赛程序参考 电子钟程序设计与调试
返回列表 发新帖
查看: 2562|回复: 0
打印 上一主题 下一主题
收起左侧

单片机蓝桥杯第八届省赛程序参考 电子钟程序设计与调试

[复制链接]
跳转到指定楼层
楼主
ID:841799 发表于 2021-5-27 13:51 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式


单片机源程序如下:
  1. #include<STC15F2K60S2.H>
  2. #include<intrins.h>
  3. #include "ds18b20.h"
  4. #include "ds1302.h"
  5. //#include "abc.h"
  6. #include "2.h"
  7. uchar code duanxuan[]={0XC0,0XF9,0XA4,0XB0,0X99,0X92,0X82,0XF8,0X80,0X90,0XBF,0XFF,0XC6};//0,1,2,3,4,5,6,7,8,9,-,空,c
  8. uchar code duanxuan1[]={0x40, 0x79, 0x24, 0x30, 0x19,0x12, 0x02, 0x78, 0x00, 0x10, 0xBF};//0~9带点1
  9. uchar code weixuan[]={0x01,0x02,0x04,0x08,0x10,0x20,0x40,0x80};
  10. uchar baojing=0,moshi=0,hour,min,sec,hour_i,hour_n=0,min_i,min_n=0,sec_i,sec_n=0,flase=0xff;
  11. uchar s1=0,s2=0,s3=0,s4=0,com=1;
  12. uint count0,count1,count3=0,wendu;
  13. bit flag,wendub=0;
  14. uchar time[7]={20,1,1,1,23,59,50};
  15. uchar du;  //数码显示扫描变量
  16. extern uchar shijian13[2];
  17. extern uchar ds[];
  18. void keyscan4();
  19. void all_chushihua();
  20. void xianshi0();
  21. void xianshi1();
  22. void xianshi2();
  23. void xianshi3();
  24. void xianshi4();
  25. void xianshi5();
  26. void xianshi6();
  27. void xian();
  28. void display();
  29. void writetime1();
  30. void readtime1();
  31. void Delay5ms();
  32. void main()
  33. {
  34.         all_chushihua();
  35.   writetime1();
  36.         TMOD &= 0xF0;                //设置定时器模式        //2ms T0定时器
  37.         TMOD |= 0x01;                //设置定时器模式
  38.         TL0 = 0xCD;                //设置定时初值
  39.         TH0 = 0xF8;                //设置定时初值
  40.         TF0 = 0;                //清除TF0标志
  41.         EA=1;
  42.         ET0=1;
  43.         TR0 = 1;                //定时器0开始计时
  44.         while(1)
  45.         {
  46.                 wendu=temget();
  47.                 readtime1();
  48.                 hour=time[4];min=time[5];sec=time[6];
  49.                 keyscan4();
  50.                 if((hour==hour_n)&&(min==min_n)&&(sec==sec_n))   
  51.                 {
  52.                         s1=0;
  53.                         s2=0;
  54.                         s3=0;
  55.                         s4=0;
  56.                         baojing=1;
  57.                         count0=0;
  58.                         count1=0;
  59.                 //        count2=0;
  60.                 }
  61.                
  62.         }
  63. }
  64. //***************资料包*********************//
  65. //void writetime1()
  66. //{
  67. //        uchar i,a,d=0x80;    //
  68. //        Ds1302_Single_Byte_Write(0x8e,0);  //
  69. //        for (i=0;i<7;i++)
  70. //        {
  71. //                a=time[6-i]/10;   //高四位
  72. //                a<<=4;

  74. //                a|=time[6-i]%10;    //低四位
  75. //                Ds1302_Single_Byte_Write(d,a);   //
  76. //                d+=2;     //
  77. //        }
  78. //        Ds1302_Single_Byte_Write(0x8e,0x80);   //
  79. //}
  80. //void readtime1()   //时间读取
  81. //{
  82. //        uchar i,a,d=0x81;
  83. //        Ds1302_Single_Byte_Write(0x8e,0);
  84. //        for (i=0;i<7;i++)
  85. //        {
  86. //                EA=0;/////!!!!!!!!!!!读数据加中断禁止，否则会出现偶然错误
  87. //                a=Ds1302_Single_Byte_Read(d);
  88. //                EA=1;
  89. //                SDA_R=0;        ///////!!!!每次读取一个字节要把IO口拉低或者延时
  90. //               
  91. //                time[6-i]=a/16*10+a%16;

  93. //                d+=2;
  94. //        }
  95. //        Ds1302_Single_Byte_Write(0x8e,0x80);
  96. //}
  97. //****************王玉帆资料驱动*****************//
  98. void writetime1()
  99. {
  100.         uchar i,a,d=0x80;    //
  101.         Write_Ds1302_Byte(0x8e,0);  //
  102.         for (i=0;i<7;i++)
  103.         {
  104.                 a=time[6-i]/10;   //高四位
  105.                 a<<=4;

  107.                 a|=time[6-i]%10;    //低四位
  108.                 Write_Ds1302_Byte(d,a);   //
  109.                 d+=2;     //
  110.         }
  111.         Write_Ds1302_Byte(0x8e,0x80);   //
  112. }
  113. void readtime1()   //时间读取
  114. {
  115.         uchar i,a,d=0x81;
  116.         Write_Ds1302_Byte(0x8e,0);
  117.         for (i=0;i<7;i++)
  118.         {
  119.                 EA=0;/////!!!!!!!!!!!读数据加中断禁止，否则会出现偶然错误
  120.                 a=Read_Ds1302_Byte(d);
  121.                 EA=1;
  122.                 SDA=0;        ///////!!!!每次读取一个字节要把IO口拉低或者延时
  123.                
  124.                 time[6-i]=a/16*10+a%16;

  126.                 d+=2;
  127.         }
  128.         Write_Ds1302_Byte(0x8e,0x80);
  129. }
  130. void all_chushihua()
  131. {
  132.         P0=0XFF;  //关闭LED灯
  133.         P2=(P2&0X1F)|0X80;  //Y4C=1;
  134.   P2=(P2&0X1F);
  135.         P0=0X00;   //关闭蜂鸣器，继电器
  136.   P2=(P2&0X1F)|0XA0;  //Y5C=1;
  137.   P2=(P2&0X1F);
  138.         P0=0XFF;  //选择所有数码管
  139.         P2=(P2&0X1F)|0XC0;  //Y6C=1;
  140.         P2=(P2&0X1F);
  141.         P0=0XFF;  //关闭所有数码管
  142.         P2=(P2&0X1F)|0XE0;  //Y7C=1;
  143.         P2=(P2&0X1F);
  144. }
  145. void keyscan4()
  146. {
  147.         if(P30==0)
  148.         {
  149.                 Delay5ms();
  150.                 if(P30==0)
  151.                 {
  152.                         s1=1;
  153.                         if(moshi==0)
  154.                         {
  155.                                 hour_i=hour;
  156.                           min_i=min;
  157.                           sec_i=sec;
  158.                         }
  159.                         if(moshi<4)
  160.                         moshi++;
  161.                         if(moshi>=4)
  162.                         {
  163.                                 time[6]=sec_i;
  164.                                 time[5]=min_i;
  165.                           time[4]=hour_i;
  166.                                 writetime1();
  167.                                 moshi=0;
  168.                         }
  169.                 }
  170.                 while(!P30);
  171.         }
  172.         if(P31==0)
  173.         {
  174.                 Delay5ms();
  175.                 if(P31==0)
  176.                 {
  177.                         s2=1;
  178.                  
  179.                   if(moshi>=4) moshi++;
  180.                   if(moshi==0) moshi=4;
  181.                   if(moshi>=7) moshi=0;
  182.                 }
  183.                  while(!P31);
  184.         }
  185.         if(P32==0)
  186.         {
  187.                 Delay5ms();
  188.                 if(P32==0)
  189.                 {
  190.                         s3=1;
  191.                         switch(moshi)
  192.                         {
  193.                                 case 1: hour_i++;if(hour_i>23) hour_i=0;break;
  194.                                 case 2: min_i++;if(min_i>59) min_i=0;break;
  195.                                 case 3: sec_i++;if(sec_i>=59) sec_i=0;break;
  196.                                 case 4: hour_n++;if(hour_n>=23) hour_n=0;break;
  197.                                 case 5: min_n++;if(min_n>=59) min_n=0;break;
  198.                                 case 6: sec_n++;if(sec_n>=59) sec_n=0;break;
  199.                         }
  200.                 }
  201.                 while(!P32);
  202.         }
  203.         if(P33==1)
  204.                 wendub=0;
  205.                 if(P33==0)
  206.                 {
  207.                         Delay5ms();
  208.                         if(P33==0)
  209.                         {
  210.                                 s4=1;
  211.                                 if(moshi==0)
  212.                                 {
  213.                                         wendu=temget();
  214.                                         wendub=1;
  215.                                 }
  216.                                 else
  217.                                 {        
  218.                                 
  219.                                 switch(moshi)
  220.                                 {
  221.                                         case 1: if(hour_i!=0) hour_i--;else hour_i=23;break;
  222.                                         case 2: if(min_i!=0) min_i--; else min_i=59;break;
  223.                                         case 3: if(sec_i!=0) sec_i--; else sec_i=59;break;
  224.                                         case 4: if(hour_n!=0) hour_n--;else  hour_n=23;break;
  225.                                         case 5: if(min_n!=0) min_n--; else min_n=59;break;
  226.                                         case 6: if(sec_n!=0) sec_n--; else sec_n=59;break;
  227.                                 }        
  228.                         }                                
  229.                         }
  230.                 }        
  231.                 while(!P33);
  232. }
  233. void xianshi0()
  234. {
  235.         if(!wendub)
  236.         {
  237.                 switch(du)
  238.                 {
  239.                         case 0:P0=duanxuan[hour/10];break;
  240.                         case 1:P0=duanxuan[hour%10];break;
  241.                         case 2:P0=duanxuan[10];break;
  242.                         case 3:P0=duanxuan[min/10];break;
  243.                         case 4:P0=duanxuan[min%10];break;
  244.                         case 5:P0=duanxuan[10];break;
  245.                         case 6:P0=duanxuan[sec/10];break;
  246.                         case 7:P0=duanxuan[sec%10];break;
  247.                 }
  248.   }
  249.         else
  250.         {
  251.                 switch(du)
  252.         {
  253.                 case 0:P0=duanxuan[11];break;
  254.                 case 1:P0=duanxuan[11];break;
  255.                 case 2:P0=duanxuan[11];break;
  256.                 case 3:P0=duanxuan[11];break;
  257.                 case 4:P0=duanxuan[wendu/1000%10];break;
  258.                 case 5:P0=duanxuan1[wendu/100%10];break;
  259.                 case 6:P0=duanxuan[wendu/10%10];break;
  260.                 case 7:P0=duanxuan[wendu%10];break;
  261.         }
  262.         }
  263. }
  264. void xianshi1()
  265. {
  266.         switch(du)
  267.         {
  268.                 case 0:P0=duanxuan[hour_i/10]|flase;break;
  269.                 case 1:P0=duanxuan[hour_i%10]|flase;break;
  270.                 case 2:P0=duanxuan[10];break;
  271.                 case 3:P0=duanxuan[min_i/10];break;
  272.                 case 4:P0=duanxuan[min_i%10];break;
  273.                 case 5:P0=duanxuan[10];break;
  274.                 case 6:P0=duanxuan[sec_i/10];break;
  275.                 case 7:P0=duanxuan[sec_i%10];break;
  276.         }

  278. }
  279. void xianshi2()
  280. {
  281.         switch(du)
  282.         {
  283.                 case 0:P0=duanxuan[hour_i/10];break;
  284.                 case 1:P0=duanxuan[hour_i%10];break;
  285.                 case 2:P0=duanxuan[10];break;
  286.                 case 3:P0=duanxuan[min_i/10]|flase;break;
  287.                 case 4:P0=duanxuan[min_i%10]|flase;break;
  288.                 case 5:P0=duanxuan[10];break;
  289.                 case 6:P0=duanxuan[sec_i/10];break;
  290.                 case 7:P0=duanxuan[sec_i%10];break;
  291.         }
  292. }
  293. void xianshi3()
  294. {
  295.         switch(du)
  296.         {
  297.                 case 0:P0=duanxuan[hour_i/10];break;
  298.                 case 1:P0=duanxuan[hour_i%10];break;
  299.                 case 2:P0=duanxuan[10];break;
  300.                 case 3:P0=duanxuan[min_i/10];break;
  301.                 case 4:P0=duanxuan[min_i%10];break;
  302.                 case 5:P0=duanxuan[10];break;
  303.                 case 6:P0=duanxuan[sec_i/10]|flase;break;
  304.                 case 7:P0=duanxuan[sec_i%10]|flase;break;
  305.         }
  306. }
  307. void xianshi4()
  308. {
  309.         switch(du)
  310.         {
  311.                 case 0:P0=duanxuan[hour_n/10]|flase;break;
  312.                 case 1:P0=duanxuan[hour_n%10]|flase;break;
  313.                 case 2:P0=duanxuan[10];break;
  314.                 case 3:P0=duanxuan[min_n/10];break;
  315.                 case 4:P0=duanxuan[min_n%10];break;
  316.                 case 5:P0=duanxuan[10];break;
  317.                 case 6:P0=duanxuan[sec_n/10];break;
  318.                 case 7:P0=duanxuan[sec_n%10];break;
  319.         }
  320. }
  321. void xianshi5()
  322. {
  323.         switch(du)
  324.         {
  325.                 case 0:P0=duanxuan[hour_n/10];break;
  326.                 case 1:P0=duanxuan[hour_n%10];break;
  327.                 case 2:P0=duanxuan[10];break;
  328.                 case 3:P0=duanxuan[min_n/10]|flase;break;
  329.                 case 4:P0=duanxuan[min_n%10]|flase;break;
  330.                 case 5:P0=duanxuan[10];break;
  331.                 case 6:P0=duanxuan[sec_n/10];break;
  332.                 case 7:P0=duanxuan[sec_n%10];break;
  333.         }
  334. }
  335. void xianshi6()
  336. {
  337.         switch(du)
  338.         {
  339.                 case 0:P0=duanxuan[hour_n/10];break;
  340.                 case 1:P0=duanxuan[hour_n%10];break;
  341.                 case 2:P0=duanxuan[10];break;
  342.                 case 3:P0=duanxuan[min_n/10];break;
  343.                 case 4:P0=duanxuan[min_n%10];break;
  344.                 case 5:P0=duanxuan[10];break;
  345.                 case 6:P0=duanxuan[sec_n/10]|flase;break;
  346.                 case 7:P0=duanxuan[sec_n%10]|flase;break;
  347.         }
  348. }

  350. void xian()
  351. {
  352.         switch(moshi)
  353.         {
  354.     case 0:xianshi0();break;
  355.                 case 1:xianshi1();break;
  356.                 case 2:xianshi2();break;
  357.                 case 3:xianshi3();break;
  358.                 case 4:xianshi4();break;
  359.                 case 5:xianshi5();break;
  360.                 case 6:xianshi6();break;
  361.         }
  362. }        
  363. void display()
  364. {
  365.         
  366.   P0=weixuan[du];
  367.         P2=(P2&0X1F)|0xc0;
  368.         P2=(P2&0X1F);
  369.         xian();
  370.         P2=(P2&0X1F)|0XE0;
  371.         P2=(P2&0X1F);
  372.         if(++du>7) du=0;
  373. }

  375. void led(uchar liang)
  376. {
  377.         P0=liang;
  378.         P2=(P2&0x1f)|0x80;
  379.         P2=(P2&0x1f);
  380. }
  381. void T1dingshiqi() interrupt 1
  382. {
  383.         
  384.         display();                                                                //用于控制整体时钟变化
  385.         count1++;                                                                //用于控制LED灯闪烁
  386.         count0++;
  387.         count3++;
  388.         if(baojing==1)                                        //让灯闪烁时间间隔位0.2秒
  389.                 {

  391.                         if(count1>=100)
  392.                                 {
  393.                                                 count1=0;
  394.                                         if(flag==0)
  395.                                                 {
  396.                                                         flag=1;
  397.                                                         led(0xfe);
  398.                                                 }
  399.                                         else
  400.                                                 {
  401.                                                         flag=0;
  402.                                                         led(0xff);
  403.                                                 }
  404.                                 }
  405.                                 if((s1==1)||(s2==1)||(s3==1)||(s4==1))
  406.                                 {
  407.                                         s1=0;
  408.                                         s2=0;
  409.                                         s3=0;
  410.                                         s4=0;
  411.                                         led(0xff);
  412.                                         baojing=0;
  413.                                 }
  414.                         //count0++;
  415.                                 if(count0>=2500)
  416.                                         {
  417.                                                 count0=0;
  418.                                                 led(0xff);
  419.                                                 baojing=0;
  420. //                                                 count2++;                //限定灯就闪烁5秒
  421. //                                                if(count2>=5)
  422. //                                                        {
  423. //                                                                led(0xff);
  424. //                                                                baojing=0;
  425. //                                                        }                                                         //在设定时间的时候让设置的数字以间隔为一秒闪烁
  426.                                         }        
  427.                 }
  428.         else
  429.                 {
  430.                         led(0xff);
  431.                 }        
  432.   if(count3>=500)
  433.         {
  434.                 count3=0;
  435.                 flase=~flase;
  436.         }
  437.         TL0 = 0xCD;                //设置定时初值
  438.         TH0 = 0xF8;                //设置定时初值

  440. }
  441. void Delay5ms()                //@11.0592MHz
  442. {
  443.         unsigned char i, j;

  445.         i = 54;
  446.         j = 199;
  447.         do
  448.         {
  449.                 while (--j);
  450.         } while (--i);
  451. }
复制代码

所有资料51hei提供下载:
蓝桥杯大赛第8届.rar (209.71 KB, 下载次数: 24)

评分

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

查看全部评分

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

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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