Kurs micro:bit – #6 – zmienne, wyświetlacz 7-segmentowy

Kurs micro:bit – #6 – zmienne, wyświetlacz 7-segmentowy

Tym razem poznamy w praktyce zmienne, dzięki którym nasze programy będą mogły zapisywać pewne informacje w pamięci micro:bita.

Oprócz tego zajmiemy się też nowym modułem tzw. wyświetlacza 7-segmentowego, który często spotyka się np. w elektronicznych zegarach.

Czym są zmienne?

Najczęściej zmienne porównuje się do małych szufladek w pamięci komputera, do których odkłada się pewne informacje. W każdej chwili możemy sprawdzić, co znajduje się w takiej szufladce, możemy też zmienić jej zawartość. Oczywiście do takiej komputerowej szuflady nie możemy schować np. piłki, ale bez problemu schowamy do niej jakieś informacje.

Zmienne przypominają w działaniu małe szuflady

Zmienne przypominają w działaniu małe szuflady

Na razie zajmiemy się zmiennymi, które mogą przechowywać w sobie liczby – np. informację o tym, ile razy nacisnęliśmy jakiś przycisk. Warto pamiętać, że są też bardziej złożone zmienne, w których można trzymać wyrazy, długie teksty, a nawet grafiki. Zacznijmy jednak od prostych testów w praktyce!

Pierwsza zmienna w micro:bicie

Jeśli chcemy w programie wykorzystać zmienną, to musimy ją najpierw utworzyć – posługując się „językiem programistów”, powiemy, że musimy taką zmienną zadeklarować. W przypadku micro:bita sprawa jest prosta. Tworzymy nowy projekt i przechodzimy do zakładki Variables (pol. „zmienne”).

Następnie klikamy przycisk Make a Variable. W nowym okienku podajemy krótką nazwę, dzięki której każdy, kto spojrzy w nasz program, będzie mógł domyślić się, co zawiera ta zmienna. My będziemy teraz zliczać liczbę naciśnięć przycisku, więc dobrą nazwą będzie „licznik”. Nazwa zmiennej musi być krótka, nie może zawierać spacji ani polskich znaków.

Tworzenie nowej zmiennej podczas programowania micro:bita

Tworzenie nowej zmiennej podczas programowania micro:bita

Deklarację zmiennej należy traktować tak, jakbyśmy podeszli do biurka z wieloma szufladami, wybrali konkretną szufladę i przykleili jej naklejkę z nazwą. Następnie włożylibyśmy do niej kartkę, na której da się zapisać jakąś liczbę.

Po kliknięciu przycisku Ok nowa zmienna zostanie utworzona, a w zakładce Variables pojawiają się aż trzy nowe bloczki, które są związane z naszą zmienną licznik. Pierwszy bloczek to sama zmienna, którą będziemy mogli wykorzystywać wszędzie tam, gdzie będziemy chcieli odczytać jej zawartość. Kolejne bloczki pozwalają na zapisanie oraz zmienienie zawartości zmiennej – omówimy to zaraz w praktyce.

Nowe bloczki związane ze zmienną „licznik”

Nowe bloczki związane ze zmienną „licznik”

Wykorzystajmy zmienną w praktyce. Zacznijmy od programu, który wyświetli zawartość zmiennej na ekranie micro:bita. W tym celu w on start umieszczamy dwa bloczki. Pierwszy z nich to set licznik to 0 – należy ten zapis rozumieć jako „ustaw zmienną licznik na 0”. Odnosząc się do porównania z szufladami, oznaczałoby to, że podchodzimy do biurka, szukamy szuflady „licznik” i na kartce, która jest w środku, zapisujemy cyfrę 0.

Drugi bloczek w programie to znany nam show number, który został uzupełniony nowym bloczkiem licznik (dostępny w zakładce Variables). Łapiemy go i przeciągamy tam, gdzie normalnie wpisalibyśmy wartość, która ma się pojawić na ekranie.

Przykład prostego wykorzystania zmiennej

Przykład prostego wykorzystania zmiennej

Po wgraniu programu na ekranie micro:bita powinna pojawić się cyfra 0. Stało się tak, ponieważ przed wyświetleniem liczby micro:bit sprawdził, jaka cyfra jest zapisana w szufladzie opisanej jako „licznik”, i podstawił tę wartość do bloczka show number. Program działa – ale po co tam zmienna? To samo dałoby się uzyskać bez zmiennej! Tak, ale dopiero za chwilę zobaczymy zalety tej wersji programu.

Zestaw elementów do kursu

 999+ pozytywnych opinii  Gwarancja pomocy  Wysyłka w 24h

Moduły do wykonania wszystkich ćwiczeń z kursu micro:bita dostępne są w formie gotowych zestawów! W komplecie m.in.: micro:bit, czujnik gestów i odległości oraz taśma diod RGB.

Zamów w Botland.com.pl »

Prosty licznik wciśnięć przycisku

Pora rozbudować wcześniejszy program i wykorzystać zmienną do przechowywania informacji na temat liczby wciśnięć przycisku B. Chcemy więc, aby po wciśnięciu przycisku B „ktoś” podszedł do szuflady, sprawdził, jaka liczba zapisana jest na umieszczonej w środku kartce, i dodał do niej 1 (wymazana zostanie stara wartość i na kartce pojawi się nowa liczba).

Dodajemy więc do programu on button B pressed, a w jego wnętrzu wstawiamy nowy bloczek, który nazywa się change licznik by 1. Zrobi on dokładnie to, co chcemy, czyli zwiększy wartość zmiennej o 1. Następnie powielamy bloczki, które wyświetlają zawartość zmiennej na ekranie.

Prosty program zliczający naciśnięcia przycisku B

Prosty program zliczający naciśnięcia przycisku B

Wgrywamy i testujemy program – każde naciśnięcie przycisku powinno zwiększać liczbę, która pojawia się na naszym ekranie. Napisanie takiego programu bez używania zmiennych nie byłoby możliwe, bo nasz micro:bit nie mógłby zapamiętać, ile razy naciskaliśmy już przycisk.

Licznik wciśnięć przycisku z limitem

Nasz program działa bardzo dobrze, ale po 10 naciśnięciach przycisku zaczynają się drobne problemy, bo liczby dwucyfrowe nie mieszczą się na ekranie i dlatego są przewijane. Nie jest to zbyt ładne, dodajmy więc limit – naciśnięcia będą zliczane od 0 do 9, a gdy licznik będzie miał wskazać 10, to nasz program wyzeruje zmienną (przypisze jej wartość 0) i odliczanie zacznie się znów od początku.

W tym celu musimy dodać warunek, który sprawdzi, czy zmienna „licznik” jest równa 10. Jeśli tak, to jej wartość zostanie ustawiona na 0. Wiemy już, jak korzystać z warunków, potrafimy również sprawdzić i zmienić wartość zmiennej, pora zatem wykorzystać to do budowy programu.

Licznik wciśnięć przycisku z limitem

Licznik wciśnięć przycisku z limitem

Po wgraniu programu i kilkukrotnym wciśnięciu przycisku B zamiast 10 na ekranie zobaczymy 0, a później 1, 2, 3 itd. Dzieje się tak, ponieważ po wciśnięciu przycisku zwiększamy wartość zmiennej o 1, aby za chwilę sprawdzić, czy wartość zapisana w tej „szufladce” jest równa 10. Jeśli nie jest, to bloczek warunkowy nic nie robi i wyświetlamy zmienną na ekranie. Jeśli jednak zmienna licznik jest równa 10, to zmieniamy jej zawartość na 0 i dopiero wtedy ją wyświetlamy.

Dwukierunkowy licznik na micro:bicie

Oczywiście zmienne nie muszą być zwiększane – można je zmniejszać lub przypisywać im zupełnie inne wartości. Skopiujmy bloczek on button B pressed, tym razem zmieniając go w taki sposób, aby reagował na przycisk A. Od razu zmieńmy też program w taki sposób, aby przycisk ten powodował odejmowanie 1 od zmiennej licznik (za jego pomocą będziemy mogli więc odliczać do tyłu).

Program licznika, który potrafi zliczać w dwie strony

Program licznika, który potrafi zliczać w dwie strony

Zwróć uwagę na sposób, w jaki zmieniona została zawartość bloczka warunkowego if przy drugim przycisku. Po reakcji na wciśnięcie przycisku A zmniejszamy liczbę o 1 (odejmujemy od zmiennej licznik 1 przy każdym naciśnięciu przycisku). Z kolei w warunku sprawdzamy, czy zmienna licznik nie równa się −1. Jeśli wartość będzie równa −1, to ustawiamy wartość zmiennej na 9. Dzięki temu nasz licznik będzie mógł odliczać do tyłu w koło (np. 3, 2, 1, 0, 9, 8 itd).

Wirtualna kostka do gry

W jednym z poprzednich odcinków kursu micro:bita zbudowaliśmy prostą kostkę do gry, która mogła wyświetlać losową cyfrę (od 1 do 6) na ekranie. Kostka oczywiście spełniała swoje zadanie, ale nie była podobna do tradycyjnych kostek, które wynik pokazują za pomocą oczek.

Kości do gry ze standardowym oznaczeniem w formie oczek

Kości do gry ze standardowym oznaczeniem w formie oczek

Teraz, gdy znamy już zmienne, możemy zbudować taką kostkę, która wyświetli wynik w formie oczek. Tworzymy nowy projekt i zaczynamy od deklaracji nowej zmiennej. Tym razem może ona nazywać się np. kostkaWynik. Ostrzegam, że program działający jak kostka jest bardzo prosty, ale długi, dlatego pozornie może wydawać się trudny – nie ma się jednak czego bać.

Zacznijmy więc od krótkiego początku. Po wciśnięciu przycisku A chcemy wylosować liczbę z zakresu od 1 do 6 i zapisać ją do zmiennej kostkaWynik. Następnie, zależnie od wartości zmiennej, będziemy wyświetlać na ekranie inne wyniki (oczka kostki). Początek programu powinien więc wyglądać tak:

Początek programu kostki do gry

Początek programu kostki do gry

Zaraz po wylosowaniu liczby i zapisaniu jej do zmiennej w programie jest warunek. Sprawdza on, czy wylosowana liczba to 1 – jeśli tak, to na ekranie pojawi się jedno oczko; jeśli wartość będzie inna, to nic się nie stanie. Musimy więc dorobić kolejne warunki, aby układ działał poprawnie dla wszystkich liczb. Robimy to poprzez rozbudowanie bloczka warunkowego o kolejne warunki (za pomocą ikony plusa).

Pełny kod programu graficznej kostki do gry na micro:bit

Pełny kod programu graficznej kostki do gry na micro:bit

Warto zwrócić uwagę na koniec tego bloczka warunkowego. Nie sprawdzamy, czy wylosowana liczba to 6. Dlaczego? Wiemy, że zmienna kostkaWynik może być równa 1, 2, 3, 4, 5 lub 6. Cały bloczek jest sprawdzany od góry do dołu, więc jeśli żaden z wcześniejszych warunków nie był prawdziwy, to znaczy, że nasza wylosowana liczba na pewno nie jest równa 1, 2, 3, 4 ani 5. Zostaje zatem tylko jedna możliwość – to musi być 6, więc nie musimy tego sprawdzać osobnym bloczkiem if kostkaWynik = 6.

Wyświetlacz 7-segmentowy dla micro:bita

Pora poznać kolejny moduł z Grove, który jest w naszym zestawie. Tym razem to wyświetlacz, który może wyświetlać liczbę składającą się z 4 cyfr. Wyświetlacze tego typu nazywa się 7-segmentowymi, bo cyfry są wyświetlane za pomocą 7 segmentów. Każdy segment to tak naprawdę dioda świecąca, która może świecić lub nie – włączając poszczególne segmenty, tworzymy cyfrę.

Wyświetlacze 7-segmentowe bardzo często spotyka się w zegarach i budzikach

Wyświetlacze 7-segmentowe bardzo często spotyka się w zegarach i budzikach

Elektronicy nazywają każdy z tych segmentów za pomocą kolejnych znaków alfabetu od a do g – nam nie będzie to potrzebne, ale warto o tym pamiętać, bo takie oznaczenie spotyka się bardzo często.

Opis poszczególnych elementów na wyświetlaczu 7-segmentowym

Opis poszczególnych elementów na wyświetlaczu 7-segmentowym

Pierwsze uruchomienie wyświetlacza

Napiszmy program testowy, który na wyświetlaczu pokaże dowolną wartość, np. Twój rok urodzenia. Zaczynamy od utworzenia nowego projektu oraz instalacji bloczków Grove (opis tej czynności znajduje się w poprzedniej części kursu). Następnie podłączamy moduł wyświetlacza do P0/P14.

Trochę wcześniej wspomniałem, że zmienne mogą przechowywać informacje o liczbach czy tekstach oraz bardziej skomplikowane informacje, np. grafiki. Okazuje się jednak, że uniwersalność zmiennych jest jeszcze większa! Do naszej szufladki możemy też włożyć jakiś bardziej skomplikowany moduł, jak np. opisywany tutaj moduł wyświetlacza 7-segmentowego.

Na razie zajmijmy się obsługą wyświetlacza. Aby było to możliwe, musimy utworzyć nową zmienną, np. wyswietlacz (przypominam o braku polskich znaków). Następnie do on start przenosimy nasz nowy bloczek set wyswietlacz to. Poprzednio do zmiennej przypisywaliśmy jakąś liczbę, a teraz chcemy ją powiązać z wyświetlaczem. W tym celu używamy bloczka 4-Digit Display at P0 and P14 z zakładki Grove. Całość ma wyglądać następująco:

Informacja o wyświetlaczu przypisana do zmiennej

Informacja o wyświetlaczu przypisana do zmiennej

Jeśli w jednym programie jest kilka zmiennych, to bloczki set oraz change pojawiają się w zakładce Variables tylko raz (nie są powielane dla każdej zmiennej). Wybieramy wtedy odpowiedni typ bloczka, a po wstawieniu go do programu wybieramy z listy rozwijanej tą zmienną, która nas interesuje (trzeba tylko kliknąć na ikonkę trójkąta na bloczku).

Powyższy program należy rozumieć następująco: przypisz do naszej zmiennej wyswietlacz informacje na temat wyświetlacza 7-segementowego, który podłączony jest do micro:bita do pinów P0 i P14 (tak, ten moduł korzysta z dwóch sygnałów, które na szczęście są wyprowadzone do tego samego gniazda).

Od teraz, gdy będziemy chcieli zmienić coś w ustawieniach wyświetlacza lub pokazać na nim liczbę, to nie będziemy musieli się do niego odwoływać przez długi bloczek 4-Digit Display at P0 and P14 –wystarczy, że użyjemy zmiennej wyswietlacz.

Teraz możemy ustawić jasność wyświetlacza – w tym celu przyda się bloczek brightness level to, który znajdziemy w zakładce Grove (0 to najniższa jasność, a 7 – najwyższa). Aby pokazać liczbę na wyświetlaczu, wykorzystujemy kolejny bloczek z tej zakładki (tym razem jest to show number) i zwyczajnie wpisujemy tam rok urodzenia (lub dowolną inną liczbę).

Program testujący wyświetlacz 7-segmentowy

Program testujący wyświetlacz 7-segmentowy

Oba bloczki są domyślnie uzupełnione nową zmienną – strip. Chcemy wykorzystać naszą zmienną, więc usuwamy tę, która została utworzona automatycznie. Klikamy na trójkąt obok nazwy zmiennej strip i z rozwijanego menu wybieramy Delete the "strip" variable.

Usuwanie zbędnej zmiennej

Usuwanie zbędnej zmiennej

Następnie podstawiamy w obu bloczkach naszą zmienną (przeciągając ją z zakładki Variables).

Poprawnie uzupełnione bloczki

Poprawnie uzupełnione bloczki

Po wgraniu programu na wyświetlaczu pokaże się liczba. W ramach dodatkowego eksperymentu warto sprawdzić, jak wyświetlacz będzie świecił przy różnych ustawieniach jasności. Niska jasność może być bardzo słabo widziana w dzień, ale za to świetnie sprawdzi się wieczorem.

Pierwszy test wyświetlacza 7-segmentowego podłączonego do micro:bita

Pierwszy test wyświetlacza 7-segmentowego podłączonego do micro:bita

Test czujników analogowych

Jak pewnie pamiętasz z poprzednich części kursu, wartości odczytywane z czujników analogowych (np. z czujnika obrotu i jasności) to liczby z zakresu od 0 do 1023. Ciężko byłoby odczytać taką dużą liczbę z ekranu micro:bita, ale bardzo łatwo będzie ją widać na naszym nowym wyświetlaczu. Zacznijmy od podłączenia wyświetlacza 7-segmentowego do P0/P14, a czujnika obrotu – do P1.

Teraz stwórzmy program, który cały czas (w pętli) będzie pobierał informacje z czujnika i wyświetlał je na naszym nowym wyświetlaczu. Kod programu jest krótki. Przypisanie informacji o wyświetlaczu musi zostać wewnątrz on start, bo informację o podłączeniu wyświetlacza ustawiamy raz, i to na początku działania programu. Tak samo w przypadku ustawienia jasności.

W pętli forever umieszczamy bloczek show number (z zakładki Grove), który uzupełniamy bloczkiem analog read pin P1 – dzięki temu wartość odczytana z czujnika obrotu trafi prosto do wyświetlacza.

Program testujący czujnik analogowy

Program testujący czujnik analogowy

Po uruchomieniu programu na wyświetlaczu pojawi się liczba z zakresu od 0 do 1023, która będzie się zmieniała, gdy będziemy kręcić czujnikiem. Czasami może się zdarzyć, że wskazania na ekranie nie będą stabilne (np. szybko będzie się zmieniała ostatnia cyfra) lub nigdy nie będą wskazywały aż 1023. Wynika to z tego, że dane z czujnika nie są idealne i czasami micro:bit nie może zmierzyć dokładnej wartości – aby ustabilizować odczyty, można dodać opóźnienie (np. 200 milisekund) w pętli forever.

Podgląd wartości z czujnika obrotu na wyświetlaczu 7-segmentowym

Podgląd wartości z czujnika obrotu na wyświetlaczu 7-segmentowym

Prosty stoper na micro:bit

Wykorzystajmy wiedzę na temat zmiennych oraz nowego wyświetlacza do budowy stopera. Tworzymy nowy projekt, instalujemy bloczki Grove, podłączamy wyświetlacz do P0/P14 i od razu przechodzimy do pisania programu.

Zaczynamy od tego, co ma wydarzyć się po włączeniu, czyli w on start. Inicjalizujemy tam wyświetlacz i ustawiamy jasność. Oprócz tego używamy bloczka turn true colon point, który znajdziemy w menu more wewnątrz zakładki Grove. Za pomocą tego bloczka włączymy kropki na naszym wyświetlaczu (oddzielą one później sekundy od części dziesiętnych).

Teraz dodamy nową zmienną – czas, którą będziemy zwiększać o 1 w każdym obiegu forever. W pętli znajduje się również opóźnienie 1000 milisekund, aby zmienna była zwiększana co sekundę; oprócz tego jej wartość będzie pokazywana na wyświetlaczu.

Pierwsza wersja stopera

Pierwsza wersja stopera

Tym łatwym sposobem udało nam się napisać pierwszą wersję prostego stopera. Po uruchomieniu programu na wyświetlaczu zobaczymy, że micro:bit odlicza sekundy.

Pierwsza wersja prostego stopera – wyświetlacz wskazuje 13 sekund

Pierwsza wersja prostego stopera – wyświetlacz wskazuje 13 sekund

Stoper miał jednak pokazywać sekundy i dziesiętne sekundy, a w tej chwili naszą zmienną zwiększamy co sekundę, więc stoper odlicza tylko sekundy. Musimy zatem przyspieszyć program, aby pętla była wykonywana 100 razy szybciej – wtedy zmienna będzie zwiększana co 10 milisekund. Zmieniamy więc opóźnienie z pause (ms) 1000 na pause (ms) 10.

Stoper, który pokazuje wynik do dziesiętnych części sekundy

Stoper, który pokazuje wynik do dziesiętnych części sekundy

Od teraz nasz stoper będzie pracował już tak jak powinien – przed kropkami na wyświetlaczu pojawią się pełne sekundy, a za kropkami będą dziesiętne części sekundy.

Pierwsza wersja prostego stopera – wyświetlacz wskazuje 2,06 sekundy

Pierwsza wersja prostego stopera – wyświetlacz wskazuje 2,06 sekundy

Sterowanie pracą stopera

Nasz stoper działa całkiem fajnie, ale niestety nie jest zbyt wygodny, bo zaczyna odliczać czas zaraz po włączeniu zasilania. Przydałoby się, aby ruszał on dopiero po naciśnięciu jakiegoś przycisku. Oczywiście możemy to dorobić – potrzebna jest tylko kolejna zmienna, np. start.

Tworzymy nową zmienną i na końcu bloczka on start przypisujemy jej wartość 0. Następnie w forever dodajemy warunek, który sprawi, że zawarte tam instrukcje będą wykonywane tylko wtedy, gdy zmienna start będzie miała wartość 1. Domyślnie, po włączeniu, zmienna ta będzie równa 0, więc stoper nie ruszy. Do tego dodajemy jeszcze bloczek on button A pressed, w którym ustawiamy zmienną start na 1.

Stoper z opcją startowania pomiaru przyciskiem

Stoper z opcją startowania pomiaru przyciskiem

Od teraz stoper będzie ruszał dopiero po wciśnięciu przycisku A, ponieważ dopiero wtedy zmienna start przyjmie wartość 1, co sprawi, że w pętli forever rozpocznie się odliczanie czasu.

Do pełni szczęścia potrzebne nam jest jeszcze zatrzymywanie pracy stopera. W tym celu wystarczy, że dodamy bloczek on button B pressed, w którym ustawimy wartość zmiennej start na 0 – wtedy stoper się zatrzyma, bo warunek w pętli znów nie będzie prawdziwy. Do reakcji na naciśnięcie przycisku A dodajemy jeszcze ustawienie zmiennej czas na 0.

Stoper z funkcją startowania i zatrzymywania pomiaru

Stoper z funkcją startowania i zatrzymywania pomiaru

Na koniec drobny detal estetyczny – dodajmy trzy bloczki show arrow. Będą one wskazywały przycisk, który należy nacisnąć. Gdy stoper jest wyłączony, strzałka ma wskazywać na przycisk A (aby włączyć pomiar), a gdy stoper działa, to strzałka ma wskazywać przycisk B (aby wyłączyć pomiar).

Kompletny program stopera

Kompletny program stopera

Od teraz nasz układ działa już jak prawdziwy stoper, który oczywiście można jeszcze rozbudować o kolejne opcje. Ostateczna wersja powinna na ten moment działać następująco:

Podsumowanie

Za nami intensywna część kursu, w której sprawdziliśmy, jak w praktyce działają zmienne. Upewnij się, że dobrze rozumiesz to zagadnienie, bo jest ono bardzo, ale to bardzo ważne. Praktycznie nie da się napisać żadnego rozbudowanego programu bez zmiennych.

Czy wpis był pomocny? Oceń go:

Średnia ocena 5 / 5. Głosów łącznie: 7

Nikt jeszcze nie głosował, bądź pierwszy!

Artykuł nie był pomocny? Jak możemy go poprawić? Wpisz swoje sugestie poniżej. Jeśli masz pytanie to zadaj je w komentarzu - ten formularz jest anonimowy, nie będziemy mogli Ci odpowiedzieć!

W kolejnej części zajmiemy się czymś przyjemnym dla oka. Wykorzystamy taśmę diod RGB, które mogą świecić na dowolne kolory tęczy. Dzięki temu wszystkie nasze projekty będą mogły być pełne kolorów.

Autor kursu: Damian Szymański

Nawigacja kursu

kurs, kursmicrobit, micro:bit, stoper, wyświacz, zmienne

Trwa ładowanie komentarzy...