Recorder de impact pentru vehicule: 18 pași (cu imagini)

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:44

Impact Recorder este proiectat pentru a înregistra impactul suportat de vehicul în timp ce conduceți sau staționează. Impacturile sunt stocate în baza de date sub formă de citiri, precum și video / imagine. La impact, utilizatorul la distanță poate fi verificat în timp real, iar utilizatorul la distanță poate să vizioneze videoclipul salvat sau să aibă acces la distanță la camera pi și să urmărească evenimentele în consecință..

Pasul 1: Piese și accesorii

(1) Raspberry Pi 3 sau mai bine: este necesară puterea de calcul

(2) Raspberry pi sense hat

(3) Cameră Raspberry pi / Cameră USB

(4) Card de memorie cu cea mai recentă imagine raspbian (ar trebui să accepte nod roșu, aproape fiecare imagine recentă o face)

(5) Alimentare cu energie electrică de cel puțin 2,1 A (am folosit bateria pentru funcționarea autonomă în mașină)

Pasul 2: Descrierea pieselor: Sense Hat

Sense HAT are o matrice LED 8 × 8 RGB, un joystick cu cinci butoane și include următorii senzori:

• Giroscop
• Accelerometru
• Magnetometru
• Temperatura
• Barometric
• presiune
• Umiditate

Mai multe informații despre lucrul cu hat hat pot fi obținute din următoarele link-uri: Sense_Hat

API-urile pentru hat hat sunt găzduite la: Sense_hat_API

Codul pentru programarea senzorului este acoperit în pașii ulteriori. Codul Sense Hat poate fi simulat și pe un simulator găzduit la: Sense-hat simulator

Pasul 3: Asamblare: Recorder de impact

• Asamblarea este mai simplă, deoarece pălăria trebuie să fie suprapusă peste pi (șuruburile de montare desemnate sunt prevăzute cu pălărie).
• Camera USB sau camera pi pot fi conectate. În tutorial, se ia în considerare camera pi și, în consecință, se efectuează codificarea pentru aceeași.
• Introduceți cardul de memorie și configurați codul python și nodul -red (configurația și codul sunt acoperite în pași suplimentari)

Imaginea de mai sus arată camera pi conectată prin cablu plat cu bandă la pi

Pasul 4: Asamblare: Recorder de impact pe tabloul de bord al mașinii

Pentru montarea reportofonului, am folosit bandă dublă, avantajul este că reportofonul poate fi ușor deplasat în diferite poziții, oricare dintre acestea se potrivește cel mai bine mașinii dvs.

Camera suplimentară este montată vertical așa cum se arată, folosind aceeași bandă dublă laterală, Următorul rând este să conectați o sursă de alimentare (10.000 mAH power bank) împreună cu o conexiune la internet pregătită

Conexiunea la internet este necesară pentru aplicația MQTT (detaliile pentru MQTT sunt acoperite în pași suplimentari)

Pasul 5: Impact Recoder: lucru și aplicații

Din pălăria de sens, accelerația și giroscopul sunt utilizate pentru a verifica dacă valorile brute depășesc limita stabilită în cod.

Accelerometru: Accelerometrul indică cantitatea de forță gravitațională (forța G) care acționează pe fiecare dintre axele x, y și z, dacă o axă măsoară o forță mai mare de 1G, se poate detecta o mișcare rapidă. (Vă rugăm să rețineți că axa îndreptată în jos ar avea o valoare de 1g și trebuie luată în considerare în consecință în codul python).

Giroscop; Giroscopul este folosit pentru a măsura mișcarea unghiulară, adică în timpul virajului brusc, senzorul ar putea fi activat (depinde de setarea din cod), astfel încât o persoană care învârte brusc vehiculul ar fi prinsă !!

Orice activare a limitei setate este, de asemenea, afișată pe matricea LED a pălăriei de sens ca "!" în roșu pentru accelerare și verde pentru activarea giroscopului

Pasul 6: Descrierea software-ului: Node Red

Node-RED este un instrument de programare bazat pe flux, dezvoltat inițial de Emerging Technology Servicesteam de la IBM și acum face parte din JS Foundation.

Mai multe informații despre nodul roșu pot fi obținute prin următorul link: nod-roșu

Pentru cazul nostru, vom folosi nod-roșu pentru următoarele activități

(1) Interacțiunea cu joystick-urile pentru a porni funcțiile camerei

(2) Monitorizarea impactului asupra vehiculului și transmiterea informațiilor către utilizatorul final prin utilizarea MQTT și acceptarea în continuare a comenzilor utilizatorului final prin MQTT și lansarea aplicației necesare pe pi

(3) Efectuarea unor elemente de bază, cum ar fi închiderea pi

Următorii pași oferă informații detaliate pentru diagrama de flux implementată pe roșu nod

Vă rugăm să rețineți că diagramele de flux roșu nod interacționează cu codul python, prin urmare, ultima parte acoperă aspectele codului python

Pasul 7: Noțiuni de bază roșu-nod

Anumiți pași de bază sunt evidențiați pentru a începe roșu nod într-o clipită, dar da roșu nod este prea simplu pentru a începe și rezolva aplicații.

• Nod de pornire-roșu: https:// localhost: 1880.
• Pornind Node-red când pi este conectat la internet https:// adresa IP>: 1880

Pasul 8: roșu nod: Flux _1a

Fluxul _1a, monitorizează orice modificări în fișierul CSV și pe baza modificărilor, adică impactul detectat, înregistrarea video a camerei este setată pe modul activ și, în plus, utilizatorul este informat pe internet că a avut loc un impact

Pasul 9: Nod roșu: Flux_1b

În fluxul menționat, înregistrarea video poate fi pornită în orice punct prin simpla apăsare a joystick-ului

Pasul 10: nod roșu: Flux_2a

În fluxul menționat, ori de câte ori o imagine sau un videoclip nou este stocat / încărcat în director, informațiile sunt transmise utilizatorului înregistrat prin internet

Pasul 11: Nod roșu: Flux_2b

Acest flux este conceput în primul rând pentru utilizatorul la distanță, astfel încât să controleze dispozitivul în modul următor

(a) dispozitiv de oprire

(b) faceți fotografii

(c) Înregistrați videoclipuri

(d) pornește codul principal (codul datalogger este codul principal care calculează impactul)

Pasul 12: nod roșu; Flux_3

Fluxul este conceput pentru acces local, astfel încât să pornească codul principal sau dispozitivul de oprire

Pasul 13: MQTT

MQTT (Message Queuing Telemetry Transport) este un protocol TCP / IP, în care editorul și abonatul interacționează.

În cazul nostru Pi este editor, în timp ce aplicația instalată în mobilul / computerul nostru va fi abonat.

În acest fel, la generarea oricărui impact, informațiile sunt transmise de la distanță către utilizator (este necesară o conexiune la internet funcțională)

Mai multe informații despre MQTT pot fi accesate de pe următorul link: MQTT

Pentru a începe să utilizați MQTT, trebuie să ne înregistrăm mai întâi, pentru tutorialul pe care l-am folosit cloudmqtt (www.cloudmqtt.com), există un plan gratuit sub „pisică drăguță”, atâta tot.

După înregistrare, creați o instanță, spuneți „pi”, după care veți primi următoarele detalii

• Numele serverului
• port
• nume de utilizator
• parola

Cele de mai sus sunt necesare în timp ce vă abonați prin mobil / PC

Pentru aplicația mea, am folosit aplicația MQTT din magazinul Google Play (versiunea Android)

Pasul 14: MQTT: Abonat

Aplicația MQTT care rulează pe mobil (versiunea Android)

Impactul detectat pe pi este reluat înapoi

Pasul 15: MQTT: Editarea proprietăților în roșu nod

În roșu nod după selectarea nodului MQTT, trebuie menționate „Numele serverului” și „subiectul”. Acest lucru ar trebui să fie același la sfârșitul abonatului

Pasul 16: Codul Python:

Funcționalitatea codului este conform diagramei atașate

Pasul 17: Codul final

Codul python este atașat

Pentru a face scriptul nostru Python să ruleze de la terminal, trebuie să le facem executabile ca chmod + x datalogger.py, decât în partea de sus a codului ar trebui să conțină următoarea linie "shebang" #! / usr / bin / python3 (acest lucru este necesar pentru a executa funcții de la roșu la nod)

#! / usr / bin / python3 // shebang linede la sense_hat import SenseHat din datetime import datetime din csv import writer import RPi. GPIO ca GPIO din timp import somn

sense = SenseHat ()

import csv

timestamp = datetime.now ()

delay = 5 // delay este definit pentru a stoca date în fișierul data.csv roșu = (255, 0, 0) verde = (0, 255, 0) galben = (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"])

returnează sens_impact

def impact (): // funcție pentru detectarea impactului # GPIO.setmode (GPIO. BCM) # GPIO.setup (4, GPIO. OUT) acceleration = sense.get_accelerometer_raw () x = acceleration ['x'] y = acceleration ['y'] z = accelerare ['z'] x = abs (x) y = abs (y) z = abs (z)

gyro = sense.get_gyroscope_raw ()

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

giroscop = rotund (giroscop, 2)

gyroy = rotund (gyroy, 2) gyroz = rotund (gyroz, 2)

impact = get_sense_impact ()

dacă x> 1,5 sau y> 1,5 sau z> 1,5: // valorile sunt stabilite după iterație pe drumul real pot fi modificate în consecință pentru diferite tipuri și abilități de conducere cu deschis („impact.csv”, „w”, newline = „ ') ca f: data_writer = writer (f) data_writer.writerow ([' acc x ',' acc y ',' acc z ',' gyro x ',' gyro y ',' gyro z ']) #GPIO. ieșire (4, GPIO. HIGH) sense.clear () sense.show_letter ("!", roșu) data_writer.writerow (impact)

elif gyrox> 1,5 sau gyroy> 1,5 sau gyroz> 1,5: // valorile sunt setate privind viteza la care se inițiază ture cu open („impact.csv”, „w”, newline =””) ca 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 ("!", Verde) data_writer.writerow (impact)

altceva:

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

def get_sense_data (): // funcție pentru a înregistra și stoca valori de la senzor 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 ["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"])

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

returnează date_sensibil

cu open ('data.csv', 'w', newline = '') ca f:

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

în timp ce este adevărat:

print (get_sense_data ()) pentru eveniment în sense.stick.get_events (): # Verificați dacă joystick-ul a fost apăsat dacă event.action == "apăsat": # Verificați ce direcție dacă event.direction == "sus": # sense.show_letter ("U") # Săgeată sus accelerare = sense.get_accelerometer_raw () x = accelerare ['x'] y = accelerare ['y'] z = accelerare ['z'] x = rotund (x, 0) y = rotund (y, 0) z = rotund (z, 0)

# Actualizați rotația afișajului în funcție de ce direcție sus dacă 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 = red, scroll_speed = 0.09) elif event.direction == "down": acceleration = sense.get_accelerometer_raw () x = acceleration ['x'] y = acceleration ['y'] z = acceleration ['z'] x = round (x, 0) y = rotund (y, 0) z = rotund (z, 0)

# Actualizați rotația afișajului în funcție de ce direcție sus dacă 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") # Săgeată în jos sense.clear () h = sense.get_humidity () h = round (h, 1) message = "H:" + str (h) sense.show_message (mesaj, text_colour = verde, scroll_speed = 0.09) p = sense.get_pressure () p = round (p, 1) message = "P:" + str (p) sense.show_message (message, text_colour = galben, scroll_speed = 0,09)

# elif event.direction == "left":

# accelerare = sense.get_accelerometer_raw () # x = accelerare ['x'] #y = accelerare ['y'] #z = accelerare ['z'] # x = rotund (x, 0) # y = rotund (y, 0) # z = rotund (z, 0)

# Actualizați rotația afișajului în funcție de ce direcție sus // Neutilizat și controlat de nod-roșu #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") # Săgeată la stânga # elif event.direction == "dreapta": # sense.show_letter ("K") # Săgeată dreapta # elif event.direction == "mijloc": # sense.clear ()

impact ()

data = get_sense_data ()

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

Pasul 18: Monitorizarea videoclipurilor live

Impact Recorder poate fi, de asemenea, utilizat pentru a monitoriza video live, deoarece videoclipul poate fi pornit oricând oriunde prin MQTT

am folosi VLC player pentru a transmite videoclipuri, în mod implicit în cel mai recent raspbian, VLC este preinstalat, altfel instalați vlc ca în

Mai multe informații despre vizualizarea fluxului de rețea pot fi accesate prin fluxul de rețea VLC

Mulțumesc că ai citit !!

Înregistratorul de impact poate face mult mai mult..

Aveți grijă la spațiul următor pentru analiza câmpului magnetic în efectuarea cartografierii obstacolelor