Impact Recorder for Vehicles: 18 Steps (med bilder)

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:23

Impact Recorder er designet for å registrere påvirkning påført kjøretøyet mens du kjører eller står stille. Virkningene lagres i databasen i form av avlesninger, så vel som video/bilde. Ekstern bruker kan bli verifisert i sanntid, og ekstern bruker kan enn se den lagrede videoen eller ta ekstern tilgang til pi -kamera og se hendelser deretter.

Trinn 1: Deler og tilbehør

(1) Raspberry Pi 3 eller bedre: Beregningskraft kreves

(2) Raspberry pi sense hat

(3) Bringebær pi kamera / Usb kamera

(4) Minnekort med det siste raspbian -bildet (Bør støtte node rød, nesten alle siste bilder gjør det)

(5) Strømforsyning minst 2,1 A (jeg har brukt batteribank for frittstående drift i bil)

Trinn 2: Delbeskrivelse: Sense Hat

Sense HAT har en 8 × 8 RGB LED-matrise, en femknapps joystick og inkluderer følgende sensorer:

• Gyroskop
• Akselerometer
• Magnetometer
• Temperatur
• Barometrisk
• press
• Luftfuktighet

Mer informasjon om å jobbe med sense hat kan hentes fra følgende lenker: Sense_Hat

API for sense hat er hostet på: Sense_hat_API

Kode for sense-hat-programmering dekkes i senere trinn. Sense hat-kode kan også simuleres på en simulator som er hostet på: Sense-hat simulator

Trinn 3: Montering: Impact Recorder

• Montering er enklere ettersom sense hat må stables over pi (angitte monteringsbolter er utstyrt med sense hat).
• USB -kamera eller pi -kamera kan kobles til. I opplæringen vurderes pi -kameraet, og derfor utføres koding for det samme.
• Sett inn minnekortet og konfigurer python -kode og node -red (konfigurasjon og kode dekkes i ytterligere trinn)

Bildet ovenfor viser pi-kamera koblet gjennom flatbåndkabel til pi

Trinn 4: Montering: Impact Recorder på Dash Board of Car

For montering av opptakeren har jeg brukt dobbeltsidig tape, fordelen er at opptakeren enkelt kan flyttes i forskjellige posisjoner, alt etter hva som passer best for bilen din.

Ytterligere kamera er montert vertikalt som vist, med samme dobbeltsidige tape, Neste på rekken er å koble til en strømkilde (10 000 mAH kraftbank) sammen med en klar internettforbindelse

Internett -tilkobling må være nødvendig for MQTT -applikasjoner (detaljene for MQTT dekkes i ytterligere trinn)

Trinn 5: Impact Recoder: Working & Applications

Fra sansehatten brukes akselerasjon og gyroskop for å kontrollere om råverdiene er utenfor den angitte grensen i koden.

Akselerometer: Akselerometeret forteller mengden gravitasjonskraft (G-kraft) som virker på hver av x-, y & z-aksene, hvis en akse måler mer enn 1G kraft, enn det kan oppdages rask bevegelse. (vær oppmerksom på at aksen som peker nedover vil ha 1g verdi og må vurderes tilsvarende i python -koden).

Gyroskop; Gyroskopet brukes til å måle vinkelbevegelse, dvs. under skarp sving kan sensoren bli aktivert (avhenger av innstillingen i koden), slik at en person som hvirvler kraftig i kjøretøyet vil bli fanget !!

Enhver aktivering av angitt grense vises også på sense hat LED -matrisen som "!" i rødt for akselerasjon og grønt for gyroskopaktivering

Trinn 6: Programvarebeskrivelse: Node Red

Node-RED er et flytbasert programmeringsverktøy, opprinnelig utviklet av IBMs Emerging Technology Servicesteam og nå en del av JS Foundation.

Mer informasjon om node rød kan fås via følgende lenke: node-red

For vårt tilfelle bruker vi node -red for følgende aktiviteter

(1) Samhandling med styrespakene for å starte kamerafunksjoner

(2) Overvåke påvirkningene på kjøretøyet og videreformidle informasjonen til sluttbrukeren ved å bruke MQTT og ytterligere godta sluttbrukerkommandoene gjennom MQTT og starte den nødvendige applikasjonen på pi

(3) Utføre noen grunnleggende ting som nedleggelse av pi

De videre trinnene gir detaljert informasjon for flytskjemaet implementert på node-red

Vær oppmerksom på at node-røde flytdiagrammer samhandler med python-koden, derfor dekker den siste delen aspektene av python-koden

Trinn 7: Noderødt grunnleggende

Enkelte grunnleggende trinn er uthevet for å begynne Node-rødt på et blunk, men ja node-rødt er for enkelt til å begynne og trene programmer.

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

Trinn 8: Node-rød: Flow _1a

Flow _1a, overvåker eventuelle endringer i CSV -filen og på grunnlag av endringene, det vil si påvirkning oppdaget, kameraopptak er satt til på -modus og videre blir brukeren informert over internett om at det har skjedd en påvirkning

Trinn 9: Node Red: Flow_1b

I den nevnte strømmen kan videoopptak startes når som helst ved bare å trykke på styrespaken

Trinn 10: Node rød: Flow_2a

I den nevnte strømmen, når et nytt bilde eller en video lagres/lastes opp til katalogen, blir informasjonen videresendt til den registrerte brukeren over internett

Trinn 11: Node rød: Flow_2b

Denne strømmen er hovedsakelig designet for den eksterne brukeren, for å kontrollere enheten på følgende måte

(a) avstengingsenhet

(b) ta bilder

(c) Ta opp videoer

(d) start hovedkoden (datalogger -koden er hovedkoden som beregner virkningen)

Trinn 12: Node Red; Flow_3

Flyten er designet for lokal tilgang, for å starte hovedkoden eller avstengingsenheten

Trinn 13: MQTT

MQTT (Message Queuing Telemetry Transport) er en TCP/IP -protokoll, der utgiver og abonnent samhandler.

I vårt tilfelle er Pi utgiver, mens applikasjonen som er installert i vår mobil/PC skal være abonnenten.

På denne måten ved generering av enhver innvirkning, blir informasjon sendt videre til brukeren (en fungerende internettforbindelse er nødvendig)

Mer informasjon om MQTT kan nås fra følgende lenke: MQTT

For å begynne å bruke MQTT, må vi først registrere oss, for opplæringen jeg har brukt cloudmqtt (www.cloudmqtt.com), er det en gratis plan under "søt katt", det er alt.

Etter registrering, opprett en forekomst, si "pi", og deretter vil du få følgende detaljer

• Server navn
• havn
• brukernavn
• passord

Ovenstående er påkrevd når du abonnerer via mobil/pc

For søknaden min har jeg brukt MQTT -applikasjon fra Google Play Store (Android -versjon)

Trinn 14: MQTT: Abonnent

MQTT -applikasjonen kjører på mobil (Android -versjon)

Virkningen som oppdages på pi videresendes

Trinn 15: MQTT: Redigering av egenskaper i Node-rød

I noderød etter å ha valgt MQTT-noden, skal "Servernavn" og "emne" nevnes. Dette bør være det samme på abonnentenden

Trinn 16: Python -koden:

Kodefunksjonaliteten er som vedlagt flytskjema

Trinn 17: Den endelige koden

Python -koden er vedlagt

For å få vårt python -skript til å kjøre fra terminal, må vi gjøre dem kjørbare som chmod +x datalogger.py, enn videre bør toppen av koden inneholde følgende "shebang" linje #! /usr/bin/python3 (dette er nødvendig for å utføre funksjoner fra node-red)

#!/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 definert for å lagre data i data.csv -filen rød = (255, 0, 0) grønn = (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 (): // funksjon for å oppdage påvirkning #GPIO.setmode (GPIO. BCM) #GPIO.setup (4, GPIO. OUT) akselerasjon = sense.get_accelerometer_raw () x = akselerasjon ['x'] y = akselerasjon ['y'] z = akselerasjon ['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: // er verdiene satt etter at iterasjon på den faktiske veien kan endres tilsvarende for forskjellige typer og kjøreferdigheter med åpen ('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 (innvirkning)

elif gyrox> 1.5 eller gyroy> 1.5 eller gyroz> 1.5: // verdiene settes for å se på hastigheten som svinger initieres med åpen ('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ØY) sense.clear () sense.show_letter ("!", Grønn) data_writer.writerow (innvirkning)

ellers:

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

def get_sense_data (): // funksjon for å registrere og lagre verdier 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 åpen ('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 sant:

print (get_sense_data ()) for hendelse i sense.stick.get_events (): # Sjekk om joysticken ble trykket hvis event.action == "presset": # Sjekk hvilken retning hvis event.direction == "opp": # sense.show_letter ("U") # Pil opp akselerasjon = sense.get_accelerometer_raw () x = akselerasjon ['x'] y = akselerasjon ['y'] z = akselerasjon ['z'] x = runde (x, 0) y = runde (y, 0) z = rund (z, 0)

# Oppdater rotasjonen på displayet avhengig av hvilken vei opp hvis x == -1: sense.set_rotation (90) elif y == 1: sense.set_rotation (270) elif y == -1: sense.set_rotation (180) annet: sense.set_rotation (0) sense.clear () t = sense.get_temperature () t = round (t, 1) melding = "T:" + str (t) sense.show_message (melding, tekst_farge = rød, scroll_speed = 0.09) elif event.direction == "ned": akselerasjon = sense.get_accelerometer_raw () x = akselerasjon ['x'] y = akselerasjon ['y'] z = akselerasjon ['z'] x = rund (x, 0) y = rund (y, 0) z = rund (z, 0)

# Oppdater rotasjonen på displayet avhengig av hvilken vei opp til hvis x == -1: sense.set_rotation (90) elif y == 1: sense.set_rotation (270) elif y == -1: sense.set_rotation (180) annet: sense.set_rotation (0) # sense.show_letter ("D") # pil ned sense.clear () h = sense.get_humidity () h = round (h, 1) melding = "H:" + str (h) sense.show_message (melding, tekst_farge = grønn, scroll_speed = 0,09) p = sense.get_pressure () p = rund (p, 1) melding = "P:" + str (p) sense.show_message (melding, tekst_farge = gul, scroll_speed = 0,09)

# elif event.direction == "venstre":

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

#Oppdater rotasjonen på displayet avhengig av hvilken vei opp // Ikke brukt og kontrollert av node -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øyre": # sense.show_letter ("K") # Høyrepil # elif event.direction == "midten": # sense.clear ()

innvirkning()

data = get_sense_data ()

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

Trinn 18: Overvåking av levende video

Impact Recorder kan også brukes til å overvåke live video, ettersom video kan startes når som helst og hvor som helst via MQTT

vi ville bruke VLC-spiller til å streame videoer, som standard i siste raspbian er VLC forhåndsinstallert, ellers installer vlc som under

Mer informasjon om visning av nettverksstrøm kan nås via VLC Network stream

Takk for at du leser!!

Det er mye mer effektopptakeren kan gjøre..

Se opp neste plass for magnetfeltanalyse når du utfører hinderkartlegging