Controla luces de Halloween con ESP32 y batería

En este tutorial aprenderás cómo hacer funcionar un ESP32 lite con baterías usando el modo deep-sleep para controlar luces de Halloween. Y para hacerlo realmente genial, usaremos esto para darle a una calavera de Halloween un par de ojos rojos brillantes y aterradores 😉

Como parte de este proyecto aprenderás sobre la placa de desarrollo Lolin32 lite, el modo deep-sleep para conservar la batería y cómo crear algunos efectos de iluminación simples con LEDs.

Vamos a divertirnos.

Piezas necesarias

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

A continuación encontrarás los componentes necesarios para construir el proyecto. Para este proyecto estoy usando una placa ESP32 antigua, que ha sido descontinuada pero aún puedes conseguirla a muy bajo precio. Es la que se lista abajo. Hay un modelo sucesor con especificaciones mejoradas, que puedes encontrar here. No lo he probado personalmente pero debería funcionar igual.

Además, la calavera que usé es diferente de la que listé abajo. Creo que la que está abajo se ve mejor pero es un poco más pequeña. Sin embargo, probé y la placa y la batería encajan muy bien.

Finalmente, todas las baterías LiPo 903052 que pude encontrar tienen el conector incorrecto. Así que las que sugiero abajo son las que usé. Tendrás que cortar el conector y reemplazarlo por un conector JST PH de 2 pines y 2.0mm. Pero me gusta el factor de forma de estas baterías ya que tienen casi las mismas dimensiones que la placa ESP32.

Conectando las piezas

Queremos construir una calavera de Halloween con un par de ojos rojos brillantes. Para los ojos usamos dos LEDs rojos. Además, queremos que esos ojos parpadeen o muestren algún otro efecto. Lo que significa que necesitaremos un microcontrolador.

La imagen abajo te muestra cómo conectar esas piezas.

Breadboard wiring of the ESP32 and the LEDs — Conectando LEDs al ESP32

Como puedes ver, es muy simple. Conectamos el pin GND de la placa ESP32 con un cable azul a los cátodos de los dos LEDs (que son los pines más cortos). Los ánodos (los pines más largos) de los LEDs están conectados a los pines 16 y 17 a través de una resistencia de 68Ω (cable morado y verde).

No importa mucho qué LED conectes a qué pin de la placa. Solo asegúrate de saber cuál LED será el ojo derecho y cuál el izquierdo.

Por ahora, usamos el puerto USB para programar y alimentar. Así que no es necesario conectar la batería.

Escribiendo el software

En esta sección, te mostraré cómo implementar el software de control para los LEDs. Buscamos el siguiente efecto:

una fase de 5 segundos donde los ojos/LEDs se oscurecen lentamente con un parpadeo aleatorio al final
seguida de otra fase de 5 segundos donde los LEDs están completamente apagados.

Queremos dar la impresión de que la calavera de repente despierta, te mira con ojos rojos brillantes y luego se adormece lentamente hasta dormir un rato.

Si eres completamente nuevo en el mundo Arduino, tal vez eches un vistazo a nuestro tutorial How To Blink An LED Using Arduino primero. De lo contrario, solo echa un vistazo rápido al código abajo. Explicaré los detalles en las siguientes secciones.

const int ledPin1 = 16;
const int ledPin2 = 17;

const int ts_ms = 10;               
const int dozingoff_ms = 5000;      
const uint64_t sleeping_ms = 5000;  

void set_brightness(int brightness) {
  analogWrite(ledPin1, brightness);
  analogWrite(ledPin2, brightness);
}

int effect(int t) {
  long flutter = random(0, 30);
  int brightness = 255 * (dozingoff_ms - t) / dozingoff_ms;
  return brightness < 150 ? brightness + flutter : brightness;
}

void dozingoff() {
  for (int t = 0; t < dozingoff_ms / ts_ms; t++) {
    delay(ts_ms);
    int brightness = effect(t * ts_ms);
    set_brightness(brightness);
  }
}

void sleeping() {
  esp_sleep_enable_timer_wakeup(sleeping_ms * 1000);
  esp_deep_sleep_start();
}

void setup() {
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);
}

void loop() {
  dozingoff();
  sleeping();
}

Constantes

Comenzamos definiendo algunas constantes. ledPin1 y ledPin2 son obviamente los pines donde están conectados los LEDs.

const int ledPin1 = 16;
const int ledPin2 = 17;

const int ts_ms = 10;               
const int dozingoff_ms = 5000;      
const uint64_t sleeping_ms = 5000;

Después, tenemos algunas constantes de tiempo. Usamos estas para regular cuánto duran las fases de adormecimiento y de sueño. Estos tiempos están en milisegundos (ms), así que 5000ms son 5 segundos.

Puedes cambiar estas constantes como quieras para hacer las dos fases más cortas o más largas. Haz dozingoff_ms más grande si quieres un adormecimiento más lento. Y haz sleeping_ms más grande si quieres una fase de sueño más larga.

Hablaremos del paso de tiempo ts_ms más adelante.

Funciones auxiliares

Luego implementamos algunas funciones auxiliares útiles para mantener el código bien estructurado y legible. Usamos la función set_brightness() para ajustar el brillo de los dos LEDs. Donde analogWrite() hace el trabajo real.

void set_brightness(int brightness) {
  analogWrite(ledPin1, brightness);
  analogWrite(ledPin2, brightness);
}

Ten en cuenta que necesitaremos un pin que soporte Modulación por Ancho de Pulso (PWM) para que analogWrite() funcione. Para la placa ESP32 que usamos aquí eso no es problema. Los pines 16 y 17 son pines PWM y casi todos los pines de esa placa también. Mira el diagrama de pines en Pinout de la placa ESP32.

El parámetro brightness será un valor entre 0 y 255, donde 255 significa brillo máximo.

Para crear el efecto de adormecimiento, implementamos una función llamada effect(). Sorpresa, sorpresa. Toma un paso de tiempo t como parámetro y con el tiempo disminuye el brillo del LED de 255 a 0. Para hacerlo más interesante, añadimos un parpadeo aleatorio a mitad del adormecimiento. Esto dará la impresión de que la calavera lucha contra el sueño con párpados temblorosos. Sé que las calaveras no tienen párpados, pero bueno…

int effect(int t) {
  long flutter = random(0, 30);
  int brightness = 255 * (dozingoff_ms - t) / dozingoff_ms;
  return brightness < 150 ? brightness + flutter : brightness;
}

Espero que el siguiente diagrama aclare cómo funciona esto en detalle.

Diagram of the dozing-off and sleeping phases that regulate the LED brightness

Función de adormecimiento

Vamos a usar la función effect() dentro de la función dozingoff() que se muestra abajo. Esta función simplemente itera sobre los pasos de tiempo de longitud ts_ms, calcula el brillo mediante la función effect() y luego ajusta el brillo del LED en consecuencia.

void dozingoff() {
  for (int t = 0; t < dozingoff_ms / ts_ms; t++) {
    delay(ts_ms);
    int brightness = effect(t * ts_ms);
    set_brightness(brightness);
  }
}

Puedes cambiar la longitud de los pasos de tiempo, lo que resultará en un efecto más suave o más grueso. Elegí 10ms, que funciona bien. Puedes ahorrar batería haciéndolo más largo, pero la animación no será tan suave.

Función de sueño

Para hacer que la cabeza duerma, podríamos simplemente poner el brillo de los LEDs a cero y luego esperar la duración de la fase de sueño. El código abajo hace exactamente eso.

void sleeping() {
  set_brightness(0);
  delay(sleeping_ms);
}

Sin embargo, desperdiciaríamos batería valiosa, ya que el microprocesador sigue funcionando sin hacer nada durante la fase de sueño. En cambio, ponemos el microprocesador en modo deep-sleep mode deep-sleep, donde consume mucho menos energía. El código abajo muestra cómo se hace.

void sleeping() {
  esp_sleep_enable_timer_wakeup(sleeping_ms * 1000);
  esp_deep_sleep_start();
}

Primero, especificamos cómo queremos despertar. Hay diferentes formas de hacerlo, pero aquí configuramos un temporizador con esp_sleep_enable_timer_wakeup (). Toma el tiempo de sueño en microsegundos. Por eso necesitamos multiplicar sleeping_ms por 1000.

Y en la segunda línea simplemente iniciamos el modo deep sleep llamando a esp_deep_sleep_start(). Ten en cuenta que esto significa que la función setup y loop se ejecutarán, luego la placa se dormirá, despertará y repetirá el ciclo, comenzando por llamar a setup.

Función setup

Nuestra configuración es muy simple. Solo ponemos los pines que controlan los LEDs en modo salida. Listo.

void setup() {
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);
}

Función loop

Y gracias a nuestras funciones auxiliares, la función loop también es muy simple. Nos adormecemos, luego dormimos y eso es todo.

void loop() {
  dozingoff();
  sleeping();
}

Sin embargo, ten en cuenta que la función loop solo se ejecutará una vez, ya que entramos en modo deep-sleep al dormir y luego se reinicia la placa al despertar.

Ahorro de energía

Queremos que nuestra calavera aterradora funcione con baterías. Y la pregunta obvia es, ¿cuánto tiempo funcionará y cuánto ayuda el modo deep-sleep?

Estoy usando una batería LiPo de 1200mAh . Y medí la corriente durante la fase de adormecimiento (LEDs encendidos) como 50mA. En deep-sleep la placa consume solo 0.054mA y si uso delay() en su lugar, el consumo sube a 39mA . Ahora, hagamos las cuentas.

Primero, convertimos la capacidad de la batería a Coulomb:

1200mA x 3600s = 4320000mC

Para la fase de adormecimiento, cuando la placa está despierta 5 segundos, consumimos

50mA x 5s = 250mC

Durante los 5 segundos en modo deep sleep, sin embargo, consumimos solo

0.054mA x 5s = 0.27mC

En total, consumimos 250mC + 0.27mC = 250.27mC cada 10 segundos.

Por lo tanto, obtenemos un tiempo de funcionamiento continuo de aproximadamente

10s * 4320000mC / 250.27mC ≈ 17263s ≈ 48 horas = 2 días

Si no usamos el modo deep-sleep ese tiempo se reduce a la mitad. Si quieres aumentar el tiempo de funcionamiento, haz la fase de sueño más larga (o la de adormecimiento más corta). O usa una batería más grande, claro.

Pinout de la placa ESP32

En esta sección, quiero destacar algunos aspectos específicos de la placa Lolin32 lite que usamos para este proyecto. Encontrarás el pinout abajo.

Pinout of the Lolin32 lite development board — Lolin32 lite

Esta placa es especialmente adecuada para proyectos con batería, ya que tiene un conector para batería y un circuito de carga con corriente máxima de 500mA. Esto significa que puedes conectar una batería LiPo a la placa, hacerla funcionar con batería y cargarla vía el puerto USB. ¡Muy bien!

Además, las corrientes en deep sleep son bastante bajas. La especificación dice 125mA con WiFi encendido y 45mA con WiFi apagado, que es lo que medí aproximadamente también.

Sin batería conectada, y la placa alimentada por USB, verás un parpadeo continuo del LED de carga. ¡Esto es normal! Si conectas una batería el parpadeo se detendrá. Si la batería está cargando, el LED estará azul fijo y se apagará cuando esté completamente cargada.

Ten en cuenta que la placa opera con un nivel lógico de 3.3V. Así que no todos los módulos que consigues para Arduino funcionarán necesariamente con esta placa, ya que Arduino funciona a 5V.

Finalmente, una advertencia. El conector de la batería es un conector JST PH de 2 pines y 2.0mm. Pero la mayoría de las baterías con este conector tienen polaridad invertida. Mira cuidadosamente las marcas en la placa. En la imagen arriba el pin positivo está a la izquierda. Asegúrate de que el cable rojo de la batería se conecte al pin positivo. Tuve que cortar y revertir el conector en mi batería.

Cableado de la calavera de Halloween

Aunque la protoboard es genial para probar el circuito, no cabrá dentro de la calavera. Una vez que confirmes que todo funciona, tendrás que soldar los cables a la placa y a los LEDs. Así es como quedó mi cableado

Inside of the Halloween skull and its LED eyes

La calavera que compré no tenía tapa removible. Así que tuve que cortar la base y hacer dos agujeros para los ojos. También la repinté y le añadí algo de envejecido. Pero estoy muy contento con el resultado final

Especialmente después de que todo está bien guardado:

Another Halloween skull with red glowing eyes

Conclusión

En este artículo, hemos explorado cómo controlar luces de Halloween usando un Lolin32 lite con batería. Comenzamos listando las piezas necesarias, incluyendo la placa LoLin32 Lite, que es una gran opción para proyectos con batería. Luego discutimos el proceso de conectar las piezas y cablear los LEDs para la calavera de Halloween.

Después, escribimos el software para el ESP32, que implicó programarlo para controlar las luces y entrar en modo deep sleep para conservar la batería. Esto permite que las luces funcionen por un período prolongado sin necesidad de alimentación constante.

En general, este proyecto ofrece una forma divertida y creativa de añadir un toque espeluznante a tus decoraciones de Halloween. Usando el ESP32 y algunos componentes simples, puedes controlar fácilmente tus luces de Halloween y crear una experiencia memorable para los que piden dulces.

Por supuesto, podríamos hacer mucho más. Añadir un sensor PIR o radar para encender las luces solo cuando se detecte una persona. O añadir un módulo de sonido y más efectos de iluminación, o controlar la calavera vía Wi-Fi. Las posibilidades son infinitas.

Si tienes alguna pregunta o encuentras algún problema mientras trabajas en este proyecto, por favor consulta la sección de Preguntas Frecuentes abajo para más orientación.

Preguntas Frecuentes

Aquí tienes algunas preguntas comunes sobre el control de LEDs usando ESP32 con batería:

P: ¿Puedo usar cualquier placa ESP32 para este proyecto?

R: Sí, puedes usar cualquier placa ESP32 para este proyecto. Sin embargo, en este post usamos específicamente la placa LoLin32 Lite, ya que es fácil de usar con batería.

P: ¿Cuánto durará la batería?

R: La duración de la batería dependerá de varios factores, como la capacidad de la batería, el consumo de las luces y la duración del sueño del ESP32. Se recomienda usar una batería de alta capacidad y optimizar el código para minimizar el consumo y prolongar la vida de la batería. Consulta los cálculos arriba.

Para formas más avanzadas de ahorrar energía, echa un vistazo a este excelente post: ESP32: Tips to increase battery life.

P: ¿Puedo usar luces diferentes en lugar de la calavera de Halloween?

R: ¡Por supuesto! Puedes usar cualquier tipo de luces que prefieras. El cableado y el código pueden variar según las luces que elijas, pero el concepto general es el mismo. Una buena idea sería usar LEDs RGB para tener efectos de color.

P: ¿Es posible controlar varios juegos de luces con un solo ESP32?

R: Sí, es posible controlar más luces con un solo ESP32. Puedes conectar varias luces en paralelo o usar un multiplexor para controlarlas individualmente. Sin embargo, ten en cuenta que el consumo de energía aumentará, afectando la duración de la batería.

P: ¿Puedo modificar el código para añadir más funciones?

R: ¡Definitivamente! El código proporcionado en este post es un ejemplo básico para que comiences. Puedes modificarlo y ampliarlo para añadir más funciones, como diferentes patrones de iluminación, control remoto o integración con otros dispositivos inteligentes del hogar.

P: ¿Puedo alimentar el ESP32 usando un cable USB en lugar de una batería?

R: Sí, puedes alimentar el ESP32 con un cable USB en lugar de una batería. Sin embargo, el propósito de este proyecto es hacerlo portátil e inalámbrico usando una batería. Si prefieres una configuración con cable, puedes conectar el ESP32 a una fuente de alimentación vía USB.

Enlaces

Algunos enlaces útiles con información adicional se listan a continuación.

Stefan Maetschke