Impact Recorder til køretøjer: 18 trin (med billeder)

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:27

Impact Recorder er designet til at registrere påvirkning, der påføres køretøjet, mens du kører eller står stille. Virkningerne gemmes i databasen i form af aflæsninger såvel som video/billede. Ved påvirkning fjernbruger kan verificeres i realtid, og fjernbruger kan end se den gemte video eller tage fjernadgang til pi -kamera og se begivenheder i overensstemmelse hermed.

Trin 1: Dele og tilbehør

(1) Raspberry Pi 3 eller bedre: Beregnet computerkraft

(2) Hindbær pi sense hat

(3) Hindbær pi kamera / Usb kamera

(4) Hukommelseskort med nyeste raspbian -billede (Skulle understøtte knude rød, næsten alle nyeste billeder gør)

(5) Strømforsyning mindst 2,1 A (jeg har brugt batteribank til selvstændig drift i bil)

Trin 2: Dele Beskrivelse: Sense Hat

Sense HAT har en 8 × 8 RGB LED-matrix, et joystick med fem knapper og indeholder følgende sensorer:

• Gyroskop
• Accelerometer
• Magnetometer
• Temperatur
• Barometrisk
• tryk
• Fugtighed

Flere oplysninger om arbejde med sense hat kan hentes fra følgende links: Sense_Hat

API til sense hat er hostet på: Sense_hat_API

Kode til sense-hat programmering er dækket i senere trin. Sense hat-kode kan også simuleres på en simulator hostet på: Sense-hat simulator

Trin 3: Samling: Impact Recorder

• Montering er enklere, da sense hat skal stables over pi (udpegede monteringsbolte er forsynet med sense hat).
• USB -kamera eller pi -kamera kan tilsluttes. I selvstudiet overvejes pi -kamera, og derfor udføres kodning for det samme.
• Indsæt hukommelseskortet, og konfigurer python -kode og knude -rød (konfiguration og kode er dækket i yderligere trin)

Billedet ovenfor viser pi-kamera forbundet via fladbåndskabel til pi

Trin 4: Montering: Impact Recorder på bilens instrumentbræt

Til montering af optageren har jeg brugt dobbeltsidet tape, fordelen er, at optageren let kan flyttes i en anden position, alt efter hvad der passer bedst til din bil.

Yderligere kamera er monteret lodret som vist ved hjælp af samme dobbeltsidebånd, Næste i rækken er at tilslutte en strømkilde (10.000 mAH powerbank) sammen med en klar internetforbindelse

Internetforbindelse er påkrævet for MQTT -applikation (detaljerne for MQTT er dækket i yderligere trin)

Trin 5: Impact Recoder: Working & Applications

Fra sansehatten bruges acceleration og gyroskop til at kontrollere, om råværdierne er over den fastsatte grænse i koden.

Accelerometer: Accelerometeret fortæller mængden af tyngdekraft (G-kraft), der virker på hver af x-, y & z-akserne, hvis en akse måler mere end 1G kraft, end hurtig bevægelse kan detekteres. (Bemærk, at aksen, der peger nedad, ville have 1 g værdi og skal betragtes i overensstemmelse hermed i python -kode).

Gyroskop; Gyroskopet bruges til at måle vinkelbevægelse, dvs. under skarpe sving kan sensoren blive aktiveret (afhænger af indstillingen i koden), så en person, der hvirvler kraftigt, ville blive fanget !!

Enhver aktivering af den indstillede grænse vises også på sense hat LED -matrix som "!" i rødt for acceleration og grønt for gyroskopaktivering

Trin 6: Softwarebeskrivelse: Node Red

Node-RED er et flowbaseret programmeringsværktøj, oprindeligt udviklet af IBM’s Emerging Technology Servicesteam og nu en del af JS Foundation.

Flere oplysninger om knude rød kan fås via følgende link: knude-rød

I vores tilfælde ville vi bruge knude -rød til følgende aktiviteter

(1) Interaktion med joysticks for at starte kamerafunktioner

(2) Overvågning af påvirkningerne af køretøjet og videresendelse af oplysningerne til slutbrugeren ved at anvende MQTT og yderligere acceptere slutbrugerkommandoerne gennem MQTT og starte den nødvendige applikation på pi

(3) Udførelse af nogle grundlæggende ting som nedlukning af pi

De yderligere trin giver detaljerede oplysninger om flowdiagrammet implementeret på node-red

Bemærk, at knude-røde flowdiagrammer interagerer med pythonkoden, derfor dækker den sidste del aspekterne af python-koden

Trin 7: Node-red Basics

Visse grundlæggende trin fremhæves for at begynde Node-rød på et øjeblik, men ja node-rød er for simpel til at starte og udarbejde applikationer.

• Starter Node-red: https:// localhost: 1880.
• Starter Node-red, når pi er forbundet til internettet https:// ip-adresse>: 1880

Trin 8: Knude-rød: Flow _1a

Flow _1a, overvåger eventuelle ændringer i CSV -filen og på grundlag af ændringerne, det vil sige påvirkning detekteret, kameravideooptagelse er indstillet til on -tilstand, og yderligere informeres brugeren over internettet om, at der er sket en påvirkning

Trin 9: Knude rød: Flow_1b

I det nævnte flow kan videooptagelse startes når som helst ved blot at trykke på joysticket

Trin 10: Knude rød: Flow_2a

I det nævnte flow, hver gang et nyt billede eller en video gemmes/uploades til biblioteket, videregives oplysningerne til den registrerede bruger over internettet

Trin 11: Knude rød: Flow_2b

Denne strømning er primært designet til fjernbrugeren for at styre enheden på følgende måde

(a) lukkeanordning

(b) tage billeder

(c) Optag videoer

(d) start hovedkode (datalogger -kode er hovedkoden, der beregner virkningen)

Trin 12: Knude rød; Flow_3

Flowet er designet til lokal adgang for at starte hovedkoden eller lukkeenheden

Trin 13: MQTT

MQTT (Message Queuing Telemetry Transport) er en TCP/IP -protokol, hvor udgiver og abonnent interagerer.

I vores tilfælde er Pi udgiver, mens applikationen installeret i vores moblile/pc skal være abonnenten.

På denne måde ved generering af enhver indflydelse videresendes oplysninger eksternt til brugeren (en fungerende internetforbindelse er et must)

Flere oplysninger om MQTT kan tilgås fra følgende link: MQTT

For at begynde at bruge MQTT skal vi først registrere, for selvstudiet har jeg brugt cloudmqtt (www.cloudmqtt.com), der er en gratis plan under "cute cat", det er alt.

Efter registrering skal du oprette en forekomst, sige "pi", hvorefter du får følgende detaljer

• Server navn
• Havn
• brugernavn
• adgangskode

Ovenstående er påkrævet, mens du abonnerer via mobil/pc

Til min applikation har jeg brugt MQTT -applikation fra Google Play Store (Android -version)

Trin 14: MQTT: Abonnent

MQTT -applikationen kører på mobilen (Android -version)

Virkningen detekteret på pi videresendes

Trin 15: MQTT: Redigering af egenskaber i Node-rød

I knude-rød efter valg af MQTT-knude, "Servernavn" og "emne", der skal nævnes. Dette bør være det samme i abonnentens ende

Trin 16: Python -koden:

Kodefunktionen er som vedlagt flowdiagram

Trin 17: Den endelige kode

Python -koden er vedhæftet

For at få vores python -script til at køre fra terminal, skal vi gøre dem eksekverbare som chmod +x datalogger.py, end at toppen af koden skal indeholde følgende "shebang" linje #! /usr/bin/python3 (dette er påkrævet for at udføre funktioner fra knude-rød)

#!/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

sense = SenseHat ()

importer csv

tidsstempel = datetime.now ()

forsinkelse = 5 // forsinkelse er defineret til at gemme data i data.csv -fil rød = (255, 0, 0) grøn = (0, 255, 0) gul = (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"]))

gyro = sense.get_gyroscope_raw ()

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

return sense_impact

def impact (): // funktion til at registrere påvirkning #GPIO.setmode (GPIO. BCM) #GPIO.setup (4, GPIO. OUT) acceleration = sense.get_accelerometer_raw () x = acceleration ['x'] y = acceleration ['y'] z = acceleration ['z'] x = abs (x) y = abs (y) z = abs (z)

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

hvis x> 1,5 eller y> 1,5 eller z> 1,5: // værdierne er sat efter iteration på den faktiske vej kan ændres tilsvarende for forskellige typer og kørefærdigheder med åben ('impact.csv', 'w', newline = ' ') som f: data_writer = skribent (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 ("!", rød) data_writer.writerow (effekt)

elif gyrox> 1.5 eller gyroy> 1.5 eller gyroz> 1.5: // værdierne indstilles og kigger på den hastighed, hvormed drejninger indledes med open ('impact.csv', 'w', newline = '') som f: data_writer = skribent (f) data_writer.writerow (['acc x', 'acc y', 'acc z', 'gyro x', 'gyro y', 'gyro z']) #GPIO.output (4, GPIO. HØJ) sense.clear () sense.show_letter ("!", Grøn) data_writer.writerow (effekt)

andet:

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

def get_sense_data (): // funktion til registrering og lagring af værdier fra sensor sense_data =

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

orientering = sense.get_orientation ()

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

gyro = sense.get_gyroscope_raw ()

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

sense_data.append (datetime.now ())

returner sense_data

med open ('data.csv', 'w', newline = '') som f:

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

mens det er sandt:

print (get_sense_data ()) for begivenhed i sense.stick.get_events (): # Kontroller, om der blev trykket på joysticket, hvis event.action == "presset": # Kontroller hvilken retning, hvis event.direction == "up": # sense.show_letter ("U") # Pil op acceleration = sense.get_accelerometer_raw () x = acceleration ['x'] y = acceleration ['y'] z = acceleration ['z'] x = rund (x, 0) y = runde (y, 0) z = rund (z, 0)

# Opdater displayets rotation afhængigt af hvilken vej op til 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 (meddelelse, tekst_farve = rød, scroll_speed = 0,09) elif event.direction == "ned": acceleration = sense.get_accelerometer_raw () x = acceleration ['x'] y = acceleration ['y'] z = acceleration ['z'] x = rund (x, 0) y = runde (y, 0) z = runde (z, 0)

# Opdater displayets rotation afhængigt af hvilken vej op til 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") # Pil ned sense.clear () h = sense.get_humidity () h = round (h, 1) message = "H:" + str (h) sense.show_message (meddelelse, tekst_farve = grøn, scroll_speed = 0,09) p = sense.get_pressure () p = rund (p, 1) besked = "P:" + str (p) sense.show_message (besked, tekst_farve = gul, scroll_speed = 0,09)

# elif event.direction == "venstre":

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

#Opdater displayets rotation afhængigt af hvilken vej op ad // Ikke brugt og styret af knude -rødt #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") # Venstre pil # elif event.direction == "højre": # sense.show_letter ("K") # Højre pil # elif event.direction == "midten": # sense.clear ()

indvirkning()

data = get_sense_data ()

dt = data [-1] - tidsstempel, hvis dt.sekunder> forsinkelse: data_writer.writerow (data) timestamp = datetime.now ()

Trin 18: Overvågning af livevideo

Impact Recorder kan også bruges til at overvåge live video, da video kan startes når som helst og hvor som helst via MQTT

vi ville bruge VLC-afspiller til at streame videoer, som standard i seneste raspbian er VLC forudinstalleret, ellers installer vlc som under

Flere oplysninger om visning af netværksstrøm kan tilgås via VLC -netværksstrøm

Tak fordi du læste!!

Der er meget mere effektoptageren kan gøre..

Pas på næste rum for magnetfeltanalyse ved udførelse af forhindringskortlægning