Registratore di impatti per veicoli: 18 passaggi (con immagini)

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

Impact Recorder è progettato per registrare l'impatto subito sul veicolo durante la guida o fermo. Gli impatti sono memorizzati nel database sotto forma di letture e video/immagine. Dopo l'impatto, l'utente remoto può essere verificato in tempo reale e l'utente remoto può guardare il video salvato o accedere da remoto alla telecamera pi e guardare gli eventi di conseguenza.

Passaggio 1: parti e accessori

(1) Raspberry Pi 3 o superiore: potenza di calcolo richiesta

(2) Cappello del senso di Raspberry pi

(3) Fotocamera Raspberry pi / Fotocamera USB

(4) Scheda di memoria con l'ultima immagine raspbian (dovrebbe supportare il nodo rosso, quasi tutte le ultime immagini lo fanno)

(5) Alimentazione di almeno 2,1 A (ho usato il banco batterie per il funzionamento autonomo in auto)

Fase 2: Descrizione delle parti: Sense Hat

Il Sense HAT ha una matrice LED RGB 8×8, un joystick a cinque pulsanti e include i seguenti sensori:

• Giroscopio
• Accelerometro
• Magnetometro
• Temperatura
• barometrico
• pressione
• Umidità

Ulteriori informazioni su come lavorare con il cappello dei sensi possono essere ricavate dai seguenti collegamenti: Sense_Hat

L'API per il cappello dei sensi è ospitata su: Sense_hat_API

Il codice per la programmazione del cappello sensoriale è trattato nei passaggi successivi. Il codice Sense-hat può anche essere simulato su un simulatore ospitato su: Sense-hat simulator

Passaggio 3: assemblaggio: registratore di impatti

• L'assemblaggio è più semplice poiché il cappello di rilevamento deve essere impilato su pi (i bulloni di montaggio designati sono forniti con il cappello di rilevamento).
• È possibile collegare una fotocamera USB o una fotocamera pi. Nel tutorial, viene considerata la fotocamera pi e di conseguenza viene eseguita la codifica per la stessa.
• Inserisci la scheda di memoria e configura il codice python e il nodo -red (la configurazione e il codice sono trattati in ulteriori passaggi)

L'immagine sopra mostra la telecamera pi collegata tramite cavo a nastro piatto a pi

Passaggio 4: assemblaggio: registratore di impatto sul cruscotto dell'auto

Per montare il registratore, ho usato del nastro biadesivo, il vantaggio è che il registratore può essere facilmente spostato in diverse posizioni, a seconda di quale si adatta meglio alla tua auto.

L'ulteriore telecamera è montata verticalmente come mostrato, utilizzando lo stesso nastro biadesivo, Il prossimo passo è collegare una fonte di alimentazione (banco di alimentazione da 10.000 mAH) insieme a una connessione Internet pronta

È necessaria una connessione Internet per l'applicazione MQTT (i dettagli per MQTT sono trattati in ulteriori passaggi)

Passaggio 5: Impact Recorder: funzionamento e applicazioni

Dal cappello di rilevamento, l'accelerazione e il giroscopio vengono utilizzati per verificare se i valori grezzi superano il limite impostato nel codice.

Accelerometro: l'accelerometro indica la quantità di forza gravitazionale (forza G) che agisce su ciascuno degli assi x, y e z, se un asse misura più di 1 G di forza, è possibile rilevare il movimento rapido. (si prega di notare che l'asse che punta verso il basso avrebbe un valore di 1g e deve essere considerato di conseguenza nel codice Python).

Giroscopio; Il giroscopio viene utilizzato per misurare il movimento angolare, ad es. durante una svolta brusca il sensore potrebbe attivarsi (dipende dall'impostazione nel codice), quindi una persona che fa roteare bruscamente il veicolo verrebbe catturata!!

L'eventuale attivazione del limite impostato viene visualizzata anche sulla matrice LED sense hat come "!" in rosso per l'accelerazione e in verde per l'attivazione del giroscopio

Passaggio 6: descrizione del software: nodo rosso

Node-RED è uno strumento di programmazione basato sul flusso, originariamente sviluppato dal team Emerging Technology Services di IBM e ora parte della JS Foundation.

Maggiori informazioni sul nodo rosso possono essere ottenute tramite il seguente link: nodo-rosso

Nel nostro caso useremmo node -red per le seguenti attività

(1) Interagire con i joystick per avviare le funzioni della fotocamera

(2) Monitoraggio degli impatti sul veicolo e trasmissione delle informazioni all'utente finale utilizzando MQTT e accettando ulteriormente i comandi dell'utente finale tramite MQTT e avviando l'applicazione richiesta su pi

(3) Esecuzione di alcune cose di base come l'arresto di pi

Gli ulteriori passaggi forniscono le informazioni dettagliate per il diagramma di flusso implementato su node-red

Si prega di notare che i diagrammi di flusso del nodo rosso interagiscono con il codice Python, quindi l'ultima parte copre gli aspetti del codice Python

Passaggio 7: Nozioni di base sul nodo rosso

Alcuni passaggi di base sono evidenziati per iniziare Node-red in un lampo, ma sì node-red è troppo semplice per iniziare ed elaborare applicazioni.

• Avvio di Node-red:
• Avvio di Node-red quando pi è connesso a Internet https:// indirizzo ip>: 1880

Passaggio 8: Nodo rosso: flusso _1a

Il flusso _1a, monitora eventuali modifiche nel file CSV e sulla base delle modifiche, ad esempio l'impatto rilevato, la registrazione video della telecamera viene impostata su modalità attiva e inoltre l'utente viene informato su Internet che si è verificato un impatto

Passaggio 9: nodo rosso: Flow_1b

In tale flusso, la registrazione video può essere avviata in qualsiasi momento semplicemente premendo il joystick

Passaggio 10: nodo rosso: Flow_2a

In tale flusso, ogni volta che una nuova immagine o video viene archiviato/caricato nella directory, le informazioni vengono trasmesse all'utente registrato su Internet

Passaggio 11: nodo rosso: Flow_2b

Questo flusso è principalmente progettato per l'utente remoto, in modo da controllare il dispositivo nel modo seguente

(a) dispositivo di spegnimento

(b) scattare foto

(c) Registra video

(d) start main code (il codice datalogger è il codice principale che calcola l'impatto)

Passaggio 12: nodo rosso; Flusso_3

Il flusso è progettato per l'accesso locale, in modo da avviare il codice principale o il dispositivo di spegnimento

Passaggio 13: MQTT

MQTT (Message Queuing Telemetry Transport) è un protocollo TCP/IP, in cui l'editore e l'abbonato interagiscono.

Nel nostro caso Pi è l'editore, mentre l'applicazione installata nel nostro cellulare/PC sarà l'abbonato.

In questo modo, alla generazione di qualsiasi impatto, le informazioni vengono trasmesse in remoto all'utente (è necessaria una connessione Internet funzionante)

Maggiori informazioni su MQTT sono accessibili dal seguente link: MQTT

Per iniziare a utilizzare MQTT, dobbiamo prima registrarci, per il tutorial che ho usato cloudmqtt (www.cloudmqtt.com), c'è un piano gratuito sotto "cute cat", tutto qui.

Dopo la registrazione, crea un'istanza pronuncia "pi" dopo di che otterrai i seguenti dettagli

• Nome del server
• porta
• nome utente
• parola d'ordine

Quanto sopra è richiesto durante l'iscrizione tramite cellulare/pc

Per la mia applicazione, ho usato l'applicazione MQTT da Google Play Store (versione Android)

Passaggio 14: MQTT: abbonato

L'applicazione MQTT in esecuzione su dispositivi mobili (versione Android)

L'impatto rilevato su pi viene ritrasmesso

Passaggio 15: MQTT: modifica delle proprietà in Node-red

In rosso nodo dopo aver selezionato il nodo MQTT, "Nome server" e "argomento" da menzionare. Questo dovrebbe essere lo stesso per l'utente finale

Passaggio 16: il codice Python:

La funzionalità del codice è come da diagramma di flusso allegato

Passaggio 17: il codice finale

Il codice Python è allegato

Per far funzionare il nostro script python dal terminale, dobbiamo renderli eseguibili come chmod +x datalogger.py, quindi la parte superiore del codice dovrebbe contenere la seguente riga "shebang" #! /usr/bin/python3 (necessario per eseguire funzioni da node-red)

#!/usr/bin/python3 // shebang linefrom sense_hat import SenseHat from datetime import datetime from csv import writer import RPi. GPIO as GPIO from time import sleep

senso = Cappello Sense()

importa csv

timestamp = datetime.now()

delay = 5 // il ritardo è definito per memorizzare i dati nel file data.csv rosso = (255, 0, 0) verde = (0, 255, 0) giallo = (255, 255, 0)

#GPIO.setmode(GPIO. BCM)

#GPIO.setup(17, GPIO. OUT)

def get_sense_impact():

sense_impact = acc = sense.get_accelerometer_raw() sense_impact.append(acc["x"]) sense_impact.append(acc["y"]) sense_impact.append(acc["z"])

giroscopio = sense.get_gyroscope_raw()

sense_impact.append(gyro["x"]) sense_impact.append(gyro["y"]) sense_impact.append(gyro["z"])

ritorno sense_impact

def impact(): // funzione per rilevare l'impatto #GPIO.setmode(GPIO. BCM) #GPIO.setup(4, GPIO. OUT) accelerazione = sense.get_accelerometer_raw() x = accelerazione['x'] y = accelerazione['y'] z = accelerazione['z'] x=abs(x) y=abs(y) z=abs(z)

giroscopio = sense.get_gyroscope_raw()

giroscopio = giroscopio["x"] giroscopio = giroscopio["y"] giroscopio = giroscopio["z"]

girox = giro(girox, 2)

giroscopio = giro(giroscopio, 2) giroscopio = giro(giroscopio, 2)

impatto = get_sense_impact()

se x > 1,5 o y > 1,5 o z > 1,5: // i valori sono impostati dopo l'iterazione sulla strada effettiva possono essere modificati di conseguenza per diversi tipi e abilità di guida con open('impact.csv', 'w', newline=' ') as f: data_writer = writer(f) data_writer.writerow(['acc x', 'acc y', 'acc z', 'gyro x', 'gyro y', 'gyro z']) #GPIO. output(4, GPIO. HIGH) sense.clear() sense.show_letter("!", rosso) data_writer.writerow(impatto)

elif gyrox > 1.5 o gyroy > 1.5 o gyroz > 1.5: // i valori vengono impostati esaminando la velocità con cui vengono avviate le virate con open('impact.csv', 'w', newline='') come f: data_writer = writer(f) data_writer.writerow(['acc x', 'acc y', 'acc z', 'gyro x', 'gyro y', 'gyro z']) #GPIO.output(4, GPIO. HIGH) sense.clear() sense.show_letter("!", verde) data_writer.writerow(impatto)

altro:

# GPIO.output(4, GPIO. LOW) sense.clear()

def get_sense_data(): // funzione per registrare e memorizzare i valori dal sensore sense_data =

sense_data.append(sense.get_temperature()) sense_data.append(sense.get_pression()) sense_data.append(sense.get_humidity())

orientamento = sense.get_orientation()

sense_data.append(orientation["yaw"]) sense_data.append(orientation["pitch"]) sense_data.append(orientation["roll"])

acc = sense.get_accelerometer_raw()

sense_data.append(acc["x"]) sense_data.append(acc["y"]) sense_data.append(acc["z"]) mag = sense.get_compass_raw() sense_data.append(mag["x"]) sense_data.append(mag["y"]) sense_data.append(mag["z"])

giroscopio = sense.get_gyroscope_raw()

sense_data.append(gyro["x"]) sense_data.append(gyro["y"]) sense_data.append(gyro["z"])

sense_data.append(datetime.now())

ritorno sense_data

con open('data.csv', 'w', newline='') come f:

data_writer = scrittore (f)

data_writer.writerow(['temp', 'pres', 'hum', 'yaw', 'pitch', 'roll', 'acc x', 'acc y', 'acc z', 'mag x', ' mag y', 'mag z', 'gyro x', 'gyro y', 'gyro z', 'datetime'])

mentre vero:

print(get_sense_data()) for event in sense.stick.get_events(): # Controlla se il joystick è stato premuto if event.action == "pressed": # Controlla in quale direzione if event.direction == "up": # sense.show_letter("U") # Freccia su accelerazione = sense.get_accelerometer_raw() x = accelerazione['x'] y = accelerazione['y'] z = accelerazione['z'] x=round(x, 0) y =tondo(y, 0) z=tondo(z, 0)

# Aggiorna la rotazione del display a seconda della direzione in cui si alza if x == -1: sense.set_rotation(90) elif y == 1: sense.set_rotation(270) elif y == -1: sense.set_rotation(180) else: sense.set_rotation(0) sense.clear() t = sense.get_temperature() t = round(t, 1) message = "T: " + str(t) sense.show_message(message, text_colour = red, scroll_speed=0.09) elif event.direction == "down": accelerazione = sense.get_accelerometer_raw() x = accelerazione['x'] y = accelerazione['y'] z = accelerazione['z'] x=round(x, 0) y=arrotondato(y, 0) z=rotonda(z, 0)

# Aggiorna la rotazione del display a seconda della direzione in cui si alza if x == -1: sense.set_rotation(90) elif y == 1: sense.set_rotation(270) elif y == -1: sense.set_rotation(180) else: sense.set_rotation(0) # sense.show_letter("D") # Freccia giù sense.clear() h = sense.get_humidity() h = round(h, 1) message = "H: " + str(h) sense.show_message(message, text_colour = green, scroll_speed=0.09) p = sense.get_pressure() p = round(p, 1) message = "P: " + str(p) sense.show_message(message, text_colour = giallo, scroll_speed=0.09)

# elif event.direction == "sinistra":

# accelerazione = sense.get_accelerometer_raw() # x = accelerazione['x'] #y = accelerazione['y'] #z = accelerazione['z'] #x=round(x, 0) #y=round(y, 0) #z=arrotondato(z, 0)

# Aggiorna la rotazione del display a seconda della direzione in cui // Non utilizzato e controllato da node-red #if x == -1: sense.set_rotation(90) #elif y == 1: sense.set_rotation(270) #elif y == -1: sense.set_rotation(180) #else: sense.set_rotation(0) #sense.show_letter("L") # Freccia sinistra # elif event.direction == "right": # sense.show_letter ("K") # Freccia destra # elif event.direction == "middle": # sense.clear()

impatto()

dati = get_sense_data()

dt = data[-1] - timestamp se dt.seconds > delay: data_writer.writerow(data) timestamp = datetime.now()

Passaggio 18: monitoraggio del video in diretta

Impact Recorder può essere utilizzato anche per monitorare video in diretta, poiché il video può essere avviato in qualsiasi momento e ovunque tramite MQTT

utilizzeremmo il lettore VLC per lo streaming di video, per impostazione predefinita nell'ultima raspbian il VLC è preinstallato, altrimenti installa vlc come sotto

È possibile accedere a ulteriori informazioni sulla visualizzazione del flusso di rete tramite il flusso di rete VLC

Grazie per aver letto!!

C'è molto di più che il registratore di impatto può fare..

Attenzione al prossimo spazio per l'analisi del campo magnetico nell'effettuare la mappatura degli ostacoli