Impact Recorder för fordon: 18 steg (med bilder)

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:44

Impact Recorder är utformad för att registrera påverkan på fordonet under körning eller stillastående. Effekterna lagras i databasen i form av avläsningar såväl som video/bild. Fjärranvändare vid påverkan kan verifieras i realtid, och fjärranvändare kan än titta på den sparade videon eller ta fjärråtkomst till pi -kamera och titta på händelser i enlighet därmed.

Steg 1: Delar och tillbehör

(1) Raspberry Pi 3 eller bättre: Beräkningseffekt krävs

(2) Hallon pi sense hatt

(3) hallon pi -kamera / usb -kamera

(4) Minneskort med senaste raspbian -bilden (Bör stödja nodröd, nästan alla senaste bilder gör det)

(5) Strömförsörjning minst 2,1 A (jag har använt batteribank för fristående drift i bil)

Steg 2: Delar Beskrivning: Sense Hat

Sense HAT har en 8 × 8 RGB LED-matris, en femknapps joystick och innehåller följande sensorer:

• Gyroskop
• Accelerometer
• Magnetometer
• Temperatur
• Barometrisk
• tryck
• Fuktighet

Mer information om hur man arbetar med sense hat kan härledas från följande länkar: Sense_Hat

API för sense hat finns på: Sense_hat_API

Kod för sense-hat-programmering omfattas i senare steg. Sense hattkod kan också simuleras på en simulator som är värd på: Sense-hat simulator

Steg 3: Montering: Impact Recorder

• Montering är enklare eftersom sense hat måste staplas över pi (utsedda monteringsbultar är försedda med sense hat).
• USB -kamera eller pi -kamera kan anslutas. I handledningen övervägs pi -kamera och kodning utförs därför för samma.
• Sätt i minneskortet och konfigurera python -kod och nod -rött (konfiguration och kod omfattas av ytterligare steg)

Bilden ovan visar pi-kamera ansluten via plattbandskabel till pi

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

För montering av inspelaren har jag använt dubbelsidig tejp, fördelen är att inspelaren enkelt kan flyttas i olika positioner, vilket som passar bäst för din bil.

Ytterligare kamera monteras vertikalt enligt bilden med samma dubbeltejp, Nästa på raden är att ansluta en strömkälla (10 000 mAH powerbank) tillsammans med en klar internetanslutning

Internetanslutning krävs för MQTT -applikationer (detaljerna för MQTT behandlas i ytterligare steg)

Steg 5: Impact Recoder: Working & Applications

Från sense -hatten används acceleration och gyroskop för att kontrollera om råvärdena överskrider inställd gräns i koden.

Accelerometer: Accelerometern anger mängden gravitationskraft (G-kraft) som verkar på var och en av x-, y & z-axlarna, om någon axel mäter mer än 1G kraft, kan snabb rörelse detekteras. (observera att axeln som pekar nedåt skulle ha 1g värde och måste beaktas i enlighet med pythonkoden).

Gyroskop; Gyroskopet används för att mäta vinkelrörelser, dvs vid skarp svängning kan sensorn aktiveras (beror på inställningen i koden), så att en person som snurrar runt fordonet skulle fastna !!

Varje aktivering av inställd gräns visas också på sense hat LED -matrisen som "!" i rött för acceleration och grönt för aktivering av gyroskop

Steg 6: Programvarubeskrivning: Node Red

Node-RED är ett flödesbaserat programmeringsverktyg, ursprungligen utvecklat av IBMs Emerging Technology Servicesteam och nu en del av JS Foundation.

Mer information om nodröd kan erhållas via följande länk: node-red

För vårt fall skulle vi använda nod -rött för följande aktiviteter

(1) Interagerar med joystickarna för att starta kamerafunktioner

(2) Övervakning av påverkan på fordon och vidarebefordran av information till slutanvändare genom att använda MQTT och vidare acceptera slutanvändarkommandon via MQTT och starta nödvändig applikation på pi

(3) Utföra några grundläggande saker som avstängning av pi

De ytterligare stegen ger detaljerad information för flödesschemat implementerat på nod-rött

Observera att de nodröda flödesscheman interagerar med pythonkoden, varför den senare delen täcker aspekterna av pythonkoden

Steg 7: Noderöda grunder

Vissa grundläggande steg markeras för att börja Node-röd på ett ögonblick, men ja nod-rött är för enkelt för att börja och träna applikationer.

• Startar Node-red: https:// localhost: 1880.
• Startar Node-red när pi är ansluten till internet https:// ip-adress>: 1880

Steg 8: Nod-röd: Flöde _1a

Flödet _1a, övervakar eventuella ändringar i CSV -filen och på grundval av ändringarna, dvs påverkan detekterad, kameravideoinspelning är inställd på på -läge och vidare informeras användaren via internet om att en påverkan har inträffat

Steg 9: Röd nod: Flow_1b

I nämnda flöde kan videoinspelning startas när som helst genom att bara trycka på joysticken

Steg 10: Röd nod: Flow_2a

I det nämnda flödet, när någon ny bild eller video lagras/laddas upp till katalogen, vidarebefordras informationen till den registrerade användaren via internet

Steg 11: Röd nod: Flow_2b

Detta flöde är primärt utformat för fjärranvändaren för att styra enheten på följande sätt

(a) avstängningsenhet

(b) ta bilder

(c) Spela in videor

(d) starta huvudkoden (dataloggerkoden är huvudkoden som beräknar effekten)

Steg 12: Röd nod; Flöde_3

Flödet är utformat för lokal åtkomst för att starta huvudkoden eller avstängningsenheten

Steg 13: MQTT

MQTT (Message Queuing Telemetry Transport) är ett TCP/IP -protokoll, där utgivare och abonnent interagerar.

I vårt fall är Pi utgivare, medan applikationen som är installerad i vår moblile/PC ska vara abonnenten.

På detta sätt vid generering av eventuell påverkan vidarebefordras information på distans till användaren (en fungerande internetanslutning är ett måste)

Mer information om MQTT kan nås från följande länk: MQTT

För att börja använda MQTT måste vi registrera oss först, för självstudien har jag använt cloudmqtt (www.cloudmqtt.com), det finns en gratis plan under "söt katt", det är allt.

Efter registrering skapa en instans säga "pi" varefter du skulle få följande detaljer

• Server namn
• hamn
• Användarnamn
• Lösenord

Ovanstående krävs vid prenumeration via mobil/dator

För min applikation har jag använt MQTT -applikation från Google Play Store (Android -version)

Steg 14: MQTT: Prenumerant

MQTT -applikationen som körs på mobilen (Android -version)

Påverkan som upptäcks på pi vidarebefordras

Steg 15: MQTT: Redigera egenskaper i nodrött

I nodrött efter att ha valt MQTT-nod, "Servernamn" och "ämne" som ska nämnas. Detta bör vara detsamma i prenumerantänden

Steg 16: Pythonkoden:

Kodfunktionen är enligt bifogat flödesschema

Steg 17: Den slutliga koden

Pythonkoden är bifogad

För att få vårt python -skript att köra från terminal måste vi göra dem körbara som chmod +x datalogger.py, än att toppen av koden bör innehålla följande "shebang" -rad #! /usr/bin/python3 (detta krävs för att köra funktioner från nod-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 ()

importera csv

tidsstämpel = datetime.now ()

fördröjning = 5 // fördröjning definieras för att lagra data i data.csv -filen 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"])

returnera sense_impact

def impact (): // funktion för att upptäcka påverkan #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 ()

om x> 1.5 eller y> 1.5 eller z> 1.5: // värdena ställs in efter att iteration på den faktiska vägen kan ändras i enlighet därmed för olika typer och körförmåga med öppen ('impact.csv', 'w', newline = ' ') som 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 ("!", röd) data_writer.writerow (impact)

elif gyrox> 1.5 eller gyroy> 1.5 eller gyroz> 1.5: // värdena ställs in och tittar på hastigheten vid vilken varv initieras med open ('impact.csv', 'w', newline = '') som f: data_writer = writer (f) data_writer.writerow (['acc x', 'acc y', 'acc z', 'gyro x', 'gyro y', 'gyro z']) #GPIO.output (4, GPIO. HÖG) sense.clear () sense.show_letter ("!", Grön) data_writer.writerow (impact)

annan:

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

def get_sense_data (): // funktion för att spela in och lagra värden från 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 (orientation ["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 ())

returnera sense_data

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

data_writer = författare (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 '])

medan det är sant:

print (get_sense_data ()) för händelse i sense.stick.get_events (): # Kontrollera om joysticken var nedtryckt om event.action == "tryckt": # Kontrollera vilken riktning om event.direction == "upp": # sense.show_letter ("U") # Pil upp 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)

# Uppdatera displayens rotation beroende på vilken väg upp till 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) meddelande = "T:" + str (t) sense.show_message (meddelande, text_colour = röd, scroll_speed = 0.09) elif event.direction == "down": 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)

# Uppdatera displayens rotation beroende på vilken väg upp 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") # nedåtpil sense.clear () h = sense.get_humidity () h = round (h, 1) meddelande = "H:" + str (h) sense.show_message (meddelande, text_färg = grönt, scroll_speed = 0,09) p = sense.get_pressure () p = rund (p, 1) meddelande = "P:" + str (p) sense.show_message (meddelande, text_färg = gul, scroll_speed = 0,09)

# elif event.direction == "vänster":

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

#Uppdatera displayens rotation beroende på vilken väg uppåt // Används inte och styrs av nodröd #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") # Vänsterpil # elif event.direction == "höger": # sense.show_letter ("K") # Högerpil # elif event.direction == "mitten": # sense.clear ()

påverkan()

data = get_sense_data ()

dt = data [-1] - tidsstämpel om dt.sekunder> fördröjning: data_writer.writerow (data) timestamp = datetime.now ()

Steg 18: Övervakning av livevideo

Impact Recorder kan också användas för att övervaka livevideo, eftersom video kan startas när som helst var som helst via MQTT

vi skulle använda VLC-spelare för att strömma videor, som standard i senaste raspbian är VLC förinstallerad, annars installera vlc som under

Mer information om visning av nätverksström kan nås via VLC Network stream

Tack för att du läste!!

Det finns mycket mer som effektregistratorn kan göra..

Se upp nästa utrymme för magnetfältanalys vid utförande av hinderkartläggning