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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › 单片机DIY制作 › DIY梦幻十字旋转屏，MP3、电子时钟、电子音乐的综合体！ ...
返回列表 发新帖
查看: 2664|回复: 2
打印 上一主题 下一主题
收起左侧

DIY梦幻十字旋转屏，MP3、电子时钟、电子音乐的综合体！附单片机源码

[复制链接]
跳转到指定楼层
楼主
ID:432864 发表于 2018-11-25 15:33 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
电路原理图如下：


制作出来的实物图如下：


单片机源程序如下:
  1. #include <reg52.h>
  2. #include <intrins.h>
  3. #include "LED_STRING.h"
  4. #include "DS1302.h"

  6. sfr XICON=0xc0;                                 //定义STC89C52中断特殊功能寄存器

  8. sbit PX3=XICON^7;
  9. sbit EX3=XICON^6;
  10. sbit IE3=XICON^5;
  11. sbit IT3=XICON^4;
  12. sbit PX2=XICON^3;
  13. sbit EX2=XICON^2;
  14. sbit IE2=XICON^1;
  15. sbit IT2=XICON^0;

  17. sbit IR=P4^2;                        //红外
  18. uchar a[4];                         //存储红外解出来的厂家编码和键码值及它们的反码
  19. uint LowTime,HighTime;         //存储高低电平宽度的变量
  20. uchar L_OnTime,display_flag,time_count,time_count0,time_count1,effect;
  21. uchar led_0,led_1,display_n,KeyVal;
  22. bit IR_Flag,display_time_flag,set_second_flag;
  23. uchar set_count,set_year,set_month,set_day,set_week;
  24. char set_hour,set_minute,set_second;
  25. uchar set_year_tmp,set_month_tmp,set_day_tmp,set_week_tmp,set_hour_tmp,set_minute_tmp;

  27. /*延迟机器周期级的短延迟*/
  28. void delay(uchar z)
  29. {
  30.         while (z--)
  31.         _nop_();
  32. }

  34. /*开机初始画面*/
  35. void open_display()
  36. {
  37.         uchar i;
  38.         uint led_0,led_1,count,num;
  39. L_OnTime++;
  40. num++;
  41. count=num;
  42. if(num>(16*15))
  43. {
  44. display_flag=1;
  45. TR1=1;
  46. }
  47.          if(L_OnTime>65) L_OnTime=65;

  49.         for(i=0;i<L_OnTime;i++)
  50.                 {
  51.                 count--;
  52.                 led_0=count*2+1;
  53.                 led_1=count*2;
  54.                 delay(60);
  55.                 P3=tab_open[led_0];
  56.                 P1=tab_open[led_1];
  57.                 P0=tab_open[led_0];
  58.                 P2=tab_open[led_1];
  59.                 delay(30);
  60.                 P1=0xff;
  61.                 P3=0xff;
  62.                 P0=0xff;
  63.                 P2=0xff;
  64.                 delay(3);
  65.                 }
  66. }


  69. /*LOVE画面*/
  70. void love_display()
  71. {
  72.         uchar i;
  73.         uint led_0,led_1,count,num;

  75. L_OnTime++;
  76. num++;
  77. count=num;
  78. if(num>(16*13)) num=0;
  79.          if(effect==0)
  80.         {
  81.                  if(L_OnTime>65) L_OnTime=65;
  82.         }
  83.         else
  84.         {
  85.                  if(L_OnTime>125) L_OnTime=125;
  86.         }

  88.         for(i=0;i<L_OnTime;i++)
  89.                 {
  90.                 count--;
  91.                 led_0=count*2+1;
  92.                 led_1=count*2;
  93.                 delay(60);
  94.                         if(effect==0)
  95.                         {
  96.                         P3=tab_love[led_0];
  97.                         P1=tab_love[led_1];
  98.                         P0=tab_love[led_0];
  99.                         P2=tab_love[led_1];
  100.                         }
  101.                         else if(effect==1)
  102.                         {
  103.                         P0=tab_love[led_0];
  104.                         P2=tab_love[led_1];
  105.                         }
  106.                         else
  107.                         {
  108.                         P3=tab_love[led_0];
  109.                         P1=tab_love[led_1];
  110.                         }
  111.                 delay(30);
  112.                 P1=0xff;
  113.                 P3=0xff;
  114.                 P0=0xff;
  115.                 P2=0xff;
  116.                 delay(3);               
  117.                 }
  118. }

  120. /*显示“年、月、日、星期”*/
  121. void time0_display()
  122. {
  123. uchar time_count0=8;
  124. uchar time_count1=16;
  125. int time_count=159;
  126. uchar i;
  127. uchar L_0=159;
  128.         for(i=0;i<L_0;i++)
  129.         {
  130.                 if(time_count>143&&time_count<160)                                        //星期值
  131.                 {
  132.                 led_0=((ReadSet1302(0x8b)&0x0f)-1)*32+(time_count1*2)-1;
  133.                 led_1=((ReadSet1302(0x8b)&0x0f)-1)*32+(time_count1*2)-2;
  134.                 P3=tab_xingqi[led_0];
  135.                 P1=tab_xingqi[led_1];
  136.                 if(--time_count1<1) time_count1=16;
  137.                 }
  138.                 else if(time_count>127&&time_count<144)                                        //“期“
  139.                 {                                                                        
  140.                 led_0=3*32+(time_count1*2)-1;
  141.                 led_1=3*32+(time_count1*2)-2;
  142.                 P3=tab_time[led_0];
  143.                 P1=tab_time[led_1];
  144.                 delay(65);
  145.                 if(--time_count1<1) time_count1=16;
  146.                 }

  148.                 else if(time_count>111&&time_count<128)                                        //“星“
  149.                 {                                                                        
  150.                 led_0=2*32+(time_count1*2)-1;
  151.                 led_1=2*32+(time_count1*2)-2;
  152.                 P3=tab_time[led_0];
  153.                 P1=tab_time[led_1];
  154.                 delay(65);
  155.                 if(--time_count1<1) time_count1=16;
  156.                 }


  159.                 else if(time_count>95&&time_count<112)                                        //“日“
  160.                 {                                                                        
  161.                 led_0=6*32+(time_count1*2)-1;
  162.                 led_1=6*32+(time_count1*2)-2;
  163.                 P3=tab_xingqi[led_0];
  164.                 P1=tab_xingqi[led_1];
  165.                 delay(65);
  166.                 if(--time_count1<1) time_count1=16;
  167.                 }

  169.                 else if(time_count>87&&time_count<96)                                                                  //”日“ 个位
  170.                 {
  171.                 led_0=((ReadSet1302(0x87)&0x0f)*16)+(time_count0*2)-1;
  172.                 led_1=((ReadSet1302(0x87)&0x0f)*16)+(time_count0*2)-2;
  173.                 P3=tab_num[led_0];
  174.                 P1=tab_num[led_1];
  175.                 if(--time_count0<1) time_count0=8;
  176.                 }
  177.                 else if(time_count>79&&time_count<88)                                                                 //”日“ 十位
  178.                 {
  179.                 led_0=((ReadSet1302(0x87)>>4)*16)+(time_count0*2)-1;
  180.                 led_1=((ReadSet1302(0x87)>>4)*16)+(time_count0*2)-2;
  181.                 P3=tab_num[led_0];
  182.                 P1=tab_num[led_1];
  183.                 if(--time_count0<1) time_count0=8;
  184.                 }
  185.                                 
  186.                 else if(time_count>63&&time_count<80)                                        //“月“        
  187.                 {                                                               
  188.                 led_0=1*32+(time_count1*2)-1;
  189.                 led_1=1*32+(time_count1*2)-2;
  190.                 P3=tab_time[led_0];
  191.                 P1=tab_time[led_1];
  192.                 delay(65);
  193.                 if(--time_count1<1) time_count1=16;
  194.                 }
  195.                                                                                                                                        
  196.                 else if(time_count>55&&time_count<64)                                                                  //”月“ 个位
  197.                 {
  198.                 led_0=((ReadSet1302(0x89)&0x0f)*16)+(time_count0*2)-1;
  199.                 led_1=((ReadSet1302(0x89)&0x0f)*16)+(time_count0*2)-2;
  200.                 P3=tab_num[led_0];
  201.                 P1=tab_num[led_1];
  202.                 if(--time_count0<1) time_count0=8;
  203.                 }
  204.                 else if(time_count>47&&time_count<56)                                                                 //”月“ 十位
  205.                 {
  206.                 led_0=((ReadSet1302(0x89)>>4)*16)+(time_count0*2)-1;
  207.                 led_1=((ReadSet1302(0x89)>>4)*16)+(time_count0*2)-2;
  208.                 P3=tab_num[led_0];
  209.                 P1=tab_num[led_1];
  210.                 if(--time_count0<1) time_count0=8;                                                                                                                        
  211.                 }

  213.                 else if(time_count>31&&time_count<48)                                        //“年“        
  214.                 {                                                               
  215.                 led_0=0*32+(time_count1*2)-1;
  216.                 led_1=0*32+(time_count1*2)-2;
  217.                 P3=tab_time[led_0];
  218.                 P1=tab_time[led_1];
  219.                 delay(65);
  220.                 if(--time_count1<1) time_count1=16;
  221.                 }

  223.                 else if(time_count>23&&time_count<32)                                                                  //”年“ 个位
  224.                 {
  225.                 led_0=((ReadSet1302(0x8d)&0x0f)*16)+(time_count0*2)-1;
  226.                 led_1=((ReadSet1302(0x8d)&0x0f)*16)+(time_count0*2)-2;
  227.                 P3=tab_num[led_0];
  228.                 P1=tab_num[led_1];
  229.                 if(--time_count0<1) time_count0=8;
  230.                 }
  231.                 else if(time_count>15&&time_count<24)                                                                 //”年“ 十位
  232.                 {
  233.                 led_0=((ReadSet1302(0x8d)>>4)*16)+(time_count0*2)-1;
  234.                 led_1=((ReadSet1302(0x8d)>>4)*16)+(time_count0*2)-2;
  235.                 P3=tab_num[led_0];
  236.                 P1=tab_num[led_1];
  237.                 if(--time_count0<1) time_count0=8;                                                                                                                        
  238.                 }
  239.                 else if(time_count>7&&time_count<16)                                                                 //"0"
  240.                 {
  241.                 led_0=(0*16)+(time_count0*2)-1;
  242.                 led_1=(0*16)+(time_count0*2)-2;
  243.                 P3=tab_num[led_0];
  244.                 P1=tab_num[led_1];
  245.                 delay(70);                                                                                                                                //延迟，使得在这里处理的时间与处理1302的时间相同
  246.                 if(--time_count0<1) time_count0=8;
  247.                 }
  248.                 else if(time_count>=0&&time_count<8)                                                                 //"2"
  249.                 {
  250.                 led_0=(2*16)+(time_count0*2)-1;
  251.                 led_1=(2*16)+(time_count0*2)-2;
  252.                 P3=tab_num[led_0];
  253.                 P1=tab_num[led_1];
  254.                 delay(70);                                                                                                                                //延迟，使得在这里处理的时间与处理1302的时间相同
  255.                 if(--time_count0<1) time_count0=8;
  256.                 }

  258.         if(--time_count<0)
  259.         {
  260.         time_count=159;
  261.         time_count0=8;
  262.         time_count1=16;
  263.         }

  265.         }
  266.                 delay(95);
  267.                 P3=0xff;
  268.                 P1=0xff;
  269.                 delay(5);
  270. }

  272. /*显示“时、分、秒”*/
  273. void time1_display()
  274. {
  275. uchar time_count1=8;
  276. char time_count=79;
  277. uchar i;
  278. uchar L_0=79;
  279.         for(i=0;i<L_0;i++)
  280.         {
  281.                 if(time_count>63)
  282.                 {
  283.                 delay(123);                                                                  //整屏左移
  284.                 }
  285.                 else if(time_count>55&&time_count<64)                                                                                                         //秒个位
  286.                 {
  287.                 led_0=((ReadSet1302(0x81)&0x0f)*16)+(time_count1*2)-1;
  288.                 led_1=((ReadSet1302(0x81)&0x0f)*16)+(time_count1*2)-2;
  289.                 P3=tab_num[led_0];
  290.                 P1=tab_num[led_1];
  291.                 }
  292.                 else if(time_count>47&&time_count<56)                                                                  //秒十位
  293.                 {
  294.                 led_0=((ReadSet1302(0x81)>>4)*16)+(time_count1*2)-1;
  295.                 led_1=((ReadSet1302(0x81)>>4)*16)+(time_count1*2)-2;
  296.                 P3=tab_num[led_0];
  297.                 P1=tab_num[led_1];
  298.                 }
  299.                 else if(time_count>39&&time_count<48)                                                                   //冒号
  300.                 {
  301.                 led_0=(10*16)+(time_count1*2)-1;
  302.                 led_1=(10*16)+(time_count1*2)-2;
  303.                 P3=tab_num[led_0];
  304.                 P1=tab_num[led_1];
  305.                 delay(70);                                                                                                                                //延迟，使得在这里处理的时间与处理1302的时间相同
  306.                 }
  307.                 else if(time_count>31&&time_count<40)                                                                   //分个位
  308.                 {
  309.                 led_0=((ReadSet1302(0x83)&0x0f)*16)+(time_count1*2)-1;
  310.                 led_1=((ReadSet1302(0x83)&0x0f)*16)+(time_count1*2)-2;
  311.                 P3=tab_num[led_0];
  312.                 P1=tab_num[led_1];
  313.                 }
  314.                 else if(time_count>23&&time_count<32)                                                                   //分十位
  315.                 {
  316.                 led_0=((ReadSet1302(0x83)>>4)*16)+(time_count1*2)-1;
  317.                 led_1=((ReadSet1302(0x83)>>4)*16)+(time_count1*2)-2;
  318.                 P3=tab_num[led_0];
  319.                 P1=tab_num[led_1];
  320.                 }
  321.                 else if(time_count>15&&time_count<24)                                                                   //冒号
  322.                 {
  323.                 led_0=(10*16)+(time_count1*2)-1;
  324.                 led_1=(10*16)+(time_count1*2)-2;
  325.                 P3=tab_num[led_0];
  326.                 P1=tab_num[led_1];
  327.                 delay(70);
  328.                 }
  329.                 else if(time_count>7&&time_count<16)                                                                   //时个位
  330.                 {
  331.                 led_0=((ReadSet1302(0x85)&0x0f)*16)+(time_count1*2)-1;
  332.                 led_1=((ReadSet1302(0x85)&0x0f)*16)+(time_count1*2)-2;
  333.                 P3=tab_num[led_0];
  334.                 P1=tab_num[led_1];
  335.                 }
  336.                 else if(time_count>=0&&time_count<8)                                                                   //时十位
  337.                 {
  338.                 led_0=((ReadSet1302(0x85)>>4)*16)+(time_count1*2)-1;
  339.                 led_1=((ReadSet1302(0x85)>>4)*16)+(time_count1*2)-2;
  340.                 P3=tab_num[led_0];
  341.                 P1=tab_num[led_1];
  342.                 }
  343.         if(--time_count1<1) time_count1=8;
  344.         if(--time_count<0)
  345.         {
  346.         time_count=79;
  347.         time_count1=8;
  348.         }

  350.         }
  351.                 delay(95);
  352.                 P3=0xff;
  353.                 P1=0xff;
  354.                 delay(5);


  357. }


  360. /*调“年、月、日、星期、时、分、秒”*/

  362. void set_time_display()
  363. {

  365. uchar time_count0=8;
  366. uchar time_count1=16;
  367. int time_count=71;
  368. uchar i;
  369. uchar L_0=71;
  370.                 switch(set_count)
  371.                 {
  372.                         case 1:
  373.                         {
  374.                         for(i=0;i<L_0;i++)
  375.                         {
  376.                                 if(time_count>55)
  377.                                 {
  378.                                 delay(85);                                                                  //整屏左移
  379.                                 }
  380.                                 else if(time_count>47&&time_count<56)
  381.                                 {
  382.                                 led_0=(set_year%10)*16+(time_count0*2)-1;
  383.                                 led_1=(set_year%10)*16+(time_count0*2)-2;
  384.                                 P3=tab_num[led_0];
  385.                                 P1=tab_num[led_1];
  386.                                 if(--time_count0<1) time_count0=8;
  387.                                 }
  388.                                 else if(time_count>39&&time_count<48)
  389.                                 {
  390.                                 led_0=(set_year/10)*16+(time_count0*2)-1;
  391.                                 led_1=(set_year/10)*16+(time_count0*2)-2;
  392.                                 P3=tab_num[led_0];
  393.                                 P1=tab_num[led_1];
  394.                                 if(--time_count0<1) time_count0=8;
  395.                                 }
  396.                                 else if(time_count>31&&time_count<40)                           //冒号
  397.                                 {
  398.                                 led_0=(10*16)+(time_count0*2)-1;
  399.                                 led_1=(10*16)+(time_count0*2)-2;
  400.                                 P3=tab_num[led_0];
  401.                                 P1=tab_num[led_1];
  402.                                 if(--time_count0<1) time_count0=8;               
  403.                                 }
  404.                                 else if(time_count>15&&time_count<32)                           //“年”
  405.                                 {
  406.                                 led_0=0*32+(time_count1*2)-1;
  407.                                 led_1=0*32+(time_count1*2)-2;
  408.                                 P3=tab_time[led_0];
  409.                                 P1=tab_time[led_1];
  410.                                 if(--time_count1<1) time_count1=16;
  411.                                 }
  412.                                 else if(time_count>=0&&time_count<16)                           //“调”
  413.                                 {
  414.                                 led_0=4*32+(time_count1*2)-1;
  415.                                 led_1=4*32+(time_count1*2)-2;
  416.                                 P3=tab_time[led_0];
  417.                                 P1=tab_time[led_1];
  418.                                 if(--time_count1<1) time_count1=16;
  419.                                 }                                                
  420.                                  delay(70);
  421.                                 if(--time_count<0)
  422.                                 {
  423.                                 time_count=71;
  424.                                 time_count0=8;
  425.                                 time_count1=16;
  426.                                 }
  427.                         }
  428.                 }
  429.                 break;
  430.                 case 2:
  431.                 {
  432.                         for(i=0;i<L_0;i++)
  433.                         {
  434.                                 if(time_count>55)
  435.                                 {
  436.                                 delay(85);                                                                  //整屏左移
  437.                                 }
  438.                                 else if(time_count>47&&time_count<56)
  439.                                 {
  440.                                 led_0=(set_month%10)*16+(time_count0*2)-1;
  441.                                 led_1=(set_month%10)*16+(time_count0*2)-2;
  442.                                 P3=tab_num[led_0];
  443.                                 P1=tab_num[led_1];
  444.                                 if(--time_count0<1) time_count0=8;
  445.                                 }
  446.                                 else if(time_count>39&&time_count<48)
  447.                                 {
  448.                                 led_0=(set_month/10)*16+(time_count0*2)-1;
  449.                                 led_1=(set_month/10)*16+(time_count0*2)-2;
  450.                                 P3=tab_num[led_0];
  451.                                 P1=tab_num[led_1];
  452.                                 if(--time_count0<1) time_count0=8;
  453.                                 }
  454.                                 else if(time_count>31&&time_count<40)                           //冒号
  455.                                 {
  456.                                 led_0=(10*16)+(time_count0*2)-1;
  457.                                 led_1=(10*16)+(time_count0*2)-2;
  458.                                 P3=tab_num[led_0];
  459.                                 P1=tab_num[led_1];
  460.                                 if(--time_count0<1) time_count0=8;               
  461.                                 }
  462.                                 else if(time_count>15&&time_count<32)                           //“月”
  463.                                 {
  464.                                 led_0=1*32+(time_count1*2)-1;
  465.                                 led_1=1*32+(time_count1*2)-2;
  466.                                 P3=tab_time[led_0];
  467.                                 P1=tab_time[led_1];
  468.                                 if(--time_count1<1) time_count1=16;
  469.                                 }
  470.                                 else if(time_count>=0&&time_count<16)                           //“调”
  471.                                 {
  472.                                 led_0=4*32+(time_count1*2)-1;
  473.                                 led_1=4*32+(time_count1*2)-2;
  474.                                 P3=tab_time[led_0];
  475.                                 P1=tab_time[led_1];
  476.                                 if(--time_count1<1) time_count1=16;
  477.                                 }                                                
  478.                                  delay(70);
  479.                                 if(--time_count<0)
  480.                                 {
  481.                                 time_count=71;
  482.                                 time_count0=8;
  483.                                 time_count1=16;
  484.                                 }
  485.                         }
  486.                 }
  487.                 break;
  488.                 case 3:
  489.                 {
  490.                         for(i=0;i<L_0;i++)
  491.                         {
  492.                                 if(time_count>55)
  493.                                 {
  494.                                 delay(85);                                                                  //整屏左移
  495.                                 }
  496.                                 else if(time_count>47&&time_count<56)
  497.                                 {
  498.                                 led_0=(set_day%10)*16+(time_count0*2)-1;
  499.                                 led_1=(set_day%10)*16+(time_count0*2)-2;
  500.                                 P3=tab_num[led_0];
  501.                                 P1=tab_num[led_1];
  502.                                 if(--time_count0<1) time_count0=8;
  503.                                 }
  504.                                 else if(time_count>39&&time_count<48)
  505.                                 {
  506.                                 led_0=(set_day/10)*16+(time_count0*2)-1;
  507.                                 led_1=(set_day/10)*16+(time_count0*2)-2;
  508.                                 P3=tab_num[led_0];
  509.                                 P1=tab_num[led_1];
  510.                                 if(--time_count0<1) time_count0=8;
  511.                                 }
  512.                                 else if(time_count>31&&time_count<40)                           //冒号
  513.                                 {
  514.                                 led_0=(10*16)+(time_count0*2)-1;
  515.                                 led_1=(10*16)+(time_count0*2)-2;
  516.                                 P3=tab_num[led_0];
  517.                                 P1=tab_num[led_1];
  518.                                 if(--time_count0<1) time_count0=8;               
  519.                                 }
  520.                                 else if(time_count>15&&time_count<32)                           //“日”
  521.                                 {
  522.                                 led_0=6*32+(time_count1*2)-1;
  523.                                 led_1=6*32+(time_count1*2)-2;
  524.                                 P3=tab_xingqi[led_0];
  525.                                 P1=tab_xingqi[led_1];
  526.                                 if(--time_count1<1) time_count1=16;
  527.                                 }
  528.                                 else if(time_count>=0&&time_count<16)                           //“调”
  529.                                 {
  530.                                 led_0=4*32+(time_count1*2)-1;
  531.                                 led_1=4*32+(time_count1*2)-2;
  532.                                 P3=tab_time[led_0];
  533.                                 P1=tab_time[led_1];
  534.                                 if(--time_count1<1) time_count1=16;
  535.                                 }                                                
  536.                                  delay(70);

  538.                                 if(--time_count<0)
  539.                                 {
  540.                                 time_count=71;
  541.                                 time_count0=8;
  542.                                 time_count1=16;
  543.                                 }
  544.                         }

  546.                 }
  547.                 break;
  548.                 case 4:
  549.                 {
  550.                 for(i=0;i<L_0;i++)
  551.                         {
  552.                                 if(time_count>55)
  553.                                 {
  554.                                 delay(85);                                                                  //整屏左移
  555.                                 }
  556.                                 else if(time_count>39&&time_count<56)                                         //设置星期的值
  557.                                 {
  558.                                 led_0=(set_week-1)*32+(time_count1*2)-1;
  559.                                 led_1=(set_week-1)*32+(time_count1*2)-2;
  560.                                 P3=tab_xingqi[led_0];
  561.                                 P1=tab_xingqi[led_1];
  562.                                 if(--time_count1<1) time_count1=16;
  563.                                 }
  564.                                 else if(time_count>31&&time_count<40)                                  //冒号
  565.                                 {
  566.                                 led_0=(10*16)+(time_count0*2)-1;
  567.                                 led_1=(10*16)+(time_count0*2)-2;
  568.                                 P3=tab_num[led_0];
  569.                                 P1=tab_num[led_1];
  570.                                 if(--time_count0<1) time_count0=8;
  571.                                 }

  573.                                 else if(time_count>15&&time_count<32)                           //“星”
  574.                                 {
  575.                                 led_0=2*32+(time_count1*2)-1;
  576.                                 led_1=2*32+(time_count1*2)-2;
  577.                                 P3=tab_time[led_0];
  578.                                 P1=tab_time[led_1];
  579.                                 if(--time_count1<1) time_count1=16;
  580.                                 }
  581.                                 else if(time_count>=0&&time_count<16)                           //“调”
  582.                                 {
  583.                                 led_0=4*32+(time_count1*2)-1;
  584.                                 led_1=4*32+(time_count1*2)-2;
  585.                                 P3=tab_time[led_0];
  586.                                 P1=tab_time[led_1];
  587.                                 if(--time_count1<1) time_count1=16;
  588.                                 }                                                
  589.                                  delay(70);

  591.                                 if(--time_count<0)
  592.                                 {
  593.                                 time_count=71;
  594.                                 time_count0=8;
  595.                                 time_count1=16;
  596.                                 }
  597.                         }
  598.                 }
  599.                 break;
  600.                 case 5:
  601.                 {
  602.                         for(i=0;i<L_0;i++)
  603.                         {
  604.                                 if(time_count>55)
  605.                                 {
  606.                                 delay(85);                                                                  //整屏左移
  607.                                 }
  608.                                 else if(time_count>47&&time_count<56)
  609.                                 {
  610.                                 led_0=(set_hour%10)*16+(time_count0*2)-1;
  611.                                 led_1=(set_hour%10)*16+(time_count0*2)-2;
  612.                                 P3=tab_num[led_0];
  613.                                 P1=tab_num[led_1];
  614.                                 if(--time_count0<1) time_count0=8;
  615.                                 }
  616.                                 else if(time_count>39&&time_count<48)
  617.                                 {
  618.                                 led_0=(set_hour/10)*16+(time_count0*2)-1;
  619.                                 led_1=(set_hour/10)*16+(time_count0*2)-2;
  620.                                 P3=tab_num[led_0];
  621.                                 P1=tab_num[led_1];
  622.                                 if(--time_count0<1) time_count0=8;
  623.                                 }
  624.                                 else if(time_count>31&&time_count<40)                           //冒号
  625.                                 {
  626.                                 led_0=(10*16)+(time_count0*2)-1;
  627.                                 led_1=(10*16)+(time_count0*2)-2;
  628.                                 P3=tab_num[led_0];
  629.                                 P1=tab_num[led_1];
  630.                                 if(--time_count0<1) time_count0=8;               
  631.                                 }
  632.                                 else if(time_count>15&&time_count<32)                           //“时”
  633.                                 {
  634.                                 led_0=5*32+(time_count1*2)-1;
  635.                                 led_1=5*32+(time_count1*2)-2;
  636.                                 P3=tab_time[led_0];
  637.                                 P1=tab_time[led_1];
  638.                                 if(--time_count1<1) time_count1=16;
  639.                                 }
  640.                                 else if(time_count>=0&&time_count<16)                           //“调”
  641.                                 {
  642.                                 led_0=4*32+(time_count1*2)-1;
  643.                                 led_1=4*32+(time_count1*2)-2;
  644.                                 P3=tab_time[led_0];
  645.                                 P1=tab_time[led_1];
  646.                                 if(--time_count1<1) time_count1=16;
  647.                                 }                                                
  648.                                  delay(70);

  650.                                 if(--time_count<0)
  651.                                 {
  652.                                 time_count=71;
  653.                                 time_count0=8;
  654.                                 time_count1=16;
  655.                                 }
  656.                         }

  658.                 }
  659.                 break;
  660.                 case 6:
  661.                 {
  662.                         for(i=0;i<L_0;i++)
  663.                         {
  664.                                 if(time_count>55)
  665.                                 {
  666.                                 delay(85);                                                                  //整屏左移
  667.                                 }
  668.                                 else if(time_count>47&&time_count<56)
  669.                                 {
  670.                                 led_0=(set_minute%10)*16+(time_count0*2)-1;
  671.                                 led_1=(set_minute%10)*16+(time_count0*2)-2;
  672.                                 P3=tab_num[led_0];
  673.                                 P1=tab_num[led_1];
  674.                                 if(--time_count0<1) time_count0=8;
  675.                                 }
  676.                                 else if(time_count>39&&time_count<48)
  677.                                 {
  678.                                 led_0=(set_minute/10)*16+(time_count0*2)-1;
  679.                                 led_1=(set_minute/10)*16+(time_count0*2)-2;
  680.                                 P3=tab_num[led_0];
  681.                                 P1=tab_num[led_1];
  682.                                 if(--time_count0<1) time_count0=8;
  683.                                 }
  684.                                 else if(time_count>31&&time_count<40)                           //冒号
  685.                                 {
  686.                                 led_0=(10*16)+(time_count0*2)-1;
  687.                                 led_1=(10*16)+(time_count0*2)-2;
  688.                                 P3=tab_num[led_0];
  689.                                 P1=tab_num[led_1];
  690.                                 if(--time_count0<1) time_count0=8;               
  691.                                 }
  692.                                 else if(time_count>15&&time_count<32)                           //“分”
  693.                                 {
  694.                                 led_0=6*32+(time_count1*2)-1;
  695.                                 led_1=6*32+(time_count1*2)-2;
  696.                                 P3=tab_time[led_0];
  697.                                 P1=tab_time[led_1];
  698.                                 if(--time_count1<1) time_count1=16;
  699.                                 }
  700.                                 else if(time_count>=0&&time_count<16)                           //“调”
  701.                                 {
  702.                                 led_0=4*32+(time_count1*2)-1;
  703.                                 led_1=4*32+(time_count1*2)-2;
  704.                                 P3=tab_time[led_0];
  705.                                 P1=tab_time[led_1];
  706.                                 if(--time_count1<1) time_count1=16;
  707.                                 }                                                
  708.                                  delay(70);

  710.                                 if(--time_count<0)
  711.                                 {
  712.                                 time_count=71;
  713.                                 time_count0=8;
  714.                                 time_count1=16;
  715.                                 }
  716.                         }

  718.                 }
  719.                 break;
  720.                 case 7:
  721.                 {
  722.                         for(i=0;i<L_0;i++)
  723.                         {
  724.                                 if(time_count>55)
  725.                                 {
  726.                                 delay(85);                                                                  //整屏左移
  727.                                 }
  728.                                 else if(time_count>47&&time_count<56)
  729.                                 {
  730.                                 led_0=(set_second%10)*16+(time_count0*2)-1;
  731.                                 led_1=(set_second%10)*16+(time_count0*2)-2;
  732.                                 P3=tab_num[led_0];
  733.                                 P1=tab_num[led_1];
  734.                                 if(--time_count0<1) time_count0=8;
  735.                                 }
  736.                                 else if(time_count>39&&time_count<48)
  737.                                 {
  738.                                 led_0=(set_second/10)*16+(time_count0*2)-1;
  739.                                 led_1=(set_second/10)*16+(time_count0*2)-2;
  740.                                 P3=tab_num[led_0];
  741.                                 P1=tab_num[led_1];
  742.                                 if(--time_count0<1) time_count0=8;
  743.                                 }
  744.                                 else if(time_count>31&&time_count<40)                           //冒号
  745.                                 {
  746.                                 led_0=(10*16)+(time_count0*2)-1;
  747.                                 led_1=(10*16)+(time_count0*2)-2;
  748.                                 P3=tab_num[led_0];
  749.                                 P1=tab_num[led_1];
  750.                                 if(--time_count0<1) time_count0=8;               
  751.                                 }
  752.                                 else if(time_count>15&&time_count<32)                           //“秒”
  753.                                 {
  754.                                 led_0=7*32+(time_count1*2)-1;
  755.                                 led_1=7*32+(time_count1*2)-2;
  756.                                 P3=tab_time[led_0];
  757.                                 P1=tab_time[led_1];
  758.                                 if(--time_count1<1) time_count1=16;
  759.                                 }
  760.                                 else if(time_count>=0&&time_count<16)                           //“调”
  761.                                 {
  762.                                 led_0=4*32+(time_count1*2)-1;
  763.                                 led_1=4*32+(time_count1*2)-2;
  764.                                 P3=tab_time[led_0];
  765.                                 P1=tab_time[led_1];
  766.                                 if(--time_count1<1) time_count1=16;
  767.                                 }                                                
  768.                                  delay(70);

  770.                                 if(--time_count<0)
  771.                                 {
  772.                                 time_count=71;
  773.                                 time_count0=8;
  774.                                 time_count1=16;
  775.                                 }
  776.                         }

  778.                 }
  779.         }

  781.                 P3=0xff;
  782.                 P1=0xff;
  783.                 delay(5);

  785. }


  788. /*红外解码过程函数*/
  789. bit IRWork()
  790. {
  791. uchar i,j;
  792. uchar dat;
  793. for(j=0;j<4;j++)                                                         //共四个编码
  794. {
  795. for(i=0;i<8;i++)                                                         //每个编码八位
  796.         {
  797. dat>>=1;                                                                                //先移位
  798. TH0=0;
  799. TL0=0;
  800. TR0=1;
  801. while(!IR);                                                                                //低电平等待
  802. TR0=0;
  803. LowTime=TH0*256+TL0;                                                        //将低电平宽度保存
  804. TH0=0;
  805. TL0=0;
  806. TR0=1;
  807. while(IR);                                                                                 //高电平等待
  808. TR0=0;
  809. HighTime=TH0*256+TL0;                                                         //将高电平宽度保存
  810.             if(LowTime<380||LowTime>750) return 0;           //检测得到的低电平是否在560us左右，如果不是，则返回0；说明解码失败

  812.                    if((HighTime>1500)&&(HighTime<1900)) //如果高电平时间在1690微秒左右,(1690-200=1490,1690+200=1890),则该位是1;
  813.                                    dat=dat|0x80;       //是0的情况可判断,也可以不判断了,因为不判断的话上面开始移位后高位已自动清0,在这一行不在高位置1,已说明是0
  814.         }
  815. a[j]=dat;                                                                                                          //将每次解出的编码存到a[]中
  816. }
  817. if(a[2]=~a[3]) return 1;                                                                        //再次判断键码值，如果一致，返回1，解码正确
  818. }

  820. void IR_Scan(uchar dat00)
  821. {
  822.         switch(dat00)
  823.     {
  824.           case 0x46:KeyVal=7;break;                                           //MODE
  825.           case 0x07:KeyVal=8;break;                                           //EQ
  826.           case 0x15:KeyVal=9;break;                                           //--
  827.           case 0x09:KeyVal=10;break;                                           //+
  828.           case 0x19:KeyVal=11;break;                                           //REP
  829.           case 0x0d:KeyVal=12;break;                                        //SCAN
  830.           default:break;
  831.           }                                                   
  832. }


  835. /*设置时间入口*/
  836. void KeyScan()
  837. {
  838.         if(IR_Flag&&(KeyVal==7))                                                  //切换显示时间和日期
  839.         {
  840.         IR_Flag=0;                                                                           //标志位清零,每次只进入一遍这个函数,即每按一次键加1或减1
  841.                 display_time_flag=!display_time_flag;
  842.                 TR1=1;
  843.                 TH1=(65536-50000)/256;
  844.                 TL1=(65536-50000)%256;
  845.                 time_count=0;
  846.                 time_count0=0;
  847.                 time_count1=0;
  848.                 if(display_flag!=1)
  849.                 {
  850.                  display_flag=1;
  851.                  display_time_flag=0;
  852.                 }
  853.                 if(display_time_flag==1)        time_count1=28;
  854.                         if(set_count!=0)
  855.                         {
  856.                         if(set_count==7)
  857.                         {
  858.                         WriteSet1302(0x80,(((set_second/10)<<4)|(set_second%10)));
  859.                         set_second_flag=0;
  860.                         }
  861.                         WriteSet1302(0x8e,0x80);
  862.                         display_time_flag=!display_time_flag;
  863.                         set_count=0;
  864.                         }

  866.         }

  868.         else if(IR_Flag&&(KeyVal==8))                                                  //设置时间
  869.         {
  870.         IR_Flag=0;
  871.         display_flag=1;
  872.                 if(++set_count>8) set_count=0;
  873.                 switch(set_count)
  874.                 {
  875.                         case 1:                                                                                                                          //设置年
  876.                         {
  877.                         WriteSet1302(0x8e,0x00);                                                   //去掉保护
  878.                         set_year_tmp=(ReadSet1302(0x8d)>>4)*10+((ReadSet1302(0x8d))&0x0f);                         //在当前值设置
  879.                         set_year=set_year_tmp;
  880.                         }
  881.                         break;
  882.                         case 2:                                                                                                                                  //设置月
  883.                         {
  884.                         set_month_tmp=(ReadSet1302(0x89)>>4)*10+((ReadSet1302(0x89))&0x0f);
  885.                         set_month=set_month_tmp;
  886.                         }
  887.                         break;
  888.                         case 3:                                                                                                                                         //设置日
  889.                         {
  890.                         set_day_tmp=(ReadSet1302(0x87)>>4)*10+((ReadSet1302(0x87))&0x0f);
  891.                         set_day=set_day_tmp;
  892.                         }
  893.                         break;
  894.                         case 4:                                                                                                                                         //设置星期
  895.                         {
  896.                         set_week_tmp=ReadSet1302(0x8b);
  897.                         set_week=set_week_tmp;
  898.                         }
  899.                         break;
  900.                         case 5:                                                                                                                                         //设置时
  901.                         {
  902.                         set_hour_tmp=(ReadSet1302(0x85)>>4)*10+((ReadSet1302(0x85))&0x0f);
  903.                         set_hour=set_hour_tmp;
  904.                         }
  905.                         break;
  906.                         case 6:                                                                                                                                         //设置分
  907.                         {
  908.                         set_minute_tmp=(ReadSet1302(0x83)>>4)*10+((ReadSet1302(0x83))&0x0f);
  909.                         set_minute=set_minute_tmp;
  910.                         }
  911.                         break;
  912.                         case 8:
  913.                         {
  914.                         WriteSet1302(0x80,(((set_second/10)<<4)|(set_second%10)));
  915.                         WriteSet1302(0x8e,0x80);                                                        //写保护
  916.                         set_second_flag=0;
  917.                         set_count=0;
  918.                         time_count1=0;
  919.                         }
  920.                         break;
  921.                 }
  922.         }

  924.         else if(IR_Flag&&(KeyVal==10))                                                                           //+
  925.         {        
  926.                 IR_Flag=0;
  927.                 switch(set_count)
  928.                 {
  929.                 case 1:
  930.                 {
  931.                         if(++set_year>50) set_year=10;
  932.                 }
  933.                 break;
  934.                 case 2:
  935.                 {
  936.                         if(++set_month>12) set_month=1;
  937.                 }
  938.                 break;
  939.                 case 3:
  940.                 {
  941.                         if(++set_day>31) set_day=1;
  942.                 }
  943.                 break;
  944.                 case 4:
  945.                 {
  946.                         if(++set_week>7) set_week=1;
  947.                 }
  948.                 break;
  949.                 case 5:
  950.                 {
  951.                         if(++set_hour>23) set_hour=0;
  952.                 }
  953.                 break;
  954.                 case 6:
  955.                 {
  956.                         if(++set_minute>59) set_minute=0;
  957.                 }
  958.                 break;
  959.                 case 7:
  960.                 {
  961.                         set_second_flag=1;
  962.                         if(++set_second>59) set_second=0;
  963.                 }
  964.                 break;
  965.                 }
  966.         }

  968.         else if(IR_Flag&&(KeyVal==9))                                                                 //-
  969.         {
  970.                 IR_Flag=0;
  971.                 switch(set_count)
  972.                 {
  973.                 case 1:
  974.                 {
  975.                         if(--set_year<10) set_year=50;
  976.                 }
  977.                 break;
  978.                 case 2:
  979.                 {
  980.                         if(--set_month<1) set_month=12;
  981.                 }
  982.                 break;
  983.                 case 3:
  984.                 {
  985.                         if(--set_day<1) set_day=31;
  986.                 }
  987.                 break;
  988.                 case 4:
  989.                 {
  990.                         if(--set_week<1) set_week=7;
  991.                 }
  992.                 break;
  993.                 case 5:
  994.                 {
  995.                         if(--set_hour<0) set_hour=23;
  996.                 }
  997.                 break;
  998.                 case 6:
  999.                 {
  1000.                         if(--set_minute<0) set_minute=59;
  1001.                 }
  1002.                 break;
  1003.                 case 7:
  1004.                 {
  1005.                         set_second_flag=1;
  1006.                         if(--set_second<0) set_second=59;
  1007.                 }
  1008.                 }
  1009.         }
  1010.         else if(IR_Flag&&(KeyVal==11))                                                                 //-
  1011.         {
  1012.                 IR_Flag=0;
  1013.                 display_flag=2;
  1014.                 TH1=(65536-50000)/256;
  1015.                 TL1=(65536-50000)%256;
  1016.                 time_count=0;
  1017.                 time_count0=0;
  1018.         }
  1019.         else if(IR_Flag&&(KeyVal==12))                                                                 //-
  1020.         {
  1021.                 IR_Flag=0;
  1022.                 if(++effect>2)        effect=0;
  1023.         }


  1026. }


  1029. void set_time()
  1030. {
  1031. switch(set_count)
  1032. {
  1033.         case 1:
  1034.         {
  1035.         if(set_year!=set_year_tmp) WriteSet1302(0x8c,((set_year/10)<<4)|(set_year%10));                                                 //将上个设置数据写入1302
  1036.         } break;
  1037.         case 2:
  1038.         {
  1039.         if(set_month!=set_month_tmp)  WriteSet1302(0x88,((set_month/10)<<4)|(set_month%10));
  1040.         } break;
  1041.         case 3:
  1042.         {
  1043.         if(set_day!=set_day_tmp) WriteSet1302(0x86,((set_day/10)<<4)|(set_day%10));
  1044.         } break;
  1045.         case 4:
  1046.         {
  1047.         if(set_week!=set_week_tmp) WriteSet1302(0x8a,set_week);
  1048.         } break;
  1049.         case 5:
  1050.         {
  1051.         if(set_hour!=set_hour_tmp) WriteSet1302(0x84,((set_hour/10)<<4)|(set_hour%10));
  1052.         } break;
  1053.         case 6:
  1054.         {
  1055.         if(set_minute!=set_minute_tmp) WriteSet1302(0x82,((set_minute/10)<<4)|(set_minute%10));
  1056.         } break;
  1057.         case 7:
  1058.         {
  1059.                 if(set_second_flag==0)
  1060.                 {         
  1061.                 set_second=(ReadSet1302(0x81)>>4)*10+((ReadSet1302(0x81))&0x0f);
  1062.                 }
  1063.                 else
  1064.                 {
  1065.                 WriteSet1302(0x80,((((set_second/10)<<4)|(set_second%10))|0x80));                                           //秒默认为00分,且先不启动时钟
  1066.                 }

  1068.         } break;


  1071. }
  1072. }

  1074. void main()
  1075. {
  1076. //set_count=1;
  1077. P1=0xff;
  1078. P3=0xff;
  1079. EA=1;
  1080. EX2=1;
  1081. EX3=1;
  1082. ET1=1;
  1083. IT2=0;
  1084. IT3=1;        //下降沿触发
  1085. PX2=0;
  1086. PX3=1;        //最高优先级
  1087. PT1=1;
  1088. TMOD=0x11;
  1089. TH1=(65536-50000)/256;
  1090. TL1=(65536-50000)%256;
  1091. Init1302();
  1092.         while(1)
  1093.         {
  1094.                    KeyScan();
  1095.                  set_time();
  1096.                  EX2=1;

  1098.                  
  1099.         }

  1101. }



  1105. void time1() interrupt 3
  1106. {
  1107. TH1=(65536-50000)/256;
  1108. TL1=(65536-50000)%256;
  1109.         if(++time_count>=20)
  1110.         {
  1111.         time_count=0;
  1112.         if(set_count==0)
  1113.         {
  1114.                 if(++time_count0>40)
  1115.                 {
  1116.                 time_count0=0;
  1117.                 time_count1=0;
  1118.                                 if(++display_flag>2) display_flag=1;
  1119.                 }
  1120.                 time_count1++;
  1121.                 if(time_count1<28) display_time_flag=0;
  1122.                 else if(time_count1>27)
  1123.                 {
  1124.                 display_time_flag=1;
  1125.                         if(time_count1>40) time_count1=0;
  1126.                 }

  1128.         }

  1130.         }
  1131. }

  1133. void int2_led()        interrupt 6
  1134. {
  1135. EX2=0;
  1136. switch(display_flag)
  1137. {
  1138. case 0:open_display();break;
  1139. case 1:
  1140. {

  1142.          if(set_count==0)
  1143.          {
  1144.          if(display_time_flag==0)         time1_display();                                                //显示时间
  1145.         else   time0_display();                                                                                                //显示日期
  1146.          }
  1147. else set_time_display();                                                                                                 //显示设置状态
  1148. } break;
  1149. case 2:love_display();break;
  1150. }
  1151.          EX3=1;                                                                                                                                //再开外中断INT3

  1153.         
  1154. }

  1156. /*红外接收外中断INT0*/
  1157. void int3() interrupt 7
  1158. {
  1159. EX3=0;
  1160. //delay(10);
  1161. if(IR) return;                                                          //防止长按时无效尾码的干扰，这个很关键！！！！                                                                 //暂关T1中断
  1162. TL0=0x00;
  1163. TH0=0x00;
  1164. TR0=1;
  1165. while(!IR);                                                  //低电平引导码等待
  1166. TR0=0;
  1167. LowTime=TH0*256+TL0;
  1168. TL0=0x00;
  1169. TH0=0x00;
  1170. TR0=1;
  1171. while(IR);                                                     //高电平引导码等待
  1172. TR0=0;
  1173. HighTime=TH0*256+TL0;

  1175. if((LowTime>8250)&&(LowTime<9350)&&(HighTime>3950)&&(HighTime<5050))           //判断是否在合理的范围内
  1176.         {
  1177.                 if(IRWork()&&(a[0]==0x00))                                                                   //如果解码正确,且厂家编码为0x04(我的遥控器)才执行子语句，防其它遥控器干扰
  1178.                 {
  1179.                 IR_Flag=1;               
  1180.                 IR_Scan(a[2]);               
  1181.                 }
  1182.         }
  1183. }
复制代码

所有资料51hei提供下载:
代码.rar (69.28 KB, 下载次数: 33)


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

使用道具 举报

沙发
ID:399179 发表于 2018-11-25 18:40 来自手机 | 只看该作者
无线供电？
回复

使用道具 举报

板凳
ID:89286 发表于 2018-11-27 08:55 | 只看该作者
thanks for sharing
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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