Pared de 500 LED con ESP32: 16 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:41

¡Hola a todos! Al final de este tutorial, sabrá cómo crear su propia pared LED.

Este tutorial se basa en un programa de verano ofrecido en Sacred Heart University.

¡Divertirse!

Suministros

Suministros enumerados a continuación.

Paso 1: Suministros

Comencemos reuniendo todo lo que necesitamos para completar nuestro Led Wall:

(Los enlaces se crearon el 7/10/2019)

Software IDE de Arduino

Microcontrolador ESP32

Luz de píxel LED

Fuente de alimentación

Cable de alimentación

Herramienta para pelar cables

Cables de puente para placa de pruebas

Cable eléctrico

Paso 2: Determinar la fuente de alimentación adecuada para su LedWall

Existe una forma matemática simple de averiguar qué fuente de alimentación es la mejor para su uso.

Estamos usando la ley de potencia de Ohm: P = IxV (Potencia = Intensidad x Voltaje)

La tensión viene determinada por nuestros leds: en este caso 5V.

La intensidad depende del hardware, un solo Led consume 30mA.

Por tanto, cada tira de 50 Leds consume 50 x 30mA = 1250mA = 1,25A.

Por tanto, nuestra pared de 500 Led consume 10 veces más (10 tiras): 12,5 A.

El consumo de energía es entonces de 5 V x 12,5 A = 62,5 W para los LED.

Por supuesto, además de los LED, debe tener en cuenta el ESP y todos los demás elementos de su circuito.

Tenemos una fuente de alimentación de 60 A, tenemos mucho más de lo que necesitamos.

Paso 3: el cable de alimentación

Nuestra fuente de alimentación viene con conectores de cables. Necesitamos adaptar un cable de alimentación para conectarlo a un enchufe de 110V.

- Cortar el conector hembra del cable de alimentación. Conservaremos la parte macho, de lo contrario conocida como NEMA 5-15P.

- Pele el cable para tener unos 3 mm de cobre visibles en todos los cables.

Aquí hay un video tutorial rápido sobre cómo pelar cables:

Paso 4: cableado de la fuente de alimentación

¡Ahora estamos listos para conectar nuestra fuente de alimentación!

Desenchufe siempre la fuente de alimentación cuando trabaje en ella.

Alambrado

• El cable negro (fase) se conecta al pin 'L' de la fuente de alimentación
• El cable blanco (neutro) se conecta al pin 'N' de la fuente de alimentación
• El cable verde se conecta al pin 'Tierra' de la fuente de alimentación

(Si los cables interiores de su cable de alimentación no son de los mismos colores que los nuestros, esté seguro y busque los esquemas en línea).

Pruebas

Enchufe el cable de alimentación de la computadora en cualquier tomacorriente. El LED verde de la fuente de alimentación debería encenderse.

Paso 5: Encendido del ESP32S

Mirando su ESP, debería haber etiquetas al lado de cada pin. Si no está etiquetado, puede buscar el 'pinout' de su ESP individual en línea.

Con un cable de puente macho a hembra de placa de pruebas o un cable eléctrico, conecte:

• El pin '5V' ESP32S al '+ V' de la fuente de alimentación (naranja en la foto de arriba)
• El pin 'GND' ESP32S a la sección '-V' de la fuente de alimentación (negro en la foto de arriba)

(En algunos ESP, el pin '5V' está etiquetado como 'VCC', ambos significan lo mismo).

Tenga en cuenta que su ESP puede tener un 'pinout' diferente al que estamos usando. Como tal, puede estar conectando sus cables a una ubicación diferente a la de la imagen de arriba. Siempre que se conecte a los pines correctos (5V y GND), la ubicación física en la placa no importa.

Prueba Vuelva a enchufar la fuente de alimentación y, si su ESP tiene un indicador LED (la mayoría lo tiene), se iluminará para indicar que se está enviando energía al ESP. ¡Felicidades!

Paso 6: Encendido de las tiras de luz LED

Usando cables eléctricos:

- Conecte el cable rojo de la tira de luz LED a V + en la fuente de alimentación.

- Conecte el cable azul de la tira de luces LED a la V- en la fuente de alimentación.

Paso 7: Conexión del ESP32 a las tiras de luz LED

Nuestro ESP32 indica al controlador WS2811 conectado a cada led el color y brillo que deben tener. Para hacerlo, nuestro ESP32 necesita un cable de "datos" para las tiras.

Las tiras de Leds vienen con un conector de 3 hilos:

- Rojo: Encendido - Azul: Neutro - Blanco: Datos

Conectemos el cable de la tira de Led Blanco a un pin digital en el ESP, por favor recuerde el PIN seleccionado ya que necesitaremos seleccionarlo en el código más adelante, conectamos el nuestro al pin 13.

Paso 8: Preparación de la computadora: controlador C2102

Ahora que nuestro hardware está cableado, queremos cargar nuestro primer código para probarlo. Por defecto, Windows o MacOs no pueden comunicarse con nuestro ESP32. Para hacerlo, necesitamos descargar un "controlador" para el chip de comunicación ESP USB: el C2102.

Este controlador debe descargarse e instalarse:

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

(Enlaces al 7/10/2019)

Paso 9: Software Arduino - Adición de compatibilidad con ESP32 - Paso 1

Antes de que podamos usar nuestro ESP32 con el software Arduino, debemos asegurarnos de que sea reconocido. De forma predeterminada, el software Arduino no puede compilar código para nuestro ESP32, arreglemos eso:

Paso 1: agregar tableros al administrador

1 - Haga clic en Arduino en la opción Archivo >> Preferencias

2- En el campo "URL adicionales del administrador de tableros", copie el siguiente enlace:

Paso 10: Software Arduino - Adición de compatibilidad con ESP32 - Paso 2

Ahora que el software Arduino "conoce" más placas, instalemos nuestro soporte ESP32

Paso 2: instalación del soporte ESP32

1 - En el menú superior, seleccione: Herramientas >> Tablero >> Administrador de tableros

2 - Aparecerá una ventana. Utilice el cuadro de búsqueda, ubicado en la esquina superior derecha, para encontrar "ESP32".

3 - Localice el realizado por espressif. Instalarlo. (Ver imagen)

Paso 11: Software Arduino - Adición de compatibilidad con ESP32 - Paso 3

Ahora que el software Arduino puede comunicarse con nuestro ESP32, conéctelo a la computadora y verifiquemos que todo funciona.

1 - Asegurémonos de trabajar en la plataforma ESP32:

Haga clic en Herramientas >> Placa >> Módulo de desarrollo ESP32

1- Asegurémonos de que el software Arduino sepa comunicarse con nuestro ESP:

Haga clic en Herramientas >> Puerto y seleccione el que aparece al conectar este cable.

Importante:

Si tiene algún problema para cargar el código en su ESP, primero verifique esos dos menús. Si el puerto no está seleccionado con una marca de verificación, el software Arduino no se comunicará con él.

Paso 12: Agregar bibliotecas al IDE de Arduino

¡Ahora vamos a agregar una biblioteca que nos permitirá probar nuestro Led Wall!

1- Haga clic en Herramientas >> Administrar bibliotecas.

2- En la esquina superior derecha, busque NeoPixelBus. Localice "NeoPixelBus by Makuna", instálelo (ver imagen)

Posibles otras bibliotecas interesantes: (No es necesario para este tutorial)

- NeoMatrix

- FastLed

- Artnet

- GFX

Paso 13: Primer código: prueba de hebra

Nuestro primer código es un ejemplo de la biblioteca.

Puede copiar / pegar el código a continuación o hacer clic en:

Archivo >> Ejemplos >> Adafruit NeoPixelBus >> Strandtest

Asegúrate de cambiar tu LED_PIN por el que usaste para conectar físicamente tus leds. Usamos 13 a lo largo de este tutorial.

También asegúrese de adaptar el tamaño de la hebra con la variable LED_COUNT.

// Un programa básico de prueba de tira de LED todos los días.

# include # ifdef _AVR_ #include // Requerido para Adafruit Trinket de 16 MHz #endif // ¿Qué pin del Arduino está conectado a los NeoPixels? #define LED_PIN 13 // ¿Cuántos NeoPixels están conectados al Arduino? #define LED_COUNT 500 // Declare nuestro objeto de tira NeoPixel: Adafruit_NeoPixel strip (LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800); // Argumento 1 = Número de píxeles en la tira de NeoPixel // Argumento 2 = Número de pin de Arduino (la mayoría son válidos) // Argumento 3 = Indicadores de tipo de píxel, sume según sea necesario: // NEO_KHZ800 800 KHz bitstream (la mayoría de los productos NeoPixel con LED WS2812) // NEO_KHZ400 400 KHz (píxeles FLORA clásicos 'v1' (no v2), controladores WS2811) // NEO_GRB Los píxeles están conectados para el flujo de bits GRB (la mayoría de los productos NeoPixel) // Los píxeles NEO_RGB están conectados para el flujo de bits RGB (píxeles FLORA v1, no v2) // NEO_RGBW Los píxeles están conectados para flujo de bits RGBW (productos NeoPixel RGBW) // función setup () - se ejecuta una vez al inicio -------------------- ------------ void setup () {// Estas líneas son específicamente para admitir Adafruit Trinket 5V 16 MHz. // Cualquier otra placa, puede eliminar esta parte (pero no hay daño al dejarla): #if definido (_ AVR_ATtiny85_) && (F_CPU == 16000000) clock_prescale_set (clock_div_1); #endif // FIN del código específico de Trinket. strip.begin (); // INICIALIZAR el objeto de tira de NeoPixel (OBLIGATORIO) strip.show (); // Apague todos los píxeles lo antes posible strip.setBrightness (50); // Establece BRILLO en aproximadamente 1/5 (máx. = 255)} // Función loop () - se ejecuta repetidamente mientras la placa esté encendida --------------- void loop () {// Rellena a lo largo de la tira con varios colores … colorWipe (strip. Color (255, 0, 0), 50); // Red colorWipe (strip. Color (0, 255, 0), 50); // Verde colorWipe (strip. Color (0, 0, 255), 50); // Azul // Haz un efecto de teatro en varios colores… theaterChase (strip. Color (127, 127, 127), 50); // Blanco, medio brillo theaterChase (strip. Color (127, 0, 0), 50); // Rojo, medio brillo theaterChase (strip. Color (0, 0, 127), 50); // Arco iris azul, medio brillo (10); // Ciclo del arcoíris que fluye a lo largo de toda la tira theaterChaseRainbow (50); // Variante theaterChase mejorada con arcoíris} // Algunas funciones propias para crear efectos animados ----------------- // Rellenar los píxeles de la tira uno tras otro con un color. La tira NO se borra // primero; todo lo que haya allí se cubrirá píxel a píxel. Pase el color // (como un único valor 'empaquetado' de 32 bits, que puede obtener llamando a // strip. Color (rojo, verde, azul) como se muestra en la función loop () anterior), // y un tiempo de retardo (en milisegundos) entre píxeles. void colorWipe (uint32_t color, int wait) {for (int i = 0; i strip.setPixelColor (i, color); // Establecer el color del píxel (en RAM) strip.show (); // Actualizar la tira para que coincida con el retraso (esperar); // Pausa por un momento}} // Luces de persecución estilo marquesina de teatro. Pase un color (valor de 32 bits, // a la tira. Color (r, g, b) como se mencionó anteriormente), y un tiempo de retardo (en ms) // entre fotogramas. void theaterChase (uint32_t color, int esperar) {for (int a = 0; a <10; a ++) {// Repetir 10 veces… for (int b = 0; b <3; b ++) {// 'b' cuenta de 0 a 2 … strip.clear (); // Establecer todos los píxeles en la RAM en 0 (desactivado) // 'c' cuenta desde 'b' hasta el final de strip en pasos de 3… for (int c = b; c strip.setPixelColor (c, color); // Establece el píxel 'c' en el valor 'color'} strip.show (); // Actualiza la tira con el nuevo retraso de contenido (espera); // Pausa por un momento}}} // Ciclo del arco iris a lo largo de toda la franja. Pasar el tiempo de retardo (en ms) entre fotogramas. arco iris void (espera int) {// El tono del primer píxel ejecuta 5 bucles completos a través del rueda de color. // La rueda de color tiene un rango de 65536 pero es Está bien si pasamos, entonces // solo cuenta de 0 a 5 * 65536. Agregar 256 a firstPixelHue cada vez // significa que haremos 5 * 65536/256 = 1280 pases a través de este bucle externo: for (long firstPixelHue = 0; firstPixelHue <5 * 65536; firstPixelHue + = 256) {for (int i = 0; I // Desplazar el tono del píxel en una cantidad para hacer una revolución completa de la // rueda de color (rango de 65536) a lo largo de la tira // (pasos de strip.numPixels ()): int pixelHue = firstPixelHue + (i * 65536L / strip.numPixels ()); // strip. ColorHSV () puede tomar 1 o 3 argumentos: un tono (0 a 65535) u // opcionalmente agregar saturación y valor (brillo) (cada uno de 0 a 255). // Aquí estamos usando solo la variante de tono de un solo argumento. El resultado // se pasa a través de strip.gamma32 () para proporcionar colores 'más verdaderos' // antes de asignar a cada píxel: strip.setPixelColor (i, strip.gamma32 (strip. ColorHSV (pixelHue)));} strip.show (); // Actualización de la tira con nuevo contenido delay (espera); // Pausa por un momento}} // Marquesina de teatro mejorada con arcoíris. Tiempo de retardo de paso (en ms) entre fotogramas. void theaterChaseRainbow (int espera) {i nt firstPixelHue = 0; // El primer píxel comienza en rojo (tono 0) para (int a = 0; a <30; a ++) {// Repetir 30 veces… para (int b = 0; b RGB strip.setPixelColor (c, color); / / Establecer el píxel 'c' en el valor 'color'} strip.show (); // Actualizar la tira con nuevo contenido delay (esperar); // Pausar por un momento firstPixelHue + = 65536/90; // Un ciclo de rueda de color más de 90 fotogramas}}}

Paso 14: Código de muestra de SHU

Nuestro código enciende todos los Leds uno por uno para asegurarse de que funcionan:

// Este ejemplo alternará entre mostrar 500 píxeles como rojo

#includeconst uint16_t PixelCount = 500; // este ejemplo asume 4 píxeles, hacerlo más pequeño causará una falla const uint8_t PixelPin = 13; // asegúrese de establecer esto en el pin correcto, ignorado para Esp8266

#define colorSaturation 128 // píxeles de tres elementos, en diferente orden y velocidades

Tira NeoPixelBus (PixelCount, PixelPin);

// Tira de NeoPixelBus (PixelCount, PixelPin); RgbColor rojo (0, colorSaturación, 0); RgbColor green (colorSaturation, 0, 0); RgbColor azul (0, 0, colorSaturación); RgbColor blanco (colorSaturation); RgbColor negro (0); HslColor hslRed (rojo); HslColor hslGreen (verde); HslColor hslBlue (azul); HslColor hslWhite (blanco); HslColor hslBlack (negro); void setup () {Serial.begin (115200) while (! Serial); // espera a que se conecte el serial Serial.println (); Serial.println ("Inicializando …"); Serial.flush (); // esto restablece todos los neopíxeles a un estado fuera de banda. Begin (); strip. Show (); Serial.println (); Serial.println ("Ejecutando…"); } bucle vacío () {retraso (100); Serial.println ("Colores R, G, B, W …"); for (int i = 0; i <= 499; i ++) {// establece los colores, // si no coinciden en orden, necesitas usar NeoGrbFeature feature strip. SetPixelColor (i, red); strip. Show (); retraso (100); strip. SetPixelColor (i, hslRed); strip. Show (); retraso (100); }}

Paso 15: carga de código al ESP32

Importante:

Para poder cargar el código en cualquier microcontrolador, debe estar en modo de programación. La mayoría lo hace automáticamente y todo lo que tiene que hacer es hacer clic en cargar en el software.

Nuestro ESP32 requiere que mantenga presionado el botón de programación mientras se envía el código. También debe restablecerlo después de que se cargue el código presionando una vez el botón de reinicio.

El botón de programación de nuestro ESP32 se encuentra a la izquierda, el botón de reinicio a la derecha. Consulte su manual si tiene otro microcontrolador.

Paso 16: Citas

Este instructable se realizó con la ayuda de los siguientes tutoriales:

randomnerdtutorials.com/installing-the-esp…

Se utiliza para instalar el ESP32 en Arduino IDE.

Autores:

Nathaniel Barone como Gabriel Castro

Editor:

Cedric Bleimling