Mit der folgenden Schaltung führen wir einen einfachen Test der P3-64x64 Matrix durch. Die Schaltung ist nicht kompliziert, jedoch nicht
jeder Mikrocontroller kann hier eingesetzt werden. Neben der Spannungsversorgung, die separat ausgeführt wird, benötigt die Matrix 14
Steueranschlüsse.
Die P3-64x64 Matrix von Coolwell stellt uns 4096 RGB-LEDs zur Verfügung. Mit einer so hohen Anzahl an Pixel kann man sowohl durchaus
interessante Effekte, umfangreiche Texte als auch Bilder darstellen.
Rückseite
Das Matrix-Panel kann bei Bedarf zu einem größeren Panel-Verbund verkettet werden. Es ist dabei zu beachten, dass jedes Panel separat mit
Strom versorgt werden muss. Die benötigte Spannung beträgt 5V, die Stromversorgung soll in der Lage sein, ca. 4A zu
liefern.
Pinbelegung
Die Steueranschlüsse:
GND: Masse
R1, R2, G1, G2, B1, B2 – Bitdaten
A, B, C, D, E - Linien und Zeilenauswahl
CLK – Takt
LAT – Verriegelung
OE - Aktivierung
Anschlüsse
Technische Daten:
Abmessungen: 192 mm × 192 mm
Pixel: 64 × 64 = 4096 RGB-LEDs
Abstand: 3 mm
Stromversorgung: 5V / 4A
Leistung: 20 W
Arduino Mega
Die Ansteuerung der Matrix übernimmt Arduino Mega. Der Mikrocontroller verfügt über ausreichende Anzahl von Anschlusspins, um diese Aufgabe zu
bewältigen. Um die Schaltung nicht unnötig zu komplizieren, wird Arduino mit Strom einfach über den USB-Anschluss
versorgt.
Die Stromaufnahme der Matrix wird mit ca. 4A angegeben. In unserem Test stellte sich heraus, dass die maximale Stromaufnahme 1,8 A nicht
überstiegen hat. Trotzdem für die Versorgung der Matrix soll ein leistungsfähiges Netzteil vorgesehen werden. Für die Spannungsversorgung der Matrix ist auf der
Rückseite ein separater Anschluss vorhanden.
Testschaltung
Das Programm
Das Programm besteht aus einer Reihe einfacher Unterprogramme, die jeweils simple Effekte auf dem „Bildschirm“ kreieren. In der Hauptschlaufe
„Loop“ werden diese Unterprogramme, Demo_1 bis Demo_9 nacheinander aufgerufen und abgearbeitet. Manche von Ihnen, um Tipparbeit zu sparen, rufen weitere
Hilfsprogramme auf.
Damit man nicht alles selbst machen muss, kommt in dem Programm die Bibliothek „RGBmatrixPanel.h“ zum Einsatz. Sie stellt eine Schnittstelle zwischen
unserem Programm und der Elektronik des Matrix-Panels dar. Mit den Anweisungen, die die Bibliothek mit sich bringt, ist es sehr einfach, die Matrix anzusteuern
und einfache Bilder und Texte zu erstellen.
Die Bibliothek (von Adafruit) ist unter „https://github.com/“ zu finden.
// *****************************************************************************************
// Farben und Formen mit RGB 64x64 Matrix
// Eine Schaltung mit Arduino Mega
// Arduino IDE 2.0.4
// *****************************************************************************************
#include "RGBmatrixPanel.h"
#define CLK 11
#define OE 9
#define LAT 10
#define A A0
#define B A1
#define C A2
#define D A3
#define E A4
RGBmatrixPanel matrix(A, B, C, D, E, CLK, LAT, OE, false, 64);
int r, g, b;
// *****************************************************************************************
void setup()
{
matrix.begin();
delay(500);
}
// *****************************************************************************************
void loop() {
Demo_1 (); // Matrix einfarbig
Demo_2 (); // Einzelne Pixel via Zufall
Demo_3 (); // Blaue Rechtecke
Demo_4 (); // Rote Rechtecke
Demo_5 (); // Magenta Rechtecke
Demo_6 (); // Buntes Schachbrett
Demo_7 (); // Linien und Kreise
Demo_8 (); // Text
Demo_9 (); // Blume
}
// Matrix komplett einfarbig füllen -------------------------------------------------------
void Demo_1 () {
screen_clear(); // Matrix löschen
matrix.fillRect(0, 0, matrix.width(), matrix.height(), matrix.Color333(0, 7, 0));
delay(1000);
matrix.fillRect(0, 0, matrix.width(), matrix.height(), matrix.Color333(0, 0, 7));
delay(1000);
matrix.fillRect(0, 0, matrix.width(), matrix.height(), matrix.Color333(7, 0, 0));
delay(1000);
matrix.fillRect(0, 0, matrix.width(), matrix.height(), matrix.Color333(7, 7, 0));
delay(2000);
}
// Matrix via Zufall mit einzelnen Pixel füllen -------------------------------------------
void Demo_2 () {
screen_clear(); // Matrix löschen
for (int i = 0; i < 15000; i++) {
int X = random (64); // X - Koordinate
int Y = random (64); // Y - Koordinate
int F = random (8); // Farbe
Farbe_aktuell (F);
matrix.drawPixel(X, Y, matrix.Color333(r, g, b));
}
delay(2000);
}
// Blaue Rechtecke ------------------------------------------------------------------------
void Demo_3 () {
screen_clear(); // Matrix löschen
for (int i = 20; i > -1; i--) {
int X = i; // X - Koordinate
int Y = i; // Y - Koordinate
int W = i * 2; // Breite
int H = i * 2; // Höhe
matrix.drawRect(X, Y, W, H, matrix.Color333(0, 0, 7));
delay(500);
}
delay(2000);
}
// Rote Rechtecke -------------------------------------------------------------------------
void Demo_4 () {
screen_clear(); // Matrix löschen
for (int i = 5; i < 55; i++) {
int X = i; // X - Koordinate
int Y = i; // Y - Koordinate
int W = 20 - i; // Breite
int H = 20 - i; // Höhe
matrix.drawRect(X, Y, W, H, matrix.Color333(7, 0, 0));
delay(200);
}
delay(2000);
}
// Magenta Rechtecke ----------------------------------------------------------------------
void Demo_5 () {
screen_clear(); // Matrix löschen
for (int i = 4; i < 20; i=i+2) {
int X = i + 4; // X - Koordinate
int Y = i + 4; // Y - Koordinate
int W = 55 - (i * 2); // Breite
int H = 55 - (i * 2); // Höhe
matrix.drawRect(X, Y, W, H, matrix.Color333(7, 0, 7));
delay(500);
}
delay(2000);
}
// Buntes Schachbrett ---------------------------------------------------------------------
void Demo_6 () {
screen_clear(); // Matrix löschen
for (int i = 1; i < 5; i++) {
for (int X = 5; X < 50; X = X + 11) { // X - Koordinate
for (int Y = 5; Y < 50; Y = Y + 11) { // Y - Koordinate
int F = random (1, 8); // Farbe
Farbe_aktuell (F);
matrix.fillRect(X, Y, 10, 10, matrix.Color333(r, g, b));
}
}
delay(2000);
}
}
// Linien und Kreise ----------------------------------------------------------------------
void Demo_7 () {
for (int i = 1; i < 10; i++) {
screen_clear(); // Matrix löschen
int X = random (15, 50); // X - Koordinate
matrix.drawLine(X, 0, X, 63, matrix.Color333(0, 0, 7)); // Linie senkrecht
int Y = random (10, 55); // Y - Koordinate
matrix.drawLine(0, Y, 63, Y, matrix.Color333(0, 0, 7)); // Linie waagenrecht
int F = random (1, 8); // Farbe
Farbe_aktuell (F);
int ab = random (0,4); // Kreis-Koordinaten
switch (ab) { // X,Y vom Kreis
case 0: { X = X - 7; Y = Y - 7;
break; }
case 1: { X = X + 7; Y = Y - 7;
break; }
case 2: { X = X - 7; Y = Y + 7;
break; }
case 3: { X = X + 7; Y = Y + 7;
break; }
}
matrix.fillCircle(X, Y, 5, matrix.Color333(r, g, b)); // gefüllter Kreis
delay(1000);
}
}
// Text ausgeben --------------------------------------------------------------------------
void Demo_8 () {
screen_clear(); // Matrix löschen
matrix.setTextSize(1); // Textgröße
matrix.setCursor(5, 5); // Cursor Position
matrix.setTextColor(matrix.Color333(7,7,0)); // Textfarbe
matrix.println("Spass"); // Textausgabe
delay(1000);
matrix.setCursor(20, 15);
matrix.setTextColor(matrix.Color333(0,7,7));
matrix.println("mit");
delay(1000);
matrix.setCursor(2, 25);
matrix.setTextColor(matrix.Color333(7,0,0));
matrix.println("RGB Matrix");
delay(1000);
matrix.setTextSize(2);
matrix.setCursor(3, 40);
matrix.setTextColor(matrix.Color333(0,7,0));
matrix.println("64x64");
delay(2000);
}
// Linien und Kreise (Blume) --------------------------------------------------------------
void Demo_9 () {
int XY [8][2] = {{ 12, 32 }, { 9, 21 },
{ 20, 20 }, { 23, 12 },
{ 32, 15 }, { 40, 12 },
{ 47, 17 }, { 52, 22 } };
screen_clear(); // Matrix löschen
for (int i=1; i < 15; i++ ) {
Bild (XY[0][0], XY[0][1]);
Bild (XY[1][0], XY[1][1]);
Bild (XY[2][0], XY[2][1]);
Bild (XY[3][0], XY[3][1]);
Bild (XY[4][0], XY[4][1]);
Bild (XY[5][0], XY[5][1]);
Bild (XY[6][0], XY[6][1]);
Bild (XY[7][0], XY[7][1]);
}
delay(2000);
}
// Matrix Löschen -------------------------------------------------------------------------
void screen_clear() {
matrix.fillRect(0, 0, matrix.width(), matrix.height(), matrix.Color333(0, 0, 0));
}
// Farbe setzen ---------------------------------------------------------------------------
void Farbe_aktuell (int F) {
switch (F) {
case 0: { r = 0; g = 0; b = 0; // Schwarz
break; }
case 1: { r = 0; g = 0; b = 7; // Blau
break; }
case 2: { r = 0; g = 7; b = 0; // Grün
break; }
case 3: { r = 0; g = 7; b = 7; // Cyan
break; }
case 4: { r = 7; g = 0; b = 0; // Rot
break; }
case 5: { r = 7; g = 0; b = 7; // Magenta
break; }
case 6: { r = 7; g = 7; b = 0; // Gelb
break; }
case 7: { r = 7; g = 7; b = 7; // Weiss
break; }
}
}
// Bild -----------------------------------------------------------------------------------
void Bild (int X, int Y) {
matrix.drawLine(X, Y, 63-X, 63-Y, matrix.Color333(0, 7, 0)); // Linie
int F = random (1, 8);
Farbe_aktuell (F);
matrix.fillCircle(X, Y, 3, matrix.Color333(r, g, b)); // Kreis
matrix.fillCircle(63-X, 63-Y, 3, matrix.Color333(r, g, b));
delay(200);
}
// *****************************************************************************************
