Weihnachten rückt immer näher und bald werden wir anfangen, unsere Häuser zu schmücken. Diese Dekoration ist meist statisch. Zum Beispiel schmücken wir den Baum mit Figuren, Kugeln und Lametta. Was, wenn wir der Dekoration eine besondere Note geben wollen? Wir könnten den Baum mit einer Leinwand schmücken, auf der wir Weihnachtsgrüße und -bilder zeigen.

Als ich darüber nachdachte, kam mir der Gedanke, dass wir es im Stil des Times Square (New York) machen könnten. Es wäre sehr auffällig mit sich bewegenden Begrüßungen und Grafiken. Nun, wir haben die richtigen Komponenten für dieses Projekt, ein WS2812B LED-Panel mit 16x16 LEDs und ATmega-Mikrocontroller. Mit diesen Komponenten, den notwendigen Bibliotheken und ein bisschen Fantasie, werden wir unser kleines Times Square-Display bauen. Wir werden Grußbotschaften in verschiedenen Sprachen zeigen und verschiedene Bilder konfigurieren. Es ist vollständig individualisierbar, so dass Sie Ihre eigenen Bilder einfügen können. Also fangen wir an.

Benötigte Komponenten und Materialien

1	Mega 2560 Board mit ATmega2560 mit USB Kabel alternativ Mikrocontroller Board mit ATmega328P
1	RGB LED Panel WS2812B 16x16 256 LEDs Flexibel Led Matrix IC
1	65Stk. Jumper Wire Kabel Steckbrücken für Breadboard alternativ Jumper Wire Kabel 40 STK. je 20 cm M2M Male to Male
1	Mini Breadboard 400 Pin alternativ Breadboard Kit - 3x Jumper Wire m2m/f2m/f2f + 3er Set MB102 Breadbord alternativ Breadboard Kit - 3 x 65Stk. Jumper Wire Kabel M2M und 3 x Mini Breadboard alternativ MB 102 Breadboard Kit - 830 Breadboard, Netzteil Adapter 3,3V 5V, 65Stk Steckbrücken
1	Holzleim
1	Sperrholzplatten
1	Transparentes Vinyl oder dünnes, weißes Papier

 

Benötigte Software

• Arduino DIE
• led_panel_christmas.ino (ATmega2560)
• led_panel_christmas_ATmega328.ino (ATmega328)
• FastLED.h library (über Bibliotheksverwalter)
• Adafruit_GFX.h library (über Bibliotheksverwalter)
• Adafruit_NeoMatrix.h library (über Bibliotheksverwalter)
• Adafruit_NeoPixel.h library (über Bibliotheksverwalter)

Schaltkreis

Download des Schaltkreises

Der Aufbau besteht aus Materialien, die sich leicht verändern lassen, da es sich um einen Prototypen handelt und wir Änderungen vornehmen müssen, bis die Komponenten eingepasst sind. Mit Materialien wie Balsaholz oder Doppelwellenkarton (wie in diesem Projekt) können wir alles Notwendige verändern, bis wir die endgültigen Abmessungen und das Design mit den genauen Maßen erhalten. Auf diese Weise können wir das Gehäuse anschließend als 3D-Model für einen 3D-Drucker entwerfen.

Die Form kann flach sein, oder gebogen wie in unserem Projekt. Dafür fertigen wir zwei Halbkreise mit einem Radius von 11 cm an. Innerhalb dieser Halbkreise zeichnen wir einen weiteren Halbkreis mit einem Radius von 10,2 cm auf, der konzentrisch zu dem vorhergehenden ist. In den Umkreis dieser neuen Halbkreise ritzen wir eine kleine Rille von 1 mm Tiefe und 16 cm Länge. Dort werden die oberen und unteren Ränder der Leuchtplatte eingeführt. Die Größe des LED-Panels beträgt 16 cm x 16 cm. Wenn wir also 1 mm des Panels in den oberen und unteren Kreisen einführen, haben wir eine Höhe von 15,8 cm. Also müssen wir die oberen und unteren Kreise mit zwei "Säulen" dieser Dimensionen (15,8 cm) vertikal verbinden. Die Breite der Säulen kann 3 cm betragen. Wenn wir das Panel in der Struktur installiert haben, müssen wir nur noch den äußeren Schirm mit einer dünnen Folie aus lichtdurchlässigem Kunststoff (oder einem Material mit ähnlichen Eigenschaften) versehen. Ich habe ein Blatt weißes Papier benutzt, um die Tests zu machen. Schon haben wir unser leuchtendes Panel fertig.

Achten Sie auf die LED-Nummer 0. Sie muss sich am unteren Rand auf der rechten Seite befinden.

Der elektronische Aufbau ist sehr einfach, da wir nur den Mikrocontroller, ein paar Kabel und das LED-Panel benötigen. Wie die Programmierung des Atmega328p aussieht, zeige ich spätr. Ich empfehle den Mega, da die verwendeten Bilder viel Platz wegnehmen und wir eventuell an die Speichergrenze stoßen. Die Datenleitung des LED-Panels wird mit dem Mikrocontroller verbunden. Was die Stromversorgung betrifft, so würde laut Datenblatt bei allen LEDs in weißer Farbe und 100 % Helligkeit jede LED 0,3 W verbrauchen, was multipliziert mit den 256 LEDs einen Gesamtverbrauch von 76,8 W ergeben würde. Bei einer Versorgungsspannung von 5 Vdc würde der benötigte Strom 15,36 A betragen. Die gute Nachricht ist, dass wir keine 100%ige Helligkeit programmiert haben, nicht alle LEDs sind gleichzeitig an und nicht alle sind weiß, also brauchen wir eine etwas geringere Stromversorgung. Ein 2 A oder 3 A Handy-Ladegerät wäre ausreichend. Ich habe ein Labornetzteil verwendet.

Beschreibung des Programmablaufs und des Sketches

Wir zeigen Weihnachtsgrüße in verschiedenen Sprachen, die von der rechts nach links durchs Bild scrollen. Zwischen den Grüßen zeigen wir Weihnachtsbilder.

Wir müssen für die Darstellung von Bildern zunächst Matrizen mit den Identifizierungsnummern jeder LED definieren. Dann wird eine Methode definiert, die so viele Bedingungen enthält, wie wir Matrizen für dieses Bild definieren. Diese Bedingungen gehen die Nummern der LEDs in den Matrizen durch, um jede LED mit der entsprechenden Farbe zu konfigurieren und sie dann alle mit der konfigurierten Farbe leuchten zu lassen. Ein sehr einfaches Beispiel ist die Socke. Sie hat nur zwei Farben Rot und Weiß. Für die weißen LEDs definieren wir die Matrix heel[] und als Elemente davon die Identifizierungsnummer jeder LED, die in weiß aufleuchten wird. Ähnlich für die roten LEDs erstellen wir die Matrix sock_body[].

int heel[] {
    44, 45, 49, 50, 51, 52, 67, 68, 69, 76,
    77, 78, 81, 82, 83, 90, 91, 92, 93, 98,
    99, 100, 108, 109, 110, 113, 114, 115, 124, 125,
    140, 141, 142, 145, 146, 147, 172, 173, 174, 177,
    178, 179, 180, 204, 205
};

int sock_body[] {
    70, 71, 72, 73, 74, 75 , 84, 85, 86, 87,
    88, 89, 101, 102, 103, 104, 105, 106, 107, 116,
    117, 118, 119, 120, 121, 122, 123, 130, 131, 132,
    133, 134, 135, 136, 137, 138, 139, 148, 149, 150,
    151, 152, 153, 154, 155, 156, 157, 162, 163, 164,
    165, 166, 167, 168, 169, 170, 171, 185, 186, 187,
    188, 189, 194, 195, 196, 197, 198, 217, 218, 219,
    220, 229, 228
};

void sock_red_show() {
    FastLED.clear();
    //Heel
    for (int i = 0; i < 45; i++){      
        leds[heel[i]] = CRGB::White;
    }

    //Sock body red
    for (int i = 0; i < 73; i++){      
        leds[sock_body[i]] = CRGB::Red;
    }  
    FastLED.show();
}

Dann definieren wir die Methode sock_red_show(), die als erstes alle LEDs des Panels ausschaltet und dann die erste Bedingung ausführt, um die 45 Elemente (LEDs) der heel[]-Matrix in weißer Farbe zu konfigurieren. Sobald das letzte Element konfiguriert ist, beginnt die Ausführung der zweiten Bedingung sock_body[], die die 73 Elemente (LEDs) in roter Farbe konfiguriert. Wenn sie mit dem letzten Element fertig ist, führt sie FastLED.show() aus. Damit werden alle zuvor konfigurierten LEDs mit ihren entsprechenden Farben gleichzeitig zum Leuchten gebracht.

Zu Beginn des Sketches werden wie immer die Bibliotheken eingebunden, die für die Verwendung der Module benötigt werden. In diesem Fall sind es vier Bibliotheken. Die FastLED.h-Bibliothek ist notwendig für die optimale Steuerung des Chipsatzes jeder LED und für die Verwaltung der Daten und der Konfiguration. Die folgenden drei Bibliotheken werden benötigt, um Text anzeigen zu können. Die Bibliothek Adafruit_GFX.h wird benötigt, um primitive Grafiken wie Linien, Kreise usw. darzustellen. Da unser LED-Panel ein Raster aus LEDs ist, binden wir auch die Bibliothek Adafruit_NeoMatrix.h ein. Die letzte Bibliothek ist Adafruit_NeoPixel.h, die zur Steuerung der drei internen LEDs jeder RGB-LED benötigt wird.

#include "FastLED.h"
#include <Adafruit_GFX.h>
#include <Adafruit_NeoMatrix.h>
#include <Adafruit_NeoPixel.h>

HINWEIS: Um Adafruit_NeoMatrix.h verwenden zu können, müssen die Bibliotheken Adafruit_GFX.h und Adafruit_NeoPixel.h installiert sein.

Als Nächstes erstellen wir eine erste Konstante mit der Anzahl der LEDs (256) unseres Panels. Eine zweite, um den Port (9) des Mikrocontrollers anzugeben, an den wir die Datenleitung des Panels anschließen.

#define NUM_LEDS 256
#define PIN 9

Anschließend implementieren wir ein Objekt mit dem Namen matrix aus der Adafruit_NeoMatrix.h Bibliothek, um Text auf dem LED-Panel darstellen zu können. Die Argumente oder Parameter, die wir angeben müssen, sind:

- Anzahl der LEDs in der Breite und Höhe der Tafel (16 LEDs in der Breite und 16 LEDs in der Höhe), sowie den PIN des Mikrocontrollers, an den wir die Datenleitung des Panels angeschlossen haben (9)

- Position der LED Nummer 0 auf dem Panel (die Anzahl der LEDs ist 256, aber die Nummerierung beginnt bei 0 und endet mit der Zahl 255); in unserem Panel befindet sich die LED 0 unten rechts auf dem Panel

- Anordnung der LEDs in der Matrix und Fortschreiten der Nummerierung, die LEDs sind spaltenweise angeordnet, d.h. wenn sich die LED Nummer 0 in der rechten unteren Ecke befindet, ist die LED Nummer 1 die oberste; wenn sie die LED Nummer 15 (erste Spalte und letzte LED) erreicht, ist die nächste LED (Nummer 16) diejenige, die sich links von ihr befindet, d.h. sie würde sich wie eine Zick-Zack-Schlange fortbewegen

- Das Layout und die Verdrahtung der drei internen LEDs; das interne Layout ist grün, rot und blau LED (NEO_GRB)

- Der letzte Parameter ist die Arbeitsfrequenz (800 KHz)

Adafruit_NeoMatrix matrix = Adafruit_NeoMatrix(16, 16, PIN,
                NEO_MATRIX_BOTTOM + NEO_MATRIX_RIGHT +
                NEO_MATRIX_COLUMNS + NEO_MATRIX_ZIGZAG,
                NEO_GRB + NEO_KHZ800);

Dann erstellen wir die Variable x, die zunächst die Anzahl der LEDs speichert, die das Panel in der Breite hat. Dieser Wert wird mit der Anweisung matrix.width() zurückgegeben. Diese Daten wurden zuvor bei der Erstellung des matrix-Objekts angegeben. Wir werden diese Variable in einer if-Anweisung verwenden, um die Anzahl der Spalten zu zählen, die wir nach links verschieben müssen, um eine Nachricht auf dem Panel darzustellen. Diese Bedingung befindet sich innerhalb einer do-while-Schleife. Die Methode zur Darstellung des Textes sehen wir später.

int x = matrix.width();

Wir erzeugen einige Matrizen, die einzelne Bildelemente eines Bildes darstellen. Die Nummern sind die entsprechenden LEDs, über die wir mit einer for-Schleife iterieren.

int body[] = {
    66,67,68,90,91,92,93,94,96,97,                      
    98,99,100,101,102,105,106,117,118,119,
    121,125,126,127,128,129,130,136,138,137,
    139,148,150,151,153,154,155,156,157,158,
    159,160,161,162,163,164,165,166,168,170,
    171,180,183,185,187,188,189,191,192,193,
    194,196,197,198,218,219,220,221,222
};

int scarf[] = { 
    57,58,69,70,88,89,103,104,120,122,
    123,124,131,132,133,134,135,152,167,184
};

int nose[] = {
    169,182,201
};

int hat[] = { 
    81,82,84,85,107,109,110,111,112,113,
    115,116,140,142,143,144,145,147,149,172,
    174,175,179,181,186,190,195,204
};

int lac[] = { 
    108,114,141,146,173
};

Um die Bilder auf dem Panel anzuzeigen, definieren wir ein Array des Datenstrukturtyps CRGB aus der FastLED-Bibliothek. Es enthält die Nummern jeder LED auf dem Panel (von Nummer 0 bis 255). Wir werden diese Nummern in einem Array von Nummern übergeben (was wir oben erklärt haben). Wir werden sie verwenden, um die LEDs mit einer bestimmten Farbe zu konfigurieren. Dies wird in der Methode zur Anzeige eines Bildes näher erläutert.

CRGB leds[NUM_LEDS];

Die Darstellung von Bildern und Texten funktioniert getrennt und unabhängig voneinander. Bilder werden mit der FastLED.h-Bibliothek dargestellt. Für den Rolltext nutzen wir die Adafruit-Bibliotheken. Wir benötigen also zwei unabhängige Objekte für die Darstellung auf einem LED-Panel.

Sobald wir den Bibliothekseinbindungsblock, die Objektimplementierung und die Variablendeklarationen abgeschlossen haben, werden wir die setup()-Methode entwickeln. Das erste, das wir in dieser Methode sehen können, ist eine Pause von 2 Sekunden. Das machen wir, damit beim ersten Einschalten oder zurücksetzen des Mikrocontrollers die Spannung stabilisiert werden kann.

delay(2000);

Als Nächstes programmieren wir die Parameter unseres LED-Panels für die Anzeige der Bilder mit der ersten Zeile FastLED.addLeds. Wir müssen den Treiberchip (WS2812B) der LEDs angeben, den Port des Mikrocontrollers und die Anordnung der drei internen RGB-LEDs. Als Parameter übergeben wir dafür den Namen der CRGB-Datenstrukturmatrix, die wir zur Konfiguration der LEDs verwenden und die Anzahl der im Panel enthaltenen LEDs. In der zweiten Zeile stellen wir die Helligkeit der LEDs ein und in der dritten Zeile schalten wir alle LEDs des Panels aus.

FastLED.addLeds<WS2812B, PIN, GRB>(leds, NUM_LEDS); 
FastLED.setBrightness(5);
FastLED.clear();

Nun konfigurieren wir die Parameter für die Anzeige des Textes. Wir initialisieren mit matrix.begin()  das Panel. Der Text beginnt seine Anzeige auf der rechten Seite des Panels und wird auf der linken Seite ausgeblendet. Mit der Anweisung matrix.setTextWrap(false) verhindern wir, dass der Text, der auf der linken Seite verschwindet, auf der rechten Seite wieder erscheint. Wir stellen die Helligkeit der LEDs mit einem Wert von 7 ein. Die anfängliche Farbe des Textes wird mit der Anweisung matrix.setTextColor(matrix.Color(Red, Green, Blue)) auf blau gesetzt, da sowohl die rote, als auch die grüne LED mit einem Wert von 0 vollständig ausgeschaltet sind. Die blaue LED wird mit einem Wert von 254 eingeschaltet ist.

matrix.begin();
matrix.setTextWrap(false);
matrix.setBrightness(7);
matrix.setTextColor(matrix.Color(0, 0, 254));

Wir haben nun die Parameter für die Anzeige von Text und Bildern vollständig konfiguriert und müssen nur noch die loop()-Methode implementieren, um unser Times Square-Schild zum Leben zu erwecken. In der Methode loop() rufen wir nur Methoden auf, um die Nachrichten in verschiedenen Sprachen und Bilder darzustellen. Die Pause von drei Sekunden ist die Zeit, die jedes Bild auf dem Bildschirm angezeigt wird. Insgesamt gibt es acht Aufrufe, um 8 Texte darzustellen und weitere 8 Aufrufe, um 8 Bilder darzustellen. Da die jeweiligen Methoden zur Darstellung des Textes, bzw. der Bilder ähnlich sind und sich nur der Text und die LEDs, die zur Darstellung der verschiedenen Bilder farbig leuchten müssen, unterscheiden, werde ich eine Methode der Textdarstellung und eine der Bilddarstellung erläutern.

Die ersten beiden Methodenaufrufe innerhalb der Methode loop() sind:

show_message_az();
snowman_show();
delay(3000);

In der Methode show_message_az() wird eine do-while-Schleife ausgeführt. Wenn wir uns erinnern, wurde die Variable x anfänglich mit der Anzahl der LEDs initialisiert, die das Panel breit ist, d.h. 16. Diese Schleife wird ausgeführt, bis die while-Bedingung den x-Wert von -109 erreicht (es sind negative Zahlen).

void show_message_az() {
  do {
    …
    …
    …
  } while (x > -110);
}

Innerhalb der Schleife werden alle LEDs des Panels mit der Anweisung matrix.fillScreen(0) ausgeschaltet. Mit der zweiten Anweisung matrix.setTextColor(matrix.Color(254, 0, 0)) setzen wir die Textfarbe auf Rot, mit matrix.setCursor(x, 5) setzen wir den Cursor in Spalte 16 (d.h. die erste Spalte wird um 16 Positionen nach links verschoben) und Zeile 5. Dann geben wir den Text mit matrix.print(F(" From AZ-Delivery ")) auf dem Panel aus. Mit der if-Anweisung bewegen wir den Text. matrix.show() lässt die entsprechenden LEDs dieser Position leuchten. Mit delay(35) warten wir 35 ms. Die Schleife wird erneut von Anfang an ausgeführt wird, solange der Wert von x größer als -110 ist. Zusammenfassend kann man sagen, dass man die Farbe des Textes konfiguriert, die Spalten verschiebt und die entsprechenden LEDs für die Visualisierung jedes Teils der Buchstaben des Textes einschaltet und mit einer Verzögerung von 35 Millisekunden das Gefühl der Bewegung des Textes vermittelt.

matrix.fillScreen(0);
matrix.setTextColor(matrix.Color(254, 0, 0));
matrix.setCursor(x, 5);
matrix.print(F(" From AZ-Delivery "));
     
if(--x < -110) {
  x = matrix.width();
}
    
matrix.show();
delay(35);

Jetzt folgt die Methode snowman_show(), womit wir das Bild eines Schneemanns ausgeben. Das erste, was wir in dieser Methode sehen, ist die Anweisung FastLED.clear(), die alle LEDs auf dem Panel ausschaltet. Mit den folgenden for-Schleifen werden die jeweiligen LEDs der einzelnen Bildelemente mit den dazugehörigen Farbwerten versehen. Mit der letzten Anweisung FastLED.show() wird auf dem LED-Panel das entsprechende Bild ausgegeben.

void snowman_show() {
    FastLED.clear();

    //body
    for (int i = 0; i < 69; i++){
        leds[body[i]] = CRGB::White;
    }

    //scarf
    for (int i = 0; i < 20; i++){
        leds[scarf[i]] = CRGB::Red;
    }

    //nose
    for (int i = 0; i < 3; i++){ 
        leds[nose[i]] = CRGB::Orange;
    }

    //lac
    for (int i = 0; i < 5; i++){
        leds[lac[i]] = CRGB::Blue;
    }

    //hat
    for (int i = 0; i < 28; i++){
        leds[hat[i]] = CRGB::Green;
    }
            
    FastLED.show();
}

 

Sketch als Download led_panel_christmas.ino

Die anderen Methoden für die Darstellung von Texten und Bildern sind genauso aufgebaut. Probieren Sie doch einmal eigene Bildkreationen oder Texte aus, oder kreieren Ihr eigenes Gehäuse.

Verwendung des ATmega328 Mikrocontrollers

Um den Sketch auf dem ATmega328-Mikrocontroller auszuführen, müssen wir einige Änderungen am ursprünglichen Sketch vornehmen. Die LEDs werden mit der FastLED.h-Bibliothek in Arrays konfiguriert, was viel Speicherplatz benötigt und daher auf dem kleineren ATmega328 nicht korrekt ausgeführt wird.

Download des Schaltplans

Die Programmierung für die Visualisierung der Texte ist die gleiche, aber für die Grafiken werden wir die Adafruit_NeoPixel.h-Bibliothek verwenden. So werden wir Matrizen vermeiden. Die LEDs werden mit der gewählten Farbe in der loop()-Methode konfiguriert. Zu diesem Zweck wird zunächst die Bibliothek eingebunden.

#include <Adafruit_NeoPixel.h>

Wir implementieren dann das Bildobjekt dieser Bibliothek mit der Anzahl der LEDs auf dem Panel, dem Verbindungspin zum Mikrocontroller, dem Layout und der Verdrahtung der drei internen LEDs und der Arbeitsfrequenz (800 KHz).

Adafruit_NeoPixel picture(NUM_LEDS, PIN, NEO_GRB + NEO_KHZ800);

Wir definieren die Farben, die wir in unserem Objekt verwenden werden:

uint32_t p_red = picture.Color(150,0,0);
uint32_t p_green = picture.Color(0,150,0);
uint32_t p_blue = picture.Color(0,0,150);
uint32_t p_yellow = picture.Color(150,150,0);
uint32_t p_purple = picture.Color(150,0,150);
uint32_t p_light_blue = picture.Color(0,150,150);
uint32_t p_white = picture.Color(150,150,150);
uint32_t p_maroon = picture.Color(150,51,0);
uint32_t p_black = picture.Color(0,0,0);

In der Methode setup() initialisieren wir unser Panel-Objekt:

picture.begin();

Nach der Anzeige der Textnachricht in jeder Sprache wird die Prozedur für die Anzeige der Grafik ausgeführt. Zuerst schalten wir alle LEDs mit der Anweisung picture.clear() aus, wir konfigurieren die Helligkeit mit picture.setBrightness(7), dann konfigurieren wir jede LED, die auf dem Panel für die Grafik verwendet wird mit der gewählten Farbe mit picture.setPixelColor(LED-NR,FARBE). Nach der letzten LED-Konfiguration verwenden wir die Anweisung picture.show(), um die zuvor konfigurierten LEDs zum Leuchten zu bringen, gefolgt von einem delay() für die Anzeigezeit der Grafik. Für die Anzeige der übrigen Bilder ist die Vorgehensweise die gleiche.

picture.clear();
picture.setBrightness(7); 

// Body
picture.setPixelColor(66,p_white);
..
..

// Lac
picture.setPixelColor(108,p_blue);
picture.setPixelColor(114,p_blue);
picture.setPixelColor(141,p_blue);
picture.setPixelColor(146,p_blue);
picture.setPixelColor(173,p_blue);
    
picture.show();
/*--- End Snowman picture show ---*/
delay(3000);  

Sketch Download

Ich hoffe Sie damit für eine etwas andere Weihnachtsdekoration inspiriert zu haben und wünsche ein schönes Weihnachtsfest.