32*16 RGB LED点阵32*16 RGB LED点阵

smching

老外设计的32*16 RGB LED点阵
先看看Youtube。LED置入乒乓球里，变成大屏幕了

1. 
   
2. /*-------------------------------------------------------------------------------------------------------------------------------------------*/
   
3. 
   
4. //Definitions
   
5. #define number_of_gray_scale_values 4 // corresponds to 6 Gray-Scale-Levels
   
6. 
   
7. #define Latch      2 // PIN number on PORTC
   
8. #define Clock      1 // PIN number on PORTC
   
9. #define Enable     0 // PIN number on PORTC
   
10. #define Clear      3 // PIN number on PORTC
    
11. #define Debug      2 // PIN number on PORTB
    
12. 
    
13. #define Data_r_u   2 // PIN number on PORTD
    
14. #define Data_g_u   3 // PIN number on PORTD
    
15. #define Data_b_u   4 // PIN number on PORTD
    
16. #define Data_z_u   5 // PIN number on PORTD
    
17. #define Data_r_d   6 // PIN number on PORTD
    
18. #define Data_g_d   7 // PIN number on PORTD
    
19. #define Data_b_d   0 // PIN number on PORTB
    
20. #define Data_z_d   1 // PIN number on PORTB
    
21. 
    
22. #define Latch_Low       PORTC &=  ~(1 << Latch)
    
23. #define Latch_High      PORTC |=   (1 << Latch)
    
24. #define Clock_Low       PORTC &=  ~(1 << Clock)
    
25. #define Clock_High      PORTC |=   (1 << Clock)
    
26. #define Enable_Low      PORTC &=  ~(1 << Enable)
    
27. #define Enable_High     PORTC |=   (1 << Enable)
    
28. #define Clear_Low       PORTC &=  ~(1 << Clear)
    
29. #define Clear_High      PORTC |=   (1 << Clear)
    
30. #define Debug_Low       PORTB &=  ~(1 << Debug)
    
31. #define Debug_High      PORTB |=   (1 << Debug)
    
32. 
    
33. #define Data_r_u_Low    PORTD &=  ~(1 << Data_r_u)
    
34. #define Data_r_u_High   PORTD |=   (1 << Data_r_u)
    
35. #define Data_g_u_Low    PORTD &=  ~(1 << Data_g_u)
    
36. #define Data_g_u_High   PORTD |=   (1 << Data_g_u)
    
37. #define Data_b_u_Low    PORTD &=  ~(1 << Data_b_u)
    
38. #define Data_b_u_High   PORTD |=   (1 << Data_b_u)
    
39. #define Data_z_u_Low    PORTD &=  ~(1 << Data_z_u)
    
40. #define Data_z_u_High   PORTD |=   (1 << Data_z_u)
    
41. #define Data_r_d_Low    PORTD &=  ~(1 << Data_r_d)
    
42. #define Data_r_d_High   PORTD |=   (1 << Data_r_d)
    
43. #define Data_g_d_Low    PORTD &=  ~(1 << Data_g_d)
    
44. #define Data_g_d_High   PORTD |=   (1 << Data_g_d)
    
45. #define Data_b_d_Low    PORTB &=  ~(1 << Data_b_d)
    
46. #define Data_b_d_High   PORTB |=   (1 << Data_b_d)
    
47. #define Data_z_d_Low    PORTB &=  ~(1 << Data_z_d)
    
48. #define Data_z_d_High   PORTB |=   (1 << Data_z_d)
    
49. 
    
50. /*-------------------------------------------------------------------------------------------------------------------------------------------*/
    
51. 
    
52. //Global variables
    
53. unsigned char dispmem[512];          //Display Memory
    
54. static unsigned char *ptr_dispmem;   //Pointer to Display Memory used in ISR-Funktion
    
55. 
    
56. //Color-Look-Up-Table for full Color Scale --> 216 colors (6xR + 6xG + 6xB)
    
57. unsigned char LUT_r[216];
    
58. unsigned char LUT_g[216];
    
59. unsigned char LUT_b[216];
    
60. 
    
61. //Reduced Color-Look-Up-Table - Contains only Colors within the topmost Color-Cycle
    
62. unsigned char LUT_r_reduced[30];
    
63. unsigned char LUT_g_reduced[30];
    
64. unsigned char LUT_b_reduced[30];
    
65. 
    
66. //Pointers to dispmem
    
67. static unsigned char *ptr_dispmem_u;
    
68. static unsigned char *ptr_dispmem_d;
    
69.   
    
70. unsigned char compare_value = 0;
    
71. unsigned char row = 0;
    
72. unsigned char x   = 0;
    
73. 
    
74. byte remote = 0;
    
75. 
    
76. /*-------------------------------------------------------------------------------------------------------------------------------------------*/
    
77. 
    
78. //Initialize USART Comunication
    
79. void uart_init(void)
    
80. {
    
81.   UCSR0A |= (1<<U2X0);                                 // Double up UART
    
82.   UCSR0B |= (1<<RXEN0)  | (1<<TXEN0) | (1<<RXCIE0);    // UART RX, TX und RX Interrupt enable
    
83.   UCSR0C |= (1<<UCSZ01) | (1<<UCSZ00)             ;    // Asynchrous 8N1
    
84. 
    
85.   UBRR0H = 0;
    
86.   UBRR0L = 16; //Baud Rate 115200   --> 2.1% Error at 16MHz
    
87. }
    
88. 
    
89. /*-------------------------------------------------------------------------------------------------------------------------------------------*/
    
90. 
    
91. //Initialize Look Up Tables
    
92. void LUT_init(void)
    
93. {
    
94.   //Full LUT with 216 colors
    
95.   for (byte i = 0; i < 216; i++)
    
96.   {
    
97.     LUT_r[i] = (byte)(i/36);
    
98.     LUT_g[i] = (byte)((i%36)/6);
    
99.     LUT_b[i] = i%6;
    
100.   }
     
101.   
     
102.   //Reduced LUT with 30 colors
     
103.   for (byte k=0; k<5; k++)
     
104.   {
     
105.     LUT_r_reduced[k     ] =   5; // R: 5
     
106.     LUT_g_reduced[k     ] = k+1; // G: 1 --> 5
     
107.     LUT_b_reduced[k     ] =   0; // B: 0
     
108. 
     
109.     LUT_r_reduced[5  + k] = 4-k; // R: 4 --> 0
     
110.     LUT_g_reduced[5  + k] =   5; // G: 5
     
111.     LUT_b_reduced[5  + k] =   0; // B: 0
     
112.             
     
113.     LUT_r_reduced[10 + k] =   0; // R: 0
     
114.     LUT_g_reduced[10 + k] =   5; // G: 5
     
115.     LUT_b_reduced[10 + k] = k+1; // B: 1 --> 5
     
116.    
     
117.     LUT_r_reduced[15 + k] =   0; // R: 0
     
118.     LUT_g_reduced[15 + k] = 4-k; // G: 4 --> 0
     
119.     LUT_b_reduced[15 + k] =   5; // B: 5
     
120.               
     
121.     LUT_r_reduced[20 + k] = k+1; // R: 1 --> 5
     
122.     LUT_g_reduced[20 + k] =   0; // G: 0
     
123.     LUT_b_reduced[20 + k] =   5; // B: 5      
     
124.             
     
125.     LUT_r_reduced[25 + k] =   5; // R: 5
     
126.     LUT_g_reduced[25 + k] =   0; // G: 0
     
127.     LUT_b_reduced[25 + k] = 4-k; // B: 4 --> 0
     
128.   }
     
129. }
     
130. 
     
131. /*-------------------------------------------------------------------------------------------------------------------------------------------*/
     
132. 
     
133. //Interrupt Service Function which is called everytime a byte is recieved
     
134. ISR(USART_RX_vect)
     
135. {
     
136.   unsigned char b;
     
137.   b=UDR0;
     
138.   if (b == 255) {ptr_dispmem = dispmem;}
     
139.   else
     
140.   {
     
141.     *ptr_dispmem = b;
     
142.     ptr_dispmem++;
     
143.   }
     
144. }
     
145. 
     
146. /*-------------------------------------------------------------------------------------------------------------------------------------------*/
     
147. 
     
148. //Refresh Function - refreshes one ROW each time called (time apprx. 175 猀)
     
149. void refresh_leds(void)
     
150. {  
     
151.   unsigned char temp_u;
     
152.   unsigned char temp_d;
     
153.                     
     
154.   //Clear Latch
     
155.   Latch_Low;
     
156.         
     
157.   for (x = 0; x < 32; x++)
     
158.   {                    
     
159.     //Clear Clock in advance      
     
160.     Clock_Low;
     
161.    
     
162.     //Clear all Data Outputs in advance
     
163.     PORTD &=  B00000011;
     
164.     PORTB &=  B11111100;
     
165.                
     
166.     //Copy current color value only once from dispmem
     
167.     temp_u = *ptr_dispmem_u;
     
168.     temp_d = *ptr_dispmem_d;
     
169.    
     
170.     //Set Data Outputs if necessary
     
171.     if (LUT_r[temp_u] > compare_value) {Data_r_u_High;}
     
172.     if (LUT_g[temp_u] > compare_value) {Data_g_u_High;}
     
173.     if (LUT_b[temp_u] > compare_value) {Data_b_u_High;}
     
174.    
     
175.     if (LUT_r[temp_d] > compare_value) {Data_r_d_High;}
     
176.     if (LUT_g[temp_d] > compare_value) {Data_g_d_High;}
     
177.     if (LUT_b[temp_d] > compare_value) {Data_b_d_High;}
     
178.    
     
179.     if ((x == row) || (x == row + 8) || (x == row + 16) || (x == row + 24)) {Data_z_u_High; Data_z_d_High;}
     
180.     if (row == 8) {Data_z_u_Low; Data_z_d_Low;}
     
181.    
     
182.     //Set Clock and thus shift out current bits
     
183.     Clock_High;
     
184.    
     
185.     //Increment Pointers                  
     
186.     ptr_dispmem_u++;
     
187.     ptr_dispmem_d++;   
     
188.   }
     
189.   
     
190.   //Set Latch
     
191.   Latch_High;
     
192.   
     
193.   //Row is done --> Increment Row Number
     
194.   row++;
     
195.   
     
196.   //If Frame is done
     
197.   if (row == 9)
     
198.   {
     
199.     row = 0;
     
200.     ptr_dispmem_u = dispmem;
     
201.     ptr_dispmem_d = dispmem + 256;
     
202.     compare_value++;
     
203.     if (compare_value > number_of_gray_scale_values) {compare_value = 0;}
     
204.   }
     
205.   
     
206. }
     
207. 
     
208. /*-------------------------------------------------------------------------------------------------------------------------------------------*/
     
209. 
     
210. /*-------------------------------------------------------------------------------------------------------------------------------------------*/
     
211. 
     
212. //Does the same as the refresh-funcition above but with the reduced color LUT
     
213. void refresh_leds_with_reduced_colors(void)
     
214. {  
     
215.   unsigned char temp_u;
     
216.   unsigned char temp_d;
     
217.                  
     
218.   //Clear Latch
     
219.   Latch_Low;
     
220.       
     
221.   for (x = 0; x < 32; x++)
     
222.   {                    
     
223.     //Clear Clock in advance      
     
224.     Clock_Low;
     
225.    
     
226.     //Clear all Data Outputs in advance
     
227.     PORTD &=  B00000011;
     
228.     PORTB &=  B11111100;
     
229.                
     
230.     //Copy current color value only once from dispmem
     
231.     temp_u = *ptr_dispmem_u;
     
232.     temp_d = *ptr_dispmem_d;
     
233.    
     
234.     //Set Data Outputs if necessary
     
235.     if (LUT_r_reduced[temp_u] > compare_value) {Data_r_u_High;}
     
236.     if (LUT_g_reduced[temp_u] > compare_value) {Data_g_u_High;}
     
237.     if (LUT_b_reduced[temp_u] > compare_value) {Data_b_u_High;}
     
238.    
     
239.     if (LUT_r_reduced[temp_d] > compare_value) {Data_r_d_High;}
     
240.     if (LUT_g_reduced[temp_d] > compare_value) {Data_g_d_High;}
     
241.     if (LUT_b_reduced[temp_d] > compare_value) {Data_b_d_High;}
     
242.    
     
243.     if ((x == row) || (x == row + 8) || (x == row + 16) || (x == row + 24)) {Data_z_u_High; Data_z_d_High;}
     
244.     if (row == 8) {Data_z_u_Low; Data_z_d_Low;}
     
245.    
     
246.     //Set Clock and thus shift out current bits
     
247.     Clock_High;
     
248.    
     
249.     //Increment Pointers                  
     
250.     ptr_dispmem_u++;
     
251.     ptr_dispmem_d++;   
     
252.   }
     
253.   
     
254.   //Set Latch
     
255.   Latch_High;
     
256.   
     
257.   //Row is done --> Increment Row Number
     
258.   row++;
     
259.   
     
260.   //If Frame is done
     
261.   if (row > 8)
     
262.   {
     
263.     row = 0;
     
264.     ptr_dispmem_u = dispmem;
     
265.     ptr_dispmem_d = dispmem + 256;
     
266.     compare_value++;
     
267.     if (compare_value > number_of_gray_scale_values) {compare_value = 0;}
     
268.   }
     
269.   
     
270. }
     
271. 
     
272. /*-------------------------------------------------------------------------------------------------------------------------------------------*/
     
273. 
     
274. //Setup Function called once at the beginning
     
275. void setup()
     
276. {
     
277.   
     
278.   //Set PINs as OUTPUTs
     
279.   DDRD = DDRD | B11111100;
     
280.   DDRB = DDRB | B00000111;
     
281.   DDRC = DDRC | B00001111;
     
282.   
     
283.   //Set Select_Button_Pin as Input
     
284.   pinMode(19, INPUT);
     
285.   delay(10);
     
286.   if (digitalRead(19)) {remote = 1;}
     
287.   
     
288.   Debug_High;
     
289.   delay(50);
     
290.   Debug_Low;
     
291.   
     
292.   Enable_Low;
     
293.   Clear_High;
     
294.   
     
295.   for (int i=0; i<512; i++){dispmem[i]=0;}
     
296.   
     
297.   uart_init();
     
298.   LUT_init();
     
299.   ptr_dispmem = dispmem;
     
300.   
     
301.   ptr_dispmem_u = dispmem;
     
302.   ptr_dispmem_d = dispmem + 256;
     
303.   
     
304.   sei();
     
305.   
     
306. }
     
307. 
     
308. /*-------------------------------------------------------------------------------------------------------------------------------------------*/
     
309. 
     
310. //Loop Function called over and over again
     
311. void loop()
     
312. {
     
313.   if (remote == 1)
     
314.   {
     
315.     refresh_leds();
     
316.   }
     
317.   else
     
318.   {     
     
319.     byte do_plasma = random(100);
     
320.     //Plasma should be the most significant secence on the wall cause this is what it was made for, so 50% seems a fair number
     
321.     if (do_plasma < 50)
     
322.     {
     
323.       plasma(random(5,40),random(25, 050));
     
324.     }
     
325.     //if sequence is not plasma than its randomly choosen from a repertoir
     
326.     else
     
327.     {
     
328.       byte   sequence = random(4);
     
329.       byte   duration = random(5,40);   //How long the sequence should last
     
330.       byte frame_time = random(60,100); //Speed of the sequence
     
331.       
     
332.       switch (sequence)
     
333.       {
     
334.         case 0: falling_points(duration, frame_time); break;
     
335.         case 1:  random_points(duration, frame_time); break;
     
336.         case 2:           pong(duration, frame_time); break;
     
337.         case 3:          boxes(duration, frame_time); break;
     
338.       }
     
339.     }
     
340.   }
     
341. }
     
342. 
     
343. /*-------------------------------------------------------------------------------------------------------------------------------------------*/
     
344. 
     
345. 
     
346. 
     
347. //Sequences//
     
348. 
     
349. /*-------------------------------------------------------------------------------------------------------------------------------------------*/
     
350. 
     
351. void plasma (unsigned long duration, unsigned long frame_time)
     
352. {
     
353.   //Variables
     
354.   unsigned long end_time = millis() + (duration * 1000);
     
355.   byte pixel_size_x = random(2,7);
     
356.   byte pixel_size_y = random(2,7);
     
357.    
     
358.   //Pointer to frame
     
359.   static unsigned char *ptr_frame;
     
360.       
     
361.   //Calculate Plasma Geometry only ONCE
     
362.   for(byte y = 0; y < 16;  y++)
     
363.   {
     
364.     for(byte x = 0; x < 32; x++)
     
365.     {
     
366.       dispmem[y*32 + x] = (byte) ((15+15*(sin(((float)x)/pixel_size_x)) + 15+15*(sin(((float)y)/pixel_size_y))) / 2);
     
367.     }
     
368.   }
     
369.    
     
370.   do
     
371.   {   
     
372.     ptr_frame = dispmem;
     
373.    
     
374.     for (byte y = 0; y < 16; y++)
     
375.     {
     
376.       for (byte x = 0; x < 32; x++)
     
377.       {
     
378.         if (*ptr_frame == 29) {*ptr_frame = 0;} else {*ptr_frame = *ptr_frame + 1;}
     
379.         ptr_frame++;
     
380.       }
     
381.     }
     
382.    
     
383.     unsigned long frame_end_time = millis() + frame_time;
     
384.    
     
385.     Enable_Low;
     
386.    
     
387.     while (frame_end_time > millis())
     
388.     {
     
389.       for (byte x=0; x<8; x++){refresh_leds_with_reduced_colors();}
     
390.     }
     
391.    
     
392.     Enable_High;
     
393.    
     
394.   } while (millis() <= end_time);
     
395. 
     
396.   //At the end of the plasma sequence fade all LEDs smoothly to red
     
397.   frame_time = 80;
     
398.   
     
399.   for (byte c=0; c < 30; c++)
     
400.   {
     
401.     ptr_frame = dispmem;
     
402.    
     
403.     for (byte y = 0; y < 16; y++)
     
404.     {
     
405.       for (byte x = 0; x < 32; x++)
     
406.       {
     
407.         if (*ptr_frame < 29) {*ptr_frame = *ptr_frame + 1;}
     
408.         ptr_frame++;
     
409.       }
     
410.     }
     
411.    
     
412.     unsigned long frame_end_time = millis() + frame_time;
     
413.     Enable_Low;
     
414.     while (frame_end_time > millis())
     
415.     {
     
416.       for (byte x=0; x<8; x++){refresh_leds_with_reduced_colors();}
     
417.     }
     
418.     Enable_High;
     
419.   }
     
420.   
     
421. }
     
422. 
     
423. /*-------------------------------------------------------------------------------------------------------------------------------------------*/
     
424. 
     
425. /*-------------------------------------------------------------------------------------------------------------------------------------------*/
     
426. 
     
427. void falling_points (unsigned long duration, unsigned long frame_time)
     
428. {
     
429.   //Variables
     
430.   unsigned long end_time = millis() + (duration * 1000);
     
431.   
     
432.   //Clear Dispmem first
     
433.   for (byte y = 0; y < 16; y++)
     
434.   {
     
435.     for (byte x = 0; x < 32; x++)
     
436.     {
     
437.       dispmem[y*32+x] = 0;
     
438.     }
     
439.   }
     
440.             
     
441.   do
     
442.   {        
     
443. 
     
444.     for (byte y = 15; y > 0; y--)
     
445.     {
     
446.       for (byte x = 0; x < 32; x++)
     
447.       {
     
448.         dispmem[y*32+x] = dispmem[(y-1)*32+x];
     
449.       }
     
450.     }
     
451.    
     
452.     for (byte i=0; i<32; i++) {dispmem[i] = 0;}
     
453.    
     
454.     byte dummy = random(100);
     
455. 
     
456.     if (dummy <= 20) {dummy =  0;}
     
457.     if (dummy >  20) {dummy =  3;}
     
458.     if (dummy >  30) {dummy =  2;}
     
459.     if (dummy >  40) {dummy =  5;}
     
460.     if (dummy >  50) {dummy =  6;}
     
461.     if (dummy >  60) {dummy =  7;}
     
462.     if (dummy >  70) {dummy =  8;}
     
463.     if (dummy >  80) {dummy =  9;}
     
464.     if (dummy >  90) {dummy = 10;}
     
465.    
     
466.     for (byte i=0; i < dummy; i++)
     
467.     {
     
468.       dispmem[random(32)] = random(216);
     
469.     }
     
470.    
     
471.     unsigned long frame_end_time = millis() + frame_time;
     
472.     Enable_Low;
     
473.     while (frame_end_time > millis())
     
474.     {
     
475.       for (byte x=0; x<8; x++){refresh_leds();}
     
476.     }
     
477.     Enable_High;
     
478.       
     
479.   } while (millis() <= end_time);
     
480. }
     
481. 
     
482. /*-------------------------------------------------------------------------------------------------------------------------------------------*/
     
483. 
     
484. /*-------------------------------------------------------------------------------------------------------------------------------------------*/
     
485. 
     
486. void pong (unsigned long duration, unsigned long frame_time)
     
487. {
     
488.   //Variables  
     
489.   unsigned long end_time = millis() + (duration * 1000);
     
490.   
     
491.   //Pointer to frame
     
492.   static unsigned char *ptr_frame;
     
493.    
     
494.   byte pos_x[7];
     
495.   byte pos_y[7];
     
496.   byte dir_x[7];
     
497.   byte dir_y[7];
     
498.   byte color[7];
     
499.   
     
500.   for (byte i=0; i<7; i++)
     
501.   {
     
502.     pos_x[i]=random(1,31);
     
503.     pos_y[i]=random(1,15);
     
504.     dir_x[i]=random(2);
     
505.     dir_y[i]=random(2);
     
506.     color[i]=random(215);
     
507.   }
     
508.    
     
509.   do
     
510.   {            
     
511.     ptr_frame = dispmem;
     
512.    
     
513.     //clear matrix
     
514.     for (byte y = 0; y < 16; y++)
     
515.     {
     
516.       for (byte x = 0; x < 32; x++)
     
517.       {
     
518.         *ptr_frame = 0;
     
519.         ptr_frame++;
     
520.       }
     
521.     }
     
522.    
     
523.     for (byte i=0; i<7; i++)
     
524.     {
     
525.       if (dir_x[i] == 1)  {pos_x[i]++;} else {pos_x[i]--;}
     
526.       if (dir_y[i] == 1)  {pos_y[i]++;} else {pos_y[i]--;}
     
527.       if (pos_x[i] == 31) {dir_x[i] = 0;}
     
528.       if (pos_y[i] == 15) {dir_y[i] = 0;}
     
529.       if (pos_x[i] ==  0) {dir_x[i] = 1;}
     
530.       if (pos_y[i] ==  0) {dir_y[i] = 1;}
     
531.       dispmem[pos_y[i]*32+pos_x[i]] = color[i];
     
532.     }
     
533.       
     
534.     unsigned long frame_end_time = millis() + frame_time;
     
535.     Enable_Low;
     
536.     while (frame_end_time > millis())
     
537.     {
     
538.       for (byte x=0; x<8; x++){refresh_leds();}
     
539.     }
     
540.     Enable_High;
     
541.       
     
542.   } while (millis() <= end_time);
     
543. }
     
544. 
     
545. /*-------------------------------------------------------------------------------------------------------------------------------------------*/
     
546. 
     
547. /*-------------------------------------------------------------------------------------------------------------------------------------------*/
     
548. 
     
549. void random_points (unsigned long duration, unsigned long frame_time)
     
550. {
     
551.   //Variables
     
552.   unsigned long end_time = millis() + (duration * 1000);
     
553.   byte number_of_points = random(5,20);
     
554.   byte color_of_points[20];
     
555.   
     
556.   //Pointer to frame
     
557.   static unsigned char *ptr_frame;
     
558.          
     
559.   for (byte i=0; i < number_of_points; i++)
     
560.   {
     
561.     color_of_points[i] = random(216);
     
562.   }
     
563.      
     
564.   //Animate Points   
     
565.   do
     
566.   {   
     
567.     ptr_frame = dispmem;
     
568.    
     
569.     //clear matrix
     
570.     for (byte y = 0; y < 16; y++)
     
571.     {
     
572.       for (byte x = 0; x < 32; x++)
     
573.       {
     
574.         *ptr_frame = 0;
     
575.         ptr_frame++;
     
576.       }
     
577.     }
     
578.    
     
579.     for (byte i=0; i < number_of_points; i++)
     
580.     {
     
581.       ptr_frame = dispmem + random(512);
     
582.       *ptr_frame = color_of_points[i];
     
583.     }
     
584.    
     
585.    
     
586.     unsigned long frame_end_time = millis() + frame_time;
     
587.     Enable_Low;
     
588.     while (frame_end_time > millis())
     
589.     {
     
590.       for (byte x=0; x<8; x++){refresh_leds();}
     
591.     }
     
592.     Enable_High;
     
593.    
     
594.   } while (millis() <= end_time);  
     
595. }
     
596. 
     
597. /*-------------------------------------------------------------------------------------------------------------------------------------------*/
     
598. 
     
599. /*-------------------------------------------------------------------------------------------------------------------------------------------*/
     
600. 
     
601. void boxes (unsigned long duration, unsigned long frame_time)
     
602. {
     
603.   //Variables  
     
604.   unsigned long end_time = millis() + (duration * 1000);
     
605.   
     
606.   //Pointer to frame
     
607.   static unsigned char *ptr_frame;
     
608.    
     
609.   byte   pos[] = {0,2,4,6,8,10,12,10};
     
610.   byte   dir[] = {1,1,1,1,1,1,0,0};
     
611.   byte color[] = {180,210,30,35,5,185,180,210};
     
612.         
     
613.   do
     
614.   {            
     
615.     ptr_frame = dispmem;
     
616.    
     
617.     //clear matrix
     
618.     for (byte y = 0; y < 16; y++)
     
619.     {
     
620.       for (byte x = 0; x < 32; x++)
     
621.       {
     
622.         *ptr_frame = 0;
     
623.         ptr_frame++;
     
624.       }
     
625.     }
     
626.    
     
627.     for (byte i=0; i<8; i++)
     
628.     {
     
629.       if (dir[i] ==  1) {pos[i]++;} else {pos[i]--;}
     
630.       if (pos[i] == 12) {dir[i] = 0;}
     
631.       if (pos[i] ==  0) {dir[i] = 1;}
     
632.       dispmem[(pos[i]+0)*32+4*i+0] = color[i];
     
633.       dispmem[(pos[i]+0)*32+4*i+1] = color[i];
     
634.       dispmem[(pos[i]+0)*32+4*i+2] = color[i];
     
635.       dispmem[(pos[i]+0)*32+4*i+3] = color[i];
     
636.       dispmem[(pos[i]+1)*32+4*i+0] = color[i];
     
637.       dispmem[(pos[i]+1)*32+4*i+1] = color[i];
     
638.       dispmem[(pos[i]+1)*32+4*i+2] = color[i];
     
639.       dispmem[(pos[i]+1)*32+4*i+3] = color[i];
     
640.       dispmem[(pos[i]+2)*32+4*i+0] = color[i];
     
641.       dispmem[(pos[i]+2)*32+4*i+1] = color[i];
     
642.       dispmem[(pos[i]+2)*32+4*i+2] = color[i];
     
643.       dispmem[(pos[i]+2)*32+4*i+3] = color[i];
     
644.       dispmem[(pos[i]+3)*32+4*i+0] = color[i];
     
645.       dispmem[(pos[i]+3)*32+4*i+1] = color[i];
     
646.       dispmem[(pos[i]+3)*32+4*i+2] = color[i];
     
647.       dispmem[(pos[i]+3)*32+4*i+3] = color[i];   
     
648.     }
     
649.            
     
650.     unsigned long frame_end_time = millis() + frame_time;
     
651.     Enable_Low;
     
652.     while (frame_end_time > millis())
     
653.     {
     
654.       for (byte x=0; x<8; x++){refresh_leds();}
     
655.     }
     
656.     Enable_High;
     
657.       
     
658.   } while (millis() <= end_time);
     
659. }
     
660. 
     
661. /*-------------------------------------------------------------------------------------------------------------------------------------------*/
     

复制代码

ro0t

还得翻墙。。。

interrgned

ro0t 发表于 2013-6-13 09:52
还得翻墙。。。

用web freer浏览器自带代理服务器

Randy

这次大家不用费心找这个教程了，例程都有了。。。。

smching

ro0t 发表于 2013-6-13 09:52
还得翻墙。。。

我是马来西亚人。为何要翻墙？

ro0t

interrgned 发表于 2013-6-13 19:01
用web freer浏览器自带代理服务器

谢谢  我学习一下  

ro0t

smching 发表于 2013-6-13 22:43
我是马来西亚人。为何要翻墙？

我在中国大陆。。。。。

糯米基

他这是，三色点阵，每个595控制一种颜色，另一个595控制行，那是不是说列全部都接地了
还有，这个如何改成单色点阵的程序呢？最近刚好在研究这个

smching

是的，全部列都得通过NPN晶体管接地，但並非同时接通，而是经过扫描方式接通。

smching

糯米基 发表于 2013-6-14 14:26
他这是，三色点阵，每个595控制一种颜色，另一个595控制行，那是不是说列全部都接地了
还有，这个如何改成 ...

我只找到8x8和48x8单色点阵

8x8单色点阵

1. /*
   
2. * _8x8 LED matrix
   
3. *
   
4. * (c) 2009 BlushingBoy.net
   
5. */
   
6. 
   
7. #include "TimerOne.h"
   
8. 
   
9. byte rows[8] = {9, 14, 8, 12, 1, 7, 2, 5};
   
10. byte cols[8] = {13, 3, 4, 10, 6, 11, 15, 16};
    
11. byte pins[16] = {5, 4, 3, 2, 14, 15, 16, 17, 13, 12, 11, 10, 9, 8, 7, 6};
    
12. byte screen[8] = {0, 0, 0, 0, 0, 0, 0, 0};
    
13. volatile byte screenRow = 0;
    
14. volatile byte screenCol = 0;
    
15. 
    
16. void setup() {
    
17.   Timer1.initialize(100);
    
18.   for (int i = 2; i <= 17; i++)
    
19.     pinMode(i, OUTPUT);
    
20.   Timer1.attachInterrupt(doubleBuffer);
    
21. }
    
22. 
    
23. // interrupt routine
    
24. void doubleBuffer() {
    
25.   // reset the previous iteration
    
26.   digitalWrite(translatePin(rows[screenRow]), HIGH); // set previous off
    
27.   digitalWrite(translatePin(cols[screenCol]), LOW);  // set previous off
    
28.   // go to the next iteration...
    
29.   // go to the next screenCol, wrap if necessary
    
30.   screenCol++;
    
31.   if (screenCol >= 8) {
    
32.     screenCol = 0;
    
33.     // when screenCol wraps, go to the next screenRow, wrap if necessary
    
34.     screenRow++;
    
35.     if (screenRow >= 8) {
    
36.       screenRow = 0;
    
37.     }
    
38.   }
    
39.   // set this iteration
    
40.   if((screen[screenRow]>>screenCol)&B1 == B1) {
    
41.     digitalWrite(translatePin(rows[screenRow]), LOW);  // set this on
    
42.     digitalWrite(translatePin(cols[screenCol]), HIGH); // set this on
    
43.   } else {
    
44.     digitalWrite(translatePin(rows[screenRow]), HIGH); // set this off
    
45.     digitalWrite(translatePin(cols[screenCol]), LOW);  // set this off
    
46.   }
    
47. }
    
48. 
    
49. byte translatePin(byte original) {
    
50.   return pins[original - 1];
    
51. }
    
52. 
    
53. void allOFF() {
    
54.   for (int i = 0; i < 8; i++)
    
55.     screen[i]=0;
    
56. }
    
57. 
    
58. void on(byte row, byte column) {
    
59.     screen[column-1] |= (B1<<(row-1));
    
60. }
    
61. 
    
62. void off(byte row, byte column) {
    
63.     screen[column-1] &= ~(B1<<(row-1));
    
64. }
    
65. 
    
66. // looping some LEDs routine
    
67. void loop() {
    
68.   allOFF();
    
69.   delay(1000);
    
70.   on(3,3); on(3,4); on(3,5); on(3,6);
    
71.   delay(400);
    
72.   allOFF();
    
73.   delay(1000);
    
74.   on(4,4);
    
75.   delay(400);
    
76. }
    

复制代码

8x48单色点阵

1. int x;
   
2. int y;
   
3. int latchPin1 = 5; //Arduino pin connected to blue 12 RCLK of 74HC595
   
4. int clockPin1 = 6; //Arduino pin connected to green 11 SRCLK of 74HC595
   
5. int dataPin1 = 7;  //Arduino pin connected to violet 14 SER of 74HC595
   
6. 
   
7. //-- Rows (Positive Anodes) --
   
8. int latchPin2 = 9; //Arduino pin connected to yellow Latch 12 RCLK of 74HC595
   
9. int clockPin2 = 10; //Arduino pin connected to white Clock 11 SRCLK of 74HC595
   
10. int dataPin2 = 8;  //Arduino pin connected to grey Data 14 SER of 74HC595
    
11. 
    
12. //=== B I T M A P ===
    
13. //Bits in this array represents one LED of the matrix
    
14. // 8 is # of rows, 7 is # of LED matrix we have
    
15. byte bitmap[8][7]; // Change the 7 to however many matrices you want to use.
    
16. int numZones = sizeof(bitmap) / 8;
    
17. int maxZoneIndex = numZones-1;
    
18. int numCols = numZones * 8;
    
19. 
    
20. byte alphabets[][5] = {
    
21.   {0,0,0,0,0},
    
22.   {31, 36, 68, 36, 31},
    
23.   {127, 73, 73, 73, 54},
    
24.   {62, 65, 65, 65, 34},
    
25.   {127, 65, 65, 34, 28},
    
26.   {127, 73, 73, 65, 65},
    
27.   {127, 72, 72, 72, 64},
    
28.   {62, 65, 65, 69, 38},
    
29.   {127, 8, 8, 8, 127},
    
30.   {0, 65, 127, 65, 0},
    
31.   {2, 1, 1, 1, 126},
    
32.   {127, 8, 20, 34, 65},
    
33.   {127, 1, 1, 1, 1},
    
34.   {127, 32, 16, 32, 127},
    
35.   {127, 32, 16, 8, 127},
    
36.   {62, 65, 65, 65, 62},
    
37.   {127, 72, 72, 72, 48},
    
38.   {62, 65, 69, 66, 61},
    
39.   {127, 72, 76, 74, 49},
    
40.   {50, 73, 73, 73, 38},
    
41.   {64, 64, 127, 64, 64},
    
42.   {126, 1, 1, 1, 126},
    
43.   {124, 2, 1, 2, 124},
    
44.   {126, 1, 6, 1, 126},
    
45.   {99, 20, 8, 20, 99},
    
46.   {96, 16, 15, 16, 96},
    
47.   {67, 69, 73, 81, 97},
    
48. };
    
49. 
    
50. //=== S E T U P ===
    
51. 
    
52. void setup() {
    
53.   pinMode(latchPin1, OUTPUT);
    
54.   pinMode(clockPin1, OUTPUT);
    
55.   pinMode(dataPin1, OUTPUT);
    
56. 
    
57.   pinMode(latchPin2, OUTPUT);
    
58.   pinMode(clockPin2, OUTPUT);
    
59.   pinMode(dataPin2, OUTPUT);
    
60. 
    
61.   //-- Clear bitmap --
    
62.   for (int row = 0; row > 8; row++) {
    
63.     for (int zone = 0; zone <= maxZoneIndex; zone++) {
    
64.       bitmap[row][zone] = 0;
    
65.     }
    
66.   }
    
67. }
    
68. 
    
69. //=== F U N C T I O N S ===
    
70. // This routine takes whatever we've setup in the bitmap array and display it on the matrix
    
71. void RefreshDisplay()
    
72. {
    
73.   for (int row = 0; row < 8; row++) {
    
74.     int rowbit = 1 << row;
    
75.     digitalWrite(latchPin2, LOW);  //Hold latchPin LOW for as long as we're transmitting data
    
76.     shiftOut(dataPin2, clockPin2, MSBFIRST, rowbit);   //Transmit data
    
77. 
    
78.     //-- Start sending column bytes --
    
79.     digitalWrite(latchPin1, LOW);  //Hold latchPin LOW for as long as we're transmitting data
    
80. 
    
81.     //-- Shift out to each matrix (zone is 8 columns represented by one matrix)
    
82.     for (int zone = maxZoneIndex; zone >= 0; zone--) {
    
83.       shiftOut(dataPin1, clockPin1, MSBFIRST, bitmap[row][zone]);
    
84.     }
    
85. 
    
86.     //-- Done sending Column bytes, flip both latches at once to eliminate flicker
    
87.     digitalWrite(latchPin1, HIGH
    
88.     digitalWrite(latchPin2, HIGH
    
89. 
    
90.     //-- Wait a little bit to let humans see what we've pushed out onto the matrix --
    
91.     delayMicroseconds(500);
    
92.   }
    
93. }
    
94. 
    
95. // Converts row and colum to actual bitmap bit and turn it off/on
    
96. void Plot(int col, int row, bool isOn)
    
97. {
    
98.   int zone = col / 8;
    
99.   int colBitIndex = x % 8;
    
100.   byte colBit = 1 << colBitIndex;
     
101.   if (isOn)
     
102.     bitmap[row][zone] =  bitmap[y][zone] | colBit;
     
103.   else
     
104.     bitmap[row][zone] =  bitmap[y][zone] & (~colBit);
     
105. }
     
106. // Plot each character of the message one column at a time, updated the display, shift bitmap left.
     
107. void AlphabetSoup()
     
108. {
     
109.   char msg[] = "YOUR TEXT ";
     
110. 
     
111.   for (int charIndex=0; charIndex < (sizeof(msg)-1); charIndex++)
     
112.   {
     
113.     int alphabetIndex = msg[charIndex] - '@';
     
114.     if (alphabetIndex < 0) alphabetIndex=0;
     
115.    
     
116.     //-- Draw one character of the message --
     
117.     for (int col = 0; col < 6; col++)
     
118.     {
     
119.       for (int row = 0; row < 8; row++)
     
120.       {
     
121.         bool isOn = 0;
     
122.         if (col<5) isOn = bitRead( alphabets[alphabetIndex][col], 7-row ) == 1;
     
123.         Plot( numCols-1, row, isOn
     
124.       }
     
125.      
     
126.       //-- The more times you repeat this loop, the slower we would scroll --
     
127.       for (int refreshCount=0; refreshCount < 7; refreshCount++) //change  this value to vary speed
     
128.         RefreshDisplay();
     
129.       //-- Shift the bitmap one column to left --
     
130.       for (int row=0; row<8; row++)
     
131.       {
     
132.         for (int zone=0; zone < numZones; zone++)
     
133.         {
     
134.           bitmap[row][zone] = bitmap[row][zone] >> 1;
     
135.                     // Roll over lowest bit from the next zone as highest bit of this zone.
     
136.           if (zone < maxZoneIndex) bitWrite(bitmap[row][zone], 7,
     
137. bitRead(bitmap[row][zone+1],0));
     
138.         }
     
139.       }
     
140.     }
     
141.   }
     
142. }
     
143. 
     
144. //=== L O O P ===
     
145. void loop() {
     
146.   AlphabetSoup();
     
147. }

复制代码

糯米基

楼主，我对那个32*8的例子很感兴趣，能否给出这个教程的链接，先谢谢了

smching

糯米基 发表于 2013-6-16 08:23
楼主，我对那个32*8的例子很感兴趣，能否给出这个教程的链接，先谢谢了

不是已经有链接了吗。一开始就是了。
没关係，这里再放一次。
http://www.solderlab.de/index.ph ... modular-plasma-wall

smching

糯米基 发表于 2013-6-16 08:23
楼主，我对那个32*8的例子很感兴趣，能否给出这个教程的链接，先谢谢了

除了32*8，在他们的网站里还有一个12*8 RGB矩阵
http://www.solderlab.de/index.php/led-projects/rgb-matrix-12x8
我已经改成8*8，且每粒LED更换成两尺的LED Strip。总共用了64条LED Strip，安置在墙上。