Różnica między wejściem analogowym i cyfrowym

Do wejść micro:bita podłącza się elementy, które mają przekazać informację ze świata zewnętrznego do wnętrza układu. Takim elementem jest m.in. przycisk, dzięki któremu możemy uzależnić działanie programu od tego, czy nasz palec naciska na dany element, czy nie. Tutaj sytuacja jest bardzo prosta, bo są możliwe tylko dwa stany – przycisk może być puszczony lub wciśnięty.

Jest jednak wiele sytuacji, w których dwa stany to za mało – np. pomiar natężenia światła. Tutaj informacja typu „jest jasno” lub „jest ciemno” to trochę za mało. Chcielibyśmy mieć możliwość pomiaru tego, jak jest jasno – np. w skali od 0 do 1000, gdzie 0 oznaczałoby, że jest bardzo ciemno, 110 to półmrok, 800 to jasno, a 1000 to bardzo jasno. Tutaj przydają się właśnie wejścia analogowe, czyli takie, które potrafią rozpoznać więcej stanów, a konkretnie aż 1024. Zaraz sprawdzimy to w praktyce!

Wejścia analogowe dla dociekliwych

W praktyce wejścia analogowe to „małe mierniki”, które potrafią mierzyć napięcie pojawiające się na wejściu micro:bita. Zakres pomiarowy nie jest duży, bo możemy mierzyć jedynie wartości od 0 do 3,3 V, ale jest to wystarczające dla wielu zastosowań. Wszystko dzięki czujnikom analogowym, które potrafią przedstawić zmierzoną wartość właśnie w formie napięcia z zakresu od 0 do 3,3 V.

Mikrokontroler, czyli mały procesor na micro:bit, nie mierzy napięcia w woltach. Układ ten przedstawia wartość jako liczbę z zakresu od 0 do 1023, gdzie 0 oznacza 0 V, a 1023 – 3,3 V. Maksymalna wartość, wynosząca 1023, wynika z rozdzielczości 10-bitowego przetwornika analogowo-cyfrowego.

Więcej informacji na temat czujników analogowych można znaleźć np. w naszym innym kursie, który przeznaczony jest dla wszystkich osób chcących poznać najważniejsze podstawy elektroniki.

Dodatkowy czujnik światła dla micro:bita

W naszym zestawie znajduje się moduł analogowego czujnika światła. Na jego pokładzie znajdziemy mały układ scalony oraz fototranzystor, który wyglądem przypomina diodę świecącą. Czujnik wpinamy do złącza opisanego jako P0/14. Moduł ten mierzy natężenie światła i zamienia je na napięcie, które bez problemu zmierzymy za pomocą wejścia analogowego.

W programie wykorzystamy dwa nowe bloczki. Pierwszy z nich to plot bar graph z zakładki Led, dzięki któremu odczyt z czujnika zostanie przedstawiony na diodach w formie małego wykresu. Drugi bloczek to analog read pin z zakładki Pins – za jego pomocą odczytamy wartość z czujnika. Program powinien działać w pętli forever, w której znajduje się jeszcze opóźnienie 100 ms. Opóźnienie sprawi, że dane będą mierzone co 100 milisekund, czyli 10 razy na sekundę (szybciej nie potrzebujemy).

Wartość 1023 wpisana do bloczka rysującego wykres oznacza, że 1023 jest wartością maksymalną, jaką spodziewamy się odczytać z czujnika (zgodnie z informacjami z początku tej części kursu). Zakładamy więc, że w wyniku działania czujnika otrzymamy liczbę z zakresu od 0 do 1023, gdzie 0 oznacza, że jest ciemno, a 1023 – że jest jasno. 

Po uruchomieniu programu możemy przetestować jego działanie – najlepiej zasłonić czujnik ręką, można też zgasić światło w pokoju. Im będzie jaśniej, tym więcej diod powinno się świecić. Wszystko musi działać zgodnie z planem, czyli odsłonięcie czujnika powinno włączać więcej diod.

Nigdy nie włączą się jednak wszystkie diody (nawet przy silnym świetle). Dzieje się tak, bo czujnik został zbudowany w taki sposób, że nigdy nie zwraca maksymalnej wartości, czyli 1023 – tutaj maksymalnie uzyskamy tylko około 650. Jest to jednak cecha unikalna konkretnie dla tego modułu – w dalszej części zajmiemy się czujnikiem obrotu, który będzie działał w pełnym zakresie.

Jeśli korzystamy ze środowiska w przeglądarce Chrome lub tego, które instaluje się na komputerze, to możemy bardzo łatwo podejrzeć, jaką maksymalną wartość faktycznie zwraca czujnik. Wystarczy, że po wgraniu programu klikniemy przycisk Show console Device, który pokaże się pod symulatorem.

Pojawi się wtedy nowy ekran, na którym widoczny będzie wykres rysowany na podstawie odczytów z czujnika. Całość powinna działać bardzo płynnie. Śledząc informacje pojawiające się na tym ekranie, bardzo łatwo odczytamy, jaką wartość maksymalną zwraca oświetlony czujnik.

W górnej części okna widoczny jest fioletowy wykres, na którym pokazywane są dane z czujnika. Wartość na pomarańczowym tle (622) to aktualny odczyt, a po prawej stronie wykresu widoczna jest aktualna skala wykresu, która została automatycznie dopasowana do odbieranych wartości – tutaj było to minimum 7 i maksimum 622. 

W dolnej części okna widoczne są te same dane, ale przedstawiono je w formie tekstowej – widać tam poszczególne odczyty. Jeśli wartość została przesłana kilka razy z rzędu, to wyświetla się jako jedna pozycja z informacją o liczbie powtórzeń – tutaj widzimy, że wartość 622 została odebrana 24 razy.

Znając maksymalną wartość, którą naprawdę zwraca czujnik, możemy edytować nasz program. Teraz wpisujemy, że maksymalna spodziewana przez nas wartość to 650 (622 zaokrąglone do 650, aby został mały margines), a nie 1023. Po wgraniu nowego programu wszystkie diody na płytce powinny się świecić, gdy oświetlimy mocno micro:bit.

Warunki w praktyce – budujemy inteligentną lampkę

Wiemy już, że czujnik działa poprawnie, możemy więc wykorzystać go do budowy inteligentnej lampki, która włączy się automatycznie, gdy będzie ciemno. W tym celu potrzebny będzie nam nowy bloczek, dzięki któremu będziemy mogli sprawdzić, czy dany warunek jest spełniony. 

Zaczynamy od dodania bloczka warunkowego if [...] then [...] else z zakładki Logic. Wstawiamy go oczywiście do pętli forever, ponieważ lampka ma działać cały czas. Następnie uzupełniamy go w taki sposób, aby na wyświetlaczu micro:bita była wyświetlana ikonka, gdy jest ciemno, a jeśli jest jasno, to diody mają być wyłączone.

Mamy już szkielet instrukcji warunkowej. Pora dodać warunek. Wybieramy więc nowy bloczek z zakładki Logic – tym razem chodzi o mały bloczek 0 < 0, który znajdziemy w Logic > Comparison. Łapiemy go i przeciągamy do bloczka if w miejsce, gdzie domyślnie napisane było „true”.

Teraz przeciągamy znany nam już bloczek analog read pin P0 na miejsce pierwszego 0 w warunku, a drugie 0 zastępujemy liczbą 400. Całość powinna wyglądać następująco:

Teraz dodajemy bloczki sterujące wyświetlaczem. Jeden pokazuje ikonkę, a drugi wyłącza diody. Bloczki umieszczone w sekcji tuż pod if zostaną wykonane, gdy warunek będzie prawdziwy (można również powiedzieć, że będą wykonane, gdy warunek będzie „spełniony”). Z kolei bloczki umieszczone w sekcji pod else zostaną wykonane, gdy warunek będzie fałszywy (zaraz sprawdzimy to w praktyce).

Stworzenie tego warunku za pierwszym razem wydaje się zawiłe, ale na szczęście jego zrozumienie jest bardzo łatwe. Powyższy zapis czytamy następująco:

1. Odczytaj wartość z wejścia analogowego P0 i sprawdź, czy jest ona mniejsza od liczby 400.
2. Jeśli warunek jest prawdziwy (tzn. zmierzona wartość jest mniejsza od 400), to wyświetl ikonę. 
3. Jeśli warunek jest fałszywy (tzn. zmierzona wartość jest równa 400 lub większa), to wykonaj operację zawierającą się w sekcji else, czyli wyczyść ekran.

Całość jest chyba prosta do zrozumienia, jedynie wyklikanie takiego warunku za pierwszym razem może wydać się zawiłe. Wgrywamy i testujemy program! Od teraz diody powinny włączać się, gdy poziom oświetlenia spadnie poniżej 400. Wartość ta została dobrana eksperymentalnie. Sprawdź, jak będzie działał układ, gdy ustawisz inną wartość (eksperymentuj w zakresie od 0 do 650).

Rozbudowany warunek, lampka z dodatkową diodą

Warunki można łączyć i rozbudowywać. Teraz dodamy do naszego układu moduł diody, który znamy z poprzedniej części kursu. Podłączamy ją do pinu P1. Stworzymy lampkę, która ma dwa stopnie świecenia. Gdy czujnik wykryje, że powoli robi się ciemno, to włączona zostanie dioda na module, a gdy zrobi się bardzo ciemno, to włączą się diody na wyświetlaczu (pokaże się ikonka).

Klikamy znaczek plusa, który widoczny jest w dolnej części naszego bloczka if. Zostanie wtedy dodane miejsce na drugi warunek, oznaczony jako else if.

Drugi warunek wypełniamy analogicznie do pierwszego. Zmieniamy tylko od razu wartości liczbowe. W pierwszym warunku wpisujemy 200, a w drugim 500. Dodajemy też bloczki włączające i wyłączające diodę na module podłączonym do wyjścia P1.

Całość interpretujemy następująco:

1. Odczytaj wartość z wejścia P0 i sprawdź, czy jest mniejsza od liczby 200.
2. Jeśli warunek jest prawdziwy (tzn. wartość jest mniejsza od 200), to wyświetl ikonę. 
3. Jeśli warunek jest fałszywy (tzn. wartość jest równa 200 lub większa), to sprawdź drugi warunek, czyli czy wartość z wejścia P0 jest mniejsza od 500.
4. Jeśli drugi warunek jest prawdziwy, to włącz diodę na P1.
5. Jeśli drugi warunek jest fałszywy, to wyłącz moduł z diodą i wyczyść ekran.

Bloczek if sprawdzany jest w kolejności od góry do dołu. Wykonane zostaną instrukcje dla pierwszego warunku, który jest prawdziwy. Oznacza to również, że jeśli program dotrze do drugiego warunku, to wcześniejszy musiał być fałszywy. Czyli w praktyce, odnosząc to do naszego programu: jeśli dojdziemy do momentu sprawdzenia, czy wartość z czujnika jest mniejsza od 500, to znaczy, że wcześniejszy warunek nie został spełniony. Czyli liczba jest już na pewno równa 200 lub większa.

Wgrywamy program i testujemy. Gdy jest jasno, to nic nie powinno się dziać. Stopniowe zasłanianie czujnika powinno najpierw włączyć diodę, a później wyświetlacz.

Mały haczyk dla dociekliwych

W tym przypadku możemy zauważyć jedną ciekawą rzecz. Mianowicie, gdy zasłonimy zupełnie czujnik, to będzie świeciła się dioda i równolegle będzie włączony wyświetlacz. Jest to bardzo dziwne, bo nasz program nie przewiduje takiej opcji. W jednym przypadku miał być włączony wyświetlacz, a w drugim – dioda na module. W programie nie ma przypadku, w którym miały świecić oba elementy.

Jak to możliwe? Warunek w pętli sprawdzany jest bardzo często (setki razy na sekundę). Jeśli czujnik zasłaniamy ręką, to sprawiamy, że powoli robi się ciemno. W praktyce działa to więc następująco:

1. Czujnik jest odsłonięty, jest jasno, więc oba warunki są fałszywe, uruchamiają się bloczki pod else, które wyłączają diodę i wyświetlacz.
2. Zasłaniamy delikatnie czujnik, robi się ciemniej i wartość spada np. do 400.
3. Pierwszy warunek nie jest spełniony, przechodzimy do drugiego, on jest już prawdziwy, bo wartość jest mniejsza od 500. Włączamy więc moduł z diodą na P1.
4. Zasłaniamy mocniej czujnik, robi się bardzo ciemno i wartość spada np. do 150.
5. W kolejnym obiegu pętli sprawdzamy pierwszy warunek i jest on prawdziwy, bo wartość spadła poniżej 200. Włączamy więc wyświetlacz.
6. W kolejnym obiegu pętli znów pierwszy warunek jest spełniony, włączamy diody na wyświetlaczu (które i tak są cały czas włączone) i tak w koło.
7. Dioda na module Grove świeci cały czas, nigdy jej nie wyłączyliśmy, bo nie było sytuacji, w której oba warunki byłyby fałszywe i doszlibyśmy do instrukcji znajdujących się pod else.
8. Zarówno dioda na module, jak i wyświetlacz zgasną, gdy odkryjemy czujnik.

Czy jest więc możliwa sytuacja, w której świecić się będzie tylko wyświetlacz, a dioda będzie wyłączona? Oczywiście, stanie się tak, gdy układ po włączeniu od razu odczyta z czujnika wartość mniejszą od 200, czyli w praktyce stanie się tak, jeśli układ włączymy w ciemności. Dla testu można odłączyć zasilanie, zakryć czujnik i podłączyć micro:bit ponownie.

Jeśli chcielibyśmy, aby dioda na module zawsze gasła, możemy to zrobić bardzo prosto. Wystarczy, że dodamy taką instrukcję w sekcji, która jest wykonywana po spełnieniu pierwszego warunku. Gdy wartość z czujnika spadnie poniżej 200, to wyłączymy diodę i włączymy wyświetlacz.

Warunki podczas pisania programów są niezwykle użyteczne, warto więc już na samym początku dość dobrze zrozumieć, o co w nich chodzi – stąd pojawił się tutaj przykład z małym „haczykiem”, który miał pokazać, że nie jest możliwe, aby jednocześnie spełnione były dwa sprzeczne warunki – to było tylko nasze błędne wrażenie, które łatwo wyjaśnić, analizując dokładnie działanie programu. 

Dodatkowy czujnik obrotu dla micro:bita

Wiemy już, czym są wejścia analogowe, znamy już warunki, więc teraz pójdzie z górki. Nasz czujnik obrotu działa praktycznie identycznie jak wspomniany wcześniej czujnik światła. Możemy nawet wziąć nowy moduł i wpiąć go do wcześniejszego układu bez żadnej zmiany w programie.

Przetestujmy tylko dla formalności, czy wszystko działa poprawnie. W tym celu wykorzystamy program z początku tej części kursu, który rysował wykres. Tym razem ważne jest, aby maksymalną spodziewaną wartością było 1023, bo akurat ten moduł działa w całym zakresie (0–1023).

Przetestuj, czy układ działa poprawnie. Przekręcanie czarnego pokrętła powinno wpływać na liczbę świecących diod oraz na dane wyświetlane na wykresie widocznym na komputerze. 

Moduł czujnika to tak naprawdę potencjometr, czyli popularny element elektroniczny, który zmienia swój opór zależnie od ustawienia pokrętła. Tutaj został on podłączony w taki sposób, aby ruch pokrętła wpływał na zmianę napięcia na wyjściu modułu.

Budujemy światło ostrzegawcze

Wykorzystajmy czujnik obrotu do budowy lampki ostrzegawczej migającej z prędkością, którą ustawimy za pomocą naszego czujnika obrotu. W tym celu czujnik podłączamy do wejścia P0, a moduł z diodą do P1.

Tym razem wartość odczytaną z czujnika obrotu wykorzystamy jako wartość opóźnienia. Program ma więc wyglądać następująco (wszystkich bloczków używaliśmy już wcześniej):

Program w pętli forever działa bardzo prosto. Włączamy diodę, czekamy pewien czas, gasimy diodę, czekamy i tak w koło. W poprzedniej części kursu w bloczku pause wpisywaliśmy konkretną wartość opóźnienia w milisekundach. Teraz podstawiliśmy tam wartość z wejścia analogowego. Oznacza to, że nasze opóźnienie przyjmie wartość z zakresu od 0 do 1023 milisekund (zależnie od pozycji czujnika).

Warto zwrócić uwagę, jak układ zachowuje się w sytuacji, gdy opóźnienie jest ustawione na minimum. Opóźnienia wynoszą wtedy ~0 milisekund i są właściwie pomijane. Program cały czas w pętli włącza i wyłącza diodę, która miga bardzo szybko.

Światło ostrzegawcze z wygodniejszą regulacją

W poprzednim przykładzie mogliśmy regulować czas w zakresie od 0 do 1023 milisekund, co nie jest zbyt wygodne. Znacznie lepiej byłoby, jeśli moglibyśmy regulować czas w jakimś zakresie, który jest bardziej „przyjazny” dla człowieka. Znacznie lepiej w instrukcji lampy ostrzegawczej wyglądałoby, że możemy regulować czas w zakresie od 0,1 do 2 sekund, a nie do jakichś „dziwnych” 1023 milisekund.

Funkcja map dla micro:bita

Tutaj z pomocą przyjdzie nam bloczek realizujący operację mapowania, chociaż może lepiej byłoby to nazwać skalowaniem. Nowy bloczek map znajdziemy w zakładce Pins. Wygląda on dość zawile, ale to tylko pozory.

W praktyce przelicza on jedną wartość na inną. Musimy tylko uzupełnić pięć pól:

1. map – wartość, która ma być przeliczona (u nas będzie to wartość z czujnika)
2. from low – najniższa wartość, jaką może zwrócić czujnik (0)
3. from high – najwyższa wartość, jaką może zwrócić czujnik (1023)
4. to low – najniższa wartość, jaką chcemy otrzymać (100)
5. to high – najwyższa wartość, jaką chcemy otrzymać (2000)

Bloczek ten będzie skalował dane z czujnika. Jeśli pomiar wskaże 0, to bloczek map przeliczy to na 100; jeśli czujnik wskaże 1023, to bloczek przeliczy tę wartość na 2000. Analogicznie, jeśli czujnik zwróci nam np. 512 (połowa zakresu), to bloczek map przeliczy to na 950 (połowa zakresu między 100 a 2000).

Bloczek ten możemy więc wstawić do naszych opóźnień:

Po wgraniu takiego programu będziemy mogli regulować prędkość migania w wygodniejszym dla nas zakresie, czyli od 100 do 2000 milisekund.

Inteligentne światło ostrzegawcze

Na koniec ćwiczenie łączące wszystkie informacje z tej części kursu micro:bita. Stwórzmy program dla inteligentnego światła ostrzegawczego, które będzie migało z zadaną częstotliwością, ale tylko wtedy, gdy jest ciemno. Dołączamy do wcześniejszego układu czujnik światła – tym razem do wejścia P2.

Bazujemy na ostatnim programie z bloczkiem map. Umieszczamy całość w warunku, który sprawi, że dioda będzie migała tylko wówczas, gdy poziom oświetlenia spadnie poniżej 400. W tym przypadku sekcja else (wykonywana, gdy warunek nie jest spełniony) jest zbędna – możemy więc ją usunąć, klikając na znak minusa przy warunku.

Wgrywamy program i testujemy! Dioda powinna migać z ustawioną przez nas częstotliwością tylko wtedy, gdy jest ciemno. Działanie układu można przetestować w następujący sposób:

Zbudowaliśmy więc całkiem przydatne urządzenie – wystarczyłoby wymienić diodę na moduł, który świeci z większą intensywnością, i mielibyśmy swoją wersję ostrzegawczej lampy, którą ustawia się np. na drogach podczas remontu. Urządzenie migałoby ostrzegawczo po zmroku, dzięki czemu żaden kierowca nie wjechałby na plac budowy.

Dodatek (dostępny w książce)

Osoby, które zamówiły kurs w formie książki drukowanej lub e-booka, znajdą tu dodatkowy przykład użycia drugiego czujnika światła (wbudowanego w micro:bit) oraz rozwiązania do zadań dodatkowych.

Zadania dodatkowe

Zad. 3.1. Napisz program, który będzie rysował na PC wykres położenia czujnika obrotu podłączonego do P0/P14, w taki sposób, aby jedna skrajna pozycja czujnika była oznaczana przez wartość 100, a druga przez 200. Odczyty powinny być wysyłane do komputera co około 100 ms. Kręcąc czujnikiem, powinniśmy więc widzieć płynną zmianę wartości od 100 do 200, a nie od 0 do 1023.

Zad. 3.2. Wykorzystaj czujnik światła podłączony do P0/P14 do tego, aby micro:bit po włączeniu witał się odpowiednio do pory dnia. Jeśli jest jasno, to na ekranie ma się wyświetlić „Dzien dobry”, a jeśli jest ciemno – „Dobry wieczor”.

Zad. 3.3. „Zamień” działanie przycisków A i B za pomocą czujnika obrotu podłączonego do P0/P14. Jeśli czujnik wskazuje mniej niż 512, to wciśnięcie przycisku A ma wyświetlać na chwilę uśmiechniętą buźkę, a wciśnięcie przycisku B – zdziwioną minę. Po przekręceniu czujnika obrotu na wartość większą od 512 działanie przycisków powinno zostać zamienione.

Podsumowanie

Czujniki analogowe to bardzo często spotykane układy. Moduły tego typu mogą również mierzyć wiele innych wartości, np. temperaturę lub odległość, a za każdym razem używa się ich praktycznie tak samo – wystarczy odczytać wartość z zakresu 0–1023 i odpowiednio ją przeskalować.

W kolejnej części kursu micro:bita zajmiemy się nowym modułem z serii Grove – tym razem będzie to głośnik. Przy okazji poznamy w praktyce bloczki dostępne w zakładce Music, dzięki którym nasz układ będzie mógł wydawać dźwięki – od pojedynczych nut aż po długie melodie.

Autor kursu: Damian Szymański

czujniki, grove, kurs, kursmicrobit, micro:bit