Sygnały analogowe

Posted on 9 stycznia, 201814 stycznia, 2018 by gawryl

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!

Zajęcia nr 5 – serwo silniki, map(), bluetooth

Posted on 14 czerwca, 201715 czerwca, 2017 by gawryl

Serwo silnik (a właściwie mikro-serwo)

serwo1 Czyli silnik, który obraca się od 0 do 180 stopni (ma blokadę na inne wychylenia). Potem utrzymuje swoją pozycję. Służy do tworzenia obrotowych ramion itd…

Trzy przewody – zasilanie (czerowny +5V, czarny/brązowy GND) oraz jeden sterujący – musi być PWM. Za dużo nie wnikałem o co chodzi w sterowaniu tym silnikiem, tylko wspomniałem o potencjometrze wewnątrz i o wypełnieniu sygnału sterującego… więcej może później? Zobaczymy.

Do sterowania tym silnikiem użyliśmy 2 nowych funkcji z nowej biblioteki:

#include <Servo.h> – na początku programu informujemy, że chcemy funkcje z tej nowej biblioteki
Servo silniczek; tworzymy zmienną typu silnik-serwo, czyli właśnie o to nam chodzi!
silniczek.attach(3); powoduje przekazanie informacji do Arduino, że sterujemy silnikiem przez pin numer 3 (przypominam: musi być to pin PWM, czyli jak nie 3, to 5,9…)
silniczek.write(133); ustawia nasz silnik w pozycji 133 stopni. Albo na dowolny inny z zakresu 0..180 stopni. Dziecinie proste 😉

Serwo sterowane z klawiatury

Przypomnieliśmy sobie jak odczytywać liczby z klawiatury (funkcja parseInt() dla obiektu Serial) i stworzyliśmy program ustawiający silnik w pozycji wczytanej z klawiatury. Proste a przyjemne. No i zawsze warto powtarzać wiedzę 😉

Serwo sterowane potencjometrem

Połączenie poprzednich zajęć – potencjometr liniowy (dzielnik napięć!) wykorzystany do ustawiania pozycji serwa – ruszam „gałką” w lewo, orczyk w serwie obraca się w lewo. Tak samo w prawo. Fajne!

Serwo sterowane potencjometrem – program PRO

Dbamy o szczegóły – i nie chcemy ustawiać położenia serwa wówczas, gdy potencjometr nie zminił swojej pozycji. Bez złośliwości – my staramy się programować na serio!

Prąd „zjadany” przez serwo – mierzymy!

W skrajnych ustawieniach serwa (tj. w okolicy 0 stopni, oraz w okolicach 180 stopni) słyszymy buczenie/piszczenie serwo-silnika. Coś się dzieje. Amperomierz w garść i mierzymy prąd.

serwo1

Przyjrzyj się uważnie obrazkowi i zwróć uwagę, jak podłączony jest amperomierz.

Oczywiście w wirtualnym Arduino (ciągle polecam circuits.io) silniczek serwo jest idealny i nie widzimy tego, co było u nas na zajęciach….

Dodatkowo: w przypadku mierników uniwersalnych ustaw największą wartość prądu, jaką się spodziewasz dostać – nie odwrotnie! W przeciwnym przypadku zwiększając zakres przepalisz bezpiecznik w multimetrze…

Funkcja map()

Czyli skalowanie wartości z jednego zakresu na drugi zakres. Przykład, z którym my się bawiliśmy: serwo silniczek sterowany potencjometrem. Odczytujemy nastawy potencjometru z portu analogowego Arduino jako liczbę (nazwijmy ją x) z zakresu 0..1023, a następnie ustawiamy serwo w położeniu z zakresu 0..180 stopni (nazwijmy te stopnie y). Czyli musimy dokonać zamiany wczytaj liczby x na y. Na zajęciach pokazałem skalowanie funkcją liniową, rozwiązaliśmy ten układ równań, ale Arduino jest także dla tych co tego nie umieją zrobić i przygotowało funkcję map(). W naszym przypadku będzie to:

y=map(x, 0, 1023, 0, 180);

Należy pamiętać, że funkcja map() działa tylko na liczbach całkowitych (int).

Serwo sterowane przez Androida – bluetooth XM-15B

Dlaczego ten? Bo działa w zakresie 3-6V, czyli można go bezpiecznie podłączyć do Arduino. Inne modele – popularne HC-05, HC-06 komunikują się przez 3.3V i wymagają „zbijania” napięcia (np. dzielnikiem napięć). To proste, ale… po co się w to bawić, jak można kupić właśnie moduł pozbawiony tej uciążliwości? Praujemy więc z XM-15B.

Pamiętajmy o łączeniu „na krzyż” portów RxD,TxD modułu XM-15B z portami RxD,TxD płytki Arduino (także tymi wirtualnymi).

Komunikacja z 8LAMP

Ze sklepu Play bierzemy prostą apkę i sprawdzamy, co ona wysyła do naszego bluetootha. Kod:

#include <SoftwareSerial.h>

#define RxD 8
#define TxD 9
SoftwareSerial btSerial(RxD,TxD);

void setup() {
  Serial.begin(9600);
  btSerial.begin(9600);
  Serial.println("start!");
}

void loop() {
  if (btSerial.available()){
    Serial.print("Odebrałem znak= ");
    Serial.println(btSerial.read());
  }  
}

Następnie tak modyfikujemy ten program, by wczytany znak sterował naszym serwem – guzik '1′ ustawiał serwo na 90 stopni, guzik '2′ na 10 stopni i guzik '3′ na 170 stopni. Inne modyfikacje mile widziane 😉

Ważne

Na następne zajęcia proszę o zainstalowanie ze sklepu Play aplikacji Arduino Bluetooth Controler bo będziemy sterować pojazdem.

fotorezystor + oscyloskop (processing, finał bis)

Posted on 21 lutego, 201722 lutego, 2017 by gawryl

Oscylockop – finał „bis”

Sesja powoli za nami… a my wróciliśmy do fotorezystora i wykresów. Oto co udało się nam powtórzyć:

praca z multimetrem – mierzenie oporności, napięcia
dzielnik napięć na płytce stykowej – wyliczanie oczekiwanego napięcia i sprawdzanie multimetrem
dzielnik napięć z fotorezystorem
podłączenie Arduino do naszego dzielnika i wypisywanie odczytów na ekran
zamiana liczb całkowitych z portu analogowego Arduino na konkretne wartości napięcia – porównanie z multimetrem
zmiana programu w Arduino: stosujemy protokół wysyłania liczb całkowitych, omawiany na wcześniejszych zajęciach
uruchomienie processinga z prostym oscyloskopem i cieszenie się wykresem!

Kolejne zajęcia – także we wtorek 16:00 – czujka pola magnetycznego + niespodzianka. Zapraszam!

Podstawy: dzielnik napięć, PWM, fotorezystor = inteligentne oświetlenie

Posted on 22 listopada, 201623 listopada, 2016 by gawryl

Podstawy: dzielnik napięć

Obrazki z tablicy…

Najpierw bawiliśmy się multimetrem i dzielnikiem:

a potem podłączyliśmy fotorezystor i próbowaliśmy go odczytywać z poziomu Arduino.

Pomysł Pana Pawła (PPP) aby najpierw zmierzyć multimetrem prąd płynący w obwodzie, a następnie znając podane napięcie i stosując prawo Ohma otrzymywać wartość rezystancji na fotooporniku – był dobry, ale wymagał ówczesnego użycia amperomierza (z multimetru). Mi bardziej chodziło o wykorzystanie fotorezystora w ten sposób, aby uzyskać informację czy go zasłaniamy czy nie, czy jest dużo światła zastanego (w pomieszczeniu) czy jest ciemno. Dlatego nie koniecznie interesuje mnie sama wartość oporu, a raczej jej zmiany. Dlatego po sprawdzeniu działania PPP i przyznaniu mu racji (a raczej Ohmowi), zaproponowałem zastosowanie dzielnika napięć i mierzenia napięcia w standardowy spodówb

void setup(){
  Serial.begin(9600);
}

void loop(){
  Serial.println(analogRead(A0));  
  delay(100);
}

W zależności od kolejności oporników (stałego R i zmiennego fotorezystora) otrzymywaliśmy liczby rosnące lub malejące zasłaniając fotorezystor ręką. Dodatkowo można było użyć latarki z telefonu komórkowego i symulować mocne oświetlenie.

PWM

Aby zrobić inteligentne oświetlenie potrzebowaliśmy sposobu na kontrolowanie jasności LED-a. Poznaliśmy Pulse Width Modulation i piny cyfrowe Arduino z „falką” (wolę: tyldą).

Inteligentne oświetlenie

To nic innego jak połączenie dwóch poznanych schematów:

mierzymy napięcie na fotorezystora przez wejście analogowe, a następnie
ustawiamy jasność LED-a sterując wypełnieniem PWM.

Jedyny problem to kwestia zamiany odczytywanych wartości z portu A0 (fotorezystora) na wartości akceptowane przez piny PWM (przypominam: 0..255). W tym celu wróciliśmy do gimnazjum i zastosowaliśmy funkcję liniową.

Dla przykładu: Pani Emanuela zastosowała stały opornik R o takiej wartości, że na porcie A0 odczytywała wartości 130 gdy fotorezystor był zasłonięty palcem, oraz 500 gdy był oświetlany światłem zastanym. Wartości pomiędzy przedziałem 130..500 odpowiadały częściowemu zasłonięciu ręką fotorezystora. Trzeba to teraz zamienić na liczby 0..255 aby sterować LED-em przez PWM (bo PWM akceptuje właśnie takie liczby, a nie 130..500). Dlatego stosujemy liniowe skalowanie (y=ax+b, współczynniki a i b na razie nie znane), gdzie wartość 130 ma odpowiadać maksymalnemu świeceniu LED-a, czyli 100% wypełnieniu PWM-a (wartość 255), natomiast gdy odczytujemy 500 (jest jasno) to LED ma się nie świecić (wypełnienie 0). Trzeba skonstruować układ równań i wyznaczyć a oraz b a następnie przeliczać wskazania z portu A0 (traktując je jako x w równaniu prostej, a otrzymany y to właśnie wartość przekazana do PWM-a). Poniższy rysunek wyjaśniał ten opis:

Z kolei Pan Paweł użył innego rezystora (oraz innej kolejności ustawienia oporników) i miał następujący schemat do rozważenia

W obu przypadkach trzeba było rozwiązać otrzymany układ równań na kartce a następnie wpisać liczby (wyliczone współczynniki a i b) to takiego prostego programiku:

#define lampka 9
float a=0.689189, b = 344.595;

void setup(){
  Serial.begin(9600);
  pinMode(lampka, OUTPUT);
}

void loop(){
  int fotorezystor = analogRead(A0);  
  Serial.print("fotorezystor=");
  Serial.print(fotorezystor);  
  Serial.print("-->");  
  int pwm = a*fotorezystor+b:
  Serial.print(" PWM=");  
  Serial.println(pwm);
  analogWrite(lampka, pwm);  
  delay(100);  
}

Wrócimy do tego programu na kolejnym spotkaniu, bo trzeba tu o paru kwestiach wspomnieć. Ale już teraz zachęcam do zabawy z powyższym programikiem na wirtualnym Arduino (jest tam też wirtualny fotorezystor). Proszę też zastanowić się nad następującymi kwestiami:

dlaczego Pan Paweł miał prostą o współczynniki kierunkowym a>0, a Pani Ema a<0 ?
kto zastosował lepszą wartość opornika stałego – Pani Ema czy Pan Paweł, a może to nieistotne?

Zapraszam za tydzień!

Podstawy – wejście analogowe + potencjometr

Posted on 15 listopada, 201616 listopada, 2016 by gawryl

Podstawy – komunikacja szeregowa i obiekt Serial.

Z racji sporej liczby nowych ludzi (nie tylko studentów), głodnych wiedzy i żądnych przygód (zdjęć nie publikuję – tak, jak się umawialiśmy) rozpoczęliśmy od przypomnienia podstaw… Na warsztat trafiło pojęcie zmiennej. Aby to pojęcie „namacalnie” zobrazować przygotowałem programik, w którym poziom życia bohatera (np. Wiedźmina) reprezentowane przez zmienną energia ciągle malał (np. bohater ranny = krwawi). Aktualna wartość życia był wypisywany na ekranie monitora (via obiekt Serial i metoda print/println).

byte energia=77;

void setup(){
  Serial.begin(9600);
  energia=17;
}

void loop(){
  Serial.print("Energia= ");  
  Serial.println(energia);  
  delay(1000);
  energia= energia-1;  
}

Powyższy programik posłużył także do omówienia pojęć bit i bajt oraz wielkości informacji, jaką można zapisać wiadomości za pomocą n-bitów. Zapiski z tablicy w trakcie zajęć (pokolorowałem już po zajęciach):

gdzie przypominam, ze RAM na moim super-obrazku przedstawia całą pamięć operacyjną płytki Arduino UNO (dlatego komórki pamięci – bajty – są ponumerowane od 1..2048, bo UNO ma 2kB pamięci), gdzie mikrokontroler przechowuje właśnie zmienne. W szczególności w naszym programie zaznaczyłem miejsce w pamięci, gdzie zadeklarowaliśmy zmienną energia. Na tym rysunku (modyfikowanym w trakcie zajęć – pamiętacie?) zmienna ta zajmuje 2 komórki (bajty) i odpowiada to już sytuacji innej niż z pierwszego listingu programu: mianowicie int energia=77; Zmienna typu int to 16 bitów, czyli 2^16 różnych informacji (kolor zielony na pokolorwanej tablicy, natomiast kolor żółty – to bity). Pierwotnie była to zmienna byte, czyli 8 bitów i 256 dopuszczalnych wartości (kolor niebieski). Ta pierwsza wersja programu była bardzo treściwa, gdyż pokazywała sytuację co się dzieje z wartością zmiennej, gdy przekraczamy jej dopuszczalny zakres: w naszym przypadku zmniejszaliśmy wartość zmiennej energia co 1 sekundę (delay(1000)) no i gdy mieliśmy już „na liczniku” 0 (zero) to wcale nie pojawiło się -1 (minus jeden) tylko… 255! a potem juz 254… 253… itd. Warte to jest zapamiętania (no i oczywiście w drugą stronę – gdybyśmy zwiększali naszą zmiennę z wartości 255 o jedne to… wiesz, co będzie? jeśli nie, proponuję sprawdzić!).

Potencjometr nastawny.

Na spotkaniu poznawaliśmy potencjometr nastawny i jego podłączenie/obsługę przez Arduino. Ale najpierw zabawy z bateryjka i multimetrem – ćwiczenia obowiązkowe. Dodatkowo przypomniałem co to jest dzielnik napięć i jak „to się je”, a tym samym (mam nadzieję) zrozumieliśmy działanie potencjometru nastawnego (w naszym przypaku liniowego 10k).

Powyższy schemat tłumaczy działanie potencjometru… Warty zapamiętania jest też taki rysunek:

który pokazuje co się dzieje gdy mierzymy napięcie, lub raczej (prawidłowo) różnicę napięć (potencjałów). Podłaczamy do pinu nr 1 (kolor czerwony na rysunku, numeracja odnosi się do schematu potencjometru z poprzedniego obrazka) „minus” z bateryjki, a do pinu 3 „plus” z bateryjki (niech to będzie 4x bateria AAA – czyli właśnie 6V). Gdy ustawiemy potencjometr w takiej pozycji, aby zmierzone napięcie na pinie nr 2 wynosiło 4V to w zależności od tego, jak mierzymy (=jak podłączamy sondy multimetru) możemy otrzymać też wynik 2V. Chodzi oczywiście o poziom odniesienia (sonda czerwona jest cały czas w „środkowej nóżce”, czyli pinie nr 2, natomiast sonda czarna – poziom odniesienia właśnie – może być w pinie 1 lub 3). Jeśli naszym poziomem będzie GND (=0V, pin 1) to faktycznie otrzymamy 4V, ale gdy mierzymy napięcie pomiędzy „szczytem góry” a naszą pozycją (sonda czarna „na szczycie”, czyli pinie 3) to oczywiście otrzymamy 2V. Wszystko jasne?

Po zabawach z multimetrem (i LED-em podłączonym do potencjometru) przyszedł czas na podłączenie do Arduino i wpisanie nowego kodu programu:

#define IN A0

void setup(){
  Serial.begin(9600);
}

void loop(){
  int war = analogRead(IN);  
  Serial.print(war);  
  Serial.print("-->");  
  Serial.print(war*5.0/1024);  
  Serial.println("V");  
  delay(100);  
}

Ten program (dla odróżnienia się od poprzedniego) wprowadza etykiety nazw (za pomocą dyrektywy preprocesora #define) i nie posługuje się zmienną w tym celu. Zmienna pojawia się dopiero w funkcji loop(). Przypominam, że „zysk” ze stosowania etykiet nazw jest taki, że nie zajmują one pamięci RAM komputera… (ale są i minusy).

„Danie główne” dzisiejszego spotkania to piny analogowe Arduino, i aby je zrozumieć posłużyłem się takim rysuneczkiem:

gdzie pokazuję jakiś przebieg napięcia w czasie (krzywa czarna na wykresie V(t), minimalne napięcie 0, zaznaczone jest też poziom 5V), który teraz możemy odczytywać z rozdzielczością 7-miu poziomów (od 0..6). Mamy więc odczyty jako napięcia jako liczby całkowite 0,1,2,..,6 które odpowiadają napięciom 0V, 0.8333V, 1.666V, …, 5V (przedziały napięcia to właśnie dV=5/6V). Przy takiej rozdzielczości nie ma możliwości odróżnić napięć 0.2V, 0.6V czy 0.8V, gdyż te odczyty trafiają do jednego „worka” (tu: zero). Dopiero poziom 0.84V zmienia wartość mojego odczytu (tu: jedynka).

W przpadku Arduino mamy nie 7 dostępnych poziomów, a 1024 (gdyż jest tam przetwornik analogowo cyfrowy 10-cio bitowy, czyli 2^10=1024). Stąd też i dokładność pomiarów dużo lepsza niż na moim rysuneczku.

Co najciekawsze, wykonaliśmy kalibrację odczytów z analogowego portu Arduino – posłużyliśmy się multimetrem. Okazało się bowiem, że bez tego często pomiary były baaaardzo nietrafione (tj. dużo się różniły wskazania woltomierza od wskazań Arduino). Przyczyną były doś „spracowane” płytki Arduino…

Bardzo ważna była też informacja o dzieleniu liczb: przypominam, że 5/1024 jest zawsze 0 (zero), natomiast 5.0/1024 już nie.

Zapraszam za tydzień!

Zajęcia nr 6 – pilot IR, fotorezystor, map() i serwa

Posted on 9 października, 20169 października, 2016 by gawryl

Pilot na podczerwień – TSOP22xx

Czyli wykorzystujemy bibliotekę IRLib wraz z czujką TSOP22xx. Przy tej okazji pokazałem, jak instalowac biblioteki w Arduino IDE na 2 sposoby: z pliku zip, oraz ze środowiska.

Cujka TSOP22xx pożera bardzo mało prądu (jedynie 5 mA – patrz nota katalogowa) i dlatego zdecydowałem się pokazać Wam podłączenie jej bezpośrednio do płytki Arduino (czyli bez przewodów lub płytki stykowej). Jedna nóżka czujki siedziała w GND, druga w pinie numer 13 (zasilanie VCC) a trzecia – sygnałowa – w pinie 12 Arduino – bardzo stabilna konfiguracja. Należało tylko włączyć zasilanie na 13-tce aby odbiornik podczerwieni pracował – ale to już powinniśmy umieć (ponownie: pamiętacie „zabawy” z LED-ami? no właśnie po to one wszystkie…).

Nasz pierwszy projekt polegał na odczytywaniu kodów klawiszy z domowego pilota, a potem sterowanie trzema LEDami. Przy tej okazji poznaliśmy też wygodny zamiennik instrukcji if/else w języku C – a mianowicie switch/case.

Dzielnik napięć

Wróciliśmy do dzielnika aby pobawić się miernikami oraz… aby za chwilę wykorzystać je w projekcie inteligentnego oświetlenia sterowanego Arduio. Ale to za chwilę. Najpierw fajna (mam nadzieję) zabawa z multimetrem 😉

Dzielnik napięć – bardzo podstawowa wiedza, ale niezbędna podczas zabawy z Arduino i podobnymi. Dlatego zajęcia rozpoczęliśmy od dwóch rezystorów o tej samej wartości, wówczas ze wzoru na dzielnik Uwy= Uwe*R/(R+R1)= 0.5*Uwe i przy pomocy miernika uniwersalnego mierzyliśmy napięcie Uwy. Jako źródło mieliśmy do dyspozycji baterie AAA (różnie – jedni 2 sztuki, inni 4) o różnych napięciu. Dlatego aby prawidłowo wykonać to ćwiczenie trzeba było najpierw zmierzyć napięcie źródła. Dzielnik napięć zbudowaliśmy na płytce stykowej, o tak:

Gdy już prawidłowo zbudowaliśmy dzielnik napięć i rozumieliśmy co się dzieje z mierzonym napięciem, zastąpiliśmy fotorezystorem.

Fotorezystor

Oświetlenie fotorezystora powoduje zmniejszenie jego rezystancji (a tym samym zwiększenie płynącego przez niego prądu, jeśli mamy stałe napięcie zasilania). Oświetlenie zmienialiśmy albo zasłaniając ręką fotorezystor, albo oświetlając go latarką z telefonu komórkowego. Dalej zamieniliśmy jeden z rezystorów z naszego dzielnika napięć na fotoopornik i przeprowadziliśmy pomiary napięcia. Układy doświadczalne prezentowały się w ten oto sposób:

Warto podkreślić, że istotne jest który rezystor zastępujemy fotoopornikiem. Rysunki poniżej przedstawiają dwa podobne układy dzielnika napięć – zwróć uwagę na wskazania napięcia przy zmianie oświetlenia:

Czyli w jednej konfiguracji napięcie rosło oświetlając dzielnik, w drugiej – napięcie malało. Najpierw każdy z nas ustalił więc, co ma na swojej płytce aby kontrolować swój układ.

Odczyt zastanego oświetlenia

W tym ćwiczeniu do zbudowanego układu podłączyliśmy Arduino z pinem analogowym i odczytywaliśmy napięcie, niezależnie od miernika – to ważne, aby kontrolować to co wypisuje nam Arduino niezależnym miernikiem (u nas multimetrem). Ponownie okazało się, że aby otrzymać wyniki bardzo zbliżone do multimetru należało najpierw upewnić się jakie mamy faktycznie napięcie 5V w naszym Arduino (wiadomo – uczniowie/studenci popełniają błędy – a kto nie! – i płytka się uszkadza…. są więc płytki z napięciem 4.7V zamiast katalogowych 5V).

Inteligentne oświetlenie

Do układu podłączyliśmy LEDa, którego jasnością sterowaliśmy poprzez Arduino z pinem PWM (poprzednie zajęcia z przykładem Fade). Zabawa miała polegać na oprogramowaniu układu tak, aby LED gasł gdy jest dużo światła zastanego (mierzonego przez fotorezystor i wejście analogowe Arduino), oraz aby LED świecił mocniej i mocniej gdy światła zastanego braknie. Takie proste, ale inteligentne oświetlenie 😉

Tutaj poznaliśmy nową funkcję z biblioteki Arduino: map(). Funkcja ta przeskalowywała (liniowo) podaną wartość z pewnego zakresu (dziedziny, poniżej oznaczonej jako wartości od min_x do max_x), na inna wartość z innego zakresu (przeciwdziedzina, od min_y do max_y). Formalnie wygląda to następująco:

map(war, min_x, max_x, min_y, max_y)

co oznacza, że chcemy przeskalować wartość war z zakresu min_x do max_x, na wartość z przedziału min_y do max_y. W naszym przykładzie chodziło o przeskalowanie wartości odczytywanych przez analogRead (czyli wartości od 0 do 1023) do wartości podawanych do sterowania jasnością LEDa (przez PWM, czyli z zakresu 0..255). Dlatego skalowaliśmy

war2= map(war, 0, 1023, 255, 0);

To liniowe skalowanie przez funkcję map() nie ma „magii” w sobie, to proste wykorzystanie funkcji liniowej y=ax+b, znanej Wam z lekcji matematyki plus umiejętność rozwiązania układu równań. Dopowiadając: w liniowym skalowaniu mamy 2 nieznane parametry – współczynniki a i b prostej. Musimy więc podać dwa równania aby je wyznaczyć (chyba każdy pamięta, że do narysowania prostej potrzebne są tylko dwa punkty? więc stąd dwa równania…). Posługuję się wartościami krańcowymi, oczywistymi przy naszym zagadnieniu: chcę bowiem, by do PWMa trafiło 255 gdy na wejściu z analogRead-a było 0 (pierwsze równanie: y=255 gdy x=0), oraz chcę, by mieć wartość y=0 gdy podaję x=1023 (drugie równanie). Oba punkty podstawiam do niewiadomego y=a*x+b i otrzymuję układ równań. Funkcja map() znajduje a i b za nas i wyznacza każdą inną wartość leżącą na tej prostej.

UWAGA: map() działa tylko na liczbach całkowitych!

Przyjrzyjcie się ponownie mojemu rysunkowi – to prosta matematyka w zastosowaniu 😉

Sterowanie jasnością LDEa przez PWM robiliśmy poleceniem analogWrite(9, war2);

Okazało się, że aby wszystko działało dość widowiskowo należało najpierw wyskalować nasze odczyty jasności zastanej zmniejszając zakres…. W wielu przypadkach było więc potrzebne:

war2 = map(war, 400, 800, 255, 0);

co sprawdziło się metodą prób-i-błędów – w tym celu mocno debugowaliśmy nasz kod wypisując na ekran monitora odczytywane liczby.

Serwo silnik (a właściwie mikro-serwo)

Czyli silnik, który obraca się od 0 do 180 stopni (ma blokadę na inne wychylenia). Potem utrzymuje swoją pozycję. Służy do tworzenia obrotowych ramion itd…

Do sterowania tym silnikiem użyliśmy 2 nowych funkcji z nowej biblioteki:

#include <Servo.h> – na początku programu informujemy, że chcemy funkcje z tej nowej biblioteki
Servo silniczek; tworzymy zmienną typu silnik-serwo, czyli właśnie o to nam chodzi!
silniczek.attach(3); powoduje przekazanie informacji do Arduino, że sterujemy silnikiem przez pin numer 3 (przypominam: musi być to pin PWM, czyli jak nie 3, to 5,9…)
silniczek.write(133); ustawia nasz silnik w pozycji 133 stopni. Albo na dowolny inny z zakresu 0..180 stopni. Dziecinie proste 😉

Serwo sterowane z klawiatury

Prąd „zjadany” przez serwo – mierzymy!

W skrajnych ustawieniach serwa (tj. w okolicy 0 stopni, oraz w okolicach 180 stopni) słyszymy buczenie/piszczenie serwo-silnika. Coś się dzieje. Amperomierz w garść i mierzymy prąd.

Przyjrzyj się uważnie obrazkowi i zwróć uwagę, jak podłączony jest amperomierz.

Oczywiście w wirtualnym Arduino silniczek serwo jest idealny i nie widzimy tego, co było u nas na zajęciach….

Serwo sterowane pilotem na podczerwień

W tym przykładzie wróciliśmy do początku zajęć i ponownie wykorzystaliśmy pilot od telewizora – tym razem czytywaliśmy klawisze i ustawialiśmy serwo na konkretną wartość kąta. Dwa przyciski obracały serwo w lewo i w prawo, trzeci zaś ustawiał serwo w pozycję 90 stopni.

Serwo pracy ciągłej (aka 360 stopni)

Poznaliśmy też serwa obracające się „w kółko”, ale z kontrolą szybkości swoich obrotów. Sterowanie polegało na używaniu funkcji writeMicroseconds(), w której komenda STOP dla silnika wymagała podania wypełnienia 1500 ms, natomiast wypełnienie z zakresu 1501-2000 ms oznaczało obrót w prawą stronę z prędkością proporcjonalną do tego wypełnienia (i analogicznie z obrotami w lewą stroną – wypełnienie z przedziału 1000-1499 ms).

Ta sama funkcja writeMicroseconds() może być przydatna w korygowaniu niedoskonałości tanich, chińskich serw, które nie trzymają katalogowych parametrów – obrót od 0 do 180 stopni. Proszę tylko obchodzić się z nią ostrożnie, bo z poprzedniego ćwiczenia – gdzie mierzyliśmy prąd zjadany przez serwo – wiemy, że dużo się dzieje w skrajnych położeniach.

Koniec? Początek!

Z wielkim niedosytem kończymy nasze spotkania w ramach Talentów XXI w. Niedosyt bierze się z faktu, że umiemy obsługiwać kilka fajnych „klocków” i aż się prosi, aby je teraz połączyć w jakąś całość (samochodzik sterowany pilotem, albo obrotowa wieżyczka z laserem). Ale czas naszych spotkań dobiegł końca. Cóż… zachęcam do samodzielnej pracy i koniecznie pochwalcie się swoimi osiągnięciami – dlatego dla Was jest to początek przygody z Arduino (mam nadzieję!). Proszę śmiało pisać do mnie na email! Pozdrawiam i dziękuję za wspólną pracę, K. Gawryluk

Zajęcia nr 6 – fotorezystor, dzielnik napięć, map(), serwo silnik i znowu map()

Posted on 3 czerwca, 20163 czerwca, 2016 by gawryl

Dzielnik napięć

Bardzo podstawowa wiedza, ale niezbędna podczas zabawy z Arduino i podobnymi. Dlatego zajęcia rozpoczęliśmy od dwóch rezystorów o tej samej wartości, wówczas ze wzoru na dzielnik Uwy= Uwe*R/(R+R1)= 0.5*Uwe i przy pomocy miernika uniwersalnego mierzyliśmy napięcie Uwy. Jako źródło mieliśmy do dyspozycji baterie AAA (różnie – jedni 2 sztuki, inni 4) o różnych napięciu. Dlatego aby prawidłowo wykonać to ćwiczenie trzeba było najpierw zmierzyć napięcie źródła. Dzielnik napięć zbudowaliśmy na płytce stykowej, o tak:

Gdy już prawidłowo zbudowaliśmy dzielnik napięć i rozumieliśmy co się dzieje z mierzonym napięciem, zastąpiliśmy fotorezystorem.

Fotorezystor

Czyli w jednej konfiguracji napięcie rosło oświetlając dzielnik, w drugiej – napięcie malało. Było to przyczyną kilku wątpliwości na naszych zajęciach… Proponuję pobawić się tym w domu (na wirtualnym Arduino, jeśli nie posiadamy płytki).

Inteligentne oświetlenie

Do układu podłączyliśmy LEDa, którego jasnością sterowaliśmy poprzez Arduino z pinem PWM (poprzednie zajęcia + poprzednia praca domowa). Zabawa miała polegać na oprogramowaniu układu tak, aby LED gasł gdy jest dużo światła zastanego (mierzonego przez fotorezystor i wejście analogowe Arduino), oraz aby LED świecił mocniej i mocniej gdy światła zastanego braknie. Takie proste, ale inteligentne oświetlenie 😉

map(war, min_x, max_x, min_y, max_y)

war2= map(war, 0, 1023, 0, 255);

To liniowe skalowanie przez funkcję map() nie ma „magii” w sobie, to proste wykorzystanie funkcji liniowej y=ax+b, znanej Wam z lekcji matematyki plus umiejętność rozwiązania układu równań. Dopowiadając: w liniowym skalowaniu mamy 2 nieznane parametry – współczynniki a i b prostej. Musimy więc podać dwa równania aby je wyznaczyć (chyba każdy pamięta, że do narysowania prostej potrzebne są tylko dwa punkty? więc stąd dwa równania…). Posługuję się wartościami krańcowymi, oczywistymi przy naszym zagadnieniu: chcę bowiem, by do PWMa trafiło 255 gdy na wejściu z analogRead-a było 1023 (pierwsze równanie: y=255 gdy x=1023), oraz chcę, by mieć wartość y=0 gdy podaję x=0 (drugie równanie). Oba punkty podstawiam do niewiadomego y=a*x+b i otrzymuję układ równań. Funkcja map() znajduje a i b za nas i wyznacza każdą inną wartość leżącą na tej prostej.

UWAGA: map() działa tylko na liczbach całkowitych!

Przyjrzyjcie się ponownie mojemu rysunkowi – to prosta matematyka w zastosowaniu 😉

Okazało się, że w wyniku różnego łączenia fotoopornika w układ niektórzy uczniowie musieli stosować:

war2 = map(war, 0, 1023, 255, 0);

co oznaczało taką sytuację:

Serwo silnik (a właściwie mikro-serwo)

Czyli silnik, który obraca się od 0 do 180 stopni (ma blokadę na inne wychylenia). Potem utrzymuje swoją pozycję. Służy do tworzenia obrotowych ramion itd…

Do sterowania tym silnikiem użyliśmy 2 nowych funkcji z nowej biblioteki:

#include <Servo.h> – na początku programu informujemy, że chcemy funkcje z tej nowej biblioteki
Servo silniczek; tworzymy zmienną typu silnik-serwo, czyli właśnie o to nam chodzi!
silniczek.attach(3); powoduje przekazanie informacji do Arduino, że sterujemy silnikiem przez pin numer 3 (przypominam: musi być to pin PWM, czyli jak nie 3, to 5,9…)
silniczek.write(133); ustawia nasz silnik w pozycji 133 stopni. Albo na dowolny inny z zakresu 0..180 stopni. Dziecinie proste 😉

Serwo sterowane potencjometrem

W tym przykładzie wróciliśmy do poprzednich zajęć i ponownie wykorzystaliśmy potencjometr – tym razem czytywaliśmy wartości napięcia na potencjometrze przez Arduino (i wejście analogowe, np. A0) a następnie ustawialiśmy serwo na konkretną wartość kąta. Ponownie użyliśmy funkcję map() w taki oto sposób:

kąt = map( potencjometr, 0, 1023, 0, 180);

gdzie kąt to właśnie wartość kąta, na jaką ma się ustawić serwo (z zakresu 0..180 stopni), a potencjometr to wartość napięcia na wyjściu z potencjometra (z zakresu 0..1023). Upewnij się, że rozumiesz kolejność przekazywania parametrów do funkcji map().

Program działał na prostej zasadzie:

potencjometr = analogRead(A0);
kąt = map( potencjometr, 0, 1023, 0, 180);
silniczek.write(kąt);

i ponownie od początku. Taki program miał jednak pewien problem, gdyż gdy nic nie zmienialiśmy na potencjometrze, to nasz program ciągle przeliczał wartość napięcia na kąt i ciągle ustawiał serwo w pozycji, w której już był! To głupie, prawda? Jak na pierwsze rozwiązanie OK, ale po dłuższym przyjrzeniu się widać, że nie jest dobrze. Dlatego zaproponowałem ulepszyć program tak, by serwo nie było ustawiane gdy pozycja potencjometru się nie zmieniła. W tym celu należało pamiętać poprzednie ustawienia potencjometru (lub poprzedni kąt) i porównywać tą wartość z nowymi ustawieniami. Zaproponowałem taki oto kod:

#include <Servo.h>
#define potencjometr A0

Servo silniczek;  
void setup() {
  Serial.begin(9600);
  silniczek.attach(3);
  pinMode(potencometr, INPUT);
}

int pot, kat, ost_kat;
void loop() {
  pot = analogRead(potencjometr);
  kat = map(pot, 0, 1023, 0, 180);
  if (kat != ost_kat){
    Serial.print(pot);
    Serial.print(" czyli  ");
    Serial.println(kat);
    silniczek.write(kat);           
    ost_kat=kat;
  }
  delay(100);                 
}

Gratuluję tym, którym udało się samodzielnie na to wpaść! Przy okazji: w powyższym programie jest o jedną zmienną za dużo… nie ma bowiem potrzeby tworzyć zmiennej pot. Można się jej pozbyć i zastąpić dwie linijki tak:

int kat, ost_kat;
void loop() {
  kat = analogRead(potencjometr);
  kat = map(kat, 0, 1023, 0, 180);
...
}

Kluczowa tutaj linijka to kat = map(kat, 0, 1023, 0, 180); którą należy rozumieć tak, że nowa wartość zmiennej kat zostaje ustawioina na postawie funkcji map() ze starej wartości zmiennej kat. Symbol = („równa się”) jest tak zwanym w informatyce operatorem left-assign operator (czyli operator przypisania lewostronnego, tj. najpierw obliczamy wszystko z lewej strony, a dopiero potem obliczona wartość przekazana jest to prawej strony – zmiennej). Z matematycznego punktu widzenia jest to skomplikowana funkcja rekurencyjna…. ale tutaj symbol = trzeba rozumieć w sposób informatyczny.

Prąd „zjadany” przez serwo – mierzymy!

W skrajnych ustawieniach serwa (tj. w okolicy 0 stopni, oraz w okolicach 180 stopni) słyszymy buczenie/piszczenie serwo-silnika. Coś się dzieje. Amperomierz w garść i mierzymy prąd.

Przyjrzyj się uważnie obrazkowi i zwróć uwagę, jak podłączony jest amperomierz.

Oczywiście w wirtualnym Arduino silniczek serwo jest idealny i nie widzimy tego, co było u nas na zajęciach….

Gratulacje

Wypada pogratulować jednemu z uczestników BTXXIw, który w międzyczasie zbudował układ sterujący serwem za pomocą… fotorezystora! To świetny przykład na to, że nie ma co się nudzić na moich zajęciach – jeśli wyprzedzasz grupę, wykombinuj coś samemu! A ten projekt nie jest bynajmniej głupi – może to być sterowanie jakimś silnikiem w kierunku światła… Gratuluję pomysłowości Mariuszowi Karpowiczowi z II LO. Kto zabłyśnie następnym razem? Nagrody czekają …

Praca domowa

Zbudować układ w wirtualnym Arduino z serwem i zrobić tak, aby czytać z klawiatury kąt, na jaki należy ustawić silniczek. Zajrzyj do poprzednich notatek z naszych spotkań aby przypomnieć sobie o prawidłowym czytaniu liczb z portu szeregowego Arduino.