truco estrella luminosa de Navidad

Difícil de creer, pero la Navidad se acerca. Las vacaciones de Navidad es justo antes y desea, por supuesto, en su tiempo libre un poco de la afición Fabricante Afterprecy. ¿Qué hay mejor que para poner en práctica como un pequeño truco IKEA. Hoy queremos modificar la pantalla IKEA Stråla un poco y de corresponder a una decoración de la ventana ilustrativa.

Video al final del blog!

hardware y software necesarios

El hardware para este montaje experimental es relativamente simple, véase la Tabla 1.

Tabla 1: partes de hardware para el ciclón con el anillo WS2812B LED

Además, todavía se necesita un blockbate 9V, para que después el hack obtiene la electricidad. Para el corte, que específicamente diseñado una pequeña caja para la impresora 3D, pero también se puede hacer de su propia vivienda con un poco de cartón y pegamento.

Además, todavía se tiene que tratar con IKEA pantalla Stråla Organizar porque es sobre el hack sólo esta pantalla.

El software necesario para este proyecto es manejable:

• Arduino IDE (https://www.arduino.cc/en/Main/Software), Aquí mejor descargar la versión actual
• La biblioteca adafruit Neopixel, Al crear este artículo en la versión 1.10.0 disponible, con todas las dependencias que se ven a través de la gestión de bibliotecas, consulte https://www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/arduino-ide-programmieren-fuer-einsteiger-teil-1 Sección de Gestión de Bibliotecas, debe instalar.

La estructura

El circuito para el pequeño corte IKEA debe ser compacto, pero funcional, véase la Figura 1.

Figura 1: Construcción del circuito

Por favor, tenga en cuenta que el anillo de LED necesita una disposición de voltaje de 5V. La masa de Nano V3.0 debe ser acoplado al anillo de LED.

El código fuente

A medida que se acostumbre a ella, el código fuente se proporciona de nuevo con muchos comentarios, ver el código 1. Al mismo tiempo, esto está diseñado en la función de bucle para que pueda agregar animaciones más iluminación.

esbozo

 //-----------------------------------------------------
 // IKEA estrella Hack para Nano V3.0
 // Autor: Joern Camino
 // Licencia: GNU GPL 3.0
 // Creado: 07. diciembre 2021
 // actualizar:  
 //-----------------------------------------------------
 // incluyen bibliotecas
 # include 
 ​
 // definida
 #define led_pin 6        // Pin en Arduino Nano D6
 led_count #define 12        // Número de LEDs
 time_change #define 120000 // tiempo para cambiar la manera en la EM 2 min = 120000ms
 num_mode #define 5         // Max Num de modos de LED
 ​
 // Init Neopixel de Gaza
 Adafruit_neaopixel banda(LED_count, LED_PIN, Neo_grb + Neo_khz800);  // anillo LED init
 ​
 // Algunos Vars Global
 En t IshowMode = -1;   // Cambiar a modo válido para conseguir un modo de solución !!
 En t IcurrentMode = 0; // para cambiar entre los modos
 no firmado largo ullastime = 0; // para el tiempo de comprobación
 ​
 /*
   =================================================================
   FUNCIÓN: Configuración
   DEVOLUCIONES: suprimido
   Descripción: Necesario para la rutina de configuración del microcontrolador
   =================================================================
 */
 vacío configurar() {
   De serie.Comenzar(115200);
   banda.Comenzar();           // Inicializar Neopixel Gaza Objeto (Obligatorio)
   banda.show();            // Desactivar todos los píxeles ASAP
   banda.Setbrightness(50); // configurar el brillo de alrededor de 1/5 (max = 255)
   Semilla aleatoria(analogead(A0)); // Hacer aleatorio Más Randome
   
 }
 ​
 /*
   =================================================================
   FUNCIÓN: Bucle
   DEVOLUCIONES: suprimido
   Descripción: Necesario para la rutina Loop microcontrolador
   =================================================================
 */
 vacío círculo() {
   SI(IshowMode == -1)
   {
     SI(IcurrentMode >= NUM_MODE)
       IcurrentMode = 0;
       De serie.println("Modo actual:" + Cuerda(IcurrentMode));
   }
   demás
     IcurrentMode = IshowMode;
 ​
   // simple máquina de estado para ir a través de los modos
   // Más modos se pueden Add, tener en cuenta para Aumentar Num_Mode
   cambiar(IcurrentMode)
   {
     Caso 0:
       De serie.println("Caso: 0");
       Color aleatorio();
       elaborar cerveza;
     Caso 1:
       De serie.println("Caso 1");
       arcoíris(10);
       elaborar cerveza;
     Caso 2:
       De serie.println("Caso: 2"); 
       teatrochaserainbow(50);
       descanso;
     caso 3:
       De serie.imprimir("Caso: 3");
       Classchase(banda.Color(aleatorio(0,255), aleatorio(0,255), aleatorio(0,255)),250);
       descanso;
     caso 4:
       De serie.imprimir("Caso: 4");
       cambio(150);
       descanso;
     defecto:
       De serie.imprimir("Caso: Predeterminado");
       Color aleatorio();
       descanso;
   }
 }
 ​
 /*
   =================================================================
   Función: RandomColor
   Devoluciones: vacío
   Descripción: Coloree un LED aleatorio con un color aleatorio.
   =================================================================
 */
 vacío Color aleatorio()
 {
   estático no firmado largo ulrandomlasto = milis();
   UllostTime = milis();
   De serie.imprimir("UllastTime:" + Cuerda(UllostTime));
   banda.claro();
   mientras((milis() - UllostTime) < CAMBIO DE TIEMPO)
   {
     Si(milis() - ulrandomlasto > 250)
     {
       En t ired    = aleatorio(0,255);
       En t Igreen  = aleatorio(0,255);
       En t IBLUE   = aleatorio(0,255);
       En t ilado    = aleatorio(0,En t(LED_COUNT) );
       banda.setpixelcolor(ilado, banda.Color(ired, Igreen, IBLUE));         // Establecer el color de Pixel (en RAM)
       banda.show();
       ulrandomlasto = milis();
     }
   }
   De serie.imprimir("Salir mientras-bucle");
   Modo de icurrent++;
 }
 ​
 /*
   =================================================================
   Función: arco iris
   Devoluciones: vacío
   En espera: tiempo para esperar el próximo cambio LED
   Descripción: Colorea el anillo como un arco iris.
   =================================================================
 */
 vacío arcoíris(En t Espere)
 {
   estático no firmado largo ulrainboast = milis();
   UllostTime = milis();
   De serie.imprimir("UllastTime:" + Cuerda(UllostTime));
   estático En t ifirstpixelhue = 0;
   banda.claro();
   mientras((milis() - UllostTime) < CAMBIO DE TIEMPO)
   {
     Si(milis() - ulrainboast > Espere)
     {
       ifirstpixelhue += 256;
       Si(ifirstpixelhue >= 65536)
         ifirstpixelhue = 0;
       por(En t I=0; I<banda.numpixeles(); I++)
       {
         En t ipixelhue = ifirstpixelhue + (I / banda.numpixeles());
         banda.setpixelcolor(I, banda.gamma32(banda.Colorhsv(ipixelhue)));
       }
       ulrainboast = milis();
       banda.show();
     }
   }
   De serie.imprimir("Salir mientras-bucle");
   Modo de icurrent++;
 }
 ​
 /*
   =================================================================
   Función: TeatroChaserainbow
   Devoluciones: vacío
   En espera: tiempo para esperar el próximo cambio LED
   Descripción: Círculo de color arco iris alrededor del anillo de LED
   =================================================================
 */
 vacío teatrochaserainbow(En t Espere) 
 {
   estático no firmado largo teatrochaserainbow = milis();
   UllostTime = milis();
   De serie.imprimir("UllastTime:" + Cuerda(UllostTime));
   estático En t ifirstpixelhue = 0;
   banda.claro();
   estático En t ifirstpixel = 0;
   mientras((milis() - UllostTime) < CAMBIO DE TIEMPO)
   {
     Si(milis() - teatrochaserainbow > Espere)
     {
       banda.claro();
       por(En t Yo cuento = ifirstpixel; Yo cuento < banda.numpixeles(); Yo cuento += 3)
       {
         En t      matiz   = ifirstpixelhue + Yo cuento * 65536L / banda.numpixeles();
         uint32_t color = banda.gamma32(banda.Colorhsv(matiz)); // Hue -> RGB
         banda.setpixelcolor(Yo cuento, color); // establecer pixel 'c' para valorar 'color'
       }
       teatrochaserainbow = milis();
       banda.show();
       ifirstpixelhue += 65536 / 90;
       ifirstpixel++ ;
       Si(ifirstpixel >= 3)
         ifirstpixel = 0;
     }
   }
   De serie.imprimir("Salir mientras-bucle");
   Modo de icurrent++;
 }
 ​
 /*
   =================================================================
   Función: Classchase
   Devoluciones: vacío
   En espera: tiempo para esperar el próximo cambio LED
   En color: color aleatorio para el anillo de LED.
   Descripción: Círculo aleatorio de color alrededor del anillo de LED
   =================================================================
 */
 vacío Classchase(uint32_t color, En t Espere)
 {
   estático no firmado largo Classchase = milis();
   UllostTime = milis();
   De serie.imprimir("UllastTime:" + Cuerda(UllostTime));
   estático En t ifirstpixel;
   ifirstpixel = 0;
   banda.claro();
   mientras((milis() - UllostTime) < CAMBIO DE TIEMPO)
   {
     Si(milis() - Classchase > Espere)
     {
       banda.claro();
       por(En t Yo cuento = ifirstpixel; Yo cuento < banda.numpixeles(); Yo cuento += 3)
       {
         banda.setpixelcolor(Yo cuento, color); // establecer pixel 'c' para valorar 'color'
       }
       Classchase = milis();
       banda.show();
       ifirstpixel++ ;
       Si(ifirstpixel >= 3)
         ifirstpixel = 0;
     }
   }
   De serie.imprimir("Salir mientras-bucle");
   Modo de icurrent++;
 }
 ​
 /*
   =================================================================
   Función: Cambio
   Devoluciones: vacío
   En espera: tiempo para esperar el próximo cambio LED
   Descripción: Coloree cada anillo de LED paso a paso al color aleatorio
   =================================================================
 */
 vacío cambio(En t Espere)
 {
   estático no firmado largo ulgrafiado = Millis();
   ullastime = Millis();
   De serie.println("UlLastTime" + Cuerda(ullastime));
   estático En t Ipixel;
   Ipixel = 0;
   estático En t iShifter = 1;
   banda.claro();
   estático uint32_t color = banda.color(aleatorio(0,255), aleatorio(0,255), aleatorio(0,255));
   mientras((Millis() - ullastime) < CAMBIO DE TIEMPO)
   {
     SI(Millis() - ulShift > Espere)
     {
       banda.setPixelColor(Ipixel, color); // Conjunto de píxeles 'c' con el valor 'color'
       ulShift = Millis();
       banda.show();
       
       Ipixel+= iShifter;
       SI(Ipixel >= (LED_count - 1) )
       {
         color = banda.color(aleatorio(0,255), aleatorio(0,255), aleatorio(0,255));
         iShifter = -1; 
       }
       demás SI (Ipixel <= 0)
       {
         iShifter = 1;
         color = banda.color(aleatorio(0,255), aleatorio(0,255), aleatorio(0,255));
       }
     }
   }
   De serie.println("Salir bucle while");
   IcurrentMode++;
 }

Tomemos, por ejemplo, animaciones aún más la función de luz Color aleatorio ()Que muestra sólo el principio de la animación. Puesto que no soy personalmente un fan de la demora de función (), utilizo una resta de los milisegundos que se están ejecutando en el último valor almacenado. Si se excede un límite, la función continúa funcionando o se inicia una nueva animación luz. Los bloques de función de retardo () el programa, lo que impide la ejecución de un líquido, si desea responder a los eventos.

montaje

Así, la estrella al final se ilumina en consecuencia, he diseñado especialmente siendo una pequeña vivienda, como se muestra en la figura 2. El alojamiento se puede encontrar en mi GitHubPágina de modo que usted puede cortar por sí mismo.

Figura 2: la vivienda para la técnica de

Dado que por desgracia no tengo tornillos adecuados para fijar el anillo de LED, tenía una cantidad buena de pegamento caliente para este punto. En relación sigue siendo el caso con el titular de la combinación en estrella, por ejemplo, simplemente con las ataduras de cables y listo es la estrella brillante, ver Figura. 3

Figura 3: La final de la estrella

En general, el conjunto de toma sin imprimir la carcasa, cerca de 30 minutos. Con un poco de artesanía Talento propia carcasa de cartón se hace a mano de la tecnología rápidamente.

resumen

Les deseo una Feliz Navidad y un Feliz Navidad. Aunque Corona nos tiene aún bajo control, no se debe reducir la velocidad, pero el fabricante de la unidad. Como se mencionó en el código fuente, usted tiene la posibilidad de añadir sus propios efectos, o simplemente dejar todo así. Son también tubos de LED concebibles que se envuelven alrededor de una carcasa. Todo es posible, deje que su creatividad salvaje plazo.

Otros proyectos para AZ-entrega por mí, véase
https://github.com/M3taKn1ght/Blog-Repo.