Zdalnie sterowany po WiFi robot z użyciem Raspberry Pi
Elektronika

Zdalnie sterowany po WiFi robot z użyciem Raspberry Pi

20141123_113735-e1416740068909

 

Prawie każdy wie, że transformacja faceta w dziecko potrafi zostać zainicjowana klockami LEGO lub czymś co świeci, jeździ i ma w sobie dużo kabelków. W dobie dzisiejszej technologii spokojnie jesteśmy sobie w stanie sami wykonywać takowe zabawki. Bazując na platformie Raspberry Pi rozbudowanej o trochę fajnych rzeczy postaram się przedstawić krok po kroku jak stać się ojcem jeżdżącej platformy na podwoziu czołgu, sterowanej za pomocą dowolnego komputera w sieci. W dodatku powstały pojazd będzie miał sporo możliwości rozbudowy, ale o tym już dalej. Zapraszam więc!

 

Przygotowania

Potrzebować będziemy:

  1. Raspberry Pi
    Bardzo przyjemna płytka pozwalająca na całkiem sporo rzeczy. Myślę, że dokładniejszy opis jest zbędny – całkiem sporo rzeczy można o niej wyczytać w necie. Ja korzystam z wersji B (512MB RAM) i systemu Raspbian.
  2. Moduł WiFi do Raspberry Pi.
    Przyda się żeby nie latać za maszyną z kablem.
  3. PowerBank
    Zwykły, czy to do telefonu, czy do tabletu – byleby dawał 5V i min. 2A. Osobiście korzystam z pqi power 7800mAh (pomimo 1.5A max. daje rade).
  4. Sterownik silników TB6612FNG
    Moduł dwukanałowy o maksymalnym ciągłym prądzie 1A/kanał. Na początek zdecydowanie wystarczająco.
  5. Dodatki
    Potrzebować też będziemy trochę przewodów połączeniowych (męsko-męskich jak i żeńsko-męskich), jakąś małą płytkę stykową, koszyk na baterie (choć równie dobrze można je połączyć “na krótko” ja zdecydowałem się wykorzystać coś, co mi zapewni pewien porządek na platformie) no i oczywiście 4 baterie AA.
  6. Podwozie
    …zostało żywcem wyciągnięte z mojej starej zabawki. Ma silniczki, gąsienice – jeździć będzie.
CzęśćCenaLinkIlość sztuk
Raspberry Pi (dowolna wersja, ja korzystam z wersji B)179,00http://botland.com.pl/moduly-glowne-i-zestawy-raspberry-pi/972-raspberry-pi-model-b-512mb-ram.html1
Sterownik silników TB6612FNG18,90http://botland.com.pl/sterowniki-silnikow-moduly/32-tb6612-dwukanalowy-sterownik-silnikow-modul-pololu.html1
Moduł WiFi34,90http://botland.com.pl/akcesoria-usb-raspberry-pi/1316-karta-sieciowa-wifi-usb-nano-standard-n-tl-wn725n-tp-link-raspberry-pi.html1
Mała płytka stykowa7,50http://botland.com.pl/plytki-stykowe/1250-plytka-stykowa-170-otworow-zielona.html1
Przewody połączeniowe męsko-męskie13,90http://botland.com.pl/przewody-polaczeniowe/1022-przewody-polaczeniowe-mesko-meskie-65szt.html1
Przewody połączeniowe żeńsko-męskie6,90http://botland.com.pl/przewody-polaczeniowe/1400-przewody-polaczeniowe-zesko-meskie-20cm-czerwone-10szt.html2
Podwozie razem z silniczkami z odzysku01
Koszyk na baterie 4xAA1,50http://botland.com.pl/koszyki-na-baterie/173-koszyk-na-4-baterie-typu-aa-r6.html1
Bateria AA4
PowerBank80,00http://www.ceneo.pl/209790631

Co do zasilania silniczków to powiem tak, bezpiecznym wyjściem jest zastosowanie połączenia 4xAA (NiMH) gdyż otrzymamy w ten sposób max. 5V. Gdyby było to za mało, wystarczy rozszerzyć pakiet o dodatkowe dwie bateryjki i już powinny silniczki chodzić bez problemu (większość silniczków DC toleruje 7-12V). U mnie 4x2200mAh wystarcza na kilkanaście minut jeżdżenia po całym mieszkaniu.

Sam zaczynałem wzorując się na dziele Cyryla i jego SPiBot’a i nie ukrywam, że bardzo mi to ułatwiło zadanie. Z tego miejsca też pragnę mu bardzo podziękować za wskazówki i wszelką pomoc przy tworzeniu. Zacznijmy więc!

Kabelki, kabelki, kabelki!

Na samym początku ważne jest połączenie przewodów. Do naszego sterownika dołączona jest instrukcja logiczna (tabela prawdy) oraz opis płytki:

Instrukcja logiczna:

 

 

Najpierw podłączmy silniczki i zasilanie silników do sterownika. W tym celu łączymy:

  • – (minus) koszyczka baterii z pinem GND znajdującym się po lewo na dole płytki (pod VMOT);
  • + (plus) koszyczka baterii z pinem VMOT;
  • Przewód pierwszy pierwszego silnika z pinem AIN1
  • Przewód drugi pierwszego silnika z pinem AIN2
  • Przewód pierwszy drugiego silnika z pinem BIN1
  • Przewód drugi drugiego silnika z pinem BIN2

Ponownie sprawdzamy, czy wszystko jest ok i idziemy dalej. Ważne jest żeby w przypadku podziału na pierwszy i drugi przewód silnika obrać dla obydwu ten sam. Oszczędzi to nam później mieszania w kodzie. Korzystając z okazji wyjaśnię działanie pinu STBY. W momencie, gdy jest ustawiony na nim stan wysoki to maszyna będzie jeździć. Gdy jest stan niski to mimo wydawania poleceń nic się nie stanie. Piny PWMA i PWMB odpowiadają w naszym przypadku – najprościej mówiąc – za prędkość.

 

Teraz podłączamy sterownik do Raspberry.

  • STBY łączymy z PIN17
  • VCC łączymy z PIN 3,3V
  • GND łączymy z PIN GND ponad VCC

Dla prawego silniczka:

  • PWMA łączymy z PIN18
  • AIN1 łączymy z PIN23
  • AIN2 łączymy z PIN24

Dla lewego silniczka:

  • PWMB łączymy z PIN25
  • BIN1 łączymy z PIN21
  • BIN2 łączymy z PIN22

I kwestię połączeniową mamy z głowy! Plątanina kabli powinna wyglądać mniej-więcej tak:

 

20141123_105143

 

Czas na serce robota – program

Jak łatwo się domyślić, nasz robot nie będzie jeszcze na tym etapie na tyle autonomiczny, by samemu obierać kierunek podróży. W celu zapanowania nad nim posłużymy się programem napisanym w pythonie. Będziemy do tego potrzebowali komendy sudo oraz pakietu RPi.GPIO.

UWAGA!

Przedstawiony poniżej kod może nie działać poprawnie z uwagi na brak odpowiedniego formatowania. Proponuję skorzystać z bardzo podobnego, prostszego kodu umieszczonego w podobnym projekcie (klik).

  1. Tworzymy nowy plik – nazwijmy go rc.py: 
    sudo nano rc.py
  2. Następnie wczytujemy RPi.GPIO oraz kilka dodatkowych składników, które umożliwią nam korzystanie z klawiatury do sterowania: 
    import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
import sys, tty, termios, time
GPIO.setup(18, GPIO.OUT)
GPIO.setup(25, GPIO.OUT)
GPIO.setup(23, GPIO.OUT)
GPIO.setup(24, GPIO.OUT)
GPIO.setup(21, GPIO.OUT)
GPIO.setup(22, GPIO.OUT)
GPIO.setup(17, GPIO.OUT)
  3. Dodajemy moduł odpowiedzialny za klawisze: 
    def getch():
fd = sys.stdin.fileno()
old_settings = termios.tcgetattr(fd)
try:
tty.setraw(sys.stdin.fileno())
ch = sys.stdin.read(1)
finally:
termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
return ch
  4. Upewniamy się, że nic nam samo nie odjedzie: 
    GPIO.output(23, False)
GPIO.output(24, False)
GPIO.output(21, False)
GPIO.output(22, False)
GPIO.output(17, False)
  5. Wyświetlamy na ekranie instrukcję sterowania: 
    print("######################################################")
print("#                                                    #")
print("#            / \                                     #")
print("#           | W |            |E| - zasilanie on      #")
print("#                            |R| - zasilanie off     #")
print("#   <| A |  | S |  | D |>                            #")
print("#            \ /             |X| - system off        #")
print("#                                                    #")
print("#                                                    #")
print("#  1(100) / 2(150) / 3(200) / 4(250)                 ")
print("#                        v0.1 02/09/14(c)letsmakeit.pl #")
print("######################################################")
  6. Ustawiamy cycle dla silników (dla ciekawskich odsyłam do wiki RPi.GPIO): 
    p1cycle = 50
p2cycle = 50
  7. Najważniejszy element – sterowanie: 
    while True:char = getch()if(char == "1"):
p1cycle = 30
p2cycle = 30if(char == "2"):
p1cycle = 50
p2cycle = 50

if(char == "3"):
p1cycle = 70
p2cycle = 70

if(char == "4"):
p1cycle = 90
p2cycle = 90

if(char == "w"):
GPIO.output(23, 1)
GPIO.output(24, 0)
#lewa gasienica
GPIO.output(21, 0)
GPIO.output(22, 1)
#jazda
p1.start(p1cycle)
p2.start(p2cycle)

if(char == "s"):
GPIO.output(23, 0)
GPIO.output(24, 0)
#lewa gasienica
GPIO.output(21, 0)
GPIO.output(22, 0)
#jazda
p1.start(0)
p2.start(0)

if(char == "a"):
#prawa gasienica
GPIO.output(23, 1)
GPIO.output(24, 0)
#lewa gasienica
GPIO.output(21, 0)
GPIO.output(22, 0)
#jazda
p1.start(p1cycle)
p2.start(0)

if(char == "d"):
#prawa gasienica
GPIO.output(23, 0)
GPIO.output(24, 0)
#lewa gasienica
GPIO.output(21, 0)
GPIO.output(22, 1)
#jazda
p1.start(0)
p2.start(p2cycle)

# SYSTEM ONLINE
if(char == "e"):
GPIO.output(17, 1)
print("System online")

# SYSTEM OFFLINE
if(char == "r"):
GPIO.output(17, 0)
print("System offline")

if(char == "x"):
GPIO.output(17, 0)
print("Sterownik zatrzymany!")
break
  8. I dla bezpieczeństwa – zatrzymanie silników po wyłączeniu programu (na wypadek gdyby np. utracić połączenie po WiFi): 
    p1.stop()
p2.stop()char = ""GPIO.cleanup()

 

A poniżej kod w całości.

Sterowanie robotem
################################
# STEROWNIK ROBOTA JEZDZACEGO  #
#  (c) SEBASTIANCHINOWSKI.PL   #
################################
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
import sys, tty, termios, time
GPIO.setup(18, GPIO.OUT)
GPIO.setup(25, GPIO.OUT)
GPIO.setup(23, GPIO.OUT)
GPIO.setup(24, GPIO.OUT)
GPIO.setup(21, GPIO.OUT)
GPIO.setup(22, GPIO.OUT)
GPIO.setup(17, GPIO.OUT)
p1 = GPIO.PWM(18, 200)
p2 = GPIO.PWM(25, 200)
p1.ChangeDutyCycle(100)
p2.ChangeDutyCycle(100)

def getch():
fd = sys.stdin.fileno()
old_settings = termios.tcgetattr(fd)
try:
tty.setraw(sys.stdin.fileno())
ch = sys.stdin.read(1)
finally:
termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
return ch

GPIO.output(23, False)
GPIO.output(24, False)
GPIO.output(21, False)
GPIO.output(22, False)
GPIO.output(17, False)

print("######################################################")
print("#                                                    #")
print("#            / \                                     #")
print("#           | W |            |E| - zasilanie on      #")
print("#                            |R| - zasilanie off     #")
print("#   <| A |  | S |  | D |>                            #")
print("#            \ /             |X| - system off        #")
print("#                                                    #")
print("#                                                    #")
print("#  1(100) / 2(150) / 3(200) / 4(250)                 #")
print("#                        v0.1 2/9/14(c)letsmakeit.pl #")
print("######################################################")

p1cycle = 50
p2cycle = 50

while True:

char = getch()

if(char == "1"):
p1cycle = 30
p2cycle = 30

if(char == "2"):
p1cycle = 50
p2cycle = 50

if(char == "3"):
p1cycle = 70
p2cycle = 70

if(char == "4"):
p1cycle = 90
p2cycle = 90

if(char == "w"):
GPIO.output(23, 1)
GPIO.output(24, 0)
#lewa gasienica
GPIO.output(21, 0)
GPIO.output(22, 1)
#jazda
p1.start(p1cycle)
p2.start(p2cycle)

if(char == "s"):
GPIO.output(23, 0)
GPIO.output(24, 0)
#lewa gasienica
GPIO.output(21, 0)
GPIO.output(22, 0)
#jazda
p1.start(0)
p2.start(0)

if(char == "a"):
#prawa gasienica
GPIO.output(23, 1)
GPIO.output(24, 0)
#lewa gasienica
GPIO.output(21, 0)
GPIO.output(22, 0)
#jazda
p1.start(p1cycle)
p2.start(0)

if(char == "d"):
#prawa gasienica
GPIO.output(23, 0)
GPIO.output(24, 0)
#lewa gasienica
GPIO.output(21, 0)
GPIO.output(22, 1)
#jazda
p1.start(0)
p2.start(p2cycle)

# SYSTEM ONLINE
if(char == "e"):
GPIO.output(17, 1)
print("System online")

# SYSTEM OFFLINE
if(char == "r"):
GPIO.output(17, 0)
print("System offline")

if(char == "x"):
GPIO.output(17, 0)
print("Sterownik zatrzymany!")
break

p1.stop()
p2.stop()

char = ""

GPIO.cleanup()

Kliknij tu aby pobrać plik bezpośrednio.

Rozwiń - zignoruj informację o nieaktualności kodu
Pokaż mniej

Ruszamy!

Na początku najlepiej upewnić się, że wszystko jest dobrze połączone. Następnie wkładamy baterie do koszyczka i podpinamy PowerBank do Raspberry.

Gdy już zalogujemy się przez SSH, wklepujemy:

sudo python rc.py

I naszym oczom powinna ukazać się instrukcja sterowania. Oznacza to, że kod działa poprawnie i możemy w sumie śmigać! W tym celu naciskamy E w celu ustawienia pinu STBY w stan wysoki. Klawisze W / A / D odpowiadają za CIĄGŁĄ jazdę w danym kierunku. Klawisz S odpowiada za zatrzymanie się. Czołg powinien jeździć w każdym kierunku ale niestety ja uszkodziłem swój sterownik i nie mam możliwości.. cofania. Dlatego nie uwzględniłem tego w programie. Poniżej krótki filmik z małej podróży po podłodze (ponieważ nie miałem naładowanych baterii, skorzystałem z pakietu LiPo 3S – dało to trochę kopa ale sterownik nie jest przystosowany do natężenia prądu >1A i mimo wszystko lepiej jest użyć baterii).

 

%d bloggers like this: