Kursy • Poradniki • Inspirujące DIY • Forum
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.
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
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!
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
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ę.
Dobre nazwy dla zmiennych to np.: „licznik”, „temperatura”, „liczbaNacisniec”. Bardzo złe nazwy, które nic nam nie mówią o zawartości zmiennej, to np. „aaaaa”, „xxxx”, „test” itd.
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”
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
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.
Komplet elementów 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 »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
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.
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
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.
W praktyce zmienna licznik przyjmuje więc na krótką chwilę wartość 10, ale jest ona zmieniana na 0, zanim zostanie wyświetlona na ekranie micro:bita.
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
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).
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
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
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).
Program jest prosty, ale długi – na poniższej grafice został on sztucznie „przecięty” na dwie kolumny, aby łatwiej mieścił się na ekranie komputera. Oryginalny program dostępny jest tutaj.
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.
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
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
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.
Nie można zrobić tego z każdym modułem, bo czasami nie ma to żadnego sensu, a czasami nie jest to technicznie możliwe, ale nie będziemy się tym szerzej teraz zajmować.
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
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).
„4-Digit” w nazwie bloczka to tylko nazwa producenta, która ma nam podpowiedzieć, że ten wyświetlacz ma możliwość pokazania liczby składającej się z 4 cyfr.
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ę).
Upewnij się, że wybrałeś bloczek show number z zakładki Grove, a nie z zakładki Basic.
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
Następnie podstawiamy w obu bloczkach naszą zmienną (przeciągając ją z zakładki Variables).
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
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
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
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).
Nie da się włączać kropek niezależnie – obie mogą być włączone lub wyłączone.
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
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
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
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
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
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.
Dzięki temu po naciśnięciu tego przycisku odliczanie zawsze zacznie się od 0.
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
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:
Osoby, które zdecydowały się na dodatkowe wsparcie naszej działalności i kupiły kurs w formie książki drukowanej lub e-booka, znajdą w tym miejscu informacje, jak łączyć warunki, aby w jednym bloczku od razu sprawdzić, czy liczba jest np. większa od 400, ale mniejsza od 600, a także przykładowe rozwiązania do poniższych zadań dodatkowych.
Zad. 6.1. Napisz program, który po naciśnięciu przycisku A wyświetla na ekranie jedną z trzech losowych ikon przedstawiających buźki (np. uśmiechniętą, smutną lub zdziwioną).
Zad. 6.2. Stwórz program odtwarzacza muzyki, w którym za pomocą przycisku można zmieniać melodię odtwarzaną w pętli. Do wyboru powinny być cztery melodie, przycisk B ma włączać następny utwór. Gdy dojdziemy do ostatniego utworu, układ powinien wrócić do pierwszej melodii. Na ekranie micro:bita ma wyświetlać się numer aktualnie odgrywanego utworu. Przycisk A powinien wyłączać graną obecnie muzykę, a na ekranie powinna pojawić się wtedy ikonka nutki.
Zad. 6.3. Dodaj do układu z zadania 6.2 czujnik obrotu, który powinien zmieniać tempo odtwarzania muzyki w zakresie od 40 do 240 (domyślnie 120). Podpowiedź: do zmiany tempa wykorzystaj bloczek set tempo to (bmp), który ustawia je na wskazaną w nim wartość.
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.
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
kurs, kursmicrobit, micro:bit, stoper, wyświacz, zmienne
Dołącz do 20 tysięcy osób, które otrzymują powiadomienia o nowych artykułach! Zapisz się, a otrzymasz PDF-y ze ściągami (m.in. na temat mocy, tranzystorów, diod i schematów) oraz listę inspirujących DIY z Arduino i RPi.
Trwa ładowanie komentarzy...