Star de Noël lumineux hack

Difficile à croire, mais Noël se rapproche. Les vacances de Noël sont juste avant et que vous voulez, bien sûr, dans votre temps libre un peu du passe-temps Fabricant Précédent. De quoi y a-t-il mieux que de mettre en œuvre comme un petit piratage IKEA. Aujourd'hui, nous voulons modifier quelque peu l'abat-jour Ikea Stråla et pour la réciprocité vers une décoration de fenêtre illustrative.

Vidéo à la fin du blog!

Matériel et logiciel requis

Le matériel de cette configuration expérimentale est relativement simple, voir tableau 1.

Tableau 1: Pièces matérielles pour cyclone avec bague à LED WS2812B

De plus, vous avez toujours besoin d'un blockbate de 9V, de sorte que plus tard le hack devienne de l'électricité. Pour le hack, j'ai spécifiquement conçu un petit cas pour l'imprimante 3D, mais vous pouvez également créer votre propre logement avec un peu de carton et de colle.

De plus, vous devez toujours faire face à IKEA Abat-jour stråla Organiser parce que c'est à propos du hack de cet abat-jour.

Le logiciel requis pour ce projet est gérable:

• Arduino Ide (https://www.arduino.cc/en/Main/Software), ici meilleur téléchargement de la version actuelle
• La bibliothèque Adafruit néopixel, Lors de la création de cet article dans la version 1.10.0 disponible, avec toutes les dépendances que vous voyez via la gestion de la bibliothèque, voir https://www.az-delivery.de/blogs/azdelivery-blog-fur-arduino-und-raspberry-pi/arduino-ide-programmieren-fuer-einsteiger-teil-1 La gestion de la bibliothèque de section doit installer.

La structure

Le circuit pour le petit hack IKEA devrait être compact, mais fonctionnel, voir la figure 1.

Figure 1: Construction du circuit

Veuillez garder à l'esprit que l'anneau LED a besoin d'une tension de 5V. La masse de Nano V3.0 doit être couplée à la bague à LED.

Le code source

Comme vous l'avez été habitué, le code source est à nouveau fourni avec de nombreux commentaires, voir code 1. En même temps, il est conçu dans la fonction de boucle afin que vous puissiez ajouter plus d'animations d'éclairage.

Sketch Télécharger

 //-----------------------------------------------------
 // Ikea Star Hack pour Nano V3.0
 // Auteur: JOERN WAY
 // Licence: GNU GPL 3.0
 // créé: 07. Décembre 2021
 // mettre à jour:  
 //-----------------------------------------------------
 // inclure les bibliothèques
 #include 
 ​
 // défini
 #define LED_PIN 6        // Pin sur Arduino Nano D6
 #define LED_COUNT 12        // nombre de voyants
 #define Time_change 120000 // Il est temps de changer de mode dans ms 2 min = 120000ms
 #define num_mode 5         // nombre maximum de modes LED
 ​
 // init neopixel bande
 Adafruit_neopixel déshabiller(LED_COUNT, LED_PIN, Neo_GRB + Neo_khz800);  // anneau LED init
 ​
 // Certains vars globaux
 int Ishowmode = -1;   // passe au mode valide pour obtenir un mode correcteur !!
 int IcurrentMode = 0; // pour passer à travers les modes
 non signé long ullastime = 0; // pour vérifier le temps
 ​
 /*
   =================================================================
   Fonction: Configuration
   Retours: annuler
   Description: Routine de configuration nécessaire pour le microcontrôleur
   =================================================================
 */
 annuler d'installation() {
   En série.Commencer(115200);
   déshabiller.Commencer();           // Initialiser l'objet de bande Neopixel (obligatoire)
   déshabiller.Afficher();            // désactive tous les pixels dès que possible
   déshabiller.sertout(50); // Définir la luminosité à environ 1/5 (max = 255)
   aléatoire(analogique(Août)); // fait au hasard plus de randome
   
 }
 ​
 /*
   =================================================================
   Fonction: boucle
   Retours: annuler
   Description: Routine de boucle nécessaire pour le microcontrôleur
   =================================================================
 */
 annuler boucler() {
   SI(Ishowmode == -1)
   {
     SI(IcurrentMode >= Num_Mode)
       IcurrentMode = 0;
       En série.Imprimeur("Mode actuel:" + Chaîne de caractères(IcurrentMode));
   }
   autre
     IcurrentMode = Ishowmode;
 ​
   // machine d'état simple pour passer par les modes
   // Plus de modes peut être ajouté, gardez à l'esprit pour augmenter Num_Mode
   changer(IcurrentMode)
   {
     Cas 0:
       En série.Imprimeur("Cas: 0");
       couleur aléatoire();
       brasser;
     Cas 1:
       En série.Imprimeur("Cas 1");
       arc en ciel(10);
       brasser;
     Cas 2:
       En série.Imprimeur("Case: 2"); 
       theaterChaseRainbow(50);
       Pause;
     Cas 3:
       En série.imprimeur("Cas: 3");
       theaterChase(déshabiller.Couleur(Aléatoire(0,255), Aléatoire(0,255), Aléatoire(0,255)),250);
       Pause;
     Cas 4:
       En série.imprimeur("Cas: 4");
       changement(150);
       Pause;
     défaut:
       En série.imprimeur("Cas: default");
       couleur aléatoire();
       Pause;
   }
 }
 ​
 /*
   =================================================================
   Fonction: randomColor
   Renvoie: void
   Description: couleur aléatoire une LED avec une couleur aléatoire
   =================================================================
 */
 annuler couleur aléatoire()
 {
   statique non signé long ulRandomLast = millis();
   ulLastTime = millis();
   En série.imprimeur("UlLastTime:" + Chaîne de caractères(ulLastTime));
   déshabiller.dégager();
   tandis que((millis() - ulLastTime) < CHANGEMENT D'HEURE)
   {
     si(millis() - ulRandomLast > 250)
     {
       int iRed    = Aléatoire(0,255);
       int iGreen  = Aléatoire(0,255);
       int iBlue   = Aléatoire(0,255);
       int iLED    = Aléatoire(0,int(LED_COUNT) );
       déshabiller.setPixelColor(iLED, déshabiller.Couleur(iRed, iGreen, iBlue));         // Définir la couleur de pixel (en RAM)
       déshabiller.Afficher();
       ulRandomLast = millis();
     }
   }
   En série.imprimeur(« Sortie en boucle »);
   iCurrentMode++;
 }
 ​
 /*
   =================================================================
   Fonction: arc en ciel
   Renvoie: void
   IN attente: Temps d'attente pour la prochaine modification de LED
   Description: Couleur de l'anneau comme un arc-en
   =================================================================
 */
 annuler arc en ciel(int attendre)
 {
   statique non signé long ulRainbowLast = millis();
   ulLastTime = millis();
   En série.imprimeur("UlLastTime:" + Chaîne de caractères(ulLastTime));
   statique int iFirstPixelHue = 0;
   déshabiller.dégager();
   tandis que((millis() - ulLastTime) < CHANGEMENT D'HEURE)
   {
     si(millis() - ulRainbowLast > attendre)
     {
       iFirstPixelHue += 256;
       si(iFirstPixelHue >= 65536)
         iFirstPixelHue = 0;
       pour(int je=0; je<déshabiller.numPixels(); je++)
       {
         int iPixelHue = iFirstPixelHue + (je / déshabiller.numPixels());
         déshabiller.setPixelColor(je, déshabiller.gamma32(déshabiller.ColorHSV(iPixelHue)));
       }
       ulRainbowLast = millis();
       déshabiller.Afficher();
     }
   }
   En série.imprimeur(« Sortie en boucle »);
   iCurrentMode++;
 }
 ​
 /*
   =================================================================
   Fonction: theaterChaseRainbow
   Renvoie: void
   IN attente: Temps d'attente pour la prochaine modification de LED
   Description: Cercle arc-en-couleur autour de la LED torique
   =================================================================
 */
 annuler theaterChaseRainbow(int attendre) 
 {
   statique non signé long theaterChaseRainbow = millis();
   ulLastTime = millis();
   En série.imprimeur("UlLastTime:" + Chaîne de caractères(ulLastTime));
   statique int iFirstPixelHue = 0;
   déshabiller.dégager();
   statique int iFirstPixel = 0;
   tandis que((millis() - ulLastTime) < CHANGEMENT D'HEURE)
   {
     si(millis() - theaterChaseRainbow > attendre)
     {
       déshabiller.dégager();
       pour(int Je compte = iFirstPixel; Je compte < déshabiller.numPixels(); Je compte += 3)
       {
         int      teinte   = iFirstPixelHue + Je compte * 65536L / déshabiller.numPixels();
         uint32_t Couleur = déshabiller.gamma32(déshabiller.ColorHSV(teinte)); // teinte -> RGB
         déshabiller.setPixelColor(Je compte, Couleur); // Set pixel 'c' à 'couleur' ​​valeur
       }
       theaterChaseRainbow = millis();
       déshabiller.Afficher();
       iFirstPixelHue += 65536 / 90;
       iFirstPixel++ ;
       si(iFirstPixel >= 3)
         iFirstPixel = 0;
     }
   }
   En série.imprimeur(« Sortie en boucle »);
   iCurrentMode++;
 }
 ​
 /*
   =================================================================
   Fonction: theaterChase
   Renvoie: void
   IN attente: Temps d'attente pour la prochaine modification de LED
   EN Couleur: Couleur aléatoire pour la LED-Ring
   Description: couleur aléatoire cercle autour de la LED torique
   =================================================================
 */
 annuler theaterChase(uint32_t Couleur, int attendre)
 {
   statique non signé long theaterChase = millis();
   ulLastTime = millis();
   En série.imprimeur("UlLastTime:" + Chaîne de caractères(ulLastTime));
   statique int iFirstPixel;
   iFirstPixel = 0;
   déshabiller.dégager();
   tandis que((millis() - ulLastTime) < CHANGEMENT D'HEURE)
   {
     si(millis() - theaterChase > attendre)
     {
       déshabiller.dégager();
       pour(int Je compte = iFirstPixel; Je compte < déshabiller.numPixels(); Je compte += 3)
       {
         déshabiller.setPixelColor(Je compte, Couleur); // Set pixel 'c' à 'couleur' ​​valeur
       }
       theaterChase = millis();
       déshabiller.Afficher();
       iFirstPixel++ ;
       si(iFirstPixel >= 3)
         iFirstPixel = 0;
     }
   }
   En série.imprimeur(« Sortie en boucle »);
   iCurrentMode++;
 }
 ​
 /*
   =================================================================
   Fonction: changement
   Renvoie: void
   IN attente: Temps d'attente pour la prochaine modification de LED
   Description: Couleur chaque étape LED-cycle par l'étape de couleur aléatoire
   =================================================================
 */
 annuler changement(int attendre)
 {
   statique non signé long ulShift = millis();
   ullastime = millis();
   En série.Imprimeur("Ullasttime:" + Chaîne de caractères(ullastime));
   statique int ipixel;
   ipixel = 0;
   statique int ishifter = 1;
   déshabiller.Dégager();
   statique uint32_t Couleur = déshabiller.Couleur(Aléatoire(0,255), Aléatoire(0,255), Aléatoire(0,255));
   robuste((millis() - ullastime) < Changement d'heure)
   {
     SI(millis() - Ulshift > attendre)
     {
       déshabiller.Setpixelcolor(ipixel, Couleur); // définit pixel 'c' pour valoriser "couleur"
       Ulshift = millis();
       déshabiller.Afficher();
       
       ipixel+= ishifter;
       SI(ipixel >= (LED_COUNT - 1) )
       {
         Couleur = déshabiller.Couleur(Aléatoire(0,255), Aléatoire(0,255), Aléatoire(0,255));
         ishifter = -1; 
       }
       autre SI (ipixel <= 0)
       {
         ishifter = 1;
         Couleur = déshabiller.Couleur(Aléatoire(0,255), Aléatoire(0,255), Aléatoire(0,255));
       }
     }
   }
   En série.Imprimeur("Sortie pendant la boucle");
   IcurrentMode++;
 }

Utiliser pour d'autres animations d'éclairage E.g. la fonction Couleur aléatoire ()qui montre simplement le principe d'une animation. Depuis que je n'ai personnellement aucun ami du délai de fonction (), j'utilise une soustraction des millisecondes actuelles à la dernière valeur enregistrée. Si une limite est dépassée, la fonction est en outre exécutée ou une nouvelle animation de lumière commence. La fonction de retard () bloque le programme et empêche ainsi une procédure de programme liquide s'il doit être réagi aux événements.

Assemblée

De sorte que l'étoile est également allumée à la fin, j'ai spécialement conçu un petit cas, voir la figure 2. Le logement peut être trouvé sur le mien GéantPage donc vous pouvez le glisser vous-même.

Figure 2: Logement pour la technologie

Malheureusement, comme je n'avais aucune vis assorties pour attacher la bague à LED, elle a également fait une bonne partie de la colle chaude à ce stade. Ensuite, connectez le boîtier avec le support de l'étoile, par exemple, à jeûner avec les cravates de câble et la finition est l'étoile lumineuse, voir la figure 3.

Figure 3: L'étoile finie

Globalement, montage, sans imprimer le boîtier, prend environ 30 minutes. Avec un peu de talent artisanal, un carton privé en carton peut être effectué rapidement.

résumé

Je vous souhaite un joyeux Noël et un joyeux Noël. Bien que Corona soit toujours sous contrôle, mais il ne doit pas freiner le lecteur de fabricant. Comme mentionné dans le code source, vous avez la possibilité d'ajouter vos propres effets ou de tout laisser comme ça. Aussi concevables sont des tuyaux à LED qui sont enveloppés autour d'un boîtier. Tout est possible, laissez simplement votre créativité.

D'autres projets pour AZ-Livraison de moi, voir
https://github.com/M3taKn1ght/Blog-Repo.