Un indicatore di direzione Micro:bit per caschi da bicicletta: 5 passaggi

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

Versione aggiornata 2018-maggio-12

Di seguito le istruzioni su come costruire un semplice indicatore di direzione basato su micro: bit per caschi da bicicletta (o simili). Utilizza gli accelerometri incorporati nel micro:bit come controlli.

Gli script micro python forniti sono ottimizzati per mu, un editor micro python con una "modalità" specifica per micro: bit. Nella sua ultima versione viene fornito con un plotter seriale e inizialmente volevo solo capire come usarlo per visualizzare i valori misurati (suggerimento: invia i dati come tuple: print((x, y, z)), usando doppie parentesi).

Sul display LED 5x5 del micro:bit vengono visualizzati quattro pattern:

• Nello stato di riposo viene visualizzato un bel modello randomizzato. Attualmente trovi script per tre diversi modelli, un modello "lucciola", una "pioggia" e uno "stella cadente". Dai un'occhiata e scegli quello che ti piace di più. Sentiti libero di regolare i parametri, per renderli più o meno densi o per correre più velocemente o più lentamente.
• Poi ci sono gli indicatori "gira a destra" o "gira a sinistra" sotto forma di frecce mobili. Si attivano inclinando la testa a sinistra oa destra, premendo i pulsanti del micro:bit. Nella versione con pulsanti esterni dello script, attivare premendo uno dei pulsanti esterni collegati ai pin 0 e 1.
• Se pieghi la testa all'indietro, o entrambi i pulsanti sul micro:bit vengono attivati contemporaneamente, viene visualizzato uno schema di "avviso" o "interruzione".

Questo micro:bit che mostra il modello potrebbe essere usato come indicatore direzionale, ad es. per andare in bicicletta, pattinare o sciare. Fissa il micro:bit sul tuo casco e controllalo con la posizione della testa. Oppure fissalo sulla tua bici, carica lo script del pulsante esterno e controllalo con due interruttori esterni collegati al micro:bit tramite alcuni cavi.

Per coloro che lavorano con MakeCode, ho aggiunto uno script di blocco nell'ultimo passaggio, che può essere copiato direttamente nel micro: bit. È meno sofisticato ma offre le funzionalità di base senza la necessità di installare mu.

Per favore ricorda:

• Sebbene questo progetto possa essere utile per la tua sicurezza, assicurati di fornire sempre indicazioni chiare su dove vuoi guidare usando le mani e le braccia.
• Il concetto non è stato ampiamente testato su strada ed è stato inteso solo come esempio di programmazione. Usalo a tuo rischio.
• Utilizzare la versione base solo in condizioni climatiche asciutte, poiché il micro:bit e la batteria o i pacchi LiPo sono sensibili all'umidità. C'è una descrizione di come costruire una versione incapsulata più avanti.

Passaggio 1: materiali utilizzati

Un computer micro:bit. A con installato l'editor mu. Pacchetto batteria o LiPo pack per il casco da bicicletta micro:bit. A. Ne ho usato uno che aveva una retroilluminazione a LED. Un pezzo di cartone in polipropilene da 3 mm, come distanziale tra micro:bit e casco. Nastro biadesivo per fissare il micro:bit al distanziale e questo al casco. Duct nastro, per fissare il micro:bit e il pacco batteria nel casco.

Per una versione incapsulata: una scatola di plastica trasparente 59 x 59 x 30 mm, Modulor, Berlino: 0, 70 Euro Kitronic MI: scheda di alimentazione, nastro adesivo biadesivo da 5 GBP e un pezzo delle piastre in PP

Per la versione con interruttori esterni (dettagli non mostrati qui): cavi jumper e due interruttori, due LED bianchi, una resistenza da 10 kOhm, una breadboard. Morsetti a coccodrillo. Viti M3 in ottone (20 mm), dadi M3 in nylon; quattro ciascuno, per pin 0, pin 1, 3V e Ground. Inserire le viti attraverso i fori nel PCB del micro:bit e fissare con le viti. Semplificano il fissaggio dei morsetti a coccodrillo.

Passaggio 2: configurazione del dispositivo, installazione dello script

• Installa l'editor mu sul tuo computer.
• Collega il micro:bit al computer.
• Carica lo script desiderato.
• Flash lo script al micro: bit.
• Nel caso degli script dell'accelerometro (casco), fissa il micro:bit e il pacco batterie al tuo casco. Io ho usato un pezzettino di cartone di plastica, un materiale che puoi trovare in ferramenta, come distanziale e condotto bifacciale nastro adesivo su entrambi i lati per fissare il micro:bit al casco. Quindi fissare il micro:bit e il pacco batteria con del nastro adesivo sul casco.
• Per fare in modo che il tempo lo dimostri, dai un'occhiata a un passaggio successivo.
• Se necessario, regolare i valori di soglia xez in base alle proprie esigenze.

Nel caso dello script guidato da pulsanti e se desideri utilizzare pulsanti esterni, collega i binari di alimentazione della breadboard alle porte Gnd e 3V del micro:bit. Collega i pulsanti a Gnd e alle porte Pin0 e Pin1

Passaggio 3: gli script Micro Python

In allegato trovi gli script micro python per mu e micro: bit.

Ci sono quattro script: uno che controlla il display usando i pulsanti interni ed esterni, tre che usano gli accelerometri incorporati del micro:bit. Hanno diversi generatori di pattern casuali per lo stato di riposo.

C'è un motivo a "lucciola", uno a "pioggia" e uno a "stella cadente" (stile matrice). Lo script firefly/accelerometro è elencato di seguito. C'è anche uno script che ha tutti e tre i modelli e li esegue in un ordine casuale, con una nuova scelta ogni volta che un indicatore è stato attivato.

I valori dell'accelerometro vengono inviati al computer e possono essere letti tramite il monitor seriale dell'editor mu o visualizzati sul plotter seriale.

È facile modificare i parametri per adattare gli script alle tue esigenze e preferenze.

'''Versione controllata da angolo/accelerometro o pulsanti incorporati. 2018-mag-07 Un semplice script che produce un modello "lucciola" in stato di riposo, frecce in movimento a sinistra o a destra se il bit m è ruotato nella direzione corrispondente, o vengono premuti i pulsanti A o B o un indicatore di interruzione/schema di avviso se vengono premuti entrambi i pulsanti o se l'm-bit è piegato all'indietro. Potrebbe essere utilizzato per la retroilluminazione di un casco da bicicletta o simili. Crea per l'editor mu micro python del Dr H. https://www.instructables.com/id/A-Microbit-Direction-Indicator-for-Biking-Helmets/ ''' from microbit import * import random random.seed(3433) # inserisci il tuo numero fortunato de = 100 # imposta il ritardo di visualizzazione in ms ff1 = 100 # imposta il ritardo di lucciola 1 in ms ff2 = 50 # imposta il ritardo di lucciola 2 in ms fn = 3 # imposta il numero di punti seme di lucciola thresh_z = 80 # valore di soglia per indietro thresh_x = 350 # valore di soglia per lateralmente # define images image_l_1 = Image("00900:" "09000:" "97531:" "09000:" "00900") image_l_2 = Image("09000:" "90000:" "75319:" "90000:" "09000") image_l_3 = Immagine("90000:" "00009:" "53197:" "00009:" "90000") image_l_4 = Immagine("00009:" "00090:" "31975:" "00090:" "00009") image_l_5 = Immagine("00090:" "00900:" "19753:" "00900:" "00090") image_r_1 = Immagine("00900:" "00090:" "13579:" "00090:" "00900") image_r_2 = Immagine("00090:" "00009:" "91357:" "00009:" "00090") image_r_3 = Immagine("00009:" "90000:" "79135:" "90000:" "00009") image_r_4 = Immagine("90000:" "09000:" "57913:" "09000:" "90000") image_r_5 = Immagine("09000:" "00900:" "35791:" "00900:" "09000") image_z_1 = Image("90009:" "00000:" "00900:" "00000:" "90009") image_z_2 = Image("09090:" "90009:" "00000:" "90009:" "09090") # avvia il programma while True: print((accelerometer.get_x(), accelerometer.get_y(), accelerometer.get_z())) # da utilizzare con monitor seriale o plotter per l'ottimizzazione del valore di soglia; # mute con '#' se non utilizzato if ((accelerometer.get_z() > thresh_z) # testa piegata all'indietro, regolare se necessario oppure (button_a.is_pressed() e button_b.is_pressed())): # per la visualizzazione a scopo di controllo. show(Image. DIAMOND_SMALL) sleep(de) display.show(Image. DIAMOND) sleep(de) display.show(image_z_2) sleep(de) display.show(image_z_1) sleep(de) display.clear() elif ((accelerometer.get_x() thresh_x) # indicatore di direzione a destra; per attivare piega la testa di circa 20 gradi a destra o button_b.is_pressed()): display.show(image_r_1) sleep(de) display.show(image_r_2) sleep(de) display. show(image_r_3) sleep(de) display.show(image_r_4) sleep(de) display.show(image_r_5) sleep(de) display.clear() else: # generatore di pattern 'lucciola' per g in range(0, fn): # semina un dato numero (fn) di pixel x = random.randint(0, 4) # sceglie una posizione casuale y = random.randint(0, 4) v = 9 # luminosità del seme massima # v = random.randint(0, 9) # opzionale: luminosità seme casuale display.set_pixel(x, y, v) # imposta la velocità della lucciola sleep(ff1) # display per ff ms # riduce l'intensità di tutti i pixel di un passo per j in range(0, 5): # per ogni pixel dell'array LED per i in range(0, 5): b = display.get_pixel(i, j) # ottiene l'intensità della corrente if (b > 0): f = b - 1 # riduce la luminosità di un altro: f = 0 # imposta 0 come valore minimo consentito display.set_pixel(i, j, f) sleep(ff2)

Passaggio 4: una versione incapsulata a prova di intemperie

Come accennato in precedenza, la versione base non è resistente alle intemperie. Ho quindi costruito una versione incapsulata.

Per alimentare il micro:bit qui ho usato una scheda Kitronic MI:power. È alimentato da una pila a bottone da 3V e può essere fissato al micro:bit con tre bulloni e dadi. Ha anche un interruttore di alimentazione integrato. In alternativa puoi usare una batteria LiPo.

Come custodia sto usando una scatola di plastica trasparente 59 x 59 x 30 mm. Come distanziale è stato utilizzato un pezzo di cartone di plastica da 3 mm ricoperto di nastro biadesivo. È necessario poiché il retro dell'MI:power non è nemmeno dovuto ai dadi e mantiene il micro:bit in posizione.

La scatola con il micro:bit viene poi fissata al casco con un altro pezzo di cartone plastico ricoperto di nastro biadesivo.

Passaggio 5: uno script MakeCode

Per coloro che non vogliono o non possono installare mu, ho aggiunto uno script di blocco MakeCode con funzionalità simili. Di gran lunga non così fantasioso, ma abbastanza buono da mostrare il principio.

Puoi semplicemente copiare il file sul tuo micro: bit e riprodurlo.