Kursy • Poradniki • Inspirujące DIY • Forum
Jeśli wszystko poszło zgodnie z planem, to w tej chwili każdy powinien mieć przed sobą złożonego robota, który potrafi już jeździć. Pora, aby nasz pojazd zaczął widzieć otoczenie!
Podczas tej części kursu wykorzystamy proste czujniki przeszkód. Dzięki nim robot będzie mógł poruszać się po nieznanym terenie!
Do tej pory nie powinniśmy nazywać naszego pojazdu robotem. Nie miał on żadnych czujników, więc nie mógł reagować na swoje otoczenie. Roboty charakteryzują się tym, że dzięki sensorom są autonomiczne (samodzielnie "podejmują" decyzje).
Oczywiście jest to dużym uproszczeniem. "Podejmowanie decyzji" polega na wykonywaniu działań zgodnie z napisanym przez człowieka algorytmem. Do prawdziwego podejmowania decyzji i sztucznej inteligencji jeszcze robotom daleko!
W konstrukcjach mobilnych najczęściej pojawiają się czujniki odległości/przeszkód. Sensory te pozwalają zachowywać bezpieczny odstęp od innych uczestników ruchu i zabezpieczają robota przed zderzeniem się z przeszkodami (np. ścianami).
Trzeba pamiętać, że czasami czujniki takie są wykorzystywane również do całkowicie odwrotnych zadań. Idealnym przykładem będą roboty startujące w zawodach Sumo (przykłady na forum), które wykorzystują sensory do zlokalizowania przeciwnika i wypchnięcia go poza planszę.
Komplet elementów Gwarancja pomocy Wysyłka w 24h
Części pozwalające wykonać ćwiczenia z kursu budowy robotów dostępne są w formie gotowych zestawów! W komplecie znajdują się elementy mechaniczne (w tym koła i silniki), baterie oraz shield!
Zamów w Botland.com.pl »Wykrywanie przeszkód można zrealizować na wiele sposobów. Przykładem może być optyczny czujnik, który budowaliśmy podczas kursu podstaw elektroniki (poziom II). Za pomocą generatora zbudowanego z NE555 sterowaliśmy diodą IR. Światło, które odbijało się od przeszkód trafiało do naszego odbiornika i było interpretowanego jako przeszkoda.
Dla przypomnienia:
Niewątpliwą zaletą powyższego rozwiązania jest to, że wykrywa ono przeszkodę bez fizycznego kontaktu. Jednak z drugiej strony czujnik ten ma stosunkowo wąski kąt widzenia.
W naszym robocie lepiej sprawdzi się prosty czujnik mechaniczny, który będzie mógł monitorować zarówno przód, jak i bok pojazdu. Jak działają sensory tego typu przeczytać można w osobnym artykule: microswitche jako proste czujniki przeszkód. To co najważniejsze, dla pewności, opisałem raz jeszcze w dalszej części tego tekstu.
W zestawach elementów do tego kursu znajdują się 2 przełączniki krańcowe z przylutowanymi przewodami. To właśnie one pozwolą nam wykrywać przeszkody:
Dwa czujniki krańcowe (krańcówki).
Od strony elektronicznej zasada działania tych krańcówek nie różni od zwykłych przycisków. Po wciśnięciu dźwigni (blaszki) następuje zwarcie sygnału wewnątrz przełącznika.
Kolor przewodów nie ma żadnego znaczenia
i może się różnić od tego ze zdjęcia.
Nasze krańcówki mają 3 wyprowadzenia (styki) opisane na obudowie w następujący sposób:
Przewody dolutowane są do wyprowadzenia C oraz NO. Oznacza to, że jeśli przycisk nie jest wciśnięty, to między naszymi wyprowadzeniami nie ma połączenia. Sygnał będzie mógł popłynąć od C do NO dopiero po wciśnięciu dźwigni przycisku.
Jego działanie jest więc identyczne do
zwykłych przycisków typu tactswitch/microswitch.
Gdybyśmy wykorzystali parę C oraz NC, to przycisk działałby odwrotnie. Sygnał mógłby płynąć od jednego wyprowadzenia, do drugiego tylko, gdy dźwignia nie byłaby wciśnięta. Dotknięcie przycisku powodowałoby rozwarcie wyprowadzeń.
Aby ułatwić montaż i pozycjonowanie krańcówek będziemy je mocować z wykorzystaniem małych elementów ze sklejki. Nie będziemy przekładać śrubek przez otwory znajdujące się w obudowie przełączników! Do zamontowania pierwszego czujnika potrzebne są następujące elementy:
Elementy konieczne do montażu czujnika.
Oczywiście nie ma jednego, słusznego miejsca do zamontowania czujników. Jest kilka wariantów, każdy ma swoje wady i zalety. Poniżej przedstawiam kilka możliwości wraz z ich krótkim opisem.
Podczas dalszych części kursu będziemy korzystać z jednego wariantu (nr 3), zachęcam jednak do testów we własnym zakresie! Dajcie znać w komentarzach jak sprawdzają się czujniki, gdy zamontujecie je w innych miejscach!
Przed przystąpieniem do montażu przeczytaj opis wszystkich wariantów,
aby później nie przekładać źle ustawionych czujników!
Pierwsza możliwość zamocowania czujników to ustawienie ich z przodu i skierowanych dźwigniami krańcówek na zewnątrz. Chodzi o takie ułożenie:
Pierwsza możliwość ułożenia czujników przeszkód.
Aby zamontować tak czujniki najwygodniej zacząć od przyłożenia elementów ze sklejki i wstępnego przykręcenia nakrętek. Podkładki należy dodać przy łbie śruby oraz przy nakrętce. Dopiero po takim wstępnym przymocowaniu przekładamy pod spodem czujnik:
Oczywiście analogicznie postępujemy z drugim czujnikiem. Przewody, dla większego porządku, warto przeciągnąć przez wcięcia znajdujące się w okolicy kół:
Sposób zamocowania przewodu.
Na koniec trzeba podłączyć przewody od krańcówek. W tym celu korzystamy z dwóch złącz, które zostały umieszczone na płytce z myślą o czujnikach. Dokładne informacje na ten temat znajdują się w drugiej części kursu budowy robotów.
Jedno z wyprowadzeń krańcówki podłączamy do pinu opisanego jako GND, a drugie do A0/A1. Kolejność przewodów nie ma żadnego znaczenia! Poprawne podłączenie:
Podłączenie przewodów od czujników.
Dla przypomnienia, ten wariant zakłada następujące ułożenie czujników:
Ustawienie czujników zgodnie z wariantem nr 1.
Jak widać takie rozstawienie czujników sprawia, że dźwignie krańcówek dobrze reagowałyby na przeszkody znajdujące się po lewej i prawej stronie robota. Niestety stosunkowo wąska noga od stołu, w którą robot wjechałby prosto, od przodu nie zostałaby wychwycona (żadna z dźwigni nie byłaby wtedy wciśnięta).
Sposób montażu krańcówek za pomocą sklejki, jak i prowadzenie przewodów jest identyczne, jak w pierwszym sposobie. Jednak tym razem nasze dźwignie kierujemy do środka:
Ustawienie czujników zgodnie z wariantem nr 2.
Tym razem środek jest pilnowany zdecydowanie lepiej. Tracimy jednak kontrolę nad bokami robota. W takiej konfiguracji możemy zahaczyć kołami o przeszkody, które nie będą wychwytywane przez czujniki. Pora więc na 3 wariant...
Wcześniejsze metody mocowania czujników mają wadę - za każdym razem należy wybierać, czy bardziej zależy nam na obserwacji boków robota, czy jego przodu. Oczywiście najlepiej byłoby, aby nasze czujniki miały jeszcze dłuższe ramiona. Ciężko jednak znaleźć w sprzedaży krańcówki z jeszcze dłuższymi dźwigniami.
Budując roboty często improwizować i radzić sobie za pomocą rzeczy, które mamy pod ręką. Teraz wykorzystamy fragmenty opasek zaciskowych i rurki termokurczliwe!
Pierwszy krok to odcięcie zbędnego fragmentu opaski zaciskowej. W części zestawów zostało to już zrobione, więc krok ten oczywiście dotyczy tylko osób, które otrzymały całe opaski. Plastik jest na tyle miękki, że opaskę można przeciąć nawet nożyczkami.
Usunięcie zbędnego fragmentu opaski zaciskowej.
Podczas kolejnego kroku potrzebna będzie rurka termokurczliwa, która po podgrzaniu zmniejsza swoją średnicę (kurczy się). Za pomocą nożyczek odcinamy 2 cm rurki, a następnie nakładamy ją na dźwignię czujnika. Oczywiście wkładamy tam również odciętą wcześniej opaskę zaciskową.
W rurkę termokurczliwą wsuwamy grubszą część opaski (tą z ząbkami),
cieńsza końcówka (bez ząbków) od teraz zostanie przedłużonym końcem czujnika.
Szczegóły na poniższych zdjęciach!
Teraz należy ogrzać rurkę (aby się zacisnęła), najlepiej zrobić to nad zapalniczką, świeczką lub korzystając z lutownicy typu hotair (dmuchającej gorącym powietrzem). Oczywiście konieczna jest ostrożność, aby nie stopić opaski i nie zrobić sobie krzywdy - uwaga na oparzenia!
Młodszym czytelnikom polecam skorzystać z pomocy kogoś dorosłego!
Tak przedłużonych czujników nie możemy zamocować w sposób opisany w 1 wariancie, ponieważ będą one na siebie nachodzić. Jednak korzystając z tego, że dźwignie krańcówek są teraz bardzo długie możemy je skrzyżować. Dzięki temu możliwe będzie wykrywanie przeszkód po bokach robota, a jednocześnie nie stracimy możliwości obserwacji przodu - sytuacja idealna!
Skrzyżowanie dźwigni od czujników.
Trzeba pamiętać, że takie ułożenie wprowadza małe "zamieszanie".
Teraz czujnik przykręcony po prawej stronie będzie informował nas
o przeszkodach, które są po lewej stronie robota!
Oczywiście w związku z wydłużonymi dźwigniami nie możemy zamontować krańcówek tak, jak robiliśmy to poprzednio, ponieważ będą się dotykać opaskami. Rozwiązanie jest bardzo proste. Wystarczy jeden czujnik przykręcić od góry, a drugi od dołu:
Podczas dalszych testów proponuję zacząć właśnie od takiego ułożenia czujników. Jednak, tak jak wspomniałem wcześniej - zachęcam później do testowania innych sposobów mocowania!
Pora sprawdzić, jak nasze czujniki działają w praktyce. Na początku prosty program, który przez UART wyświetli informację na temat stanu sensorów. Szkic jest bardzo prosty i chyba nie wymaga tłumaczenia. Po prostu sprawdzamy stan wejść i na tej podstawie wyświetlamy komunikaty.
Oznaczenia lewej/prawej strony robota przyjąłem zgodnie z literami L i R,
które są wygrawerowane na podwoziu robota.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
#define L_SIDE_SENSOR A0 #define R_SIDE_SENSOR A1 void setup() { Serial.begin(9600); //Start komunikacji przez UART pinMode(L_SIDE_SENSOR, INPUT_PULLUP); //Konfiguracja pinu jako wejście pinMode(R_SIDE_SENSOR, INPUT_PULLUP); //Konfiguracja pinu jako wejście } void loop() { if (digitalRead(L_SIDE_SENSOR) == LOW) { Serial.println("Wykryto przeszkode po lewej stronie!"); } if (digitalRead(R_SIDE_SENSOR) == LOW) { Serial.println("Wykryto przeszkode po prawej stronie!"); } delay(500); //Opoznienie dla zwiekszenia czytelnosci komunikatow } |
Zadaniem dodanego opóźnienia jest ograniczenia ilości komunikatów trafiających do komputera w momencie, gdy trzymamy wciśnięty przycisk. W praktyce działanie układu wygląda następująco:
Sposobów na omijanie przeszkód jest wiele i na pewno każdy z Was wypracuje swoje rozwiązanie. Poniżej przedstawiam moje propozycje takiego programu. Na początku zaczynam od szkicu, który powstał w poprzednim odcinku kursu. Dodałem jedynie do niego informację na temat czujników oraz buzzera, który będzie pomocny podczas testów.
Nowe linie zostały podświetlone w poniższym kodzie:
|
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 |
#define L_PWM 5 #define L_DIR 4 #define R_PWM 6 #define R_DIR 9 #define PWM_MAX 165 #define L_SIDE_SENSOR A0 #define R_SIDE_SENSOR A1 #define BUZZER 10 void setup() { //Konfiguracja pinow od mostka H pinMode(L_DIR, OUTPUT); pinMode(R_DIR, OUTPUT); pinMode(L_PWM, OUTPUT); pinMode(R_PWM, OUTPUT); //Konfiguracja pinow od czujnikow pinMode(L_SIDE_SENSOR, INPUT_PULLUP); pinMode(R_SIDE_SENSOR, INPUT_PULLUP); //Konfiguracja pozostalych elementow pinMode(BUZZER, OUTPUT); digitalWrite(BUZZER, 0); //Wylaczenie buzzera } void loop() { //Jedz do przodu leftMotor(40); rightMotor(40); } void leftMotor(int V) { if (V > 0) { //Jesli predkosc jest wieksza od 0 (dodatnia) V = map(V, 0, 100, 0, PWM_MAX); digitalWrite(L_DIR, 0); //Kierunek: do przodu analogWrite(L_PWM, V); //Ustawienie predkosci } else { V = abs(V); //Funkcja abs() zwroci wartosc V bez znaku V = map(V, 0, 100, 0, PWM_MAX); digitalWrite(L_DIR, 1); //Kierunek: do tyłu analogWrite(L_PWM, V); //Ustawienie predkosci } } void rightMotor(int V) { if (V > 0) { //Jesli predkosc jest wieksza od 0 (dodatnia) V = map(V, 0, 100, 0, PWM_MAX); digitalWrite(R_DIR, 0); //Kierunek: do przodu analogWrite(R_PWM, V); //Ustawienie predkosci } else { V = abs(V); //Funkcja abs() zwroci wartosc V bez znaku V = map(V, 0, 100, 0, PWM_MAX); digitalWrite(R_DIR, 1); //Kierunek: do tyłu analogWrite(R_PWM, V); //Ustawienie predkosci } } void stopMotors() { analogWrite(L_PWM, 0); //Wylaczenie silnika lewego analogWrite(R_PWM, 0); //Wylaczenie silnika prawego } |
Powyższy program po uruchomieniu robota sprawi, że będzie on jechał cały czas do przodu. W pętli głównej trzeba teraz dodać warunek korzystający z czujników. Na początku proponuję wykonywać identyczną reakcję dla każdego z nich:
|
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 |
#define L_PWM 5 #define L_DIR 4 #define R_PWM 6 #define R_DIR 9 #define PWM_MAX 165 #define L_SIDE_SENSOR A0 #define R_SIDE_SENSOR A1 #define BUZZER 10 void setup() { //Konfiguracja pinow od mostka H pinMode(L_DIR, OUTPUT); pinMode(R_DIR, OUTPUT); pinMode(L_PWM, OUTPUT); pinMode(R_PWM, OUTPUT); //Konfiguracja pinow od czujnikow pinMode(L_SIDE_SENSOR, INPUT_PULLUP); pinMode(R_SIDE_SENSOR, INPUT_PULLUP); //Konfiguracja pozostalych elementow pinMode(BUZZER, OUTPUT); digitalWrite(BUZZER, 0); //Wylaczenie buzzera } void loop() { //Jedz do przodu leftMotor(40); rightMotor(40); if (digitalRead(L_SIDE_SENSOR) == LOW || digitalRead(R_SIDE_SENSOR) == LOW) { //Jesli przeszkoda po dowolnej stronie //Jedz wstecz i wydawaj dzwiek leftMotor(-40); rightMotor(-40); digitalWrite(BUZZER, 1); delay(800); //Obrot w miejscu leftMotor(40); rightMotor(-40); digitalWrite(BUZZER, 0); delay(500); //Koniec warunku wracamy do jazdy prosto } } void leftMotor(int V) { if (V > 0) { //Jesli predkosc jest wieksza od 0 (dodatnia) V = map(V, 0, 100, 0, PWM_MAX); digitalWrite(L_DIR, 0); //Kierunek: do przodu analogWrite(L_PWM, V); //Ustawienie predkosci } else { V = abs(V); //Funkcja abs() zwroci wartosc V bez znaku V = map(V, 0, 100, 0, PWM_MAX); digitalWrite(L_DIR, 1); //Kierunek: do tyłu analogWrite(L_PWM, V); //Ustawienie predkosci } } void rightMotor(int V) { if (V > 0) { //Jesli predkosc jest wieksza od 0 (dodatnia) V = map(V, 0, 100, 0, PWM_MAX); digitalWrite(R_DIR, 0); //Kierunek: do przodu analogWrite(R_PWM, V); //Ustawienie predkosci } else { V = abs(V); //Funkcja abs() zwroci wartosc V bez znaku V = map(V, 0, 100, 0, PWM_MAX); digitalWrite(R_DIR, 1); //Kierunek: do tyłu analogWrite(R_PWM, V); //Ustawienie predkosci } } void stopMotors() { analogWrite(L_PWM, 0); //Wylaczenie silnika lewego analogWrite(R_PWM, 0); //Wylaczenie silnika prawego } |
Po wykryciu przeszkody robot delikatnie się cofnie, następnie obróci i pojedzie dalej. Oczywiście polecenie jazdy prosto mogłoby znajdować się w drugiej części warunku (po dodanym else). Nie jest to jednak konieczne, ponieważ komenda jazdy prosto wydawana jest w każdym obiegu pętli bez żadnego opóźnienia. Gdy tylko czujniki wykryją przeszkodę robot przechodzi do instrukcji, które są wewnątrz warunku. Po wykonaniu manewru obrotu robot będzie jechał dalej prosto.
Działanie tego prostego mechanizmu w praktyce widoczne jest na poniższym filmie:
Delikatne podskoki robota spowodowane są szybką zmianą kierunku, w którym jedzie. W celu usunięcia tego problemu wystarczy zmniejszyć trochę prędkość jazdy.
Robot nie korzysta jeszcze z informacji o położeniu przeszkody, więc zawsze skręca w tę samą stronę. Regulując czas jazdy w tył oraz czas obrotu można uzyskać inne zachowanie robota. Im obroty będą dłuższe, tym jazda będzie bardziej chaotyczna - zachęcam do testów.
Nie należy jednak przesadzać z jazdą wstecz. Pamiętajmy, że cofanie dobywa się na sztywno, bez żadnych czujników. W ciasnych miejscach może prowadzić to do taranowania przeszkód tyłem!
Dla lepszego efektu wykorzystajmy teraz informacje na temat poszczególnych czujników. Jeśli przeszkoda będzie po lewej, to będziemy skręcać w prawo (aby ominąć blokadę). Analogicznie w przypadku wykrycia czegoś po prawej stronie będziemy skręcać lewo.
|
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 |
#define L_PWM 5 #define L_DIR 4 #define R_PWM 6 #define R_DIR 9 #define PWM_MAX 165 #define L_SIDE_SENSOR A0 #define R_SIDE_SENSOR A1 #define BUZZER 10 void setup() { //Konfiguracja pinow od mostka H pinMode(L_DIR, OUTPUT); pinMode(R_DIR, OUTPUT); pinMode(L_PWM, OUTPUT); pinMode(R_PWM, OUTPUT); //Konfiguracja pinow od czujnikow pinMode(L_SIDE_SENSOR, INPUT_PULLUP); pinMode(R_SIDE_SENSOR, INPUT_PULLUP); //Konfiguracja pozostalych elementow pinMode(BUZZER, OUTPUT); digitalWrite(BUZZER, 0); //Wylaczenie buzzera } void loop() { //Jedz do przodu leftMotor(40); rightMotor(40); if (digitalRead(L_SIDE_SENSOR) == LOW) { //Jesli przeszkoda po lewej stronie //Jedz wstecz i wydawaj dzwiek leftMotor(-40); rightMotor(-40); digitalWrite(BUZZER, 1); delay(800); //Obrot w miejscu w prawo leftMotor(40); rightMotor(-40); digitalWrite(BUZZER, 0); delay(140); //Koniec warunku wracamy do jazdy prosto } if (digitalRead(R_SIDE_SENSOR) == LOW) { //Jesli przeszkoda po prawej stronie //Jedz wstecz i wydawaj dzwiek leftMotor(-40); rightMotor(-40); digitalWrite(BUZZER, 1); delay(800); //Obrot w miejscu w lewo leftMotor(-40); rightMotor(40); digitalWrite(BUZZER, 0); delay(140); //Koniec warunku wracamy do jazdy prosto } } void leftMotor(int V) { if (V > 0) { //Jesli predkosc jest wieksza od 0 (dodatnia) V = map(V, 0, 100, 0, PWM_MAX); digitalWrite(L_DIR, 0); //Kierunek: do przodu analogWrite(L_PWM, V); //Ustawienie predkosci } else { V = abs(V); //Funkcja abs() zwroci wartosc V bez znaku V = map(V, 0, 100, 0, PWM_MAX); digitalWrite(L_DIR, 1); //Kierunek: do tyłu analogWrite(L_PWM, V); //Ustawienie predkosci } } void rightMotor(int V) { if (V > 0) { //Jesli predkosc jest wieksza od 0 (dodatnia) V = map(V, 0, 100, 0, PWM_MAX); digitalWrite(R_DIR, 0); //Kierunek: do przodu analogWrite(R_PWM, V); //Ustawienie predkosci } else { V = abs(V); //Funkcja abs() zwroci wartosc V bez znaku V = map(V, 0, 100, 0, PWM_MAX); digitalWrite(R_DIR, 1); //Kierunek: do tyłu analogWrite(R_PWM, V); //Ustawienie predkosci } } void stopMotors() { analogWrite(L_PWM, 0); //Wylaczenie silnika lewego analogWrite(R_PWM, 0); //Wylaczenie silnika prawego } |
Najgorszy możliwy wariant w takiej sytuacji, to zaklinowanie się robota w narożniku. Będzie wtedy odbijał raz w lewo, raz w prawo i tak w koło. Można starać się tak dobrać czas jazdy wstecz/obrotu, aby zniwelować takie prawdopodobieństwo, ale jeszcze lepiej będzie dodać element losowy!
Najprościej zacząć od losowego czasu obrotu, czyli w praktyce losowy będzie kąt, o który obróci się robot po "odbiciu" od przeszkody. Dla widocznych zmian warto zacząć od dodatkowego opóźnienia np. 50-200 ms.
Pierwsza myśl, to zastosowanie funkcji random w następujący sposób:
|
1 |
int los = random(50, 201); |
Otrzymamy wtedy losowe wartości z założonego zakresu, jednak w większości przypadków nie będą one miały znacznego wpływu na zachowanie robota. Obrót przez 100 lub 102 ms nie będzie się od siebie w praktyce niczym różnił (różnica w czasie będzie za mała).
Lepiej będzie losować wartości o większym zróżnicowaniu (np. minimum co 10 ms). W tym celu wystarczy losować wartości z zakresu 5 - 20, a następnie wynik ten mnożyć przez 10. W praktyce wylosowanie 5 da nam 5 * 10 = 50 ms, a wylosowanie 6, da 6 * 10 = 60 ms.
|
1 |
int los = random(5, 21) * 10; //Dodajemy losowo od 50 do 200 ms obrotu |
Tak obliczoną wartość dodajemy do czasu obrotu. Oczywiście należy też pamiętać o inicjalizacji generatora liczb pseudolosowych! Więcej informacji o funkcji random podałem w kursie Arduino.
|
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 |
#define L_PWM 5 #define L_DIR 4 #define R_PWM 6 #define R_DIR 9 #define PWM_MAX 165 #define L_SIDE_SENSOR A0 #define R_SIDE_SENSOR A1 #define BUZZER 10 void setup() { //Konfiguracja pinow od mostka H pinMode(L_DIR, OUTPUT); pinMode(R_DIR, OUTPUT); pinMode(L_PWM, OUTPUT); pinMode(R_PWM, OUTPUT); //Konfiguracja pinow od czujnikow pinMode(L_SIDE_SENSOR, INPUT_PULLUP); pinMode(R_SIDE_SENSOR, INPUT_PULLUP); //Konfiguracja pozostalych elementow pinMode(BUZZER, OUTPUT); digitalWrite(BUZZER, 0); //Wylaczenie buzzera randomSeed(analogRead(5)); //Inicjalizacja generatora } void loop() { //Jedz do przodu leftMotor(30); rightMotor(30); int los = random(5, 20) * 10; //Dodajemy losowo od 50 do 200 ms obrotu if (digitalRead(L_SIDE_SENSOR) == LOW) { //Jesli przeszkoda po lewej stronie //Jedz wstecz i wydawaj dzwiek leftMotor(-30); rightMotor(-30); digitalWrite(BUZZER, 1); delay(300); //Jazda po łuku leftMotor(30); rightMotor(-30); digitalWrite(BUZZER, 0); delay(140+los); //Koniec warunku wracamy do jazdy prosto } if (digitalRead(R_SIDE_SENSOR) == LOW) { //Jesli przeszkoda po prawej stronie //Jedz wstecz i wydawaj dzwiek leftMotor(-30); rightMotor(-30); digitalWrite(BUZZER, 1); delay(300); //Jazda po łuku leftMotor(-30); rightMotor(30); digitalWrite(BUZZER, 0); delay(140+los); //Koniec warunku wracamy do jazdy prosto } } void leftMotor(int V) { if (V > 0) { //Jesli predkosc jest wieksza od 0 (dodatnia) V = map(V, 0, 100, 0, PWM_MAX); digitalWrite(L_DIR, 0); //Kierunek: do przodu analogWrite(L_PWM, V); //Ustawienie predkosci } else { V = abs(V); //Funkcja abs() zwroci wartosc V bez znaku V = map(V, 0, 100, 0, PWM_MAX); digitalWrite(L_DIR, 1); //Kierunek: do tyłu analogWrite(L_PWM, V); //Ustawienie predkosci } } void rightMotor(int V) { if (V > 0) { //Jesli predkosc jest wieksza od 0 (dodatnia) V = map(V, 0, 100, 0, PWM_MAX); digitalWrite(R_DIR, 0); //Kierunek: do przodu analogWrite(R_PWM, V); //Ustawienie predkosci } else { V = abs(V); //Funkcja abs() zwroci wartosc V bez znaku V = map(V, 0, 100, 0, PWM_MAX); digitalWrite(R_DIR, 1); //Kierunek: do tyłu analogWrite(R_PWM, V); //Ustawienie predkosci } } void stopMotors() { analogWrite(L_PWM, 0); //Wylaczenie silnika lewego analogWrite(R_PWM, 0); //Wylaczenie silnika prawego } |
Przykład kilku przejazdów mojego robota z wykorzystaniem powyższego kodu:
Zachęcam do eksperymentów z czasami cofania i obrotów. Warto również wykorzystać inne ruchy robota np.: jazda po łuku. Pochwalcie się filmami w komentarzach, jak Wasze konstrukcje radzą sobie z omijaniem przeszkód, które stawiacie na ich drodze!
W powyższych programach nie sprawdzaliśmy nigdy, czy oba czujniki wykryły jednocześnie coś na drodze naszego robota. Oczywiście można połączyć dwa warunki (za pomocą &&) i czekać na sytuację, w której robot wjedzie idealnie prosto w przeszkodę. Arduino sprawdza stany wejść dość często (miliony razy na sekundę), wciśnięcie obu czujników jednocześnie będzie zdarzało się więc bardzo, bardzo rzadko.
Najczęściej, któryś z czujników wykryje przeszkodę minimalnie szybciej od drugiego!
Oprócz zmiany programu warto też obserwować zachowanie czujników. Jeśli nasze przedłużone dźwignie krańcówki będą za długie lub zbyt krótkie, to również będzie to negatywnie wpływało na działanie robota.
Oprócz długości dźwigni warto sprawdzić kąty pod jakimi ustawione są czujnikami, czasami drobna zmiana w mocowaniu może wpłynąć na działanie całej konstrukcji. Oczywiście sensory nie muszą być ustawione symetrycznie - można również sprawdzić jak robot będzie radził sobie z omijaniem przeszkód, gdy każdy z czujników będzie ustawiony inaczej.
Tak jak wspomniałem w poprzedniej części kursu - nie trzeba martwić się tym, że robot "nie potrafi" jechać idealnie do przodu. Po dodaniu czujników może on reagować na otoczenie i wprowadzać poprawki do swojej trasy w zależności od napotkanych przeszkód.
W kolejnym odcinku kursu budowy robotów zajmiemy się wykorzystaniem czujników optycznych. Zbudujemy światłoluba, czyli robota, który jedzie w stronę najsilniejszego źródła światła. W praktyce oznacza to możliwość sterowania robota za pomocą latarki!
Autor kursu: Damian (Treker) Szymański
arduino, kurs, kursBudowyRobotow, programowanie, robot
Dołącz do 20 tysięcy osób, które otrzymują powiadomienia o nowych artykułach! Zapisz się, a otrzymasz PDF-y ze ściągami (m.in. na temat mocy, tranzystorów, diod i schematów) oraz listę inspirujących DIY z Arduino i RPi.
Trwa ładowanie komentarzy...