Sternenhimmel Led Krawatte - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:19

Vor einiger Zeit fand ich ein Kinderspielzeug mit Glasfaser in einem Dollar-Laden und begann darüber nachzudenken, was ich damit machen könnte.

Eine meiner verrückten Ideen war, eine Krawatte mit Sternenhimmel-Effekt zu nähen.

Ich hatte noch einige Arduino Pro Minis, Adafruit-Boards und Batterien herumliegen, die wahrscheinlich zu diesem Projekt passen würden.

Als ich also in einem Pfandhaus in meiner Stadt eine schöne weite Krawatte gefunden hatte und eine Kiste gefunden hatte, die zur Hardware passte, beschloss ich, sie zu versuchen und zu bauen.

Dieses anweisbare zeigt Ihnen, wie ich es gemacht habe.

Es läuft auf einem Arduino Pro Mini, einem Adafruit Powerboost 500-Ladegerät, einem Emmerich icr 18650nh-sp und 5 weißen LEDs. Der Code bewirkt, dass die Helligkeit der LEDs zufällig ändert. (Die ersten 40 Sekunden des Videos haben 3x Geschwindigkeit)

Schritt 1: Schaltpläne und Hardware

Ich verwende folgende Hardware:

- Platine mit eisweißen LEDs und 220 Ohm Widerständen.

- Arduino pro mini (ich habe einen Knockoff verwendet)

- Adafruit Powerboost 500 Ladegerät

- Emmerich Li-Ion Akku ICR-18650NH-SP

- Glasfasern (in verschiedenen Größen)

Schritt 2: Herstellung der PCB-Hosting der LEDs

Ich schneide einen Streifen von einer Platine ab, um die LEDs zu halten, und verwende die LED-Pins, um sie an die Hauptplatine zu löten.

Alle Kathoden (-) mit GND verbunden und die Hälfte der Stifte verwendet, um sie an die Hauptplatine zu löten.

Verbunden alle Anoden (+) mit Widerständen und mit Kabeln zum Arduino.

LEDs müssen jeweils an einen der folgenden PWM-Ports angeschlossen werden: 3, 5, 6, 9, 10, 11

Dummerweise habe ich bei diesem Projekt viele Fehler gemacht und vergessen, die richtigen PWM-Ports zu überprüfen, also musste ich ein paar später nachlöten. Getestet mit High/Low also ist mir das erst später aufgefallen.

Ich begann mit 7 LEDs, aber es gab nur 6 PWM-Ports und eine der LEDs, die ich umlötete, starb. Ich habe nur die 5 funktionierenden LEDs behalten und verwende die 6. nicht.

Schritt 3: Herstellung der Box

Ich habe einen Bosch GRO (wie ein Dremel) und einen Bohrer verwendet, um die Form der Batterie, des Knopfes, des Micro-USB-Anschlusses, der Header vom Arduino und der Glasfasern auszuschneiden. (Verwenden Sie eine Staubmaske!)

Habe den Akku mit 2 Bändern an das Gehäuse geklebt.

Verwendet Schrauben, um die Adafruit-Platine und die Platine zu montieren.

Reibung beim Öffnen und Schließen beschädigte einige Drähte. Ich musste sie umlöten und Kleber verwenden, um zu verhindern, dass es wieder passiert.

Schritt 4: Vorbereiten der Krawatte

Die Nähte vom unteren Teil der Krawatte wurden entfernt, um die Gummiplatte zu passen.

Um die Hardware zu verstecken und bei Bedarf trotzdem darauf zugreifen zu können, habe ich mich für einen Reißverschluss entschieden.

Ich kann mit einer Nähmaschine nicht gut umgehen, also hat meine süße Mama einen Reißverschluss hinten auf die Krawatte gelegt.

Danach klebte ich die Gummiplatte in die Krawatte. Ich hatte Angst, zu viel Kleber zu verwenden, der den Stoff sättigt und von vorne sichtbar ist, also habe ich versucht, ihn auszugleichen und nicht zu viel zu verwenden. Insgesamt sieht es gut aus, aber an einigen Stellen habe ich zu viel oder zu wenig Kleber bemerkt, weil er durch den Stoff gedrungen ist oder den Stoff nicht so gut klebt. Glücklicherweise ist dies bei hellem Licht nur aus nächster Nähe kaum zu erkennen.

Box und Krawatte sind fertig. Zeit, die Glasfaser zu kleben!

Schritt 5: Kleben der Fiberoptik

Das Spielzeug hatte ein großes Bündel von Glasfaserkabeln, die leicht auseinander brachen. Ich versuchte sie zuerst einzeln zu kleben, merkte aber bald, dass es besser wäre, kleine Bündel zu machen und diese sofort an die LED zu kleben. Das würde es einfacher machen, es ruhig zu halten, bis der Leim trocken war. Habe die erste LED durcheinander gebracht, um dies herauszufinden.

Verwenden Sie unbedingt einen transparenten Kleber! Der, den ich verwendet habe, trocknete sehr langsam und der schnell trocknende Kleber, den ich auf der ersten LED ausprobierte, wurde weiß, wodurch einige Fasern der ersten LED weniger hell wurden.

Ich habe kleine schwarze Gummiplatten geklebt, um ein Austreten von Licht nach oben zu verhindern und die LEDs zu trennen.

Eines der Blätter verhinderte das Schließen des Gehäuses, also fügte ich ein Gummiband hinzu, um die Abdeckung geschlossen zu halten.

Schritt 6: Fiberoptik durch die Krawatte stecken

Von unten beginnend habe ich mit einer Nadel Löcher gequetscht und die Fasern nacheinander durchgesteckt. Die Fasern jeder LED verteilen sich zufällig über die Krawatte.

Ich habe einen schwarzen Streifen auf die Rückseite geklebt, der bis zum kleineren Teil der Krawatte reichen sollte, um das Gewicht der Box zu halten, aber nachdem ich alle Drähte durchgesteckt und die Spannung der Drähte gefühlt hatte, entschied ich mich zum Kleben Alles bis zur Krawatte war eine bessere Idee und schneide den Streifen ab.

Da die Glasfaserkabel des Spielzeugs so kurz waren, war es schwierig, sie überall an der Krawatte zu befestigen. Ich war in der Positionierung der Box eingeschränkt und hatte Schwierigkeiten, alles so flach zu machen, wie ich es wollte.

Schritt 7: Kleben von Glasfasern an die Krawatte

Ich klebte alle Glasfaserdrähte auf die Gummiplatte, um zu verhindern, dass die Drähte aus der Gummiplatte gezogen werden und um die Krawatte flach zu machen.

Um sicherzustellen, dass ich die Klammer beim Druck nicht an die Krawatte geklebt habe, lege ich etwas Papier dazwischen. Sieht nicht so toll aus aber funktioniert gut. Und Sie sehen es nicht, wenn es geschlossen ist.

Nachdem der Kleber getrocknet war, schneide ich die Drähte auf der Vorderseite ab und schneide die Gummiplatte etwas über dem höchsten Draht ab, da die Krawatte etwas zu lang war.

Fotos mit dem weißen Hemd sind gemacht, bevor ich das letzte Stück Gummi abgeschnitten habe.

Schritt 8: Der Code

Unter dem Code habe ich für die Krawatte geschrieben.

Alle LEDs haben einen eingestellten "Durchschnitt" (eigentlich keinen Durchschnitt, sondern eine mittlere Helligkeit).

Sobald es diesen Durchschnitt erreicht, entscheidet es sich mit einer Chance von 3/4 zu einer niedrigeren Helligkeit. Es setzt auch zufällig eine neue minimale Helligkeit, maximale Helligkeit, Wartezeit für minimale und maximale Helligkeit und die Geschwindigkeit, mit der es jede Runde (1-255) von 5 voreingestellten Werten erhöht oder verringert wird. Dann wird es einen Zyklus machen, bis es wieder den Durchschnitt erreicht. Es können sich nur 2 LEDs gleichzeitig in einem High-Zyklus befinden.

Jeder Zustand wird durch einen ganzzahligen Wert (1-7) dargestellt, der bestimmt, ob er auf durchschnittlich niedrig, niedrig-durchschn., niedrig wartend, aktualisiert usw. wird.

Informationen zum Hochladen von Code auf das arduino finden Sie unter www.arduino.cc

/* Starry Sky Tie * * Dies ist ein Skript zum zufälligen Überblenden von 5 LEDs von einer durchschnittlichen auf eine niedrigere * oder höhere Helligkeit mit zufälligen niedrigeren, höheren und Timing-Einstellungen *, um bei Verwendung mit Glasfasern wie ein Sternenhimmel auszusehen. * In diesem Fall werden diese unentschieden umgesetzt. * * Chance nach oben/unten = 1/4 nach oben, 3/4 nach unten, wobei maximal 2 * gleichzeitig auf das Maximum steigen. * * Durchschnitt bleibt gleich. * Minimum, Maximum und Timing-Optionen ändern sich zufällig * von 5 Optionen jedes Mal, wenn eine LED wieder den Durchschnitt erreicht. * * Erstellt von Billy Jaspers, Mai 2019. *

/ Pins deklarieren

int LED01 = 3; int LED02 = 5; int LED03 = 6; int LED04 = 9; int LED05 = 11;

// Zeitvariablen

unsigned long currentTime; lange Wartezeit ohne Vorzeichen[5]; unsigned long lastRound;

// LED-Variablen

int hellMin [5] = { 10, 10, 10, 10, 10 }; // Minimale Helligkeit int brightAvg [5] = { 200, 200, 200, 200, 200}; // Durchschnittliche Helligkeit int brightMax[5] = { 240, 240, 240, 240, 240 }; // Maximale Helligkeit int timeWaitLow[5] = {1000, 1000, 1000, 1000, 1000}; // Wartezeit int timeWaitAvg[5] = { 5000, 5000, 5000, 5000, 5000 }; // Wartezeit int timeWaitMax[5] = { 4000, 3000, 3000, 3000, 3000 }; // Wartezeit int Inkrement[5] = { 2, 5, 4, 5, 2 }; // Erhöhung der Helligkeit int currentBright[5]= { 200, 230, 210, 210, 235 }; // Aktuelle Helligkeit

// Möglichkeiten der LED-Variablen

int hellMinPos[5] = { 5, 20, 40, 5, 20 }; // Möglichkeiten der minimalen Helligkeit int brightMaxPos[5] = { 240, 245, 230, 225, 245 }; // Maximale Helligkeitsmöglichkeiten int timeLowPos[5] = { 3000, 5000, 4000, 2000, 1000 }; // Wartezeit auf Möglichkeiten geringer Helligkeit int timeHighPos[5] = { 3000, 1000, 500, 2000, 4000 }; // Wartezeit bei hohen Helligkeitsmöglichkeiten int timeAvgPos[5] = { 3000, 5000, 4000, 7000, 8000 }; // Wartezeit auf durchschnittliche Helligkeitsmöglichkeiten int InkrementPos[5] = { 2, 4, 5, 3, 1 }; // Erhöhung der Helligkeitsmöglichkeiten

// Variablen

bool startup = true; // Müssen die Starteinstellungen gestartet werden?

// Richtungsvariablen

/* 0 = Warten auf Durchschnitt 1 = Avg auf Low gehen 2 = Warten Low 3 = Low auf Avg gehen 4 = Avg auf Max gehen 5 = Max warten 6 = High auf Avg gehen 7 = Variablen aktualisieren*/ int statusLED[5] = {0, 0, 0, 0, 0}; int MengeHighLED = 0; int RefreshRate = 50; bool statusWaiting[5] = { false, false, false, false, false}; // Wartet die LED?

// Zufällige Variablen

lange Zufallszahl; // Long zum Speichern der Zufallszahl long randomNumberTwo; // Long zum Speichern der zweiten Zufallszahl

// Zähler

int i = 0; // Zähler für Hauptschleife

Leere Einrichtung () {

Serienbeginn (115200); // Starten Sie die serielle RandomSeed (analogRead (A0)); // Setze Randomseed

// Ausgänge deklarieren

PinMode (LED01, AUSGANG); PinMode (LED02, AUSGANG); PinMode (LED03, AUSGANG); pinMode (LED04, AUSGANG); PinMode (LED05, AUSGANG); }

// Daten in LEDs schreiben

Void writeToLED () { analogWrite (LED01, currentBright [0]); analogWrite (LED02, currentBright[1]); analogWrite (LED03, currentBright[2]); analogWrite (LED04, currentBright[3]); analogWrite (LED05, currentBright[4]); }

// Hauptschleife

Void loop () { if (startup) {// Starteinstellungen lastRound = millis (); // LastRound für Boot setzen writeToLED(); // Startdaten in LED-Startup schreiben = false; // Start ausschalten} currentTime = millis(); // Aktuelle Uhrzeit einstellen

if (currentTime - lastRound >= refreshRate){

for (i=0;i<5;i++){ if (statusLED == 7){ // -7- Led aktualisieren randomNumber = random(5); helleMin = helleMinPos[zufällige Zahl]; // Zufallswert für minimale Helligkeit einstellen randomNumber = random(5); brightMax = brightMaxPos[randomNumber]; // Zufallswert für maximale Helligkeit einstellen randomNumber = random(5); timeWaitLow = timeLowPos[randomNumber]; // Zufallswert für geringe Wartezeit setzen randomNumber = random(5); timeWaitMax = timeHighPos[randomNumber]; // Zufallswert für hohe Wartezeit setzen randomNumber = random(5); timeWaitAvg = timeAvgPos[zufällige Zahl]; // Zufallswert für durchschnittliche Wartezeit setzen randomNumber = random(5); Inkrement = InkrementPos[randomNumber]; // Zufallswert für Inkrementwert setzen randomNumber = random(2); // Zufallswert für Richtung setzen randomNumberTwo = random(2); // Zufallswert für Richtung setzen if (randomNumber == 1 && randomNumberTwo == 0 && numberHighLED = brightAvg){ statusLED = 0; // Wenn am niedrigsten Punkt: Gehe zu Waiting Avg }else{ currentBright = currentBright+increment; // Sonst: Höhere Helligkeit } }else if (statusLED == 2){ // -2- Waiting Low if (!statusWaiting){ // Falls nicht wartend: waitTime = millis(); // Wartezeit setzen statusWaiting = true; // Beginne mit dem Warten }else if(statusWaiting && currentTime-waitingTime >= timeWaitLow){ // Wenn das Warten UND timeWaitAvg abgelaufen ist: statusWaiting = false; // Aufhören zu warten statusLED = 3; // setze statusLed auf Waiting for update } }else if (statusLED == 1){ // -1- Going Avg to Low if (currentBright <= brightMin){ statusLED = 2; // Wenn am niedrigsten Punkt: Gehe zu Waiting Low }else{ currentBright = currentBright-increment; // Sonst: Niedrigere Helligkeit } }else if (statusLED == 6){ // -6- Going Max to Avg if (currentBright = timeWaitMax){ // Wenn das Warten UND timeWaitAvg vergangen ist: statusWaiting = false; // Aufhören zu warten statusLED = 6; // setze statusLed auf Waiting for update } }else if (statusLED == 4){ // -4- Going Avg to Max if (currentBright >= brightMax){ statusLED = 5; // Wenn am niedrigsten Punkt: Gehe zu Waiting High }else{ currentBright = currentBright+increment; // Sonst: Höhere Helligkeit } }else if (statusLED == 0){ // -0- Warten auf Durchschnitt if (!statusWaiting){ // Wenn nicht warten: waitTime = millis(); // Wartezeit setzen statusWaiting = true; // Beginne mit dem Warten }else if(statusWaiting && currentTime-waitingTime >= timeWaitAvg){ // Wenn das Warten UND timeWaitAvg abgelaufen ist: statusWaiting = false; // Aufhören zu warten statusLED = 7; // setze statusLed auf Waiting for update } } } i=0; lastRound = millis(); // Wird gesetzt, wenn die letzte Runde beendet ist. writeToLED(); // Alle Daten in die LEDs schreiben } }

Schritt 9: Endprodukt

Ich denke, es hat gut geklappt. Die Krawatte ist nicht zu dick, steif, lang oder schwer und der Sterneffekt sieht toll aus.