Nie, nie boję się 13-tek 😛 Jednak będę w Warszawie na konferencji i (niestety!) się nie spotkamy. Zapraszam w kolejnym tygodniu – 20 marzec 2018. Do zobaczenia!
KG
Category Archives: FiBot
Ekranik LCD 16×2 oraz komunikacja I2C
Kontynuujemy projekt zabawki mierzącej refleks (także pamięć – „memory”). Potrzebujemy sposobu komunikacji z użytkownikiem (innego niż podłączony komputer PC do Arduino) – wybór padł na ekranik LCD 16×2.
LCD 16×2
Układ ten to szesnaście znaków w dwóch wierszach – stąd nazwa 16×2. Są także inne, obejrzyjcie dla przykładu magazyny botland.com.pl
Schemat podłączenia ładnie opisany jest na oficjalnych stronach Arduino – zapraszam do lektury. Nasze układy po złożeniu wyglądały tak:
Program polega na użyciu wbudowanej bibliotyki LiquidCrystal.h — poniżej program:
//LCD16x2 sterowany przez Arduino
#include <LiquidCrystalC.h> // dolaczenie pobranej biblioteki dla LCD
LiquidCrystal lcd(, 2, 11, 12, 4, 5, 6, 7);
void setup(){
lcd.begin(16,2); // Inicjalizacja LCD 2x16
lcd.setCursor(0,0); // Ustawienie kursora w pozycji 0,0 (pierwszy wiersz, pierwsza kolumna)
lcd.print("pomidor!");
delay(500);
lcd.setCursor(0,1); //Ustawienie kursora w pozycji 0,0 (drugi wiersz, pierwsza kolumna)
lcd.print("LCD 16x2");
}
void loop() {
}
Warte podkreślenia jest tutaj fakt wykorzystania aż 6-ciu cyfrowych pinów do obsługi tego wyświetlacza. To dużo! Nie ma sprawy, gdy tylko „bawimy” się modułem ekraniku, ale gdy już coś budujemy, podłączamy LED-y czy przyciski – to wówczas spotykamy się z deficytem pinów w Arduino UNO. Ale są lepsze sposoby na podłączenie takiego wyświetlacza.
Komunikacja I2C (IIC, TWI)
To bardzo popularny interface komunikacyjny, obsługujący za pomocą tylko 2 linii aż 127 urządzeń! tymi pinami są SDA (w Arduino pin A4) oraz SDC (w Arduino pin A5). Oznacza to, że gdy podłączamy coś na I2C to łączamy to coś dwoma przewodami z Arduino, podłączając do wejść A4 i A5 – jednocześnie „tracimy” te piny (A4 i A5) – nie możemy z nich korzystać. Trudno – coś za coś. Zresztą, to nic nowego – podobnie jest z komunikacją UART – Serial.begin(xxx) – „zabiera” nam cyfrowe piny #o (TX) i #1 (RX). Przy czym UART to tylko komunikacja z jednym urządzeniem – a tutaj 2 piny i możliwość obsługi do 127 urządzeń!
Moduł hd44780 (i2c)
Jako przykład komunikacji I2C użyliśmy wyświetlacza LCD 16×2 z dodatkowym sterownikiem hd44780. Taki sterownik jest tani a bardzo użyteczny.
Całe podłączenie polega na połączeniu VCC i GND ze steronika do VCC i GND z Arduino, oraz pinów SDA, SDC ze sternika – do SDA i SDC w Arduino. Przy okazji dowiedzieliśmy się, że piny A4 i A5 w Arduino mają swoje „klony” w szeregu pinów cyfrowych, powyżej #13, GDN, ARFE.
Musimy użyć nowej biblioteki do obsługi tego modułu – ja zdecydowałem się na LiquidCrystal_I2C.h autorstwa Franka de Brabandera. Nie jest standardowo zainstalowana więc trzeba ją samodzielnie doinstalować. Przykładowy program:
//LCD16x2 sterowany przez I2C Arduino
include <Wire.h> // standardowa biblioteka Arduino
#include <LiquidCrystal_I2C.h> // dolaczenie pobranej biblioteki I2C dla LCD
LiquidCrystal_I2C lcd(0x27, 16, 2);
//LiquidCrystal_I2C lcd(0x3f, 16, 2);
void setup(){
lcd.init();
lcd.begin(16,2); // Inicjalizacja LCD 2x16
lcd.backlight(); // zalaczenie podwietlenia
lcd.setCursor(0,0); // Ustawienie kursora w pozycji 0,0 (pierwszy wiersz, pierwsza kolumna)
lcd.print("pomidor!");
delay(500);
lcd.setCursor(0,1); //Ustawienie kursora w pozycji 0,0 (drugi wiersz, pierwsza kolumna)
lcd.print("LCD 16x2 I2C -- hd44780");
}
void loop() {
}
i2cScanner
To bardzo użyteczny program (aż mnie dziw bierze, że nie jest standardowo dodany do Arduino IDE!) więc trzeba go ręcznie zgrać z internetu i uruchomić. Dzięki niemu poznajemy adres swojego urządzenia – bo skoro magistrala i2c obsługuje aż do 127 urządzeń, to jak je rozpoznaje? które urządzenie jest które? a jeśli chcemy mieć 2, 3 lub 4 wyświetlacze LCD w jednym projekcie? Właśnie po to są adresy!
W naszej pracowni występują dwa rodzaje urządzeń – o adresach 0x27 oraz o 0x3f. Koniecznie sprawdź u siebie! W naszym przykładowym kodzie adres zapisany jest w linii 6 (kolejna linia przygotowuje na inny adresik).
Pomiar prądu
Warto zdawać sobie sprawę z użycia prądu – jak widać z poniższych zdjęć wykonaliśmy pomiar i odnotowaliśmy różnicę w poborze prądu w zależności od trybu działania ekraniku LCD – bez podświetlenia (około 6 mA) oraz z podświetleniem (około 26 mA).
A tutaj pomiar prądu z włączonym podświetleniem:
Projektując swój układ warto brać pod uwagę „prądożerność” każdego urządzenia. Ale to na przyszłość. My przećwiczyliśmy mierzenie prądu 😉
(c) KG 2018
Uwaga: koło Fi-BOT w nowych godzinach!
Zmieniam godziny naszych cotygodniowych spotkań – od najbliższych zajęć (wtorek, 6 marzec) widzimy się w godzinach 14:15-15:45 (plus/minus ewentualne przedłużenia do 16-tej). Jak zawsze zajęcia we wtorki w sali 1064. Do zobaczenia!
KG
Przycisk + dioda + random = REFLEKS!
Na zajęciach wykorzystaliśmy proste elementy do zbudowania prototypu maszyny badającej nasz refleks. Ale od początku.
Moduł z przyciskiem
Moduł posiada trzy piny – GND oraz Vcc to zalsilanie, S to stygnał wysyłany przez płytkę (na innych płytkach często oznaczony OUT). My używamy modułów firmy RobotDyn (o nazwie Button Switch module) i trzeba przyznać im dobrą jakość wykonania. Na dodatek układy te mają wbudowanego LED-a informującego o wciśnięciu przycisku.
Najpierw sprawdzamy, czy po wciśnięciu przycisku Arduino „zobaczy” jedynkę (stan HIGH) czy „zero” (stan LOW). Prosty programik poniżej:
#define gdzie 7
void setup(){
pinMode(gdzie, INPUT);
Serial.begin(9600);
}
void loop(){
Serial.println(digitalRead(gdzie));
delay(100);
}
Liczby losowe – rand()
Bibliotyki Arduino wyposażone są w funkcje pseudo losowe – czyli takie, które generują liczby „udające” prawdziwe liczby losowe. Mowa tu o funkcji rand() – aby to sprawdzić piszemy poniższy kod:
void setup(){
Serial.begin(9600);
}
void loop(){
Serial.print("czas= ");
Serial.print(millis());
Serial.print(" los=");
Serial.printtln(rand());
delay(100);
}
Widzimy więc duuuuuże (i losowe!) liczby całkowite, które wyświetlają się co 100ms. Aby z takich liczb zbudować coś konkretnego, np. typowy rzut kostki do gry – trzeba to lekko zmodyfikować przez użycie funkcji reszta z dzielenia całkowitego (tzw. modulo, symbol % w języku C/C++):
void setup(){
Serial.begin(9600);
}
void loop(){
Serial.print("czas= ");
Serial.print(millis());
Serial.print(" kostka=");
Serial.printtln(1 + rand()%6);
delay(100);
}
Jak to działa? Reszta z dzielenia całkowitego przez 6 zwraca liczby z przedziału 0..5, ale my dodajemy jeszcze jedynkę – otrzymujemy liczby 1…6 – czyli naszą kostkę do gry. W ten właśnie sposób możemy modyfikować wynik funkcji rand() i dopasowywać ją do naszych potrzeb.
Zapalenie LED-a co losowy czas
Podłączyliśmy niebieskiego LED-a bezpośrednio do pinu 13 Arduino i GND – bez dodatkowego, wymaganego opornika. Nie jest to poprawne połączenie (brak opornika = uszkodzenie LED-a), ALE niebieskie LEDy mają (wysokie) napięcie przewodzenia, około 3V. Arduino zasili je jednak 5V – co jest za dużo – i uszkadzamy naszego LED-a, ale go nie zniszczymy (celowo wybrałem niebieski LED, a nie inny – inne LEDy pracuą na napięciu ~2V, więc 5V by je zniszczyło). Zależy mi tutaj na prostocie budowy układu więc darowałem sobie niezbędny opornik (no i nie chiałem korzystać z wbudowanego LEDa #13 – bo jest mały i niewyraźny).
Chwilowo odłożyliśmy moduł z przyciskiem i zaprogramowaliśmy włączenei LED-a po losowym czasie od 5s, do 15s:
#define LED 13
void setup(){
pinMode(LED, OUTPUT);
}
int i;
void loop(){
//odczekanie 5..15 sekund
delay(5000+ rand()%10000);
//wlaczenie LED-a
digitalWrite(LED, HIGH);
delay(1000);
digitalWrite(LED, LOW);
//miganie - znak, ze za chwile powtarzamy zabawe
for (i=0; i<4; i++){
digitalWrite(LED, HIGH);
delay(200);
digitalWrite(LED, LOW);
delay(200);
}//miganie
}
Warto pobawić się z tym programem, uzupełniając go o dodatkowe informacje wyświetlane przez monitor portu szeregowego – informujące, że trwa losowe czekanie, a potem, że włączono LEDa i na koniec – że zabawa od początku się zaczyna.
Program „badamy refleks”
Wracamy do przycisku – rozbudowujemy poprzedni program o odczytanie momentu wciśnięcia przycisku. Użytkownik ma to zrobić w momencie zapalenia się niebieskiego LEDa — tylko, że nie wiadomo, kiedy to dokładnie nastąpi (losowy czas z poprzedniego programu). Na koniec wyświetlimy czas jego reakcji – jego refleksu 😉
#define LED 13
#define gdzie 7
void setup(){
pinMode(gdzie, INPUT);
pinMode(LED, OUTPUT);
Serial.begin(9600);
}
int i;
unsigned long int t1,t2;
void loop(){
Serial.println("START!");
//odczekanie 5..15 sekund
delay(5000+ rand()%10000);
t1=millis();
//wlaczenie LED-a
digitalWrite(LED, HIGH);
while (digitalRead(gdzie)== HIGH);
t2=millis();
digitalWrite(LED, LOW);
Serial.print("Rekacja (refleks)=");
Serial.print(t2-t1);
Serial.println(" ms");
delay(500);
//miganie - znak, ze za chwile powtarzamy zabawe
for (i=0; i<4; i++){
digitalWrite(LED, HIGH);
delay(200);
digitalWrite(LED, LOW);
delay(200);
}//miganie
}
Kluczowa jest linia #17 – to w niej następuje zatrzymanie działania programu i oczekiwanie na rekację użytkownika. Zrealizowałem to za pomocą pętli podczytującej przycisk – w moim module naciśnięcie przycisku powoduje odczyt stanu LOW, natomiast stan HIGH oznacza brak wciśnięcia. Jak widać ta pętla NIC nie robi. Właśnie o to mi tu chodziło – pętla nic nie robi, więc ponownie wracamy do sprawdzenia warunku pętli while – bez straty czasu. I tak w kółko, aż w końcu naciśnięty zostanie przycisk.
A jak mierzę czas? Za pomocą funkcji millis() – która zwraca czas (w milisekundach) od uruchomienia Arduino. Robię to dwukrotnie – przed odczytaniem przycisku zapisuję do zmiennej t1, a po naciśnięciu przycisku – do zmiennej t2. Różnica tych czasów jest właśnie Twoim czesem reakcji – Twoim refleksem.
Pomysły
Program należy rozbudować – o dwa przyciski, dwa LEDy. To wzbogaci zabawę, bo losowo zapali się albo jeden LED, albo drugi. Warto wybrać dwa kolory LED-ów i dwa kolory przycisków. To będzie dodatkowe utrudnienie dla użytkownika – ma on bowiem wcisnąć odpowiedni przycisk (np. LED żółty – to i przycisk żółty, a nie niebieski. Niebieski to dyskwalifikacja! I na odwrót).
Inna modyfikacja polega na wychwyceniu falstartu – zapobiegnięciu sytuacji, że użytkownik bezmyślnie „klika” przyciskiem w nadziei, że gdy LED się zaświeci – on właśnie wcisnął przycisk i otrzymał bardzo krótki czas reakcji. Trzeba tak zrobić, aby wciśnięcie przycisku PRZED zaświeceniem kończyło zabawę. Podpowiedź: zamiast funkcji delay() w linii #13 trzeba sprytnie wykorzystać pętlę while…
(c) KG 2018
Zajęcia Fi-BOTa dopiero 27-go lutego
Przedłużamy przerwę w spotkaniach Fi-BOTa ze względu na „walkę o zaliczenia” w ramach sesji poprawkowej. Widzimy się 27-go lutego (wtorek, jak zawsze 16:00).
KG
Przerwa egzaminacyjna
Ogłaszam przerwę w spotkaniach Fi-BOTa na czas 30 styczeń – 14 luty 2017. Proszę poświęcić się przygotowaniom do sesji. Życzę powodzenia w zaliczeniach i widzimy się 20-go lutego (wtorek, jak zawsze 16:00).
KG
Sterowanie serwem za pomocą joysticka
Na zajęciach sterowaliśmy serwomechanizmami za pomocą joysticka. Na początku używaliśmy niewielkiego modułu z joystickiem podłączanego bezpośrednio do Arduino. W drugiej części użyliśmy nakładki (shield) na Arduino z joystickiem oraz czterema przyciskami (podobnie jak na gamepadach).
Moduł z joystickiem
Moduł posiada pięć pinów. GND oraz 5V podłączamy do Arduino. VRx i VRy to piny sterujące odpowiednio osią OX (czyli lewo-prawo) oraz OY (czyli góra-dół). Podłączamy je do pinów analogowych. Ostatni pin odpowiada za przycisk, jednak nie używaliśmy go w tym zadaniu.
Prosty program wyświetlający położenie joystika
void setup(){
Serial.begin(9600);
}
int x,y;
void loop(){
x = analogRead(A0);
y = analogRead(A1);
Serial.print("x=");
Serial.print(x);
Serial.print(", y=");
Serial.println(y);
}
Położenie na osi OX (także OY) to liczby z zakresu 0..1023. Położenie spoczynkowe powinno odpowiadać wartości 511 (liczby 0..510 to wychylenie w lewo, liczby 512..1023 to wychylenie w prawo). Użycie tego programu pozwoliło nam sprawdzić, że tak jednak nie jest – u nas joy w położeniu spoczynkowym miał wartości 514, 517 (oś OX i OY).
Podczas działania tego programu możemy postawić sobie następujące zadanie: ustawić pozycję joy-a w takim położeniu, aby odczyty były x=800 y=200. Okazuje się to jednak bardzo trudne! Widzimy więc, że sterowanie joy-em nie jest łatwe i wymaga sporo wprawy.
Wieżyczka
Używana przez nas wieżyczka (do której można przyczepić, np. kamerkę internetową by nią sterować) składała się z dwóch serw na podstawce. Umożliwia to poruszanie się mechanizmu na boki oraz w górę i dół.
Wszystkie potrzebne elementy połączyliśmy za pomocą płytki prototypowej. Zamiast zasilania z Arduino użyliśmy zewnętrznego koszyka na 4 baterie o łącznym napięciu 5V. Dlaczego tak zrobiliśmy? Chodziło nam o oddzielne zasilanie silników aby nie przeciążyć płytki Arduino – pojedyncze serwo może pobrać nawet 200mA prądu (co sprawdzaliśmy na poprzednich zajęciach), a wydajność prądowa Arduino UNO to około 200-400 mA. Dlatego dwa takie serwa mogą uszkodzić naszą płytkę. My użyliśmy oddzielnego zasilania silników aby temu zapobiec. WAŻNE: w przypadku używania kilku źródeł zasilania (u nas Arduino 5V i 4x baterie AAA) musimy uwspólnilić masy (GDN z Arduino, „minus” z bateryjki).
Użyliśmy płytki prototypowej, gdzie na jednej szynie (koloru niebieskiego) wetknęliśmy „-” z koszyka baterii oraz GND Arduino. Do tej „szyny” podłączone były masy serw (przewody koloru brązowego). Druga szyna (czerwona – z drugiej strony płytki, dla naszej wygody) doprowadzone miała przewód „+” z koszyka baterii i tam podłączone były zasilania silników serw (czerwone przewody serw). UWAGA: nie można łączyć pinu 5V Arduino z zewnętrznym zasilaniem baterii – może to spowodować uszkodzenie płytki! Łączymy (=uwspólniamy) jedynie masy. Przewody sterujące serwami (koloru żółtego) podłączyliśmy do pinów PWM Arduino UNO – u nas #3 i #5.
Program sterujący
Na początku standardowo dołączamy do programu bibliotekę umożliwiającą sterowanie serwami. Następnie dodajemy zmienne do obu serw, jedno odpowiedzialne za ruch góra-dół, a drugie lewo-prawo.
#include <Servo.h>
Servo GoraDol;
Servo LewoPrawo;
void setup (){
Serial.begin(9600);
GoraDol.attach(3);
LewoPrawo.attach(5);
}
int x,y;
W kolejnej części deklarujemy zmienne odpowiadające za położenie obu osi joysticka – dokładnie tak, jak w pierwszym programie odczytującym położenia joy-a. Wyświetlamy wartości x oraz y w monitorze szeregowym. Joystick zwykle nie jest idealnie skalibrowany, jednak nie ma to znaczenia przy niewielkiej precyzji.
Funkcja map pozwala na łatwe proporcjonalne przeliczenie wartości. Używamy jej, ponieważ położenia joysticka są z zakresiu 0-1023, natomiast sterowanie serwem chcemy wyrażamy w stopniach 0-180. Wynik przypisujemy od razu do zmiennych x oraz y (używamy tych samych zmiennych, niszcząc ich poprzednie wartości). W argumentach funkcji wpisujemy zmienną do przeliczenia, następnie jej obecny zakres i na końcu zakres po zamianie. Po przeliczeniu wartości możemy je przekazać do serwomechanizmów.
x=map(x,0,1023,0,180); //funkcja map LewoPrawo.write(x); y=map(y,0,1023,0,180); GoraDol.write(y); delay(10);
Nakładka (shield) na Arduino
Fajnym rozwiązaniem jest wykorzystanie specjalnej nakładki (shield), która poszerza możliwości Arduino. Piny obu komponentów pasują do siebie, więc nie da się pomylić przy wpinaniu nakładki. Joystick oraz przyciski są fabrycznie podłączone do pinów, więc nie musimy tego robić w programie. Na nakładce wszystkie piny są podpisane, więc później będziemy tylko operować odpowiednimi oznaczeniami pinów.
Modyfikacja programu – przycisk „zamrażający” położenie wieżyczki
Program sterujący jest bardzo podobny do poprzedniego. Jedyną różnicą jest brak podłączenia pinów cyfrowych. Dodatkową funkcją, którą wprowadzamy do naszego programu, jest zatrzymywanie serwa w ustawionej pozycji. Chcemy aby wciśnięcie wybranego przycisku (np. koloru czerwonego) zablokowywało dalsze sterowanie wieżyczką. Kolejne wciśnięcie tego przycisku powoduje odblokowanie sterowania. W tym celu do kodu wprowadzamy zmienną typu logicznego bool (nazwaną tryb) i ustawiamy ją na wartość true. Następnie wybieramy przycisk (np. ten czerwony), który ma sterować zatrzymaniem serwa i sprawdzamy, który numer pinu u odpowiada. W naszym programie jest to pin 5. Tworzymy instrukcję sterującą if, która wykona się po wciśnięciu przycisku. Do wartości zmiennej tryb, przypisujemy jej odwrotność. Czyli jeśli tryb jest true, zostanie zmieniony na false i odwrotnie. Funkcja delay() wprowadzamy aby zarejestrować tylko jedną zmianę ustawienia przycisku (przyciski lubią „drgać” co powoduje nie jeden „klik” a wiele takich „klików” – opóźnienie je zniweluje). Działa to w taki sposób, że jeśli tryb jest wartością false, czyli zostanie raz zmieniony we wcześniejszym if’ie, sterowanie joyem zostaje zablokowane. Natomiast po kolejnym użyciu przycisku, tryb zmieni się z false na true, a sterowanie zostanie odblokowane.
bool tryb=true;
void loop(){
x=analogRead(A0);
y=analogRead(A1);
if (digitalRead(5)==HIGH){
tryb=!tryb;
delay(50);
}
if(tryb==true){
x=map(x,0,1023,0,180); //funkcja map
LewoPrawo.write(x);
y=map(y,0,1023,0,180);
GoraDol.write(y);
}
}
Podsumowanie
Jak można zauważyć programy umożliwiające sterowanie servami nie są skomplikowane ani długie. Można sprytnie wykorzystać komponenty posiadające więcej niż jedną oś ruchu, dzięki czemu nasze możliwości się poszerzają. Jednak precyzyjne sterowanie takimi joystikami nie jest łatwe…
(c) Ewelina, KG 2017
Sterowanie servem za pomocą potencjometru
Na ostatnich zajęciach łączyliśmy wiedzę nabytą na dwóch poprzednich spotkaniach, czyli działanie potencjometru oraz serva. Chcieliśmy wykorzystać możliwość zmiany nastawy potencjometru, w celu sterowania ramionami serwomechanizmu. Podobnie jak na zajęciach przedświątecznych, wykorzystamy do tego komendy biblioteki sterującej servami.
Sterowanie serva
#include <Servo.h>
Servo silnik;
void setup (){
Serial.begin(9600);
silnik.attach(3);
}
Servo podłączamy tak samo jak na przedświątecznych zajęciach, jednak w tym przypadku używamy 3 pinu, a sam mechanizm nazywamy silnikiem (linia #2 i #6).
Wykorzystanie potencjometru
int pot;
void loop(){
pot=analogRead(A0);//odczytujemy liczby z zakresu od 0 do 1023
pot=pot*180.0/1023;//zamienimy na liczby od 0 do 180
Serial.print(pot);
silnik.write(pot);
}
Na początku deklarujemy zmienną zapisującą stan potencjometru. W ciele funkcji void loop() podłączamy potencjometr do portu analogowego A0. Linia #4 przelicza zakres potencjometru. Jak pamiętamy, wynosi on od 0 do 1023, natomiast stopnie wychylenia serva chcemy wyrażać w zakresie 0-180. 180 konwertujemy na zmienną typu float dopisując do niej część dziesiętną w celu uniknięcia dzielenia całkowitego. W innym wypadku otrzymywalibyśmy nieprawdziwe wyniki, ponieważ wynikiem dzielenia 180/1023 zawsze będzie 0, przez co całe działanie również wyniesie 0. Przy zapisie 180.0/1023 mamy do czynienia z dzieleniem rzeczywistym, którego wynikiem będzie liczba rzeczywista. Następnie przy przemnożeniu przez zmienną całkowitą pot dostaniemy również liczbę rzeczywistą. Ostateczny wynik jest rzutowany na liczbę całkowitą w momencie przypisania operatorem równości.
Ulepszenie – dodatkowy if
W celu ulepszenia naszego kodu, chcieliśmy aby położenie ramion serwa było aktualizowane jedynie wtedy, kiedy zmienimy położenie potencjometru. Tym samym chcemy uniknąć sytuacji wydawania polecenia „ustaw serwo na pozycję XX” jeśli właśnie aktualną pozycją jest XX (nie ma to sensu, mimo tego, że to działa – jak w naszym pierwszym, prostym programie). Użyliśmy do tego instrukcji sterującej if. W linii #1 dopisaliśmy kolejną zmienną nazwaną old, która ma za zadanie zapisywać poprzedni stan położenia potencjometru (odczytanego napięcia). W warunkach if-a sprawdzamy, czy zmienna pot (czyli aktualny stan potencjometru), różni się od zmiennej old (czyli jego poprzedni stan). Jeśli nie, funkcja Serial.print() nic nie wypisze i nie zmieniamy położenia serwa. W przeciwnym przypadku zostanie wypisane nowe napięcie, a ramiona serwa zmienią położenie. Na końcu przypisujemy zmienną old do pot, aby móc dokonać nowego porównania w kolejnej iteracji pętli.
int pot, old; //old - zmienna zapisujaca poprzedni odczyt
void loop(){
pot=analogRead(A0);
pot=pot*180.0/1023.0;
if (pot!=old){ //aby zmieniac polozenie tylko wtedy, kiedy sie zmienilo, a nie wyswietlac polozenie ciagle
Serial.print(pot);
silnik.write(pot);
old=pot;
}
}
Podsumowanie
Dzięki naszemu programowi możemy sterować ramionami serwa kręcąc potencjometrem. Przeliczenie wartości napięcia na stopnie umożliwia dość precyzyjne ustawienie serva.
2018, Ewelina (c)
Sygnały analogowe
Konwerter analogowo cyfrowy (DAC)
Sygnały analogowe to takie sygnały elektroniczne, które możemy zapisywac nie tylko jako 0 lub 1 (tak/nie, prawda/fałsz – tylko dwie wartości), ale w wielu „odcieniach” – w końcu pomiędzy zerem a jedynką jest nieskończenie wiele liczb. Oczywiście w informatyce wszystko musi byc skończone, tak więc tych „odcieni” (poziomów pomiędzy zerem a jedynką) jest skończona liczba. Układ zamianiający sygnał elektroniczny na informację cyfrową nazywa się konwerter analogowo cyffrowy (DAC) i mówiąc o nim podajemy jego zakres – liczbę bitów. Dla 8-bitowego DACa mamy wartości sygnału analogowego z przedziału od 0..255 (256 poziomów = 2^8), natomiast w przypadku 10-bitów 0..1023 (1024 poziomy = 2^10).
Potencjometr
Wygląda dość topornie – ale jeśl macie w domu zbyteczną gałkę z kryształów Swarowskiego to proszę śmiało przynieść i uatrakcyjnimy wygląd tego podzespołu elektronicznego 😉 Trzeba pamiętać o sposobie podłączania go do budowanych układów. Widzimy trzy nóżki więc:
- jedna skrajna nóżka (nie ma różnicy która) powinna być podłączona do masy (nazwijmy ją GND i oznacza napięcie zero V)
- druga skrajna nóżka musi być podłączona do danego napięcia, nazwijmy je VCC
- środkowa nóżka będzie „wyprowadzać” napięcie od zera do VCC w zależności od ustawienia pokrętła na potencjometrze.
Na zajęciach dość szczegółowo omówiłem budowę potencjometru i zasadę jego działania – dzielnik napięć – ale do tego jeszcze obiecuję wrócić. Na razie skupmy się na powyższych informacjach jak potencjometr łączymy w układ. Jako przykład możemy podłączyć „minus” bateryjki AAA do pierwszej nóżki, „plus” do trzeciej „nóżki”, wówczas z pinu numer dwa otrzymamy napięcie od 0..1.5V. Innym przykładem podłączenia jest wykorzystanie Arduino i pinów GND (podłączamy do pinu 1 na potencjometrze) oraz 5V (do pinu 3 na potencjometrze) – wówczas mamy kontrolę potencjometrem nad napięciem 0..5V (pin 2 na potencjometrze).
Pinem #2 z potencjometru możemy zasilać jakiś układ – sprawdzaliśmy to z LED-em wpiętemym pomiędzy piny #1 (GND) i #2(0..3.3V) potencjometru, lub mozemy podłączyć pin #2 do wejścia A0 w Arduino – wówczas odczytamy wartość napięcia ustawionego potencjometrem jako liczbę z przedziału 0..1023 (Arduino UNO ma DAC 10-bitowy).
Kalibracja
Konieczne jest sprawdzenie poziomu napięcia 5V w Arduino – może się zdarzyć, że nasza płytka jest uszkodzona lub producent nie trzymał standartów i zamiast 5V mamy 5.1V. To spora różnica. W przypadku uszkodzonych płytek – których wcale nie ma co wyrzucać – napięcie zamiast 5V może być nawet 4.5V co jest już ogormną różnicą! Dlatego konieczne jest sprawdzenie multimetrem wartości napięcia produkowanego przez Arduino z pinu 5V.
Odczytywanie sygnału – analogRead
void setup(){
Serial.begin(9600);
}
int odczyt;
void loop(){
odczyt = analogRead(A0);
Serial.print("Odczytalem ");
Serial.print(odczyt);
Serial.print(" ---> ");
Serial.print(odczyt*4.9/1024);
Serial.println(" [V] ");
}
Ten prosty program odczytuje sygnał podłączony do pinu A0 w Arduino (możesz wybrac inne wyjścia: A1,A2…A5) i wypisuje jego wartość jako liczbę z przedziału 0..1023 (gdyż Arduino UNO ma przetwornik DAC 10-cio bitowy, czyli 2^10=1024) a także podaje wartość w woltach. Sprawdziłem, że w moim Arduino napięcie z pinu 5V wcale nie wynosiło 5V a 4.9V i dlatego linia #10 zawiera właśnie takie przeliczenie na wolty. Zwróć też uwagę na sposób komunikowania się z ekranem – budowanie napisu w jednej linii i dopiero na koniec użycie funkcji Serial.println().
Posługują się powyższym programem najpierw sprawdzamy odczytywane napięcie z pinu 3.3V Arduino, potem 5V Arduino – porównując wartości wypisywane na ekranie z multimetrem. Potem możemy użyć jakiś baterii a w końcu wykorzystać potencjometr i jego środkowy pin.
PWM (cyfrowe piny z „tyldą” ~)
PWM to szybkozmienny sygnał cyfrowy (cyfrowy, a więc tylko dwie wartości: 0V oraz 5V). Szybkozmienny oznacza naprawdę szybkie zmiany, 500x na sekundę – czyli co 2ms! Musimy podać jaki ułamek czasu (z przedziału 2ms) będzie napięciem wysokim (5V) a wówczas pozostały czas będzie napięciem 0V. Ten ułamek czasu musimy wyrazić jako liczbę całkowitą z przedziału 0..255 (gdzie 255 to 100%) gdyż w Arduino UNO piny PWM są 8-bitowe (a 2^8=256). Wartość 0..255 nazywa się to wypełnieniem sygnału.
Sterowanie wypełnieniem – analogWrite
void setup(){
pinMode(3, INPUT);//pin cyfrowy z tyldą = PWM
}
void loop(){
analogWrite(3, 0);
delay(5000);
analogWrite(3, 100);
delay(5000);
analogWrite(3, 200);
delay(5000);
analogWrite(3, 255);
delay(5000);
}
Powyższy program wybiera pin #3 Arduino UNO (zwróć uwagę, że jest on onzaczony „tyldą” na płytce – czylli jest to pin PWM, ale można wybrac inne piny PWM) i steruje jego wypełnieniem. W tym celu używamy funkcji analogWrite(int,int) podając numer pinu którego ma dotyczyć zmiana (koniecznie pin z tyldą!) oraz wartość wypełnienia (koniecznie z przedziału 0..255). Co 5 sekund zmienia jego wartość, którą możemy odczytać na multimetrze – ale uwaga, będzie to tylko wartość średnia! Aby zobaczyć zmiany napięcia w okresach 2ms należało by użyć oscyloskopu.
Praca domowa
Wykorzystując informacje z dzisiejszych zajęć uruchomić wirtualne Arduino i zbudować program z potencjometrem, który steruje jasnością LED-a. Musimy więc odczytywać wartości z potencjometru a następnie odpowiednio sterować zasilaniem LED-a. Powodzenia!
(c) KG, 2017
Łączenie rejestrów przesuwnych oraz sterowanie serwomechanizmami.
Na ostatnim spotkaniu przed przerwą świąteczną rozwinęliśmy projekt rozpoczęty na poprzednich zajęciach tj. wyświetlanie cyfr przy pomocy wyświetlacza siedmiosegmentowego oraz rejestru przesuwnego. Główną korzyścią tej metody jest użycie jedynie trzech pinów cyfrowych Arduino. Okazuje się, że dołączenie drugiego wyświetlacza siedmiosegmentowego wymaga podłączenia drugiego rejestru przesuwnego, ale liczba pinów cyfrowych pozostaje taka sama !
Logika stosowania wielu rejestrów przesuwnych może być porównana do tworzenia jednego rejestru, który przedłużamy kolejnymi chipami 74HC595.
Podłączenie drugiego układu scalonego 74HC595 ogranicza się do podłączenia pinów RCLK oraz SRCLK do tych samych pinów arduino co odpowiadające RCLK oraz SRCLK piny pierwszego rejestru. Będzie to oznaczało, że nowy chip będzie on otrzymywał te same sygnały sterujące co pierwszy. Różnicą jest podłączenie pinu SER. Zamiast bezpośrednio do Arduino, podłączamy ten pin do wyjścia 9 naszego pierwszego rejestru przesuwnego. Dzięki temu całość będzie funkcjonowała jak jeden, przedłużony rejestr przesuwny.
Nasuwa się pytanie: jak zmodyfikować ostatnio napisany przez nas program tak, by poprawnie działał?
Odpowiedź jest prosta. Przygotowaliśmy się na to już na poprzednim spotkaniu i wystarczy wprowadzić nową wartość dla zmiennej ileScalakow (widocznej od razu w pierwszej linijce kodu), tak by równała się liczbie zastosowanych rejestrów, czyli 2:
Cały kod pozwalający sprawdzić działanie wyświetlaczy
#define ileScalakow 2
#define ilePinow ileScalakow * 8
int SER=8;
int RCLK=9;
int SRCLK=10;
int rejestr[ilePinow];
void setup(){
pinMode(SER, OUTPUT);
pinMode(RCLK, OUTPUT);
pinMode(SRCLK, OUTPUT);
czyscRejestr();
zapiszRejestr();
}
void czyscRejestr(){
for(int i=0; i<ilePinow; i++)
rejestr[i]=LOW;
}
void zapiszRejestr(){
digitalWrite(RCLK, LOW);
for(int i=ilePinow-1; i>=0; i--){
digitalWrite(SRCLK, LOW);
digitalWrite(SER, rejestr[i]);
digitalWrite(SRCLK, HIGH);
}
digitalWrite(RCLK, HIGH);
}
void ustawPin(int ktory, int wartosc){
rejestr[ktory]=wartosc;
}
void loop(){
int i;
for(i=0;i<ilePinow;i++)
ustawPin(i, LOW);
zapiszRejestr();
delay(500);
for(i=0;i<ilePinow;i++){
ustawPin(i, HIGH);
zapiszRejestr();
delay(500);
}
}
Po tej prostej zmianie kod działa poprawnie. Jest to przykład jak odpowiednie wprowadzanie zmiennych pozwala na skalowalność i rozwijanie kreowanych programów.
Sterowanie serwomechanizmami
Serwomechanizm, lub potocznie serwo, to nic innego jak silniczek prądu stałego sterowany PWM (modulator szerokości impulsu) z podłączonym odpowiednim układem zębatek. To niewielkie i niedrogie urządzenie pozwala wygenerować niespodziewanie dużą siłę i moment obrotowy, szczególnie zważywszy na jego rozmiary i nieduży pobór mocy (przy mini serwach np. używanych przez nas SG92r produkcji TowerPro rzędu kilku watów).
Przed rozpoczęciem jakichkolwiek doświadczeń z serwami warto pamiętać właśnie o poborze mocy. Rekomendowane jest zasilanie ich z zewnętrznego źródła mocy np. baterii lub zasilacza prądu stałego. Przyczyną jest niebezpieczeństwo, jakie niesie za sobą skok natężenia prądu podczas ruchu serw – podłączenie kilku na raz do Arduino może niechybnie doprowadzić do spalenia sterownika.
Tworzenie programu sterującego serwami
Arduino posiada dedykowaną bibliotekę do sterowania serwami, co niezwykle ułatwia sterowanie i zarządzanie.
#include <Servo.h>
Nasz program pozwala na wpisywanie wartości do monitora szeregowego i dyktowanie ich serwomechanizmom.
Servo serwomechanizm;
int pozycja = 90;
void setup()
{
serwomechanizm.attach(9);
Serial.begin(9600);
}
„Servo” jest formą deklaracji, że dany obiekt o nazwie „Serwmechanizm” ma być traktowany przez interpreter kodu jako serwomechanizm. Deklarujemy je w tej samej konwencji, co np. zmienne typu integer. Traktowanie go jak serwomechanizm oznacza, że możemy przypisać mu jakiś pin oraz pozycję (będą to odpowiednie zmienne w obiekcie Servo).
W naszym kodzie w etapie setup() przypisaliśmy pozycję wyjściową 90 stopni (2. linijka), pin 9 (7. linijka) oraz uruchomiliśmy monitor szeregowy dla częstotliwości 9600 baud. Następnie w loop() przy pomocy metody „parseInt” każemy „nasłuchiwać” wartości, które zostaną przypisane zmiennej „pozycja”.
void loop()
{
if (Serial.available() > 0) {
pozycja = Serial.parseInt();
}
if (pozycja > 0 && pozycja < 180) {
serwomechanizm.write(pozycja);
} else {
pozycja = pozycja%160+10;
serwomechanizm.write(pozycja);
}
}
Tym sposobem możemy sterować serwomechanizmem z klawiatury przypisując mu kąt od 0 do 180 stopni. Warto jednak pamiętać, by unikać skrajnych pozycji takich jak 0 i 180 stopni, gdyż w niektórych przypadkach może to doprowadzić do uszkodzenia serwomechanizmu.
Adnotacja: W bloku „else” umieściłem zabezpieczenie, które nie pozwoli również na przypisanie wartości większych niż 180. Była to nadprogramowa metoda, która pozwala ograniczyć przypisywane na serwo wartości tak, by zamykały się pomiędzy bezpiecznymi kątami 10 – 170 stopni. Sposoby zabezpieczania zależą od nas, jednak nie warto ich zaniedbywać. Szkoda naszego sprzętu i nerwów!
Pomiar prądu płynącego przez serwo.
Na bardziej ciekawych czekała również możliwość pomiaru prądu płynącego przez serwo. Warto pamiętać, że pomiar natężenia prądu należy przeprowadzać szeregowo względem badanego układu. Oznacza to, że multimetr w trybie pomiaru prądu musi być „po drodze” prądu między źródłem zasilania, a serwem. Dlatego zrobiliśmy to w następujący sposób:
Źródło napięcia (bez obaw, 5V i prąd zdecydowanie poniżej 1 A można swobodnie „izolować” suchymi dłońmi) dołączyliśmy do czerwonej sondy multimetru, a czarną do wejścia 5V serwa – jest to właśnie połączenie szeregowe.
Przy okazji mogliśmy zbadać wartość prądu pobieraną przez pracujące serwo. Wartości te na ogół wynosiły kilkadziesiąt mA, ale czasami (w skarajnym położeniu a także podczas zmiany położenia) wynosiły 100-200 mA. Oznacza to, że podłączenie kilku serw do Arduino jako źródła napięcia (a nie tylko do zadawania sygnału) skończyłoby się spaleniem płytki. Dlatego budując bardziej złożone układy z pewnością użyjemy zewnętrznych źródeł napięcia.
Do zobaczenia na kolejnym spotkaniu!
Maciej (c)