Mur de 500 LED avec ESP32 : 16 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:07

Salut à tous! À la fin de ce tutoriel, vous saurez comment créer votre propre mur LED.

Ce tutoriel est basé sur un programme d'été offert à l'Université du Sacré-Cœur.

S'amuser!

Fournitures

Fournitures listées ci-dessous.

Étape 1: Fournitures

Commençons par rassembler tout ce dont nous avons besoin pour compléter notre Led Wall:

(Les liens ont été créés le 2019-07-10)

Logiciel IDE Arduino

Micro-contrôleur ESP32

LED Pixel Lumière

Source de courant

Cordon d'alimentation

Outil de dénudage de fil

Câbles de démarrage de planche à pain

Fil électrique

Étape 2: Déterminer la bonne alimentation pour votre LedWall

Il existe un moyen mathématique simple de déterminer quelle alimentation est la meilleure pour votre utilisation.

Nous utilisons la loi de puissance d'Ohm: P = IxV (Puissance = Intensité x Tension)

La tension est déterminée par nos leds: dans ce cas 5V.

L'intensité dépend du matériel, une seule Led consomme 30mA.

Chaque barrette de 50 Leds consomme donc 50 x 30mA = 1250mA = 1,25A.

Notre mur 500 Led consomme donc 10 fois plus (10 bandes): 12,5A.

La consommation électrique est alors de 5V x 12,5A = 62,5W pour les Leds.

Bien sûr, en plus des Leds, vous devez tenir compte de l'ESP et de tous les autres éléments de votre circuit.

Nous avons une alimentation 60A, nous avons beaucoup plus que ce dont nous avons besoin.

Étape 3: Le cordon d'alimentation

Notre alimentation est livrée avec des connecteurs de fils. Il faut adapter un cordon d'alimentation pour le brancher sur une prise 110V.

- Coupez le connecteur femelle du cordon d'alimentation. Nous garderons la partie mâle, autrement appelée NEMA 5-15P.

- Dénudez le câble pour avoir environ 3mm de cuivre visible sur tous les fils.

Voici un tutoriel vidéo rapide sur la façon de dénuder les fils:

Étape 4: Câblage de l'alimentation

Nous sommes maintenant prêts à câbler notre alimentation électrique !

Débranchez toujours l'alimentation électrique lorsque vous travaillez dessus.

Câblage

• Le fil noir (Phase) se connecte à la broche 'L' de l'alimentation
• Le fil blanc (Neutre) se connecte à la broche 'N' de l'alimentation
• Le fil vert se connecte à la broche 'Masse' de l'alimentation

(Si les fils intérieurs de votre cordon d'alimentation ne sont pas de la même couleur que les nôtres, soyez prudent et recherchez les schémas en ligne.)

Essai

Branchez le cordon d'alimentation de l'ordinateur dans n'importe quelle prise électrique. La LED verte de l'alimentation doit s'allumer.

Étape 5: Mise sous tension de l'ESP32S

En regardant votre ESP, il devrait y avoir des étiquettes à côté de chaque broche. Si elle n'est pas étiquetée, vous pouvez rechercher le "brochage" de votre ESP individuel en ligne.

À l'aide d'un fil de pontage mâle à femelle ou d'un fil électrique, connectez:

• La broche '5V' ESP32S au '+V' de l'alimentation (orange sur la photo ci-dessus)
• La broche 'GND' ESP32S à la section '-V' de l'alimentation (noir sur la photo ci-dessus)

(Sur certains ESP, la broche '5V' est étiquetée comme 'VCC' à la place, elles signifient toutes les deux la même chose.)

Veuillez noter que votre ESP peut avoir un "brochage" différent de celui que nous utilisons. En tant que tel, vous pouvez connecter vos fils à un emplacement différent de celui sur l'image ci-dessus. Tant que vous vous connectez aux bonnes broches (5 V et GND), l'emplacement physique sur la carte n'a pas d'importance.

TestBranchez à nouveau votre alimentation, et si votre ESP a un indicateur LED (la plupart le font), il s'allumera pour indiquer que l'alimentation est envoyée à l'ESP. Toutes nos félicitations!

Étape 6: Alimentation des bandes lumineuses LED

Utilisation de fils électriques:

- Connectez le fil rouge de la LED Light Strip au V+ de l'alimentation.

- Connectez le fil bleu de la bande lumineuse LED au V- de l'alimentation.

Étape 7: Connexion de l'ESP32 aux bandes lumineuses LED

Notre ESP32 indique au pilote WS2811 connecté à chaque led la couleur et la luminosité dont ils ont besoin. Pour ce faire, notre ESP32 a besoin d'un câble "data" vers les bandes.

Les bandes Leds sont livrées avec un connecteur 3 fils:

- Rouge: Puissance- Bleu: Neutre- Blanc: Données

Connectons le câble à bande de LED blanches à une broche numérique sur l'ESP. Veuillez vous souvenir du code PIN sélectionné car nous devrons le sélectionner dans le code plus tard. Nous avons branché le nôtre sur la broche 13.

Étape 8: Préparation de l'ordinateur: pilote C2102

Maintenant que notre matériel est câblé, nous souhaitons télécharger notre premier code pour le tester. Par défaut, Windows ou MacOs ne peuvent pas communiquer avec notre ESP32. Pour ce faire, nous devons télécharger un "driver" pour la puce de communication USB ESP: le C2102.

Ce pilote doit être téléchargé et installé:

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

(Liens au 7/10/2019)

Étape 9: Logiciel Arduino - Ajout du support ESP32 - Étape 1

Avant de pouvoir utiliser notre ESP32 avec le logiciel Arduino, nous devons nous assurer qu'il est reconnu. Par défaut, le logiciel Arduino ne peut pas compiler de code pour notre ESP32, corrigeons cela:

Étape 1: Ajouter des tableaux au gestionnaire

1 - Cliquez dans l'Arduino sur l'option Fichier >> Préférences

2- Dans le champ "Additional Boards Manager URLs", copiez le lien suivant:

Étape 10: Logiciel Arduino - Ajout du support ESP32 - Étape 2

Maintenant que le logiciel Arduino "connaît" plus de cartes, installons notre support ESP32

Étape 2: Installation du support ESP32

1 - Dans le menu du haut, sélectionnez: Outils >> Tableau >> Gestionnaire de tableaux

2 - Une fenêtre apparaît. Utilisez le champ de recherche, situé dans le coin supérieur droit, pour trouver "ESP32".

3 - Repérez celui fabriqué par espressif. Installez-le. (Voir image)

Étape 11: Logiciel Arduino - Ajout du support ESP32 - Étape 3

Maintenant que le logiciel Arduino peut communiquer avec notre ESP32, connectons-le à l'ordinateur et vérifions que tout fonctionne.

1 - Assurons-nous de travailler sur la plateforme ESP32:

Cliquez sur Outils >> Carte >> Module de développement ESP32

1- Assurons-nous que le logiciel Arduino sait communiquer avec notre ESP:

Cliquez sur Outils >> Port et sélectionnez celui qui apparaît en branchant ce câble.

Important:

Si vous rencontrez des problèmes pour télécharger le code sur votre ESP, vérifiez d'abord ces deux menus. Si le port n'est pas sélectionné avec une coche, le logiciel Arduino ne communiquera pas avec lui.

Étape 12: Ajout de bibliothèques à l'IDE Arduino

Nous allons maintenant ajouter une bibliothèque qui nous permettra de tester notre Led Wall !

1- Cliquez sur Outils >> Gérer les bibliothèques.

2- Dans le coin supérieur droit, recherchez NeoPixelBus. Localisez "NeoPixelBus by Makuna", installez-le (voir image)

Potentiel d'autres bibliothèques intéressantes: (non requis pour ce didacticiel)

- NeoMatrix

- FastLed

-Artnet

- GFX

Étape 13: Premier code: Test de brin

Notre premier code est un exemple de la bibliothèque.

Vous pouvez soit copier/coller le code ci-dessous soit cliquer sur:

Fichier >> Exemples >> Adafruit NeoPixelBus >> Strandtest

Veuillez vous assurer de remplacer votre LED_PIN par celui que vous avez utilisé pour connecter physiquement vos leds. Nous en avons utilisé 13 tout au long de ce tutoriel.

Assurez-vous également d'adapter la taille du brin avec la variable LED_COUNT.

// Un programme de base de Striptest LED de tous les jours.

#include#ifdef _AVR_ #include // Requis pour Adafruit Trinket 16 MHz #endif // Quelle broche de l'Arduino est connectée aux NeoPixels ? #define LED_PIN 13 // Combien de NeoPixels sont attachés à l'Arduino ? #define LED_COUNT 500 // Déclarer notre objet bande NeoPixel: Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800); // Argument 1 = Nombre de pixels dans la bande NeoPixel // Argument 2 = Numéro de broche Arduino (la plupart sont valides) // Argument 3 = Drapeaux de type de pixel, additionnez si nécessaire: // NEO_KHZ800 800 KHz Bitstream (la plupart des produits NeoPixel avec LED WS2812) // NEO_KHZ400 400 KHz (pixels FLORA classiques 'v1' (pas v2), drivers WS2811) // Les pixels NEO_GRB sont câblés pour le flux binaire GRB (la plupart des produits NeoPixel) // Les pixels NEO_RGB sont câblés pour le flux binaire RVB (pixels FLORA v1, pas v2) // Les pixels NEO_RGBW sont câblés pour le flux binaire RGBW (produits NeoPixel RGBW) // fonction setup() -- s'exécute une fois au démarrage -------------------- ------------ void setup() { // Ces lignes sont spécifiquement destinées à supporter l'Adafruit Trinket 5V 16 MHz. // Toute autre carte, vous pouvez supprimer cette partie (mais pas de mal à la laisser): #if define(_AVR_ATtiny85_) && (F_CPU == 16000000) clock_prescale_set(clock_div_1); #endif // FIN du code spécifique à Trinket. strip.begin(); // INITIALISER l'objet bande NeoPixel (REQUIS) strip.show(); // Désactiver tous les pixels dès que possible strip.setBrightness(50); // Réglez BRIGHTNESS sur environ 1/5 (max = 255) } // fonction loop() -- s'exécute de manière répétée tant que la carte est allumée --------------- void loop() { // Remplir le long de la bande de différentes couleurs… colorWipe(strip. Color(255, 0, 0, 50); // Red colorWipe(strip. Color(0, 255, 0), 50); // Vert colorWipe(strip. Color(0, 0, 255), 50); // Bleu // Faire un effet de théâtre dans différentes couleurs… TheaterChase(strip. Color(127, 127, 127), 50); // Blanc, demi-luminosité TheaterChase(strip. Color(127, 0, 0), 50); // Rouge, demi-luminosité TheaterChase(strip. Color(0, 0, 127), 50); // Bleu, demi-luminosité arc-en-ciel (10); // Cycle arc-en-ciel fluide le long de la bande entière TheaterChaseRainbow(50); // Variante de TheaterChase améliorée par l'arc-en-ciel } // Certaines de nos propres fonctions pour créer des effets animés ----------------- // Remplir les pixels de la bande les uns après les autres avec une couleur. La bande n'est PAS effacée // d'abord; tout ce qui y sera sera couvert pixel par pixel. Passez en couleur // (sous forme d'une seule valeur 'packed' 32 bits, que vous pouvez obtenir en appelant // strip. Color(red, green, blue) comme indiqué dans la fonction loop() ci-dessus), // et un temps de retard (en millisecondes) entre les pixels. void colorWipe(uint32_t color, int wait) { for(int i=0; i strip.setPixelColor(i, color); // Définir la couleur du pixel (en RAM) strip.show(); // Mettre à jour la bande pour qu'elle corresponde au délai (attendez); // Pause un instant } } // Lumières de poursuite de style chapiteau de théâtre. Passez une couleur (valeur 32 bits, // a la strip. Color(r, g, b) comme mentionné ci-dessus), et un temps de retard (en ms) // entre les images.void TheaterChase(uint32_t color, int wait) { for(int a=0; a<10; a++) { // Répétez 10 fois… for(int b=0; b<3; b++) { // 'b' compte de 0 à 2… strip.clear(); // Met tous les pixels de la RAM à 0 (désactivé) // 'c' compte de 'b' à la fin de strip par étapes de 3… for(int c=b; c strip.setPixelColor(c, color); // Définir le pixel 'c' sur la valeur 'color' } strip.show(); // Mettre à jour la bande avec le nouveau contenu delay (attendre); // Pause un instant } } } // Cycle arc-en-ciel le long de la bande entière. Temps de retard (en ms) entre les images. void rainbow(int wait) { // La teinte du premier pixel effectue 5 boucles complètes à travers le roue chromatique. // La roue chromatique a une plage de 65536 mais c'est OK si on retourne, donc // il suffit de compter de 0 à 5*65536. Ajouter 256 à firstPixelHue à chaque fois // signifie que nous ferons 5*65536/256 = 1280 passages à travers cette boucle externe: for(long firstPixelHue = 0; firstPixelHue < 5*65536; firstPixelHue += 256) { for(int i= 0; I // Décaler la teinte du pixel d'une quantité pour faire un tour complet de la // roue chromatique (plage de 65536) sur la longueur de la bande // (pas de strip.numPixels()): int pixelHue = firstPixelHue + (i * 65536L / strip.numPixels()); // strip. ColorHSV() peut prendre 1 ou 3 arguments: une teinte (0 à 65535) ou // éventuellement ajouter une saturation et une valeur (luminosité) (chacun de 0 à 255). // Ici, nous utilisons uniquement la variante de teinte à un seul argument. Le résultat // est passé à travers strip.gamma32() pour fournir des couleurs "plus vraies" // avant d'être affecté à chaque pixel: strip.setPixelColor(i, strip.gamma32 (strip. ColorHSV(pixelHue))); } strip.show(); // Mettre à jour la bande avec le nouveau contenu delay(wait); // Pause un instant } } // Chapiteau de théâtre amélioré par l'arc-en-ciel. Passe le délai (en ms) entre les images. void TheaterChaseRainbow(int wait) { i nt firstPixelHue = 0; // Le premier pixel commence au rouge (teinte 0) for(int a=0; a<30; a++) { // Répétez 30 fois… for(int b=0; b RGB strip.setPixelColor(c, color); / / Définir le pixel 'c' sur la valeur 'color' } strip.show(); // Mettre à jour la bande avec le nouveau contenu delay(wait); // Pause un instant d'abordPixelHue += 65536 / 90; // Un cycle de roue chromatique plus de 90 images } } }

Étape 14: Exemple de code SHU

Notre code allume toutes les Leds une par une pour s'assurer qu'elles fonctionnent:

// Cet exemple va alterner entre l'affichage de 500 pixels en rouge

#includeconst uint16_t PixelCount = 500; // cet exemple suppose 4 pixels, le rendre plus petit provoquera un échec const uint8_t PixelPin = 13; // assurez-vous de le définir sur la broche correcte, ignoré pour Esp8266

#define colorSaturation 128 // pixels à trois éléments, dans un ordre et des vitesses différents

Bande NeoPixelBus (PixelCount, PixelPin);

// Bande NeoPixelBus (PixelCount, PixelPin); RgbColor red(0, colorSaturation, 0); RgbColor green(colorSaturation, 0, 0); RgbColor blue(0, 0, colorSaturation); RgbColor white(colorSaturation); RgbCouleur noir(0); HslColor hslRed(rouge); HslColor hslGreen(vert); HslColor hslBlue(bleu); HslColor hslWhite(blanc); HslColor hslBlack(noir); void setup() { Serial.begin(115200) while (!Serial); // attend la connexion en série Serial.println(); Serial.println("Initialisation…"); Serial.flush(); // cela réinitialise tous les néopixels à un état désactivé. Begin(); strip. Show(); Serial.println(); Serial.println("En cours d'exécution…"); } boucle vide() { délai (100); Serial.println("Couleurs R, V, B, W…"); for(int i = 0; i <=499;i++){ // définit les couleurs, // si elles ne correspondent pas dans l'ordre, vous devez utiliser NeoGrbFeature feature strip. SetPixelColor(i, red);strip. Show (); retard (100); strip. SetPixelColor(i, hslRed); strip. Show(); retard (100); }}

Étape 15: Téléchargement du code vers l'ESP32

Important:

Pour pouvoir télécharger du code sur n'importe quel microcontrôleur, il doit être en mode programmation. La plupart le font automatiquement et tout ce que vous avez à faire est de cliquer sur télécharger dans le logiciel.

Notre ESP32 vous oblige à maintenir le bouton de programmation enfoncé pendant l'envoi du code. Vous devez également le réinitialiser une fois le code téléchargé en appuyant une fois sur le bouton de réinitialisation.

Le bouton de programmation de notre ESP32 est situé à gauche, le bouton de réinitialisation à droite. Veuillez vous référer à votre manuel si vous avez un autre micro-contrôleur.

Étape 16: Citations

Cette instructable a été faite à l'aide des tutoriels suivants:

randomnerdtutorials.com/installing-the-esp…

Utilisé pour installer l'ESP32 dans Arduino IDE.

Auteurs:

Nathaniel BaroneGabriel Castro

Éditeur:

Cédric Bleimling