Rejestrator uderzeń dla pojazdów: 18 kroków (ze zdjęciami)

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:30

Impact Recorder jest przeznaczony do rejestrowania uderzeń pojazdu podczas jazdy lub postoju. Uderzenia są przechowywane w bazie danych w postaci odczytów, a także wideo/zdjęć. Po uderzeniu zdalny użytkownik może zostać zweryfikowany w czasie rzeczywistym, a zdalny użytkownik może obejrzeć zapisane wideo lub uzyskać zdalny dostęp do kamery pi i odpowiednio obejrzeć wydarzenia.

Krok 1: Części i akcesoria

(1) Raspberry Pi 3 lub lepszy: wymagana moc obliczeniowa

(2) Kapelusz Raspberry pi;

(3) kamera Raspberry pi/kamera USB

(4) Karta pamięci z najnowszym obrazem raspbian (powinna obsługiwać czerwony węzeł, prawie każdy najnowszy obraz tak)

(5) Zasilanie co najmniej 2,1 A (używałem baterii akumulatorów do samodzielnej pracy w samochodzie)

Krok 2: Opis części: Sense Hat

Sense HAT ma matrycę LED 8×8 RGB, pięcioprzyciskowy joystick i zawiera następujące czujniki:

• Żyroskop
• Akcelerometr
• Magnetometr
• Temperatura
• Barometryczny
• nacisk
• Wilgotność

Więcej informacji na temat pracy z czapką sensowną można znaleźć pod następującymi linkami: Sense_Hat

API dla kapelusza sensu jest hostowane pod adresem: Sense_hat_API

Kod do programowania kapelusza sensu omówiono w dalszych krokach. Sense Hat Code może być również symulowany na symulatorze hostowanym pod adresem: Sense-hat Simulator

Krok 3: Montaż: Rejestrator uderzeń

• Montaż jest prostszy, ponieważ kapelusz sensu musi być ułożony w stos nad pi (wyznaczone śruby mocujące są dostarczane z kapeluszem sensu).
• Można podłączyć kamerę USB lub kamerę pi. W samouczku brana jest pod uwagę kamera pi i odpowiednio dla niej przeprowadzane jest kodowanie.
• Włóż kartę pamięci i skonfiguruj kod Pythona oraz node -red (konfiguracja i kod są opisane w dalszych krokach)

Zdjęcie powyżej pokazuje pi-kamerę podłączoną przez płaski kabel taśmowy do pi

Krok 4: Montaż: Rejestrator uderzeń na desce rozdzielczej samochodu

Do montażu rejestratora użyłem taśmy dwustronnej, zaletą jest to, że rejestrator można łatwo przestawić w inne położenie, w zależności od tego, która najbardziej odpowiada Twojemu samochodowi.

Dalsza kamera jest montowana pionowo, jak pokazano, za pomocą tej samej taśmy dwustronnej, W następnej kolejności należy podłączyć źródło zasilania (10 000 mAh power bank) wraz z gotowym łączem internetowym

Do aplikacji MQTT wymagane jest połączenie z Internetem (szczegóły dotyczące MQTT są opisane w dalszych krokach)

Krok 5: Impact Recoder: działanie i aplikacje

Na podstawie czujnika, przyspieszenie i żyroskop są używane do sprawdzania, czy wartości surowe wykraczają poza limit ustawiony w kodzie.

Akcelerometr: Akcelerometr informuje o wielkości siły grawitacyjnej (siła G) działającej na każdą z osi x, y i z, jeśli jakakolwiek oś mierzy siłę większą niż 1G, można wykryć szybki ruch. (należy zwrócić uwagę, że oś skierowana w dół miałaby wartość 1g i należy ją odpowiednio uwzględnić w kodzie Pythona).

żyroskop; Żyroskop służy do pomiaru ruchu kątowego, tzn. przy ostrym skręcie czujnik może się aktywować (w zależności od ustawienia w kodzie), przez co osoba ostro kręcąca się pojazdem zostanie złapana!!

Każda aktywacja ustawionego limitu jest również wyświetlana na matrycy LED kapelusza czujnika jako „!” w kolorze czerwonym dla przyspieszenia i zielonym dla aktywacji żyroskopu

Krok 6: Opis oprogramowania: czerwony węzeł

Node-RED to narzędzie programistyczne oparte na przepływach, pierwotnie opracowane przez zespół IBM Emerging Technology Servicesteam, a obecnie będące częścią JS Foundation.

Więcej informacji na temat węzła czerwonego można uzyskać, klikając link:node-red

W naszym przypadku używalibyśmy węzła -red do wykonywania czynności

(1) Interakcja z joystickami w celu uruchomienia funkcji aparatu

(2) Monitorowanie wpływu na pojazd i przekazywanie informacji użytkownikowi końcowemu za pomocą MQTT i dalsze akceptowanie poleceń użytkownika końcowego za pośrednictwem MQTT i uruchamianie wymaganej aplikacji na pi

(3) Wykonywanie podstawowych rzeczy, takich jak wyłączenie pi

Dalsze kroki dają szczegółowe informacje dla schematu blokowego zaimplementowanego na węźle-czerwonym

Zwróć uwagę, że diagramy przepływu z czerwonym węzłem współdziałają z kodem Pythona, dlatego ta ostatnia część obejmuje aspekty kodu Pythona

Krok 7: Podstawy czerwonego węzła

Niektóre podstawowe kroki są podświetlone, aby błyskawicznie uruchomić czerwony węzeł, ale tak, czerwony węzeł jest zbyt prosty, aby rozpocząć i opracować aplikacje.

• Początkowy węzeł czerwony:
• Uruchamianie Node-czerwone, gdy pi jest połączone z internetem https:// adres ip>:1880

Krok 8: Węzeł-czerwony: Przepływ _1a

Flow _1a, monitoruje wszelkie zmiany w pliku CSV i na podstawie tych zmian, tj. wykrytego uderzenia, nagrywanie wideo z kamery jest włączane i dodatkowo użytkownik jest informowany przez internet o wystąpieniu uderzenia

Krok 9: Węzeł czerwony: Flow_1b

We wspomnianym przepływie nagrywanie wideo można rozpocząć w dowolnym momencie, po prostu naciskając joystick

Krok 10: Węzeł czerwony: Flow_2a

We wspomnianym przepływie za każdym razem, gdy jakiekolwiek nowe zdjęcie lub wideo jest przechowywane/przesyłane do katalogu, informacje są przekazywane zarejestrowanemu użytkownikowi przez Internet

Krok 11: Węzeł czerwony: Flow_2b

Ten przepływ jest przeznaczony przede wszystkim dla zdalnego użytkownika, aby sterować urządzeniem w następujący sposób;

(a) urządzenie wyłączające

(b) robić zdjęcia

(c) Nagrywaj filmy

(d) start main code (kod dataloggera jest głównym kodem obliczającym wpływ)

Krok 12: czerwony węzeł; Przepływ_3

Przepływ jest przeznaczony do lokalnego dostępu, aby uruchomić główny kod lub urządzenie wyłączające;

Krok 13: MQTT

MQTT (Message Queuing Telemetry Transport) to protokół TCP/IP, w którym wydawca i subskrybent współdziałają ze sobą.

W naszym przypadku Pi jest wydawcą, natomiast aplikacja zainstalowana na naszym telefonie/komputerze jest subskrybentem.

W ten sposób po wygenerowaniu jakiegokolwiek wpływu informacje są przekazywane użytkownikowi zdalnie (konieczne jest działające połączenie internetowe)

Więcej informacji na temat MQTT można uzyskać pod następującym linkiem: MQTT

Aby zacząć korzystać z MQTT, musimy się najpierw zarejestrować, w samouczku korzystałem z cloudmqtt (www.cloudmqtt.com), jest darmowy plan pod "cute cat", to wszystko.

Po rejestracji utwórz instancję, powiedz „pi”, po czym otrzymasz następujące szczegóły

• Nazwa serwera
• Port
• Nazwa Użytkownika
• hasło

Powyższe są wymagane podczas subskrypcji za pośrednictwem telefonu komórkowego/PC

Do mojej aplikacji użyłem aplikacji MQTT ze sklepu Google Play (wersja na Androida)

Krok 14: MQTT: Subskrybent

Aplikacja MQTT działająca na urządzeniu mobilnym (wersja na Androida)

Uderzenia wykryte na pi są przekazywane z powrotem

Krok 15: MQTT: Edycja właściwości w kolorze Node-red

W węźle czerwony po wybraniu węzła MQTT, "Nazwa serwera" i "temat", które mają zostać wymienione. Powinno to być takie samo na końcu abonenta

Krok 16: Kod Pythona:

Funkcjonalność kodu jest zgodna z załączonym schematem blokowym

Krok 17: Ostateczny kod

Kod Pythona jest dołączony

Aby nasz skrypt Pythona był uruchamiany z terminala, musimy uczynić go wykonywalnym jako chmod +x datalogger.py, niż dalej górna część kodu powinna zawierać następującą linię "shebang" #! /usr/bin/python3 (jest to wymagane do wykonywania funkcji z 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

sens = Sense Hat()

importuj csv

znacznik czasu = datetime.now()

delay = 5 // opóźnienie jest zdefiniowane do przechowywania danych w pliku data.csv czerwony = (255, 0, 0) zielony = (0, 255, 0) żółty = (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"])

żyroskop = sens.get_gyroscope_raw()

sense_impact.append(żyro["x"]) sense_impact.append(żyro["y"]) sense_impact.append(żyro["z"])

zwróć sens_impact

def impact(): // funkcja wykrywania uderzenia #GPIO.setmode(GPIO. BCM) #GPIO.setup(4, GPIO. OUT) przyspieszenie = sense.get_accelerometer_raw() x = przyspieszenie['x'] y = przyspieszenie['y'] z = przyspieszenie['z'] x=abs(x) y=abs(y) z=abs(z)

żyroskop = sens.get_gyroscope_raw()

żyroks = żyroskop["x"] żyroskop = żyroskop["y"] żyroskop = żyroskop["z"]

gyrox = okrągły(gyrox, 2)

gyroy = round(gyroy, 2) gyroy = round(gyroy, 2)

wpływ = get_sense_impact()

if x > 1.5 or y > 1.5 or z > 1.5: // wartości są ustawiane po iteracji na rzeczywistej drodze mogą być odpowiednio zmieniane dla różnych typów i umiejętności jazdy za pomocą open('impact.csv', 'w', newline=' ') jako f: data_writer = writer(f) data_writer.writerow(['acc x', 'acc y', 'acc z', 'żyro x', 'żyro y', 'żyro z']) #GPIO. output(4, GPIO. HIGH) sense.clear() sense.show_letter("!", czerwony) data_writer.writerow(impact)

elif gyrox > 1.5 or gyroy > 1.5 or gyroz > 1.5: // wartości są ustawione patrząc na prędkość, z jaką rozpoczynają się skręty za pomocą open('impact.csv', 'w', newline='') jak f: data_writer = writer(f) data_writer.writerow(['acc x', 'acc y', 'acc z', 'żyro x', 'żyro y', 'żyro z']) #GPIO.output(4, GPIO. WYSOKI) sense.clear() sense.show_letter("!", zielony) data_writer.writerow(impact)

w przeciwnym razie:

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

def get_sense_data(): // funkcja do rejestrowania i przechowywania wartości z czujnika sense_data =

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

orientacja = sens.get_orientation()

sense_data.append(orientacja["odchylenie"]) sense_data.append(orientacja["wysokość"]) sense_data.append(orientacja["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"])

żyroskop = sens.get_gyroscope_raw()

sense_data.append(żyro["x"]) sense_data.append(żyro["y"]) sense_data.append(żyro["z"])

sense_data.append(datetime.now())

zwróć sens_dane

z open('data.csv', 'w', newline='') jako f:

data_writer = pisarz (f)

data_writer.writerow(['temp', 'pres', 'hum', 'yaw', 'pitch', 'roll', 'acc x', 'acc y', 'acc z', 'mag x', ' mag y', 'mag z', 'żyroskop x', 'żyroskop y', 'żyro z', 'data-godzina'])

podczas gdy prawda:

print(get_sense_data()) for event in sense.stick.get_events(): # Sprawdź, czy joystick został naciśnięty if event.action == "wciśnięty": # Sprawdź, w którym kierunku, jeśli event.direction == "up": # sense.show_letter("U") # Strzałka w górę przyspieszenie = sense.get_accelerometer_raw() x = przyspieszenie['x'] y = przyspieszenie['y'] z = przyspieszenie['z'] x=round(x, 0) y =okrągły(y, 0) z=okrągły(z, 0)

# Zaktualizuj obrót wyświetlacza w zależności od tego, w którą stronę w górę 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(message, text_color = red, scroll_speed=0.09) elif event.direction == "w dół": przyspieszenie = sense.get_accelerometer_raw() x = przyspieszenie['x'] y = przyspieszenie['y'] z = przyspieszenie['z'] x=round(x, 0) y=okrągły(y, 0) z=okrągły(z, 0)

# Zaktualizuj obrót wyświetlacza w zależności od tego, w którą stronę w górę 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") # Strzałka w dół 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_color = żółty, scroll_speed=0,09)

# elif event.direction == "po lewej":

# przyspieszenie = sense.get_accelerometer_raw() # x = przyspieszenie['x'] #y = przyspieszenie['y'] #z = przyspieszenie['z'] #x=round(x, 0) #y=round(y, 0) #z=okrągły(z, 0)

# Zaktualizuj obrót wyświetlacza w zależności od tego, w którą stronę // Nie jest używany i kontrolowany przez węzeł-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") # Strzałka w lewo # elif event.direction == "right": # sense.show_letter ("K") # Strzałka w prawo # elif event.direction == "middle": # sense.clear()

uderzenie()

dane = get_sense_data()

dt = data[-1] - znacznik czasu jeśli dt.sekundy > opóźnienie: data_writer.writerow(data) znacznik czasu = datetime.now()

Krok 18: Monitorowanie wideo na żywo

Impact Recorder może być również używany do monitorowania wideo na żywo, ponieważ wideo można uruchomić w dowolnym miejscu w dowolnym miejscu za pośrednictwem MQTT

używalibyśmy odtwarzacza VLC do strumieniowego przesyłania filmów, domyślnie w najnowszym raspbian VLC jest preinstalowany, w przeciwnym razie zainstalujemy vlc jak poniżej

Więcej informacji na temat przeglądania strumienia sieciowego można uzyskać za pośrednictwem strumienia sieciowego VLC

Dziękuję za przeczytanie!!

Rejestrator uderzeń może zrobić znacznie więcej..

Uważaj na kolejne miejsce na analizę pola magnetycznego podczas mapowania przeszkód