標題: DIY集MP3、電子時鐘、電子音樂于一體的夢幻十字旋轉(zhuǎn)屏 [打印本頁]
作者: xiaoyao    時間: 2014-12-17 00:26
標題: DIY集MP3、電子時鐘、電子音樂于一體的夢幻十字旋轉(zhuǎn)屏
今天比較空閑，發(fā)個最近的作品到51hei論壇。先再看總體介紹圖

但是，我這個DIY作品為了能跟大家分享，讓更多的愛好者看到，我還是決定要發(fā)到這個版塊來哈
當然，十字旋轉(zhuǎn)屏不是我原創(chuàng)的了，這個東西很早以前就有了，但是本著弘揚DIY精神的態(tài)度，
我可不局限于只是讓旋轉(zhuǎn)屏滾動顯示文字就罷了……所以全新的DIY開始了……
由于這個東西是今年4月份左右弄的，弄好后送給MM了，現(xiàn)在也拿不回來了哈~~
所以下面介紹的圖片是以前留下的，所以要詳細說制作過程比較難了…
剛傳了視頻，也先讓大家看看以下留下的視頻效果……看完視頻后我再用保留下來的圖片和原理圖、程序等盡可能的向大家
介紹以前的制作過程！
其實，我最想向大家分享的是這個顯示屏的程序，我寫這個程序的時候，由于網(wǎng)上資料不全，我自己弄了幾天才終于搞墊了哈！


看完視頻，我將開始介紹DIY過程……
1、主旋轉(zhuǎn)屏底盒及電路等
我也去網(wǎng)上看過不少DIY高手用身邊的材料做的旋轉(zhuǎn)屏（有十字立體的，也有平面的），我也很是佩服。但是看來看去，他們說的材料我都不太有，而且我這個東西做出來后需要有一定的耐用性和美觀性（因為要送MM嘛），所以最后主旋轉(zhuǎn)屏是買了網(wǎng)上的套件來焊接組裝。


，
買回到的套件是這樣子的


，



這是原理圖。
具體的安裝方法等等我就不多做介紹了，因為那是別人的東西了，我再說出來，只能說我剽竊別人的，具體參考這賣套件的這個鏈接吧，他們上面有說明http://item.taobao點com/item.htm?spm=0.0.0.33.yS9Nym&;id=12577599101
而我下面主要說我對這個套件進行改裝DIY的部分：
2、電源
電源我原來是用5V手機直充供電的，但由于是無線供電，最后到達頂部旋轉(zhuǎn)屏的電壓供不上（其實主要不是電壓供不到，而是旋轉(zhuǎn)屏點亮后，整體功率增強，就會導(dǎo)致輸出的有效電壓迅速下降，從而低于單片機的正常工作電壓），導(dǎo)致單片機無**常工作，所以為了提高輸出功率，只能提高電壓。我試過用9V的開關(guān)電源，可以正常工作，但電壓太高就會導(dǎo)致互初正反饋振蕩電路（在底盒內(nèi)部）的三極管溫度很高，所以最終我去二手市場花了4塊錢買了一個諾基亞的直充，上面標稱是輸出5.7V，我用萬用表量過，也差不多，剛好合適哈，我再在次級線圈上多繞了幾圈，次級感應(yīng)出來的電壓就更大，更合適了。
3、頂部旋轉(zhuǎn)屏DIY
原來的套件使用的是STC89C51RC的單片機，我為了能多寫點程序和添加功能，我換成了52的單片機




看上面的圖片，大家會發(fā)現(xiàn)，我自己用洞洞板加了一個DS1302的時鐘模塊進去，同時還添加了一體化紅外接收頭用于調(diào)時間和控制顯示。特別說明一下，一般51單片機有4個IO口，而這個旋轉(zhuǎn)屏套件是兩個（紅色和綠色）16路流水燈直接加限流電阻后連到單片機的32個IO口，所以按理來說單片機的IO口已全部占用。但是這個單片機不是一般的51單片機，它還有4個P4的IO口。這多出來的4個IO口，一個我用于普通紅外接收（用于編程時控制顯示的），一個用于一體化紅外接收頭，另外兩個用于接DS1302，但DS1302一共要接三根線，另外一個IO口哪里來呢？實際上另一根線我接到了其中一個綠色LED上，所以，時間的顯示只能顯示紅色，而且看視頻你會發(fā)現(xiàn)顯示時間時上面有一綠色的燈環(huán)在亮，這是DS1302控制線控制綠色LED發(fā)出來的。具體的，各位高手看我程序就懂了。對于P4口的定義等等，可以參考我的C程序哈~~




還有，我用到的遙控器是這種常用車載MP3的遙控器，估計現(xiàn)在很多開發(fā)板也是附帶這種紅外遙控器，可以對時間和顯示進行控制。



4、底盒內(nèi)部電路介紹
底部的DIY才是我自己的核心哈。








下面從左到右給大家介紹一下：
（1）最左邊是一些開關(guān)和接口，主要有MP3耳機接口、電源輸入接口，開關(guān)主要有MP3獨立總開關(guān)、旋轉(zhuǎn)屏總開關(guān)、電機開關(guān)、電子音樂開關(guān)。
（2）MP3模塊
MP3模塊是買網(wǎng)上的夾子MP3


就是這種，大概10塊錢左右。里面主要就是一個MP3解碼芯片，把外殼去掉，在底盒合適位置鑿個洞就裝上去了哈，MP3模塊的供電也是直接接電源接口（5.7v）。因為電源是接到MP3模塊的USB接口上，本應(yīng)5V供電，現(xiàn)在電壓過高了，因此為了保險起見，串聯(lián)了一個1N4007二極管才按到MP3模塊的USB接口的，這樣1N4007降了0.6-0.7V左右，MP3模塊就可以工作了。但是實際卻發(fā)現(xiàn)，有時給MP3供電卻沒反應(yīng)，后面想到，平時MP3模塊不工作時，兩條電源線呈高阻狀態(tài)，而1N4007要導(dǎo)通工作時，兩端要有0.2V左右的壓降，因此，在1N4007輸出端我加了一個20K的下拉電阻哈，電路就像下面這樣子


，這樣就保證每次都可以上電啟動MP3了。
還有耳機的接口啊什么的，在底盒左側(cè)我都重新單獨弄出來，接法就不說了，大家都懂的。
MP3我弄有單獨的總開關(guān)，在左上角位置，同時MP3的五個按鍵我也全部引出來了，那幾個按鍵大家參考一下插卡MP3的原理圖就會發(fā)現(xiàn)，那是模擬按鍵，而不是數(shù)字按鍵。因此，好像五個按鍵我一共引出了八條線出來，有三條是公共的，還是五條是分別控制五個按鍵。而且節(jié)省體積，我引出的引線是用爛耳機里面的漆包線作為導(dǎo)線的，同時上面連DS1302模塊也是用那種線。下面是最終安裝好的MP3效果圖






（3）無線供電模塊
這個就不用多做介紹了，我是用洞洞板做的，電路圖參考上面主旋轉(zhuǎn)屏的原理圖，我加了散熱，并固定好，同時，在該模塊下面還是一個紅外發(fā)射LED，是配合頂部旋轉(zhuǎn)屏編程顯示的。
（4）電子音樂
我使用的是普通的固化了語音內(nèi)容的音樂IC，增加了一點電子韻味哈，這個模塊也是在51電子淘寶來的，


，參考電路也是上面這個，但是我沒用揚聲器，節(jié)省體積我用了有源蜂鳴器代替（注意一定要用有源的蜂鳴器，無源的聲音很�。�，同時該模塊工作電壓比較小，我直接加了100歐左右的電阻分壓就可以了。這個模塊我也加了獨立的開關(guān)，因為電機的工作有很大的干擾，因此在這個音樂IC的電源輸入端我加了100UF的濾波電容。
（5）MP3外揚電路
為實現(xiàn)MP3外揚，有使用了TDA2822功放芯片，并加大了輸入電源的濾波（220UF，盡量大，因為電機干擾），出來的聲音勉強可以了哈。如果從MP3音頻插口直接輸入到TDA2822的聲音過大失真嚴重的話，可以在輸入線按一個10-20K左右的電阻下拉到地線，這樣聲音就柔和適合多了。電路原理圖參考下面



同時，剛才的耳機接口要用那種五個腳帶開關(guān)的音頻插座，這樣就可以實現(xiàn)插入耳機后斷開送入TDA2822的音源。在該模塊下面有一個0.5W的小喇叭，通過上面的紅外說明上面的洞洞發(fā)出聲音。如下



（6）電機調(diào)速
按照原來的套件，電機是直接接到一個1N4007的兩端通過1N4007兩端的壓降供電的（大概0.6-0.7V），但這樣的供電在實際中，電機會轉(zhuǎn)得很慢。又因為我在頂部加了時鐘模塊和其它的，不加大電機電壓，轉(zhuǎn)速跟不上，顯示時會非常閃爍的，所以我用了CW317可調(diào)穩(wěn)壓IC對電機進行調(diào)壓�？赡苡行┡笥丫驼f了，干嘛不直接串聯(lián)一個電阻到電機就可以了，干嘛那么麻煩。首先，電阻串聯(lián)是可以的，但電阻阻值會隨著產(chǎn)熱發(fā)生改變，加上直流電機本身的阻值不是很高，要串聯(lián)的電阻是也是比較低的，電阻產(chǎn)熱會很高，就導(dǎo)致到電機的電壓不穩(wěn)定，即影響轉(zhuǎn)速，又不穩(wěn)定了。所以最后還是用CW317進行穩(wěn)壓調(diào)速。其電路很簡單，大家參考CW317芯片的經(jīng)典接法就是了。
（7）其他
還買了個七彩LED，在底盒頂部用電鉆打了一些小洞組成一個“心”形，在心形中間把這個七彩LED裝上，這些小洞既可以來給底盒的互初正反饋振蕩電路散熱，又有其他的意思哈




~~還有其他的旋轉(zhuǎn)屏顯示效果，只是真正見識到了我這人DIY作品才能感受得到的哈。
到現(xiàn)在，DIY過程也介紹得差不多了，因為制作過程中沒留有相片，只能靠現(xiàn)在的口述了……
感興趣的朋友，制作過程中有什么問題的都可以向我交流探討哈
最后，分享我的程序，這個程序可是原創(chuàng)的哦，有什么建議或問題再交流了哈…………
程序發(fā)下： 十字旋轉(zhuǎn)LED紅外時鐘程序.rar (69.28 KB, 下載次數(shù): 36)
，
最后，算算我這個東西大概一共花了七八十塊錢左右哈，但功能很多，也夠炫了哈~~
最后還有一點相片分享哈~~









作者: admin    時間: 2014-12-20 01:16
作品很牛，以下是主程序方便大家預(yù)覽：
  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. /*調(diào)“年、月、日、星期、時、分、秒”*/

  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)                           //“調(diào)”
  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)                           //“調(diào)”
  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)                           //“調(diào)”
  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)                                         //設(shè)置星期的值
  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)                           //“調(diào)”
  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)                           //“調(diào)”
  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)                           //“調(diào)”
  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)                           //“調(diào)”
  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. /*紅外解碼過程函數(shù)*/
  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. /*設(shè)置時間入口*/
  836. void KeyScan()
  837. {
  838.         if(IR_Flag&&(KeyVal==7))                                                  //切換顯示時間和日期
  839.         {
  840.         IR_Flag=0;                                                                           //標志位清零,每次只進入一遍這個函數(shù),即每按一次鍵加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))                                                  //設(shè)置時間
  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:                                                                                                                          //設(shè)置年
  876.                         {
  877.                         WriteSet1302(0x8e,0x00);                                                   //去掉保護
  878.                         set_year_tmp=(ReadSet1302(0x8d)>>4)*10+((ReadSet1302(0x8d))&0x0f);                         //在當前值設(shè)置
  879.                         set_year=set_year_tmp;
  880.                         }
  881.                         break;
  882.                         case 2:                                                                                                                                  //設(shè)置月
  883.                         {
  884.                         set_month_tmp=(ReadSet1302(0x89)>>4)*10+((ReadSet1302(0x89))&0x0f);
  885.                         set_month=set_month_tmp;
  886.                         }
  887.                         break;
  888.                         case 3:                                                                                                                                         //設(shè)置日
  889.                         {
  890.                         set_day_tmp=(ReadSet1302(0x87)>>4)*10+((ReadSet1302(0x87))&0x0f);
  891.                         set_day=set_day_tmp;
  892.                         }
  893.                         break;
  894.                         case 4:                                                                                                                                         //設(shè)置星期
  895.                         {
  896.                         set_week_tmp=ReadSet1302(0x8b);
  897.                         set_week=set_week_tmp;
  898.                         }
  899.                         break;
  900.                         case 5:                                                                                                                                         //設(shè)置時
  901.                         {
  902.                         set_hour_tmp=(ReadSet1302(0x85)>>4)*10+((ReadSet1302(0x85))&0x0f);
  903.                         set_hour=set_hour_tmp;
  904.                         }
  905.                         break;
  906.                         case 6:                                                                                                                                         //設(shè)置分
  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));                                                 //將上個設(shè)置數(shù)據(jù)寫入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;        //下降沿觸發(fā)
  1085. PX2=0;
  1086. PX3=1;        //最高優(yōu)先級
  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();                                                                                                 //顯示設(shè)置狀態(tài)
  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;                                                          //防止長按時無效尾碼的干擾，這個很關(guān)鍵！�。�！                                                                 //暫關(guān)T1中斷
  1162. TL0=0x00;
  1163. TH0=0x00;
  1164. TR0=1;
  1165. while(!IR);                                                  //低電平引導(dǎo)碼等待
  1166. TR0=0;
  1167. LowTime=TH0*256+TL0;
  1168. TL0=0x00;
  1169. TH0=0x00;
  1170. TR0=1;
  1171. while(IR);                                                     //高電平引導(dǎo)碼等待
  1172. TR0=0;
  1173. HighTime=TH0*256+TL0;

  1175. if((LowTime>8250)&&(LowTime<9350)&&(HighTime>3950)&&(HighTime<5050))           //判斷是否在合理的范圍內(nèi)
  1176.         {
  1177.                 if(IRWork()&&(a[0]==0x00))                                                                   //如果解碼正確,且廠家編碼為0x04(我的遙控器)才執(zhí)行子語句，防其它遙控器干擾
  1178.                 {
  1179.                 IR_Flag=1;               
  1180.                 IR_Scan(a[2]);               
  1181.                 }
  1182.         }
  1183. }
復(fù)制代碼
作者: xyz1015231411    時間: 2015-1-28 12:33
不錯，值得學(xué)習
作者: 蒲公英lhl    時間: 2015-1-31 12:02
樓主，好厲害啊，贊贊贊贊贊
作者: delay    時間: 2015-4-4 17:31
高手呀
作者: hwt616591    時間: 2015-4-4 23:13
謝謝分享
作者: hwt616591    時間: 2015-4-4 23:13
謝謝分享
作者: 過路人小鋒    時間: 2016-7-4 10:00
厲害，我也要學(xué)習做一個當生日禮物送
作者: xiayu0216    時間: 2016-9-30 00:39
樓主可以發(fā)下完整的教程和說明嗎。。新手想嘗試下
作者: 沒有蠟筆的小新    時間: 2017-4-17 14:25
今天剛剛來到51黑電子論壇 希望 能夠和大家相處的愉快
作者: idealize    時間: 2017-9-16 16:31
太棒了                     
作者: idealize    時間: 2017-9-16 16:31
太棒了！�。。。。。。。。。。�
作者: 1290664367    時間: 2017-11-27 14:03
小白學(xué)習




歡迎光臨 (http://www.torrancerestoration.com/bbs/) Powered by Discuz! X3.1