Lámparas de fibra óptica impresas en lienzo: 5 pasos

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

Este proyecto agrega un giro único a una impresión de lienzo estándar. Progré en 4 modos de iluminación diferentes, pero fácilmente podrías agregar más. El modo se cambia cada vez que lo apaga y vuelve a encender en lugar de tener un botón separado para minimizar el daño al marco. Las baterías deberían durar más de 50 horas de uso; no estoy muy seguro, pero hice un proyecto similar para un amigo y usó 5 veces más luces y ha durado más de 20 horas con un solo juego de baterías.

Materiales

• Impresión de lienzo con espacio viable: pedí la mía en https://www.easycanvasprints.com porque tenían buenos precios y una parte trasera abierta. El marco más grueso de 1.5 "era perfecto y me dio mucho espacio para doblar los hilos de fibra óptica. Además, desea una imagen que le brinde 3" por 8 "de espacio útil para la batería, el microcontrolador y las tiras de LED
• Tiras de luces LED: utilicé tiras de LED direccionables WS2812. No se deje intimidar, ¡son realmente fáciles de usar con las bibliotecas FastLED o Neopixel! También puede usar cualquier tira de LED estándar, simplemente no podrá controlar cada sección de luz individualmente sin mucho más cableado.
• Microcontrolador: utilicé un Arduino Uno, pero puedes usar casi cualquier cosa para este proyecto.
• Paquete de baterías: pedí este en eBay (de China) y se titulaba "Soporte para baterías CELL de 6 x 1,5 V AA 2A".
• Hilos de fibra óptica - una vez más, ordenados desde China en eBay - "Extremo de cable de fibra óptica de plástico PMMA Grow Led Light DIY Decor" o "Cable de fibra óptica PMMA End Glow para kit de luz de techo Star". Usé tamaños de 1 mm y 1,5 mm, de hecho, recomiendo usar más pequeños que eso.
• Interruptor de encendido / apagado: "Interruptores de palanca en miniatura de 2 posiciones de encendido / apagado SPDT"
• Clips de organización de cables: ayudan a mantener los hilos de fibra óptica limpios y ordenados.
• Tablero de espuma, cable conector de núcleo sólido, tubo termorretráctil

Instrumentos

• Dremel: se utiliza para colocar el interruptor de encendido / apagado en el marco de la imagen. Esto tal vez podría lograrse con un simulacro y una gran cantidad, pero no lo recomiendo.
• Soldador: conectar cables a la tira de LED
• Pistola de pegamento caliente: literalmente, cada paso de este proyecto
• Aguja de coser grande: para hacer agujeros en el lienzo y la tabla de espuma para las luces

Paso 1: Tablero de espuma, paquete de baterías e interruptor de encendido / apagado

Antes que nada, debe colocar un trozo de tablero de espuma en la parte posterior del lienzo impreso. Esto nos da una superficie sólida agradable para unir todo lo demás y ayuda a mantener los hilos de fibra óptica en su lugar. Solo use un cuchillo exacto o un cortador de cajas para cortar un trozo de tabla de espuma del tamaño correcto y pegarlo en muchos lugares. Recomiendo usar una tabla de espuma negra para que no deje pasar tanta luz.

Utilicé la broca dremel que parece una broca normal, pero en realidad es excelente para eliminar material. Es uno de los bits que debería incluir cualquier dremel. Utilice una lata de aire comprimido para eliminar el aserrín de la dremel.

Pega todo en su lugar con pegamento caliente. Asegúrese de que la batería esté bien colocada porque requiere un poco de fuerza para insertar / quitar una batería y no quiere que el soporte de la batería se vaya a ninguna parte.

Paso 2: microcontrolador y circuito

Puse el interruptor de encendido antes del Arduino UNO para que cuando lo muevas, nada esté usando la energía de los paquetes de baterías. Esto debería ayudar a que las baterías duren el mayor tiempo posible cuando el proyecto no está encendido. Las placas Arduino son notoriamente malas en la administración de energía: usan mucha corriente si están encendidas, incluso si no están haciendo nada activamente.

Enchufe el extremo positivo del paquete de baterías en el VIN (entrada de voltaje) del microcontrolador para que use el regulador de voltaje incorporado del controlador para reducir el voltaje a los 5V que necesita. Si estuviéramos alimentando más luces, podríamos necesitar usar nuestro propio regulador de voltaje para ellas, pero el UNO debería poder manejar 5 LED.

Usé una resistencia entre la salida de datos y la tira de LED para suavizar la señal; sin la resistencia, es posible que los píxeles parpadeen aleatoriamente. El tamaño de la resistencia realmente no importa, cualquier valor entre 50 Ω y 400 Ω debería funcionar.

Paso 3: luces de fibra óptica

Después de algunas pruebas y errores, finalmente encontré una buena manera de pasar los hilos de fibra óptica a través del lienzo.

1. Use la aguja de coser más grande que tenga para hacer un agujero en la parte frontal del lienzo y la tabla de espuma. Recomiendo hacer todos los orificios que desee desde el principio para que pueda darle la vuelta y ver dónde puede / no puede colocar sus clips de organización de cables
2. Tome un par de alicates de punta de aguja y agarre el hilo de fibra óptica a menos de un centímetro del extremo
3. Introduce el hilo de fibra óptica a través del orificio que hiciste con una aguja.
4. Pase el hilo a través de varios clips de plástico hasta donde sea un poco más largo de lo necesario; lo cortaremos más tarde
5. Con su pistola de pegamento caliente en el ajuste de temperatura BAJA (si tiene esa opción), coloque una gota de pegamento caliente en el hilo de fibra óptica donde se asoma a través del tablero de espuma. Alternativamente, podrías usar esa cosa pegajosa azul. El pegamento caliente deforma un poco la hebra, pero no parece alterar demasiado las cualidades ópticas.
6. Corta la hebra un poco lejos del lienzo con un cortador de alambre.

Para acelerar el proceso, puede pasar muchas fibras seguidas antes de aplicar el pegamento caliente. Por lo general, deben permanecer en su lugar por su cuenta.

Tenga cuidado de no romper o aplastar los hilos de fibra óptica sobre la mesa; se romperán y si hace que el hilo sea demasiado corto, se entristecerá y tendrá que rehacerlo. Utilice la batería como contrapeso para que pueda tener el marco de la imagen menos de la mitad en el escritorio.

Debido a que usé una placa de espuma blanca en lugar de negra, había mucha luz brillando cuando los LED estaban encendidos. Como solución, pegué un poco de papel de aluminio entre las luces y el lienzo.

Utilice tubos termorretráctiles para mantener juntos cada manojo de hilos de fibra óptica.

1. Corta las hebras del paquete a aproximadamente la misma longitud
2. Pase la sección a través de un tubo termorretráctil
3. Use una pistola de calor o un soldador para encogerlo. Si está usando un soldador, simplemente deje que el costado del soldador toque ligeramente el tubo y se encogerá. No debe derretir el tubo porque está diseñado para un poco de calor.

Finalmente, usé pegamento caliente para unir el extremo del paquete a cada luz LED. Usé mucho pegamento caliente para que las fibras recibieran luz de cada diodo rojo / verde / azul en la luz; cuando las fibras están muy cerca de la luz, un color "blanco" (que en realidad es rojo, verde y azul). entonces algunas fibras serán simplemente rojas y otras serán verdes, en lugar de ser todas blancas. Esto podría mejorarse usando un trozo de papel o algo más para difundirlo, pero el pegamento caliente funcionó lo suficientemente bien para mí.

Paso 4: programación

En la programación de esto utilicé tres bibliotecas

FastLED: una gran biblioteca para controlar las tiras de LED WS2812 (y muchas otras tiras de LED direccionables) -

Arduino Low Power: no sé cuánta energía ahorra realmente, pero fue muy fácil de implementar y debería ayudar a ahorrar un poco de energía en la función que es solo luces blancas y luego se demora para siempre.

EEPROM: se utiliza para leer / almacenar el modo actual del proyecto. Esto permite que el proyecto aumente el modo de color cada vez que lo apaga y vuelve a encender, lo que elimina la necesidad de un botón separado para cambiar el modo. La biblioteca EEPROM se instala cada vez que instala el IDE de Arduino.

También utilicé un boceto para hacer parpadear las luces que instaló otra persona. Ilumina aleatoriamente un píxel desde un color base hasta un color pico y luego vuelve a bajar. https://gist.github.com/kriegsman/88954aae22b03a66… (también usa la biblioteca FastLED)

También utilicé el complemento vMicro para Visual Studio: esta es una versión mejorada del IDE de Arduino. Tiene un montón de funciones útiles de autocompletar y resalta los problemas en su código sin tener que compilarlo. Cuesta $ 15 pero vale la pena si vas a hacer más de un proyecto Arduino, y te obligará a aprender sobre Visual Studio, que es un programa súper poderoso.

(También adjunto el archivo de código.ino porque el alojamiento Instructable de un Github Gist destruye muchos de los espacios en blanco en el archivo)

El código Arduino que ejecuta 4 modos de color en un Arduino UNO para algunas tiras de luces LED WS2812B usando la biblioteca FastLED

#incluir

#incluir

#incluir

// Configuración FastLED

# defineNUM_LEDS4

# definePIN3 // Pin de datos para tira de LED

Leds CRGB [NUM_LEDS];

// Configuración de centelleo

#defineBASE_COLORCRGB (2, 2, 2) // Color de fondo base

#definePEAK_COLORCRGB (255, 255, 255) // Color de pico para brillar hasta

// Cantidad para incrementar el color en cada bucle a medida que se vuelve más brillante:

#defineDELTA_COLOR_UPCRGB (4, 4, 4)

// Cantidad para disminuir el color en cada bucle a medida que se atenúa:

#defineDELTA_COLOR_DOWNCRGB (4, 4, 4)

// Posibilidad de que cada píxel comience a iluminarse.

// 1 o 2 = algunos píxeles de brillo a la vez.

// 10 = muchos píxeles que se iluminan a la vez.

# defineCHANCE_OF_TWINKLE2

enum {SteadyDim, GettingBrighter, GettingDimmerAgain};

uint8_t PixelState [NUM_LEDS];

byte runMode;

byte globalBright = 150;

byte globalDelay = 20; // Velocidad de retardo para parpadear

dirección de byte = 35; // Dirección para almacenar el modo de ejecución

voidsetup ()

{

FastLED.addLeds (leds, NUM_LEDS);

FastLED.setCorrection (TypLEDStrip);

//FastLED.setMaxPowerInVoltsAndMilliamps(5, maxMilliamps);

FastLED.setBrightness (globalBright);

// Obtener el modo para ejecutar

runMode = EEPROM.read (dirección);

// Incrementa el modo de ejecución en 1

EEPROM.write (dirección, modo de ejecución + 1);

}

voidloop ()

{

cambiar (modo de ejecución)

{

//Blanco sólido

case1: fill_solid (leds, NUM_LEDS, CRGB:: Blanco);

FastLED.show ();

DelayForever ();

rotura;

// Brilla un poco lentamente

case2: FastLED.setBrightness (255);

globalDelay = 10;

TwinkleMapPixels ();

rotura;

// Brilla rápidamente

case3: FastLED.setBrightness (150);

globalDelay = 2;

TwinkleMapPixels ();

rotura;

//Arcoíris

case4:

RunRainbow ();

rotura;

// Indexar fuera de rango, restablecerlo a 2 y luego ejecutar el modo 1.

// Cuando el arduino se reinicie, ejecutará el modo 2, pero por ahora ejecutará el modo 1

defecto:

EEPROM.write (dirección, 2);

runMode = 1;

rotura;

}

}

voidRunRainbow ()

{

byte * c;

uint16_t i, j;

mientras (cierto)

{

for (j = 0; j <256; j ++) {// 1 ciclo de todos los colores en la rueda

para (i = 0; i <NUM_LEDS; i ++) {

c = Rueda (((i * 256 / NUM_LEDS) + j) & 255);

setPixel (i, * c, * (c + 1), * (c + 2));

}

FastLED.show ();

delay (globalDelay);

}

}

}

byte * Wheel (byte WheelPos) {

byte estático c [3];

si (WheelPos <85) {

c [0] = WheelPos * 3;

c [1] = 255 - WheelPos * 3;

c [2] = 0;

}

elseif (WheelPos <170) {

WheelPos - = 85;

c [0] = 255 - WheelPos * 3;

c [1] = 0;

c [2] = WheelPos * 3;

}

demás {

WheelPos - = 170;

c [0] = 0;

c [1] = WheelPos * 3;

c [2] = 255 - WheelPos * 3;

}

return c;

}

voidTwinkleMapPixels ()

{

InitPixelStates ();

mientras (cierto)

{

para (uint16_t i = 0; i <NUM_LEDS; i ++) {

if (PixelState == SteadyDim) {

// este píxel es actualmente: SteadyDim

// así que consideramos aleatoriamente hacer que comience a ser más brillante

si (random8 () <CHANCE_OF_TWINKLE) {

PixelState = GettingBrighter;

}

}

elseif (PixelState == GettingBrighter) {

// este píxel es actualmente: GettingBrighter

// así que si está en el color máximo, cámbielo para que vuelva a ser más tenue

si (leds > = PEAK_COLOR) {

PixelState = GettingDimmerAgain;

}

demás {

// de lo contrario, sigue iluminándolo:

leds + = DELTA_COLOR_UP;

}

}

else {// volviéndose más tenue de nuevo

// este píxel es actualmente: GettingDimmerAgain

// así que si vuelve al color base, cámbielo a tenue constante

si (leds <= BASE_COLOR) {

leds = BASE_COLOR; // restablecer al color base exacto, en caso de que nos sobrepasemos

PixelState = SteadyDim;

}

demás {

// de lo contrario, sigue atenuándolo:

leds - = DELTA_COLOR_DOWN;

}

}

}

FastLED.show ();

FastLED.delay (globalDelay);

}

}

voidInitPixelStates ()

{

memset (PixelState, tamaño de (PixelState), SteadyDim); // inicializa todos los píxeles a SteadyDim.

fill_solid (leds, NUM_LEDS, BASE_COLOR);

}

voidDelayForever ()

{

mientras (cierto)

{

retraso (100);

LowPower.powerDown (SLEEP_FOREVER, ADC_OFF, BOD_OFF);

}

}

voidshowStrip () {

FastLED.show ();

}

voidsetPixel (int Pixel, byte rojo, byte verde, byte azul) {

// FastLED

leds [Pixel].r = rojo;

leds [Pixel].g = verde;

leds [Pixel].b = azul;

}

ver rawFiberOptic_ClemsonPic.ino alojado con ❤ por GitHub

Paso 5: Producto final

¡Ta-da! Espero que este Instructable inspire a alguien más a hacer su propio proyecto similar. Realmente no fue difícil de hacer y me sorprendió que nadie lo hubiera hecho y escrito un instructivo completo al respecto todavía.