Enregistreur d'impact pour véhicules : 18 étapes (avec photos)

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:07

L'enregistreur d'impact est conçu pour enregistrer l'impact subi par le véhicule pendant la conduite ou à l'arrêt. Les impacts sont stockés dans la base de données sous forme de lectures ainsi que de vidéo/image. Lors de l'impact, l'utilisateur distant peut être vérifié en temps réel, et l'utilisateur distant peut alors regarder la vidéo enregistrée ou accéder à distance à la caméra pi et regarder les événements en conséquence..

Étape 1: Pièces et accessoires

(1) Raspberry Pi 3 ou supérieur: Puissance de calcul requise

(2) chapeau de sens framboise pi

(3) Caméra Raspberry pi/caméra Usb

(4) Carte mémoire avec la dernière image raspbian (devrait prendre en charge le nœud rouge, presque toutes les dernières images le font)

(5) Alimentation d'au moins 2,1 A (j'ai utilisé un banc de batteries pour un fonctionnement autonome en voiture)

Étape 2: Description des pièces: Sense Hat

Le Sense HAT dispose d'une matrice de LED RVB 8×8, d'un joystick à cinq boutons et comprend les capteurs suivants:

• Gyroscope
• Accéléromètre
• Magnétomètre
• Température
• Barométrique
• pression
• Humidité

Plus d'informations sur l'utilisation de sense hat peuvent être obtenues à partir des liens suivants: Sense_Hat

Les API pour sense hat sont hébergées sur: Sense_hat_API

Le code pour la programmation sense-hat est couvert dans les étapes ultérieures. Le code Sense hat peut également être simulé sur un simulateur hébergé sur: Sense-hat simulator

Etape 3: Assemblage: Impact Recorder

• L'assemblage est plus simple car le chapeau de détection doit être empilé sur pi (les boulons de montage désignés sont fournis avec le chapeau de détection).
• Une caméra USB ou une caméra pi peut être connectée. Dans le didacticiel, la caméra pi est prise en compte et, en conséquence, le codage est effectué pour la même chose.
• Insérez la carte mémoire et configurez le code python et node -red (la configuration et le code sont traités dans les étapes suivantes)

L'image ci-dessus montre une caméra pi connectée via un câble plat à pi

Étape 4: Assemblage: Enregistreur d'impact sur le tableau de bord de la voiture

Pour le montage de l'enregistreur, j'ai utilisé du ruban adhésif double face, l'avantage est que l'enregistreur peut être facilement déplacé dans différentes positions, celle qui convient le mieux à votre voiture.

Une autre caméra est montée verticalement comme indiqué, en utilisant le même ruban adhésif double face, La prochaine étape consiste à connecter une source d'alimentation (banque d'alimentation 10 000 mAH) avec une connexion Internet prête

Une connexion Internet est requise pour l'application MQTT (les détails de MQTT sont traités dans les étapes suivantes)

Étape 5: Impact Recoder: Fonctionnement & Applications

À partir du chapeau de détection, l'accélération et le gyroscope sont utilisés pour vérifier si les valeurs brutes dépassent la limite définie dans le code.

Accéléromètre: L'accéléromètre indique la quantité de force gravitationnelle (force G) agissant sur chacun des axes x, y et z, si un axe mesure plus de 1G de force, alors un mouvement rapide peut être détecté. (veuillez noter que l'axe pointant vers le bas aurait une valeur de 1g et doit être pris en compte en conséquence dans le code python).

Gyroscope; Le gyroscope est utilisé pour mesurer le mouvement angulaire, c'est-à-dire que lors d'un virage serré, le capteur peut être activé (selon le réglage du code), de sorte qu'une personne faisant tourner brusquement le véhicule se ferait prendre !

Toute activation de la limite définie est également affichée sur la matrice LED du chapeau de détection sous la forme "!" en rouge pour l'accélération et en vert pour l'activation du gyroscope

Étape 6: Description du logiciel: Node Red

Node-RED est un outil de programmation basé sur les flux, développé à l'origine par l'équipe Emerging Technology Services d'IBM et fait maintenant partie de la Fondation JS.

Plus d'informations sur node red peuvent être obtenues via le lien suivant: node-red

Dans notre cas, nous utiliserions node -red pour les activités suivantes

(1) Interagir avec les joysticks pour démarrer les fonctions de l'appareil photo

(2) Surveillance des impacts sur le véhicule et transmission des informations à l'utilisateur final en utilisant MQTT et en acceptant les commandes de l'utilisateur final via MQTT et en démarrant l'application requise sur pi

(3) Effectuer des tâches de base comme l'arrêt de pi

Les étapes suivantes donnent les informations détaillées pour le diagramme de flux mis en œuvre sur node-red

Veuillez noter que les diagrammes de flux nœud-rouge interagissent avec le code python, donc cette dernière partie couvre les aspects du code python

Étape 7: Notions de base sur Node-red

Certaines étapes de base sont mises en évidence pour commencer Node-red en un clin d'œil, mais oui, node-red est trop simple pour commencer et élaborer des applications.

• Démarrage de Node-red:
• Démarrage de Node-red lorsque pi est connecté à Internet https:// adresse ip>:1880

Étape 8: Node-red: Flow _1a

Le Flow _1a surveille tout changement dans le fichier CSV et sur la base des changements, c'est-à-dire l'impact détecté, l'enregistrement vidéo de la caméra est activé et en outre, l'utilisateur est informé sur Internet qu'un impact s'est produit.

Étape 9: Nœud rouge: Flow_1b

Dans ledit flux, l'enregistrement vidéo peut être démarré à tout moment en appuyant simplement sur le joystick

Étape 10: Nœud Rouge: Flow_2a

Dans ledit flux, chaque fois qu'une nouvelle image ou vidéo est stockée/téléchargée dans le répertoire, l'information est relayée à l'utilisateur enregistré sur Internet.

Étape 11: Nœud Rouge: Flow_2b

Ce flux est principalement conçu pour l'utilisateur distant, afin de contrôler l'appareil de la manière suivante

(a) dispositif d'arrêt

(b) prendre des photos

(c) Enregistrer des vidéos

(d) démarrer le code principal (le code de l'enregistreur de données est le code principal qui calcule l'impact)

Étape 12: Nœud Rouge; Flux_3

Le flux est conçu pour un accès local, afin de démarrer le code principal ou le dispositif d'arrêt

Étape 13: MQTT

MQTT (Message Queuing Telemetry Transport) est un protocole TCP/IP, dans lequel l'éditeur et l'abonné interagissent.

Dans notre cas, Pi est éditeur, alors que l'application installée sur notre mobile/PC sera l'abonné.

De cette façon, lors de la génération de tout impact, les informations sont relayées à distance vers l'utilisateur (une connexion Internet fonctionnelle est indispensable)

Plus d'informations sur MQTT sont accessibles à partir du lien suivant: MQTT

Pour commencer à utiliser MQTT, nous devons d'abord nous inscrire, pour le tutoriel que j'ai utilisé cloudmqtt (www.cloudmqtt.com), il existe un plan gratuit sous "cute cat", c'est tout.

Après l'enregistrement, créez une instance, dites "pi", après quoi vous obtiendrez les détails suivants

• Nom du serveur
• Port
• Nom d'utilisateur
• le mot de passe

Les éléments ci-dessus sont requis lors de l'abonnement via mobile/pc

Pour mon application, j'ai utilisé l'application MQTT de Google Play Store (version Android)

Etape 14: MQTT: Abonné

L'application MQTT fonctionnant sur mobile (version Android)

Les impacts détectés sur pi sont relayés

Étape 15: MQTT: Modification des propriétés dans Node-red

Dans le nœud rouge après avoir sélectionné le nœud MQTT, le "nom du serveur" et le "sujet" doivent être mentionnés. Cela devrait être le même du côté de l'abonné

Étape 16: Le code Python:

La fonctionnalité du code est conforme à l'organigramme ci-joint

Étape 17: Le code final

Le code python est joint

Pour que notre script python s'exécute à partir du terminal, nous devons les rendre exécutables en tant que chmod +x datalogger.py, puis le haut du code doit contenir la ligne "shebang" suivante # ! /usr/bin/python3 (ceci est requis pour exécuter des fonctions à partir de node-red)

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

sens = SenseHat()

importer csv

horodatage = datetime.now()

delay = 5 // le délai est défini pour stocker les données dans le fichier data.csv rouge = (255, 0, 0) vert = (0, 255, 0) jaune = (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"])

gyroscope = sense.get_gyroscope_raw()

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

retour sense_impact

def impact(): // fonction pour détecter l'impact #GPIO.setmode(GPIO. BCM) #GPIO.setup(4, GPIO. OUT) accélération = sense.get_accelerometer_raw() x = accélération['x'] y = accélération['y'] z = accélération['z'] x=abs(x) y=abs(y) z=abs(z)

gyroscope = sense.get_gyroscope_raw()

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

gyrox = rond(gyrox, 2)

gyro = rond(gyro, 2) gyroz = rond(gyroz, 2)

impact = get_sense_impact()

si x > 1,5 ou y > 1,5 ou z > 1,5: // les valeurs sont définies après l'itération sur la route réelle peuvent être modifiées en conséquence pour différents types et compétences de conduite avec 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("!", rouge) data_writer.writerow(impact)

elif gyrox > 1.5 ou gyroy > 1.5 ou gyroz > 1.5: // les valeurs sont définies en fonction de la vitesse à laquelle les virages sont initiés avec open('impact.csv', 'w', newline='') comme f: data_writer = écrivain(f) data_writer.writerow(['acc x', 'acc y', 'acc z', 'gyro x', 'gyro y', 'gyro z']) #GPIO.output(4, GPIO. HAUT) sense.clear() sense.show_letter("!", vert) data_writer.writerow(impact)

autre:

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

def get_sense_data(): // fonction pour enregistrer et stocker les valeurs du capteur 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(orientation["lacet"]) sense_data.append(orientation["pas"]) sense_data.append(orientation["rouler"])

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"])

gyroscope = sense.get_gyroscope_raw()

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

sense_data.append(datetime.now())

retourner sense_data

avec open('data.csv', 'w', newline='') comme f:

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

tant que vrai:

print(get_sense_data()) for event in sense.stick.get_events(): # Vérifiez si le joystick a été enfoncé if event.action == "pressed": # Vérifiez dans quelle direction if event.direction == "up": # sense.show_letter("U") # Accélération de la flèche vers le haut = sense.get_accelerometer_raw() x = accélération['x'] y = accélération['y'] z = accélération['z'] x=round(x, 0) y =rond(y, 0) z=rond(z, 0)

# Mettre à jour la rotation de l'affichage en fonction de la montée du 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 = rouge, scroll_speed=0.09) elif event.direction == "down": accélération = sense.get_accelerometer_raw() x = accélération['x'] y = accélération['y'] z = accélération['z'] x=round(x, 0) y=arrondi(y, 0) z=arrondi(z, 0)

# Mettre à jour la rotation de l'affichage en fonction de la montée du 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") # Flèche vers le bas 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 = jaune, scroll_speed=0.09)

# elif event.direction == "gauche":

# accélération = sense.get_accelerometer_raw() # x = accélération['x'] #y = accélération['y'] #z = accélération['z'] #x=round(x, 0) #y=round(y, 0) #z=arrondi(z, 0)

# Mettre à jour la rotation de l'affichage en fonction de la hauteur du // Non utilisé et contrôlé par 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") # Flèche gauche # elif event.direction == "right": # sense.show_letter ("K") # Flèche droite # elif event.direction == "middle": # sense.clear()

impacter()

données = get_sense_data()

dt = data[-1] - horodatage si dt.seconds > délai: data_writer.writerow(data) timestamp = datetime.now()

Étape 18: Surveillance de la vidéo en direct

Impact Recorder peut également être utilisé pour surveiller la vidéo en direct, car la vidéo peut être démarrée à tout moment n'importe où via MQTT

nous utiliserions le lecteur VLC pour diffuser des vidéos, par défaut dans le dernier raspbian le VLC est pré-installé, sinon installez vlc comme ci-dessous

Plus d'informations sur l'affichage du flux réseau sont accessibles via le flux réseau VLC

Merci pour la lecture!!

Il y a beaucoup plus que l'enregistreur d'impact peut faire.

Méfiez-vous de l'espace suivant pour l'analyse du champ magnétique lors de la réalisation de la cartographie des obstacles