Zainspirowany kursem budowy robotów FORBOT jak i ElektroPrzewodnikiem postanowiłem skonstruować prostego i taniego dwukołowca, którego można sterować smartfonem przez WiFi. Opiszę tutaj proces budowy tego pojazdu w wersji sterowanej z wykorzystaniem aplikacji Blynk oraz przy założeniu, że pojazd znajduje się w zasięgu sieci WiFi (np. domowej). Założenie to upraszcza proces sterowania robotem, gdyż nie wymaga logowania się do AP (Access Point) tworzonego przez ESP8266 i sprawia że kod programu jest prosty. Wadą tego rozwiązania jest to, że nie można z robotem wyjść w teren.
Spis części
Do zbudowania prostego pojazdu potrzeba:
- Podwozie robota 2WD dwukołowe z silnikami – np. https://botland.com.pl/podwozia-robotow/7283-podwozie-robota-2wd-dwukolowe-z-silnikami-prostokatne.html – ja używałem podwozia z zestawu Kurs budowy robota FORBOT
- Dodatkowy koszyk na baterie do zasilania ESP – np. https://botland.com.pl/koszyki-na-baterie/236-koszyk-na-4-baterie-typu-aa-r6-z-pokrywa-i-wlacznikiem.html
- Moduł WiFi ESP-12E ESP8266 – np. https://botland.com.pl/moduly-wifi/7381-modul-wifi-esp-12e-esp8266-black-adapter-254mm.html
- Dwukanałowy sterownik silników – np. https://botland.com.pl/sterowniki-silnikow-dc/851-pololu-drv8835-dwukanalowy-sterownik-silnikow-11v12a.html
- Konwerter USB-UART do zaprogramowania ESP – np. https://botland.com.pl/konwertery-usb-uart-rs232-rs485/4925-konwerter-usb-uart-cp2102-gniazdo-miniusb.html
- Stabilizator napięcia 3,3V do zasilania ESP – np. https://botland.com.pl/regulatory-napiecia/126-stabilizator-ldo-33v-lf33cv.html
- Oraz przewody połączeniowe, kondensator elektrolityczny 2.2uF, dwa kondensatory ceramiczny 100nF, rezystor 10kOhm.
Całość powinna nas wynieść ok. 110 zł (bez baterii lub akumulatorków)
Przygotowanie
Do zaprogramowani dwukołowca będziemy potrzebowali środowiska Arduino IDE (najnowsza wersja do ściągnięcia na stronie: https://www.arduino.cc/en/Main/Software).
Aby móc w tym środowisku używać ESP8266 należy doinstalować odpowiednią bibliotekę. W tym celu należy w menu programu Arduino IDE wybrać File–>Preferences i w okienku ‘Additional Boards Manager URLs‘ wpisać: http://arduino.esp8266.com/stable/package_esp8266com_index.json.(patrz rys. 1)
Rys. 1 Okno Preferences w Arduino IDE
Następnie wybieramy w menu Tools–>Board–>Boards Manager, wpisujemy w okno wyszukiwania ‘ESP8266’ i instalujemy bibliotekę esp8266 (patrz rys. 2).
Rys. 2 Okno Boards Manager w Arduino IDE
Aby móc obsługiwać robota przy użyciu aplikacji Blynk należy zainstalować do środowiska Arduino IDE bibliotekę dla tego programu zgodnie z instrukcją ze strony producenta: http://www.blynk.cc/getting-started/. W skrócie: należy ściągnąć ZIPA z bibliotekami i zawartość skopiować do katalogu gdzie zainstalowane jest Arduino IDE.
Programowanie ESP8266
W celu wgrania programu (o którym w dalszej części opisu) do ESP8266 należy podłączyć je przez USB-UART do komputera według schematu przedstawionego na rys. 3.
Rys. 3 Schemat podłączenia ESP-12E (ESP8266) w celu wgrania programu
Czyli:
- UART VCC — ESP VCC
- UART GND — ESP GND
- UART TXD — ESP RXD
- UART RXD — ESP TXD
- ESP GPIO0 — GND (tylko do programowania)
Należy mieć na uwadze to, że zasilanie jedynie przez USB-UART może nie wystarczyć dlatego dobrze jest dołączyć dodatkowe zasilanie. Ja zrobiłem to używając dodatkowego modułu zasilającego do płytki stykowej. Trzeba pamiętać, że ESP zasilać należy napięciem ok. 3.3 V (przy większych napięciach może ulec uszkodzeniu).
Po poprawnym podłączeniu ESP włączamy zasilanie (niebieska dioda w ESP powinna raz mignąć) i podłączamy USB-UART do portu USB w komputerze. W programie Arduino IDE wybieramy w menu Tools–>Board–>Generic ESP8266 Module oraz w menu Tools–>Port wybieramy odpowiedni port (COM’XX‘), do którego podłączony jest nasz programator USB-UART. Dodatkowo w menu Tools ustawiamy Flash size: “4M (1M SPIFFS)” lub Flash size: “4M (3M SPIFFS)”. Resztę ustawień możemy pozostawić bez zmian (u mnie: Flash mode: “DIO”, Flash Frequency: “40MHz”, CPU Frequency: “80MHz”, Debug port: “Disable”, Debug Level: “None”, Reset Method: “ck”, Upload Speed: “115200”).
Podłączenie ESP do mostka H
Po wgraniu programu (o którym w dalszej części opisu) do ESP8266 należy połączyć je ze sterownikiem silników według schematu przedstawionego na rys. 4.
Rys. 4 Schemat podłączenia ESP do sterownika silników
Czyli GPIO2 i GPIO4 będą sterować kanałem B, natomiast GPIO13 i GPIO14 będą sterować kanałem A. Podanie stanu wysokiego na wejście MODE sterownika powoduje że będzie on działał w trybie PHASE/ENABLE.
I tyle. U mnie połączenie wygląda jak na rys. 5.
Rys. 5 Połączenie ESP do sterownika silników
Aplikacja Blynk
Po zainstalowaniu aplikacji należy stworzyć nowy projekt pod nazwą np. ‘samochod’ i wstawić z bocznego menu jeden przycisk, jeden suwak pionowy i jeden suwak poziomy jak pokazano na rys. 6.
Rys. 6 Aplikacja Blynk – projekt
Następnie wprowadzamy ustawienia dodanych elementów. Przycisk powinien zwracać wartość 1 lub 0 na wirtulanym pinie V0. Suwak pionowy będzie zwracać wartości z zakresu (-100,100) na wirtualnym pinie V1 a suwak poziomy wartości (-50,50) na wirtulanym pinie V2 (patrz rys. 7).
Rys. 7 Aplikacja Blynk – ustawienia
Program
Kod programu z komentarzami znajduje się poniżej. W programie założono że sterowanie odbywać się będzie z aplikacji Blynk.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 |
#define BLYNK_PRINT Serial // Umożliwia włączenie monitora szeregowego (opcjonalne) #include <ESP8266WiFi.h> #include <BlynkSimpleEsp8266.h> char auth[] = "................."; // Token otrzymany w mailu od aplikacji Blynk char ssid[] = "........";// Nazwa sieci, do której nasz ESP się dołączy char pass[] = "........";// Hasło do tej sieci #define Lewy_PWM 2 #define Lewy_KIERUNEK 4 #define Prawy_PWM 12 #define Prawy_KIERUNEK 14 #define Maksymalny_PWM 160 // Ograniczenie "mocy" silników int suwak_PT = 0, suwak_LP = 0; // zmienne dla suwaka PrzódTył oraz LewoPrawo int motor_Lewy = 0, motor_Prawy = 0; int stan = 0; void setup() { Serial.begin(9600); // Obserwowanie połączenia w monitorze szeregowym Blynk.begin(auth, ssid, pass); // Konfiguracja pinów od mostka H pinMode(Lewy_KIERUNEK, OUTPUT); pinMode(Prawy_KIERUNEK, OUTPUT); pinMode(Lewy_PWM, OUTPUT); pinMode(Prawy_PWM, OUTPUT); analogWriteFreq(20000); analogWriteRange(150); } BLYNK_WRITE(V1) { int PT = param.asInt(); // pobranie wartości z pinu V1 suwak_PT=PT; } BLYNK_WRITE(V2) { int LP = param.asInt(); // pobranie wartości z pinu V2 suwak_LP=LP; } BLYNK_WRITE(V0) { int S = param.asInt(); // pobranie wartości z pinu V0 stan=S; } // zakładam że suwaki w aplikacji Blynk ustawione są: // PrzódTył od -100 do 100 // LewyPrawy od -50 do 50 void loop() { if (stan==1) { motor_Lewy = suwak_PT-suwak_LP; motor_Prawy = suwak_PT+suwak_LP; lewyMotor(motor_Lewy); prawyMotor(motor_Prawy); } else { stopMotory(); } Blynk.run(); } void lewyMotor(int V) { if (V > 0){ digitalWrite(Lewy_KIERUNEK, 0); //Kierunek do przodu } else{ digitalWrite(Lewy_KIERUNEK, 1); //Kierunek do tyłu } V=abs(V); V = map(V, 0 , 150, 0, Maksymalny_PWM); // Mapowanie prędkości analogWrite(Lewy_PWM, V); //Ustawienie prędkości } void prawyMotor(int V) { if (V > 0){ digitalWrite(Prawy_KIERUNEK, 0); //Kierunek do przodu } else{ digitalWrite(Prawy_KIERUNEK, 1); //Kierunek do tyłu } V=abs(V); V = map(V, 0 , 150, 0, Maksymalny_PWM); // Mapowanie prędkości analogWrite(Prawy_PWM, V); //Ustawienie prędkości } void stopMotory(){ analogWrite(Lewy_PWM,0); analogWrite(Prawy_PWM,0); } |
Pojazd w akcji
Złożony i zaprogramowany pojazd w akcji można zobaczyć na filmie:
Bardzo dokładnie wszystko opisane, na pewno się przyda gdy będę zabierał się za podobne projekty :D
Trochę namieszałeś przy podłączaniu ESP.
Zastosowany przez Ciebie adapter ma już dwa rezystory, łączące GPIO15 do masy oraz CH_PD do Vcc (trzeci rezystor to po prostu zwora 0Ω na zasilaniu) – czyli oba piny należy zostawić niepodłączone. Do prawidłowego działania należy podłączyć GPIO0 do VCC poprzez rezystor (np. 10k), a tylko na czas programowania zwierać go do masy. RST jeśli go nie używamy można podłączyć do CH_PD, lub również przez rezystor do Vcc.
Co do ustawień Arduino: chyba też o czymś zapomniałeś. Oprócz portu należy ustawić ilość pamięci Flash. W przypadku ESP-12E możesz użyć 4M/3M lub 4M/1M – przy domyślnych ustawieniach (512k) są niewielkie szanse na działanie. Reszta ustawień może być domyślna.
Popraw artykuł, to wtedy ocenię.
Dzięki za uwagi. Sprawdzę wieczorem i wprowadzę poprawki.
“przy domyślnych ustawieniach (512k) są niewielkie szanse na działanie”
Nigdy nie miałem problemu przez wielkość flash. Zobacz tu:
https://github.com/esp8266/Arduino/issues/314
“If you build the sketch with a linker script for 512k flash and the upload it to 1M flash, it will run.”
Niestety – kilka razy pomyliłem się i załadowałem szkic dla 512k, nie miał najmniejszego zamiaru działać.
Czyli jak zmieniłeś rozmiar flasha (i tylko to), zadziałało?
Czy używałeś jakiegoś bardzo dużego programu (wiele bibliotek)?
Bardzo dziwne, jak napisałem nigdy nie miałem problemu z ustawieniem rozmiaru flash i sami developerzy Arduino dla ESP8266 twierdzą, że będzie działać.
Dokładnie, tylko to.
Tak jak pisałem – omyłkowo zostawiłem ze dwa czy trzy razy 512k (często zmieniam ustawienia między ESP8266 a UNO/Pro, a Arduino IDE nie zawsze pamięta poprzednie ustawienia po ponownej zmianie). Efekt – upload poszedł normalnie, natomiast po uruchomieniu mogłem podziwiać efekty działania watchdoga.
Od tej pory po prostu zwracam uwagę na ustawienia po przełączeniu.
Nie wnikałem w szczegóły, ale może jest jakaś znacząca różnica między 4M a 1M/512k. Zresztą developerzy o ile zauważyłem twierdzili że będzie działać na 1M a nie pisali nic o 4M, poza tym twierdzili dwa lata temu – a w światku ESP8266 Arduino czas płynie bardzo szybko :)
Co do wielkości – nic poważnego, szkic po skompilowaniu miał jakiś 230 k, czyli bez problemu powinien się zmieścić.
Sprawdziłem i wprowadziłem poprawki: dodałem opis ustawień Arduino, usunąłem zbędne połączenia do GPIO15 i CH_PD oraz dodałem połączenie GPIO0 do VCC przez rezystor. Oprócz opisu zaktualizowałem rys. 3, 4 i 5. Zmieniłem również sposób zasilania sterownika silników. Teraz zasilam go bezpośrednio z 6V (można do 2V do 7V). Dla lepszej stabilności dodałem również kondensator 100nF przed podłączeniem do ESP zgodnie z sugestią na stronie: https://github.com/esp8266/Arduino/blob/master/doc/boards.md
Mam nadzieje, że teraz wygląda lepiej. Jeszcze raz dziękuję za uwagi.
Jest OK – masz obiecaną ocenę :)
A takie pytanie. Czy nie warto pokombinować i spróbować ustawić ESP jako AP i się z nim łączyć przez telefon i wtedy zadziała to w terenie?
Oczywiście można tak zrobić. Tylko kod programu się trochę skomplikuje i aby sterować pojazdem trzeba się będzie logować do sieci utworzonej przez ESP. Ale, tak jak piszesz, zaletą będzie możliwość wyjścia w teren. Właśnie, w ramach zabawy, obudowuje silniki i sterownik klockami Lego, oraz używam Wemosa (który własnie dotarł z Chin) aby ograniczyć ilość okablowania i mam zamiar wrzucić niedługo opis wersji pojazdu, który będzie mógł działać w terenie.
Oczywiście można, jednak alternatywą jest stworzenie hotspota w telefonie, a kod ustawić na łączenie się do tego właśnie hotspota, dzięki czemu robot może znajdować się nawet 20m i będzie można nim sterować. Jeżeli w czymś się mylę to proszę mnie poprawić 😉
Witam, wysłałem do Pana PW
W tekście i na schemacie do sterowania kanałem A (silnik lewy) wymienione są piny 13 i 14, za to na zdjęciu po złożeniu oraz w kodzie są to piny 12 i 14. Po za tym projekt spoko. Udało się odtworzyć z drobną modyfikacją – zrobiliśmy cztereokołowca po jednym silniku na koło. Silniki połączone po dwa równolegle pod jeden kanał sterownika. Tylko przy wstrząsach lubi się rozłączać bateryjka w koszyku i ESP uruchamia się od nowa.