Kit luci per bauletto moto Givi V56 fai da te con segnali integrati: 4 passaggi (con immagini)

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

Come motociclista, ho fin troppo familiarità con l'essere trattato come se fossi invisibile sulla strada. Una cosa che aggiungo sempre alle mie bici è un bauletto che di solito ha una luce integrata. Recentemente sono passato a una nuova bici e ho acquistato la scatola Givi V56 Monokey poiché aveva molto spazio per gli oggetti. Questa scatola ha uno spot per un kit luci di fabbrica che consiste in due strisce di LED per ogni lato. Il problema è che questo kit costa circa $ 70 e fa solo i freni. C'è un kit aftermarket che probabilmente fa cose simili e potrebbe essere un po' più facile da installare, ma il tuo prezzo sale a $ 150. Essendo una persona piena di risorse e cercando una scusa per provare le strisce LED indirizzabili, ho deciso di creare un sistema integrato che non solo avesse luci di stop, ma luci di marcia (accese ogni volta che ci si muove), indicatori di direzione e luci di emergenza. Solo per il gusto di farlo, ho anche aggiunto una sequenza di avvio… perché potrei. Nota che questo ha richiesto molto lavoro da fare anche se avevo molte cose da capire. Nonostante il lavoro, sono piuttosto contento di come sia andata a finire. Speriamo che questo finisca per essere utile a qualcun altro.

L'operazione di base di come funziona questo sistema è che l'unità Arduino cerca i segnali sui pin: luce di stop, luce di svolta a sinistra e luce di svolta a destra. Per leggere il segnale a 12 volt dalla moto, ho usato optoisolatori per convertire il segnale a 12 V in un segnale a 5 V che Arduino può leggere. Il codice attende quindi uno di questi segnali, quindi invia i comandi alla striscia LED utilizzando la libreria FastLED. Queste sono le basi, ora per entrare nei dettagli.

Forniture

Queste sono le cose che ho usato perché per la maggior parte le avevo già in giro. Ovviamente, possono essere scambiati secondo necessità:

1. Arduino: ho usato un nano per considerazioni sulle dimensioni, ma puoi usare quello che vuoi purché tu abbia cinque pin da usare.
2. Regolatore 5V - Ho usato un L7805CV capace di 1,5 amp. Questo progetto utilizzerà 0,72 ampere per i LED più la potenza per il nano, quindi 1,5 funziona alla grande per questo progetto.
3. Condensatori: avrai bisogno di uno da 0,33 uF e uno da 0,1 uF affinché il regolatore di tensione funzioni correttamente.
4. 3x optoisolatori - per effettuare la conversione del segnale da 12V a 5V. Ho usato il tipo PC817X che ha solo quattro pin, che è tutto ciò di cui abbiamo bisogno.
5. Resistori: avrai bisogno di due tipi, tre per ogni tipo. Il primo deve essere sufficiente per ridurre la corrente attraverso il LED IR dell'optoisolatore. Avrai bisogno di almeno 600 ohm, ma 700 sarebbe un'idea migliore per gestire le variazioni di tensione sulla moto. L'altro deve essere da qualche parte tra 10k e 20k per un segnale rapido dall'altra parte dell'optoisolatore.
6. Scheda prototipo: ne avevo alcune abbastanza piccole da stare all'interno di una piccola scatola di progetto con una leggera quantità di rifilatura.
7. Scatola del progetto: abbastanza grande da contenere i componenti, ma abbastanza piccola da essere facile da montare.
8. Cavo - Ho usato un cavo Ethernet Cat 6 perché ne avevo un sacco in giro. Questo ha otto fili tutti codificati a colori che hanno aiutato con tutte le diverse connessioni ed era un calibro abbastanza grande per gestire gli assorbimenti di corrente.
9. Spine: ovunque desideri che il sistema sia facilmente rimovibile. Ho usato una spina impermeabile per consentire la rimozione del bauletto e per gestire la pioggia o l'acqua che vi entra. Avevo anche bisogno di spine più piccole per le strisce LED, quindi non ho dovuto praticare fori grandi.
10. Fascette e supporti adesivi per fascette per tenere tutto a posto.
11. Pellicola termoretraibile per riordinare le connessioni.

Passaggio 1: costruire il circuito

Ovviamente, se stai seguendo la mia build, non dovrai passare attraverso la quantità di test che ho fatto. La prima cosa che ho fatto è stato assicurarmi che il mio codice funzionasse e che potessi ricevere correttamente un segnale dagli optoisolatori e controllare correttamente le strisce LED. Ci è voluto un momento per capire come collegare al meglio i pin del segnale agli isolatori, ma attraverso tentativi ed errori ho trovato il giusto orientamento. Ho appena usato una scheda prototipo standard poiché ne stavo costruendo solo una e capire un modello di traccia avrebbe richiesto più tempo di quanto ne valesse la pena. La parte superiore del circuito ha un bell'aspetto, ma la parte inferiore sembra un po' disordinata, ma almeno è funzionale.

Il design di base inizia con l'immissione dell'alimentazione a 12 V da una sorgente commutata (un filo che è acceso solo quando la moto è accesa). Uno schema elettrico può davvero aiutare a trovare questo filo. Questo viene immesso in un lato del regolatore di tensione. Un condensatore da 0,33 uF lega questo ingresso alla massa del regolatore di tensione che poi ritorna alla massa della motocicletta. L'uscita del regolatore di tensione avrà un condensatore da 0.1uF collegato a terra. Questi condensatori aiutano a livellare la tensione dal regolatore. Se non riesci a trovarli nella foto del circuito, sono sotto il regolatore di tensione. Da lì, la linea 5V va al Vin su Arduino, al pin di alimentazione che alimenterà le strisce LED e due al lato Source dell'optoisolatore che alimenterà i pin Arduino fornendo il segnale 5V necessario.

Per quanto riguarda gli optoisolatori, ci sono due lati: uno con un LED IR e l'altro con un transistor con rivelatore IR. Vogliamo utilizzare il lato LED IR per misurare il segnale a 12V. Poiché il LED ha una tensione diretta di 1,2 V, abbiamo bisogno di un resistore di limitazione della corrente in serie. 12V - 1.2V = 10,8V e per far funzionare il LED a 18 mA (mi piace sempre funzionare a meno di 20 mA per motivi di vita), avrai bisogno di un resistore di R = 10,8 V/0,018 A = 600 ohm. Anche i voltaggi sui veicoli tendono a essere più alti, potenzialmente fino a 14 V, quindi è meglio pianificarlo, che è di circa 710 ohm, anche se 700 sarebbe più che ragionevole. L'uscita per il lato LED ritorna quindi a terra. Per il lato di uscita dell'optoisolatore, l'ingresso utilizzerà il segnale 5V dal regolatore, quindi l'uscita si collegherà a un altro resistore prima di andare a terra. Questo resistore deve essere solo di circa 10k - 20k ohm, almeno questo è quello che ha mostrato il mio foglio dati. Ciò fornirà una misurazione rapida del segnale poiché non abbiamo a che fare con un ambiente rumoroso. L'uscita al pin Arduino si interromperà tra il resistore e l'uscita dell'optoisolatore in modo che quando il segnale è spento il pin è basso e quando il segnale è sul pin è alto.

Le strisce luminose a LED hanno tre fili associati: alimentazione, terra e dati. L'alimentazione deve essere 5V. Questo progetto utilizza 12 LED in totale (anche se ho più LED sulle strisce ma sto usando solo un LED su tre) e ognuno richiede 60 mA quando la luce bianca viene utilizzata a piena luminosità. Questo dà un totale di 720 mA. Siamo ben all'interno della potenza di uscita per il regolatore di tensione, quindi siamo a posto. Assicurati solo che il cavo sia abbastanza grande per gestire la potenza, ho usato un cavo Ethernet Cat 6 da 24 gauge. Il cavo Ethernet era qualcosa che avevo in giro e ha 8 cavi codificati a colori, quindi ha funzionato bene per questo progetto. Gli unici fili che devono poi andare al topbox stesso sono l'alimentazione e la massa (che vengono entrambe divise tra le strisce) e due linee dati (una per ogni striscia).

Il resto del cablaggio si collega ai pin dell'arduino e lo alimenta. I pin utilizzati per questo progetto sono stati i seguenti:

1. Vin - collegato a 5V
2. Gnd - collegato a massa
3. Pin2 - collegato alla linea dati della striscia sinistra
4. Pin3 - collegato alla linea dati della striscia destra
5. Pin4 - collegato al segnale del freno dall'optoisolatore
6. Pin5 - collegato al segnale di svolta a sinistra dall'optoisolatore
7. Pin6 - collegato al segnale di svolta a destra dall'optoisolatore

Passaggio 2: cablaggio e installazione

Una volta che il circuito è stato costruito, arriva il momento di collegarlo effettivamente in posizione. Utilizzando lo schema elettrico della tua bici, dovrai individuare quanto segue:

• Alimentazione commutata
• Terreno
• Ingresso segnale freno
• Segnale di svolta a sinistra in
• Segnale di svolta a destra in ingresso

Per il mio, c'era una singola spina che aveva tutti questi su di esso, quindi l'ho appena usato. Con abbastanza tempo, sarei stato in grado di trovare lo stesso tipo di spina e creare un modulo plug-in, ma non l'ho fatto, quindi ho semplicemente rimosso l'isolamento in alcuni punti e saldato il nuovo filo. Ho usato spine su queste connessioni impiombate in modo da poter rimuovere il resto se dovessi mai aver bisogno in futuro. Da lì ho posizionato l'Arduino, che ora è in una scatola del progetto sigillata, sotto il sedile dove l'ho attaccato. Il cavo di uscita quindi corre lungo il telaio del rack fino a una spina impermeabile, quindi entra nella scatola e corre lungo la parte posteriore fino al coperchio dove si divide per ogni lato. I fili corrono lungo l'interno del coperchio fino al punto in cui si trovano i collegamenti per i LED. Il filo viene aiutato in posizione utilizzando fascette fissate ai supporti per fascette per esterni con un supporto adesivo. Puoi trovarli nella sezione relativa all'installazione dei cavi in un negozio di bricolage

Ho usato due mini spine JST sulle strisce LED perché avevo bisogno di una spina abbastanza piccola da passare attraverso un foro di diametro minimo e perché volevo assicurarmi che ci fosse abbastanza filo per gestire i requisiti attuali. Ancora una volta, potrebbe essere stato eccessivo e non avevo piccole spine con tre fili a portata di mano. Il foro nella scatola per il passaggio dei fili della striscia luminosa è stato sigillato per tenere fuori l'acqua. Per quanto riguarda il posizionamento delle strisce LED, poiché c'è un leggero disallineamento nella spaziatura (c'era una differenza di circa 1 - 1,5 mm nella distanza tra i fori del riflettore e i LED) le ho posizionate in modo che dividessero la differenza tra il LED e il buco il più possibile. Ho quindi usato la colla a caldo per fissarli in posizione e il sigillante per sigillare completamente l'area. Le stesse strisce LED sono impermeabili, quindi nessun problema se si bagnano. Sebbene sembri molto da installare, ciò rende il sistema più facile da rimuovere in futuro o sostituire le parti perché potrebbe accadere.

Passaggio 3: il codice

Il mio codice sorgente dovrebbe essere all'inizio di questo Instructable. Commento sempre pesantemente il mio codice in modo che sia più facile da capire in seguito. Dichiarazione di non responsabilità: non sono uno scrittore di codici professionista. Il codice è stato scritto con un metodo più semplice da avviare e sono stati apportati alcuni miglioramenti, ma so che potrebbe essere più raffinato. Sto anche usando una grande quantità della funzione delay() per i tempi che non è l'ideale. Tuttavia, i segnali che l'unità sta ricevendo non sono segnali veloci in confronto, quindi mi sentivo ancora giustificato a tenerli su usando qualcosa come millis(). Sono anche un padre e un marito molto impegnati, quindi passare del tempo per migliorare qualcosa che alla fine non cambierà la funzione non è in cima alla lista.

Per questo progetto è necessaria una sola libreria che è la libreria FastLED. Questo ha tutto il codice per controllare le strisce LED di tipo WS2811/WS2812B. Da lì, tratterò le funzioni di base che verranno utilizzate.

La prima, oltre alle definizioni standard, è dichiarare le tue due strisce. Utilizzerai il seguente codice per ogni striscia:

FastLED.addLeds(leds[0], NUM_LEDS);

Questa riga di codice imposta il Pin 2 definisce questa striscia come striscia 0 con il numero di LED definiti dalla costante NUM_LEDS, che nel mio caso è impostata a 16. Per definire la seconda striscia, il 2 diventerà 3 (per il pin3) e la striscia sarà etichettata come striscia 1.

La prossima riga che sarà importante è la definizione del colore.

leds[0][1] = Color_high CRGB(r, g, b);

Questa riga di codice viene utilizzata anche se con un aspetto diverso (la maggior parte del mio uso è una costante). Fondamentalmente, questo codice invia un valore a ciascuno dei canali LED (rosso, verde, blu) che definisce ogni luminosità. Il valore di luminosità può essere definito da un numero 0 - 255. Modificando il livello di luminosità per ogni canale, è possibile definire colori diversi. Per questo progetto, voglio un colore bianco per mantenere la luce il più brillante possibile. Quindi le uniche modifiche che faccio è impostare il livello di luminosità allo stesso modo su tutti e tre i canali.

La successiva serie di codici viene utilizzata per l'illuminazione individuale di ciascuna luce. Nota che per ogni striscia, ogni LED ha un indirizzo che inizia da 0 per quello più vicino alla connessione della linea dati fino al LED con il numero più alto che hai meno 1. Esempio, queste sono 16 strisce LED, quindi il più alto è 16 - 1 = 15. Il motivo è che il primo LED è etichettato come 0.

for (int i = NUM_LEDS-1; i > -1; i = i - 3) { // Questo cambierà la luce per ogni terzo LED che va dall'ultimo al primo. led[0] = Color_low; // Imposta il colore del LED della striscia 0 sul colore scelto. led[1] = Color_low; // Imposta il colore del LED della striscia 1 sul colore scelto. FastLED.show(); // Mostra i colori impostati. led[0] = CRGB::Nero; // Disattiva l'impostazione del colore in preparazione per il colore successivo. led[1] = CRGB::Nero; ritardo(150); } FastLED.show(); // Mostra i colori impostati.

Il modo in cui funziona questo codice è che una variabile (i) viene utilizzata all'interno di un ciclo for come indirizzo LED che viene quindi riferito al numero completo di LED (NUM_LEDS). Il motivo è che voglio che le luci inizino alla fine della striscia piuttosto che all'inizio. L'impostazione viene emessa su entrambe le strisce (led[0] e leds[1]), quindi viene inviato un comando per mostrare la modifica. Dopodiché questa luce si spegne (CRGB::Black) e si accende la luce successiva. Il riferimento Black è un colore specifico nella libreria FastLED, quindi non devo emettere 0, 0, 0 per ogni canale anche se farebbero la stessa cosa. Il ciclo For fa avanzare 3 LED alla volta (i = i-3) poiché sto usando solo ogni altro LED. Alla fine di questo ciclo, la sequenza di luci passerà da un LED all'altro con un solo acceso per striscia, una sorta di effetto Knight Rider. Se vuoi mantenere ogni luce accesa in modo che la barra si costruisca, dovresti semplicemente rimuovere le linee che spengono i LED, cosa che accade nel prossimo set di codice nel programma.

for (int i = 0; i < dim; i++) { // Dissolve rapidamente le luci al livello di luce corrente. rt = rt + 1; gt = gt + 1; bt = bt + 1; for (int i = 9; i < NUM_LEDS; i = i +3) { // Questo accenderà le ultime tre luci per la luce di posizione. led[0] = CRGB(rt, gt, bt); // Imposta il colore del LED della striscia 0 sul colore scelto. led[1] = CRGB(rt, gt, bt); // Imposta il colore del LED della striscia 1 sul colore scelto. } FastLED.show(); ritardo (3); }

L'ultimo esempio di codice che utilizzo per i LED è un loop di dissolvenza. Qui, utilizzo slot temporanei per la luminosità per ciascun canale (rt, gt, bt) e li incremento di 1 con un ritardo tra ogni visualizzazione per ottenere l'aspetto che desidero. Si noti inoltre che questo codice sta cambiando solo gli ultimi tre LED poiché questo sta svanendo nelle luci di marcia, quindi inizio da 9 anziché da 0.

Il resto del codice LED è iterazioni di questi. Tutto il resto è incentrato sulla ricerca di un segnale sui tre diversi fili. L'area Loop() del codice cerca le luci dei freni, che lampeggeranno una volta prima di rimanere accese (questo è regolabile se lo si desidera) o cercare gli indicatori di direzione. Per questo codice, poiché non potevo presumere che le luci di svolta a sinistra e a destra si accendessero esattamente allo stesso tempo per i pericoli, ho fatto in modo che il codice cercasse prima una delle due, quindi dopo un piccolo ritardo controllo per vedere se entrambe sono accese indicando le luci di emergenza sono accese. L'unica parte difficile che ho avuto sono stati gli indicatori di direzione perché la luce si spegnerà per un certo periodo, quindi come faccio a capire la differenza tra il segnale ancora acceso ma nel periodo spento e un segnale annullato? Quello che mi è venuto in mente è stato implementare un loop di ritardo che è impostato per continuare più a lungo del ritardo tra i lampeggi del segnale. Se l'indicatore di direzione è ancora acceso, il ciclo del segnale continuerà. Se il segnale non si riattiva alla fine del ritardo, torna all'inizio del loop(). Per regolare la lunghezza del ritardo, modificare il numero per la costante lightDelay ricordando per ogni 1 in lightDelay il ritardo cambia di 100 ms.

while (digitalRead(leftTurn) == LOW) { for(int i = 0; i < lightDelay; i++) { leftTurnCheck(); if(digitalRead(leftTurn) == HIGH) { leftTurnLight(); } ritardo(100); } for (int i = 0; i < NUM_LEDS; i = i +3) { // Questo cambierà la luce per ogni terzo LED che va dall'ultimo al primo. led[0] = CRGB(0, 0, 0); // Imposta il colore del LED della striscia 0 sul colore scelto. } for (int i = 9; i < NUM_LEDS; i = i +3) { // Questo imposterà le luci di marcia che usano solo le ultime tre. led[0] = Color_low; // Imposta il colore del LED della striscia 0 sul colore scelto. } FastLED.show(); // Ritorno delle impostazioni di output; // Una volta che l'indicatore di direzione non è più attivo, torna al loop. }

Speriamo che il resto del codice sia autoesplicativo. È solo un insieme ripetuto di controlli e azioni sui segnali.

Passaggio 4: risultati

La parte sorprendente è che questo sistema ha funzionato la prima volta che l'ho collegato alla bici. Ora, per essere onesti, l'ho testato pesantemente sul banco prima di questo, ma mi aspettavo comunque di avere un problema o una regolazione. Si scopre che non ho avuto bisogno di apportare modifiche al codice e alle connessioni. Come puoi vedere nel video, il sistema segue la sequenza di avvio (che non devi avere), quindi si imposta automaticamente sulle luci di marcia. Dopodiché cerca i freni, nel qual caso accenderà tutti i LED a piena luminosità e li lampeggerà una volta prima di rimanere accesi fino al rilascio dei freni. Quando viene utilizzato un segnale di svolta, ho fatto un effetto di scorrimento per il lato in cui è indicata la svolta e l'altro lato sarà luci di marcia o luce di stop se accese. Le luci di emergenza lampeggeranno a tempo con le altre luci.

Spero che con queste luci aggiuntive sarò più visibile alle altre persone. Per lo meno, è una bella aggiunta per far risaltare la mia scatola un po' più di altre fornendo allo stesso tempo utilità. Spero che questo progetto sia utile anche a qualcun altro, anche se non sta lavorando con l'illuminazione del bauletto di una moto. Grazie!