Parete da 500 LED con ESP32: 16 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:01

Ciao a tutti! Alla fine di questo tutorial saprai come creare il tuo LED wall.

Questo tutorial si basa su un programma estivo offerto alla Sacred Heart University.

Divertiti!

Forniture

Forniture elencate di seguito.

Passaggio 1: materiali di consumo

Iniziamo raccogliendo tutto il necessario per completare il nostro Led Wall:

(I link sono stati creati il 7/10/2019)

Software Arduino IDE

Microcontrollore ESP32

LED Pixel Luce

Alimentazione elettrica

Cavo di alimentazione

Strumento spelafili

Cavi jumper per tagliere

Cavo elettrico

Passaggio 2: Determinare il giusto alimentatore per il tuo LedWall

C'è un semplice modo matematico per scoprire quale alimentatore è il migliore per il tuo utilizzo.

Usiamo la legge di potenza di Ohm: P = IxV (Potenza = Intensità x Tensione)

La tensione è determinata dai nostri led: in questo caso 5V.

L'intensità dipende dall'hardware, un singolo Led consuma 30mA.

Ogni striscia di 50 Led consuma quindi 50 x 30mA = 1250mA = 1,25A.

La nostra parete da 500 Led consuma quindi 10 volte tanto (10 strisce): 12,5A.

Il consumo di energia è quindi di 5 V x 12,5 A = 62,5 W per i LED.

Naturalmente, oltre ai LED devi tenere conto dell'ESP e di ogni altro elemento del tuo circuito.

Abbiamo un alimentatore da 60A, ne abbiamo molto di più del necessario.

Passaggio 3: il cavo di alimentazione

Il nostro alimentatore viene fornito con connettori a filo. Dobbiamo adattare un cavo di alimentazione per collegarlo a una presa da 110V.

- Tagliare il connettore femmina dal cavo di alimentazione. Manterremo la parte maschio, altrimenti nota come NEMA 5-15P.

- Spelare il cavo per avere circa 3 mm di rame visibili su tutti i fili.

Ecco un breve video tutorial su come spellare i fili:

Passaggio 4: cablaggio dell'alimentatore

Ora siamo pronti per collegare il nostro alimentatore!

Scollegare sempre l'alimentatore quando si lavora su di esso.

Cablaggio

• Il filo nero (Fase) si collega al pin 'L' dell'alimentatore
• Il filo bianco (Neutro) si collega al pin 'N' dell'alimentatore
• Il filo verde si collega al pin "Ground" dell'alimentatore

(Se i cavi interni del cavo di alimentazione non sono degli stessi colori dei nostri, non preoccuparti e cerca gli schemi online.)

test

Collegare il cavo di alimentazione del computer a qualsiasi presa elettrica. Il LED verde sull'alimentatore dovrebbe accendersi.

Passaggio 5: alimentazione di ESP32S

Guardando il tuo ESP dovrebbero esserci etichette accanto a tutti i pin. Se non è etichettato puoi cercare il "pinout" del tuo singolo ESP online.

Utilizzando un cavo jumper da breadboard maschio a femmina o un cavo elettrico, collegare:

• Il pin ESP32S '5V' al '+V' dell'alimentatore (arancione nella foto sopra)
• Il pin 'GND' ESP32S alla sezione '-V' dell'alimentatore (nero nella foto sopra)

(Su alcuni ESP il pin "5V" è invece etichettato come "VCC", entrambi significano la stessa cosa.)

Tieni presente che il tuo ESP potrebbe avere un "pinout" diverso da quello che stiamo utilizzando. In quanto tale, potresti collegare i cavi in una posizione diversa rispetto all'immagine sopra. Finché ti colleghi ai pin corretti (5 V e GND), la posizione fisica sulla scheda non ha importanza.

Test Collega di nuovo l'alimentatore e se il tuo ESP ha un indicatore LED (la maggior parte lo fa), si accenderà per indicare che l'alimentazione viene inviata all'ESP. Congratulazioni!

Passaggio 6: alimentazione delle strisce luminose a LED

Utilizzo di cavi elettrici:

- Collegare il filo rosso della striscia luminosa a LED a V+ sull'alimentatore.

- Collegare il filo blu della striscia luminosa a LED alla V- dell'alimentatore.

Passaggio 7: collegamento di ESP32 alle strisce luminose a LED

Il nostro ESP32 indica al driver WS2811 collegato a ciascun led il colore e la luminosità che devono essere. Per fare ciò, il nostro ESP32 ha bisogno di un cavo "dati" per le strisce.

Le strisce LED sono dotate di un connettore a 3 fili:

- Rosso: Alimentazione- Blu: Neutro- Bianco: Dati

Colleghiamo il cavo della striscia di Led Bianchi ad un pin digitale dell'ESP. Ricordatevi il numero PIN selezionato in quanto sarà necessario selezionarlo nel codice in seguito. Abbiamo collegato il nostro al pin 13.

Passaggio 8: preparazione del computer: driver C2102

Ora che il nostro hardware è cablato, vogliamo caricare il nostro primo codice per testarlo. Per impostazione predefinita, Windows o MacOs non possono comunicare con il nostro ESP32. Per farlo, dobbiamo scaricare un "driver" per il chip di comunicazione ESP USB: il C2102.

Questo driver deve essere scaricato e installato:

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

(Link dal 7/10/2019)

Passaggio 9: Software Arduino - Aggiunta del supporto ESP32 - Passaggio 1

Prima di poter utilizzare il nostro ESP32 con il software Arduino, dobbiamo assicurarci che venga riconosciuto. Per impostazione predefinita, il software Arduino non può compilare il codice per il nostro ESP32, risolviamolo:

Passaggio 1: aggiunta di schede al manager

1 - Fare clic su Arduino sull'opzione File >> Preferenze

2- Nel campo "Ulteriori URL di Board Manager", copiare il seguente collegamento:

Passaggio 10: Software Arduino - Aggiunta del supporto ESP32 - Passaggio 2

Ora che il software Arduino "conosce" più schede, installiamo il nostro supporto ESP32

Passaggio 2: installazione del supporto ESP32

1 - Nel menu in alto, seleziona: Strumenti >> Tabellone >> Gestore bacheche

2 - Apparirà una finestra. Usa la casella di ricerca, situata nell'angolo in alto a destra, per trovare "ESP32".

3 - Individua quello realizzato da espressif. Installalo. (Vedi immagine)

Passaggio 11: Software Arduino - Aggiunta del supporto ESP32 - Passaggio 3

Ora che il software Arduino può comunicare con il nostro ESP32, colleghiamolo al computer e verifichiamo che tutto funzioni.

1 - Assicuriamoci di lavorare sulla piattaforma ESP32:

Fare clic su Strumenti >> Scheda >> Modulo di sviluppo ESP32

1- Assicuriamoci che il software Arduino sappia comunicare con il nostro ESP:

Fare clic su Strumenti >> Porta e selezionare quello che si apre collegando questo cavo.

Importante:

Se hai problemi a caricare il codice sul tuo ESP, controlla prima questi due menu. Se la porta non è selezionata con un segno di spunta, il software Arduino non comunicherà con essa.

Passaggio 12: aggiunta di librerie all'IDE Arduino

Ora aggiungeremo una libreria che ci permetterà di testare il nostro Led Wall!

1- Fare clic su Strumenti >> Gestisci librerie.

2- Nell'angolo in alto a destra, cerca NeoPixelBus. Individua "NeoPixelBus by Makuna", installalo (vedi immagine)

Potenziali altre biblioteche interessanti: (non richiesto per questo tutorial)

- NeoMatrix

- FastLed

- Artnet

- GFX

Passaggio 13: Primo codice: test del filo

Il nostro primo codice è un esempio della Biblioteca.

Puoi copiare/incollare il codice qui sotto o cliccare su:

File >> Esempi >> Adafruit NeoPixelBus >> Strandtest

Assicurati di cambiare il tuo LED_PIN con quello che hai usato per collegare fisicamente i tuoi led. Ne abbiamo usati 13 in questo tutorial.

Assicurati anche di adattare la dimensione del filo con la variabile LED_COUNT.

// Un programma di base per striptest LED di tutti i giorni.

#include#ifdef _AVR_ #include // Necessario per Adafruit Trinket a 16 MHz #endif // Quale pin dell'Arduino è collegato ai NeoPixel? #define LED_PIN 13 // Quanti NeoPixel sono collegati ad Arduino? #define LED_COUNT 500 // Dichiara il nostro oggetto striscia NeoPixel: striscia Adafruit_NeoPixel (LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800); // Argomento 1 = Numero di pixel nella striscia NeoPixel // Argomento 2 = Numero pin Arduino (la maggior parte sono validi) // Argomento 3 = Flag di tipo pixel, sommare se necessario: // NEO_KHZ800 800 KHz bitstream (la maggior parte dei prodotti NeoPixel con LED WS2812) // NEO_KHZ400 400 KHz (pixel FLORA classico 'v1' (non v2), driver WS2811) // I pixel NEO_GRB sono cablati per bitstream GRB (la maggior parte dei prodotti NeoPixel) // I pixel NEO_RGB sono cablati per bitstream RGB (pixel FLORA v1, non v2) // I pixel NEO_RGBW sono cablati per il flusso di bit RGBW (prodotti NeoPixel RGBW) // funzione setup() -- viene eseguita una volta all'avvio -------------------- ------------ void setup() { // Queste linee sono specifiche per supportare Adafruit Trinket 5V 16 MHz. // Qualsiasi altra scheda, puoi rimuovere questa parte (ma senza alcun danno se la lasci): #ifdefined(_AVR_ATtiny85_) && (F_CPU == 16000000) clock_prescale_set(clock_div_1); #endif // FINE del codice specifico di Trinket. strip.begin(); // INIZIALIZZA oggetto strip NeoPixel (RICHIESTO) strip.show(); // Spegne tutti i pixel APPENA POSSIBILE strip.setBrightness(50); // Imposta BRIGHTNESS a circa 1/5 (max = 255) } // la funzione loop() -- viene eseguita ripetutamente finché la scheda è accesa --------------- void loop() { // Riempi lungo la lunghezza della striscia in vari colori… colorWipe(strip. Color(255, 0, 0), 50); // Red colorWipe(strip. Color(0, 255, 0), 50); // Green colorWipe(strip. Color(0, 0, 255), 50); // Blu // Crea un effetto teatro in vari colori… theaterChase(strip. Color(127, 127, 127), 50); // Bianco, luminosità dimezzata theaterChase(strip. Color(127, 0, 0), 50); // Rosso, luminosità dimezzata theaterChase(strip. Color(0, 0, 127), 50); // Arcobaleno blu, mezza luminosità (10); // Ciclo arcobaleno che scorre lungo l'intera strip theaterChaseRainbow(50); // Variante theaterChase potenziata dall'arcobaleno } // Alcune nostre funzioni per la creazione di effetti animati ------------------ // Riempi i pixel della striscia uno dopo l'altro con un colore. La striscia NON viene cancellata // prima; tutto quello che c'è sarà coperto pixel per pixel. Passa in color // (come un singolo valore a 32 bit "compresso", che puoi ottenere chiamando // strip. Color(red, green, blue) come mostrato nella funzione loop() sopra), // e a tempo di ritardo (in millisecondi) tra i pixel. void colorWipe(uint32_t color, int wait) { for(int i=0; i strip.setPixelColor(i, color); // Imposta il colore del pixel (nella RAM) strip.show(); // Aggiorna la striscia in modo che corrisponda al ritardo (aspetta); // Pausa per un momento } } // Luci a inseguimento in stile teatro. Passa un colore (valore a 32 bit, // a la strip. Color(r, g, b) come menzionato sopra), e un tempo di ritardo (in ms) // tra i fotogrammi void theaterChase(uint32_t color, int wait) { for(int a=0; a<10; a++) { // Ripeti 10 volte… for(int b=0; b<3; b++) { // 'b' conta da 0 a 2… strip.clear(); // Imposta tutti i pixel nella RAM su 0 (off) // 'c' conta da 'b' alla fine di strip in step di 3… for(int c=b; c strip.setPixelColor(c, color); // Imposta il pixel 'c' al valore 'color' } strip.show(); // Aggiorna la striscia con il ritardo del nuovo contenuto (aspetta); // Pausa per un momento } } } // Ciclo arcobaleno lungo l'intera striscia. Passa il tempo di ritardo (in ms) tra i fotogrammi. void rainbow(int wait) { // La tonalità del primo pixel esegue 5 cicli completi attraverso il ruota dei colori. // La ruota dei colori ha una gamma di 65536 ma è OK se passiamo al rollover, quindi // conta solo da 0 a 5*65536. Aggiungere 256 a firstPixelHue ogni volta // significa che faremo 5*65536/256 = 1280 passaggi attraverso questo ciclo esterno: for(long firstPixelHue = 0; firstPixelHue < 5*65536; firstPixelHue += 256) { for(int i= 0; I // Compensa la tonalità dei pixel di una quantità per fare un giro completo della // ruota dei colori (intervallo di 65536) lungo la lunghezza della striscia // (steps strip.numPixels()): int pixelHue = firstPixelHue + (i * 65536L / strip.numPixels()); // strip. ColorHSV() può prendere 1 o 3 argomenti: una tonalità (da 0 a 65535) o // facoltativamente aggiungere saturazione e valore (luminosità) (ognuno da 0 a 255). // Qui stiamo usando solo la variante di tonalità a argomento singolo. Il risultato // viene passato attraverso strip.gamma32() per fornire colori "più veri" // prima di assegnare a ciascun pixel: strip.setPixelColor(i, strip.gamma32 (strip. ColorHSV(pixelHue))); } strip.show(); // Aggiorna la striscia con nuovi contenuti delay(wait); // Pausa per un momento } } // Marquee teatrale con arcobaleno. Passa il tempo di ritardo (in ms) tra i fotogrammi. void theaterChaseRainbow(int wait) { i nt firstPixelHue = 0; // Il primo pixel inizia dal rosso (tonalità 0) for(int a=0; a<30; a++) { // Ripeti 30 volte… for(int b=0; b RGB strip.setPixelColor(c, color); / / Imposta il pixel 'c' al valore 'color' } strip.show(); // Aggiorna la striscia con il nuovo contenuto delay(wait); // Metti in pausa per un momento firstPixelHue += 65536 / 90; // Un ciclo della ruota dei colori oltre 90 fotogrammi } } }

Passaggio 14: codice di esempio SHU

Il nostro codice accende uno ad uno tutti i led per assicurarsi che funzionino:

// Questo esempio mostrerà ciclicamente 500 pixel come rossi

#includeconst uint16_t PixelCount = 500; // questo esempio presuppone 4 pixel, rimpicciolirlo causerà un errore const uint8_t PixelPin = 13; // assicurati di impostarlo sul pin corretto, ignorato per Esp8266

#define colorSaturation 128// pixel di tre elementi, in ordine e velocità diversi

striscia NeoPixelBus (PixelCount, PixelPin);

//Strip NeoPixelBus(PixelCount, PixelPin); RgbColor red(0, colorSaturation, 0); RgbColor green(colorSaturation, 0, 0); RgbColor blue(0, 0, colorSaturation); RGBColor white(colorSaturation); RGBColor nero(0); HslColor hslRed(rosso); HslColor hslGreen(verde); HslColor hslBlue (blu); HslColor hslWhite(bianco); HslColor hslBlack(nero); void setup() { Serial.begin(115200) while (!Serial); // attende il collegamento seriale Serial.println(); Serial.println("Inizializzazione in corso…"); Serial.flush(); // questo ripristina tutti i neopixel su una striscia di stato off. Begin(); striscia. Mostra(); Serial.println(); Serial.println("In esecuzione…"); } ciclo vuoto() { ritardo (100); Serial.println("Colori R, G, B, W…"); for(int i = 0; i <=499;i++){ // imposta i colori, // se non corrispondono in ordine, devi utilizzare la funzione NeoGrbFeature strip. SetPixelColor(i, red);strip. Show (); ritardo(100); strip. SetPixelColor(i, hslRed); striscia. Mostra(); ritardo(100); }}

Passaggio 15: caricamento del codice su ESP32

Importante:

Per poter caricare il codice su qualsiasi microcontrollore, è necessario che sia in modalità di programmazione. La maggior parte lo fa automaticamente e tutto ciò che devi fare è fare clic su Carica nel software.

Il nostro ESP32 richiede di tenere premuto il pulsante di programmazione durante l'invio del codice. È inoltre necessario ripristinarlo dopo che il codice è stato caricato premendo una volta il pulsante di ripristino.

Il pulsante di programmazione del nostro ESP32 si trova a sinistra, il pulsante di ripristino a destra. Fare riferimento al manuale se si dispone di un altro microcontrollore.

Passaggio 16: citazioni

Questo istruibile è stato realizzato con l'aiuto dei seguenti tutorial:

randomnerdtutorials.com/installing-the-esp…

Utilizzato per installare ESP32 nell'IDE di Arduino.

Autori:

Nathaniel Barone, Gabriel Castro

Editore:

Cedric Bleimling