标题: 16*32RGB点阵屏多功能时钟源程序与资料 [打印本页]

---

作者: aozuang    时间: 2018-1-12 11:35
标题: 16*32RGB点阵屏多功能时钟源程序与资料
16*32 RGB点阵时钟、频谱使用说明

一、 控制卡 4 个独立按键使用说明：
1、按键 S1：进入调时模式以及切换年、月、日、星期、时间、亮度自动与手动切换以及补偿时间加减等项目的调整切换
2、按键 S2：进入调时模式时此按键功能为“加” 、不在调时模式时此按键功能为“亮度控制” ，在频谱模式时此按键功能为“顶点颜色切换”
3、按键 S3：进入调时模式时此按键功能为“减” 、不在调时模式时此按键功能为“时钟颜色切换， ”在频谱模式时此按键功能为“柱条颜色切换”
4、按键 S4：在调时模式时“退出时间调整” ，其他模式“频谱与时间模式切换”  
注意：当时钟显示颜色或者频谱显示颜色为全红色时，进入自动切换颜色的模式
二、遥控器使用介绍：
遥控只有 4 个按键可用，等同于独立按键的功能。


电路原理图：


/*********************************** ***************************
-0XC0--0XC1- 显示模式
-0XC2--0XC3- 速度
-0XC4--0XC5- 亮度
-0XC6--0XC7  用于闹钟总开关
每个闹钟占用DS1302的三个RAM，从第5个RAM开始使用。
-0XC8--0XC9-亮度自动控制
-0XCA--0XCB-综合模式记忆
-0XCC--0XCD-边框记忆
每三个RAM中的第一个为当前闹钟的开关，
第二个为设置的小时值，第三个为设置的分钟值。
-0XCE--0XCF--0XD0--0XD1--0XD2--0XD3- 1
-0XD4--0XD5--0XD6--0XD7--0XD8--0XD9- 2
-0XDA--0XDB--0XDC--0XDD--0XDE--0XDF- 3
-0XE0--0XE1--0XE2--0XE3--0XE4--0XE5- 4
-0XE6--0XE7--0XE8--0XE9--0XEA--0XEB- 5
-0XEC--0XED- 整点报时
-0XEE--0XEF- 字体(控制）
-0XF0--0XF1- 颜色
-0XF2--0XF3- 湿度修整开关（是加还是减）
-0XF4--0XF5- 湿度修整数值 0-----20%
-0XF6--0XF7- 温度修整开关（是加还是减）
-0XF8--0XF9- 温度修整数值 0-----20度
-0XFA--0XFB- 是否校时的标记*如果是1就校时,0不校时
-0XFC--0XFD- 写入校时的时间量0-----20秒
-0XFE--0XFF- 多字节命令
------宏定义区--------------------------------------------------------------*/

单片机源程序如下:

1. /***********************************************************
   
2. 控制卡  P0=j
   
3. 如果有配套控制卡，下载此程序即可显示
   
4. 16*32 RGB点阵屏 多功能时钟
   
5. 功能说明：上电显示   时：分    20S切换一次流动显示 年月日星期 信息
   
6. ***************************P0=j********************************/
   
7. /*
   
8. 16X32 RGB点阵屏管脚定义
   
9. GND     A     ABCD是行扫描信号
   
10. GND     B
    
11. GND     C
    
12. OE      D          OE是屏的使能端  低有效
    
13. G       R          R G B 颜色数据信号
    
14. B       NC         
    
15. GND            STR          锁存信号
    
16. GND     SCK         时钟信号
    
17. */
    
18. /*接口说明*/
    
19. //A B C D 是138行扫描信号
    
20. // SHCP   是595的移位信号
    
21. // STCP   是595的锁存信号
    
22. // OE    是屏的使能端 可以控制亮度
    
23. // R     是红色信号线
    
24. // G     是绿色信号线
    
25. // B     是蓝色信号线   
    
26. //P0=j  
    
27. 
    
28. #include<task.h>
    
29. sbit SCK=P2^7;//时钟         
    
30. sbit STR=P4^1;//上升沿输出               /*如果用的是普通单片机 没有P4.1口 请改为其他口*/   
    
31. sbit SDA_R=P2^4;//红数据  
    
32. sbit SDA_G=P2^5;//绿数据
    
33. sbit SDA_B=P2^3;//蓝数据  
    
34. sbit OE=P0^4;//输出使能
    
35. 
    
36. sbit IA=P4^0;//行控制线A                   /*如果用的是普通单片机 没有P4.0口 请改为其他口*/   
    
37. sbit IB=P2^0;//行控制线B
    
38. sbit IC=P2^1;//行控制线C
    
39. sbit ID=P2^2;//行控制线D
    
40. 
    
41. void SDA_RS(uchar i) { SDA_R = (bit)i; }
    
42. void SDA_GS(uchar i) { SDA_G = (bit)i; }
    
43. void SDA_BS(uchar i) { SDA_B = (bit)i; }
    
44. void SDA_RGS(uchar i) { SDA_R = (bit)i;SDA_G = (bit)i; }
    
45. void SDA_GBS(uchar i) { SDA_G = (bit)i; SDA_B = (bit)i;}
    
46. void SDA_BRS(uchar i) { SDA_R = (bit)i;SDA_B = (bit)i; }
    
47. void SDA_BGRS(uchar i) { SDA_R = (bit)i; SDA_G = (bit)i;SDA_B = (bit)i;}
    
48. void (*SDA_RGB)(uchar);
    
49. typedef struct bb
    
50. {
    
51.     void (*proc)(uchar);
    
52. }_ol_;
    
53. _ol_ olSet[7] =
    
54. {
    
55.     SDA_RS,
    
56.     SDA_GS,
    
57.     SDA_BS,
    
58.         SDA_RGS,
    
59.     SDA_GBS,
    
60.     SDA_BRS,
    
61.         SDA_BGRS,
    
62.    
    
63. };//P0=j
    
64. #define  scan0    {IA=0;IB=0;IC=0;ID=0;}
    
65. #define  scan1    {IA=1;IB=0;IC=0;ID=0;}
    
66. #define  scan2    {IA=0;IB=1;IC=0;ID=0;}
    
67. #define  scan3    {IA=1;IB=1;IC=0;ID=0;}
    
68. #define  scan4    {IA=0;IB=0;IC=1;ID=0;}
    
69. #define  scan5    {IA=1;IB=0;IC=1;ID=0;}
    
70. #define  scan6    {IA=0;IB=1;IC=1;ID=0;}
    
71. #define  scan7    {IA=1;IB=1;IC=1;ID=0;}
    
72. #define  scan8    {IA=0;IB=0;IC=0;ID=1;}
    
73. #define  scan9    {IA=1;IB=0;IC=0;ID=1;}
    
74. #define scan10    {IA=0;IB=1;IC=0;ID=1;}
    
75. #define scan11    {IA=1;IB=1;IC=0;ID=1;}
    
76. #define scan12    {IA=0;IB=0;IC=1;ID=1;}
    
77. #define scan13    {IA=1;IB=0;IC=1;ID=1;}
    
78. #define scan14    {IA=0;IB=1;IC=1;ID=1;}
    
79. #define scan15    {IA=1;IB=1;IC=1;ID=1;}
    
80. #define NL     12                        //空格地址
    
81. 
    
82. void   rxd_data();        // 发送移动数据
    
83. void rxd_data(void);                            //串行发送数据
    
84. uint time_count=0; //计数
    
85. uchar reg;
    
86. uchar line;
    
87. uchar Mode=0;
    
88. uchar Count=0;
    
89. uchar SPEED;
    
90. void Displaying();
    
91. void timebuff();
    
92. uchar e=0;
    
93. uchar Light=1;
    
94. uchar color;
    
95. bit Auto_bit=0;
    
96. uchar xdata Buffnum=4;
    
97. void SECOND_liudonshu(void)        ;
    
98. void Adjust_display(void);
    
99. void sendRXbyte(unsigned char wdata,unsigned char c,unsigned char n);
    
100. uchar BUFF[20];                                   //缓存
     
101. uchar code week_data[] ={24,40,42,44,46,48,50,24};  //日一二三四五六日
     
102. /***************滚动显示格式数组***********P0=j************************/
     
103. uchar xdata  A[60]=         //显示格式
     
104. {  NL,NL,NL,NL,NL,NL,NL,NL,                 //开头8个空格 0-7
     
105.         14,15,16,17,18,19,                         //今天是8,9,10,11,12,13
     
106.         2,0,00,00,                                                 //年数据14,15,16,17
     
107.         20,21,                                                        //“年”18,19
     
108.         0,0,                                                        //月数据         No.20,21
     
109.         22,23,                                                        //“月”22,23
     
110.         0,0,                                                        //日数据        No.24,25
     
111.         24,25,                                                        //“日”26,27
     
112.         NL,                                                 //空格28
     
113.         26,27,28,29,                                        //“星期”29,30,31,32
     
114.         00,00,                                                        //星期几        No.33,34
     
115.         NL,                                                                //空格35
     
116. };
     
117. uchar code zimo[];
     
118. uchar zimuo=0;
     
119. uchar offset;
     
120. bit half_sec_flag=0;
     
121. void in_data(void);                                       //调整数据
     
122. //void delay(uchar time);
     
123. 
     
124. void delay(uchar time)   //10us
     
125. {
     
126.     unsigned char a,b,c;
     
127.         for(c=time;c>0;c--)
     
128.         {
     
129.              for(b=30;b>0;b--)
     
130.         for(a=3;a>0;a--);
     
131.         }
     
132. }
     
133. 
     
134. /*****不影响其他端口的扫描******P0=j*******************/
     
135. void scan(unsigned char Value)
     
136. {switch(Value)
     
137.         {case  0: scan0;break;
     
138.                   case  1: scan1;break;
     
139.                    case  2: scan2;break;
     
140.                     case  3: scan3;break;
     
141.              case  4: scan4;break;
     
142.                       case  5: scan5;break;
     
143.                        case  6: scan6;break;
     
144.                         case  7: scan7;break;
     
145.                  case  8: scan8;break;
     
146.                        case  9: scan9;break;
     
147.                       case 10:scan10;break;
     
148.                      case 11:scan11;break;
     
149.             case 12:scan12;break;
     
150.                   case 13:scan13;break;
     
151.                  case 14:scan14;break;
     
152.             case 15:scan15;break;
     
153.         }
     
154. }
     
155. /**************************************/
     
156. 
     
157. void Timer0Interrupt(void) interrupt 1 //定时器中断
     
158. {
     
159.    uint read_time;
     
160.         TH0 = 0x0F6;
     
161.     TL0 = 0x3C;
     
162.         if(++read_time>200)
     
163.         {
     
164.                 read_time=0;
     
165.                 read_clockS();    //读时钟数据
     
166.                 //KEY_scan();
     
167.         }
     
168.    if(Mode!=2)                 
     
169.    time_count++;
     
170.    if(time_count%600==0)
     
171.         half_sec_flag=~half_sec_flag;
     
172.    if(time_count>42000)//发送一次数据
     
173.    {      
     
174.        time_count=0;
     
175.            Mode=1;
     
176.                   
     
177.         }
     
178.            if(Mode==1)
     
179.            {
     
180.                    line++; //下一行
     
181.                    if(line>15) //共16行
     
182.                    {
     
183.                             line=0; //重新移动        
     
184.                          SPEED++;
     
185.                 if(SPEED>5)         
     
186.                         {
     
187.                         SPEED=1;
     
188.                         offset++;
     
189.                         }
     
190.                               
     
191.                     }
     
192.          
     
193.             //in_data();//调整移动数据
     
194.                 //if(Mode==0)
     
195.             //
     
196. 
     
197.                            Displaying();//移动显示模式
     
198.                    //else if(Mode==2)
     
199.                    // Adjust_display();//调时模式
     
200.                 scan(line); //打开行扫描                                                                                             
     
201.                     STR=0;//锁存
     
202.                         OE=0;
     
203.                         delay(Light*2); //控制亮度
     
204.                         OE=1;
     
205.                         STR=1;
     
206.                 }
     
207.                 if(Mode==0)
     
208.                 {
     
209.                     line++; //下一行
     
210.                    if(line>15) //共16行
     
211.                    {
     
212.                               line=0; //重新移动        
     
213.                    }
     
214.                             rxd_data();//显示时间模式
     
215.                           scan(line); //打开行扫描                                                                                             
     
216.                       STR=1;//锁存
     
217.                           STR=0;
     
218.                           OE=0;
     
219.                           delay(Light*2); //控制亮度
     
220.                           OE=1;        
     
221.                 }
     
222. }
     
223. void PCA() interrupt 7        //PCA定时器          26ms
     
224. {
     
225.          
     
226.          if( CCF0 )
     
227.         {
     
228.                
     
229.                  CCAP0L = CCAP0L+0x50;
     
230.                 CCAP0H = CCAP0H+0xc3; //20ms定时
     
231.             CCF0 = 0;
     
232.                 time_count++;               
     
233.                 if(time_count>6)//
     
234.                 {      
     
235.                            time_count=0;
     
236.                         Count++;
     
237. //                        SendByte(Count);
     
238.                         if(Count>50)
     
239.                         {        
     
240.                                 Count=0;                                
     
241.                                  reg++;//依次变色
     
242.                                    if(reg>7)
     
243.                                 {
     
244.                                            reg=0;
     
245.                                 }        
     
246.                         }
     
247. 
     
248.                 }
     
249.         }
     
250.         if(CF)
     
251.         {
     
252.                 CF=0;
     
253.         
     
254.         }
     
255. }
     
256. /***************************P0=j*****************/
     
257. void Adjust_display(void)
     
258. {
     
259.          
     
260.          if(e==1)
     
261.          {
     
262.                  sendRXbyte(hanzi[0][line],0,8); //年
     
263.                  sendRXbyte(hanzi[1][line],0,8);
     
264.                  sendRXbyte(EC_8X16[yy/10][line],1,8);  
     
265.                  sendRXbyte(EC_8X16[yy%10][line],1,8);
     
266.                  
     
267. //                 sendRXbyte(hanzi[0][line+8],0,8); //年
     
268. //                 sendRXbyte(hanzi[1][line+8],0,8);
     
269. //                 sendRXbyte(EC_8X16[yy/10][line+8],1,8);  
     
270. //                 sendRXbyte(EC_8X16[yy%10][line+8],1,8);
     
271.          }
     
272.          else if(e==2)
     
273.          {
     
274.                   sendRXbyte(hanzi[2][line],1,8); //月
     
275.                  sendRXbyte(hanzi[3][line],1,8);
     
276.                  sendRXbyte(EC_8X16[mo/10][line],0,8);  
     
277.                  sendRXbyte(EC_8X16[mo%10][line],0,8);
     
278.                  
     
279. //                 sendRXbyte(hanzi[2][line+8],1,8); //月
     
280. //                 sendRXbyte(hanzi[3][line+8],1,8);
     
281. //                 sendRXbyte(EC_8X16[mo/10][line+8],0,8);  
     
282. //                 sendRXbyte(EC_8X16[mo%10][line+8],0,8);        
     
283.          }
     
284.          else if(e==3)
     
285.          {
     
286.                   sendRXbyte(hanzi[4][line],1,8); //日
     
287.                  sendRXbyte(hanzi[5][line],1,8);
     
288.                  sendRXbyte(EC_8X16[dd/10][line],2,8);  
     
289.                  sendRXbyte(EC_8X16[dd%10][line],2,8);
     
290. //                 
     
291. //                 sendRXbyte(hanzi[4][line+8],1,8); //日
     
292. //                 sendRXbyte(hanzi[5][line+8],1,8);
     
293. //                 sendRXbyte(EC_8X16[dd/10][line+8],2,8);  
     
294. //                 sendRXbyte(EC_8X16[dd%10][line+8],2,8);        
     
295.          }
     
296.          else if(e==4)
     
297.          {
     
298.                   sendRXbyte(hanzi[6][line],0,8); //周
     
299.                  sendRXbyte(hanzi[7][line],0,8);
     
300.                  sendRXbyte(EC_8X16[week/10][line],2,8);  
     
301.                  sendRXbyte(EC_8X16[week%10][line],2,8);
     
302.                  
     
303. //                 sendRXbyte(hanzi[6][line+8],0,8); //周
     
304. //                 sendRXbyte(hanzi[7][line+8],0,8);
     
305. //                 sendRXbyte(EC_8X16[week/10][line+8],2,8);  
     
306. //                 sendRXbyte(EC_8X16[week%10][line+8],2,8);        
     
307.          }        
     
308.          else if(e==5)
     
309.          {
     
310.                   sendRXbyte(hanzi[8][line],1,8);//时
     
311.                  sendRXbyte(hanzi[9][line],1,8);
     
312.                  sendRXbyte(EC_8X16[hh/10][line],0,8);  
     
313.                  sendRXbyte(EC_8X16[hh%10][line],0,8);
     
314. //                 
     
315. //                 sendRXbyte(hanzi[8][line+8],1,8);//时
     
316. //                 sendRXbyte(hanzi[9][line+8],1,8);
     
317. //                 sendRXbyte(EC_8X16[hh/10][line+8],0,8);  
     
318. //                 sendRXbyte(EC_8X16[hh%10][line+8],0,8);        
     
319.          }
     
320.          else if(e==6)
     
321.          {
     
322.                   sendRXbyte(hanzi[10][line],0,8);//分
     
323.                  sendRXbyte(hanzi[11][line],0,8);
     
324.                  sendRXbyte(EC_8X16[mm/10][line],2,8);  
     
325.                  sendRXbyte(EC_8X16[mm%10][line],2,8);
     
326.                  
     
327. //                 sendRXbyte(hanzi[10][line+8],0,8);//分
     
328. //                 sendRXbyte(hanzi[11][line+8],0,8);
     
329. //                 sendRXbyte(EC_8X16[mm/10][line+8],2,8);  
     
330. //                 sendRXbyte(EC_8X16[mm%10][line+8],2,8);        
     
331.          }
     
332.          else if(e==7)
     
333.          {
     
334.                   sendRXbyte(hanzi[12][line],1,8);//秒
     
335.                  sendRXbyte(hanzi[13][line],1,8);
     
336.                  sendRXbyte(EC_8X16[ss/10][line],2,8);  
     
337.                  sendRXbyte(EC_8X16[ss%10][line],2,8);
     
338. //                 
     
339. //                 sendRXbyte(hanzi[12][line+8],1,8);//秒
     
340. //                 sendRXbyte(hanzi[13][line+8],1,8);
     
341. //                 sendRXbyte(EC_8X16[ss/10][line+8],2,8);  
     
342. //                 sendRXbyte(EC_8X16[ss%10][line+8],2,8);        
     
343.          }
     
344.          else if((e==8)||(e==9))
     
345.          {
     
346.                   if(read_clock(10,TimeCH_OCHARGE) == 1) //时间补偿加/减显示
     
347.                  {
     
348.                          sendRXbyte(hanzi[14][line],1,8);//加
     
349.                          sendRXbyte(hanzi[15][line],1,8);
     
350.                          sendRXbyte(EC_8X16[read_clock(10,TimeCH_NumTime)/10][line],2,8);  
     
351.                          sendRXbyte(EC_8X16[read_clock(10,TimeCH_NumTime)%10][line],2,8);
     
352. //                        
     
353. //                         sendRXbyte(hanzi[14][line+8],1,8);//加
     
354. //                         sendRXbyte(hanzi[15][line+8],1,8);
     
355. //                         sendRXbyte(EC_8X16[read_clock(10,TimeCH_NumTime)/10][line+8],2,8);  
     
356. //                         sendRXbyte(EC_8X16[read_clock(10,TimeCH_NumTime)%10][line+8],2,8);
     
357.                  }
     
358.                  else if(read_clock(10,TimeCH_OCHARGE) == 0)
     
359.                  {
     
360.                           sendRXbyte(hanzi[16][line],1,8);//减
     
361.                          sendRXbyte(hanzi[17][line],1,8);
     
362.                          sendRXbyte(EC_8X16[read_clock(10,TimeCH_NumTime)/10][line],0,8);  
     
363.                          sendRXbyte(EC_8X16[read_clock(10,TimeCH_NumTime)%10][line],0,8);
     
364.                         
     
365. //                         sendRXbyte(hanzi[16][line+8],1,8);//减
     
366. //                         sendRXbyte(hanzi[17][line+8],1,8);
     
367. //                         sendRXbyte(EC_8X16[read_clock(10,TimeCH_NumTime)/10][line+8],0,8);  
     
368. //                         sendRXbyte(EC_8X16[read_clock(10,TimeCH_NumTime)%10][line+8],0,8);        
     
369.                  }        
     
370.          }
     
371.          /*************************************************/
     
372. 
     
373. }
     
374. /**************************P0=j****************/
     
375. void SendByte(unsigned char dat)
     
376. {
     
377.          SBUF = dat;
     
378.          while(!TI);
     
379.       TI = 0;
     
380. }
     
381. /*************************************************************/
     
382. void show_menu(void)
     
383. {
     
384.                 for(line=0;line<16;line++)
     
385.                         {
     
386.                                 //for(Mspeed=0;Mspeed<1;Mspeed++)
     
387.                                 //{
     
388.                                         Adjust_display();//调时模式
     
389.                                 scan(line); //打开行扫描                                                                                             
     
390.                                     STR=1;//锁存
     
391.                                     STR=0;
     
392.                                         OE=0;
     
393.                                         delay(5);
     
394.                                         OE=1;
     
395.                                 //}
     
396.                         }
     
397.                         
     
398. }
     
399. /******************************P0=j**********************/
     
400. /*主函数*/
     
401. void main()
     
402. {  
     
403.         //uchar Mspeed=0;
     
404.   SCON = 0x50;
     
405.   BRT= 0xf8;  //0xfb: 30MHz,12T,SMOD=0,9600bps
     
406.   AUXR   |= 0x11;        // 使用独立波特率发生器
     
407.   TMOD=0x01; //定时器0 16位定时定时器1方式2
     
408.   TH0 = 0x0F6;
     
409.   TL0 = 0x3C;
     
410.   OE=0;
     
411.   TR0=1; //开定时器计数
     
412.   ET0=1; //开定时器中断
     
413.   EA=1;         //开中断
     
414. DS1302_Initial();
     
415.   SendByte(0x55);
     
416.   Light=11;//亮度
     
417. // color=0;//显示颜色
     
418.    while(1)  
     
419.    {
     
420.                 KEY_scan();        //扫描按键
     
421.                 TimeCHck();        //时间补偿
     
422.                 if(ADJ==1)
     
423.                 {
     
424.                         ADJ=0xFF;
     
425.                         Mode=2;
     
426.                         //TR0=0;
     
427.                         //DS1302_TimeStop(1);  //只有调时间时,时钟停
     
428.                         e++;
     
429.                         if(e>9)
     
430.                         e=1;
     
431.                 }
     
432.                 if(Mode==2)        //如果是调时模式
     
433.                 {
     
434.                         if(ADJ==2)
     
435.                         {
     
436.                                 //ADJ=0xFF;
     
437.                         //        SendByte(2);
     
438.                                 //EA=0;
     
439.                                 Set_time(e); //调整
     
440.                         //        EA=1;
     
441.                         
     
442.                         }
     
443.                         if(ADJ==3)
     
444.                         {
     
445.                         //        ADJ=0XFF;
     
446.                                 //SendByte(3);
     
447.                                 //EA=0;
     
448.                                 Set_time(e); //调整
     
449.                                 //EA=1;
     
450.                                 
     
451.                         }
     
452.                         if(ADJ==4)
     
453.                         {
     
454.                                 Mode=0;
     
455.                                 
     
456.                                 e=0;
     
457.                                 ADJ=0XFF;
     
458.                         //        SendByte(4);
     
459.                                         TR0=1;
     
460.                                 //DS1302_TimeStop(0);  //只有调时间时,时钟停
     
461.                         }
     
462.                                 show_menu();
     
463.                 }
     
464.         
     
465.    }
     
466. }         
     
467. /***********************************P0=j**********************************************************
     
468. 函数名：Pwritekong();
     
469. 调  用：
     
470. 参  数：无
     
471. 返回值：无
     
472. 结  果：送空数据
     
473. 备  注：
     
474. /**********************************************************************************************/
     
475. void writekong()  //送空数据
     
476. {
     
477.     SDA_R=SDA_G=SDA_B=0;
     
478.     SCK=0;     
     
479.     SCK=1;
     
480. }
     
481. /*********************************************************************************************
     
482. 函数名：writemao();
     
483. 调  用：
     
484. 参  数：无
     
485. 返回值：无
     
486. 结  果：送红数据
     
487. 备  注：
     
488. /**********************************************************************************************/
     
489. void writemao(uchar dat)  //送中间秒闪烁数据
     
490. {
     
491.    uchar i;
     
492.    SDA_R=SDA_G=SDA_B=0;
     
493. for(i=0;i<2;i++)     
     
494.   {
     
495.     dat=dat<<1;
     
496.     SDA_B=CY;
     
497.     SCK=0;     
     
498.     SCK=1;
     
499.   }
     
500. }
     
501. /*********************************************************************************************
     
502. 函数名： 任意位数任意颜色74HC595程序
     
503. 调  用：writeda(uchar dat,uchar n,uchar clour)
     
504. 参  数：无
     
505. 返回值：无
     
506. 结  果：
     
507. 备  注：
     
508. /**********************************************************************************************/
     
509. void writeda(uchar dat,uchar n,uchar clour) { //送数据
     
510.           uchar i;
     
511.           SDA_R= SDA_G= SDA_B=0;
     
512.          for(i=0;i<n;i++) {
     
513.      switch(n) {
     
514.                             case  3:
     
515.                                    if(clour==0){SDA_R=dat&0x10;}
     
516.                                    if(clour==1){SDA_G=dat&0x10;}
     
517.                                    if(clour==2)SDA_B=dat&0x10;break;         
     
518.                            case  4:
     
519.                                    if(clour==0){SDA_R=dat&0x20;}
     
520.                                    if(clour==1){SDA_G=dat&0x20;}
     
521.                                    if(clour==2)SDA_B=dat&0x20;break;         
     
522.                             case  5:
     
523.                                    if(clour==0){SDA_R=dat&0x20;}
     
524.                                    if(clour==1){SDA_G=dat&0x20;}
     
525.                                    if(clour==2)SDA_B=dat&0x20;break;
     
526.                            case  6:
     
527.                                    if(clour==0){SDA_R=dat&0x40;}
     
528.                                    if(clour==1){SDA_G=dat&0x40;}
     
529.                                    if(clour==2)SDA_B=dat&0x40;break;
     
530.                            case  8:
     
531.                                    if(clour==0){SDA_R=dat&0x80;}
     
532.                                    if(clour==1){SDA_G=dat&0x80;}
     
533.                                    if(clour==2)SDA_B=dat&0x80;break;
     
534.                                  }
     
535.                     dat=dat<<1;
     
536.                 SCK=0;     
     
537.                 SCK=1;
     
538.                         }}
     
539. /***********************发送数据****************************/
     
540. void rxd_data(void)        //串行发送数据
     
541. {
     
542.           // read_clockS();    //读时钟数据
     
543.          uchar Hourcolor,miaocolor,mincolor;
     
544.          switch (color)
     
545.          {
     
546.                  case 0:
     
547.                         Hourcolor=0;
     
548.                         miaocolor=1;
     
549.                         mincolor=1;
     
550.                         break;
     
551.                 case 1:
     
552.                         Hourcolor=1;
     
553.                         miaocolor=1;
     
554.                         mincolor=0;
     
555.                         break;
     
556. 
     
557.                 case 2:
     
558.                         Hourcolor=1;
     
559.                         miaocolor=0;
     
560.                         mincolor=2;
     
561.                         break;
     
562.                 case 3:
     
563.                         Hourcolor=1;
     
564.                         miaocolor=2;
     
565.                         mincolor=0;
     
566.                         break;
     
567.                         /**************4为自动切换颜色模式*****P0=j***************/
     
568.            case 4:                 
     
569.                         Hourcolor=0;
     
570.                         miaocolor=0;
     
571.                         mincolor=0;
     
572.                         break;
     
573.                 default:
     
574.                         break;
     
575.         }   
     
576.         if(line<8)
     
577.         {
     
578.                   OE=1;
     
579.                   writekong();
     
580.                   writeda(table[hh/10*8+line],6,Hourcolor);            
     
581.                   writekong();
     
582.               writeda(table[hh%10*8+line],6,Hourcolor);            
     
583.                   writekong();
     
584.               if(half_sec_flag)
     
585.               writemao(table[80+line]);
     
586.               else
     
587.               writemao(0x00);                             
     
588.                   writekong();
     
589.               writeda(table[mm/10*8+line],6,mincolor);            
     
590.                   writekong();
     
591.               writeda(table[mm%10*8+line],6,mincolor);
     
592.                   writekong();
     
593.           }
     
594. /***************************P0=j********************************/
     
595.          else
     
596.     {
     
597.                    writekong();
     
598.                   writeda(table1[hh/10*8+line-8],6,Hourcolor);              
     
599.                   writekong();
     
600.               writeda(table1[hh%10*8+line-8],6,Hourcolor);              
     
601.                   writekong();
     
602.               
     
603.               if(half_sec_flag)
     
604.               writemao(table[80+line-8]);
     
605.               else
     
606.               writemao(0x00);                              
     
607.                   writekong();
     
608.         
     
609.               writeda(table1[mm/10*8+line-8],6,mincolor);            
     
610.                   writekong();
     
611.               writeda(table1[mm%10*8+line-8],6,mincolor);            
     
612.                   writekong();        
     
613.           }
     
614. 
     
615. }
     
616. /*;*************************P0=j******************************************************
     
617. ;程序名称:sendRXbyte(uchar wdata,uchar c,uchar n)
     
618. ;功能:选择将要送入首地址的值.
     
619. ;输入:R2. sendRXbyte(hanzi[hour/10][i],3,8)橙色数据8位
     
620. ;输出:无. sendRXbyte(hanzi[hour/10][i],2,8)红色数据8位
     
621. ;影响:无. sendRXbyte(hanzi[hour/10][i],1,8)绿色数据8位
     
622. ;修改日期:2010.05.15----b 字模数据，c颜色，n 发送位数（0-8）
     
623. ;*********************************************************************************/
     
624. void sendRXbyte(unsigned char wdata,unsigned char c,unsigned char n)
     
625. {   unsigned char i;
     
626.         SDA_R=SDA_G=SDA_B=0;
     
627.     for(i=0; i<n; i++)           //字符位数8位
     
628.     {   switch(c)
     
629.         {
     
630.          /*-------------------------------------------------红-------*/
     
631.         case 0:SDA_R=(bit)(wdata&0x80);break;
     
632.         /*---------------------------------------------------绿-----*/
     
633.         case 1:SDA_G=(bit)(wdata&0x80);break;
     
634.         /*----------------------------------------------------黄----*/
     
635.         case 2:SDA_B=(bit)(wdata&0x80);break;
     
636.         /*--------------------------------------------------------*/
     
637.         default:break;
     
638.         }
     
639.         SCK=0;           //时钟拉高，产生上升沿
     
640.         SCK=1;           //时钟拉低
     
641.         wdata <<=1;    //左移一位
     
642.     }
     
643. }
     
644. /*********************************************************************************************
     
645. 函数名：Displaying()
     
646. 调  用：
     
647. 结  果：
     
648. /**********************************************************************************************/
     
649. void Displaying()                {//送显示数据                 
     
650. 
     
651. time_count=0;
     
652. ……………………
     
653. 
     
654. …………限于本文篇幅 余下代码请从51黑下载附件…………
     

复制代码

所有资料51hei提供下载:
16X32 RGB 点阵.zip (1.53 MB, 下载次数: 114)

2018-1-12 11:30 上传

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

---

作者: hjc110    时间: 2018-6-4 22:12
亮度自动调节怎么没有看见光敏电阻

---

作者: 木佑111    时间: 2018-6-4 22:50
不错哦

---

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

Powered by Discuz! X3.1