Raspberry Pi - autonomiczny łazik marsjański ze śledzeniem obiektów OpenCV: 7 kroków (ze zdjęciami)

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

Zasilany przez Raspberry Pi 3, rozpoznawanie obiektów Open CV, czujniki ultradźwiękowe i motoreduktory prądu stałego. Ten łazik może śledzić każdy obiekt, do którego został wyszkolony i poruszać się po dowolnym terenie.

Krok 1: Wprowadzenie

W tym Instructables zbudujemy autonomiczny łazik marsjański, który potrafi rozpoznawać obiekty i śledzić je za pomocą oprogramowania Open CV działającego na Raspberry Pi 3 z opcją użycia kamery internetowej lub oryginalnej kamery raspberry pi. Jest również wyposażony w czujnik ultradźwiękowy zamontowany na serwo, aby śledzić jego drogę w ciemnym otoczeniu, w którym kamera nie działała. Sygnały odbierane z Pi są wysyłane do układu scalonego sterownika silnika (L293D), który napędza 4 silniki prądu stałego o prędkości 150 obr./min zamontowane na korpusie zbudowanym z rur PVC.

Krok 2: Wymagane materiały i oprogramowanie

Wymagane materiały

1. Raspberry Pi (dowolne oprócz zera)
2. Kamera Raspberry PI lub kamera internetowa
3. Układ scalony sterownika silnika L293D
4. Koła robota (7x4cm) X 4
5. Motoreduktory prądu stałego (150 obr./min) X 4
6. Rury PCV do podwozi

Wymagane oprogramowanie

1. Szpachlówka do SSH ing Pi
2. Otwórz CV do rozpoznawania obiektów

Krok 3: Budowa podwozia łazika

Aby zbudować to podwozie z PVC, będziesz potrzebować

• 2X8"
• 2X4"
• 4 trójniki

Rury PCV ułożyć w strukturę drabinkową i włożyć w trójniki. Możesz użyć uszczelniacza PCV, aby jeszcze bardziej wzmocnić połączenia.

Motoreduktory prądu stałego łączone są z podwoziem z rur PCV za pomocą zacisków, a następnie koła są łączone z silnikami za pomocą śrub.

Krok 4: Budowanie zespołu dalmierza ultradźwiękowego

Zespół dalmierza ultradźwiękowego jest zbudowany przy użyciu czujnika ultradźwiękowego HC-SR04 połączonego z silnikiem Micro Servo. Kable są wstępnie połączone z czujnikiem ultradźwiękowym przed umieszczeniem w plastikowej obudowie, która jest połączona z serwomotorem za pomocą śrub.

Krok 5: Schematy i połączenia elektryczne

Połączenia elektryczne należy wykonać zgodnie z załączonym schematem połączeń.

Krok 6: Instalacja SSH i Open CV

Teraz musimy SSH do naszego raspberry pi, aby zainstalować wymagane oprogramowanie. Zaczniemy od SSH do naszego Raspberry Pi. Upewnij się, że Twoje Pi jest podłączone do tego samego routera co komputer i wiesz, że jest to adres IP przypisany do niego przez router. Teraz otwórz wiersz polecenia lub PUTTY, jeśli korzystasz z systemu Windows i uruchom następujące polecenie.

ssh [email protected]

Twój adres IP może być inny, mój to 192.168.1.6.

Teraz wprowadź swoje domyślne hasło - "malinowy"

Teraz, gdy masz SSH do swojego Pi, zacznijmy od aktualizacji za pomocą tego polecenia.

aktualizacja sudo apt-get && aktualizacja sudo apt-get

Zainstalujmy teraz wymagane narzędzia programistyczne, sudo apt-get install build-essential cmake pkg-config

Następnie musimy zainstalować kilka pakietów I/O obrazu, które pomogą naszemu Pi w pobieraniu różnych formatów obrazu z dysku.

sudo apt-get zainstaluj libjpeg-dev libtiff5-dev libjasper-dev libpng12-dev

Teraz niektóre pakiety do pobierania wideo, przesyłania strumieniowego na żywo i optymalizacji wydajności OpenCV

sudo apt-get zainstaluj libavcodec-dev libavformat-dev libswscale-dev libv4l-dev

sudo apt-get zainstaluj libxvidcore-dev libx264-dev

sudo apt-get zainstaluj libgtk2.0-dev libgtk-3-dev

sudo apt-get zainstaluj libatlas-base-dev gfortran

Musimy również zainstalować pliki nagłówkowe Python 2.7 i Python 3, abyśmy mogli skompilować OpenCV z powiązaniami Pythona

sudo apt-get zainstaluj python2.7-dev python3-dev

Pobieranie kodu źródłowego OpenCV

cd ~

wget -O opencv.zip

rozpakuj opencv.zip

Pobieranie repozytorium opencv_contrib

wget -O opencv_contrib.zip

rozpakuj opencv_contrib.zip

Zaleca się również użycie środowiska wirtualnego do instalacji OpenCV.

sudo pip zainstaluj virtualenv virtualenvwrapper

sudo rm -rf ~/.cache/pip

Teraz, gdy virtualenv i virtualenvwrapper zostały zainstalowane, musimy zaktualizować nasz ~/.profile, aby uwzględnić następujące wiersze na dole

export WORKON_HOME=$HOME/.virtualenvs export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3 source /usr/local/bin/virtualenvwrapper.sh

Stwórz swoje wirtualne środowisko Pythona

mkvirtualenv cv -p python2

przełącz się do stworzonego środowiska wirtualnego

źródło ~/.profil

praca na cv

Instalowanie NumPy

pip zainstaluj numpy

Skompiluj i zainstaluj OpenCV

cd ~/opencv-3.3.0/

kompilacja mkdir

kompilacja cd

cmake -D CMAKE_BUILD_TYPE=RELEASE / -D CMAKE_INSTALL_PREFIX=/usr/local / -D INSTALL_PYTHON_EXAMPLES=ON / -D OPENCV_EXTRA_MODULES_PATH=~/opencv_contrib-3.3.0/modules / -D BUILD_EXAMPLES

Wreszcie skompiluj OpenCV

make -j4

Po zakończeniu tego polecenia. Wystarczy go zainstalować.

konfiguracja konfiguracji sudo

sudo ldconfig

Krok 7: Uruchamianie kodu Pythona dla Rovera

Utwórz plik Pythona o nazwie tracker.py i dodaj do niego następujący kod.

sudo nano tracker.py

kod:-

#Program ASAR

#Ten program śledzi czerwoną kulkę i instruuje Malinowy Pi, aby za nią podążał. import sys sys.path.append('/usr/local/lib/python2.7/site-packages') import cv2 import numpy jako np import os import RPi. GPIO jako IO IO.setmode(IO. BOARD) IO.setup (7, IO. OUT) IO.setup(15, IO. OUT) IO.setup(13, IO. OUT) IO.setup(21, IO. OUT) IO.setup(22, IO. OUT) def fwd(): IO.output(21, 1)#Lewy silnik do przodu IO.output(22, 0) IO.output(13, 1)#Prawy silnik do przodu IO.output(15, 0) def bac(): IO.output (21, 0)#Lewy silnik do tyłu IO.output(22,1) IO.output(13,0)#Prawy silnik do tyłu IO.output(15,1) def ryt(): IO.output(21,0) #Lewy silnik do tyłu IO.output(22, 1) IO.output(13, 1)#Prawy silnik do przodu IO.output(15, 0) def lft(): IO.output(21, 1)#Lewy silnik do przodu IO.output(22, 0) IO.output(13, 0)#Prawy silnik wstecz IO.output(15, 1) def stp(): IO.output(21, 0)#Lewy silnik zatrzymanie IO.output(22, 0) IO.output(13, 0)#Prawe zatrzymanie silnika IO.output(15, 0) ############################ ################################################## ##################### def main(): capWebcam = cv2. VideoCapture(0) # zadeklaruj Obiekt VideoCapture i powiązać z kamerą internetową, 0 => użyj pierwszej kamery internetowej # pokaż oryginalną rozdzielczość drukuj "default resolution = " + str(capWebcam.get(cv2. CAP_PROP_FRAME_WIDTH)) + "x" + str(capWebcam.get(cv2. CAP_PROP_FRAME_HEIGHT)) capWebcam.set(cv2. CAP_PROP_FRAME_WIDTH, 320.0) # zmień rozdzielczość na 320x240 w celu szybszego przetwarzania capWebcam.set(cv2. CAP_PROP_FRAME_HEIGHT, 240.0) # pokaż zaktualizowaną rozdzielczość print "zaktualizowana rozdzielczość = " + str(capWebcam.get(cv2. CAP_PROP_FRAME_HEIGHT)) + "x" + str(capWebcam.get(cv2. CAP_PROP_FRAME_HEIGHT)) if capWebcam.isOpened() == False: # sprawdź, czy obiekt VideoCapture został skojarzony z kamerą internetową pomyślnie wydrukuj "błąd: dostęp do kamery internetowej nie powiodło się\n\n" # jeśli nie, wypisz komunikat o błędzie na standardowe wyjście os.system("pause") # wstrzymaj, aż użytkownik naciśnie klawisz, aby użytkownik mógł zobaczyć komunikat o błędzie return # i wyjdź z funkcji (która kończy działanie programu) # end if while cv2.waitKey(1) != 27 i capWebcam.isOpened(): # do momentu naciśnięcia klawisza Esc lub utraty połączenia z kamerą internetową blnFrameReadSuccessf ully, imgOriginal = capWebcam.read() # odczytaj następną ramkę, jeśli nie blinFrameReadSuccessfully lub imgOriginal to None: # jeśli ramka nie została odczytana pomyślnie print "error: frame not read from webcam\n" # wydrukuj komunikat o błędzie, aby wyjść z systemu os.system ("pause") # wstrzymaj, dopóki użytkownik nie naciśnie klawisza, aby użytkownik mógł zobaczyć komunikat o błędzie break # wyjdź podczas pętli (która kończy działanie programu) # end if imgHSV = cv2.cvtColor(imgOriginal, cv2. COLOR_BGR2HSV) imgThreshLow = cv2.inRange(imgHSV, np. tablica ([0, 135, 135]), np. tablica ([18, 255, 255])) imgThreshHigh = cv2.inRange (imgHSV, np. tablica ([165, 135, 135]), np. array([179, 255, 255])) imgThresh = cv2.add(imgThreshLow, imgThreshHigh) imgThresh = cv2. GaussianBlur(imgThresh, (3, 3), 2) imgThresh = cv2.dilate(imgThresh, np.ones(() 5, 5), np.uint8)) imgThresh = cv2.erode(imgThresh, np.ones((5, 5), np.uint8)) intRows, intColumns = imgThresh.shape circles = cv2. HoughCircles(imgThresh, cv2. HOUGH_GRADIENT, 5, intRows / 4) # wypełnij zmienne okręgi wszystkimi okręgami w przetworzonym obrazie, jeśli okręgi nie ma Brak: # ta linia jest konieczna, aby program nie zawiesił się w następnej linii, jeśli nie znaleziono żadnych okręgów IO.output(7, 1) for circle in circles[0]: # dla każdego okręgu x, y, radius = circle # break out x, y, and radius print "ball position x = " + str(x) + ", y = " + str(y) + ", radius = " + str(radius) # wydrukuj położenie kuli i promień obRadius = int(promień) xAxis = int(x) if obRadius>0 & obRadius100&xAxis180: print("Ruch w prawo") ryt() elif xAxis<100: print("Ruch w lewo") lft() else: stp() else: stp () cv2.circle(imgOriginal, (x, y), 3, (0, 255, 0), -1) # narysuj małe zielone kółko w środku wykrytego obiektu cv2.circle(imgOriginal, (x, y), radius, (0, 0, 255), 3) # narysuj czerwone kółko wokół wykrytego obiektu # end for # end if else: IO.output(7, 0) cv2.namedWindow("imgOriginal", cv2. WINDOW_AUTOSIZE) # utwórz okna, użyj WINDOW_AUTOSIZE dla stałego rozmiaru okna cv2.namedWindow("imgThresh", cv2. WINDOW_AUTOSIZE) # lub użyj WINDOW_NORMAL, aby zezwolić na zmianę rozmiaru okna cv2.imshow("imgOriginal", imgOri ginal) # pokaż okna cv2.imshow("imgThresh", imgThresh) # end while cv2.destroyAllWindows() # usuń okna z pamięci return ##################### ################################################## ############################ if _name_ == "_main_": main()

Teraz pozostaje tylko uruchomić program

python tracker.py

Gratulacje! Twój autonomiczny łazik jest gotowy! Część nawigacji oparta na czujnikach ultradźwiękowych zostanie wkrótce ukończona i zaktualizuję tę instrukcję.

Dziękuje za przeczytanie!