Cappello a LED fantasia: 5 passaggi (con immagini)

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:04

Ho sempre voluto realizzare un progetto Arduino, ma non ho mai avuto grandi idee per uno fino a quando la mia famiglia non è stata invitata a una festa in maschera. Con un tempo di consegna di due settimane, ero curioso di sapere se potevo sia pianificare che realizzare un cappello di animazione LED sensibile al movimento. Ho scoperto che potrei! Probabilmente ho esagerato un po', ma il progetto totale è costato circa 80 dollari. Con la sperimentazione e un po' di codice potresti farlo per meno.

L'obiettivo con il cappello era il seguente:

1. Fai muovere una serie di luci dal centro davanti al cappello verso la parte posteriore, una luce su ciascun lato
2. Cambia la velocità di viaggio della luce dettata dall'inclinazione del cappello dalla parte anteriore a quella posteriore
3. Consenti alle luci di invertirsi quando la fascia del cappello è stata inclinata verso il basso (cioè emula l'effetto della gravità sulle luci)
4. Cambia colore in base all'inclinazione del cappello da sinistra a destra
5. Percepisci gli shock e mostra un effetto speciale
6. Senti chi lo indossa girare e mostra un effetto speciale
7. Fallo contenere completamente nel cappello

Passaggio 1: parti necessarie

Ho utilizzato i seguenti componenti principali (link Amazon non affiliati inclusi):

• Microcontrollore Teensy LC - L'ho scelto su un normale Arduino per le sue dimensioni ridotte e per la connessione speciale per il controllo dei miei LED, oltre a una solida libreria e al supporto della comunità.
• Sensore di posizione basato su Bosch BNO055 - onestamente uno dei primi su cui ho trovato documentazione. Ci sono opzioni molto meno costose, tuttavia una volta capito il Bosch fa molto per te che altrimenti dovresti fare nel codice
• Striscia LED indirizzabile WS2812 - Ho scelto una lunghezza di 1 metro con 144 LED per metro. Avere quella densità aiuta la luce a sembrare più in movimento, piuttosto che i singoli elementi che si accendono in sequenza.

E i seguenti componenti minori:

• Un cappello: andrà bene qualsiasi cappello con una fascia. Questo è un cappello da 6 dollari di un negozio locale. Se ha una cucitura nella parte posteriore sarà più facile far passare il cablaggio. Presta attenzione se la fascia del cappello è incollata, poiché ciò causerà anche qualche difficoltà in più. Questo è cucito lungo la parte superiore, ma il fondo si solleva facilmente.
• Resistori da 4,7K ohm
• Custodia per batterie 3x AAA: l'utilizzo di 3 batterie AAA genera una tensione esattamente nell'intervallo desiderato dall'elettronica, il che semplifica le cose. AAA si inserisce in un cappello più facilmente di AA e ha ancora un'ottima autonomia.
• Filo di piccolo calibro - Ho usato del filo solido che avevo in giro da un precedente progetto LED.
• Saldatore e saldatore
• Alcuni spandex che si abbinano al colore interno del cappello e filo

Suggerito, ma facoltativo:

• Connettori rapidi per i cavi della batteria
• Strumento Helping Hands, queste cose sono molto piccole e difficili da saldare

Passaggio 2: modifica il cappello

Avrai bisogno di un posto nel cappello per montare l'elettronica e un posto per la batteria. Mia moglie lavora professionalmente con l'abbigliamento, quindi le ho chiesto consiglio e aiuto. Abbiamo finito per creare due tasche con lo spandex. La prima tasca più piccola verso la parte anteriore è appuntita come il cappello stesso in modo che quando l'elettronica è installata, il sensore di posizione è tenuto abbastanza bene in posizione, ma può essere facilmente rimosso se necessario. La seconda tasca verso la parte posteriore serve per tenere in posizione il pacco batteria.

Le tasche erano cucite con filo intonato al colore del cappello, lungo tutta la linea della corona. A seconda dello stile del cappello e dei materiali, è realizzato in YMMV con questa tecnica.

Abbiamo anche scoperto che la fascia del cappello si ripiega su se stessa su un lato ed è stata completamente cucita al cappello in quella posizione. Abbiamo dovuto rimuovere la cucitura originale per far passare i LED sotto la fascia. Durante la costruzione è stato tenuto in posizione con spilli, e poi cucito con filo abbinato una volta completato.

Infine abbiamo aperto la cucitura sul retro del cappello dove fosse coperto dalla fascia. Abbiamo infilato il cablaggio fornito con i LED attraverso quella cucitura e abbiamo allineato il primo LED nella striscia per essere proprio sulla cucitura. Abbiamo quindi avvolto i LED attorno al cappello e tagliato la striscia in modo che l'ultimo LED fosse proprio accanto al primo. La striscia LED può essere tenuta in posizione solo con la fascia del cappello, tuttavia, a seconda della fascia e del materiale, potrebbe essere necessario fissare i LED cucendo o incollando.

Passaggio 3: collegalo

La scheda Teensy e i LED funzioneranno ovunque da 3,3 V a 5 V per l'alimentazione. Questo è il motivo per cui ho scelto di utilizzare 3 batterie AAA, la tensione di uscita di 4,5 V è ben compresa in quell'intervallo e hanno un sacco di autonomia per il modo in cui ho programmato il funzionamento dei LED. Dovresti essere in grado di ottenere ben oltre 8 ore di autonomia.

Cablaggio dell'alimentazione

Ho collegato i cavi positivo e negativo della scatola della batteria e dei LED, quindi ho saldato il Teensy in posizioni appropriate. Il positivo della batteria deve essere collegato al pin in alto a destra del Teensy nel diagramma (etichettato Vin sulla scheda) e il negativo può essere collegato a qualsiasi pin etichettato GND. Convenientemente ce n'è uno direttamente sul lato opposto del tabellone, o proprio accanto al pin Vin. Lo schema completo della piedinatura della scheda è disponibile in fondo a questa pagina. E in alcuni casi una copia cartacea è inclusa quando ordinate la tavola.

Se stai pianificando di eseguire un codice che ha solo pochi LED accesi alla volta, puoi alimentare i LED dal Teensy stesso, utilizzando un'uscita a 3,3 V e GND, tuttavia se provi a tirare troppa potenza puoi danneggiare la scheda. Quindi, per darti la maggior parte delle opzioni, è meglio collegare i LED direttamente alla fonte della batteria.

Cablaggio dei LED

Ho scelto il Teensy LC per questo progetto in quanto ha un pin che rende molto più semplice il cablaggio dei LED indirizzabili. Sul fondo della scheda il pin che è il secondo da sinistra rispecchia il Pin #17, ma ha anche 3.3v su di esso. Questo è indicato come pull-up e su altre schede dovresti collegare un resistore per fornire quella tensione. Nel caso del Teensy LC puoi semplicemente cablare da quel pin direttamente al cavo dati del tuo LED.

Cablaggio del sensore di posizione

Alcune delle schede BNO055 disponibili sono molto più rigide sulla tensione e vogliono solo 3.3v. Per questo motivo, ho collegato il Vin sulla scheda BNO055 dall'uscita 3.3v dedicata sul Teensy, che è il terzo pin in basso a destra. È quindi possibile collegare il GND sul BNO055 a qualsiasi GND sul Teensy.

Il sensore di posizione BNO055 utilizza I2c per parlare con Teensy. I2c richiede pull-up, quindi ho collegato due resistori da 4,7 K ohm da un'uscita da 3,3 V sul Teensy ai pin 18 e 19. Ho quindi collegato il pin 19 al pin SCL sulla scheda BNO055 e il 18 al pin SDA.

Suggerimenti/trucchi per il cablaggio

Per realizzare questo progetto ho utilizzato un filo pieno anziché trecciato. Un vantaggio del filo solido è durante la saldatura su schede prototipo come queste. Puoi spellare del filo, piegarlo a 90 gradi e inserirlo attraverso la parte inferiore di uno dei terminali, in modo che l'estremità tagliata del filo sporga sopra la scheda. Quindi hai solo bisogno di una piccola quantità di saldatura per tenerlo al terminale e puoi tagliare facilmente l'eccesso.

Il filo pieno può essere più difficile da lavorare poiché tende a voler rimanere come è piegato. Tuttavia per questo progetto è stato un vantaggio. Ho tagliato e modellato i miei fili in modo tale che l'orientamento del sensore di posizione fosse coerente mentre inserivo e rimuovevo l'elettronica dal cappello per la messa a punto e la programmazione.

Passaggio 4: programmazione

Ora che tutto è assemblato avrai bisogno di uno strumento di programmazione compatibile con Arduino. Ho usato l'IDE Arduino effettivo (funziona con Linux, Mac e PC). Avrai anche bisogno del software Teensyduino per interfacciarti con la scheda Teensy. Questo progetto utilizza pesantemente la libreria FastLED per eseguire la programmazione del colore e della posizione dei LED.

Calibrazione

La prima cosa che vorrai fare è andare all'eccellente repository GitHub di Kris Winer per BNO055 e scaricare il suo schizzo BNO_055_Nano_Basic_AHRS_t3.ino. Installa quel codice con il monitor seriale in esecuzione e ti dirà se la scheda BNO055 è correttamente online e supera i test automatici. Ti guiderà anche attraverso la calibrazione del BNO055, che ti darà risultati più coerenti in seguito.

Iniziare con lo schizzo Fancy LED

Il codice per il cappello Fancy LED in particolare è allegato e anche sul mio repository GitHub. Ho intenzione di apportare ulteriori modifiche al codice e queste verranno pubblicate sul repository GitHub. Il file qui riflette il codice quando questo Instructable è stato pubblicato. Dopo aver scaricato e aperto lo schizzo, ci sono alcune cose che dovrai cambiare. La maggior parte dei valori importanti da modificare sono in cima alle istruzioni #define:

Riga 24: #define NUM_LEDS 89 - cambialo con il numero effettivo di LED sulla tua striscia LED

Riga 28: #define SERIAL_DEBUG false - probabilmente vorrai renderlo vero, in modo che tu possa vedere l'output sul monitor seriale

Codice di rilevamento della posizione

Il rilevamento della posizione e la maggior parte delle modifiche inizia dalla riga 742 e passa attraverso l'802. Otteniamo i dati di beccheggio, rollio e imbardata dal sensore di posizione e li usiamo per impostare i valori. A seconda di come sono montati i componenti elettronici, potrebbe essere necessario cambiarli. Se monti il sensore di posizione con il chip verso la parte superiore del cappello e la freccia accanto alla X stampata sulla scheda puntata verso la parte anteriore del cappello dovresti vedere quanto segue:

• Pitch sta annuendo con la testa
• Roll sta inclinando la testa, ad es. tocca l'orecchio sulla spalla
• Imbardata è quale direzione. stai affrontando (Nord, Ovest, ecc.).

Se la tua tavola è montata con un orientamento diverso dovrai scambiare Pitch/Roll/Yaw affinché si comportino come vorresti.

Per regolare le impostazioni Roll puoi modificare i seguenti valori #define:

• ROLLOFFSET: con il cappello stabile e il più centrato possibile, se il Roll non è 0, cambialo per la differenza. Cioè. se vedi Roll a -20 quando il tuo cappello è centrato, fai questo 20.
• ROLLMAX: il valore massimo da utilizzare per la misura del Rotolo. È più facile da trovare indossando il cappello e spostando l'orecchio destro verso la spalla destra. Avrai bisogno di un lungo cavo USB per farlo mentre usi il monitor seriale.
• ROLLMIN: il valore più basso da utilizzare per la misurazione del Roll, per quando si inclina la testa a sinistra

Allo stesso modo, per il passo:

• MAXPITCH - il valore massimo quando stai guardando in alto
• MINPITCH - il valore minimo quando guardi in basso
• PITCHCENTER - il valore del passo quando guardi dritto in avanti

Se imposti SERIALDEBUG su true nella parte superiore del file, dovresti vedere i valori correnti per l'output di Roll/Pitch/Yaw sul monitor seriale per aiutare a modificare questi valori.

Altri parametri che potresti voler modificare

• MAX_LED_DELAY 35 - il più lento che la particella LED può muovere. Questo è in millisecondi. È il ritardo dallo spostamento da un LED al successivo nella stringa.
• MIN_LED_DELAY 10 - il digiuno che la particella LED può muovere. Come sopra è in millisecondi.

Conclusione

Se sei arrivato così lontano, dovresti avere un cappello a LED completamente funzionante e divertente! Se vuoi fare di più con esso, la pagina successiva contiene alcune informazioni avanzate su come modificare le impostazioni e fare le tue cose. così come alcune spiegazioni su cosa sta facendo il resto del mio codice.

Passaggio 5: avanzato e facoltativo: all'interno del codice

Rilevamento impatto e rotazione

Il rilevamento dell'impatto/spinta viene eseguito utilizzando le funzioni del sensore ad alta gravità del BNO055. Puoi modificarne la sensibilità con le seguenti righe in initBNO055():

• Riga #316: BNO055_ACC_HG_DURATION - quanto tempo deve durare l'evento
• Riga #317: BNO055_ACC_HG_THRESH - quanto deve essere duro l'impatto
• Riga #319: BNO055_GYR_HR_Z_SET - soglia velocità di rotazione
• Riga #320: BNO055_GYR_DUR_Z - quanto tempo deve durare anche la rotazione?

Entrambi i valori sono binari a 8 bit, attualmente l'impatto è impostato su B11000000, che è 192 su 255.

Quando viene rilevato un impatto o una rotazione il BNO055 imposta un valore che il codice cerca proprio all'inizio del Loop:

// Rileva eventuali interrupt attivati, ad esempio a causa di un byte G elevato intStatus = readByte(BNO055_ADDRESS, BNO055_INT_STATUS); if(intStatus > 8) { impatto(); } else if(intStatus > 0) { spin(); }

Cerca la riga void impact() sopra nel codice per modificare il comportamento all'impatto o void spin() per modificare il comportamento di rotazione.

aiutanti

Ho creato una semplice funzione di supporto (void setAllLeds()) per impostare rapidamente tutti i LED su un singolo colore. Uno lo usa per spegnerli tutti:

setAllLeds(CRGB::Nero);

Oppure puoi scegliere qualsiasi colore riconosciuto dalla libreria FastLED:

setAllLeds(CRGB::Rosso);

C'è anche una funzione fadeAllLeds() che attenuerà tutti i LED del 25%.

La classe delle particelle

Per semplificare notevolmente il cablaggio volevo utilizzare una singola stringa di LED, ma farli comportare come più stringhe. Dato che questo è stato il mio primo tentativo, volevo mantenerlo il più semplice possibile, quindi tratto l'unica stringa come due, con i LED centrali lì, la divisione sarebbe. Dal momento che potremmo avere un numero pari o un numero dispari, dobbiamo tenerne conto. Comincio con alcune variabili globali:

/* * Variabile e contenitori per LED */ LED CRGB[NUM_LEDS]; static unsigned int curLedDelay = MAX_LED_DELAY; static int centerLed = NUM_LEDS / 2; static int maxLedPos = NUM_LEDS / 2;static bool oddLeds = 0; static bool particelleDir = 1; static bool speedDir = 1;unsigned long dirCount; hueCount lungo senza segno;

E un po' di codice in setup():

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

Se abbiamo numeri dispari, vogliamo usare il punto 1/2 come mezzo, altrimenti vogliamo il punto 1/2 - 1. Questo è facile da vedere con 10 o 11 LED:

• 11 LED: 11/2 con numeri interi dovrebbe restituire 5. ei computer contano da 0. Quindi 0 - 4 è la metà, 6 - 10 è l'altra metà e 5 è tra di loro. Trattiamo #5 in questo caso come se fosse parte di entrambi, cioè è #1 per entrambe le stringhe virtuali di LED
• 10 LED: 10/2 è 5. Ma poiché i computer contano da 0, dobbiamo rimuoverne uno. Quindi abbiamo 0 - 4 per una metà e 5 - 9 per l'altra. #1 per la prima stringa virtuale sarà 4 e #1 per la seconda stringa virtuale sarà #5.

Quindi nel nostro codice particellare dobbiamo fare un conteggio dalla nostra posizione complessiva alle posizioni effettive sulla stringa di LED:

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

Il codice ha anche condizioni in cui la particella può cambiare direzione, quindi dobbiamo anche tenerne conto:

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--; } }

Quindi usiamo la direzione prevista (particleDir), per calcolare quale LED dovrebbe essere acceso dopo, ma dobbiamo anche considerare se abbiamo raggiunto o la vera fine della stringa di LED, o il nostro punto centrale, che funge anche da fine per ciascuna delle stringhe virtuali.

Una volta che abbiamo capito tutto, accendiamo la luce successiva secondo necessità:

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; } } led[Pos1] = CHSV(currHue, 255, 255); leds[Pos2] = CHSV(currHue, 255, 255); FastLED.show();}

Perché farne una classe? Così com'è, è abbastanza semplice e non ha davvero bisogno di essere in una classe. Tuttavia, ho piani futuri per aggiornare il codice per consentire il verificarsi di più di una particella alla volta e far sì che alcune funzionino al contrario mentre altre vanno avanti. Penso che ci siano alcune possibilità davvero grandi per il rilevamento dello spin usando più particelle.