Teatro de Sombras Navideño DIY: Espectáculo de Luces con Arduino y Tira LED Direccionable

Componentes y materiales

• 1x Arduino 101 (con Bluetooth integrado)
• 1x Tira LED RGB direccionable (SparkFun u otra compatible)
• 1x Adaptador Jack Barrel Macho (SparkFun)
• 1x Adaptador Jack Barrel Hembra (SparkFun)
• 1x Portapilas 3xAA con interruptor (SparkFun)
• 3x Pilas AA (genéricas)
• 1x Regulador Step-Up 12V (Pololu) para alimentar Arduino 101 con las mismas pilas que la tira LED
• 4x Hojas papel impresora 8.5x11"
• 4x Hojas cartulina 100lb 8.5x11"
• 1x Plancha Foam Core blanco 3/16", suficiente para cuatro piezas 8.5x11"

Herramientas necesarias

• Pistola de silicona caliente
• Soldador
• Cúter X-Acto
• Cuchillas de repuesto #11
• Pelacables 12-20 AWG
• Impresora (que imprima en cartulina)
• Destornillador pequeño para terminales jack barrel

Aplicaciones y servicios online

• Arduino IDE
• Blynk (app control remoto)
• Librería Adafruit NeoPixel

Sobre el proyecto

Visión general

Este proyecto usa un Arduino 101, una tira de LEDs direccionables, foam core y cartulina para crear un Teatro de Sombras animado y controlable desde el móvil. La electrónica se usa de forma no destructiva, así que puedes reutilizarla después. Aquí tienes una wishlist de SparkFun con el 99% de la electrónica.

Cómo funciona:

Una tira de LEDs direccionables se enrolla sobre una pieza de foam core en el centro del teatro. Los LEDs de abajo se encienden en secuencia y brillan a través de agujeritos para crear una sombra animada (nieve cayendo). Los LEDs de arriba se canalizan hacia los edificios superiores, y el último LED de la tira ilumina toda la escena, creando la sombra principal.

El Arduino 101 tiene radio Bluetooth integrada, y uso la app de prototipado rápido Blynk para control remoto. En el código de ejemplo puedes controlar colores en los edificios, activar fuego parpadeante y ajustar brillo de la luz principal.

Parte 1: Electrónica

1. Paso 1: Corta el arnés final de la tira LED dejando ~1 cm. Pela los extremos.
2. Paso 2: Separa los pines header doblados que vienen con el regulador de voltaje y suelda dos a los cables verde y amarillo. Así podrás enchufarlos directo a los pines del Arduino 101.
3. Paso 3: Suelda el cable rojo al terminal VIN del regulador, y dos headers rectos en GND y VOUT.
4. Paso 4: Conecta los adaptadores jack barrel. Pela los cables del portapilas y móntalos en el jack macho: ROJO a (+), NEGRO a (-). Luego conecta el jack hembra a los cables sueltos del inicio de la tira LED: AMARILLO a (-), ROJO a (+).
5. Paso 5: Conecta el arnés al Arduino 101: VERDE a PIN 6, AMARILLO a GND (cerca del pin 13). Del regulador: GND a GND, VOUT a pin "Vin" del Arduino 101. ¡No lo inviertas! Conectar al revés huele a quemado y humea. Lo sé por experiencia.

Parte 2: Escenario de Foam Core

1. Imprime los patrones de foam core en papel normal (4 hojas) y los de cartulina en cartulina (4 hojas).
2. Paso 1: Recorta las piezas de foam core usando los patrones. Puedes poner el patrón encima y trazar ligeramente con el cúter para transferir las líneas.
3. Paso 2: Ensambla el soporte de la tira LED como se muestra. Pega el primer LED en la base con cinta o silicona y enrolla la tira como en las fotos. No hace falta que sea muy apretado. Tras 3 vueltas, deja el extremo libre y fija la parte superior.
4. Paso 3: ¡Importante! Cuenta tus LEDs y haz un mapa de referencia. Los LEDs por debajo del pliegue brillarán hacia atrás para animación (ej. en mi caso: 0,1,2, 20,21,22, 40,41,42). Dos LEDs en la zona superior iluminan las casas: uso LED 23 para la casa trasera y 25 para simular fuego en las delanteras. Empieza a contar desde cero al inicio de la tira.
5. Paso 4: Pega el soporte LED en la base de foam core, centrado longitudinalmente. Añade las piezas laterales curvas con silicona.
6. Paso 5: Añade los divisores de luz y la tapa superior. Los divisores evitan que la luz de animación se filtre a las casas y viceversa. Coloca el divisor grande cerca del pliegue del soporte LED, y el pequeño encima dejando al menos un LED entre ellos. Pon la tapa superior cuadrada con la base y fija con silicona.
7. Paso 6: Pega el extremo de la tira LED al borde frontal superior para que el último LED ilumine la escena (LED de sombra principal).

Parte 3: Programar Arduino 101 y configurar Blynk

1. Conecta USB al Arduino 101, y une tira LED, portapilas y Arduino (deja interruptor portapilas en OFF).
2. Necesitas Arduino IDE con núcleo Intel Curie, librería Adafruit NeoPixel y librería Blynk. Si eres nuevo, prueba sketches de ejemplo primero.
3. Paso 1: Instala app Blynk en tu móvil. Es la forma más rápida de controlar Arduino 101 por BLE (aunque aún tiene algunos bugs).
4. Paso 2: Carga el código de ejemplo en Arduino IDE y cambia los números de píxel LED si hace falta usando tu mapa:

   // Luces animación nieve
   int pos[] = {0, 1, 2, 20, 21, 22, 40, 41, 42};
   // Cuántos píxeles animan
   int numLeds = 9;
   // LED sombra principal al final de la tira (en tira 60 LEDs = #59)
   int shadowPixel = 59;
   // Píxel para luces casa trasera (entre los dos divisores)
   int lightHousePixel = 23;
   // Píxel para fuego en casas delanteras (justo delante del divisor pequeño)
   int firePixel = 24;
   

   Compila y sube. Desconecta USB y enciende el portapilas. Deberías ver el shadowPixel encendido y la animación en secuencia. Las luces de casa y fuego estarán apagadas hasta controlarlas con Blynk.
5. Paso 3: Abre app Blynk, pulsa "scan" arriba a la derecha y escanea el código QR del proyecto. La interfaz cargará automáticamente. Debería verse así: 3 sliders (V0 chimenea, V1 luces casa, V2 luz principal) y widget BLE.
6. Paso 4: Conecta por BLE a tu Arduino 101. Toca widget BLE, verás "ShadowTheatre". Conecta y pulsa "play" (flecha arriba derecha). Puede que necesites reconectar tras dormir el móvil.

Parte 4: Siluetas cartulina, edificios y toques finales

1. Recorta la silueta de fondo de las 4 hojas de cartulina con cúter y cuchillas nuevas. ¡Cambia la cuchilla a menudo! Cortar con cuchilla desafilada es frustrante; yo la cambié 3 veces.
2. Recorta piezas de casas y pega las traseras con silicona. Lados impresos hacia atrás para que no se vea tinta desde el frente.
3. Añade las casas al escenario. Cierra huecos para que la luz entre en las casas pero no se escape por los lados.
4. Pliega los laterales de la silueta y pega el borde inferior al borde trasero del escenario con silicona (lado impreso hacia afuera).
5. Recorta una escena de nieve para proyectar en la pared trasera. Usa alfileres, palillos o recorta formas intrincadas. Pégala a los bordes curvos para crear superficie de proyección.
6. Pega hoja lateral izquierda y frontal con silicona. Deja la lateral derecha sujeta con cinta para poder acceder al interruptor del portapilas.

¡Listo! Busca zona oscura con pared cerca para probar. Al encender, debería proyectar la escena con nieve cayendo. Con Blynk controlas luz principal y luces de edificios.

Código

Shadow Theater Arduino Sketch (usa librerías Adafruit NeoPixel y Blynk):

/* Copyright (c) 2016 Intel Corporation. All rights reserved. */
/////////////////////// VARIABLES A CAMBIAR SEGÚN TU MONTAJE ///////////////////////
int pos[] = {0, 1, 2, 20, 21, 22, 40, 41, 42}; // LEDs animación nieve (orden de encendido)
int numLeds = 9; // cuántos píxeles en el array anterior
int shadowPixel = 59; // LED sombra principal al final de la tira
int lightHousePixel = 23; // LED luces casa trasera
int firePixel = 24; // LED fuego parpadeante casas delanteras
/////////////////////////////////////////////////////////////////////////////////////

#include <Adafruit_NeoPixel.h>
#include <BlynkSimpleCurieBLE.h>
#include <CurieBLE.h>
#define PIN 6

int v0 = 0, v1 = 0, v2 = 0; // valores entrantes desde Blynk
int fadeup = 0, fadedown = 0; // suavizado animación
int firetimer = 0, fireinterval = 50, flicker = 0; // parpadeo fuego
unsigned long lightcounter = 0;
int stp = 0, stpOld = 0;
unsigned long timer = 0;
int interval = 0;
char auth[] = "YourAuthToken"; // Token Blynk (no usado en BLE actualmente)

BLEPeripheral blePeripheral;
Adafruit_NeoPixel strip = Adafruit_NeoPixel(60, PIN, NEO_GRB + NEO_KHZ800); // cambia 60 si tu tira tiene más/menos LEDs

void setup() {
  delay(1000);
  timer = millis();
  strip.begin();
  strip.show(); // todos apagados
  blePeripheral.setLocalName("ShadowTheatre");
  blePeripheral.setDeviceName("ShadowTheatre");
  blePeripheral.setAppearance(384);
  Blynk.begin(auth, blePeripheral);
  blePeripheral.begin();
  interval = 350; // intervalo 350ms para animación nieve
}

void loop() {
  Blynk.run();
  blePeripheral.poll();

  // Luz sombra principal controlada por Blynk (V2)
  strip.setPixelColor(shadowPixel, 200 - v2, 160 - v2, 160 - v2);

  // Fuego (V0)
  if ((millis() - firetimer) > fireinterval) {
    firetimer = millis();
    flicker = random(0, 40);
  }
  if (v0 > 1) {
    strip.setPixelColor(firePixel, 80 + v0 + flicker, v0 + flicker, 0);
  } else {
    strip.setPixelColor(firePixel, 0, 0, 0);
  }

  // Luces casa trasera (V1)
  if (v1 > 1) {
    strip.setPixelColor(lightHousePixel, 200 - v1, v1, 0);
  } else {
    strip.setPixelColor(lightHousePixel, 0, 0, 0);
  }

  // Animación nieve
  if ((millis() - timer) > interval) {
    stpOld = stp;
    timer = millis();
    lightcounter++;
    stp = (lightcounter % numLeds);
    fadeup = 0;
    fadedown = 170;
  }
  fadeup += 2; fadeup = constrain(fadeup, 0, 170);
  fadedown -= 2; fadedown = constrain(fadedown, 0, 170);

  for (int i = 0; i < numLeds; i++) strip.setPixelColor(pos[i], 0, 0, 0); // apaga todos
  strip.setPixelColor(pos[stp], fadeup, fadeup, fadeup); // enciende actual con fade-in
  strip.setPixelColor(pos[stpOld], fadedown, fadedown, fadedown); // antiguo con fade-out
  strip.show();
}

// Callbacks Blynk
BLYNK_WRITE(V0) { v0 = param.asInt(); } // Chimenea
BLYNK_WRITE(V1) { v1 = param.asInt(); } // Luces casa
BLYNK_WRITE(V2) { v2 = param.asInt(); } // Luz principal

Esquemáticos y plantillas

• Patrones foam core: imprimir en papel normal (4 hojas) para guiar corte.
• Patrones cartulina: imprimir en cartulina (4 hojas) para casas, laterales, siluetas.
• Archivo SVG para corte láser/vinilo: 30bn6Le68V1Lpp2spRMw.svg