Łazik sterowany przez sieć: 14 kroków (ze zdjęciami)

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

Budowanie i zabawa z robotami to moja główna grzeszna przyjemność w życiu. Inni grają w golfa lub na nartach, ale ja buduję roboty (ponieważ nie umiem grać w golfa ani jeździć na nartach:-). Uważam to za relaksujące i zabawne! Aby zrobić większość moich botów, używam zestawów podwozia. Korzystanie z zestawów pomaga mi robić to, co lubię robić bardziej, oprogramowanie i elektronikę, a także zapewnia lepszą obudowę dla mojego kciuka.

W tej instrukcji przyjrzymy się, czego potrzeba, aby stworzyć prosty, ale solidny łazik sterowany przez Wi-Fi / sieć. Zastosowane podwozie to Actobotics Gooseneck. Wybrałem go ze względu na jego rozmiar, możliwości rozbudowy i koszt, ale możesz użyć dowolnej innej obudowy według własnego wyboru.

Do takiego projektu będziemy potrzebować dobrego, solidnego komputera jednopłytkowego, a do tego bota wybrałem Raspberry Pi (RPI), komputer oparty na Linuksie. RPI (i Linux) daje nam wiele opcji kodowania, a Python będzie używany do kodowania. Do interfejsu sieciowego używam Flask, lekkiego frameworka internetowego dla Pythona.

Do napędu silników wybrałem RoboClaw 2x5a. Pozwala na prostą komunikację szeregową do wydawania poleceń i działa dobrze z RPI i silnikami na gęsiej szyi.

Wreszcie, ma kamerę internetową do informacji zwrotnych wideo typu POV do zdalnego sterowania. Każdy temat omówię bardziej szczegółowo później.

Krok 1: Potrzebny sprzęt

• Podwozie Actobotics Gooesneck lub odpowiedni zamiennik do wyboru
• Raspberry Pi do wyboru (lub klon) - Na tym bocie używany jest model RPI B, ale każdy z co najmniej dwoma portami USB będzie działał
• Standardowa płyta serwo B x1
• Kątowy wspornik kanału 90 ° x1
• Sterownik silnika RoboClaw 2x5a
• S3003 lub podobny serwo o standardowym rozmiarze
• Mała płytka do krojenia chleba lub Mini płytka do krojenia chleba
• Przewody połączeniowe żeńskie do żeńskich
• Przewody połączeniowe męskie do żeńskich
• Kamera internetowa (opcjonalna) - używam Logitech C110, a oto lista obsługiwanych kamer dla RPI
• Źródło zasilania 5 v-6 v dla zasilania serwo;
• Akumulator 7.2v-11,1v do zasilania silnika napędowego
• 5v 2600mah (lub wyższy) power bank USB dla RPI
• Adapter USB Wi-Fi

Na moim bocie używam kół 4 , aby był trochę bardziej All-Terrain-Indoor. Do tej opcji będziesz potrzebować:

• 4-calowe koło do dużych obciążeń x2
• Piasta śruby ustalającej 4 mm (0,770 cala) x2

Krok 2: Montaż podwozia

Najpierw zmontuj obudowę zgodnie z instrukcjami dołączonymi do obudowy lub wideo. Po zakończeniu powinieneś mieć coś takiego jak obraz. UWAGA: Podczas montażu części na szyję wystarczy pozostawić wspornik montażowy wyłączony.

W moim bocie zdecydowałem się wymienić koła z podwoziem na 4 koła do dużych obciążeń. Jest to opcjonalne i nie jest potrzebne, chyba że chcesz zrobić to samo.

Krok 3: Montaż elektroniki

Gooseneck ma dużo miejsca i możliwości montażu elektroniki. Daję ci te zdjęcia jako wskazówkę, ale możesz wybrać, jak chcesz to wszystko ułożyć. Do zamontowania deski i baterii można użyć podkładek, taśmy dwustronnej, rzepa lub taśmy servo.

Krok 4: Dodawanie kamery internetowej

W tym kroku weź wspornik 90 stopni, lekką piastę serwo i cztery (4) śruby 0,3125 cala:

• Weź piastę serwomechanizmu i umieść ją po jednej stronie wspornika i zabezpiecz je razem za pomocą śrub.2125", jak na zdjęciu
• Następnie zamontuj serwo w wsporniku serwa
• Przymocuj wspornik 90 stopni z klaksonem serwomechanizmu do kręgosłupa serw i użyj śruby klaksonu dołączonej do serwomechanizmu, aby połączyć je ze sobą
• Teraz zamontuj Servo w wsporniku na górze gęsiej szyi za pomocą pozostałych śrub
• Zamontuj kamerę za pomocą opasek błyskawicznych lub taśmy dwustronnej na wsporniku 90 stopni

W razie potrzeby użyj zdjęć jako przewodników.

Krok 5: Okablowanie wszystkiego

Okablowanie jest dość proste dla tego robota.

Silniki:

Przewody lutownicze na obu silnikach, jeśli jeszcze tego nie zrobiłeś

Z przodem robota (koniec z gęsią szyją) odwróconym od siebie:

• Podłącz przewody silnika na lewym silniku do kanałów M1A i M1B
• Podłącz przewody silnika na prawym silniku do kanałów M2A i M2B

Połączenia uziemienia (GND):

• Podłącz jeden pin uziemiający RoboClaw do płytki uziemiającej. Linia szpilki uziemiającej na RoboClaw jest najbliżej środka (patrz zdjęcie)
• Podłącz PIN 6 na RPI do płyty zworek. Zobacz zdjęcie nagłówka RPI dla przypisania pinów.
• Podłącz GND z pakietu akumulatorów serwomechanizmu do jednego z pinów na płytce zworek.
• Poprowadź przewód połączeniowy od płytki połączeniowej do przewodu GND serw.

RPI do RoboClaw:

Podłącz pin RPI GPIO14 TXD do pinu RoboClaw S1

Moc:

• Podłącz przewód POS z akumulatora serwomechanizmu do przewodu serwomechanizmu POS
• Podłącz przewód POS z akumulatora silnika do POS (+) zacisku wejściowego zasilania silnika RoboClaw. Na razie zostawimy terminal GND odłączony.

Krok 6: Konfiguracja RPI

Zakładam, że użytkownik tutaj wie trochę o Linuksie i RPI. Nie opisuję, jak skonfigurować lub połączyć się z jednym. Jeśli potrzebujesz pomocy, skorzystaj z poniższych stron.

Aby uzyskać konfigurację RPI, spójrz na następujące strony:

• Podstawowa konfiguracja RPI
• Przewodnik szybkiego startu RPI
• Gildia konfiguracji NOOBS

W przypadku ogólnych stron przejściowych, strona główna RPI i strony eLinux są świetnymi miejscami do rozpoczęcia.

Zobacz ten link, aby uzyskać ogólną konfigurację Wi-Fi RPI.

Jeśli planujesz używać jakiegoś aparatu lub kamery internetowej na bocie, zajrzyj na te strony, aby uzyskać podstawowe potrzebne pliki.

• Konfiguracja kamery RPI
• Konfiguracja kamery eLinix RPI

Przesyłanie strumieniowe wideo:

Istnieje kilka sposobów, aby strumieniowanie wideo działało na RPI, ale preferuję metodę Motion.

Aby zainstalować go na swoim RPI, uruchom to: sudo apt-get install motion

Ta instruktażowa dotyczy również konfigurowania go do przesyłania strumieniowego.

Krok 7: Konfiguracja portu szeregowego RPI

Będziemy musieli wyłączyć tryb konsoli Linux, aby używać RX i TX, ponieważ chcemy rozmawiać ze sterownikiem silnika RoboClaw z tego portu. Aby to zrobić, możesz użyć tej metody lub tego narzędzia. Wybór metody należy do Ciebie, ponieważ w końcu oboje robią to samo.

Krok 8: Instalacja modułów Pythona

Będziesz potrzebować Pythona zainstalowanego na RPI, a także instalatora pakietu Pythona pip.

Aby zainstalować pip wykonaj:

1. sudo apt-get install python-setuptools
2. sudo easy_install pip

Następnie:

1. kolba instalacyjna sudo pip
2. sudo pip zainstaluj pyserial
3. sudo pip zainstaluj RPIO

To będą wszystkie moduły potrzebne do uruchomienia kodu.

Krok 9: Konfiguracja RoboClaw

Mam kod robota rozmawiający z RoboClawem w standardowym trybie szeregowym z prędkością 19200 bodów.

Aby skonfigurować RoboClaw do tego, wykonaj:

1. Naciśnij przycisk „MODE” na RoboClaw
2. Naciśnij przycisk ustawiania, aż dioda LED zamiga 5 (pięć) razy między opóźnieniami
3. Naciśnij przycisk "LIPO", aby zapisać
4. Następnie naciśnij przycisk „SET”, aż dioda LED zamiga 3 (trzy) razy między opóźnieniami
5. Naciśnij przycisk LIPO, aby zapisać

To tyle, jeśli chodzi o konfigurację sterownika silnika. W razie potrzeby zobacz link do pliku PDF, aby uzyskać więcej informacji.

Krok 10: Instalacja programu/plików Rover

Pobierz i skopiuj plik rover.zip do swojego RPI w katalogu użytkownika pi.

Jeśli używasz Linuksa lub Maca, możesz użyć 'scp', aby to zrobić:

scp ~/lokalizacja/pliku/łazika.zip pi@twój_ip_ip:/~

W systemie Windows możesz pobrać i używać pscp, a następnie wykonać:

pscp /lokalizacja/pliku/łazika.zip pi@twój_ip_ip:/~

Po skopiowaniu pliku zip do RPI zaloguj się do niego jako użytkownik pi.

Teraz uruchom:

rozpakuj rover.zip

Spowoduje to rozpakowanie plików do folderu o nazwie „rover” i będzie zawierać następujące elementy:

• restrover.py (kod Pythona dla robota)
• statyczny (przechowuje pliki obrazów dla przycisków na stronie kontrolnej)
• szablony (zawiera plik index.htlm, stronę kontrolną)

Jeśli używasz kamery internetowej, zmodyfikuj linię w dolnej części pliku index.html w folderze szablonów. Zmień adres URL w wierszu IFRAME, aby pasował do adresu URL źródła strumienia wideo.

Krok 11: Uruchamianie bota

Podłącz zasilanie USB do RPI.

Aby uruchomić kod bota, zaloguj się jako użytkownik pi i uruchom:

• cd rover
• sudo python restrover.py

Jeśli wszystko było w porządku, powinieneś zobaczyć ekran podobny do obrazu w tym kroku

Jeśli zauważysz jakieś błędy lub problemy, musisz je naprawić przed przejściem dalej.

Teraz podłącz przewód GND (-) do zacisku NEG (-) na wejściu zasilania silnika RoboClaw.

Krok 12: Dostęp do strony kontroli botów

Po uruchomieniu skryptu python robota włącz RoboClaw, a następnie przejdź do adresu IP swojego RPI:

twój_ip_ip

Powinieneś zobaczyć wyskakującą stronę kontroli sieci, jak na obrazkach. Jeśli nie, sprawdź terminal wyjściowy RPI i poszukaj błędów i popraw je.

Po wejściu na stronę jesteś gotowy do kontrolowania bota.

Robot wystartuje w ustawieniu „Med run” i ze średnią prędkością.

Botem można sterować za pomocą przycisków na stronie lub za pomocą klawiszy na klawiaturze.

Klucze to:

• w - naprzód
• z - wstecz/do tyłu
• a - długi skręt w lewo
• s - długi skręt w prawo
• q - krótki skręt w lewo
• e - krótki skręt w prawo
• 1 - kamera panoramiczna w lewo
• 2 - kamera panoramiczna w prawo
• 3 - patelnia pełna w lewo
• 4 - panoramowanie całkowicie w prawo
• / - kamera domowa/centralna
• h - zatrzymaj/zatrzymaj robota

Między wysyłanymi poleceniami istnieje półsekundowy bufor opóźnienia. Zrobiłem to, aby wyeliminować niechciane powtarzające się polecenia. Możesz oczywiście usunąć to z kodu, jeśli chcesz (w index.html)

Reszta elementów sterujących i kontrolowanie ich powinna być oczywista.

Krok 13: Kod Pythona / Flask

Ten bot używa Pythona i frameworka Flask. Jeśli jesteś zainteresowany, możesz dowiedzieć się więcej o Flasku tutaj.

Dużą różnicą w stosunku do aplikacji Flask i zwykłego skryptu Pythona jest klasa/metoda @app.route używana do obsługi identyfikatora URI. Poza tym jest to w większości normalny Python.

#!/usr/bin/env python

# # Rover oparty na Wi-Fi/sieci # # Napisany przez Scotta Beasleya - 2015 # # Używa RPIO, pyserial i Flask # import time import serial z RPIO import PWM z flask import Flask, render_template, request app = Flask (_name_, static_url_path = '') # Połącz się z portem komunikacyjnym, aby porozmawiać ze sterownikiem silnika Roboclaw, spróbuj: # Zmień szybkość transmisji tutaj, jeśli jest inna niż 19200 roboclaw = serial. Serial ('/dev/ttyAMA0', 19200) z wyjątkiem IOError: print ("Port komunikacyjny nie znaleziono") sys.exit (0) # Zmienne prędkości i sterowania napędem last_direction = -1 speed_offset = 84 turn_tm_offset = 0,166 run_time = 0,750 # Serwo pozycja neutralna (home) servo_pos = 1250 servo = PWM. Servo () servo.set_servo (18, servo_pos) # Trochę czasu na ustalenie czasu przestoju time.sleep (3) # # Programy obsługi URI - wszystkie akcje strony botów są wykonywane tutaj # # Wyślij stronę kontroli botów (strona domowa) @app.route ("/") def index (): return render_template ('index.html', name = None) @app.route ("/forward") def forward (): globalny last_direction, run_ti me print "Forward" go_forward() last_direction = 0 # sleep 100ms + run_time time.sleep (0.100 + run_time) # Jeśli nie jest ciągły, zatrzymaj po opóźnieniu, jeśli run_time > 0: last_direction = -1 halt () return "ok" @ app.route ("/backward") def back (): globalny last_direction, run_time print "Backward" go_backward () last_direction = 1 # sleep 100ms + run_time time.sleep (0.100 + run_time) # Jeśli nie jest ciągły, zatrzymaj po opóźnieniu if run_time > 0: last_direction = -1 halt() return "ok" @app.route ("/left") def left (): globalny last_direction, turn_tm_offset print "Left" go_left() last_direction = -1 # sleep @1 /2 sekunda time.sleep (0.500 - turn_tm_offset) # stop halt() time.sleep (0.100) return "ok" @app.route ("/right") def right (): global last_direction, turn_tm_offset print "Right" go_right () # sleep @1/2 sekundy time.sleep (0.500 - turn_tm_offset) last_direction = -1 # stop halt () time.sleep (0.100) return "ok" @app.route ("/ltforward") def ltforward (): globalny ostatni_kierunek, turn_t m_offset print "Skręt w lewo do przodu" go_left () # sleep @1/8 sekundy time.sleep (0.250 - (turn_tm_offset / 2)) last_direction = -1 # stop halt () time.sleep (0.100) return "ok" @app.route ("/rtforward") def rtforward (): global last_direction, turn_tm_offset print "Skręt w prawo" go_right () # sleep @1/8 sekundy time.sleep (0.250 - (turn_tm_offset / 2)) last_direction = -1 # stop halt() time.sleep (0.100) return "ok" @app.route ("/stop") def stop(): globalny last_direction print "Stop" halt() last_direction = -1 # sleep 100ms time.sleep (0.100) return "ok" @app.route ("/panlt") def panlf (): global servo_pos print "Panlt" servo_pos -= 100 if servo_pos 2500: servo_pos = 2500 servo.set_servo (18, servo_pos) # sleep 150ms time. sleep (0.150) return "ok" @app.route ("/home") def home (): globalny servo_pos print "Home" servo_pos = 1250 servo.set_servo (18, servo_pos) # sleep 150ms time.sleep (0.150) return "ok" @app.route ("/panfull_lt") def panfull_lt (): global servo_pos print "Pan full l eft" servo_pos = 500 servo.set_servo (18, servo_pos) # sleep 150ms time.sleep (0.150) return "ok" @app.route ("/panfull_rt") def panfull_rt (): global servo_pos print "Pan full right" servo_pos = 2500 servo.set_servo (18, servo_pos) # sleep 150ms time.sleep (0.150) return "ok" @app.route ("/speed_low") def speed_low (): globalna prędkość_offset, last_direction, turn_tm_offset speed_offset = 42 turn_tm_offset = 0,001 # Zaktualizuj aktualny kierunek, aby uzyskać nową prędkość if last_direction == 0: go_forward () if last_direction == 1: go_backward () # sleep 150ms time.sleep (0.150) return "ok" @app.route ("/speed_mid") def speed_mid (): global speed_offset, last_direction, turn_tm_offset speed_offset = 84 turn_tm_offset = 0.166 # Zaktualizuj aktualny kierunek, aby uzyskać nową prędkość if last_direction == 0: go_forward () if last_direction == 1: go_backward () # sleep 150ms time.sleep (0.150) return "ok" @app.route ("/speed_hi") def speed_hi (): globalne speed_offset, last_direction, turn_tm_offset speed_offset = 126 tur n_tm_offset = 0.332 # Zaktualizuj aktualny kierunek, aby uzyskać nową prędkość if last_direction == 0: go_forward () if last_direction == 1: go_backward () # sleep 150ms time.sleep (0.150) return "ok" @app.route ("/continuous ") def Continuous (): global run_time print "Continuous run" run_time = 0 # sleep 100ms time.sleep (0.100) return "ok" @app.route ("/mid_run") def mid_run (): global run_time print "Mid run" run_time = 0.750 halt () # sleep 100ms time.sleep (0.100) return "ok" @app.route ("/short_time") def short_time (): global run_time print "Short run" run_time = 0.300 halt () # sleep 100ms time.sleep (0.100) return "ok" # # Funkcje napędu silnika # def go_forward (): globalne przesunięcie_prędkości jeśli przesunięcie_prędkości != 42: roboclaw.write (chr (1 + przesunięcie_prędkości)) roboclaw.write (chr (128 + speed_offset)) else: roboclaw.write (chr (127 - speed_offset)) roboclaw.write (chr (255 - speed_offset)) def go_backward (): globalne speed_offset jeśli speed_offset != 42: roboclaw.write (chr (127 - speed_offset)) roboclaw.wri te (chr (255 - speed_offset)) else: roboclaw.write (chr (1 + speed_offset)) roboclaw.write (chr (128 + speed_offset)) def go_left (): globalne speed_offset jeśli speed_offset != 42: roboclaw.write (chr (127 - speed_offset)) roboclaw.write (chr (128 + speed_offset)) else: roboclaw.write (chr (1 + speed_offset)) roboclaw.write (chr (255 - speed_offset)) def go_right (): globalne przesunięcie_prędkości, jeśli speed_offset != 42: roboclaw.write (chr (1 + speed_offset)) roboclaw.write (chr (255 - speed_offset)) w przeciwnym razie: roboclaw.write (chr (127 - speed_offset)) roboclaw.write (chr (128 + speed_offset)) def halt (): roboclaw.write (chr (0)) if _name_ == "_main_": app.run (host = '0.0.0.0', port = 80, debug = True)

Jeśli nie chcesz lub nie potrzebujesz informacji debugowania z Flask, ustaw debugowanie na „false” w wierszu app.run.

if _name_ == "_main_":

app.run (host = '0.0.0.0', port = 80, debug = False)

Możesz także zmienić port, na którym nasłuchuje serwer http Flask.

Krok 14: Korzystanie z innego sprzętu

Jeśli chcesz używać innego sprzętu, takiego jak inny typ SBC (komputer jednopłytkowy), powinieneś mieć niewielkie problemy z uruchomieniem Pythona i Flaska na innych płytach, takich jak Beagle Bone, PCDuino itp. Będziesz musiał zmienić kod, aby pasował do GPIO układ i wykorzystać możliwości serwonapędu nowej płyty.

Aby użyć innego typu sterownika silnika, wystarczy zmodyfikować funkcje go_forward, go_backward, go_left, go_right i halt, aby wykonać to, czego potrzebuje zastępczy sterownik silnika, aby silnik wykonał tę konkretną funkcję.