W tej części naszego kursu Arduino zajmiemy się obsługą małych silników. Pokażę w jaki sposób podłączyć je do mikrokontrolera oraz sterować ich kierunkiem obrotów oraz prędkością.
Zagadnieniu temu poświęciłem osobny artykuł, ponieważ złe podłączenie tego pozornie prostego elementu często uszkadza Arduino.
Zanim zaczniemy zajmować się poszczególnymi aspektami pracy z małymi silnikami DC musisz opanować najważniejsze dwie zasady: po pierwsze - nigdy nie podłączaj silnika bezpośrednio do Arduino. Po drugie - najlepiej nic nie podłączaj przed przeczytaniem poniższych informacji!
Inaczej możesz szykować się na zakup drugiego Arduino!
Dlaczego mamy łączyć silniki z Arduino?
Sterowanie kierunkiem obrotów oraz prędkością silnika, daje bardzo dużo możliwości. Z takimi nowymi umiejętnościami możemy zbudować chociażby prostego robota mobilnego, który będzie mógł jeździć po mieszkaniu i omijać przeszkody. Równie dobrze można też zrobić pojazd zdalnie sterowany z naszym telefonem - możliwości jest naprawdę dużo.
Sterowanie dwoma silnikami wystarczy praktycznie do zbudowania większości robotów, które zostały dodane do katalogu przez naszych czytelników-konstruktorów!
Jakimi silnikami konkretnie się zajmiemy?
W tym artykule omówimy zasadę sterowanie najpopularniejszymi silnikami szczotkowymi DC. Są one najczęściej wykorzystywane przez majsterkowiczów do napędzania swoich konstrukcji. Dość łatwo można takie napędy kupić lub wymontować ze starych zabawek.
Przykładowy silnik DC firmy Pololu.
Należy jeszcze określić czym są małe silniki DC. Oczywiście nie chodzi o ich wymiar, a o zapotrzebowanie na prąd. Na potrzeby artykułu założyłem, że omówię silniki pobierające średnio poniżej 1A, przy zasilaniu z 5-9V. Ograniczenia te trochę uwarunkowane są kontrolerem silników, który wykorzystamy, jednak o tym później.
Zasada sterowania silnikami jest uniwersalna. To znaczy, że wybierając odpowiednio mocniejszy sterownik możemy sterować większym silnikiem.
W części tej nie zajmiemy się serwomechanizmami, ponieważ zostały omówione już wcześniej. Pamiętaj, że w ich wnętrzu znajduje się kontroler, który chroni Arduino przed uszkodzeniem, dlatego zasady omówione w tym artykule nie mają związku z serwami.
Dlaczego nie możemy podłączyć silnika do Arduino?
Arduino, a konkretnie mikrokontroler na jego pokładzie, z założenia ma sterować sygnałami. Wydajność każdej linii wyjściowej jest stosunkowo mała, można przyjąć, że około 20mA. Spokojnie można założyć, że 99,999% silników jakie spotkasz będzie pobierało zdecydowanie więcej prądu. Dokładniej mówiąc mogą to być wielkości setki lub tysiące razy większe.
Przepływ tak dużego prądu przez nieprzystosowany układ powoduje jego natychmiastowe i nieodwracalne uszkodzenie!
Dlaczego w zestawie nie ma silników?
Tak, jak w każdym innym przypadku, aby zacząć sterować silnikami, ważne będą praktyczne testy. Jak widzisz, w naszych zestawach, jest Arduino, bateria, sterownik silników (układ L293D), kondensatory, ale czegoś brakuje... Nie ma tam żadnego silnika (oprócz serwa).
Komplet sensownych, uniwersalnych napędów to wydatek minimum 50zł!
Dlaczego? Otóż wkładanie do zestawu silników byłoby marnowaniem Twoich pieniędzy. Dopiero się uczysz, jeszcze nie wiesz jakie projekty będziesz później budował, a bez tego nie można wybrać odpowiednich silników. Po co więc inwestować w sprzęt, którego nigdy nie wykorzystasz?
Elementy wykorzystywane w tej części.
W tym odcinku silnik zastąpimy diodami świecącymi. Będziesz mógł zaobserwować, jak zmienia się kierunek obrotów (która dioda zaświeci) oraz jak zmieni się ich prędkość (jasność diod). Dla lepszej demonstracji w ćwiczeniach zamieściłem również filmy z podłączonym silnikiem.
Gotowe zestawy do kursów Forbota
Komplet elementów Gwarancja pomocy Wysyłka w 24h
Teraz możesz kupić zestaw ponad 70 elementów niezbędnych do przeprowadzenia ćwiczeń z kursu u naszych dystrybutorów!
Masz już zestaw? Zarejestruj go wykorzystując dołączony do niego kod. Szczegóły »
Scalone mostki-h w pigułce
Między Arduino, a silnikami potrzebne są elementy pośrednie. Najczęściej nazywamy je mostkami typu H,mostkami H lub z angielskiego h-bridge. Sterowniki takie można zbudować samodzielnie z kilku tranzystorów lub można wykorzystać scalony mostek H (czyli układ będący mostkiem). Jako początkujący możesz zacząć od korzystania z gotowych układów.
Samodzielna budowa mostka H konieczna jest przy bardzo dużych prądach. Jest to jednak zadanie trudne. Na początku nie musisz się tym zajmować.
Głównym zadaniem mostków H jest niejako odczytanie i przekształcenie sygnałów dostarczanych przez mikrokontorler, na wielkości, które są odpowiednie do sterowania silnikami. Przykładowo Arduino, którego linie sygnałowe mogą pracować maksymalnie na 5V i 20mA po zastosowaniu mostka H bez problemu może sterować silnikiem, który do pracy wymaga 12V i 1A.
Jeśli jesteś zainteresowany szerzej tym tematem, to możesz zapoznać się artykułem dostępnym na forum: Mostek H (H-bridge) - kompendium dla robotyka. Jednak wiedza tam zawarta nie jest konieczna do zrozumienia materiału tego kursu!
Twój pierwszy mostek H
W kursie zajmiemy się dość starym, ale tanim i nadal popularnym układem L293D. Jego główną zaletą w naszym przypadku jest to, że mostek ten występuje w obudowie przewlekanej (THT) i możemy zamocować go w płytce stykowej: Co ważne w jednym układzie scalonym znajdziemy dwa mostki, więc nadaje się on idealnie do sterowanie napędem robotów (lewa/prawa strona) itd.
Układ L293D.
Układ ten ma 16 wyprowadzeń, a ich opis znajdziemy w nocie katalogowej. Poniżej najważniejszy wycinek. Polecam jednak zajrzeć do całego dokumentu. Warto przyzwyczajać się do czytania not.
Nota katalogowa(ang. datasheet) - do dokument dostarczany przez producenta, w którym znaleźć można wszystkie informacje dotyczącego danego układu.
Jedną z głównych informacji, jaką należy sprawdzić w przypadku każdego mostka H jest jego wydajność. Konkretnie mowa o tym, jaki prąd może pobrać silnik do niego podłączony. Jeśli używamy L293D, to średni prąd na kanał może wynosić 0,6A, a maksymalny 1,2A. Co to oznacza?
Optymalnie podczas pracy nasze silniki powinny pobierać do 0,6A, jeśli jednak zdarzy się, że na chwilę prąd podskoczy do 1,2A, to nic złego się nie stanie. Pod warunkiem, że będzie to trwało tylko krótki czas!
Pamiętaj, że silnik pracujący pod obciążeniem pobiera prąd znacznie większy od tego, który pobierany jest podczas swobodnych obrotów! Zawsze trzeba sprawdzić maksymalny prąd, jaki może pobierać dany silnik!
Na początku omówię wszystkie z nich. Następnie przejdziemy do podłączenia układu na płytce stykowej i do programowania. Na początku piny dotyczące zasilania:
4, 5, 12, 13 - łączymy razem do masy (GND)
16 - zasilanie Vcc części logicznej (5V)
8 - zasilanie Vc silników (do 36V)
Do układu można doprowadzić dwa oddzielne źródła zasilania. Jedno do części logicznej, a drugie dla silników.
Koniecznie należy jednak połączyć masy obu źródeł (baterii)!
Warto pamiętać, że każdy mostek ma spadek napięcia. To oznacza, że przykładowo podłączając 9V do zasilania dla silników w L293D dopłynie do nich maksymalnie 7V. Układ ten jest dość stary, więc ma duży spadek napięcia, nowsze (np.: TB6612) charakteryzują się mniejszym spadkiem.
Piny dotyczące sterowania silnikami:
2, 7 - wejścia określające kierunek obrotów pierwszego silnika
10, 15 - wejścia określające kierunek obrotów drugiego silnika
1 - wejście ENABLE określające prędkość pierwszego silnika
9 - wejście ENABLE określające prędkość drugiego silnika
W celu zatrzymania silnika lub zmiany kierunku należy ustawić sygnały zgodnie z poniższą rozpiską, która nazywa się tabelą prawdy:
Jak widzisz, mamy dwie kombinacje, które powoduje zatrzymanie silnika. Niektóre sterowniki przy podaniu dwóch jedynek wykonują hamowanie przeciwprądem. Czasami może być one szkodliwe dla całego układu jednak powoduje natychmiastowe zatrzymanie silnika.
Podanie dwóch stanów niskich powoduje najczęściej zatrzymanie swobodne (aż silnik wytraci pęd). Informacji na ten temat należy szukać w notach katalogowych mostka.
Piny dotyczące silników:
3, 6 - wyjścia do pierwszego silnika
11, 14 - wyjścia do drugiego silnika
Wykorzystanie mostka H w praktyce
Trochę tego dużo, jednak zaraz wszystko się wyjaśni! Na początku zasilanie, nie wiem dlaczego, ale sprawia ono początkującym wiele problemów. Zasada jednak jest prosta - układ możemy zasilić jednym lub dwoma napięciami.
Jeśli wybierzemy wariant pierwszy, to zarówno część logiczne, jak i silniki będą zasilane z tego samego źródła - zdecydowanie odradzam tej konfiguracji. Szczególnie, jeśli chcielibyście zasilać silniki z 5V dostępnego na płytce Arduino. Jest to możliwe, jednak wymaga odpowiednio wydajnego źródła zasilania oraz dobrego filtrowania.
Zasilanie silników i Arduino z tego samego źródła zasilania może prowadzić to zawieszania się programu i częstych resetów.
Najlepiej jednak odseparować te dwa zasilania np.: silniki prosto z baterii, a mikrokontroler przez stabilizator oraz odpowiednie kondensatory.
Dlatego zdecydowanie bezpieczniej wybrać rozwiązanie drugie, w którym Arduino będzie zasilane z osobnego źródła. W naszym przypadku wykorzystamy zasilanie z USB oraz baterii 9V, z której zasilimy bezpośrednio nasze silniki (Arduino również będzie mogło być z niej zasilane, ale poprzez wbudowany stabilizator, więc nie musimy bardzo obawiać się zakłóceń).
Uwaga!
W kursie zajmujemy się jedynie nauką i demonstracją pewnych mechanizmów. Bateria 9V ma zbyt małą wydajność prądową, aby zasilić robota. Zdecydowanie lepiej sprawdzą się tu akumulatory LiPo.
Układ powinien wyglądać jak poniżej, zwróć uwagę, że do płytki doprowadziliśmy 9V, a nie 5V! Pamiętaj o tym, aby niczego nie uszkodzić!
W miejscu, gdzie wyprowadzone są pomarańczowe przewody należy podłączyć "silnik". Przeczytaj jednak dalszą część artykułu, zanim coś podłączysz!
Pamiętaj koniecznie o kondensatorach na płytce stykowej. Filtrują one napięcie dostarczane prosto z baterii. Ograniczamy nimi możliwość zakłóceń w Arduino!
Układ jest stosunkowo skomplikowany. Na początku warto połączyć masy mostka L293D. Można to zrobić za pomocą nóżek odciętych od rezystorów. Pozwoli to na zaoszczędzenie miejsca:
Połączenie mas w mostku.
Następnie po kolei:
Podłączenie masy.
Podłączenie 9V (zasilanie silników)
Podłączenie 5V (zasilanie logiki)
Podłączenie sygnałów sterujących.
Teraz pora na podłączenie silnika (na początku jednego). Tak jak wspomniałem, w kursie, będziemy symulować silniki, aby nie kupować ich niepotrzebnie. Jak to zrobimy? W bardzo prosty sposób.
Symulacja silnika
Jak wiesz, dioda świecąca jest elementem półprzewodnikowym, który świeci się, gdy prąd przepływa przez niego w odpowiednim kierunku. W związku z tym, jeśli połączymy równolegle dwie diody w taki sposób, aby były połączone przeciwnie, to będziemy mogli sprawdzić "w którą stronę" płynie prąd - raz zaświeci się jedna dioda, a raz druga. Z kolei prędkość silnika będziemy mogli sprawdzać poprzez obserwowanie jasności diody.
Więc w miejsce silnika dołączamy układ jak poniższy (rezystor 1k):
I całość:
Kompletny schemat montażowy do ćwiczenia z mostkiem H.
Arduino - proste sterowanie silnikiem
Pora na pierwszy program, w którym wykorzystamy powyższy, całkiem zawiły, układ. Na początku zajmiemy się sterowaniem kierunkiem obrotów silnika. Regulację prędkości zostawmy na później. Tak jak zostało wspomniane, w tej chwili za jeden z silników odpowiadają następujące piny Arduino:
6 (PWM) - regulacja prędkości
7, 8 - sterowanie kierunkiem obrotów
Zwróć uwagę, że mowa jest tutaj o numerach pinów Arduino,
a nie wyprowadzeń mostka L293D!
Jeśli nie chcemy sterować prędkością silników, to na pinie 6 (PWM) musimy ustawić stan wysoki. Równie dobrze moglibyśmy przewód połączyć bezpośrednio do 5V. Jednak skoro mamy już gotowe podłączenie, to skorzystajmy z Arduino:
Arduino
1
2
3
4
5
6
7
8
9
10
11
voidsetup(){
pinMode(6,OUTPUT);//Sygnał PWM silnika nr 1
digitalWrite(6,HIGH);//Ustawiamy (na stałe) stan wysoki na pinie 6
pinMode(7,OUTPUT);//Sygnały sterujące kierunkiem obrotów silnika nr 1
pinMode(8,OUTPUT);
}
voidloop(){
//Tu będzie dalsza część programu
}
Jeśli układ został podłączony poprawnie, to po wgraniu poniższego programu... nie powinno się nic wydarzyć! Teraz pora na dodanie brakującego kawałka w pętli loop. Załóżmy, że chcielibyśmy teraz kręcić silnikiem 3 sekundy w jedną stronę oraz 3 w przeciwną (prędkość maksymalna). W tym celu musimy dopisać banalnie prosty fragment programu:
Arduino
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
voidsetup(){
pinMode(6,OUTPUT);//Sygnał PWM silnika nr 1
digitalWrite(6,HIGH);//Ustawiamy (na stałe) stan wysoki na pinie 6
pinMode(7,OUTPUT);//Sygnały sterujące kierunkiem obrotów silnika nr 1
pinMode(8,OUTPUT);
}
voidloop(){
digitalWrite(7,LOW);//Silnik nr 1 - obroty w lewo
digitalWrite(8,HIGH);
delay(3000);
digitalWrite(7,HIGH);//Silnik nr 1 - obroty w prawo
digitalWrite(8,LOW);
delay(3000);
}
Zgodnie z wcześniej przedstawioną tablicą prawdy wiemy, że silnik będzie się kręcił, jeśli na jedno z wejść podanym stan niski "0", a na drugi stan wysoki "1". Kierunek obrotów zależy natomiast od tego, na które wejście podamy jaki sygnał.
Po wgraniu programu do Arduino dwie diody powinny zacząć migać. Skup się jednak dokładnie i zrozum dlaczego tak się dzieje. Nie jest to takie samo miganie diodami jak w pierwszych częściach kursu. Diody świecą na przemian, ponieważ raz prąd płynie od wyjścia 1 do 2, a raz odwrotnie. Miganie jest możliwe, ponieważ diody wstawione są odwrotnie. Dla łatwiejszego zrozumienia spójrz na poniższe zdjęcia, gdzie w miejsce diod wpiąłem dodatkowo woltomierz:
„Silnik” w lewo.
„Silnik” w prawo.
Raz wynik jest dodatni, a raz ujemny. W tym wypadku minus pokazuje nam, że prąd płynie w stronę przeciwną od tej, która była na początku.
Teraz pora na eksperyment tylko w moim wykonaniu, czyli podłączenie silnika. Wykorzystam mały silnik wyposażony w przekładnie DC oraz czerwone koło (aby lepiej widoczne były obroty).
Jeśli dysponujesz małym silnikiem i chcesz podłączyć go do układu, tak jak ja, to upewnij się, że pobiera on odpowiednio małą ilość prądu (<1A) i może być zasilany z około 6-9V.
Skoro potrafimy już sterować kierunkiem obrotów silnika pora na prędkość. Przedtem sprawdź, co stanie się, gdy podczas pracy powyższego programu wyciągniesz przewód idący do pinu 6 Arduino i podłączysz go do masy?
Silnik przestał się kręcić (diody przestały świecić). Czyli gdybyśmy bardzo szybko podawali na to wejścia 0 lub 1, to moglibyśmy sterować prędkością silnika (jasnością diod). Czy przypominasz sobie, w której części kursu pojawiła się już taka analogia?
Zadanie domowe 8.1
Dodaj do układu kolejne dwie diody i symuluj nimi drugi silnik. Napisz program, który będzie wykonywał sekwencję: oba do przodu, oba w przeciwne strony, oba w tył i tak w koło. Oczywiście między zmianą kierunku zachowaj odstęp np.: 2 sekundy.
Wersja z PWM - sterujemy prędkością
Do dalszych testów konieczna jest wiedza z artykułu PWM i Arduino. Tak jak się pewnie domyślasz wystarczy podać sygnał PWM na pin ENABLE1 (układu L293D), aby sterować prędkością silnika!
Nie ma nad czym się rozpisywać. Pora napisać prosty program, który będzie na zmianę kręcił silnikami wolniej lub szybciej. Pamiętaj, że świecenie diody widoczne jest dopiero powyżej pewnego progu wypełnienia sygnału PWM, tak samo będzie z silnikami. Każdy będzie się kręcił od trochę innej wartości. Do tego wrócimy jeszcze później.
Arduino
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
voidsetup(){
pinMode(6,OUTPUT);//Sygnał PWM silnika nr 1
pinMode(7,OUTPUT);//Sygnały sterujące kierunkiem obrotów silnika nr 1
pinMode(8,OUTPUT);
}
voidloop(){
analogWrite(6,100);//Niska prędkość obrotów
digitalWrite(7,LOW);//Silnik nr 1 - obroty w lewo
digitalWrite(8,HIGH);
delay(3000);//Odczekaj 3 sekundy
analogWrite(6,255);//Maksymalna prędkość obrotów
digitalWrite(7,LOW);//Silnik nr 1 - obroty w lewo
digitalWrite(8,HIGH);
delay(3000);//Odczekaj 3 sekundy
}
Powinieneś zaobserwować, że jedna dioda zmienia wyraźnie swoją jasność - jednak robi to skowo! Teraz pora na płynną zmianę prędkości silnika, jednak zanim do tego przejdziemy pora na małe wtrącenie...
Pętla for w Arduino
Pora na omówienie niezwykle użytecznej pętli dostępnej w języku Arduino (oraz wielu innych). Na myśli mam pętlę FOR, która pozwala nam wykonać pewne instrukcje określoną ilość razy
Skorzystamy z niej, jeśli będziemy przykładowo chcieli wypisać 10 kolejnych liczb naturalnych, zamigać diodą 5 razy itd. Zanim jednak przejdziemy do przykładu pora na przedstawienie składni:
Wygląda zawile, jednak na szczęście jest to bardzo proste. Po słowie kluczowym for otwieramy nawias i podajemy tam trzy bardzo ważne rzeczy. Pierwszą z nich jest zmienna licznikowa. Skoro zawartość pętli ma być wykonywana określoną ilość razy, to skądś program musi czerpać wiedzą ile obiegów pętli zostało już wykonanych.
Następnie, po średniku podajemy warunek. Pętla wykonuje się tak długo, jak długo warunek ten będzie spełniony. Po kolejnym średniku musimy wpisać operację, która ma być wykonywana na zmiennej licznikowej podczas każdego obiegu pętli. Na koniec zamykamy okrągły nawias.
Pętla for w praktyce
Wykorzystajmy pętlę for do wypisania za pomocą UARTu powitania np.: 25 razy.
Arduino
1
2
3
4
5
6
7
8
9
10
11
voidsetup(){
Serial.begin(9600);//Start komunikacji
for(inti=0;i<25;i++){//Wykonaj 25 razy
Serial.println("Witaj na Forbot.pl");//Wypisz tekst w nowej linii
delay(200);//Odczekaj chwilkę
}
}
voidloop(){
}
Efekt widoczny w terminalu:
Efekt działania pętli for - Arduino.
Czyli dokładnie tak, jak się spodziewaliśmy. Już tłumaczę, co oznacza poniższy zapis:
Arduino
1
for(inti=0;i<25;i++){//Wykonaj 25 razy
Zmienna licznikowa, tutaj pojawił się prosty zapis int i = 0 , mam nadzieję, że go rozumiesz. W skrócie deklarujemy nową zmienną lokalną i, która jest typu int, a jej wartość początkowa, to 0. Jeśli masz problemy ze zrozumieniem tego fragmentu wróć do artykułu o zmiennych.
Warunek pętli, to w tym przypadku zapis i < 25. Czyli pętla będzie wykonywała się tak długo, jak wartość zmiennej i będzie mniejsza od 25.
Ostatni element, czyli i++ jest inkrementacją zmiennej licznikowej (czyli, co obieg pętli wartość zmiennej zwiększana jest o jeden). Równie dobrze można ten zapis zamienić na i = i + 1 w wolnej chwili możesz to sprawdzić.
Dla łatwiejszego zrozumienia warunku możesz uruchomić program w zmodyfikowanej wersji:
Arduino
1
2
3
4
5
6
7
8
9
10
11
12
13
voidsetup(){
Serial.begin(9600);//Start komunikacji
for(inti=0;i<25;i++){//Wykonaj 25 razy
Serial.print("Wartosc zmiennej i: ");
Serial.print(i);//Wyświetl wartość licznika
Serial.print("\n");//Przejdź do nowej linii
delay(200);//Odczekaj chwilkę
}
}
voidloop(){
}
Teraz można łatwo podejrzeć jakie wartości przyjmuje zmienna licznikowa (0-24). Oczywiście pętla wykona się również 25 razy, jeśli zamiast:
Arduino
1
for(inti=0;i<25;i++){//Wykonaj 25 razy
napiszemy:
Arduino
1
for(inti=0;i<=24;i++){//Wykonaj 25 razy
lub:
Arduino
1
for(inti=1;i<=25;i++){//Wykonaj 25 razy
lub:
Arduino
1
for(inti=1;i<26;i++){//Wykonaj 25 razy
lub:
Arduino
1
for(inti=0;i<50;i=i+2){//Wykonaj 25 razy
a nawet:
Arduino
1
for(inti=25;i>0;i--){//Wykonaj 25 razy
Jak widzicie, możliwości jest wiele! Oczywiście najczęściej wykorzystywana jest ta pierwsza. Warto jednak poświęcić chwilę na poćwiczenie takich dziwnych warunków, czasami mogą sporo ułatwić! Teraz możemy wrócić do kwestii silników, a konkretnie płynnej regulacji prędkości.
Zadanie domowe 8.2
Napisz program, który za pomocą pętli for będzie migał diodą 5 razy. Spróbuj napisać również to samo z wykorzystaniem pętli while.
Zadanie domowe 8.3
Napisz program, który odczyta liczbę z zakresu 0-9 wysłaną prze UART, a następnie wyświetli na ekranie tyle samo znaków gwiazdki *.
Płynne rozpędzanie silnika
Skoro znamy już pętlę for, to możemy wykorzystać ją do płynnego rozpędzania silnika. Wystarczy, że wypełnienie sygnału PWM będziemy zmieniać płynnie, na przykład co 25 ms.
Kod jest prosty i prezentuje się następująco, jako za poziom wypełnienia sygnału PWM odpowiada zmienna licznikowa i:
Arduino
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
voidsetup(){
pinMode(6,OUTPUT);//Sygnał PWM silnika nr 1
pinMode(7,OUTPUT);//Sygnały sterujące kierunkiem obrotów silnika nr 1
pinMode(8,OUTPUT);
digitalWrite(7,LOW);//Silnik nr 1 - obroty w lewo
digitalWrite(8,HIGH);
}
voidloop(){
for(inti=0;i<=255;i++){
analogWrite(6,i);//Spokojne rozpędzanie silnika
delay(25);
}
}
Tutaj warto pamiętać, że rozruch silnika jest dla niego stosunkowo trudny. Musi się rozpędzić i pokonać tarcie panujące w jego wnętrzu. Dodatkowo zanim zacznie się kręcić będzie wydawał piski. Możecie to usłyszeć na poniższym filmie:
Warto zapamiętać ten fakt. Często początkujący mają problemy, bo ich robot nie chce jeździć. Najczęściej okazuje się, że albo zastosowane zasilanie jest zbyt słabe, albo sygnał PWM ma jeszcze zbyt małe wypełnienie.
Zadanie domowe 8.4
Napisz program, który za pomocą 2 pętli for będzie płynnie rozpędzał oraz hamował silnik.
Podsumowanie
Na tym zakończymy część o sterowaniu silnikami DC, która na początku miała być stosunkowo krótka. Wyszło jednak trochę więcej, jednak chciałem przekazać Wam więcej informacji, abyście nie mieli problemów z wykorzystywaniem silników we własnych konstrukcjach. W związku z brakiem silnika część ta była dla Was trochę teoretyczna. Jednak, jeśli będzie potrzeba to w kontynuacji kursu wrócimy do tych zagadnień wyposażeni w odpowiednie napędy!
W kolejnej części kursu zajmiemy się obsługą ultradźwiękowego czujnika odległości oraz pisaniem własnych funkcji (z argumentami oraz bez). Dzięki temu nasze programy będą wyglądały jeszcze lepiej! Powoli zbliżamy się również do końca przewidzianych artykułów. Czekam na Wasze komentarze, jeśli chcielibyście, aby pojawiły się kolejne artykuły!
Autor: Damian (Treker) Szymański
PS Nie chcesz przeoczyć kolejnych części naszego darmowego kursu programowania Arduino? Skorzystaj z poniższego formularza i zapisz się na powiadomienia o nowych publikacjach!
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 na bazie Arduino i Raspberry Pi.
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...