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

Pilot na podczerwień – TSOP22xx

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_napiec

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:

dzielnik1

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

Fotorezystor

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:

dzielnik3 dzielnik2

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:

dzielnik52 dzielnik51  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 😉

map2

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)

serwo1Czyli 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ę 😉

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 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…

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)

Serwo obrotowe360stop. FS90R 1,3kg/cm FeetechPoznaliś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 5 – sygnały cyfrowe, analogowe…

Sygnały cyfrowe – czujka ruchu PIR

Prosta w obsłudze czujka ruchu. Trzy piny  – zasilanie, masa oraz wyjście. W przypadku wykrycia ruchu wyjście jest w stanie wysokim (5V) przez chwilę (można sterować tym czasem),  a gdy ruchu brak – wyjście przechodzi w stan niski (0V). Aby to odczytać przy pomocy Arduino poznaliśmy dwie nowe rzeczy:

  • pinMode(7, INPUT) – czyli właśnie informujemy Arduino, że będziemy odczytywać wartość napięcia na konkretnym pinie (w tym przypadku: pinie numer 7),
  • digitalRead(7) – funkcja odczytująca napięcie i zwracająca wartość 1 (jedynka) gdy napięcie jest wysokie (2.4 – 5V) oraz 0 (zero) gdy napięcie jest niskie (0 – 0.8V).

Warto pamiętać, że Arduino UNO ma 14 pinów cyfrowych, a inne modele – patrz specyfikacja (kupując płytkę dla siebie weź to pod uwagę).

Sygnały analogowe

Czyli czytanie napięcia z przedziału od zera do 5V z rozdzielczością 10 bitów – a więc 1024 poziomów napięć (bo 2 do potęgi 10-tej to właśnie 1024). Nasze płytki są już lekko zdezelowane i wcale na wyjściu pinu 5V z Arduino nie mamy 5V a np. 4.57V, dlatego warto to mieć na uwadze czytając konkretną wartość napięcia. Poznaliśmy:

  • wejścia analogowe: A0, A1, A2, …, A5 (6 sztuk w UNO)
  • analogRead(A0 – funkcja odczytująca napięcie i zwracająca wartości od 0..1023 w zależności od napięcia na wejściu A0.
  • wejście AREF na płytce Arduino do podawania napięcia referencyjnego z przedziału 0..5V oraz funckję analogReference(EXTERNAL) uruchamiającą tę funkcję. Dzięki temu można wykorzystać całą rozdzielczość 10-ciu bitów na czytanie napięcia w przedziale 0..AREF V – ale tego nie testowaliśmy w praktyce.
  • inne możliwości ustawienia punktu odniesienia w funkcji analogReference, np. INTERNAL1v1 w zależności od płytki Arduino daje to pożliwość wykorzystania całej rozdzielczości 10-ciu bitów w zakresie 0..1V.

Galeria:

dsc_2177

Na zdjęciu: 4-ka wspaniałych czyli mała lecz silna grupa, która soboty ma wolne 😉 A ten piąty? widać, że nie z grupy, taki na peryferiach… soboty ciekawie spędza 😉 zresztą nie tylko On, inni (spoza kadru) też.

Potencjometr liniowy – dzielnik napięć (3 piny, nie „bolce” !!!)

potencjometr-osiowy-liniowy-5kBardzo przydatny element elektroniczny – będziemy go wielokrotnie wykorzystywać. Dlatego przypominam, że działanie oparte jest na dzielniku napięć, i należy pamiętać roli 3 nóżek tego elementu (proszę nie nazywać pinów „bolcami” – to mało profesjonalne):

  • pierwsza – zasilanie (np. 5V)
  • druga – napięcie na wyjściu, czyli zmodyfikowane konkretnym ustawieniem gałki potencjometru (np. 1.2V)
  • trzecia – masa (0V)

Oczywiście nóżki piersza i trzecia mogą być zamienione rolami. Przy pomocy miernika uniwersalnego sprawdziliśmy w praktyce działanie tego potencjometru, a już po chwili wczytywaliśmy do Arduino to napięcie i pisaliśmy na ekranie – dzięki funkcji  Serial.println().

Ważne: zauważyliśmy, że ustawiony potencjometr w jednej pozycji i nie poruszany daje lekko różne wartości, np. 600, 600, 601, 600, 600, 600, 598, 600, 600, 601, 600… Niby widać, że odczytana wartość wynosi 600, a te drobne odstępstwa nazywamy fluktuacjami. Dzieje się tak gdyż przetwornik DAC w Arduino nie jest doskonały (a niby co jest?!), wrażliwy na szumy i inne rzeczy. Warto o tym pamiętać.

Sygnały PWM – sygnały cyfrowe

Czyli Pulse Width Modulation – sygnały szybkozmienne w czasie (Arduino UNO – 2ms, czyli 500Hz), o dwóch wartościach – 0V i 5V. Mamy możliwość wybrania wypełnienia sygnału 5V – czyli jak długo wartość 5V utrzymuje się w okresie 2ms (a następnie wszystko się powtarza). Mamy 8 bitów do sterowania wypełnieniem – a więc wartości z przedziału 0..255.

Ku pamięci:

  • PWM jest dla sygnałów cyfrowych, oznaczonych tyldą w Arduino (a więc ~3, ~5, ~6, ~9, ~10 – aż 6 takich wyjść!)
  • pinMode(7, OUTPUT)
  • analogWrite(3, 127) – funkcja sterująca wypełnieniem (w tym przykładzie 50%, gdyż podałem 127, a maksymalna wartość to 255)

Przykłady -> 01 Basics -> Fade

Omówienie przykładu, zbudowanie układu i uruchomienie.

Pamiętaj:

wybierając płytkę Arduino dla siebie pamiętaj o jej parametrach: z dzisiejszych zajęć już wiesz, że musisz zwracać uwagę na liczbę pinów cyfrowych, analogowych oraz pinów cyfrowych z możliwością PWM. Zajrzyj na specyfikację Arduino Mega i porównaj z UNO – zobaczysz różnicę. A kolejne istotne parametry poznasz na dalszych zajęciach.

Praca domowa

Proszę zaprogramować w wirtualnym Arduino (przypominam: 123d.circuits.io) układ potencometr 10k + LED sterowany PWM tak, by LED rozjaśniał się wskutek nastwień potencjometu. W tym celu trzeba 1) czytać potencjometr analogowo, 2) sterować jasnością LEDa przez PWM (podobnie do omawianego przykładu Fade).

Podpowiedź: analogRead() zwróci nam wartości od 0..1023, a PWM potrzebuje wartości od 0..255. Jak widać te wartości do siebie nie pasują… rozwiązanie najprostrze to podzielenie przez 4 wczytanej wartości i ustawienie właśnie na tyle PWMa. Lepsze rozwiązania tego „problemu” poznamy na kolejnych zajęciach.

 

Zajęcia nr 4 – rejestr przesuwny czyli gry i zabawy zabawy weselne

Kontynuujemy nasze zmagania z cyferkami… Marzy nam się połączenie kilku pojedynczych wyświetlaczy w całość, tworząc coś w tym stylu:

878-00

Do dyspozycji mamy 7-mio segmentowy wyświetlacz oraz nowość – rejestr przesuwny. Jego zastosowanie jest niezbędne, gdyż przy jego pomocy oszczędzamy piny cyfrowe Arduino.

Rejestr przesuwny 74HC595 (ang. shift register)

Jako rozwiązanie powyższego problemu poznaliśmy rejestr przesuwny 74HC595. Cena tego cuda na czarnym rynku to około 1 zł w detalu, a umożliwia ono sterowanie 8 wyjściami (czyli np. jedną cyferką) za pomocą tylko 3 pinów cyfrowych z Arduino! Co więcej, łącząc ze sobą dwa takie układy (za łączną kwotę 2 zł) możemy mieć już oprogramowane 2 cyferki, ciągle wykorzystując tylko 3 piny cyfrowe z Arduino. Układy można łączyć w kolejne szeregi aż do 8 sztuk.

Przy tej okazji poznaliśmy:

  • orientację modułu w kasiecie DIP (pamiętacie tą kropeczkę? wcięcie?)
  • numerację pinów na module (odwrotnie do ruchu wskazówek zegara, gdy patrzę mu w twarz…)
  • nazewnictwo niektórych pinów (GND, Vcc, Qa, Qb…)
  • szybkie czytanie specyfikacji producenta (DataSheet)
  • programowanie 8 bitów rejestru – brawo dla Tomka za szybki pomysł na algorytm!

To jeszcze nie wygląda na strasznie skomplikowane, ale… po dodaniu kolejnego układu wszystko zrobiło się „dość” pogmatwane 😉

rejestr

Mamy tutaj dwa rejestry z dwoma cyferkami („prawie” działa). Widać, że jest gmatwanina przewodów, czasami trudno się w tym wszystkim połapać… Układ Tomka – gratulacje za wytrwałość. Dodam, że czasami zamiast standardowych przewodów można wykorzystać przewody ze skrętki (kabel od internetu! zawsze można go kupić na metry w sklepie…) i zrobić coś takiego:rejestr-5

Jak widać zabrakło mi tutaj siły do okablowania 6-tego rejestru…

Praca domowa – dobrowolna!

Proszę zmusić Arduino (np. wirtualne z serwisu 123d.circuits.io) do pracy z rejestrem przesuwnym – zaprojektujcie tam układ i wgrajcie ten sam kod, który męczyliście na zajęciach – będzie działało.

Galeria 3-ki wspaniałej i wytrwałej 😉

a1 a2 a3

Zajęcia nr 3 – cyferki, cyferki…

Kto nie był niech żałuje. Naszym celem jest taka oto konsola (kto wie, z jakiego to filmu?)

Pracowaliśmy nad jednym z elementów:

878-00

A dokładniej: nad pojedynczą cyferką!

7 segment display (SSD) – przeczytaj Wikipedię (ale nie całą).


Wszyscy uczestnicy Talenów pracowali wytrwale i już po chwili każdyemu udało się tak sterować LEDami 7-mio segmentowego wyświetlacza, by pokazywał jedynkę, dwójkę i trójkę. Jeden z uczestników kursu okazał się bardzo sprytny i szybko miał zaprogramowane wszystkie 10 cyfr (gratuluję Jakubowi Sz. – nagroda na koniec kursu 😉 ).

W celu sterowania 7-mio segmentowym wyświetlaczem szlifowaliśmy techniki programowania strukturalnego:

  • tworzyliśmy własne funkcje, w tym funkcje z argumentami
  • wykorzystywaliśmy tablice (do przechowywania numerów pinów z Arduino)
  • norriswykorzystaliśmy tablice dwuwymiarowe – tzw. tablice tablic, czyli elementami tablicy była… tablica! Okazało się to bardzo użyteczne (z odpowiednim programowaniem funkcji). To była najtrudniejsza część zajęć, tj. „dla twardzieli”  – dlatego pojawił się znany bohater filmów akcji 😉 Zaawansowany kod – do ponownego zastanowienia się:
    //            A  B  C  D  E  F  G DP
    int led7[8]={ 2, 3, 5, 7, 4, 6,12,13};
    int digits[4][8]={
    // A B C D E F G DP
      {1,1,1,1,0,0,1,0},//swieci jedynka
      {0,0,1,0,0,1,0,0},//swieci dwójka
      {0,0,0,0,1,1,0,0},//swieci trójka
      {1,0,0,1,1,0,0,0}
    };
    //trzeba dodac kolejne cyfry
    
    void cyfra(int nr){
      for (i=0; i<8; i++)
        digitalWrite(led7[i], digits[nr][i]);
    }
    
  • no i poznaliśmy hardware, czyli 7 segment display ze wspólną anodą (CA – common anode – w naszym przypadku). Musieliśmy troszkę zmienić nasze myślenie – przywykliśmy do schematu: 1=włączone, 0=wyłączone. A tutaj odwrotnie. Włączając napięcie 5V na pinie Arduino powodujemy zgaszenie segmentu, z kolei ustawiając napięcie na 0V włączamy segment! Tak – specjalnie dałem Wam taki właśnie sprzęt, by troszkę wysilić szare komórki!

Niestety – programowanie pojedynczej cyferki wymagało wykorzystania 8 pinów cyfrowych z Arduino. To dość dużo… 2 Takie cyferki wymagają już 16 pinów, a nasze UNO ma ich 14 (tylko? aż?). OK, można ustawić piny analogowe jako cyfrowe, tym samy będziemy mieć ich dodatkowo 6 sztuk – czyli oprogramujemy 2 cyferki… dlatego na kolejnych zajęciach (sobota) poznamy rozwiązanie tego problemu:

Rejestr przesuwny 74HC595 (ang. shift register)

Zajęcia nr 2 – 7xLED i bardzo szybki kurs programowania strukturalnego

Na naszych drugich zajęciach powiedzieliśmy sobie o:

  • czym są zmienne w programie?
  • ile pamięci (SRAM) zajmują zmienne? int = 2 bajty, float = 4 bajty
  • może zamiast deklarować zmienne, użyć #define – czyli słów kilka o preprocesorze
  • operator przypisania i niematematyczna konstrukcja a=a+10
  • skrócone operatory przypisania a+=10 (a także a-=10, a*=10, a/=2)
  • instrukcja warunkowa if 
  • grupowanie wielu instrukcji sterujących nawiasami sześciennymi { }
  • rozbudowana instrukcja warunkowa – if else
  • pętla for
  • tablice oraz operator [ ]
  • definiowanie wartości początkowych dla tablic – ponownie nawiasy sześcienne { } w innym kontekście!
  • obiekt Serial – trochę o programowaniu obiektowym… poznaliśmy metody print(), println(), read(), available(), parseInt()

Po tych zajęciach powinieneś znać:

  • orientować się w poruszanych zagadnieniach – dla mnie oczywistym jest, że nie sposób to opanować w 100% na naszych krótkim spotkaniu! tylko praktyka spowoduje, że zrozumiesz to, o czym była mowa (dlatego rozwiąż zadanie domowe)
  • podłączyć 3 (lub więcej) LEDów do Arduino i nimi sterować – nawet, jeśli masz problemy z pętlami (for) to jeszcze się tym nie przejmuj. Z czasem nabierzesz wprawy, o ile będziesz ćwiczyć

Praca domowa

Napisać program dla Arduino, który steruje 7-mioma LEDami. Diody mają zapalać się po wczytaniu numeru pinu (do którego podłączona jest dana dioda) z klawiatury. Dodatkowo, jeśli dioda się już świeciła – powinna zgasnąć. Pamiętaj, że do wczytywania liczb dwucyfrowych należy użyć metody Serial.parseInt(). Powodzenia! (Pamiętaj, że możesz mieć wirtualne Arduino u siebie w domu wchodząc na stronkę 123d.circuits.io i tam zapalać/gasić LEDy!)

Zajęcia nr 1 – co to te Arduino? prawdziwe + wirtualne Arduino!

Na naszych pierwszych zajęciach powiedzieliśmy sobie o:

  • Arduino – otwarta platforma (open-hardware)
  • serce Arduino – mikrokontroler (uC, MCU), czyli mikrokomputer jednoukładowy (pojedynczy układ scalony zawierający w sobie procesr, pamięć, interfejsy wejścia-wyjścia, kontrolery przerwań…)
  • rodzina platform Arduino (czyli nie tylko UNO!)
  • budowa i parametry Arduino UNO
  • Arduino? Genuino? czyli o „przyjaźni” założycieli i rejestracji znaków handlowych
  • IDE (Integrated Development Environment) – środowisko programistyczne
  • omówienie (przykładowego) programu Blink wraz z przykładem tego programu w prawdziwym C/C++ (dla zaawansowanych)
  • poznajemy płytkę stykową
  • wirtualne Arduino: 123d.circuits.io — dla tych, którzy już chcą, ale jeszcze nie zakupili płytki Arduino!
  • pierwszy program sterujący diodą! w wirtualu i w realu…

Ku pamięci:

plytka_stykowa-schematPlytkaPrototypowa

Po tych zajęciach powinieneś znać:

  • orientować się w budowie platformy Arduino (piny cyfrowe, piny analogowe)
  • rozumieć połączenia na płytce stykowej
  • rozumieć konieczność stosowania rezystorów podczas podłączania LEDów
  • budowę programów dla Arduino, w tym znaczenie funkcji setup() oraz loop()
  • funkcję ustawiającą piny cyfrowe do sterowania napięciem, czyli pinMode
  • funkcję włączającą napięcie 5V (HIGH) lub 0V (LOW) na konkretnym pinie, czyli digitalWrite
  • funkcję zatrzymującą działanie programu na określoną liczbę mikrosekund – czyli delay