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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

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

DIY集MP3、电子时钟、电子音乐于一体的梦幻十字旋转屏

  [复制链接]
跳转到指定楼层
楼主
ID:70481 发表于 2014-12-17 00:26 | 只看该作者 |只看大图 回帖奖励 |倒序浏览 |阅读模式
今天比较空闲，发个最近的作品到51hei论坛。先再看总体介绍图

但是，我这个DIY作品为了能跟大家分享，让更多的爱好者看到，我还是决定要发到这个版块来哈
当然，十字旋转屏不是我原创的了，这个东西很早以前就有了，但是本着弘扬DIY精神的态度，
我可不局限于只是让旋转屏滚动显示文字就罢了……所以全新的DIY开始了……
由于这个东西是今年4月份左右弄的，弄好后送给MM了，现在也拿不回来了哈~~
所以下面介绍的图片是以前留下的，所以要详细说制作过程比较难了…
刚传了视频，也先让大家看看以下留下的视频效果……看完视频后我再用保留下来的图片和原理图、程序等尽可能的向大家
介绍以前的制作过程！
其实，我最想向大家分享的是这个显示屏的程序，我写这个程序的时候，由于网上资料不全，我自己弄了几天才终于搞垫了哈！


看完视频，我将开始介绍DIY过程……
1、主旋转屏底盒及电路等
我也去网上看过不少DIY高手用身边的材料做的旋转屏（有十字立体的，也有平面的），我也很是佩服。但是看来看去，他们说的材料我都不太有，而且我这个东西做出来后需要有一定的耐用性和美观性（因为要送MM嘛），所以最后主旋转屏是买了网上的套件来焊接组装。


，
买回到的套件是这样子的


，



这是原理图。
具体的安装方法等等我就不多做介绍了，因为那是别人的东西了，我再说出来，只能说我剽窃别人的，具体参考这卖套件的这个链接吧，他们上面有说明http://item.taobao点com/item.htm?spm=0.0.0.33.yS9Nym&;id=12577599101
而我下面主要说我对这个套件进行改装DIY的部分：
2、电源
电源我原来是用5V手机直充供电的，但由于是无线供电，最后到达顶部旋转屏的电压供不上（其实主要不是电压供不到，而是旋转屏点亮后，整体功率增强，就会导致输出的有效电压迅速下降，从而低于单片机的正常工作电压），导致单片机无**常工作，所以为了提高输出功率，只能提高电压。我试过用9V的开关电源，可以正常工作，但电压太高就会导致互初正反馈振荡电路（在底盒内部）的三极管温度很高，所以最终我去二手市场花了4块钱买了一个诺基亚的直充，上面标称是输出5.7V，我用万用表量过，也差不多，刚好合适哈，我再在次级线圈上多绕了几圈，次级感应出来的电压就更大，更合适了。
3、顶部旋转屏DIY
原来的套件使用的是STC89C51RC的单片机，我为了能多写点程序和添加功能，我换成了52的单片机




看上面的图片，大家会发现，我自己用洞洞板加了一个DS1302的时钟模块进去，同时还添加了一体化红外接收头用于调时间和控制显示。特别说明一下，一般51单片机有4个IO口，而这个旋转屏套件是两个（红色和绿色）16路流水灯直接加限流电阻后连到单片机的32个IO口，所以按理来说单片机的IO口已全部占用。但是这个单片机不是一般的51单片机，它还有4个P4的IO口。这多出来的4个IO口，一个我用于普通红外接收（用于编程时控制显示的），一个用于一体化红外接收头，另外两个用于接DS1302，但DS1302一共要接三根线，另外一个IO口哪里来呢？实际上另一根线我接到了其中一个绿色LED上，所以，时间的显示只能显示红色，而且看视频你会发现显示时间时上面有一绿色的灯环在亮，这是DS1302控制线控制绿色LED发出来的。具体的，各位高手看我程序就懂了。对于P4口的定义等等，可以参考我的C程序哈~~




还有，我用到的遥控器是这种常用车载MP3的遥控器，估计现在很多开发板也是附带这种红外遥控器，可以对时间和显示进行控制。



4、底盒内部电路介绍
底部的DIY才是我自己的核心哈。








下面从左到右给大家介绍一下：
（1）最左边是一些开关和接口，主要有MP3耳机接口、电源输入接口，开关主要有MP3独立总开关、旋转屏总开关、电机开关、电子音乐开关。
（2）MP3模块
MP3模块是买网上的夹子MP3


就是这种，大概10块钱左右。里面主要就是一个MP3解码芯片，把外壳去掉，在底盒合适位置凿个洞就装上去了哈，MP3模块的供电也是直接接电源接口（5.7v）。因为电源是接到MP3模块的USB接口上，本应5V供电，现在电压过高了，因此为了保险起见，串联了一个1N4007二极管才按到MP3模块的USB接口的，这样1N4007降了0.6-0.7V左右，MP3模块就可以工作了。但是实际却发现，有时给MP3供电却没反应，后面想到，平时MP3模块不工作时，两条电源线呈高阻状态，而1N4007要导通工作时，两端要有0.2V左右的压降，因此，在1N4007输出端我加了一个20K的下拉电阻哈，电路就像下面这样子


，这样就保证每次都可以上电启动MP3了。
还有耳机的接口啊什么的，在底盒左侧我都重新单独弄出来，接法就不说了，大家都懂的。
MP3我弄有单独的总开关，在左上角位置，同时MP3的五个按键我也全部引出来了，那几个按键大家参考一下插卡MP3的原理图就会发现，那是模拟按键，而不是数字按键。因此，好像五个按键我一共引出了八条线出来，有三条是公共的，还是五条是分别控制五个按键。而且节省体积，我引出的引线是用烂耳机里面的漆包线作为导线的，同时上面连DS1302模块也是用那种线。下面是最终安装好的MP3效果图






（3）无线供电模块
这个就不用多做介绍了，我是用洞洞板做的，电路图参考上面主旋转屏的原理图，我加了散热，并固定好，同时，在该模块下面还是一个红外发射LED，是配合顶部旋转屏编程显示的。
（4）电子音乐
我使用的是普通的固化了语音内容的音乐IC，增加了一点电子韵味哈，这个模块也是在51电子淘宝来的，


，参考电路也是上面这个，但是我没用扬声器，节省体积我用了有源蜂鸣器代替（注意一定要用有源的蜂鸣器，无源的声音很小），同时该模块工作电压比较小，我直接加了100欧左右的电阻分压就可以了。这个模块我也加了独立的开关，因为电机的工作有很大的干扰，因此在这个音乐IC的电源输入端我加了100UF的滤波电容。
（5）MP3外扬电路
为实现MP3外扬，有使用了TDA2822功放芯片，并加大了输入电源的滤波（220UF，尽量大，因为电机干扰），出来的声音勉强可以了哈。如果从MP3音频插口直接输入到TDA2822的声音过大失真严重的话，可以在输入线按一个10-20K左右的电阻下拉到地线，这样声音就柔和适合多了。电路原理图参考下面



同时，刚才的耳机接口要用那种五个脚带开关的音频插座，这样就可以实现插入耳机后断开送入TDA2822的音源。在该模块下面有一个0.5W的小喇叭，通过上面的红外说明上面的洞洞发出声音。如下



（6）电机调速
按照原来的套件，电机是直接接到一个1N4007的两端通过1N4007两端的压降供电的（大概0.6-0.7V），但这样的供电在实际中，电机会转得很慢。又因为我在顶部加了时钟模块和其它的，不加大电机电压，转速跟不上，显示时会非常闪烁的，所以我用了CW317可调稳压IC对电机进行调压。可能有些朋友就说了，干嘛不直接串联一个电阻到电机就可以了，干嘛那么麻烦。首先，电阻串联是可以的，但电阻阻值会随着产热发生改变，加上直流电机本身的阻值不是很高，要串联的电阻是也是比较低的，电阻产热会很高，就导致到电机的电压不稳定，即影响转速，又不稳定了。所以最后还是用CW317进行稳压调速。其电路很简单，大家参考CW317芯片的经典接法就是了。
（7）其他
还买了个七彩LED，在底盒顶部用电钻打了一些小洞组成一个“心”形，在心形中间把这个七彩LED装上，这些小洞既可以来给底盒的互初正反馈振荡电路散热，又有其他的意思哈




~~还有其他的旋转屏显示效果，只是真正见识到了我这人DIY作品才能感受得到的哈。
到现在，DIY过程也介绍得差不多了，因为制作过程中没留有相片，只能靠现在的口述了……
感兴趣的朋友，制作过程中有什么问题的都可以向我交流探讨哈
最后，分享我的程序，这个程序可是原创的哦，有什么建议或问题再交流了哈…………
程序发下： 十字旋转LED红外时钟程序.rar (69.28 KB, 下载次数: 33)
，
最后，算算我这个东西大概一共花了七八十块钱左右哈，但功能很多，也够炫了哈~~
最后还有一点相片分享哈~~









音乐, 电子, 梦幻
分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏1 分享淘帖 顶顶 踩踩

相关帖子
回复

使用道具 举报

沙发
ID:1 发表于 2014-12-20 01:16 | 只看该作者
作品很牛，以下是主程序方便大家预览：
  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. }
复制代码
回复

使用道具 举报

板凳
ID:72901 发表于 2015-1-28 12:33 | 只看该作者
不错，值得学习
回复

使用道具 举报

地板
ID:72995 发表于 2015-1-31 12:02 | 只看该作者
楼主，好厉害啊，赞赞赞赞赞
回复

使用道具 举报

5#
ID:72611 发表于 2015-4-4 17:31 | 只看该作者
高手呀
回复

使用道具 举报

6#
ID:76142 发表于 2015-4-4 23:13 | 只看该作者
谢谢分享
回复

使用道具 举报

7#
ID:76142 发表于 2015-4-4 23:13 | 只看该作者
谢谢分享
回复

使用道具 举报

8#
ID:111276 发表于 2016-7-4 10:00 来自手机 | 只看该作者
厉害，我也要学习做一个当生日礼物送
回复

使用道具 举报

9#
ID:140943 发表于 2016-9-30 00:39 来自手机 | 只看该作者
楼主可以发下完整的教程和说明吗。。新手想尝试下
回复

使用道具 举报

10#
ID:190426 发表于 2017-4-17 14:25 | 只看该作者
今天刚刚来到51黑电子论坛 希望 能够和大家相处的愉快
回复

使用道具 举报

11#
ID:81140 发表于 2017-9-16 16:31 | 只看该作者
太棒了                     
回复

使用道具 举报

12#
ID:81140 发表于 2017-9-16 16:31 | 只看该作者
太棒了！！！！！！！！！！！！
回复

使用道具 举报

13#
ID:251422 发表于 2017-11-27 14:03 | 只看该作者
小白学习
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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