8*8 RGB 74ls595 点阵

开心果

    在舍友提议下，做了个。8*8RGB点阵。功能有单色、彩色、各种图形显示，循环显示数字0至9、左右移动；整体刷屏。目前屏大小只有8*8，还不支持显示汉字，不过驱动板留出了级联接口，慢慢完善。

参考：http://blog.spitzenpfeil.org/wordpress/wp-content/uploads/2008/10/matrix_code.pde

附上原理图：

附上代码：
只需要连接三根线，74595的SCK、RCK、SER（需要级联，前一个595的QH连接到下一个的SER）

1. 
   
2. #define __spi_clock 13   // SCK
   
3. #define __spi_latch 10   //RCK
   
4. #define __spi_data 11    //SER+
   
5. 
   
6. #define __display_enable 9
   
7. #define __rows 8
   
8. #define __max_row __rows-1
   
9. #define __leds_per_row 8
   
10. #define __max_led __leds_per_row-1
    
11. #define __brightness_levels 32 // 0...15 above 28 is bad for ISR ( move to timer1, lower irq freq ! )
    
12. #define __max_brightness __brightness_levels-1
    
13. #define __fade_delay 4
    
14. 
    
15. #define __TIMER1_MAX 0xFFFF // 16 bit CTR
    
16. #define __TIMER1_CNT 0x0130 // 32 levels --> 0x0130; 38 --> 0x0157 (flicker)
    
17. #include <avr/interrupt.h>   
    
18. #include <avr/io.h>
    
19. #include <stdint.h>
    
20. 
    
21. byte brightness_red[__leds_per_row][__rows];
    
22. byte brightness_green[__leds_per_row][__rows];
    
23. byte brightness_blue[__leds_per_row][__rows];
    
24. 
    
25. ISR(TIMER1_OVF_vect) {
    
26.   //TCNT2 = __TIMER2_MAX - __TIMER2_CNT; // precharge TIMER2 to maximize ISR time --> max led brightness
    
27.   TCNT1 = __TIMER1_MAX - __TIMER1_CNT;
    
28.   byte cycle;
    
29.   
    
30.   digitalWrite(__display_enable,LOW); // enable display inside ISR
    
31.   
    
32.   for(cycle = 0; cycle < __max_brightness; cycle++) {
    
33.     byte led;
    
34.     byte row = B00000000;    // row: current source. on when (1)
    
35.     byte red;    // current sinker when on (0)
    
36.     byte green;  // current sinker when on (0)
    
37.     byte blue;   // current sinker when on (0)
    
38. 
    
39.     for(row = 0; row <= __max_row; row++) {
    
40.       
    
41.       red = B11111111;    // off
    
42.       green = B11111111;  // off
    
43.       blue = B11111111;   // off
    
44.       
    
45.    for(led = 0; led <= __max_led; led++) {
    
46.         if(cycle < brightness_red[row][led]) {
    
47.           red &= ~(1<<led);
    
48.         }
    
49.         if(cycle < brightness_green[row][led]) {
    
50.           green &= ~(1<<led);
    
51.         }
    
52.         if(cycle < brightness_blue[row][led]) {
    
53.           blue &= ~(1<<led);
    
54.         }
    
55.       }
    
56.       digitalWrite(__spi_latch,LOW);
    
57.       spi_transfer(blue);
    
58.       spi_transfer(green);
    
59.       spi_transfer(red);
    
60.       spi_transfer(B00000001<<row);
    
61.       digitalWrite(__spi_latch,HIGH);
    
62.       digitalWrite(__spi_latch,LOW);
    
63.     }
    
64.   }
    
65. 
    
66.   digitalWrite(__display_enable,HIGH);    // disable display outside ISR
    
67. }
    
68. 
    
69. int data[]={0x00,0x36,0x7f,0x7f,0x3e,0x1c,0x08,0x00,//xin
    
70.            0x00,0x06,0x69,0x90,0x00,0x42,0x24,0x18,/*"xiaonian",0*/
    
71. 0x00,0x10,0x30,0x10,0x10,0x10,0x10,0x38,/*"1",0*/
    
72. 0x00,0x18,0x24,0x04,0x08,0x10,0x20,0x3C,/*"2",1*/
    
73. 0x00,0x18,0x24,0x04,0x18,0x04,0x24,0x18,/*"3",2*/
    
74. 0x00,0x08,0x18,0x18,0x28,0x28,0x3C,0x08,/*"4",3*/
    
75. 0x00,0x3C,0x20,0x20,0x38,0x04,0x04,0x38,/*"5",4*/
    
76. 0x00,0x18,0x24,0x20,0x38,0x24,0x24,0x18,/*"6",5*/
    
77. 0x00,0x3C,0x24,0x04,0x08,0x10,0x10,0x10,/*"7",6*/
    
78. 0x00,0x18,0x24,0x24,0x18,0x24,0x24,0x18,/*"8",7*/
    
79. 0x00,0x18,0x24,0x24,0x1C,0x04,0x24,0x18,/*"9",8*/
    
80. 0x00,0x18,0x24,0x24,0x24,0x24,0x24,0x18,/*"0",9*/
    
81.            };
    
82. void setup(void) {
    
83.   //Serial.begin(9600);
    
84.   randomSeed(555);
    
85.   byte ctr1;
    
86.   byte ctr2;
    
87.   
    
88.   pinMode(__spi_clock,OUTPUT);
    
89.   pinMode(__spi_latch,OUTPUT);
    
90.   pinMode(__spi_data,OUTPUT);
    
91.   pinMode(__display_enable,OUTPUT);
    
92.   digitalWrite(__spi_latch,LOW);
    
93.   digitalWrite(__spi_data,LOW);
    
94.   digitalWrite(__spi_clock,LOW);
    
95.    
    
96.   setup_hardware_spi();
    
97.   delay(10);
    
98.   set_matrix_rgb(0,0,0);
    
99.   setup_timer1_ovf();
    
100. }
     
101. 
     
102. void loop(void) {
     
103.    int ctr;
     
104.   
     
105.   for(ctr=0; ctr < 2; ctr++) {
     
106.     fader_hue();//整体刷屏，颜色随设定值改变
     
107.   }
     
108.   for(ctr=0; ctr < 1; ctr++) {
     
109.     matrix_test();//从上往下刷屏，颜色随设定值改变
     
110.   }
     
111. 
     
112.   for(ctr=0; ctr < 4; ctr++) {
     
113.     matrix_heart_2();    //彩色
     
114.    // matrix_heart(100); //单色
     
115.   }
     
116. }
     
117. 
     
118. byte spi_transfer(byte data)
     
119. {
     
120.   SPDR = data;                    // Start the transmission
     
121.   while (!(SPSR & (1<<SPIF)))     // Wait the end of the transmission
     
122.   {
     
123.   };
     
124.   return SPDR;                    // return the received byte, we don't need that
     
125. }
     
126. 
     
127. 
     
128. void set_led_red(byte row, byte led, byte red) {
     
129.   brightness_red[row][led] = red;
     
130. }
     
131. 
     
132. void set_led_green(byte row, byte led, byte green) {
     
133.   brightness_green[row][led] = green;
     
134. }
     
135. 
     
136. void set_led_blue(byte row, byte led, byte blue) {
     
137.   brightness_blue[row][led] = blue;
     
138. }
     
139. 
     
140. void set_led_rgb(byte row, byte led, byte red, byte green, byte blue) {
     
141.   set_led_red(row,led,red);
     
142.   set_led_green(row,led,green);
     
143.   set_led_blue(row,led,blue);
     
144. }
     
145. 
     
146. 
     
147. void set_matrix_rgb(byte red, byte green, byte blue) {
     
148.   byte ctr1;
     
149.   byte ctr2;
     
150.   for(ctr2 = 0; ctr2 <= __max_row; ctr2++) {
     
151.     for(ctr1 = 0; ctr1 <= __max_led; ctr1++) {
     
152.       set_led_rgb(ctr2,ctr1,red,green,blue);
     
153.     }
     
154.   }
     
155. }
     
156. 
     
157. 
     
158. void set_led_hue(byte row, byte led, int hue) {
     
159. 
     
160.   // see wikipeda: HSV
     
161.   float S=100.0,V=100.0,s=S/100.0,v=V/100.0,h_i,f,p,q,t,R,G,B;
     
162.    
     
163.     hue = hue%360;
     
164.     h_i = hue/60;            
     
165.     f = (float)(hue)/60.0 - h_i;
     
166.     p = v*(1-s);
     
167.     q = v*(1-s*f);
     
168.     t = v*(1-s*(1-f));
     
169.    
     
170.     if      ( h_i == 0 ) {
     
171.       R = v;
     
172.       G = t;
     
173.       B = p;
     
174.     }
     
175.     else if ( h_i == 1 ) {
     
176.       R = q;
     
177.       G = v;
     
178.       B = p;
     
179.     }
     
180.     else if ( h_i == 2 ) {
     
181.       R = p;
     
182.       G = v;
     
183.       B = t;
     
184.     }
     
185.     else if ( h_i == 3 ) {
     
186.       R = p;
     
187.       G = q;
     
188.       B = v;
     
189.     }
     
190.     else if ( h_i == 4 ) {
     
191.       R = t;
     
192.       G = p;
     
193.       B = v;
     
194.     }
     
195.     else                   {
     
196.       R = v;
     
197.       G = p;
     
198.       B = q;
     
199.     }
     
200. 
     
201.     set_led_rgb(row,led,byte(R*(float)(__max_brightness)),byte(G*(float)(__max_brightness)),byte(B*(float)(__max_brightness)));
     
202.    
     
203.     /*
     
204.     Serial.println(byte(R*(float)(__max_brightness)),DEC);
     
205.     Serial.println(byte(G*(float)(__max_brightness)),DEC);
     
206.     Serial.println(byte(B*(float)(__max_brightness)),DEC);
     
207.     Serial.println("---");
     
208.     */   
     
209. }
     
210. 
     
211. void set_row_byte_hue(byte row, byte data_byte, int hue) {
     
212.   byte led;
     
213.   for(led = 0; led <= __max_led; led++) {
     
214.     if( (data_byte>>led)&(B00000001) ) {
     
215.       set_led_hue(row,led,hue);
     
216.     }
     
217.     else {
     
218.       set_led_rgb(row,led,0,0,0);
     
219.     }
     
220.   }
     
221. }
     
222. 
     
223. void set_matrix_hue(int hue) {
     
224.   byte ctr1;
     
225.   byte ctr2;
     
226.   for(ctr2 = 0; ctr2 <= __max_row; ctr2++) {
     
227.     for(ctr1 = 0; ctr1 <= __max_led; ctr1++) {
     
228.       set_led_hue(ctr2,ctr1,hue);
     
229.     }
     
230.   }
     
231. }
     
232. 
     
233. void set_column_hue(byte column, int hue) {
     
234.   byte ctr1;
     
235.   for(ctr1 = 0; ctr1 <= __max_row; ctr1++) {
     
236.       set_led_hue(ctr1,column,hue);
     
237.   }
     
238. }
     
239. 
     
240. 
     
241. void setup_hardware_spi(void) {
     
242.   byte clr;
     
243. 
     
244.   SPCR |= ( (1<<SPE) | (1<<MSTR) ); // enable SPI as master
     
245.   //SPCR |= ( (1<<SPR1) ); // set prescaler bits
     
246.   SPCR &= ~ ( (1<<SPR1) | (1<<SPR0) ); // clear prescaler bits
     
247.   clr=SPSR; // clear SPI status reg
     
248.   clr=SPDR; // clear SPI data reg
     
249.   SPSR |= (1<<SPI2X); // set prescaler bits
     
250.   //SPSR &= ~(1<<SPI2X); // clear prescaler bits
     
251. }
     
252. 
     
253. 
     
254. void setup_timer1_ovf(void) {
     
255. 
     
256.   TCCR1B &= ~ ( (1<<CS11) );
     
257.   TCCR1B |= ( (1<<CS12) | (1<<CS10) );      
     
258.   //normal mode
     
259.   TCCR1B &= ~ ( (1<<WGM13) | (1<<WGM12) );
     
260.   TCCR1A &= ~ ( (1<<WGM11) | (1<<WGM10) );
     
261.   //Timer1 Overflow Interrupt Enable  
     
262.   TIMSK1 |= (1<<TOIE1);
     
263.   TCNT1 = __TIMER1_MAX - __TIMER1_CNT;
     
264.   // enable all interrupts
     
265.   sei();
     
266. }
     
267. /*---------------------------单色图形--------------------------------------------*/
     
268. //通过改变 hue的值，来改变颜色
     
269. void matrix_heart(int hue) {
     
270. int k,i;
     
271. for(k = 0; k < 600; k=k+48) {
     
272. for(int j=0;j<8;j++)
     
273.       {
     
274.       set_row_byte_hue(j,data[j+i],hue);
     
275.       delay(20*__fade_delay);
     
276.       if(j>=7)
     
277.       i+=8;
     
278.       else if(i>=96)
     
279.       i=0;
     
280.       }
     
281. }
     
282. }
     
283. /*---------------------------彩色图形--------------------------------------------*/
     
284. //通过改变 hue=hue++*里面*的值，来改变颜色变换速率
     
285. void matrix_heart_2(void) {
     
286.   int hue,i=0;
     
287.   for(hue = 0; hue < 600; hue=hue+48) {
     
288.       for(int j=0;j<8;j++)
     
289.       {
     
290.       set_row_byte_hue(j,data[j+i],hue);
     
291.       delay(20*__fade_delay);
     
292.       if(j>=7)
     
293.       i+=8;
     
294.       else if(i>=96)
     
295.       i=0;
     
296.       }
     
297.   }
     
298. }
     
299. 
     
300. /*---------------------------满屏切换不同颜色--------------------------------------------*/
     
301. //通过改变 ctr1=ctr1+*里面*的值，来改变颜色变换速率
     
302. void fader_hue(void) {
     
303.   int ctr1;
     
304.   byte row;
     
305.   byte led;
     
306. 
     
307.   for(ctr1 = 0; ctr1 < 360; ctr1=ctr1+3) {
     
308.     set_matrix_hue((float)(ctr1));
     
309.     delay(__fade_delay);
     
310.   }
     
311. }
     
312. /*---------------------------从上往下单行切换不同颜色--------------------------------------------*/
     
313. //通过改变 hue=hue++*里面*的值，来改变颜色变换速率
     
314. void matrix_test(void) {
     
315.   byte ctr1;
     
316.   byte ctr2;
     
317.   int hue;
     
318.   
     
319.   for(hue = 0; hue < 360; hue=hue+32) {
     
320.     for(ctr2 = 0; ctr2 <= __max_row; ctr2++) {
     
321.       for(ctr1 = 0; ctr1 <= __max_led; ctr1++) {
     
322.         set_led_hue(ctr2,ctr1,hue);
     
323.         delay(5);
     
324.       }
     
325.     }
     
326.   }  
     
327. }

复制代码

视频：

heiketiguo

不错不错！我也正在做这个！不过，我是照抄老外的

爱因你而生

我的是淘宝现成的 55全彩的模块

开心果

heiketiguo 发表于 2013-10-10 11:42
不错不错！我也正在做这个！不过，我是照抄老外的

老外这个给力，我也在改进中。。。

亦已即

#define __display_enable 9  这个脚连到哪里？