Aufprallrekorder für Fahrzeuge - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:18

Der Aufprallrekorder wurde entwickelt, um einen während der Fahrt oder im Stillstand auf das Fahrzeug ausgeübten Aufprall aufzuzeichnen. Die Auswirkungen werden in der Datenbank in Form von Messwerten sowie Video / Bild gespeichert. Bei Auswirkungen kann der Remote-Benutzer in Echtzeit überprüft werden, und der Remote-Benutzer kann dann das gespeicherte Video ansehen oder Fernzugriff auf die Pi-Kamera nehmen und Ereignisse entsprechend ansehen.

Schritt 1: Teile & Zubehör

(1) Raspberry Pi 3 oder besser: Rechenleistung erforderlich

(2) Himbeer-Pi-Sinn-Hut

(3) Raspberry Pi-Kamera / USB-Kamera

(4) Speicherkarte mit neuestem Raspbian-Image (Sollte Node Red unterstützen, tut es fast jedes neueste Image)

(5) Stromversorgung mindestens 2,1 A (ich habe die Batteriebank für den Standalone-Betrieb im Auto verwendet)

Schritt 2: Teilebeschreibung: Sense Hat

Der Sense HAT verfügt über eine 8×8 RGB-LED-Matrix, einen 5-Tasten-Joystick und beinhaltet folgende Sensoren:

• Gyroskop
• Beschleunigungsmesser
• Magnetometer
• Temperatur
• Barometrisch
• Druck
• Feuchtigkeit

Weitere Informationen zum Arbeiten mit Sense Hat können folgenden Links entnommen werden: Sense_Hat

API für Sense Hat werden gehostet unter: Sense_hat_API

Code für die Sense-Hat-Programmierung wird in späteren Schritten behandelt. Sense-Hat-Code kann auch auf einem Simulator simuliert werden, der unter gehostet wird: Sense-Hat-Simulator

Schritt 3: Zusammenbau: Impact Recorder

• Der Zusammenbau ist einfacher, da der Sensorhut über pi gestapelt werden muss (bezeichnete Befestigungsschrauben werden mit dem Sensorhut geliefert).
• USB-Kamera oder Pi-Kamera können angeschlossen werden. Im Tutorial wird die Pi-Kamera betrachtet und entsprechend codiert.
• Stecken Sie die Speicherkarte ein und konfigurieren Sie Python-Code und Node -red (Konfiguration & Code wird in weiteren Schritten behandelt)

Das Bild oben zeigt die Pi-Kamera, die über ein Flachbandkabel mit dem Pi. verbunden ist

Schritt 4: Zusammenbau: Impact Recorder auf dem Armaturenbrett des Autos

Für die Montage des Recorders habe ich doppelseitiges Klebeband verwendet, der Vorteil ist, dass der Recorder leicht in verschiedene Positionen verschoben werden kann, je nachdem, was am besten zu Ihrem Auto passt.

Die weitere Kamera wird wie abgebildet vertikal montiert, mit dem gleichen doppelseitigen Klebeband, Als nächstes müssen Sie eine Stromquelle (10.000-mAh-Powerbank) zusammen mit einer betriebsbereiten Internetverbindung anschließen

Für die MQTT-Anwendung ist eine Internetverbindung erforderlich (die Details für MQTT werden in weiteren Schritten behandelt)

Schritt 5: Impact Recorder: Arbeiten & Anwendungen

Vom Sense Hat aus werden Beschleunigung und Gyroskop verwendet, um zu überprüfen, ob die Rohwerte außerhalb des im Code festgelegten Grenzwerts liegen.

Beschleunigungsmesser: Der Beschleunigungsmesser gibt an, wie viel Gravitationskraft (G-Kraft) auf jede der x-, y- und z-Achsen wirkt, wenn eine Achse mehr als 1G Kraft misst, als schnelle Bewegung erkannt werden kann. (Bitte beachten Sie, dass die nach unten zeigende Achse einen Wert von 1g hätte und im Python-Code entsprechend berücksichtigt werden muss).

Gyroskop; Das Gyroskop dient zur Messung von Winkelbewegungen, d.h. bei scharfen Kurven kann der Sensor aktiviert werden (abhängig von der Einstellung im Code), so dass eine Person, die das Fahrzeug stark wirbelt, erfasst wird!!

Jede Aktivierung des eingestellten Limits wird auch auf der Sense Hat-LED-Matrix als "!" in Rot für Beschleunigung & Grün für Gyroskop-Aktivierung

Schritt 6: Softwarebeschreibung: Node Red

Node-RED ist ein Flow-basiertes Programmiertool, das ursprünglich vom Emerging Technology Servicesteam von IBM entwickelt wurde und heute Teil der JS Foundation ist.

Weitere Informationen zu Node Red erhalten Sie unter folgendem Link:node-red

In unserem Fall würden wir node -red für folgende Aktivitäten verwenden

(1) Interaktion mit den Joysticks, um Kamerafunktionen zu starten

(2) Überwachung der Auswirkungen auf das Fahrzeug und Weiterleitung der Informationen an den Endbenutzer durch Verwendung von MQTT und weitere Annahme der Endbenutzerbefehle über MQTT und Starten der erforderlichen Anwendung auf pi

(3) Ausführen einiger grundlegender Dinge wie das Herunterfahren von pi

Die weiteren Schritte geben die detaillierten Informationen für das auf node-red implementierte Flussdiagramm

Bitte beachten Sie, dass die knotenroten Flussdiagramme mit dem Python-Code interagieren, daher behandelt der letzte Teil die Python-Code-Aspekte

Schritt 7: Knotenrote Grundlagen

Bestimmte grundlegende Schritte werden hervorgehoben, um Node-red blitzschnell zu beginnen, aber ja, node-red ist zu einfach, um Anwendungen zu beginnen und auszuarbeiten.

• Startknoten-rot:
• Starten von Node-red, wenn pi mit dem Internet verbunden ist https:// ip address>:1880

Schritt 8: Knoten-rot: Fluss _1a

Der Flow _1a überwacht alle Änderungen in der CSV-Datei und auf der Grundlage der Änderungen, d

Schritt 9: Knoten Rot: Flow_1b

In diesem Ablauf kann die Videoaufnahme jederzeit durch Drücken des Joysticks gestartet werden

Schritt 10: Knoten Rot: Flow_2a

In diesem Ablauf werden die Informationen jedes Mal, wenn ein neues Bild oder Video gespeichert/in das Verzeichnis hochgeladen wird, über das Internet an den registrierten Benutzer weitergeleitet

Schritt 11: Knoten Rot: Flow_2b

Dieser Ablauf ist in erster Linie für den Remote-Benutzer bestimmt, um das Gerät auf folgende Weise zu steuern:

(a) Abschaltvorrichtung

(b) Fotos machen

(c) Videos aufnehmen

(d) Start-Hauptcode (Datenlogger-Code ist der Hauptcode, der die Auswirkung berechnet)

Schritt 12: Knoten Rot; Flow_3

Der Flow ist für den lokalen Zugriff ausgelegt, um den Hauptcode zu starten oder das Gerät herunterzufahren

Schritt 13: MQTT

MQTT (Message Queuing Telemetry Transport) ist ein TCP/IP-Protokoll, bei dem Herausgeber und Abonnent interagieren.

In unserem Fall ist Pi Herausgeber, während die auf unserem Handy/PC installierte Anwendung der Abonnent ist.

Auf diese Weise werden bei Auftreten von Auswirkungen Informationen aus der Ferne an den Benutzer weitergeleitet (eine funktionierende Internetverbindung ist erforderlich).

Weitere Informationen zu MQTT finden Sie unter folgendem Link: MQTT

Um MQTT nutzen zu können, müssen wir uns zuerst registrieren, für das Tutorial habe ich cloudmqtt verwendet (www.cloudmqtt.com), es gibt einen kostenlosen Plan unter "cute cat", das ist alles.

Nachdem Sie sich registriert haben, erstellen Sie eine Instanz und sagen Sie "pi". Danach erhalten Sie die folgenden Details:

• Servername
• Hafen
• Nutzername
• Passwort

Das oben Genannte ist erforderlich, wenn Sie über Handy/PC abonnieren

Für meine Anwendung habe ich die MQTT-Anwendung aus dem Google Play Store (Android-Version) verwendet.

Schritt 14: MQTT: Abonnent

Die auf Mobilgeräten ausgeführte MQTT-Anwendung (Android-Version)

Die auf pi erkannten Auswirkungen werden zurückgemeldet

Schritt 15: MQTT: Bearbeiten von Eigenschaften in Node-red

In Knoten-Rot, nachdem MQTT-Knoten ausgewählt wurde, sind "Servername" und "Thema" zu erwähnen. Dies sollte auf der Teilnehmerseite gleich sein

Schritt 16: Der Python-Code:

Die Codefunktionalität entspricht dem beigefügten Flussdiagramm

Schritt 17: Der endgültige Code

Der Python-Code ist angehängt

Damit unser Python-Skript vom Terminal aus ausgeführt werden kann, müssen wir es als chmod +x datalogger.py ausführbar machen, dann sollte der Code oben die folgende "shebang" -Zeile # enthalten! /usr/bin/python3 (dies ist erforderlich, um Funktionen von node-red auszuführen)

#!/usr/bin/python3 // shebang linefrom sense_hat importiere SenseHat von datetime importiere datetime von csv importwriter importiere RPi. GPIO als GPIO from time importiere sleep

Sinn = SinnHat()

CSV-Datei importieren

Zeitstempel = datetime.now()

delay = 5 // Verzögerung ist definiert, um Daten in der Datei data.csv zu speichern Rot = (255, 0, 0) Grün = (0, 255, 0) Gelb = (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"])

Kreisel = sense.get_gyroscope_raw()

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

zurück sense_impact

def impact(): // Funktion zur Erkennung von Stößen #GPIO.setmode(GPIO. BCM) #GPIO.setup(4, GPIO. OUT) Beschleunigung = sense.get_accelerometer_raw() x = Beschleunigung['x'] y = Beschleunigung['y'] z = Beschleunigung['z'] x=abs(x) y=abs(y) z=abs(z)

Kreisel = sense.get_gyroscope_raw()

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

Gyrox = rund(Gyrox, 2)

gyroy = rund(gyroy, 2) gyroz = rund(gyroz, 2)

Impact = get_sense_impact()

if x > 1.5 or y > 1.5 or z > 1.5: // Die Werte werden nach der Iteration auf der tatsächlichen Straße gesetzt, können mit open('impact.csv', 'w', newline=' ') als 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("!", red) data_writer.writerow(impact)

elif gyrox > 1.5 or gyroy > 1.5 or gyroz > 1.5: // die Werte werden unter Berücksichtigung der Geschwindigkeit gesetzt, mit der Kurven eingeleitet werden mit open('impact.csv', 'w', newline='') als f: data_writer = write(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("!", green) data_writer.writerow(impact)

anders:

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

def get_sense_data(): // Funktion zum Aufzeichnen und Speichern von Werten vom Sensor sense_data =

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

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

Kreisel = sense.get_gyroscope_raw()

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

sense_data.append(datetime.now())

Sinn_Daten zurückgeben

mit open('data.csv', 'w', newline='') als f:

Datenschreiber = Schreiber (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'])

während Wahr:

print(get_sense_data()) für Event in sense.stick.get_events(): # Prüfen ob der Joystick gedrückt wurde if event.action == "pressed": # Prüfen in welche Richtung if event.direction == "up": # sense.show_letter("U") # Pfeil nach oben Beschleunigung = sense.get_accelerometer_raw() x = Beschleunigung['x'] y = Beschleunigung['y'] z = Beschleunigung['z'] x=round(x, 0) y =rund(y,0) z=rund(z,0)

# Aktualisieren Sie die Drehung des Displays, je nachdem, in welche Richtung die if x == -1: sense.set_rotation(90) elif y == 1: sense.set_rotation(270) elif y == -1: sense.set_rotation(180.)) sonst: 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": Beschleunigung = sense.get_accelerometer_raw() x = Beschleunigung['x'] y = Beschleunigung['y'] z = Beschleunigung['z'] x=round(x, 0) y=rund(y, 0) z=rund(z, 0)

# Aktualisieren Sie die Drehung des Displays je nachdem, in welche Richtung die 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") # Pfeil nach unten 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 = gelb, scroll_speed=0.09)

# elif event.direction == "links":

# Beschleunigung = sense.get_accelerometer_raw() # x = Beschleunigung['x'] #y = Beschleunigung['y'] #z = Beschleunigung['z'] #x=Runde(x, 0) #y=Runde(y, 0) #z=rund(z, 0)

# Aktualisieren Sie die Drehung des Displays, je nachdem, in welche Richtung // Nicht verwendet und gesteuert von 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") # Pfeil nach links # elif event.direction == "right": # sense.show_letter ("K") # Pfeil nach rechts # elif event.direction == "middle": # sense.clear()

Einschlag()

data = get_sense_data()

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

Schritt 18: Live-Video überwachen

Impact Recorder kann auch zur Überwachung von Live-Videos verwendet werden, da Video jederzeit und überall über MQTT. gestartet werden kann

Wir würden den VLC-Player verwenden, um Videos zu streamen, standardmäßig ist der VLC im neuesten Raspbian vorinstalliert, ansonsten installiere vlc wie unter

Weitere Informationen zum Anzeigen von Netzwerkstreams können über den VLC-Netzwerkstream abgerufen werden

Danke fürs Lesen!!

Der Impact Recorder kann noch viel mehr.

Achten Sie bei der Hinderniskartierung auf den nächsten Platz für die Magnetfeldanalyse