Registrador de impacto para vehículos: 18 pasos (con imágenes)

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:42

Impact Recorder está diseñado para registrar el impacto sufrido por el vehículo mientras conduce o está parado. Los impactos se almacenan en la base de datos en forma de lecturas, así como de video / imagen. En caso de impacto, el usuario remoto puede ser verificado en tiempo real, y el usuario remoto puede ver el video guardado o tener acceso remoto a la cámara pi y ver eventos en consecuencia..

Paso 1: Piezas y accesorios

(1) Raspberry Pi 3 o mejor: se requiere potencia computacional

(2) Sombrero de frambuesa pi sense

(3) Cámara Raspberry pi / Cámara USB

(4) Tarjeta de memoria con la última imagen raspbian (debe admitir el nodo rojo, casi todas las imágenes más recientes lo hacen)

(5) Fuente de alimentación de al menos 2,1 A (he usado el banco de baterías para funcionamiento independiente en el automóvil)

Paso 2: Descripción de las piezas: Sense Hat

El Sense HAT tiene una matriz LED RGB de 8 × 8, un joystick de cinco botones e incluye los siguientes sensores:

• Giroscopio
• Acelerómetro
• Magnetómetro
• Temperatura
• Barométrico
• presión
• Humedad

Se puede obtener más información sobre cómo trabajar con sense hat en los siguientes enlaces: Sense_Hat

Las API para sense hat están alojadas en: Sense_hat_API

El código para la programación de sense-hat se cubre en pasos posteriores. El código de Sense hat también se puede simular en un simulador alojado en: Sense-hat simulator

Paso 3: Montaje: Registrador de impacto

• El ensamblaje es más simple ya que el sensor sensor debe apilarse sobre pi (los pernos de montaje designados se proporcionan con el sensor sensor).
• Se puede conectar una cámara USB o una cámara pi. En el tutorial, se considera la cámara pi y, en consecuencia, se realiza la codificación de la misma.
• Inserte la tarjeta de memoria y configure el código python y el nodo -red (la configuración y el código se tratan en pasos posteriores)

La imagen de arriba muestra la cámara pi conectada a través de un cable plano a pi

Paso 4: Montaje: Registrador de impacto en el tablero del automóvil

Para montar la grabadora, he utilizado cinta de doble cara, la ventaja es que la grabadora se puede cambiar fácilmente a una posición diferente, la que mejor se adapte a su automóvil.

La cámara adicional se monta verticalmente como se muestra, usando la misma cinta de doble cara, Lo siguiente en la línea es conectar una fuente de energía (banco de energía de 10,000 mAH) junto con una conexión a Internet lista

Se requerirá conexión a Internet para la aplicación MQTT (los detalles para MQTT se tratan en pasos adicionales)

Paso 5: Impact Recoder: trabajo y aplicaciones

Desde el sensor sensor, la aceleración y el giroscopio se utilizan para verificar si los valores brutos están más allá del límite establecido en el código.

Acelerómetro: el acelerómetro indica la cantidad de fuerza gravitacional (fuerza G) que actúa en cada uno de los ejes x, y y z, si algún eje mide más de 1G de fuerza, entonces se puede detectar un movimiento rápido. (tenga en cuenta que el eje que apunta hacia abajo tendría un valor de 1g y debe considerarse en consecuencia en el código de Python).

Giroscopio El giroscopio se usa para medir el movimiento angular, es decir, durante un giro brusco, el sensor podría activarse (depende de la configuración en el código), por lo que una persona que gire bruscamente el vehículo quedaría atrapada.

Cualquier activación del límite establecido también se muestra en la matriz de LED del sombrero sensorial como "!" en rojo para la aceleración y verde para la activación del giroscopio

Paso 6: Descripción del software: nodo rojo

Node-RED es una herramienta de programación basada en flujo, desarrollada originalmente por el equipo de servicios de tecnología emergente de IBM y ahora forma parte de JS Foundation.

Se puede obtener más información sobre el nodo rojo a través del siguiente enlace: nodo-rojo

Para nuestro caso, estaríamos usando node -red para las siguientes actividades

(1) Interactuar con los joysticks para iniciar las funciones de la cámara

(2) Monitorear los impactos en el vehículo y transmitir la información al usuario final empleando MQTT y aceptando además los comandos del usuario final a través de MQTT e iniciando la aplicación requerida en pi

(3) Realización de algunas cosas básicas como el apagado de pi

Los siguientes pasos brindan información detallada para el diagrama de flujo implementado en node-red

Tenga en cuenta que los diagramas de flujo de nodo rojo interactúan con el código de Python, por lo tanto, la última parte cubre los aspectos del código de Python

Paso 7: Conceptos básicos de Node-red

Ciertos pasos básicos están resaltados para comenzar Node-red en un instante, pero sí, node-red es demasiado simple para comenzar y desarrollar aplicaciones.

• Iniciando Node-red: https:// localhost: 1880.
• Iniciando Node-red cuando pi está conectado a Internet https:// dirección IP>: 1880

Paso 8: Nodo-rojo: Flujo _1a

El Flow _1a, monitorea cualquier cambio en el archivo CSV y, en base a los cambios, es decir, el impacto detectado, la grabación de video de la cámara se configura en modo encendido y, además, se informa al usuario a través de Internet que se ha producido un impacto.

Paso 9: Nodo rojo: Flow_1b

En dicho flujo, la grabación de video se puede iniciar en cualquier momento con solo presionar el joystick

Paso 10: Nodo rojo: Flow_2a

En dicho flujo, cada vez que se almacena / carga una nueva imagen o video en el directorio, la información se transmite al usuario registrado a través de Internet.

Paso 11: Nodo rojo: Flow_2b

Este flujo está diseñado principalmente para el usuario remoto, a fin de controlar el dispositivo de la siguiente manera

(a) dispositivo de apagado

(b) tomar fotografías

(c) Grabar videos

(d) iniciar el código principal (el código del registrador de datos es el código principal que calcula el impacto)

Paso 12: Nodo rojo; Flow_3

El flujo está diseñado para acceso local, a fin de iniciar el código principal o el dispositivo de apagado.

Paso 13: MQTT

MQTT (Message Queue Server Telemetry Transport) es un protocolo TCP / IP, en el que el editor y el suscriptor interactúan.

En nuestro caso Pi es editor, mientras que la aplicación instalada en nuestro móvil / PC será el suscriptor.

De esta manera, al generar cualquier impacto, la información se transmite de forma remota al usuario (es imprescindible una conexión a Internet que funcione)

Se puede acceder a más información sobre MQTT desde el siguiente enlace: MQTT

Para comenzar a usar MQTT, primero debemos registrarnos, para el tutorial he usado cloudmqtt (www.cloudmqtt.com), hay un plan gratuito en "cute cat", eso es todo.

Después de registrarse, cree una instancia, diga "pi", después de lo cual obtendrá los siguientes detalles

• Nombre del servidor
• Puerto
• nombre de usuario
• contraseña

Se requiere lo anterior al suscribirse a través de un dispositivo móvil / pc

Para mi aplicación, he usado la aplicación MQTT de Google Play Store (versión de Android)

Paso 14: MQTT: suscriptor

La aplicación MQTT que se ejecuta en dispositivos móviles (versión de Android)

El impacto detectado en pi se retransmite

Paso 15: MQTT: Editar propiedades en Node-red

En rojo de nodo después de seleccionar el nodo MQTT, se debe mencionar "Nombre del servidor" y "tema". Esto debería ser el mismo en el extremo del suscriptor.

Paso 16: el código Python:

La funcionalidad del código es según el diagrama de flujo adjunto

Paso 17: El código final

Se adjunta el código de Python

Para hacer que nuestro script de Python se ejecute desde la terminal, necesitamos hacerlos ejecutables como chmod + x datalogger.py, además, la parte superior del código debe contener la siguiente línea # "shebang". / usr / bin / python3 (esto es necesario para ejecutar funciones desde node-red)

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

sense = SenseHat ()

importar csv

marca de tiempo = datetime.now ()

delay = 5 // delay se define para almacenar datos en el archivo data.csv rojo = (255, 0, 0) verde = (0, 255, 0) amarillo = (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"])

devolver sense_impact

def impact (): // función para detectar impacto # GPIO.setmode (GPIO. BCM) # GPIO.setup (4, GPIO. OUT) aceleración = sense.get_accelerometer_raw () x = aceleración ['x'] y = aceleración ['y'] z = aceleración ['z'] x = abs (x) y = abs (y) z = abs (z)

giroscopio = sense.get_gyroscope_raw ()

gyrox = gyro ["x"] gyroy = gyro ["y"] gyroz = gyro ["z"]

gyrox = redondo (gyrox, 2)

gyroy = ronda (gyroy, 2) gyroz = ronda (gyroz, 2)

impacto = get_sense_impact ()

si x> 1.5 oy> 1.5 oz> 1.5: // los valores se establecen después de la iteración en la carretera real se pueden cambiar en consecuencia para diferentes tipos y habilidades de conducción con open ('impact.csv', 'w', newline = ' ') como f: data_writer = writer (f) data_writer.writerow ([' acc x ',' acc y ',' acc z ',' gyro x ',' gyro y ',' gyro z ']) #GPIO. salida (4, GPIO. HIGH) sense.clear () sense.show_letter ("!", rojo) data_writer.writerow (impacto)

elif gyrox> 1.5 o gyroy> 1.5 o gyroz> 1.5: // los valores se establecen mirando la velocidad a la que se inician los giros con open ('impact.csv', 'w', newline = '') como f: data_writer = writer (f) data_writer.writerow (['acc x', 'acc y', 'acc z', 'gyro x', 'gyro y', 'gyro z']) # GPIO.output (4, GPIO. ALTA) sense.clear () sense.show_letter ("!", Verde) data_writer.writerow (impacto)

demás:

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

def get_sense_data (): // función para registrar y almacenar valores del sensor sense_data =

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

orientación = sense.get_orientation ()

sense_data.append (orientación ["guiñada"]) sense_data.append (orientación ["paso"]) sense_data.append (orientación ["rodar"])

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 ())

devolver sense_data

con open ('data.csv', 'w', nueva línea = '') como f:

data_writer = escritor (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 '])

mientras que es cierto:

print (get_sense_data ()) para el evento en sense.stick.get_events (): # Verifica si se presionó el joystick si event.action == "presionado": # Verifica en qué dirección si event.direction == "arriba": # sentido.show_letter ("U") # Flecha arriba aceleración = sense.get_accelerometer_raw () x = aceleración ['x'] y = aceleración ['y'] z = aceleración ['z'] x = redondeo (x, 0) y = redondo (y, 0) z = redondo (z, 0)

# Actualice la rotación de la pantalla dependiendo de qué camino hacia arriba 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 == "abajo": aceleración = sense.get_accelerometer_raw () x = aceleración ['x'] y = aceleración ['y'] z = aceleración ['z'] x = ronda (x, 0) y = round (y, 0) z = round (z, 0)

# Actualice la rotación de la pantalla dependiendo de qué camino hacia arriba 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") # Flecha hacia abajo sense.clear () h = sense.get_humidity () h = round (h, 1) message = "H:" + str (h) sense.show_message (mensaje, text_colour = verde, scroll_speed = 0.09) p = sense.get_pressure () p = round (p, 1) message = "P:" + str (p) sense.show_message (mensaje, text_colour = amarillo, scroll_speed = 0.09)

# elif event.direction == "izquierda":

# aceleración = sense.get_accelerometer_raw () # x = aceleración ['x'] #y = aceleración ['y'] #z = aceleración ['z'] # x = round (x, 0) # y = round (y, 0) # z = redondo (z, 0)

# Actualice la rotación de la pantalla dependiendo de en qué dirección suban // No utilizado y controlado por 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") # Flecha izquierda # elif event.direction == "right": # sense.show_letter ("K") # Flecha derecha # elif event.direction == "middle": # sense.clear ()

impacto()

datos = get_sense_data ()

dt = data [-1] - marca de tiempo si dt.seconds> retraso: data_writer.writerow (datos) marca de tiempo = datetime.now ()

Paso 18: Monitoreo de video en vivo

Impact Recorder también se puede usar para monitorear video en vivo, ya que el video se puede iniciar en cualquier momento y en cualquier lugar a través de MQTT

usaríamos el reproductor VLC para transmitir videos, de forma predeterminada en el último raspbian, el VLC está preinstalado, de lo contrario, instale vlc como en

Se puede acceder a más información sobre cómo ver la transmisión de la red a través de la transmisión de la red VLC

¡¡Gracias por leer!!

La grabadora de impacto puede hacer mucho más …

Tenga cuidado con el próximo espacio para el análisis del campo magnético al realizar el mapeo de obstáculos