标题: DIY集MP3、电子时钟、电子音乐于一体的梦幻十字旋转屏 [打印本页]

---

作者: xiaoyao    时间: 2014-12-17 00:26
标题: DIY集MP3、电子时钟、电子音乐于一体的梦幻十字旋转屏
今天比较空闲，发个最近的作品到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, 下载次数: 36)

2014-12-20 01:03 上传

点击文件名下载附件
下载积分: 黑币 -5

，
最后，算算我这个东西大概一共花了七八十块钱左右哈，但功能很多，也够炫了哈~~
最后还有一点相片分享哈~~

---

作者: admin    时间: 2014-12-20 01:16
作品很牛，以下是主程序方便大家预览：

1. #include <reg52.h>
   
2. #include <intrins.h>
   
3. #include "LED_STRING.h"
   
4. #include "DS1302.h"
   
5. 
   
6. sfr XICON=0xc0;                                 //定义STC89C52中断特殊功能寄存器
   
7. 
   
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;
    
16. 
    
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;
    
26. 
    
27. /*延迟机器周期级的短延迟*/
    
28. void delay(uchar z)
    
29. {
    
30.         while (z--)
    
31.         _nop_();
    
32. }
    
33. 
    
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;
    
48. 
    
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. }
    
67. 
    
68. 
    
69. /*LOVE画面*/
    
70. void love_display()
    
71. {
    
72.         uchar i;
    
73.         uint led_0,led_1,count,num;
    
74. 
    
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.         }
    
87. 
    
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. }
     
119. 
     
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.                 }
     
147. 
     
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.                 }
     
157. 
     
158. 
     
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.                 }
     
168. 
     
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.                 }
     
212. 
     
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.                 }
     
222. 
     
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.                 }
     
257. 
     
258.         if(--time_count<0)
     
259.         {
     
260.         time_count=159;
     
261.         time_count0=8;
     
262.         time_count1=16;
     
263.         }
     
264. 
     
265.         }
     
266.                 delay(95);
     
267.                 P3=0xff;
     
268.                 P1=0xff;
     
269.                 delay(5);
     
270. }
     
271. 
     
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.         }
     
349. 
     
350.         }
     
351.                 delay(95);
     
352.                 P3=0xff;
     
353.                 P1=0xff;
     
354.                 delay(5);
     
355. 
     
356. 
     
357. }
     
358. 
     
359. 
     
360. /*调“年、月、日、星期、时、分、秒”*/
     
361. 
     
362. void set_time_display()
     
363. {
     
364. 
     
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);
     
537. 
     
538.                                 if(--time_count<0)
     
539.                                 {
     
540.                                 time_count=71;
     
541.                                 time_count0=8;
     
542.                                 time_count1=16;
     
543.                                 }
     
544.                         }
     
545. 
     
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.                                 }
     
572. 
     
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);
     
590. 
     
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);
     
649. 
     
650.                                 if(--time_count<0)
     
651.                                 {
     
652.                                 time_count=71;
     
653.                                 time_count0=8;
     
654.                                 time_count1=16;
     
655.                                 }
     
656.                         }
     
657. 
     
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);
     
709. 
     
710.                                 if(--time_count<0)
     
711.                                 {
     
712.                                 time_count=71;
     
713.                                 time_count0=8;
     
714.                                 time_count1=16;
     
715.                                 }
     
716.                         }
     
717. 
     
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);
     
769. 
     
770.                                 if(--time_count<0)
     
771.                                 {
     
772.                                 time_count=71;
     
773.                                 time_count0=8;
     
774.                                 time_count1=16;
     
775.                                 }
     
776.                         }
     
777. 
     
778.                 }
     
779.         }
     
780. 
     
781.                 P3=0xff;
     
782.                 P1=0xff;
     
783.                 delay(5);
     
784. 
     
785. }
     
786. 
     
787. 
     
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；说明解码失败
     
811. 
     
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. }
     
819. 
     
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. }
     
833. 
     
834. 
     
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.                         }
     
865. 
     
866.         }
     
867. 
     
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.         }
     
923. 
     
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.         }
     
967. 
     
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.         }
      
1024. 
      
1025. 
      
1026. }
      
1027. 
      
1028. 
      
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.                 }
      
1067. 
      
1068.         } break;
      
1069. 
      
1070. 
      
1071. }
      
1072. }
      
1073. 
      
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;
      
1097. 
      
1098.                  
      
1099.         }
      
1100. 
      
1101. }
      
1102. 
      
1103. 
      
1104. 
      
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.                 }
      
1127. 
      
1128.         }
      
1129. 
      
1130.         }
      
1131. }
      
1132. 
      
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. {
      
1141. 
      
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
      
1152. 
      
1153.        
      
1154. }
      
1155. 
      
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;
      
1174. 
      
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. }
      

复制代码

---

作者: xyz1015231411    时间: 2015-1-28 12:33
不错，值得学习

---

作者: 蒲公英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
厉害，我也要学习做一个当生日礼物送

---

作者: xiayu0216    时间: 2016-9-30 00:39
楼主可以发下完整的教程和说明吗。。新手想尝试下

---

作者: 没有蜡笔的小新    时间: 2017-4-17 14:25
今天刚刚来到51黑电子论坛 希望 能够和大家相处的愉快

---

作者: idealize    时间: 2017-9-16 16:31
太棒了                     

---

作者: idealize    时间: 2017-9-16 16:31
太棒了！！！！！！！！！！！！

---

作者: 1290664367    时间: 2017-11-27 14:03
小白学习

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1