Gravador d’impacte per a vehicles: 18 passos (amb imatges)

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:13

L'enregistrador d'impactes està dissenyat per registrar l'impacte que es produeix al vehicle mentre es condueix o està parat. Els impactes s’emmagatzemen a la base de dades en forma de lectures, així com de vídeo / imatge. Si es pot verificar l’usuari remot en cas d’impacte, es pot verificar en temps real i l’usuari remot pot veure el vídeo desat o accedir a la càmera pi i veure els esdeveniments en conseqüència..

Pas 1: peces i accessoris

(1) Raspberry Pi 3 o superior: cal poder computacional

(2) Barret de sentit Raspberry pi

(3) Càmera Raspberry pi / Càmera USB

(4) Targeta de memòria amb la imatge raspbian més recent (ha de ser compatible amb el vermell del node, gairebé totes les imatges més recents)

(5) Alimentació com a mínim 2,1 A (he utilitzat un banc de bateries per al funcionament independent al cotxe)

Pas 2: Descripció de les parts: Barret de sentit

El Sense HAT té una matriu LED de 8 × 8 RGB, un joystick de cinc botons i inclou els següents sensors:

• Giroscopi
• Acceleròmetre
• Magnetòmetre
• Temperatura
• Baromètric
• pressió
• Humitat

Podeu obtenir més informació sobre el treball amb el barret de sentit als següents enllaços: Sense_Hat

Les API per al barret de sentit estan allotjades a: Sense_hat_API

El codi per a la programació de barret de sentit es cobreix en passos posteriors. El codi Sense Hat també es pot simular en un simulador allotjat a: Sense-hat simulator

Pas 3: Muntatge: gravador d’impacte

• El muntatge és més senzill, ja que cal apilar el barret sense sentit sobre pi (els cargols de muntatge designats es proporcionen amb barret sense barres).
• Es pot connectar càmera USB o càmera pi. Al tutorial, es té en compte la càmera pi i, per tant, es realitza la codificació per a la mateixa.
• Inseriu la targeta de memòria i configureu el codi i el node python -red (la configuració i el codi es descriuen en altres passos)

La imatge superior mostra una càmera pi connectada mitjançant un cable de cinta pla a pi

Pas 4: Muntatge: gravador d’impacte al tauler de control del cotxe

Per muntar la gravadora, he utilitzat cinta de doble cara, l’avantatge és que la gravadora es pot canviar fàcilment en diferents posicions, segons el que s’adapti millor al vostre cotxe.

Una altra càmera es munta verticalment com es mostra, amb la mateixa cinta lateral doble, El següent de la línia és connectar una font d’energia (banc d’alimentació de 10.000 mAH) juntament amb una connexió a Internet preparada

Cal una connexió a Internet per a l’aplicació MQTT (els detalls de l’MQTT es cobreixen en altres passos)

Pas 5: Recodificador d'impacte: treball i aplicacions

Des del barret de sentit, l’acceleració i el giroscopi s’utilitzen per comprovar si els valors en brut superen el límit establert al codi.

Acceleròmetre: l’acceleròmetre indica la quantitat de força gravitatòria (força G) que actua sobre cadascun dels eixos x, y & z, si algun eix mesura una força superior a 1G, es pot detectar un moviment ràpid. (Tingueu en compte que l'eix que apunta cap avall tindria un valor d'1 g i s'ha de considerar en conseqüència al codi python).

Giroscopi; El giroscopi s'utilitza per mesurar el moviment angular, és a dir, durant el gir brusc, el sensor es pot activar (depèn de la configuració del codi), de manera que una persona que giri bruscament el vehicle quedaria atrapada.

Qualsevol activació del límit establert també es mostra a la matriu LED del barret de sentit com a "!" en vermell per a l’acceleració i verd per a l’activació del giroscopi

Pas 6: Descripció del programari: Node Red

Node-RED és una eina de programació basada en flux, desenvolupada originalment per Emerging Technology Servicesteam d’IBM i que ara forma part de la JS Foundation.

Podeu obtenir més informació sobre el node vermell a través del següent enllaç: node-red

Per al nostre cas, utilitzaríem node -red per a les següents activitats

(1) Interacció amb els joysticks per iniciar les funcions de la càmera

(2) Supervisió dels impactes sobre el vehicle i retransmissió de la informació a l'usuari final mitjançant l'ús de MQTT i acceptació addicional de les ordres de l'usuari final mitjançant MQTT i inici de l'aplicació necessària a pi

(3) Realització d’alguns elements bàsics com l’aturada de pi

Els passos següents proporcionen la informació detallada del diagrama de flux implementat en vermell de node

Tingueu en compte que els diagrames de flux vermell del node interactuen amb el codi python, per tant la darrera part cobreix els aspectes del codi python

Pas 7: Conceptes bàsics de vermell del node

Alguns passos bàsics es ressalten per començar Node-vermell en un instant, però sí node-vermell és massa senzill per començar i treballar aplicacions.

• Node inicial vermell: https:// localhost: 1880.
• S’inicia el vermell del node quan pi està connectat a Internet https:// adreça ip>: 1880

Pas 8: vermell del node: flux _1a

Flow _1a, controla qualsevol canvi al fitxer CSV i, en funció dels canvis, és a dir, l'impacte detectat, la gravació de vídeo de la càmera està configurada en mode activat i, a més, s'informa a l'usuari per internet que s'ha produït un impacte

Pas 9: vermell del node: flux_1b

En aquest flux, la gravació de vídeo es pot iniciar en qualsevol punt amb només prémer el joystick

Pas 10: vermell del node: flux_2a

En l'esmentat flux, sempre que s'emmagatzema o penja una nova imatge o vídeo al directori, la informació es transmet a l'usuari registrat a través d'Internet.

Pas 11: vermell del node: flux_2b

Aquest flux està dissenyat principalment per a l'usuari remot, de manera que es pugui controlar el dispositiu de la manera següent

(a) dispositiu d’aturada

(b) fer fotos

(c) Gravar vídeos

(d) iniciar el codi principal (el codi de registre de dades és el codi principal que calcula l'impacte)

Pas 12: Node vermell; Flux_3

El flux està dissenyat per a accés local, per iniciar el codi principal o el dispositiu d'apagada

Pas 13: MQTT

MQTT (Message Queuing Telemetry Transport) és un protocol TCP / IP, on l'editor i el subscriptor interactuen.

En el nostre cas, Pi és l’editor, mentre que l’aplicació instal·lada al nostre mòbil / PC serà la subscriptora.

D'aquesta manera, en generar qualsevol impacte, la informació es transmet de forma remota a l'usuari (és imprescindible una connexió a Internet que funcioni)

Es pot accedir a més informació sobre MQTT des del següent enllaç: MQTT

Per començar a utilitzar MQTT, primer ens hem de registrar; per al tutorial que he utilitzat cloudmqtt (www.cloudmqtt.com), hi ha un pla gratuït a "gat bonic", això és tot.

Després de registrar-se, creeu una instància, digueu "pi" i després obtindreu els detalls següents

• Nom del servidor
• port
• nom d'usuari
• contrasenya

S’exigeix l’anterior per subscriure’s a través del mòbil / PC

Per a la meva aplicació, he utilitzat l'aplicació MQTT de Google Play Store (versió d'Android)

Pas 14: MQTT: subscriptor

L'aplicació MQTT que s'executa al mòbil (versió d'Android)

L'impacte detectat a pi es retransmet

Pas 15: MQTT: Edició de propietats en vermell de node

En vermell de node després de seleccionar el node MQTT, cal esmentar "Nom del servidor" i "tema". Això hauria de ser el mateix al final del subscriptor.

Pas 16: el codi Python:

La funcionalitat del codi és segons el diagrama de flux adjunt

Pas 17: el codi final

S'adjunta el codi python

Per tal que el nostre script Python s'executi des del terminal, els hem de fer executables com a chmod + x datalogger.py, que a la part superior del codi ha de contenir la següent línia "shebang". / usr / bin / python3 (això és necessari per executar funcions des del vermell del node)

#! / usr / bin / python3 // shebang linede sense_hat importació SenseHat des del datetime importació datetime del csv import writer writer RPi. GPIO com GPIO des de la importació del temps de repòs

sense = SenseHat ()

importar CSV

marca de temps = datetime.now ()

delay = 5 // delay es defineix per emmagatzemar dades al fitxer data.csv vermell = (255, 0, 0) verd = (0, 255, 0) groc = (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"])

giroscopi = sense.get_gyroscope_raw ()

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

torna sentit_impacte

def impact (): // funció per detectar l'impacte # GPIO.setmode (GPIO. BCM) # GPIO.setup (4, GPIO. OUT) acceleration = sense.get_accelerometer_raw () x = acceleration ['x'] y = acceleration ['y'] z = acceleració ['z'] x = abs (x) y = abs (y) z = abs (z)

giroscopi = sense.get_gyroscope_raw ()

giroscopi = giroscopi ["x"] giroscopi = giroscopi ["y"] giroscopi = giroscopi ["z"]

gyrox = rodó (gyrox, 2)

giró = rodó (giró, 2) giró = rodó (giró, 2)

impact = get_sense_impact ()

si x> 1,5 o y> 1,5 o z> 1,5: // els valors s’estableixen després de la iteració a la carretera real es poden canviar en conseqüència per a diferents tipus i habilitats de conducció amb open ('impact.csv', 'w', newline = ' ') com a f: data_writer = writer (f) data_writer.writerow ([' acc x ',' acc y ',' acc z ',' gyro x ',' gyro y ',' gyro z ']) #GPIO. sortida (4, GPIO. HIGH) sense.clear () sense.show_letter ("!", vermell) data_writer.writerow (impacte)

elif gyrox> 1,5 o gyroy> 1,5 o gyroz> 1,5: // els valors s’estableixen mirant la velocitat a la qual s’inicien els girs amb obert ('impact.csv', 'w', newline = '') com a f: data_writer = writer (f) data_writer.writerow (['acc x', 'acc y', 'acc z', 'gyro x', 'gyro y', 'gyro z']) # GPIO.output (4, GPIO. ALT) sense.clear () sense.show_letter ("!", Verd) data_writer.writerow (impacte)

en cas contrari:

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

def get_sense_data (): // funció per gravar i emmagatzemar valors del sensor sense_data =

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

orientation = sense.get_orientation ()

sense_data.append (orientació ["yaw"]) sense_data.append (orientació ["pitch"]) sense_data.append (orientació ["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"])

giroscopi = sense.get_gyroscope_raw ()

data_sense.append (giroscopi ["x"]) data_sense.append (giroscopi ["y"]) data_sensible.append (giroscopi ["z"])

sense_data.append (datetime.now ())

retornar dades_de_sensat

amb open ('data.csv', 'w', newline = '') com a f:

data_writer = escriptor (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 que és cert:

print (get_sense_data ()) per a esdeveniment a sense.stick.get_events (): # Comproveu si es va prémer el joystick si event.action == "premut": # Comproveu quina direcció si event.direction == "amunt": # sentit.show_letter ("U") # Fletxa cap amunt acceleració = sense.get_accelerometer_raw () x = acceleració ['x'] y = acceleració ['y'] z = acceleració ['z'] x = rodó (x, 0) y = rodó (y, 0) z = rodó (z, 0)

# Actualitzeu la rotació de la pantalla en funció de la pujada de si 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": acceleration = sense.get_accelerometer_raw () x = acceleration ['x'] y = acceleration ['y'] z = acceleration ['z'] x = round (x, 0) y = rodó (y, 0) z = rodó (z, 0)

# Actualitzeu la rotació de la pantalla en funció de la pujada de si 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") # Fletxa avall sense.clear () h = sense.get_humidity () h = round (h, 1) message = "H:" + str (h) sense.show_message (missatge, 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 = groc, scroll_speed = 0,09)

# elif event.direction == "left":

# acceleration = sense.get_accelerometer_raw () # x = acceleration ['x'] #y = acceleration ['y'] #z = acceleration ['z'] # x = round (x, 0) # y = round (y, 0) # z = rodó (z, 0)

# Actualitzeu la rotació de la pantalla en funció del camí cap amunt // No utilitzat i controlat per 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") # Fletxa esquerra # elif event.direction == "right": # sense.show_letter ("K") # Fletxa dreta # elif event.direction == "mig": # sense.clear ()

impact ()

data = get_sense_data ()

dt = data [-1]: marca de temps si dt.seconds> delay: data_writer.writerow (data) timestamp = datetime.now ()

Pas 18: supervisió del vídeo en directe

Impact Recorder també es pot utilitzar per controlar el vídeo en directe, ja que el vídeo es pot iniciar en qualsevol moment i en qualsevol lloc mitjançant MQTT

utilitzaríem el reproductor VLC per transmetre vídeos, de manera predeterminada a l'últim raspbian, el VLC està preinstal·lat; en cas contrari, instal·leu vlc com a sota

Es pot accedir a més informació sobre la visualització del flux de xarxa a través del flux de xarxa VLC

Gràcies per llegir !!

El gravador d’impactes pot fer molt més.

Vigileu el proper espai per a l'anàlisi del camp magnètic en la realització de mapes d'obstacles