- Moduł czujnika prędkości LM393 (H206)
- Układ mocowania czujnika H206
- DIY Arduino LM393 Schemat obwodu robota czujnika prędkości
- Logika pomiaru prędkości z modułem czujnika prędkości LM393
- Logika pomiaru odległości przebytej przez koło
- Logika stojąca za pomiarem kąta bota
- Kod robota Arduino
- Testowanie robota Arduino pod kątem pomiaru odległości, prędkości i kąta
Roboty powoli zaczęły wkradać się do naszego społeczeństwa, aby ułatwić nam życie. Na drogach Wielkiej Brytanii możemy już znaleźć sześć kołowych robotów do dostarczania żywności z Starship, inteligentnie nawigujących wśród cywilów, aby dotrzeć do celu. Każdy robot mobilny, który odnajduje się w otoczeniu, powinien zawsze mieć świadomość swojego położenia i orientacji w stosunku do świata rzeczywistego. Można to osiągnąć na wiele sposobów, używając różnych technologii, takich jak GPS, triangulacja RF, akcelerometry, żyroskopy itp. Każda technika ma swoje zalety i jest wyjątkowa. W tym samouczku czujnika prędkości Arduino LM393 użyjemy prostego i łatwo dostępnego modułu czujnika prędkości LM393do pomiaru niektórych ważnych parametrów, takich jak prędkość, przebyta odległość i kąt robota za pomocą Arduino. Dzięki tym parametrom robot będzie mógł poznać swój stan rzeczywisty i będzie mógł go używać do bezpiecznej nawigacji.
Arduino to najpopularniejszy wybór wśród hobbystów do budowy robotów, od prostego śledzącego linię po bardziej złożonego robota samobalansującego lub do czyszczenia podłóg. Możesz sprawdzić wszystkie rodzaje robotów w sekcji Robotyka.
Zbudujemy małego robota zasilanego baterią litową i będziemy nim sterować za pomocą joysticka. W trakcie pracy możemy mierzyć prędkość, odległość i kąt robota i wyświetlać je w czasie rzeczywistym na wyświetlaczu LCD podłączonym do Arduino. Ten projekt pomaga tylko w mierzeniu tych parametrów, a kiedy już to zrobisz, możesz użyć tych parametrów do autonomicznej obsługi robota zgodnie z wymaganiami. Brzmi interesująco, prawda? Więc zacznijmy.
Moduł czujnika prędkości LM393 (H206)
Zanim przejdziemy do schematu obwodu i kodu projektu, zrozummy moduł czujnika prędkości LM393, ponieważ odgrywa on istotną rolę w projekcie. Przez moduł H206 Czujnik prędkości składa się z promieniowania podczerwonego czujnik zintegrowany z komparatora LM393 napięcia IC stąd nazwa czujnika LM393 Speed. Moduł składa się również z płyty kratowej, którą należy zamontować na obrotowym wale silnika. Wszystkie komponenty są oznaczone na poniższym obrazku.
Czujnik podczerwonego składa się z diody IR i fototranzystor oddzielone małą GAB. Cały układ czujnika jest umieszczony w czarnej obudowie, jak pokazano powyżej. Płyta kratowa składa się ze szczelin, płyta jest umieszczona między szczeliną czujnika światła podczerwonego w taki sposób, że czujnik może wykryć szczeliny w płycie siatki. Każda szczelina w płycie siatki uruchamia czujnik podczerwieni podczas przechodzenia przez szczelinę; te wyzwalacze są następnie przekształcane na sygnały napięciowe za pomocą komparatora. Komparator to nic innego jak układ scalony LM393 z półprzewodników ON. Moduł posiada trzy piny, z których dwa służą do zasilania modułu, a jeden pin wyjściowy służy do zliczania liczby wyzwalaczy.
Układ mocowania czujnika H206
Montaż tego typu czujników jest nieco trudny. Może być montowany tylko do silników, które mają wał wystający z obu stron. Jedna strona wału jest połączona z kołem, a druga strona służy do montażu płyty kratowej, jak pokazano powyżej.
Ponieważ koło i tarcza są połączone z tym samym wałem, oba obracają się z tą samą prędkością, a zatem mierząc prędkość płyty, możemy zmierzyć prędkość koła. Upewnij się, że szczeliny w płycie siatki przechodzą przez czujnik podczerwieni, tylko wtedy czujnik będzie mógł policzyć liczbę szczelin, które przeszły. Możesz również wymyślić własną mechaniczną konfigurację do montażu czujnika, o ile spełnia on określony warunek. Czujnik podczerwieni jest powszechnie używany w wielu projektach robotyki do kierowania robotem na przeszkody.
Pokazana powyżej płyta siatkowa ma 20 szczelin (kratek). Oznacza to, że czujnik znajdzie 20 przerw na jeden pełny obrót koła. Licząc liczbę przerw, które wykrył czujnik, możemy obliczyć odległość przebytą przez koło, podobnie mierząc, jak szybko czujnik znajduje przerwy, możemy wykryć prędkość koła. W naszym robocie będziemy mieli ten czujnik zamontowany na obu kołach, dzięki czemu możemy również znaleźć kąt robota. Jednak kąt obrotu można rozsądniej obliczyć za pomocą akcelerometru lub żyroskopu, dowiedz się tutaj, jak połączyć akcelerometr i żyroskop z Arduino i spróbować zmierzyć za ich pomocą kąt obrotu.
DIY Arduino LM393 Schemat obwodu robota czujnika prędkości
Pełny schemat obwodu tego robota wykrywającego prędkość i odległość przedstawiono poniżej. Bot składa się z Arduino Nano jako jego mózgu, dwa silniki prądu stałego dla kół są napędzane przez moduł sterownika silnika mostka H L298N. Joystick służy do sterowania prędkością i kierunkiem robota, a dwa czujniki prędkości H206 służą do pomiaru prędkości, odległości i anioła robota. Zmierzone wartości są następnie wyświetlane w module LCD 16x2. Potencjometr podłączony do wyświetlacza LCD może służyć do regulacji kontrastu wyświetlacza LCD, a rezystor służy do ograniczenia prądu płynącego do podświetlenia wyświetlacza LCD.
Kompletny obwód zasilany przez komórkę 7.4V litu. To 7,4 V jest dostarczane do styku 12 V modułu sterownika silnika. Następnie regulator napięcia w module sterownika silnika przekształca napięcie 7,4 V na regulowane + 5 V, które służy do zasilania Arduino, LCD, czujników i joysticka.
Silnik jest sterowany przez piny cyfrowe 8,9,10 i 11 Arduino. Ponieważ prędkość silnika również musi być kontrolowana, należy dostarczyć sygnały PWM do dodatniego zacisku silnika. Stąd mamy pin 9 i 10, które są pinami obsługującymi PWM. Wartości X i Y z joysticka są odczytywane za pomocą odpowiednio pinów analogowych A2 i A3.
Jak wiemy, czujnik H206 generuje wyzwalanie, gdy zostanie wykryta szczelina w płycie siatki. Ponieważ te wyzwalacze nie zawsze powinny być dokładnie odczytywane, aby obliczyć prawidłową prędkość i odległość, oba piny wyzwalacza (wyjściowe) są podłączone do pinów 2 i 3 zewnętrznego przerwania na płycie Arduino. Zmontuj cały obwód na podwoziu i zamontuj czujnik prędkości jak wyjaśniono, mój bot wyglądał jak poniżej po wykonaniu połączeń. Możesz również obejrzeć film na końcu tej strony, aby dowiedzieć się, jak zamontowano czujnik.
Teraz, gdy część sprzętowa jest ukończona, przejdźmy do logiki tego, jak będziemy mierzyć prędkość, odległość i pojedynczą część bota, a następnie przejdźmy do sekcji programowania.
Logika pomiaru prędkości z modułem czujnika prędkości LM393
Z konfiguracji montażu czujnika należy pamiętać, że moduł czujnika prędkości LM393 (H206) mierzy tylko szczeliny obecne w płycie kratki. Podczas montażu należy upewnić się, że koło (którego prędkość należy mierzyć) i tarcza krata obracają się z taką samą prędkością. Tak jak tutaj, ponieważ zamontowaliśmy koło i tarczę na tym samym wale, oczywiście oba będą się obracać z tą samą prędkością.
W naszym zestawie zamontowaliśmy po dwa czujniki na każde koło, aby zmierzyć kąt nachylenia bota. Ale jeśli Twoim celem jest pomiar tylko prędkości i dystansu, możemy zamontować czujnik na dowolnym kole. Wyjście czujnika (sygnały wyzwalające) będzie najczęściej podłączane do zewnętrznego pinu przerywającego mikrokontrolera. Za każdym razem, gdy zostanie wykryta przerwa w płycie siatki, zostanie wyzwolone przerwanie i zostanie wykonany kod w ISR (procedura obsługi przerwania). Jeśli jesteśmy w stanie obliczyć odstęp czasu między dwoma takimi wyzwalaczami, możemy obliczyć prędkość koła.
W Arduino możemy łatwo obliczyć ten przedział czasu za pomocą funkcji millis () . Ta funkcja milisek będzie zwiększać się o 1 na każdy milisekundę od momentu włączenia zasilania urządzenia. Tak więc, gdy wystąpi pierwszy przerwania możemy zapisać wartość Millis () w zmiennej manekina (jak pevtime w tym kodzie), a następnie, gdy druga przerwanie występuje możemy obliczyć czas potrzebny przez odjęcie pevtime wartość tworzą millis ().
Zajęty czas = aktualny czas - poprzedni czas zajęty w czasie = milis () - pevtime ; // czas pobrany w milisekundach
Po obliczeniu zajętego czasu możemy po prostu obliczyć wartość obrotów na minutę za pomocą poniższych wzorów, gdzie (1000 / pobrany czas) daje RPS (obroty na sekundę) i jest mnożone przez 60, aby zamienić RPS na obroty na minutę (obroty na minutę).
rpm = (1000 / czas) * 60;
Po obliczeniu obrotów możemy obliczyć prędkość pojazdu korzystając z poniższych wzorów pod warunkiem, że znamy promień koła.
Prędkość = 2π × RPS × promień koła. v = promień_koła * obr / min * 0,104
Uwaga, powyższy wzór służy do obliczania prędkości wm / s, jeśli chcesz obliczyć w km / h, zamień 0,0104 na 0,376. Jeśli jesteś ciekawy, jak uzyskano wartość 0,104, spróbuj uprościć wzór V = 2π × RPS × promień koła.
Ta sama technika jest stosowana, nawet jeśli do pomiaru prędkości obracającego się obiektu używany jest czujnik Halla. Ale dla czujnika H206 jest zaczep, płyta kratowa ma 20 szczelin, a zatem do pomiaru czasu między dwoma szczelinami szczelinowymi spowoduje przeciążenie mikrokontrolera. Dlatego prędkość mierzymy tylko przy pełnym obrocie koła. Ponieważ dla każdej przerwy zostaną wygenerowane dwa przerwania (jedno na początku i drugie na końcu przerwy) , otrzymamy łącznie 40 przerwań, aby koło wykonało jeden pełny obrót. Więc czekamy na 40 przerwań, zanim faktycznie obliczymy prędkość koła. Kod tego samego jest pokazany poniżej
if (rotacja> = 40) { timaken = millis () - pevtime; // czas pobrany w milisekundach rpm = (1000 / pobrany czas) * 60; // formuły do obliczania rpm pevtime = millis (); obrót = 0; }
Inną wadą tej metody jest to, że wartość prędkości nie spadnie do zera, ponieważ przerwanie będzie zawsze czekać, aż koło zakończy jeden obrót w celu obliczenia wartości obrotów. Wadę tę można łatwo przezwyciężyć, dodając prosty kod, który monitoruje odstęp czasu między dwoma przerwaniami, a jeśli przekracza on normalnie, możemy wymusić wartość obrotów i prędkości na zero. Link w poniższym kodzie użyliśmy zmiennej dtime, aby sprawdzić różnicę w czasie i jeśli przekracza 500 milisekund, wartość prędkości i obrotów jest wymuszana na zero.
/ * Aby spaść do zera, jeśli pojazd się zatrzymał * / if (millis () - dtime> 500) // nie znaleziono przerwania przez 500 ms { rpm = v = 0; // ustaw obroty i prędkość na zero dtime = millis (); }
Logika pomiaru odległości przebytej przez koło
Wiemy już, że Arduino wyczuje 40 przerwań, gdy koło wykona jeden pełny obrót. Zatem dla każdego obrotu wykonanego przez koło jest oczywiste, że odległość przebyta przez koło jest równa obwodowi koła. Ponieważ znamy już promień koła, możemy łatwo obliczyć pokonaną odległość korzystając z poniższego wzoru
Odległość = 2πr * liczba obrotów odległość = (2 * 3,141 * promień_kola) * (left_intr / 40)
Gdzie obwód koła oblicza się ze wzoru 2πr, a następnie mnoży się przez liczbę obrotów wykonanych przez koło.
Logika stojąca za pomiarem kąta bota
Istnieje wiele sposobów na określenie anioła robota. Do określenia tych wartości zwykle używa się akcelerometrów i żyroskopów. Ale innym tanim podejściem jest użycie czujnika H206 na obu kołach. W ten sposób wiedzielibyśmy, ile obrotów wykonuje każde koło. Poniższy rysunek ilustruje sposób obliczania kąta.
Podczas inicjalizacji robota przyjmuje się, że kąt, do którego jest skierowany, wynosi 0 °. Stamtąd obraca się w lewo, kąt jest zwiększany ujemnie, a jeśli obraca się w prawo, anioł jest zwiększany dodatnio. Dla zrozumienia rozważmy zakres od -90 do +90, jak pokazano na rysunku. W takim układzie ponieważ oba koła mają tę samą średnicę, jeśli któreś z kół wykona pełny obrót robotem obrócimy się pod kątem 90 °.
Na przykład, jeśli lewe koło wykona jeden pełny obrót (80 przerw), robot obróci się o 90 ° w lewo i podobnie, jeśli prawe koło wykona jeden pełny obrót (80 przerw), robot obróci się o -90 ° w prawo. Teraz wiemy, że jeśli Arduino wykryje 80 przerwań na jednym kole, to bot obrócił się o 90 ° i na podstawie którego koła możemy stwierdzić, czy bot skręcił o dodatni (prawy) czy ujemny (lewy). Więc lewy i prawy kąt można obliczyć za pomocą poniższych wzorów
int angle_left = (left_intr% 360) * (90/80); int angle_right = (right_intr% 360) * (90/80);
Gdzie 90 to kąt pokonywany podczas wykonywania przerwania o wartości 80. Wynikowa wartość jest pomnożoną liczbą przerwań. Użyliśmy również modułu 360, aby wynikowa wartość nigdy nie przekraczała 36. Po obliczeniu zarówno lewego, jak i prawego kąta, efektywny kąt, pod którym zwrócony jest robot, można po prostu otrzymać odejmując lewy kąt od prawego.
kąt = kąt_prawo - kąt_left;
Kod robota Arduino
Pełny kod Arduino dla tego robota do pomiaru prędkości i kąta znajduje się na końcu tej strony. Zadaniem programu jest obliczenie prędkości, dystansu i kąta robota na podstawie powyższej logiki i wyświetlenie tego na ekranie LCD. Poza tym powinien dawać możliwość sterowania botem za pomocą joysticka.
Program rozpoczynamy od zdefiniowania pinów Digital I / O dla dwóch silników. Zwróć uwagę, że musimy również kontrolować prędkość silnika i dlatego musimy użyć pinów PWM na Arduino do sterowania silnikami. Tutaj użyliśmy pinów 8,9,10 i 11.
# zdefiniować LM_pos 9 // lewy silnik # zdefiniować LM_neg 8 // lewy silnik # zdefiniować RM_pos 10 // prawy silnik # zdefiniować RM_neg 11 // prawy silnik # zdefiniować radośćX A2 # zdefiniować radośćY A3
Aby zmierzyć prędkość i pokonaną odległość, musimy znać promień koła, zmierzyć wartość i wpisać ją w metrach, jak pokazano poniżej. Dla mojego bota promień wynosił 0,033 metra, ale dla ciebie może się różnić w zależności od twojego bota.
float radius_of_wheel = 0,033; // Zmierz promień swojego koła i wprowadź go tutaj w cm
W funkcji konfiguracji inicjalizujemy wszystkie wartości na zero, a następnie wyświetlamy tekst wprowadzający na wyświetlaczu LCD. Zainicjowaliśmy również monitor szeregowy w celu debugowania. Następnie wspomnieliśmy, że czujniki prędkości H206 są podłączone do pinu 2 i 3 jako zewnętrzne przerwania. To jest wszędzie tam, gdzie wykryte zostanie przerwanie, funkcja ISR Left_ISR i Right_ISR zostaną odpowiednio wykonane.
void setup () { rotacja = rpm = pevtime = 0; // Zainicjuj wszystkie zmienne na zero Serial.begin (9600); lcd.begin (16, 2); // Inicjalizacja 16 * 2 LCD lcd.print ("Bot Monitor"); // Intro Message line 1 lcd.setCursor (0, 1); lcd.print ("- CircuitDigest"); // Intro Message line 2 delay (2000); lcd.clear (); lcd.print ("Lt: Rt:"); lcd.setCursor (0, 1); lcd.print ("S: D: A:"); pinMode (LM_pos, OUTPUT); pinMode (LM_neg, OUTPUT); pinMode (RM_pos, OUTPUT); pinMode (RM_neg, OUTPUT); digitalWrite (LM_neg, LOW); digitalWrite (RM_neg, LOW); attachInterrupt (digitalPinToInterrupt (2), Left_ISR, CHANGE); // Left_ISR jest wywoływane po uruchomieniu czujnika lewego koła attachInterrupt (digitalPinToInterrupt (3), Right_ISR, CHANGE); // Right_ISR jest wywoływane po wyzwoleniu prawego czujnika koła }
Wewnątrz procedury Left_ISR po prostu zwiększamy zmienną o nazwie left_intr, która będzie później używana do pomiaru kąta bota. Wewnątrz Right_ISR robimy to samo, ale dodatkowo obliczamy tutaj prędkość. Zmienna rotacja jest zwiększana dla każdego przerwania, a następnie powyższa logika jest używana do obliczenia prędkości.
void Left_ISR () { left_intr ++; opóźnienie (10); } void Right_ISR () { right_intr ++; opóźnienie (10); rotacja ++; dtime = millis (); if (rotacja> = 40) { timaken = millis () - pevtime; // czas pobrany w milisekundach rpm = (1000 / pobrany czas) * 60; // formuły do obliczania rpm pevtime = millis (); obrót = 0; } }
Wewnątrz głównej funkcji nieskończonej pętli monitorujemy wartości X i Y z joysticka. Na podstawie wartości, jeśli poruszamy joystickiem, odpowiednio sterujemy botem. Szybkość bota zależy od tego, jak daleko wciśnięty jest joystick.
int xValue = analogRead (joyX); int yValue = analogRead (joyY); przyspieszenie int = map (xValue, 500, 0, 0, 200); if (xValue <500) { analogWrite (LM_pos, przyspieszenie); analogWrite (RM_pos, przyspieszenie); } else { analogWrite (LM_pos, 0); analogWrite (RM_pos, 0); } if (yValue> 550) analogWrite (RM_pos, 80); if (yValue <500) analogWrite (LM_pos, 100);
Pomoże to użytkownikowi przenieść bota i sprawdzić, czy uzyskane wartości są zgodne z oczekiwaniami. Na koniec możemy obliczyć prędkość, odległość i kąt bota używając powyższej logiki i wyświetlić to na LCD używając poniższego kodu.
v = promień_koła * obr / min * 0,104; //0.033 to promień koła w metrach odległość = (2 * 3,141 * radius_of_wheel) * (left_intr / 40); int angle_left = (left_intr% 360) * (90/80); int angle_right = (right_intr% 360) * (90/80); kąt = kąt_prawo - kąt_left; lcd.setCursor (3, 0); lcd.print (""); lcd.setCursor (3, 0); lcd.print (left_intr); lcd.setCursor (11, 0); lcd.print (""); lcd.setCursor (11, 0); lcd.print (right_intr); lcd.setCursor (2, 1); lcd.print (""); lcd.setCursor (2, 1); lcd.print (v); lcd.setCursor (9, 1); lcd.print (""); lcd.setCursor (9, 1); lcd.print (odległość); lcd.setCursor (13, 1); lcd.print (""); lcd.setCursor (13, 1); lcd.print (kąt);
Testowanie robota Arduino pod kątem pomiaru odległości, prędkości i kąta
Gdy sprzęt będzie gotowy, prześlij kod do Arduino i użyj joysticka, aby przenieść bota. prędkość bota, pokonana przez niego odległość i kąt zostaną wyświetlone na wyświetlaczu LCD, jak pokazano poniżej.
Na wyświetlaczu LCD termin Lt i Rt reprezentuje odpowiednio Licznik Przerwania Lewego i Licznik Przerwania Prawego. Można zauważyć, że wartości te są zwiększane dla każdej przerwy wykrytej przez czujnik. Tem S wskazuje prędkość robota wm / s, a termin D wskazuje przebytą odległość w metrach. Kąt robota jest wyświetlany na końcu, gdzie 0 ° oznacza prostą i jest ujemny dla obrotu przeciwnie do ruchu wskazówek zegara i dodatni dla obrotu w prawo.
Możesz także obejrzeć wideo na końcu tej strony, aby zrozumieć, jak działa bot. Mam nadzieję, że rozumiesz projekt i cieszysz się jego budowaniem. Jeśli masz jakiekolwiek wątpliwości, zostaw je w sekcji komentarzy, a ja postaram się jak najlepiej odpowiedzieć. Możesz także skorzystać z forów, aby uzyskać szybką pomoc techniczną.