#16x16LEDMatrix

[draegerit]

Bewegungen mit 16x16 LED Matrix am Arduino UNO

In diesem Beitrag möchte ich dir zeigen, wie du einfache Bewegungen auf einer 16x16 LED Matrix mit dem Arduino UNO programmierst.

Bewegungen mit 16x16 LED Matrix am Arduino UNO Im letzten Beitrag zur hier verwendeten LED Matrix habe ich dir bereits gezeigt, wie diese an den Arduino UNO angeschlossen und programmiert wird. Hier soll es nun darum gehen, wie du einfache Bewegungen auf der Matrix anzeigst. Vorweg, richtige Videos werden sich auf der Matrix nicht anzeigen lassen. Aber man kann mit meinem Generator kleine "Daumenkino" Bilder erzeugen, welche mit dem richtigen Intervall in Bewegung umgesetzt werden können.

Benötigte Ressourcen für den Aufbau

Um die nachfolgenden Beispiele nachzubauen, benötigst du: - einen Mikrocontroller Bsp Arduino UNO, - ein passendes USB-Datenkabel, - eine 16x16 LED Matrix, - fünf Breadboardkabel, männlich - weiblich, 20 cm

Anschluss der 16x16 LED Matrix an den Arduino UNO

Hier die Grafik, wie du die LED Matrix an den Arduino anschließen kannst.

16x16 LED Matrix Generator

Der kleine Generator ist sehr einfach gehalten, du hast die vier LED Matrix Module mit den entsprechenden LEDs, welche du mit der Maus anklicken kannst, die Farbe ändert sich dann von Rot auf Grau. Du kannst einstellen, ob du nur die Arrays erzeugen lassen möchtest, oder das komplette Programm.

Mit der Schaltfläche "CODE GENERIEREN" wird, wie es sich erahnen lässt, der Code erzeugt, die Schaltfläche "LÖSCHEN" setzt alle LEDs auf den default / deaktiviert.

Programm für ein Daumenkino

Da nicht jede kleine Animation gleich viel Bilder hat, habe ich das Programm sehr dynamisch aufgebaut. #include const int DIN = 11; const int CS = 7; const int CLK = 13; const int NUM_MATRIX_MODULE = 4; LedControl matrix = LedControl(DIN, CLK, CS, NUM_MATRIX_MODULE); const int BRIGHTNESS = 6; const int NUM_IMAGES = 3; const int MAX_ROWS = 8; byte data = { { //Arrays mit den Bildern }; void setupMatrixModul(int modulIndex) { matrix.shutdown(modulIndex, false); matrix.setIntensity(modulIndex, BRIGHTNESS); matrix.clearDisplay(modulIndex); } void setup() { for (int i = 0; i < NUM_MATRIX_MODULE; i++) { matrix.shutdown(i, false); matrix.setIntensity(i, BRIGHTNESS); matrix.clearDisplay(i); } } void drawMatrix(int modul, byte data) { for (int row = 0; row < MAX_ROWS; row++) { matrix.setRow(modul, row, data); } } void loop() { for (int image = 0; image < NUM_IMAGES; image++) { for (int i = 0; i < NUM_MATRIX_MODULE; i++) { drawMatrix(i, data); } delay(250); } for (int image = NUM_IMAGES-1; image >= 0; image--) { for (int i = 0; i < NUM_MATRIX_MODULE; i++) { drawMatrix(i, data); } delay(250); } }

Erzeugen eines pulsierenden Herzens mit dem Generator

Wie erwähnt, kann man mit dem Generator kleine Bilder erzeugen bzw. Arrays für das Programm. Hier meine Lösung zu den Herzen.

Die Arrays für die Bilder sind folgendermaßen: // Bild - 1 byte matrixModul1 = {B11111110,B11111100,B11111000,B11110000,B11100000,B11000000,B10000000,B00000000}; byte matrixModul2 = {B01111111,B00111111,B00011111,B00001111,B00000111,B00000011,B00000001,B00000000}; byte matrixModul3 = {B00111000,B01111100,B11111110,B11111111,B11111111,B11111111,B11111111,B11111111}; byte matrixModul4 = {B00011100,B00111110,B01111111,B11111111,B11111111,B11111111,B11111111,B11111111}; // Bild - 2 byte matrixModul1 = {B11111100,B11111000,B11110000,B11100000,B11000000,B10000000,B00000000,B00000000}; byte matrixModul2 = {B00111111,B00011111,B00001111,B00000111,B00000011,B00000001,B00000000,B00000000}; byte matrixModul3 = {B00000000,B00011100,B00111110,B11111110,B11111110,B11111110,B11111110,B11111110}; byte matrixModul4 = {B00000000,B00111000,B01111100,B01111111,B01111111,B01111111,B01111111,B01111111}; // Bild - 3 byte matrixModul1 = {B11110000,B11100000,B11000000,B10000000,B00000000,B00000000,B00000000,B00000000}; byte matrixModul2 = {B00001111,B00000111,B00000011,B00000001,B00000000,B00000000,B00000000,B00000000}; byte matrixModul3 = {B00000000,B00000000,B00011100,B00111110,B11111110,B11111110,B11111100,B11111000}; byte matrixModul4 = {B00000000,B00000000,B00111000,B01111100,B01111111,B01111111,B00111111,B00011111}; // Bild - 4 byte matrixModul1 = {B11111000,B11110000,B11100000,B11000000,B10000000,B00000000,B00000000,B00000000}; byte matrixModul2 = {B00011111,B00001111,B00000111,B00000011,B00000001,B00000000,B00000000,B00000000}; byte matrixModul3 = {B00000000,B00000000,B00000000,B00000000,B00111000,B01111100,B11111100,B11111100}; byte matrixModul4 = {B00000000,B00000000,B00000000,B00000000,B00011100,B00111110,B00111111,B00111111}; // Bild - 5 byte matrixModul1 = {B11111100,B11111000,B11110000,B11100000,B11000000,B10000000,B00000000,B00000000}; byte matrixModul2 = {B00111111,B00011111,B00001111,B00000111,B00000011,B00000001,B00000000,B00000000}; byte matrixModul3 = {B00000000,B00000000,B00000000,B00000000,B00000000,B00111000,B01111100,B11111100}; byte matrixModul4 = {B00000000,B00000000,B00000000,B00000000,B00000000,B00011100,B00111110,B00111111}; Download Damit du den Code nicht abtippen / kopieren musst, hier der Code zum einfachen Download. 16x16 LED Matrix - pulsierendes HerzHerunterladen

Erzeugen eines Hampelmanns mit dem Generator

Als weitere Animation kann man einen kleinen Hampelmann erzeugen. Hierzu erzeuge ich eine kleine Animation mit 3 Bildern.

Der Code für die Bilder ist wie folgt: byte matrixModul1 = {B11000000,B11000000,B11000000,B11000000,B11000000,B11000000,B11000000,B11100000}; byte matrixModul2 = {B00000011,B00000011,B00000011,B00000011,B00000011,B00000011,B00000011,B00000111}; byte matrixModul3 = {B00000000,B11000000,B11000000,B10000000,B10000000,B10000000,B10000000,B10000000}; byte matrixModul4 = {B00000000,B00000011,B00000011,B00000001,B00000001,B00000001,B00000001,B00000001}; //Bild - 2 byte matrixModul1 = {B10100000,B10010000,B10001000,B10000100,B10000000,B11000000,B01100000,B00110000}; byte matrixModul2 = {B00000101,B00001001,B00010001,B00100001,B00000001,B00000011,B00000110,B00001100}; byte matrixModul3 = {B00000000,B11000000,B11000000,B10000000,B10000000,B10000000,B10000000,B11000000}; byte matrixModul4 = {B00000000,B00000011,B00000011,B00000001,B00000001,B00000001,B00000001,B00000011}; //Bild - 3 byte matrixModul1 = {B10000000,B10000000,B10000000,B10000000,B10000000,B11000000,B00110000,B00011000}; byte matrixModul2 = {B00000001,B00000001,B00000001,B00000001,B00000001,B00000111,B00011000,B00110000}; byte matrixModul3 = {B00000000,B11000000,B11001000,B10001000,B10001000,B10010000,B10100000,B11000000}; byte matrixModul4 = {B00000000,B00000011,B00010011,B00010001,B00010001,B00001001,B00000101,B00000011}; Download Damit du den Code nicht abtippen / kopieren musst, hier der Code zum einfachen Download. 16x16 LED Matrix - HampelmannHerunterladen Read the full article

[draegerit]

16x16 LED Matrix am Arduino UNO

In diesem Beitrag möchte ich dir erläutern, wie du eine 16x16 LED Matrix an den Arduino UNO anschließt und programmierst.

16x16 LED Matrix am Arduino UNO Die LED Matrix mit MAX7219 Treiberchip habe ich dir bereits in einigen Beiträgen vorgestellt, hier soll es nun speziell um die 16x16 Version gehen. - Arduino Projekt: Temperaturanzeige auf einer 8x8 LED Matrix - Arduino Lektion 8: Max7219 8x8 LED Shield Das hier verwende Modul verfügt über 4 Stück von 8x8 LED Matrix Modulen, welche im Quadrat angeordnet sind.

Bezug der 16x16 LED Matrix

Das mir vorliegende Modul habe ich recht günstig über aliexpress.com gekauft, die Lieferzeit war hier wie bei diesem Shop bekannt recht lange. Du bekommst dieses Modul aber auch auf ebay.de. Zu dem Zeitpunkt wo ich den Beitrag schreibe ist dieses Modul leider nicht auf ebay.de erhältlich, daher kann ich dir keinen genauen Preis nennen.

Anschluss des 16x16 LED Matrix Moduls an den Arduino

Bevor ich dieses Modul anschließen konnte, musste ich zunächst eine 5polige Stiftleiste an die Platine löten. Auf der Platine gibt es diverse Stellen, wo man theoretisch diese Stiftleiste anlöten könnte, ABER es gibt für diese nur eine richtige Position. Um diese richtige Position zu bestimmen, müssen wir nur schauen, wo auf der Platine ein Pfeil mit "IN" steht. Problem hierbei, das auf der linken Seite des Moduls zwei Anschlüsse mit "IN" gibt, in meinem Fall habe ich den oberen der beiden verwenden müssen. Die Pins der LED Matrix werden wie nachfolgend aufgeführt mit dem Arduino verbunden: 16x16 LED MatrixArduino UNOVCC5 VGNDGNDDIND11CSD7CLKD13

Anordnung der LED Matrix Module

In der nachfolgenden Grafik habe ich einmal die LED Matrix Module nummeriert. Diese Anordnung benötigen wir für die Programmierung der gesamten Matrix!

Programmieren der 16x16 LED Matrix in der Arduino IDE 2.0

Kommen wir nun dazu, diese LED Matrix in der neuen Arduino IDE 2.0 zu programmieren. Installieren der benötigten Bibliothek Für das Ansteuern der LED Matrix Module benötigen wir eine Bibliothek. Diese können wir recht einfach über den Bibliotheksverwalter der Arduino IDE installieren. Wir müssen lediglich nach "ledControl" suchen und gleich der erste Eintrag "LedControl by Eberhard Fahle" ist die korrekte, welche wir installieren.

Wenn diese Bibliothek installiert wurde, erscheint der kleine Hinweis "INSTALLED" und wir können mit der Programmierung beginnen.

Beispielprogramm

Nachfolgend möchte ich dir ein kleines Beispielprogramm zeigen. Die Arrays mit den Daten kannst du mit meinem 16x16 LED Matrix - Generator recht einfach erstellen und hast somit keine Mühe diese zu erstellen. //Bibliothek zum ansteuern der LED Matrix //mit MAX7219 Treiberchip #include //Anschluss der LED Matrix an den Arduino int DIN = 11; int CS = 7; int CLK = 13; //Initialisieren eines Objektes vom Typ //LedControl mit den Pins und der Anzahl 4 //für die angeschlossenen LED Matrix Module LedControl lc = LedControl(DIN, CLK, CS, 4); //Konstante mit den maximalen Zeilen pro LED Matrix const int MAX_ROWS = 8; //Arrays mit den Daten pro Zeile byte matrixModul1 = { B01000001, B10000001, B00000010, B00000010, B11100100, B00001000, B00110000, B11000000 }; byte matrixModul2 = { B10000010, B10000001, B01000000, B01000000, B00100111, B00010000, B00001100, B00000011 }; byte matrixModul3 = { B11000000, B00110000, B00011000, B00000100, B00110010, B00110010, B00000001, B00000001 }; byte matrixModul4 = { B00000011, B00001100, B00011000, B00100000, B01001100, B01001100, B10000000, B10000000 }; void setup() { lc.shutdown(0, false); lc.shutdown(1, false); lc.shutdown(2, false); lc.shutdown(3, false); //setzen der Lichtintensität der LEDs lc.setIntensity(0, 6); lc.setIntensity(1, 6); lc.setIntensity(2, 6); lc.setIntensity(3, 6); //leeren der LED Matrix Module lc.clearDisplay(0); lc.clearDisplay(1); lc.clearDisplay(2); lc.clearDisplay(3); } //Funktion zum aktivieren der LEDs an //einem LED Matrix Modul void drawLine(int matrix, byte data) { for (int row = 0; row < MAX_ROWS; row++) { lc.setRow(matrix, row, data); } } void loop() { drawLine(0, matrixModul1); drawLine(1, matrixModul2); drawLine(2, matrixModul3); drawLine(3, matrixModul4); delay(5000); lc.clearDisplay(0); lc.clearDisplay(1); lc.clearDisplay(2); lc.clearDisplay(3); } Read the full article