Fancy LED-hoed: 5 stappen (met afbeeldingen)

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:18

Ik heb altijd al een Arduino-project willen doen, maar had er nooit geweldige ideeën voor totdat mijn familie werd uitgenodigd voor een chique hoedenfeestje. Met twee weken doorlooptijd was ik benieuwd of ik zowel een bewegingsgevoelige LED-animatiehoed kon plannen als uitvoeren. Het bleek dat ik het kon! Ik ging waarschijnlijk een beetje overboord, maar het totale project kostte ongeveer $ 80. Met wat experimenteren en wat coderen zou je het voor minder kunnen doen.

Het doel met de hoed was het volgende:

1. Laat een set lichten van de voorkant van de hoed naar de achterkant bewegen, één licht aan elke kant
2. Verander de snelheid van de reis van het licht bepaald door de kanteling van de hoed van voren naar achteren
3. Laat de lichten omkeren wanneer de hoedband naar beneden was gekanteld (d.w.z. emuleer het effect van de zwaartekracht op de lichten)
4. Verander van kleur op basis van de kanteling van de hoed van links naar rechts
5. Voel schokken en geef een speciaal effect weer
6. Voel hoe de drager ronddraait en laat een speciaal effect zien
7. Laat het volledig in de hoed zitten

Stap 1: benodigde onderdelen

Ik heb de volgende hoofdcomponenten gebruikt (inclusief niet-gelieerde Amazon-links):

• Teensy LC-microcontroller - Ik koos dit boven een gewone Arduino vanwege zijn kleine formaat en het heeft een speciale aansluiting voor het besturen van mijn LED's, evenals een sterke bibliotheek en community-ondersteuning.
• Op Bosch BNO055 gebaseerde positiesensor - eerlijk gezegd een van de eerste waar ik documentatie over vond. Er zijn veel goedkopere opties, maar als je eenmaal doorhebt dat Bosch het doet, doet het veel voor je dat je anders in code zou moeten doen
• WS2812 adresseerbare ledstrip - Ik heb gekozen voor een lengte van 1 meter met 144 leds per meter. Het hebben van die dichtheid helpt het licht er meer uit te zien alsof het beweegt, in plaats van dat afzonderlijke elementen achter elkaar oplichten.

En de volgende kleine onderdelen:

• Een hoed - elke hoed met een hoedband is voldoende. Dit is een hoed van $ 6 van een plaatselijke winkel. Als het een naad aan de achterkant heeft, is het gemakkelijker om de bedrading erdoor te krijgen. Let op of de hoedband is vastgelijmd, want dat geeft ook wat extra moeite. Deze is langs de bovenkant genaaid, maar de onderkant is gemakkelijk omhoog te trekken.
• 4.7K ohm weerstanden
• 3x AAA-batterijhouder - met behulp van 3 AAA-batterijen wordt de spanning precies in het bereik geleverd dat de elektronica wil, wat de zaken vereenvoudigt. AAA past gemakkelijker in een hoed dan AA en heeft nog steeds een geweldige looptijd.
• Draad met een kleine dikte - ik gebruikte wat stevige draad die ik had liggen van een vorig LED-project.
• Soldeerbout en soldeer
• Wat spandex dat overeenkomt met de kleur van de binnenkant van de hoed, en draad

Aanbevolen, maar optioneel:

• Snelkoppelingen voor de batterijdraden
• Helping Hands-tool, deze dingen zijn erg klein en moeilijk te solderen

Stap 2: Pas de hoed aan

Je hebt een plaats in de hoed nodig om de elektronica te monteren en een plaats voor de batterij. Mijn vrouw werkt professioneel met kleding, dus ik heb haar om advies en hulp gevraagd. We hebben uiteindelijk twee zakken gemaakt met spandex. De eerste kleinere zak aan de voorkant is puntig zoals de hoed zelf, zodat wanneer de elektronica is geïnstalleerd, de positiesensor redelijk goed op zijn plaats wordt gehouden, maar indien nodig gemakkelijk kan worden verwijderd. De tweede zak aan de achterkant is om de batterij op zijn plaats te houden.

De zakken waren genaaid met draad die overeenkwam met de kleur van de hoed, helemaal langs de kroonlijn. Afhankelijk van de stijl van de hoed en het materiaal wordt hij met deze techniek gemaakt van YMMV.

We ontdekten ook dat de band van de hoed aan één kant in zichzelf plooit en op die locatie volledig aan de hoed was genaaid. We moesten de originele naad verwijderen om de LED's onder de band te laten lopen. Tijdens de bouw werd het op zijn plaats gehouden met pinnen en vervolgens genaaid met bijpassende draad als het klaar was.

Ten slotte openden we de naad aan de achterkant van de hoed waar deze door de band wordt bedekt. We stopten de kabelboom die bij de LED's was geleverd door die naad en voerden de eerste LED in de strip om precies op de naad te zitten. Vervolgens hebben we de LED's om de hoed gewikkeld en de strip doorgesneden zodat de laatste LED direct naast de eerste zou komen. De LED-strip kan alleen met de hoedband op zijn plaats worden gehouden, maar afhankelijk van uw band en materiaal moet u de LED's mogelijk vastzetten door te naaien of te lijmen.

Stap 3: Sluit het aan

Het Teensy-bord en de LED's werken overal van 3,3 v tot 5 v voor stroom. Daarom heb ik ervoor gekozen om 3 AAA-batterijen te gebruiken, de uitgangsspanning van 4,5 V ligt mooi in dat bereik en ze hebben voldoende looptijd voor de manier waarop ik de LED's heb geprogrammeerd om te werken. Je zou in staat moeten zijn om ruim 8 uur aan runtime te krijgen.

Bedrading van de stroom

Ik heb de positieve en negatieve draden van de accubak en LED's met elkaar verbonden en vervolgens op de juiste locaties op de Teensy gesoldeerd. Het positieve van de batterij moet worden aangesloten op de pin rechtsboven van de Teensy in het diagram (met het label Vin op het bord), en het negatieve kan worden aangesloten op elke pin met het label GND. Handig is er een direct aan de andere kant van het bord, of direct naast de Vin-pin. Het volledige pinout-diagram voor het bord vindt u onderaan deze pagina. En in sommige gevallen zit er een papieren exemplaar bij als je het bord bestelt.

Als u van plan bent code uit te voeren waarbij slechts een paar LED's tegelijk zijn ingeschakeld, kunt u de LED's van de Teensy zelf voorzien door een 3.3v-uitgang en GND te gebruiken, maar als u te veel stroom probeert te trekken, kunt u het bord beschadigen. Dus om jezelf de meeste opties te geven, is het het beste om de LED's rechtstreeks op je batterijbron aan te sluiten.

Bedrading van de LED's

Ik koos de Teensy LC voor dit project omdat deze een pin heeft die het veel gemakkelijker maakt om adresseerbare LED's aan te sluiten. Aan de onderkant van het bord spiegelt de pin die tweede is van de linker pin #17, maar heeft ook 3,3v erop. Dit wordt een pull-up genoemd en op andere borden zou je een weerstand moeten aansluiten om die spanning te leveren. In het geval van de Teensy LC kun je gewoon rechtstreeks van die pin rechtstreeks naar de datakabel van je LED's gaan.

Bedrading van de positiesensor

Sommige van de beschikbare BNO055-kaarten zijn veel strenger op spanning en willen slechts 3,3v. Daarom heb ik de Vin op het BNO055-bord aangesloten vanaf de speciale 3.3v-uitgang op de Teensy, de 3e pin aan de rechterkant. Vervolgens kunt u de GND op de BNO055 aansluiten op elke GND op de Teensy.

De BNO055 positiesensor gebruikt I2c om met de Teensy te praten. I2c vereist pull-ups, dus ik heb twee weerstanden van 4,7 K ohm aangesloten van een 3,3 V-uitgang op de Teensy op pinnen 18 en 19. Vervolgens heb ik pin 19 aangesloten op de SCL-pin op het BNO055-bord en 18 op de SDA-pin.

Bedradingstips/trucs

Om dit project te doen heb ik massieve draad gebruikt in plaats van gestrand. Een voordeel van massieve draad is het solderen op prototypeborden zoals deze. Je kunt wat draad strippen, het tot 90 graden buigen en het door de onderkant van een van de klemmen steken, zodat het afgesneden uiteinde van de draad boven je bord uitsteekt. Je hebt dan maar een kleine hoeveelheid soldeer nodig om het op de terminal te houden en het overtollige kun je gemakkelijk afsnijden.

De massieve draad kan moeilijker zijn om mee te werken, omdat hij de neiging heeft om te blijven hoe hij gebogen is. Voor dit project was dat echter een voordeel. Ik knipte en vormde mijn draden op zo'n manier dat de oriëntatie van de positiesensor consistent zou zijn als ik de elektronica uit de hoed plaatste en verwijderde voor tweaken en programmeren.

Stap 4: Programmeren

Nu alles in elkaar zit, heb je een Arduino-compatibele programmeertool nodig. Ik gebruikte de eigenlijke Arduino IDE (werkt met Linux, Mac en pc). Je hebt ook de Teensyduino-software nodig om te communiceren met het Teensy-bord. Dit project maakt intensief gebruik van de FastLED-bibliotheek om de kleur- en positieprogrammering van de LED's te doen.

Kalibreren

Het eerste dat u wilt doen, is naar de uitstekende GitHub-repository van Kris Winer voor de BNO055 gaan en zijn BNO_055_Nano_Basic_AHRS_t3.ino-schets downloaden. Installeer die code terwijl de seriële monitor draait en het zal u vertellen of het BNO055-bord correct online komt en de zelftests doorstaat. Het zal u ook helpen bij het kalibreren van de BNO055, wat u later meer consistente resultaten zal geven.

Aan de slag met de Fancy LED sketch

De code voor de Fancy LED-hoed is specifiek bijgevoegd, en ook op mijn GitHub-repository. Ik ben van plan meer aanpassingen aan de code aan te brengen en die zullen op de GitHub-repo worden geplaatst. Het bestand hier weerspiegelt de code toen deze Instructable werd gepubliceerd. Na het downloaden en openen van de schets, zijn er een paar dingen die je moet veranderen. De meeste belangrijke waarden die moeten worden gewijzigd, staan helemaal bovenaan als #define-statements:

Regel 24: #define NUM_LEDS 89 - verander dit in het werkelijke aantal LED's op uw LED-strip

Regel 28: #define SERIAL_DEBUG false - u wilt dit waarschijnlijk waar maken, zodat u de uitvoer op de seriële monitor kunt zien

Positiedetectiecode:

Positiedetectie en de meeste van uw aanpassingen beginnen bij regel 742 en gaan door 802. We krijgen Pitch-, Roll- en Yaw-gegevens van de positiesensor en gebruiken deze om waarden in te stellen. Afhankelijk van hoe uw elektronica is gemonteerd, moet u deze mogelijk wijzigen. Als u de positiesensor monteert met de chip naar de bovenkant van de hoed en de pijl naast X op het bord naar de voorkant van de hoed wijst, ziet u het volgende:

• Pitch knikt met je hoofd
• Rollen is je hoofd kantelen, b.v. raak je oor aan op je schouder
• Yaw is welke richting. u kijkt (noord, west, enz.).

Als je board in een andere richting is gemonteerd, moet je Pitch/Roll/Yaw verwisselen zodat ze zich kunnen gedragen zoals je zou willen.

Om de Roll-instellingen aan te passen, kunt u de volgende #define-waarden wijzigen:

• ROLLOFFSET: met je hoed stabiel en zo gecentreerd als het kan, als de rol niet 0 is, verander dit dan met het verschil. D.w.z. als je Roll bij -20 ziet wanneer je hoed gecentreerd is, maak deze 20 dan.
• ROLLMAX: de maximale waarde die moet worden gebruikt voor rolmeting. Het gemakkelijkst te vinden door de hoed te dragen en uw rechteroor naar uw rechterschouder te bewegen. Hiervoor heb je een lange USB-kabel nodig als je de seriële monitor gebruikt.
• ROLLMIN: de laagste waarde om te gebruiken voor rolmeting, voor wanneer u uw hoofd naar links kantelt

Evenzo voor Pitch:

• MAXPITCH - de maximale waarde wanneer u omhoog kijkt
• MINPITCH - de minimale waarde als je naar beneden kijkt
• PITCHCENTER - de pitchwaarde als je recht vooruit kijkt

Als u SERIALDEBUG bovenaan het bestand op true instelt, zou u de huidige waarden voor Roll/Pitch/Yaw-uitvoer naar de seriële monitor moeten zien om deze waarden aan te passen.

Andere parameters die u misschien wilt wijzigen

• MAX_LED_DELAY 35 - de langzaamste die het LED-deeltje kan bewegen. Dit is in milliseconden. Het is de vertraging van het verplaatsen van de ene LED naar de volgende in de string.
• MIN_LED_DELAY 10 - de vasten dat het LED-deeltje kan bewegen. Zoals hierboven is het in milliseconden.

Conclusie

Als je zo ver bent gegaan, zou je een volledig functionerende en leuke LED-hoed moeten hebben! Als u er meer mee wilt doen, vindt u op de volgende pagina geavanceerde informatie over het wijzigen van instellingen en het doen van uw eigen dingen. evenals enige uitleg van wat de rest van mijn code doet.

Stap 5: Geavanceerd en optioneel: in de code

Impact- en spindetectie

Impact-/spindetectie wordt gedaan met behulp van de high-G-sensorfuncties van de BNO055. Je kunt de gevoeligheid ervan aanpassen met de volgende regels in initBNO055():

• Regel #316: BNO055_ACC_HG_DURATION - hoe lang het evenement moet duren
• Regel #317: BNO055_ACC_HG_THRESH - hoe hard moet de impact zijn?
• Regel #319: BNO055_GYR_HR_Z_SET - drempel voor rotatiesnelheid
• Regel #320: BNO055_GYR_DUR_Z - hoe lang moet de rotatie zelfs duren?

Beide waarden zijn 8 bit binair, momenteel is de impact ingesteld op B11000000, wat 192 van de 255 is.

Wanneer een impact of spin wordt gedetecteerd, stelt de BNO055 een waarde in waarnaar de code aan het begin van de Loop zoekt:

// Detecteer eventuele interrupts die zijn geactiveerd, d.w.z. vanwege hoge G-byte intStatus = readByte (BNO055_ADDRESS, BNO055_INT_STATUS); if(intStatus > 8) { impact(); } else if(intStatus > 0) { spin(); }

Zoek naar de regel void impact() hierboven in de code om het gedrag bij impact te veranderen, of void spin() om het spingedrag te veranderen.

Helpers

Ik heb een eenvoudige hulpfunctie gemaakt (void setAllLeds()) om snel alle LED's op één kleur in te stellen. Je kunt het gebruiken om ze allemaal uit te schakelen:

setAllLeds(CRGB::Zwart);

Of u kunt elke kleur kiezen die wordt herkend door de FastLED-bibliotheek:

setAlleLeds(CRGB::Rood);

Er is ook een fadeAllLeds()-functie die alle LED's met 25% dimt.

De deeltjesklasse

Om de bedrading aanzienlijk te vereenvoudigen, wilde ik een enkele reeks LED's gebruiken, maar ze laten zich gedragen als meerdere strings. Aangezien dit mijn eerste poging was, wilde ik het zo eenvoudig mogelijk houden, dus behandel ik de ene snaar als twee, met de middelste LED ('s) daar zou de splitsing zijn. Omdat we een even getal of een oneven getal kunnen hebben, moeten we daar rekening mee houden. Ik begin met enkele globale variabelen:

/* * Variabele en containers voor LED's */ CRGB-leds[NUM_LEDS]; statisch niet-ondertekend int curLedDelay = MAX_LED_DELAY; statische int centerLed = NUM_LEDS / 2; static int maxLedPos = NUM_LEDS / 2;static bool oddLeds = 0; statische bool partikelDir = 1; statische bool speedDir = 1; unsigned long dirCount; niet-ondertekende lange hueCount;

En wat code in setup():

if(NUM_LEDS % 2 == 1) { oddLeds = 1; maxLedPos = NUM_LEDS/2; } else { oddLeds = 0; maxLedPos = NUM_LEDS/2 - 1; }

Als we oneven getallen hebben, willen we het 1/2 punt als midden gebruiken, anders willen we het 1/2 punt - 1. Dit is gemakkelijk te zien met 10 of 11 LED's:

• 11 LED's: 11/2 met gehele getallen zou moeten evalueren tot 5. en computers tellen vanaf 0. Dus 0 - 4 is de ene helft, 6 - 10 is de andere helft en 5 is er tussenin. We behandelen #5 in dit geval alsof het deel uitmaakt van beide, d.w.z. het is #1 voor beide virtuele strings van LED's
• 10 LED's: 10/2 is 5. Maar aangezien computers vanaf 0 tellen, moeten we er een verwijderen. Dan hebben we 0 - 4 voor de ene helft en 5 - 9 voor de andere. #1 voor de eerste virtuele string zal 4 zijn, en #1 voor de tweede virtuele string zal #5 zijn.

Dan moeten we in onze deeltjescode wat tellen vanaf onze algehele positie tot de werkelijke posities op de LED-string:

if(oddLeds) { Pos1 = centerLed + currPos; Pos2 = centerLed - currPos; } else { Pos1 = centerLed + currPos; Pos2 = (centerLed -1) - currPos; }

De code heeft ook voorwaarden waar het deeltje van richting kan veranderen, dus daar moeten we ook rekening mee houden:

if(particleDir) {if((currPos == NUM_LEDS/2) && oddLeds){ currPos = 0; } else if((currPos == NUM_LEDS/2 - 1) && (!oddLeds)){ currPos = 0; } else { currPos++; } } else { if((currPos == 0) && oddLeds){ currPos = centerLed; } else if((currPos == 0) && (!oddLeds)){ currPos = centerLed - 1; } else { currPos--; } }

We gebruiken dus de beoogde richting (particleDir), om te berekenen welke LED vervolgens moet branden, maar we moeten ook overwegen of we ofwel het echte einde van de LED-string hebben bereikt, of ons middelpunt, dat ook als een einde voor elk van de virtuele strings.

Als we dat allemaal hebben uitgevogeld, steken we het volgende licht aan als dat nodig is:

if(particleDir) {if(oddLeds) {Pos1 = centerLed + currPos; Pos2 = centerLed - currPos; } else { Pos1 = centerLed + currPos; Pos2 = (centerLed -1) - currPos; } } else { if(oddLeds) { Pos1 = centerLed - currPos; Pos2 = centerLed + currPos; } else { Pos1 = centerLed - currPos; Pos2 = (centerLed -1) + currPos; } } leds [Pos1] = CHSV (currHue, 255, 255); leds[Pos2] = CHSV(currHue, 255, 255); FastLED.show();}

Waarom zou je hier überhaupt een les van maken? Zoals het is, is dit vrij eenvoudig en hoeft het niet echt in een klas te zijn. Ik heb echter plannen voor de toekomst om de code bij te werken zodat meer dan één deeltje tegelijk kan optreden, en sommige in omgekeerde volgorde, terwijl andere vooruit gaan. Ik denk dat er een aantal geweldige mogelijkheden zijn voor spindetectie met behulp van meerdere deeltjes.