Hack per stelle natalizie luminose

Difficile da credere, ma il Natale si sta avvicinando. La festa di Natale è poco prima e vuoi, naturalmente, nel tuo tempo libero un po 'dell'hobby Maker Post-prezzo. Cosa c'è di meglio che implementare come un piccolo hack IKEA. Oggi vogliamo modificare un po 'il paralume IKEA Stråla un po' e ricambiare a una decorazione illustrativa della finestra.

Video alla fine del blog!

Hardware e software richiesti

L'hardware per questa configurazione sperimentale è relativamente semplice, vedere la Tabella 1.

Tabella 1: Parti hardware per ciclone con anello LED WS2812B

Inoltre, hai ancora bisogno di un blocco di 9V, in modo che in seguito l'hack ottiene elettricità. Per l'hack, ho progettato specificamente un piccolo caso per la stampante 3D, ma è anche possibile creare il proprio alloggiamento con un po 'di cartone e colla.

Inoltre, devi ancora affrontare IKEA Paralume stråla. Organizzare perché si tratta dell'hack solo questo paralume.

Il software richiesto per questo progetto è gestibile:

• Arduino IDE (https://www.arduino.cc/en/Main/Software), qui Scarica meglio la versione corrente
• La Biblioteca Adattoruit neopixel., Quando si crea questo articolo nella versione 1.10.0 disponibile, con tutte le dipendenze che vedi attraverso la gestione della libreria, vedere https://www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/arduino-ide-programmieren-fuer-einsteiger-teil-1 Sezione Gestione della libreria, deve installare.

La struttura

Il circuito per il piccolo hack IKEA dovrebbe essere compatto, ma funzionale, vedere la figura 1.

Figura 1: costruzione del circuito

Si prega di tenere presente che l'anello a LED ha bisogno di uno smaltimento di tensione 5V. La massa di nano v3.0 deve essere accoppiata all'anello a LED.

Il codice sorgente

Come sei abituato, il codice sorgente viene nuovamente fornito con molti commenti, vedere il codice 1. Allo stesso tempo, questo è progettato nella funzione Loop in modo da poter aggiungere più animazioni di illuminazione.

Download di schizzo

 //-----------------------------------------------------
 // IKEA Star Hack per nano v3.0
 // Autore: joern way
 // Licenza: GNU GPL 3.0
 // creato: 07. DEC. 2021.
 // aggiornare:  
 //-----------------------------------------------------
 // include librerie
 #include 
 ​
 // preciso
 #define led_pin 6.        // Pin su Arduino Nano D6
 #define led_count 12.        // num di LED
 #define time_change 120000. // Ora di cambiare moda in MS 2 min = 120000MS
 #define num_mode 5.         // numero massimo di modalità LED
 ​
 // Init Neopixel Strip
 ADAFRUIT_NEAOPIXEL. striscia(Led_count., Led_pin., Neo_grb. + Neo_khz800.);  // Init LED Ring
 ​
 // alcuni vars globali
 Int. Ishowmode. = -1;   // Modifica in modalità valida per ottenere una modalità di correzione !!
 Int. ICURRENTMode. = 0; // per passare attraverso le modalità
 non firmato lungo Ullastime. = 0; // per il controllo del tempo
 ​
 /*
   =================================================================
   Funzione: Setup.
   Restituisce: Void.
   Descrizione: Need Setup Routine per microcontrollore
   =================================================================
 */
 vuoto impostare() {
   Seriale.Inizio(115200);
   striscia.Inizio();           // Inizializza l'oggetto Strip Neopixel (richiesto)
   striscia.mostrare();            // Spegni tutti i pixel al più presto
   striscia.Setbrightness.(50); // imposta la luminosità a circa 1/5 (max = 255)
   randomseed.(Analogenead.(A0.)); // rendi casuale più randome
   
 }
 ​
 /*
   =================================================================
   Funzione: loop.
   Restituisce: Void.
   Descrizione: Routine loop necessaria per microcontrollore
   =================================================================
 */
 vuoto ciclo continuo() {
   SE(Ishowmode. == -1)
   {
     SE(ICURRENTMode. >= Num_mode.)
       ICURRENTMode. = 0;
       Seriale.Println.("Modalità corrente:" + Corda(ICURRENTMode.));
   }
   altro
     ICURRENTMode. = Ishowmode.;
 ​
   // Simple State Machine per passare attraverso le modalità
   // Altre modalità possono essere aggiunte, tenere presente per aumentare NUM_MODE
   interruttore(ICURRENTMode.)
   {
     Caso 0:
       Seriale.Println.("Caso: 0");
       colore casuale();
       birra;
     Caso 1:
       Seriale.Println.("Caso 1");
       Arcobaleno(10);
       birra;
     Caso 2:
       Seriale.Println.("Caso: 2"); 
       theaterChaseRainbow(50);
       rottura;
     Astuccio 3:
       Seriale.Println.("Caso: 3");
       theaterChase(striscia.Colore(a caso(0,255), a caso(0,255), a caso(0,255)),250);
       rottura;
     Astuccio 4:
       Seriale.Println.("Caso: 4");
       cambio(150);
       rottura;
     predefinito:
       Seriale.Println.("Caso: default");
       colore casuale();
       rottura;
   }
 }
 ​
 /*
   =================================================================
   Funzione: randomColor
   Ritorni: vuoto
   Descrizione: Colore un LED casuale con un colore casuale
   =================================================================
 */
 vuoto colore casuale()
 {
   statico non firmato lungo ulRandomLast = millis.();
   ulLastTime = millis.();
   Seriale.Println.("UlLastTime:" + Corda(ulLastTime));
   striscia.chiaro();
   mentre((millis.() - ulLastTime) < TIME_CHANGE)
   {
     Se(millis.() - ulRandomLast > 250)
     {
       Int. Ho letto    = a caso(0,255);
       Int. iGreen  = a caso(0,255);
       Int. iBlue   = a caso(0,255);
       Int. iLED    = a caso(0,Int.(LED_COUNT) );
       striscia.setPixelColor(iLED, striscia.Colore(Ho letto, iGreen, iBlue));         // colore Set di pixel (in RAM)
       striscia.mostrare();
       ulRandomLast = millis.();
     }
   }
   Seriale.Println.("Exit ciclo while");
   iCurrentMode++;
 }
 ​
 /*
   =================================================================
   Funzione: arcobaleno
   Ritorni: vuoto
   In agguato: Tempo di attesa per il prossimo cambio LED
   Descrizione: Colore l'anello come un arcobaleno
   =================================================================
 */
 vuoto Arcobaleno(Int. aspettare)
 {
   statico non firmato lungo ulRainbowLast = millis.();
   ulLastTime = millis.();
   Seriale.Println.("UlLastTime:" + Corda(ulLastTime));
   statico Int. iFirstPixelHue = 0;
   striscia.chiaro();
   mentre((millis.() - ulLastTime) < TIME_CHANGE)
   {
     Se(millis.() - ulRainbowLast > aspettare)
     {
       iFirstPixelHue += 256;
       Se(iFirstPixelHue >= 65536)
         iFirstPixelHue = 0;
       per(Int. io=0; io<striscia.numPixels(); io++)
       {
         Int. iPixelHue = iFirstPixelHue + (io / striscia.numPixels());
         striscia.setPixelColor(io, striscia.gamma32(striscia.ColorHSV(iPixelHue)));
       }
       ulRainbowLast = millis.();
       striscia.mostrare();
     }
   }
   Seriale.Println.("Exit ciclo while");
   iCurrentMode++;
 }
 ​
 /*
   =================================================================
   Funzione: theaterChaseRainbow
   Ritorni: vuoto
   In agguato: Tempo di attesa per il prossimo cambio LED
   Descrizione: Il cerchio arcobaleno-colore intorno al LED ad anello
   =================================================================
 */
 vuoto theaterChaseRainbow(Int. aspettare) 
 {
   statico non firmato lungo theaterChaseRainbow = millis.();
   ulLastTime = millis.();
   Seriale.Println.("UlLastTime:" + Corda(ulLastTime));
   statico Int. iFirstPixelHue = 0;
   striscia.chiaro();
   statico Int. iFirstPixel = 0;
   mentre((millis.() - ulLastTime) < TIME_CHANGE)
   {
     Se(millis.() - theaterChaseRainbow > aspettare)
     {
       striscia.chiaro();
       per(Int. io conto = iFirstPixel; io conto < striscia.numPixels(); io conto += 3)
       {
         Int.      tinta   = iFirstPixelHue + io conto * 65536L / striscia.numPixels();
         UINT32_T. colore = striscia.gamma32(striscia.ColorHSV(tinta)); // Hue -> RGB
         striscia.setPixelColor(io conto, colore); // Set pixel 'c' al valore di 'color'
       }
       theaterChaseRainbow = millis.();
       striscia.mostrare();
       iFirstPixelHue += 65536 / 90;
       iFirstPixel++ ;
       Se(iFirstPixel >= 3)
         iFirstPixel = 0;
     }
   }
   Seriale.Println.("Exit ciclo while");
   iCurrentMode++;
 }
 ​
 /*
   =================================================================
   Funzione: theaterChase
   Ritorni: vuoto
   In agguato: Tempo di attesa per il prossimo cambio LED
   colore IN: colore casuale per il LED-Ring
   Descrizione: Circle casuale colore intorno al LED ad anello
   =================================================================
 */
 vuoto theaterChase(UINT32_T. colore, Int. aspettare)
 {
   statico non firmato lungo theaterChase = millis.();
   ulLastTime = millis.();
   Seriale.Println.("UlLastTime:" + Corda(ulLastTime));
   statico Int. iFirstPixel;
   iFirstPixel = 0;
   striscia.chiaro();
   mentre((millis.() - ulLastTime) < TIME_CHANGE)
   {
     Se(millis.() - theaterChase > aspettare)
     {
       striscia.chiaro();
       per(Int. io conto = iFirstPixel; io conto < striscia.numPixels(); io conto += 3)
       {
         striscia.setPixelColor(io conto, colore); // Set pixel 'c' al valore di 'color'
       }
       theaterChase = millis.();
       striscia.mostrare();
       iFirstPixel++ ;
       Se(iFirstPixel >= 3)
         iFirstPixel = 0;
     }
   }
   Seriale.Println.("Exit ciclo while");
   iCurrentMode++;
 }
 ​
 /*
   =================================================================
   Funzione: spostamento
   Ritorni: vuoto
   In agguato: Tempo di attesa per il prossimo cambio LED
   Descrizione: Colore ogni passo LED-ring dopo passo per colore casuale
   =================================================================
 */
 vuoto cambio(Int. aspettare)
 {
   statico non firmato lungo ulShift = millis.();
   Ullastime. = millis.();
   Seriale.Println.("Ullasttime:" + Corda(Ullastime.));
   statico Int. ipixel.;
   ipixel. = 0;
   statico Int. ishifter. = 1;
   striscia.Chiaro();
   statico UINT32_T. colore = striscia.Colore(a caso(0,255), a caso(0,255), a caso(0,255));
   whiler.((millis.() - Ullastime.) < Time_change.)
   {
     SE(millis.() - Ulshift. > aspettare)
     {
       striscia.Setpixelcolor.(ipixel., colore); // Imposta pixel 'c' per valutare 'colore'
       Ulshift. = millis.();
       striscia.mostrare();
       
       ipixel.+= ishifter.;
       SE(ipixel. >= (Led_count. - 1) )
       {
         colore = striscia.Colore(a caso(0,255), a caso(0,255), a caso(0,255));
         ishifter. = -1; 
       }
       altro SE (ipixel. <= 0)
       {
         ishifter. = 1;
         colore = striscia.Colore(a caso(0,255), a caso(0,255), a caso(0,255));
       }
     }
   }
   Seriale.Println.("Esci mentre loop");
   ICURRENTMode.++;
 }

Utilizzare per ulteriori animazioni di illuminazione E.G. La funzione Colore casuale ()che mostra semplicemente il principio di un'animazione. Dal momento che personalmente nessun amico del ritardo della funzione (), uso una sottrazione delle attuali millisecondi all'ultimo valore salvato. Se viene superato un limite, la funzione viene ulteriormente eseguita o inizia una nuova animazione della luce. La funzione di ritardo () blocca il programma e impedisce quindi una procedura di programma liquido se deve essere reagito agli eventi.

Assemblea

In modo che la stella si accenda anche alla fine, ho progettato appositamente un piccolo caso, vedere la figura 2. L'alloggiamento può essere trovato sulla mia GigantePagina in modo da poterlo scivolare da solo.

Figura 2: alloggio per la tecnologia

Sfortunatamente, dal momento che non avevo viti corrispondenti per attaccare l'anello a LED, ha anche fatto una buona porzione di colla calda a questo punto. Successivamente collegare l'alloggiamento con il titolare della stella, ad esempio, per digiunare con i legami e la finitura dei cavi è la stella luminosa, vedere la figura 3.

Figura 3: la stella finita

Complessivamente, assemblaggio, senza stampare l'alloggiamento, richiede circa 30 minuti. Con un po 'di talento artigianale, un cartone privato in cartone può essere effettuato rapidamente.

riepilogo

Ti auguro un buon Natale e un buon Natale. Sebbene Corona sia ancora sotto controllo, ma non dovrebbe frenare il produttore del produttore. Come accennato nel codice sorgente, hai l'opportunità di aggiungere i propri effetti, o semplicemente lasciare tutto così. Anche i concepibili sono tubi led che sono avvolti attorno a un alloggiamento. Tutto è possibile, lascia che la tua creatività sia libera.

Ulteriori progetti per AZ-Consegna da me, vedi
https://github.com/M3taKn1ght/Blog-Repo.