Widok z tyłu pojazdu: 9 kroków (ze zdjęciami)

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

Dlaczego budujemy Vehicle Rear Vision?

Kolizja zapasowa była poważnym problemem. Amerykańskie Centrum Kontroli Chorób poinformowało, że w latach 2001-2003 około 7 475 dzieci (2 492 rocznie) w wieku poniżej 15 lat było leczonych z powodu wypadków samochodowych. Około 300 ofiar śmiertelnych rocznie jest wynikiem kolizji zapasowych. Do 2018 roku wszystkie samochody sprzedawane w Stanach Zjednoczonych będą wymagały obowiązkowej kamery cofania.

Jak rozwiązujemy problem?

Większość samochodów dostępnych obecnie na rynku nadal nie ma kamery cofania, co obejmuje około połowę samochodów sprzedawanych obecnie w Stanach Zjednoczonych i znacznie więcej niż połowę na całym świecie. Możemy rozwiązać ten problem instalując kamerę z tyłu auta, wykorzystując przestrzeń tablicy rejestracyjnej.

Walabot będzie w stanie wykryć odległość celu znajdującego się najbliżej pojazdu.

Kamera Intel RealSense R200 zapewni nam więcej szczegółów na temat tego, co widzimy, w tym sytuacji przy słabym oświetleniu.

Zestaw programisty Intel Joule jest wystarczająco wydajny, aby obsługiwać kamery RealSense wraz z Walabot. Raspberry Pi nie jest wystarczająco wydajne, aby uruchomić kamerę RealSense 3D, w której w przyszłości możemy dodać o wiele więcej funkcji, które mogą poprawić funkcjonalność samochodu. Ta sama wersja może być używana z Pi z normalną kamerą USB, ale nie będzie to dobre na noc.

Telefon/tablet z systemem Android używany do wyświetlania kamery cofania, ma to na celu zmniejszenie kosztu dodatkowego ekranu. Wersję iOS można zbudować na żądanie.

Dzięki tym komponentom będziemy w stanie zbudować system Rear End Vision, który pokazuje użytkownikowi tył samochodu.

Krok 1: Zbierz potrzebny sprzęt

1. Intel Dżul
2. Walabot Pro
3. Kamera Intel R200 RealSense
4. Telefon/tablet z systemem Android w wersji 5.0 lub nowszej
5. Adapter samochodowy do wyjścia wtykowego i zasilacz 12VDC AC (jest to demo do zasilania Joule, wersja produkcyjna będzie zawierać inny mechanizm zasilania)
6. Hub USB do podłączenia kamery i Walabota (USB3 dla kamery i USB2 dla Walabota)
7. Przetwornica mocy DC-AC Direct Plug-in
8. Ogólna drukarka 3D do drukowania niestandardowej ramki tablicy rejestracyjnej

Krok 2: Zainstaluj Ubuntu na Joule i niezbędnych bibliotekach, które są potrzebne do jego uruchomienia

Ponieważ zdecydowaliśmy się iść z Linuksem, postępuj zgodnie z przewodnikiem https://developer.ubuntu.com/core/get-started/intel-joule, aby zainstalować Ubuntu na Joule. Ubuntu daje nam dużą elastyczność w uruchamianiu rzeczywistego systemu operacyjnego na chipie opartym na IoT.

Krok 3: Przesyłaj strumieniowo kamerę RealSense

Ponieważ używamy telefonu / tabletu z Androidem, aby zaoszczędzić na kosztach na zestawieniu materiałów, które są również bardziej dostępne dla użytkowników, będziemy używać biblioteki ruchu do hostowania kamery podobnej do kamer bezpieczeństwa. Po zainstalowaniu Ubuntu i podłączeniu do Wi-Fi możemy otworzyć terminal i użyć następującego polecenia. Najpierw podłączamy kamerę do Joule przez port USB3, a następnie wykonujemy następujące kroki.

a. Instalowanie ruchu na Ubuntu:

sudo apt-get aktualizacje sudo apt-get install motion

b. Skopiuj pliki konfiguracyjne:

mkdir.motion sudo cp /etc/motion/motion.conf ~/.motion/motion.conf

C. Konfiguracja pliku, dla tych, którzy są zaznajomieni z ubuntu, można zainstalować Sublime, aby ułatwić edycję tekstu, w przeciwnym razie możemy go edytować w wierszu poleceń.

sudo nano ~/.motion/motion.conf

D. Po podłączeniu kamery R200 możemy w motion.conf zmienić następujące linijki

Ma to na celu umieszczenie go w trybie tła:

# Uruchom w trybie demona (w tle) i zwolnij terminal (domyślnie: wyłączony) demon włączony

Służy do korzystania z widoku kamery RealSense Camera.

# Urządzenie wideo używane do przechwytywania (domyślnie /dev/video0) # dla FreeBSD domyślnie jest to /dev/bktr0 videodevice /dev/video2

Zmiana szerokości i wysokości, 1280 x 720, działała dla mnie świetnie, ale możesz pobawić się wymiarami, aby zobaczyć, co pasuje do twoich potrzeb.

# Szerokość obrazu (w pikselach). Prawidłowy zakres: zależny od kamery, domyślnie: szerokość 352 1280 # wysokość obrazu (w pikselach). Prawidłowy zakres: zależny od kamery, domyślnie: 288 wysokość 720

Ustawiłem to na 30, im wyższa liczba, tym więcej mocy obliczeniowej będzie wymagał. Możesz się pobawić, aby zobaczyć, jaki jest dla tego punkt odniesienia, ale 30 działało dla mnie świetnie.

# Maksymalna liczba klatek do przechwycenia na sekundę. # Prawidłowy zakres: 2-100. Domyślnie: 100 (prawie bez limitu). liczba klatek na sekundę 30

Ponieważ zawsze przesyłamy strumieniowo z samochodu, możemy ustawić dedykowany port, używamy 5001

################################################## ######### # Serwer transmisji na żywo ##################################### ####################### # Serwer mini-http nasłuchuje na tym porcie dla żądań (domyślnie: 0 = wyłączony) stream_port 5001 # Jakość jpeg (w procentach) wyprodukowanych obrazów (domyślnie: 50) stream_quality 50 # Wysyłaj klatki z prędkością 1 kl./s, gdy nie wykryto ruchu i zwiększaj do # szybkości podanej przez stream_maxrate po wykryciu ruchu (domyślnie: off) stream_motion off # Maksymalna liczba klatek na sekundę dla strumieni strumieni (domyślnie: 1) stream_maxrate 60 # Ogranicz połączenia strumieniowe tylko do hosta lokalnego (domyślnie: wł.) stream_localhost wył.

Następnie możesz uruchomić ifconfig i ustalić adres IP i uruchomić w terminalu, port będzie 5001.

ruch

Jeśli nie ma żadnych błędów, łatwo jest sprawdzić kamerę z komputera za pomocą ip, naprawić błędy, takie jak problemy z uprawnieniami, jeśli występują.

Po uruchomieniu możemy dodać to do aplikacji startowej w Ubuntu.

Uruchamianie ruchu dla kamery

motion.conf jest dołączony w sekcji kodu, możesz tam sprawdzić więcej ustawień.

Krok 4: Skonfiguruj Walabota

Gdy kamera jest na miejscu, nadal musimy skonfigurować walabot, który może wykryć odległość między pojazdem a obiektem z tyłu, dając jasny obraz tego, jak powinniśmy

a, pobierz plik deb z

Postępuj zgodnie z instrukcjami ze strony https://api.walabot.com/_install.html#_linuxInstall, aby zainstalować Walabot API, aby można było go zaimportować do projektów Pythona.

Na stronie jest błąd w części, w której instaluje Walabot API https://walabot.com/api/_pythonapi.html#_installingwalabotapi gdzie jest napisane

python -m pip „/usr/share/walabot/python/WalabotAPI-1.0.21.tar.gz”

To powinno być

python -m pip install "/usr/share/walabot/python/WalabotAPI-1.0.21.tar.gz"

b. podłącz Walabot Pro przez USB 2, nie mogłem uzyskać pracy usb3, ale usb2 działa dobrze, łącząc się z linuxem. Ponieważ Joule ma tylko jeden port USB3, podłącz dodatkowy port USB2, aby pomieścić Walabot Pro tutaj

C. Przetestuj projekt Walabot, taki jak https://github.com/Walabot-Projects/Walabot-Senso…, uruchamiając następujące polecenie w folderze

python SensorTargets.py

Powinno to dać dobry test, aby sprawdzić, czy Walabot działa poprawnie, a także jak mierzyć odległość na przedmiotach, które chcesz. Przykład DistanceMeasure nie był zbyt spójny w pomiarach, a zPosCm wydaje się być niezwykle dokładny, więc zdecydowałem się użyć zPosCM do demonstracji.

D. Nadal musimy przesyłać dane do urządzenia wyświetlającego, ponieważ uruchamiamy to na Androidzie, aby obniżyć koszty materiału, możemy użyć gniazd. Używamy następującego kodu, aby skonfigurować gniazdo i udp w pythonie.

MYPORT = 5002 import sys, czas od importu gniazda * s = socket(AF_INET, SOCK_DGRAM) s.bind(('', 0)) s.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) s.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)

Następujące polecenie wyśle dane podczas aktualizacji

s.sendto(str(targets[0].zPosCm), ('255.255.255.255', MÓJPORT))

mi. Kiedy to zrobimy, możemy skonfigurować go w aplikacji startowej

F. Walabot jest teraz skonfigurowany i przesyła dane przez UDP, pełny kod Pythona można zobaczyć w obszarze załącznika kodu. Zrzut ekranu poniżej to wydruk tego, jak powinien wyglądać, gdy nie ma obszaru. Kod jest dołączony w sekcji kodu.

Krok 5: Tworzenie hotspotu Wi-Fi z Joule

Tworzymy własny hotspot Wi-Fi dla urządzenia z systemem Android do przesyłania danych. Użycie następującego polecenia na początku automatycznie go ustawi. Jest używany w Ubuntu 16.04 lub nowszym, ponieważ jest używany. W następnym kroku połączymy to automatycznie przez aplikację na Androida. Użyj tego polecenia w aplikacjach startowych.

urządzenie nmcli wifi hotspot con-name ssid pojazdu wstecznego ssid pojazdu lusterko wsteczne bg hasło safedriving

Wewnątrz pliku Pythona walabot zaktualizujemy go również, gdzie będziemy wysyłać wiadomość udp do urządzeń podłączonych przez prywatny hotspot. Ma to na celu zapewnienie, że żaden pakiet nie zostanie utracony.

out = os.popen('ip neigh').read().splitlines()for i, line in enumerate(out, start=1): ip = line.split(' ')[0] s.sendto(str (targets[0].zPosCm), (IP, MYPORT))

Krok 6: Budowanie Androida jako ekranu wyświetlacza

Aplikacja na Androida jest stworzona do wyświetlania urządzenia, głównie dlatego, że zmniejsza koszty materiałów, ponieważ w przeciwnym razie oddzielny ekran może być zarówno kosztowny, jak i trudny do zainstalowania. W tym projekcie możemy korzystać z telefonu/tabletu z systemem Android.

Android skupia się na 3 częściach, które zrobiliśmy wcześniej,

• Połącz się z hotspotem Wi-Fi utworzonym za pomocą urządzenia IoT (Intel Joule)
• Przesyłaj strumieniowo kamerę RealSense za pomocą ruchu przez Wi-Fi
• Pomiar odległości od celu Walabot przez udp

Po skonfigurowaniu wszystkiego i zainstalowaniu aplikacji na Androida (tutaj open source), będziesz mógł zobaczyć, jak kamera współpracuje z walabotem

Krok 7: Testowanie wszystkiego

Teraz wszystko działa, powinniśmy mieć podstawową konfigurację wszystkich dołączonych komponentów. Kiedy uruchamiamy tablicę Joule, hotspot powinien zostać automatycznie skonfigurowany, wraz z nim uruchomi się aplikacja ruchu i walabot, a po włączeniu naszej aplikacji na Androida powinniśmy być w stanie przesyłać strumieniowo z kamery. Oznacza to, że klawiatura/mysz i monitor nie są już potrzebne do działania urządzenia IoT. Jeśli w tym momencie wystąpią jakiekolwiek problemy, takie jak niepoprawnie zainstalowane biblioteki, powinniśmy to naprawić przed przejściem do następnego kroku.

Bardzo ważne jest drukowanie 3D obudowy, która może pomieścić aparat.

Budując sprzęt, powinniśmy mieć przygotowaną niestandardową obudowę wydrukowaną w 3D dla aparatu. Ponieważ jest to prototyp, może się trochę poluzować, ale kiedy budujemy niestandardowy uchwyt na tablicę rejestracyjną, oczekujemy, że wszystkie komponenty będą wewnątrz uchwytu.

Krok 8: Testowanie na prawdziwym samochodzie

Teraz, gdy wszystko działa, będziemy mogli przetestować to na prawdziwym samochodzie. Ponieważ jest to prototyp, sprawy mogą być nieco trudne, do niektórych komponentów używamy taśmy klejącej.

Aby zasilić zestaw Joule IoT, użyliśmy falownika DC/AC Direct Plug-in, a następnie po prostu podłączyliśmy długie gniazdo zasilania do bagażnika.

Będziemy mieli przednią i tylną część. W tej chwili jest to tylko prototyp, następna wersja będzie integrować chipy wewnątrz uchwytu tablicy rejestracyjnej.

A z przodu możemy zastosować uchwyt na telefon lub po prostu taśmę klejącą do tabletu z systemem Android.

Krok 9: Użyj go na świecie

Za pomocą tego narzędzia możemy bezpiecznie cofać samochód do innych samochodów i monitorować pieszych. Film demonstracyjny możesz obejrzeć na początku. Celem projektu jest zachęcanie do bezpieczniejszych praktyk jazdy.

Możesz sprawdzić projekt na