Espejo infinito caleidoscopio DIY: Construye una impresionante pantalla de luces LED

Componentes y suministros

Arduino 101	×1
LEDs direccionables sin sellar 1m (60) Esta versión de Sparkfun viene cableada convenientemente para este proyecto, pero puedes usar NeoPixels de Adafruit o similares.	×1
Tramo corto de cable sólido o pines de puente Para hacer cable trenzado compatible con pines de Arduino.	×1
Tubo termorretráctil Opcional si quieres un acabado más profesional.	×1
Conector hembra jack de barril con terminales de tornillo	×1
Conector macho jack de barril con terminales de tornillo	×1
Portapilas 3x AA con interruptor	×1
Regulador elevador de tensión Pololu Este regulador de $4 permite alimentar todo el proyecto con un solo paquete de 3 pilas AA. Alternativamente, puedes omitir esta pieza y usar una pila de 9V para alimentar el Arduino 101. Si eliges esa ruta, seguirás necesitando el paquete de 3 AA para alimentar las luces. Más info	×1
Pilas AA	×1
Marco para fotos tipo "shadow box" cuadrado de 12" La profundidad y tamaño de este marco son perfectos.	×1
Espejo cuadrado de 12" Encajará en la parte trasera del marco.	×1
Caballete para fotos de 11" Para exhibir el producto terminado.	×1
Film de privacidad espejado (opcional – mejora mucho el efecto, pero no es 100% necesario)	×1
FoamCore Estándar de 3/16" o 1/4". Usé blanco pero el negro también quedaría bien. Necesitas suficiente para hacer una pieza de 12" x 12", más una tira de 1m de largo y 0.5" de ancho.	×1

Herramientas y máquinas necesarias

• Soldador (genérico)
• Cúter con hoja nueva
• Pistola de silicona caliente (genérica)
• Pelacables

Aplicaciones y servicios en línea

• Arduino IDE Necesitas la librería Adafruit NeoPixel para este proyecto. Instrucciones de instalación. Además, si eres nuevo en Arduino 101, necesitarás instalar el Curie Core para acceder a los sensores de posición. Guía Arduino 101

Sobre este proyecto

Un cruce entre un caleidoscopio y un espejo infinito. Al cambiar la rotación del espejo, las luces cambian en respuesta. Este proyecto se construye con un espejo y marco de fotos estándar, y unos pocos componentes más. La placa de desarrollo Arduino 101 tiene sensores de posición integrados que podemos usar para detectar el ángulo y controlar la pantalla de luces.

Nota: Este proyecto usa la misma configuración electrónica que el Teatro de Sombras Navideño, básicamente solo un Arduino 101, una tira LED y un paquete de pilas. Uso un regulador de voltaje de $4 para que el mismo paquete de pilas alimente tanto los LEDs como el Arduino 101. Alternativamente podrías usar una pila de 9V para el Arduino y omitir el regulador.

Parte uno: Construir el espejo

Paso 1: Con un cúter afilado o cuchillo de modelismo, corta un cuadrado de 12" x 12" de FoamCore y marca el centro con lápiz. Puedes usar el cartón trasero del marco como referencia.

Paso 2: Usando una herramienta para dibujar círculos o hilo y lápiz, dibuja un círculo perfecto de radio 5.25" centrado en el cuadrado 12x12. Puedes usar una regla para marcar a 0.75" del borde del 12x12 y usar eso como punto de referencia inicial.

Paso 3: Con cúter o cuchillo de hoja nueva, recorta cuidadosamente el círculo. Este corte será visible en el producto final, así que córtalo lo más limpio posible.

Paso 4: Una vez cortado el agujero, elige el lado mejor aspecto y colócalo con el lado bueno hacia abajo sobre una superficie de trabajo limpia.

Paso 5: Corta una tira separada de FoamCore de ½ pulgada, unos 36" de largo. Puede ensamblarse de segmentos más cortos con cinta si es necesario. Usa regla y mantén el tamaño lo más uniforme posible a 0.5".

Paso 6: Coloca la tira terminada horizontalmente sobre una mesa y haz cortes verticales uniformes a través de la capa superior de papel cada 2" a lo largo de toda la longitud.

Paso 7: Dale la vuelta a la tira y, usando silicona caliente, pega la tira LED a lo largo de la tira de FoamCore.

Paso 8: Dobla la tira terminada en un círculo aproximado usando los cortes que hiciste en la parte trasera del FoamCore como puntos de flexión.

Paso 9: Coloca la tira LED en anillo sobre el agujero de tu cuadrado de 12x12" de FoamCore. La tira completa será demasiado larga. Ajusta el círculo LED para que sea ligeramente mayor que el agujero y corta los LEDs sobrantes (unos 6 LEDs). Puedes guardar estos LEDs de repuesto para otro proyecto.

Paso 10: Coloca la tira LED en anillo sobre la superficie superior (lado malo) de tu cuadrado 12x12", y pégala con silicona caliente justo en el borde del agujero circular. Asegúrate de que la parte trasera del anillo LED esté al menos 0.25" dentro del borde del cuadrado 12x12". (De lo contrario, los separadores negros del marco no encajarán alrededor.)

Paso 11: Si usas la película semiespejo, saca el cristal del marco shadowbox y aplica la película siguiendo las instrucciones del fabricante. Este fue el paso más delicado. Asegúrate de limpiar bien el cristal y usa agua (o solución jabonosa) para facilitar la eliminación de burbujas de aire. La película espejo crea una ilusión mucho más fuerte y oculta los LEDs, pero no es 100% necesaria (¡y puedes añadirla después si lo deseas!). Si usas película, vuelve a colocar el cristal en el marco con el lado de la película hacia arriba/hacia el interior del marco.

Paso 12: Con el marco boca abajo y el cristal limpio, coloca el FoamCore encima del cristal, con el lado bueno hacia abajo y el anillo LED hacia arriba. Añade dos de los separadores que venían en el marco, luego coloca tu espejo de 12x12" boca abajo. Los cables del LED deben salir por la parte trasera del marco más allá del espejo. Si el espejo queda demasiado ajustado para los cables, puede que necesites tallar cuidadosamente una muesca para los cables en el borde del marco con cúter o cuchillo.

Si hay espacio, añade el cartón trasero del marco, o si no, sujeta el espejo con las pestañas del marco. ¡Eso es todo! Ahora viene la magia de la electrónica.

Parte dos: Configurar la electrónica

Paso 1 Recoge los 6 LEDs extra que cortaste al final anteriormente. Corta el mazo de cables del extremo, dejando unos 1 cm de cable desde las luces. Pela los extremos de los cables.

Paso 2 Separa los pines de header doblados que venían con tu regulador de voltaje, y suelda dos de ellos a los extremos de los cables verde y amarillo. Esto te permitirá enchufarlos fácilmente en los pines del Arduino 101.

Paso 3 A continuación, suelda el cable rojo al terminal VIN del Regulador de Voltaje, y suelda dos headers rectos en los pines GND y VOUT como se muestra.

Paso 4 Ahora conecta los adaptadores jack de barril. Primela los extremos de los cables que vienen de tu portapilas, luego móntalos en los terminales del jack macho y aprieta con destornillador. ROJO al terminal (+), NEGRO al terminal (-).

Luego conecta el adaptador jack hembra a los cables sueltos que vienen del principio de la tira LED (que salen de la parte trasera de tu espejo). En esta tira, AMARILLO va al terminal (-), y ROJO al (+).

Paso 5 Ahora conecta tu mazo al Arduino 101. El cable VERDE va al PIN 6, el cable AMARILLO al pin GND cerca del #13.

Con los dos pines de header en el regulador de voltaje, GND va a GND y VOUT al pin "Vin" del Arduino 101. ¡No te equivoques! Conectarlo al revés genera olores y quemaduras. Lo sé por experiencia.

Paso 6: Conecta los mazos de cables en el Arduino 101 y la tira LED, luego conecta el jack del portapilas al jack de la tira LED y ¡estás cableado!

Paso 7: Ahora que tu electrónica está lista, coloca el Arduino 101 en la parte trasera del espejo con su orientación paralela a cualquier lado del espejo. Sujétalo con velcro, cinta de doble cara o silicona caliente. Monta el portapilas cerca y asegura los cables sueltos con cinta o pegamento.

Sube el código de ejemplo usando un ordenador, un cable USB y el Arduino IDE. Alternativamente, puedes acceder, editar y subir el código de ejemplo usando el IDE web de Arduino.

¡Pruébalo!

El código de ejemplo cambia los colores de los LEDs según el ángulo del espejo, leído desde el acelerómetro en el Módulo de Cómputo Intel Curie. Actualmente, una posición apaga todas las luces, y un ángulo crea un efecto de luz perseguidora con el último color usado. Siéntete libre de modificar el código y crear efectos de iluminación locos. La excelente Guía Uber de Adafruit NeoPixel es un buen punto de partida.

¡IMPORTANTE! Si quieres instalar este espejo permanentemente, puedes usar una fuente de alimentación enchufable en lugar del paquete de pilas, pero asegúrate de que entregue 3.5V - 5V. ¡Cualquier voltaje superior (como una pila cuadrada de 9V) puede sobrecargar la tira LED!

Código

Sketch Espejo Infinito Arduino 101 Arduino

/* Copyright (c) 2016 Intel Corporation. Todos los derechos reservados. Ver aviso de licencia al final del archivo.
 Arduino 101 "Espejo Infinito". El ángulo de rotación del Arduino 101 cambia las luces en una tira Neopixel.
 Este código usa la librería Adafruit Neopixel. Instrucciones de instalación: https://learn.adafruit.com/adafruit-neopixel-uberguide/arduino-library-installation
 Si usas la versión de escritorio del Arduino IDE, asegúrate de tener el último Intel Curie Core instalado. Más info: https://www.arduino.cc/en/Guide/Arduino101 */
#include "CurieIMU.h"
#include <Adafruit_NeoPixel.h>
#define PIN 6 // ¿a qué pin están conectados los NeoPixels?
Adafruit_NeoPixel strip = Adafruit_NeoPixel(54, PIN, NEO_GRB + NEO_KHZ800); /// la tira tiene 15 píxeles. Puedes cambiar esto según el número de píxeles de tu tira.
int tr = 0; // Variables para "color-objetivo" y "color-actual" para suavizado...
int tg = 0;
int tb = 0;
int r = 0;
int g = 0;
int b = 0;
int rawX = 0; ///// para valores del acelerómetro Curie
int rawY = 0;
//int rawZ = 0;
float angle = 0.0;
void setup() {
  //Serial.begin(9600); //para depuración.
  CurieIMU.begin();
  CurieIMU.setAccelerometerRange(2); // Rango del acelerómetro a 2g.
  strip.begin(); // inicializar tira neopixel
  strip.show(); // Inicializar todos los píxeles a 'apagado'
}
void loop() {
  // leer acelerómetro:
  int rawX = CurieIMU.readAccelerometer(X_AXIS);
  int rawY = CurieIMU.readAccelerometer(Y_AXIS);
  int rawZ = CurieIMU.readAccelerometer(Z_AXIS);
  angle = atan2(rawX, rawY); // atan2() convierte fuerzas x e y en ángulo en radianes. ¡Genial! Salida -3.14 a 3.14
  if (abs(angle) > 2.5) { // pines digitales hacia abajo
    /// apagar luces en esta posición
    tr = 0; tg = 0; tb = 0;
    runlights();
  }
  if ((angle > 1.5) && (angle < 2.5)) { // luces blancas en esta posición (r, g, b iguales). Valores hasta 255, pero 100 es suficiente.
    tr = 100; tg = 100; tb = 100;
    runlights();
  } else if ((angle < 1.5) && (angle > 0.5)) { // luces rojas
    tr = 100; tg = 0; tb = 0;
    runlights();
  } else if ((angle < 0.5) && (angle > -0.5)) { // luces verdes
    tr = 0; tg = 100; tb = 0;
    runlights();
  } else if ((angle < -1.5) && (angle > -2.5)) { // luces azules
    tr = 0; tg = 0; tb = 100;
    runlights();
  } else if ((angle < -0.5) && (angle > -1.5)) { //// un ángulo de esquina para algo divertido!
    theaterChase(); /// estas funciones están al final del sketch.
    //rainbowCycle(2);
  } else { //// en caso de ángulo inesperado, apagar luces.
    tr = 0; tg = 0; tb = 0;
    runlights();
  }
}
void runlights() {
  /// suavizado de color. El color actual se mueve hacia el objetivo...
  if (tr > r + 1) { r++; }
  if (tg > g + 1) { g++; }
  if (tb > b + 1) { b++; }
  if (tr < r) { r--; }
  if (tg < g) { g--; }
  if (tb < b) { b--; }
  // poner todos los LEDS al color actual r, g, b.
  for (int i = 0; i < strip.numPixels(); i++) {
    strip.setPixelColor(i, r, g, b);
  }
  strip.show();
  delay(10); // retraso para temporización de fundido simple.
}
/////////////////Funciones de luz especiales del código de ejemplo Adafruit Strandtest
// ¡Arcoíris! Nota- esta función bloquea nuevas entradas de posición hasta que termina.
void rainbowCycle(uint8_t wait) {
  uint16_t i, j;
  for(j=0; j<256*5; j++) { // 5 ciclos de todos los colores en la rueda
    for(i=0; i< strip.numPixels(); i++) {
      strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));
    }
    strip.show();
    delay(wait);
  }
}
//////Persecución teatral (Theater Chase) del código de ejemplo Adafruit strandtest. Toma el valor RGB actual y hace un efecto "theatre chase".
void theaterChase(){
  for (int j = 0; j < 3; j++) { //3 ciclos de persecución
    for (int q = 0; q < 3; q++) {
      for (uint16_t i = 0; i < strip.numPixels(); i = i + 3) {
        strip.setPixelColor(i + q, r, g, b); //encender cada tercer píxel
      }
      strip.show();
      delay(50);
      for (uint16_t i = 0; i < strip.numPixels(); i = i + 3) {
        strip.setPixelColor(i + q, 0); //apagar cada tercer píxel
      }
    }
  }
}
// Entrada valor 0-255 para obtener valor de color. Usado para efecto arcoíris.
// Los colores son transición r - g - b - vuelta a r.
uint32_t Wheel(byte WheelPos) {
  WheelPos = 255 - WheelPos;
  if(WheelPos < 85) {
    return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  }
  if(WheelPos < 170) {
    WheelPos -= 85;
    return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
  WheelPos -= 170;
  return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}
////////////////////////////////////////////////////////////////////////////////////////////
/* Esta librería es software libre; puedes redistribuirla y/o modificarla bajo los términos de la Licencia Pública General Menor de GNU publicada por la Free Software Foundation; ya sea la versión 2.1 de la Licencia, o (a tu elección) cualquier versión posterior.
Esta librería se distribuye con la esperanza de que sea útil, pero SIN NINGUNA GARANTÍA; sin siquiera la garantía implícita de COMERCIABILIDAD o IDONEIDAD PARA UN PROPÓSITO PARTICULAR. Ver la Licencia Pública General Menor de GNU para más detalles.
Deberías haber recibido una copia de la Licencia Pública General Menor de GNU junto con esta librería; si no, escribe a Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */