500 LEDs Wand mit ESP32 - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:17

Hallo allerseits! Am Ende dieses Tutorials wissen Sie, wie Sie Ihre eigene LED-Wand erstellen.

Dieses Tutorial basiert auf einem Sommerprogramm, das an der Sacred Heart University angeboten wird.

Spaß haben!

Lieferungen

Unten aufgeführtes Zubehör.

Schritt 1: Zubehör

Beginnen wir damit, alles zu sammeln, was wir brauchen, um unsere Led Wall zu vervollständigen:

(Links wurden am 10.07.2019 erstellt)

Arduino IDE-Software

ESP32-Mikrocontroller

LED-Pixellicht

Energieversorgung

Netzkabel

Abisolierwerkzeug

Steckbrett-Überbrückungskabel

Elektrisches Kabel

Schritt 2: Bestimmen der richtigen Stromversorgung für Ihre LedWall

Es gibt einen einfachen mathematischen Weg, um herauszufinden, welches Netzteil für Sie am besten geeignet ist.

Wir verwenden das Ohmsche Potenzgesetz: P = IxV (Leistung = Intensität x Spannung)

Die Spannung wird von unseren LEDs bestimmt: in diesem Fall 5V.

Die Intensität hängt von der Hardware ab, eine einzelne LED verbraucht 30mA.

Jeder Streifen von 50 LEDs verbraucht daher 50 x 30 mA = 1250 mA = 1,25 A.

Unsere 500-LED-Wand verbraucht daher das 10-fache (10 Streifen): 12,5 A.

Der Stromverbrauch beträgt dann 5 V x 12,5 A = 62,5 W für die LEDs.

Natürlich müssen Sie zusätzlich zu den LEDs das ESP und alle anderen Elemente Ihrer Schaltung berücksichtigen.

Wir haben ein 60A Netzteil, wir haben viel mehr als wir brauchen.

Schritt 3: Das Netzkabel

Unser Netzteil wird mit Kabelanschlüssen geliefert. Wir müssen ein Netzkabel anpassen, um es an einen 110-V-Stecker anzuschließen.

- Schneiden Sie die Buchse vom Netzkabel ab. Wir behalten den männlichen Teil, sonst bekannt als NEMA 5-15P.

- Das Kabel so abisolieren, dass an allen Drähten ca. 3 mm Kupfer sichtbar sind.

Hier ist ein kurzes Video-Tutorial zum Abisolieren von Drähten:

Schritt 4: Verdrahten des Netzteils

Jetzt können wir unsere Stromversorgung verkabeln!

Ziehen Sie immer den Netzstecker, wenn Sie daran arbeiten.

Verdrahtung

• Das schwarze Kabel (Phase) wird mit dem 'L'-Pin des Netzteils verbunden
• Das weiße Kabel (Neutral) wird an den 'N'-Pin des Netzteils angeschlossen
• Das grüne Kabel wird mit dem 'Masse'-Pin des Netzteils verbunden

(Wenn die Innendrähte Ihres Netzkabels nicht die gleichen Farben wie unsere haben, gehen Sie auf Nummer sicher und schlagen Sie die Schaltpläne online nach.)

Testen

Stecken Sie das Netzkabel des Computers in eine beliebige Steckdose. Die grüne LED am Netzteil sollte aufleuchten.

Schritt 5: Stromversorgung des ESP32S

Wenn Sie sich Ihren ESP ansehen, sollten neben jedem Pin Labels stehen. Wenn er nicht beschriftet ist, können Sie die 'Pinbelegung' Ihres individuellen ESP online nachschlagen.

Verbinden Sie mit einem Stecker-zu-Buchse-Steckbrett-Überbrückungskabel oder einem elektrischen Kabel:

• Der '5V' ESP32S-Pin an das '+V' des Netzteils (orange auf dem Foto oben)
• Der 'GND' ESP32S-Pin an den '-V'-Abschnitt des Netzteils (schwarz auf dem Foto oben)

(Bei einigen ESPs ist der '5V'-Pin stattdessen als 'VCC' gekennzeichnet, beide bedeuten dasselbe.)

Bitte beachten Sie, dass Ihr ESP möglicherweise eine andere "Pinbelegung" hat als die, die wir verwenden. Daher können Sie Ihre Kabel an einer anderen Stelle als auf dem Bild oben anschließen. Solange Sie eine Verbindung zu den richtigen Pins (5 V & GND), spielt die physische Position auf der Platine keine Rolle.

TestingStecken Sie Ihr Netzteil erneut ein, und wenn Ihr ESP eine LED-Anzeige hat (die meisten tun), leuchtet diese auf, um anzuzeigen, dass Strom an das ESP gesendet wird. Herzliche Glückwünsche!

Schritt 6: Stromversorgung der LED-Lichtleisten

Verwendung elektrischer Leitungen:

- Verbinden Sie das rote Kabel des LED-Lichtstreifens mit V+ am Netzteil.

- Verbinden Sie das blaue Kabel des LED-Lichtstreifens mit dem V- am Netzteil.

Schritt 7: Anschließen des ESP32 an die LED-Lichtleisten

Unser ESP32 weist dem WS2811-Treiber, der mit jeder LED verbunden ist, die Farbe und Helligkeit an, die sie benötigen. Dazu benötigt unser ESP32 ein "Daten" -Kabel zu den Streifen.

Die Leds-Streifen werden mit einem 3-Draht-Anschluss geliefert:

- Rot: Power- Blau: Neutral- Weiß: Daten

Schließen wir das weiße LED-Streifenkabel an einen digitalen Pin am ESP an. Bitte merken Sie sich die ausgewählte PIN-Nummer, da wir sie später im Code auswählen müssen. Wir haben unsere an Pin 13 angeschlossen.

Schritt 8: Vorbereiten des Computers: C2102 Treiber

Nachdem unsere Hardware nun verkabelt ist, möchten wir unseren ersten Code hochladen, um sie zu testen. Standardmäßig können Windows oder MacOs nicht mit unserem ESP32 kommunizieren. Dazu müssen wir einen "Treiber" für den ESP-USB-Kommunikationschip herunterladen: der C2102.

Dieser Treiber muss heruntergeladen und installiert werden:

- Windows 10: https://www.silabs.com/documents/public/software/C…- Windows 7/8/8.1: https://www.silabs.com/documents/public/software/C…- Mac:

(Links vom 10.07.2019)

Schritt 9: Arduino-Software - Hinzufügen von ESP32-Unterstützung - Schritt 1

Bevor wir unseren ESP32 mit der Arduino-Software verwenden können, müssen wir sicherstellen, dass er erkannt wird. Standardmäßig kann die Arduino-Software keinen Code für unseren ESP32 kompilieren, lassen Sie uns das beheben:

Schritt 1: Boards zum Manager hinzufügen

1 - Klicken Sie im Arduino auf die Option Datei >> Einstellungen

2- Kopieren Sie im Feld "Additional Boards Manager URLs" den folgenden Link:

Schritt 10: Arduino-Software - Hinzufügen von ESP32-Unterstützung - Schritt 2

Jetzt, da die Arduino-Software mehr Boards "kennt", installieren wir unsere ESP32-Unterstützung

Schritt 2: Installieren der ESP32-Unterstützung

1 - Wählen Sie im oberen Menü: Tools >> Board >> Boards Manager

2 - Ein Fenster wird angezeigt. Verwenden Sie das Suchfeld in der oberen rechten Ecke, um "ESP32" zu finden.

3 - Suchen Sie die von espressif erstellte. Es installieren. (Siehe Bild)

Schritt 11: Arduino-Software - Hinzufügen von ESP32-Unterstützung - Schritt 3

Nachdem die Arduino-Software nun mit unserem ESP32 kommunizieren kann, schließen wir sie an den Computer an und überprüfen Sie, ob alles funktioniert.

1 - Stellen wir sicher, dass wir auf der ESP32-Plattform arbeiten:

Klicken Sie auf Tools >> Board >> ESP32 Dev Module

1- Stellen wir sicher, dass die Arduino-Software weiß, wie sie mit unserem ESP kommuniziert:

Klicken Sie auf Tools >> Port und wählen Sie den Port aus, der beim Einstecken dieses Kabels angezeigt wird.

Wichtig:

Wenn Sie Probleme beim Hochladen des Codes auf Ihren ESP haben, überprüfen Sie zuerst diese beiden Menüs. Wenn der Port nicht mit einem Häkchen ausgewählt ist, kommuniziert die Arduino-Software nicht damit.

Schritt 12: Hinzufügen von Bibliotheken zur Arduino-IDE

Jetzt werden wir eine Bibliothek hinzufügen, mit der wir unsere Led Wall testen können!

1- Klicken Sie auf Tools >> Bibliotheken verwalten.

2- Suchen Sie in der oberen rechten Ecke nach NeoPixelBus. Suchen Sie "NeoPixelBus by Makuna", installieren Sie es (siehe Bild)

Potentielle andere interessante Bibliotheken: (Für dieses Tutorial nicht erforderlich)

- NeoMatrix

- FastLed

- Artnet

- GFX

Schritt 13: Erster Code: Strand Test

Unser erster Code ist ein Beispiel aus der Bibliothek.

Sie können entweder den folgenden Code kopieren / einfügen oder auf klicken:

Datei >> Beispiele >> Adafruit NeoPixelBus >> Strandtest

Bitte stellen Sie sicher, dass Sie Ihre LED_PIN in diejenige ändern, mit der Sie Ihre LEDs physisch verbunden haben. Wir haben in diesem Tutorial 13 verwendet.

Achten Sie auch darauf, die Stranggröße mit der Variablen LED_COUNT anzupassen.

// Ein grundlegendes LED-Streifentest-Programm für jeden Tag.

#include#ifdef _AVR_ #include // Erforderlich für 16 MHz Adafruit Trinket #endif // Welcher Pin des Arduino ist mit den NeoPixels verbunden? #define LED_PIN 13 // Wie viele NeoPixel sind am Arduino angeschlossen? #define LED_COUNT 500 // Deklarieren Sie unser NeoPixel-Streifen-Objekt: Adafruit_NeoPixel-Streifen (LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800); // Argument 1 = Anzahl der Pixel im NeoPixel-Streifen // Argument 2 = Arduino-Pinnummer (die meisten sind gültig) // Argument 3 = Pixeltyp-Flags, nach Bedarf addieren: // NEO_KHZ800 800 KHz Bitstream (die meisten NeoPixel-Produkte mit WS2812 LEDs) // NEO_KHZ400 400 KHz (klassisch 'v1' (nicht v2) FLORA Pixel, WS2811 Treiber) // NEO_GRB Pixel sind für GRB Bitstream verdrahtet (die meisten NeoPixel Produkte) // NEO_RGB Pixel sind verdrahtet für RGB Bitstream (v1 FLORA Pixel, nicht v2) // NEO_RGBW Pixel sind für RGBW Bitstream verdrahtet (NeoPixel RGBW Produkte) // setup() Funktion -- läuft einmal beim Start -------------------- ------------ void setup() {// Diese Zeilen sind speziell zur Unterstützung des Adafruit Trinket 5V 16 MHz. // Jedes andere Board, Sie können diesen Teil entfernen (aber es schadet nicht, ihn zu verlassen): #if define(_AVR_ATtiny85_) && (F_CPU == 16000000) clock_prescale_set(clock_div_1); #endif // ENDE des Trinket-spezifischen Codes. strip.begin(); // NeoPixel-Strip-Objekt initialisieren (erforderlich) strip.show(); // Alle Pixel so schnell wie möglich ausschalten strip.setBrightness (50); // Setze BRIGHTNESS auf etwa 1/5 (max = 255) } // loop() Funktion -- läuft wiederholt solange das Board eingeschaltet ist -------------- void loop() { // Fülle entlang der Länge des Streifens in verschiedenen Farben… colorWipe(strip. Color(255, 0, 0), 50); // Rot colorWipe (strip. Color (0, 255, 0), 50); // Grün colorWipe (strip. Color (0, 0, 255), 50); // Blau // Machen Sie einen Theatereffekt in verschiedenen Farben… theaterChase(strip. Color(127, 127, 127), 50); // Weiß, halbe Helligkeit theaterChase (strip. Color (127, 0, 0), 50); // Rot, halbe Helligkeit theaterChase (strip. Color (0, 0, 127), 50); // Blau, Regenbogen mit halber Helligkeit (10); // Fließender Regenbogenzyklus entlang des gesamten StreifentheatersChaseRainbow(50); // Rainbow-erweiterte theaterChase-Variante } // Einige eigene Funktionen zum Erstellen animierter Effekte ----------------- // Streifenpixel nacheinander mit einer Farbe füllen. Streifen wird NICHT // zuerst gelöscht; alles dort wird Pixel für Pixel abgedeckt. Übergeben Sie Farbe // (als einzelnen 'gepackten' 32-Bit-Wert, den Sie durch Aufrufen von // strip. Color(red, green, blue) erhalten, wie in der Funktion loop() oben gezeigt), // und a Verzögerungszeit (in Millisekunden) zwischen Pixeln. void colorWipe(uint32_t color, int wait) { for(int i=0; i strip.setPixelColor(i, color); // Setze die Pixelfarbe (im RAM) strip.show(); // Aktualisiere den Streifen entsprechend der Verzögerung (wait); // Einen Moment pausieren } } // Lichterketten im Theater-Stil. Übergeben Sie eine Farbe (32-Bit-Wert, // a la strip. Color(r, g, b) wie oben erwähnt), und eine Verzögerungszeit (in ms) // zwischen den Frames. void theaterChase(uint32_t color, int wait) { for(int a=0; a<10; a++) { // 10 mal wiederholen… for(int b=0; b<3; b++) { // 'b' zählt von 0 bis 2… strip.clear(); // Setze alle Pixel im RAM auf 0 (aus) // 'c' zählt von 'b' bis zum Ende von Streifen in 3er Schritten… for(int c=b; c strip.setPixelColor(c, color); // Pixel 'c' auf den Wert 'color' setzen } strip.show(); // Streifen mit neuem Inhalt aktualisieren delay (wait); // Pause für einen Moment } } } // Regenbogenzyklus entlang des gesamten Streifens. Verzögerungszeit (in ms) zwischen den Bildern durchlaufen. void rainbow(int wait) { // Der Farbton des ersten Pixels führt 5 vollständige Schleifen durch die Farbrad. // Das Farbrad hat einen Bereich von 65536, aber es ist OK, wenn wir überrollen, also // einfach von 0 bis 5*65536 zählen. Jedes Mal // 256 zu firstPixelHue hinzuzufügen bedeutet, dass 5*65536/256 = 1280 durch diese äußere Schleife geht: for(long firstPixelHue = 0; firstPixelHue < 5*65536; firstPixelHue += 256) { for(int i= 0; I // Pixelfarbton um einen Betrag versetzen, um eine volle Umdrehung des // Farbrads (Bereich 65536) entlang der Länge des Streifens // (strip.numPixels() Schritte): int pixelHue = firstPixelHue + (i * 65536L / strip.numPixels()); // strip. ColorHSV() kann 1 oder 3 Argumente annehmen: einen Farbton (0 bis 65535) oder // optional Sättigung und Wert (Helligkeit) hinzufügen (jeweils 0 bis 255). // Hier verwenden wir nur die Einzelargument-Farbton-Variante. Das Ergebnis // wird durch strip.gamma32() geleitet, um 'wahrere' Farben bereitzustellen // bevor es jedem Pixel zugewiesen wird: strip.setPixelColor(i, strip.gamma32 (strip. ColorHSV(pixelHue))); } strip.show(); // Streifen mit neuem Inhalt aktualisieren delay(wait); // Einen Moment pausieren } } // Regenbogen-verbessertes Theaterzelt. Verzögerungszeit passieren (in ms) zwischen den Frames. void theaterChaseRainbow(int wait) { i nt ersterPixelHue = 0; // Erstes Pixel beginnt bei Rot (Farbton 0) for(int a=0; a<30; a++) { // 30 Mal wiederholen… for(int b=0; b RGB strip.setPixelColor(c, color); / / Pixel 'c' auf den Wert 'color' setzen } strip.show(); // Streifen mit neuem Inhalt aktualisieren delay(wait); // Einen Moment pausieren firstPixelHue += 65536 / 90; // Ein Zyklus des Farbkreises über 90 Bilder } } }

Schritt 14: SHU-Beispielcode

Unser Code schaltet alle LEDs nacheinander ein, um sicherzustellen, dass sie funktionieren:

// Dieses Beispiel wechselt zwischen der Anzeige von 500 Pixeln als Rot

#includeconst uint16_t PixelCount = 500; // dieses Beispiel geht von 4 Pixeln aus, eine Verkleinerung führt zu einem Fehler const uint8_t PixelPin = 13; // Stellen Sie sicher, dass Sie dies auf den richtigen Pin setzen, der für Esp8266 ignoriert wird

#define colorSaturation 128 // drei Elementpixel, in unterschiedlicher Reihenfolge und Geschwindigkeit

NeoPixelBus-Streifen (PixelCount, PixelPin);

// NeoPixelBus-Streifen (PixelCount, PixelPin); RgbColor rot (0, Farbsättigung, 0); RgbColor grün (Farbsättigung, 0, 0); RgbColor blau (0, 0, Farbsättigung); RGBFarbe weiß (Farbsättigung); RGBFarbe schwarz(0); HslColor hslRed(rot); HslColor hslGreen(grün); HslColor hslBlue(blau); HslColor hslWhite(weiß); HslColor hslBlack(schwarz); Void setup () { Serial.begin (115200) while (! Serial); // Warte auf serielles Anhängen Serial.println (); Serial.println("Initialisierung…"); Serial.flush(); // Dies setzt alle Neopixel auf einen Aus-Zustand zurück strip. Begin(); Strip-Show(); Serial.println(); Serial.println("Läuft…"); aufrechtzuerhalten. Void Schleife () { Verzögerung (100); Serial.println("Farben R, G, B, W…"); for(int i = 0; i <=499;i++){ // setze die Farben, // wenn sie nicht übereinstimmen, musst du die NeoGrbFeature-Funktion verwenden strip. SetPixelColor(i, red);strip. Show (); Verzögerung (100); strip. SetPixelColor(i, hslRed); Strip-Show(); Verzögerung (100); }}

Schritt 15: Hochladen von Code auf den ESP32

Wichtig:

Um Code auf jeden Mikrocontroller hochladen zu können, muss er sich im Programmiermodus befinden. Die meisten tun dies automatisch und Sie müssen nur in der Software auf Upload klicken.

Unser ESP32 erfordert, dass Sie die Programmiertaste gedrückt halten, während der Code gesendet wird. Sie müssen es auch zurücksetzen, nachdem der Code hochgeladen wurde, indem Sie einmal die Reset-Taste drücken.

Die Programmiertaste unseres ESP32 befindet sich auf der linken Seite, die Reset-Taste auf der rechten Seite. Wenn Sie einen anderen Mikrocontroller haben, lesen Sie bitte in Ihrem Handbuch nach.

Schritt 16: Zitate

Dieses instructable wurde mit Hilfe der folgenden Tutorials gemacht:

randomnerdtutorials.com/installieren-the-esp…

Wird verwendet, um den ESP32 in der Arduino IDE zu installieren.

Autoren:

Nathaniel BaroneGabriel Castro

Editor:

Cedric Bleimling