Kursy • Poradniki • Inspirujące DIY • Forum
Arduino - rysowanie wykresów
Oczywiście Arduino IDE z czasem się zmienia. Niedawno pojawiła się tam bardzo wygodna opcja, która pozwala na szybkie rysowanie wykresów z informacji przesyłanych przez UART.
Aby móc korzystać z tego narzędzia potrzebujemy nowej wersji Arduino IDE, jeśli instalowałeś je niedawno i w menu narzędzia widzisz dwie opcje: "Szeregowy monitor" oraz "Monitor portu szeregowego", to nie musisz już nic robić.
Niestety, ale nazwy obu opcji w polskiej wersji językowej IDE są delikatnie mówiąc mało intuicyjne i mylące. Poprzednio używany przez nas terminal znajduje się teraz pod opcją: Szeregowy monitor.
Jeśli widzisz tylko jedną opcję tego typu, to zaktualizuj swoje IDE. Najnowsza wersja dostępna jest oczywiście za darmo na stronie projektu.
Aby rysować wykres musimy, najlepiej w regularnych, odstępach wysyłać do komputera liczby w nowej linii. Na początku stwórzmy układ, który będzie rysował wykres napięcia mierzonego na wejściu A5, do którego podłączymy potencjometr w roli dzielnika napięcia.
Gotowe zestawy do kursów Forbota
Komplet elementów Gwarancja pomocy Wysyłka w 24h
Teraz możesz kupić zestaw ponad 70 elementów niezbędnych do przeprowadzenia ćwiczeń z kursu u naszych dystrybutorów!
Zamów w Botland.com.pl »Popularne pakiety: Mistrz Arduino • Mistrz Robotyki
Schemat podłączenia układu wygląda następująco:
Standardowa wersja programu wysyłającego dane do terminala wyglądałaby następująco:
int odczytanaWartosc = 0;
void setup() {
Serial.begin(9600); //Uruchomienie komunikacji przez USART
}
void loop() {
odczytanaWartosc = analogRead(A5); //Odczytujemy wartość napięcia
Serial.println(odczytanaWartosc); //Wysyłamy ją do terminala
delay(200); //Czekamy, aby wygodniej odczytywać wyniki
}
Korzystając z opcji "Szeregowy monitor", podczas kręcenia potencjometrem, zobaczymy taki efekt:
Mało czytelnie prawda? Wystarczy jednak włączyć drugą opcję, czyli "Monitor portu szeregowego", a naszym oczom ukaże się znacznie bardziej czytelniejszy efekt. Będzie to wykres, przykład dla pomiarów, gdy zmieniałem ręcznie ustawienia potencjometru:
Prawda, że znacznie czytelniej? Kiedy w praktyce przydają się takie opcje? Oczywiście wtedy, gdy korzystamy z czujników (odległości, temperatury itd.). Tak się składa, że w poprzedniej części kursu Arduino omówiliśmy obsługę czujnika odległości HC-SR04. Spróbujmy narysować więc wykres mierzonej odległości!
Arduino - wykres odległości od przeszkody
W tym celu wracamy do schematu montażowego z poprzedniego artykułu:
Uruchamiamy również kod napisany podczas poprzedniej lekcji. Należy wprowadzić tylko dwie zmiany. Pierwsza, to wyświetlanie wyniku w nowej linii bez jednostki. Druga, to odrobina większa częstotliwość pomiarów - dzięki temu wykres będzie bardziej płynny.
#define trigPin 12
#define echoPin 11
void setup() {
Serial.begin (9600);
pinMode(trigPin, OUTPUT); //Pin, do którego podłączymy trig jako wyjście
pinMode(echoPin, INPUT); //a echo, jako wejście
}
void loop() {
long czas, dystans;
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
czas = pulseIn(echoPin, HIGH);
dystans = czas / 58;
Serial.println(dystans);
delay(100);
}
Gotowe? Pora uruchomić narzędzie do rysowania wykresów. Tutaj może być różnie - czasami zadziała, a czasami nie. Dlaczego?
Przy korzystaniu z takich czujników zawsze ryzykujemy,
że odbierzemy pewne zakłócenia.
W przypadku tego czujnika odległości zakłócenie może spowodować, że wyślemy do komputera informację o błędnym pomiarze. Na poniższym zrzucie ekranu widać, że jeden z pierwszych pomiarów wskazał odległość wynoszącą 2000 cm.
Nie jest to możliwe, jeśli producent zadeklarował maksymalny pomiar na 400 cm.
Spowodowało to automatyczne dobranie skali na wykresie, które utrudnia odczytanie późniejszych, poprawnych wyników. Jak temu zaradzić? Najlepiej programowo. Dodajmy prosty warunek, który będzie sprawdzał jaką wartość wysyłamy do komputera. Może on wyglądać np. tak:
if (dystans > 400) { //Jeśli obliczona odległość jest większa od 400
dystans = 400; //to ustaw ją na 400 (max wskazane przez producenta)
}
Dzięki temu nigdy nie wyślemy do komputera wartości, która wykracza za zakres czujnika. Zmienna dystans została zadeklarowana jako liczba dodatnia, więc wystarczy sprawdzać górny zakres. Nie musimy kontrolować dolnego. Cały program po zmianach wygląda tak:
#define trigPin 12
#define echoPin 11
void setup() {
Serial.begin (9600);
pinMode(trigPin, OUTPUT); //Pin, do którego podłączymy trig jako wyjście
pinMode(echoPin, INPUT); //a echo, jako wejście
}
void loop() {
long czas, dystans;
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
czas = pulseIn(echoPin, HIGH);
dystans = czas / 58;
if (dystans > 400) { //Jeśli obliczona odległość jest większa od 400
dystans = 400; //to ustaw ją na 400 (max wskazane przez producenta)
}
Serial.println(dystans);
delay(100);
}
Teraz wykres za każdym razem będzie wyglądał poprawnie:
Podczas nagrywania pomiarów przesuwałem szybko przeszkodę przed czujnikiem. Jak widać, kilka razy nasze ograniczenie uchroniło nas przed błędnymi pomiarami. Przy okazji warto zwrócić uwagę, jak rysowanie wykresu ułatwia zauważenie problemów z jakością odczytów z sensora! Tutaj np.: widać stosunkowo duże szumy wartości, odczyty nie są stabilne.
Arduino - wykres kilku wartości
Opisana funkcja rysowania wykresów pozwala również na jednoczesne rysowanie kilku wartości na jednej planszy. Aby wykorzystać tę opcję należy wysłać liczby w tej samej linii oddzielonych znakiem tabulatora, a na ich końcu powinien pojawić się znak nowej linii.
W praktyce kod będzie wyglądał tak:
Serial.print(Wartosc1);
Serial.print("\t"); // Znak tabulatora
Serial.print(Wartosc2);
Serial.print("\t"); // Znak tabulatora
Serial.print(Wartosc3);
Serial.print("\t"); // Znak tabulatora
Serial.print(Wartosc4);
Serial.println(""); // Przejście do nowej linii
Natomiast wykres po podstawieniu wartości losowych wyjdzie przykładowo taki:
Rysowanie wykresów może być również szczególnie przydatne, gdy wykorzystujemy czujniki przyspieszenia lub położenia. Zachęcam do przeczytania mojego artykułu, w którym pokazałem jak wykorzystać najnowsze Genuino 101 do obrazowania jego położenia!
Tam właśnie wykorzystałem jednoczesne rysowanie wykresu dla kilku wartości:
Zadanie domowe 10.1
Wykorzystaj w praktyce możliwość rysowania jednocześnie kilku wykresów. Do Arduino podłącz dwa fotorezystory - robiliśmy to już w innych lekcjach. Następnie mierz napięcie odzwierciedlające poziom światła padającego na każdy z czujników. Obie wartości zaprezentuj na jednym wykresie. Pochwal się w komentarzu zrzutem ekranu przedstawiającym Twój wykres!
Arduino - liczby losowe
Czasami oczekujemy, aby program działał w sposób "nieprzewidywalny". Praktyczny przykład? Robot, który po wykryciu przeszkody obraca się o losowy kąt lub prosta gra, w której komputer wykonuje swój ruch z nieprzewidywalnym opóźnieniem. W poprzednim przykładzie użyłem właśnie takich wartości, aby zademonstrować jednoczesne rysowanie wykresów dla różnych danych.
W tym miejscu przydaje się funkcja zwracająca losową wartość. Jednak mówiąc szczerze, liczba ta nie będzie zupełnie nieprzewidywalna. Dlatego w przypadku komputerów/mikrokontrolerów mówimy o liczbach pseudolosowych. Jest to temat dość rozbudowany i nie będziemy się tutaj nim zajmować.
Warto jednak zapamiętać, że wartości losowane przez komputer z punktu widzenia statystyki nie są idealnie losowe (w dużym uproszczeniu pisząc).
Za zwracanie losowej wartości odpowiedzialna jest funkcjarandom();, która może przyjąć dwa argumenty. Dzięki nim kształtujemy zakres, z jakiego losowane są liczby. W praktyce funkcję najczęściej wykorzystujemy na jeden z dwóch sposobów. Z podaniem wyłącznie górnego zakresu:
random(500); //Liczba losowa z zakresu 0-499
Wtedy zwrócona wartość będzie liczbą z zakresu od 0 do liczby o jeden mniejszej od tej wpisanej w nawiasie. Możemy również wpłynąć na dolne ograniczenie zakresu. W tym celu wystarczy dodać drugi argument:
random(100, 500); //Liczba losowa z zakresu 100-499
Zapamiętaj!
Maksymalna wylosowana liczba będzie zawsze o 1 mniejsza od podanego przez nas górnego zakresu!
Pora sprawdzić działanie tej funkcji w praktyce. W tym celu napiszmy najbanalniejszy program, jaki tylko można wykonać. Jego zadaniem jest losowanie liczb w odstępach 1 sekundy i wyświetlanie ich w terminalu (opcja "Szeregowy monitor" w menu "Narzędzia"):
void setup() {
Serial.begin(9600);
}
void loop() {
Serial.println(random(300));
delay(1000);
}
Zgodnie z zapowiedzią w terminalu oczekujemy losowych wartości. Sprawdźmy:
Chcieliśmy losowe dane i mamy. Teraz uruchommy wgrany program kilka kolejnych razy. Zgodnie z oczekiwaniami za każdym razem liczby losowe powinny być inne, prawda?
- trzecie uruchomienie,
- czwarte uruchomienie,
- piąte uruchomienie.
Niestety, za każdym razem otrzymujemy identyczny ciąg. Tak jak pisałem "losowość" zwracanych liczb jest trochę oszukana. Mikrokontroler na pokładzie Arduino, to bardzo precyzyjny układ, który wykonuje kolejne, zaprogramowane operacje. W jego świecie nie istnieją wartości losowe.
Jak można się domyślać Arduino losowe liczby generuje wykonując pewne określone operacje na poprzednio wylosowanej wartości.
Stąd taki sam początek sprawia, że kolejne liczby są identyczne.
Aby poprawić działanie algorytmu losującego najlepiej byłby przed każdym jego startem zaczynać od podania innej wartości jako tej pierwszej, początkowej.
Ta liczba, na podstawie której generowane są następne nosi nazwę ziarna/zarodka, w języku angielskim określona jest ona jako random seed. Więcej na ten temat znaleźć można na Wikipedii (hasło: generator liczb pseudolosowych). Dla nas najważniejsze jest, że w języku Arduino występuje również takie pojęcie - mamy wpływ na owe ziarno. Służy do tego funkcja:
randomSeed(wartosc_poczatkowa);
W jej argumencie, zaznaczonym tutaj jako wartosc_poczatkowa, należy podać za każdym razem... losową wartość. Ale namieszałem, prawda? Aby losować liczby, potrzebujemy losowej wartości. Macie pomysł jak to uzyskać? Jeśli nie, to zerknijcie to lekcji o przetworniku ADC w Arduino.
Co dzieje się, gdy do odczytywanego wejście nie podłączymy żadnego sygnału? Wtedy zbieramy "śmieci" z otoczenia, które są... właśnie losowe. Do tej pory było to dla nas problemem. Jednak tutaj wykorzystamy te wartości w słusznym celu.
Aby nasze Arduino korzystało z "bardziej losowych" liczb możemy na początku zrobić tak:
randomSeed(analogRead(A0));
Dzięki temu, przy każdym starcie programu zmierzymy losowe napięcie panujące na wejściu A0. Dalej wartość ta zostanie podana jako ziarno do generatora liczb pseudolosowych.
Oczywiście całość zadziała najlepiej, jeśli wejście A0 nie będzie wykorzystywane jako standardowe wejście/wyjście.
Poprawmy szybko nasz program i sprawdźmy go w praktyce:
void setup() {
Serial.begin(9600);
randomSeed(analogRead(0));
}
void loop() {
Serial.println(random(300));
delay(1000);
}
Od teraz, po każdym uruchomieniu otrzymamy inne wartości:
- Pierwsze uruchomienie,
- drugie uruchomienie,
- trzecie uruchomienie.
Oczywiście nadal nie jest to idealny generator liczb losowych, jednak w takiej formie wystarczy on do wykorzystania w zdecydowanej większości projektów tworzonych na bazie Arduino.
Zadanie domowe 10.2
Sprawdź, co stanie się, jeśli zamiast ziarna odczytywanego z wejścia analogowego wpiszemy tam stałą wartość. Jak wtedy zachowa się generator liczb pseudolosowych?
Zadanie domowe 10.3
Napisz program, który działa jak elektroniczna kostka do gry. Do Arduino podłącz przycisk. Każde jego wciśnięcie powinno wysyłać do komputera (prze UART) wylosowaną wartość - oczywiście z zakresu od 1 do 6.
Losowe miganie diodą
Wykorzystajmy zdobytą wiedzą do napisania programu, który będzie migał diodą wbudowaną w Arduino w sposób losowy. Załóżmy, że długość świecenia ma wahać się od około 100ms do 990ms. Natomiast czas, gdy dioda jest wyłączona będzie w granicach 50-490ms. Obie wartości powinny zmieniać się w odstępach, co 10 ms.
W tym celu potrzebować będziemy dwóch wartości losowych:
int czasWlaczona = random(100, 1000);
int czasWylaczona = random(50, 500);
Tak wylosowane wartości moglibyśmy wstawić do funkcji opóźniającej delay, jednak wtedy opóźnienie mogłoby przyjmować wartości np.: od 100 do 999, czyli nie zachowalibyśmy założonych odstępów o 10ms. Jak to naprawić?
Wystarczy, że będziemy losować wartości 10 razy mniejsze, które pomnożymy razy 10 przed podstawieniem ich do funkcji opóźniającej:
int czasWlaczona = random(10, 100); //Wartość z zakresu 10 - 99
int czasWylaczona = random(5, 50); //Wartość z zakresu 5 - 49
czasWlaczona = czasWlaczona * 10; //Wartość z zakresu 100 - 990, skok co 10
czasWylaczona = czasWylaczona * 10; //Wartość z zakresu 50 - 490, skok co 10
Teraz wartości te można podstawić już do programu:
void setup() {
pinMode(13, OUTPUT);
randomSeed(analogRead(0));
}
void loop() {
int czasWlaczona = random(10, 100); //Wartość z zakresu 10 - 99
int czasWylaczona = random(5, 50); //Wartość z zakresu 5 - 49
czasWlaczona = czasWlaczona * 10; //Wartość z zakresu 100 - 990, skok co 10
czasWylaczona = czasWylaczona * 10; //Wartość z zakresu 50 - 490, skok co 10
digitalWrite(13, HIGH);
delay(czasWlaczona);
digitalWrite(13, LOW);
delay(czasWylaczona);
}
W praktyce dioda miga, tak jak chcieliśmy, czyli zupełnie losowo!
Łączenie instrukcji warunkowych
Już na samym początku kursu Arduino zajęliśmy się instrukcjami warunkowymi, które są używane do sterowania pracą programu w zależności od pewnych informacji. Najczęściej sprawdzaliśmy tylko jeden warunek, np.: "Czy przycisk został wciśnięty?". W programie wyglądało to następująco:
if (digitalRead(7) == LOW) { //Jeśli przycisk wciśnięty
//Zrób coś
} else { //Jeśli warunek nie został spełniony (przycisk nie jest wciśnięty)
//Zrób coś innego...
}
W praktyce często może się zdarzyć, że będziemy chcieli sprawdzić jednocześnie dwa warunki. Najprostszym przykładem będzie sprawdzenie, czy użytkownik wcisnął więcej niż jeden przycisk.
Oczywiście można to zrobić tradycyjnie:
if (digitalRead(7) == LOW) { //Jeśli pierwszy przycisk wciśnięty, sprawdź...
if (digitalRead(8) == LOW) { //...czy wciśnięto również drugi przycisk
//Zrób coś
}
}
Rozwiązanie jest skuteczne, jednak pojawią się pewne problemy z czytelnością takie zapisu, gdy będziemy chcieli sprawdzić jednocześnie jeszcze więcej warunków. Dlatego zdecydowanie łatwiej będzie, gdy poznamy dwa operatory logiczne:
- Iloczyn logiczny - &&
- Suma logiczna - ||
O takiej możliwości wspomniałem już w poprzedniej części kursu Arduino.
Teraz rozwiniemy ten temat.
Pierwszy z nich wykorzystamy, gdy będziemy chcieli sprawdzić, czy:
warunek pierwszy i warunek drugi został spełniony
if (warunek1 == 1 && warunek2 == 1)
Drugi z nich służy natomiast do sprawdzania, czy:
spełniony został warunek pierwszy lub warunek drugi (lub oba)
if (warunek1 == 1 || warunek2 == 1)
Łączenie warunków w praktyce
W tym celu podłączmy do Arduino dwie diody (zieloną i czerwoną) oraz dwa przyciski. Schemat montażowy wygląda następująco:
Teraz napiszmy program, który będzie włączał diodę zieloną, gdy wciśniemy jeden z dwóch przycisków. Kod może wyglądać np. tak:
void setup() {
pinMode(10, INPUT_PULLUP); //Przycisk jako wejście
pinMode(9, INPUT_PULLUP); //Przycisk jako wejście
pinMode(8, OUTPUT); //Dioda zielona jako wyjście
pinMode(7, OUTPUT); //Dioda czerwona jako wyjście
digitalWrite(8, LOW); //Wyłączenie diody zielonej
digitalWrite(7, LOW); //Wyłączenie diody czerwonej
}
void loop() {
if (digitalRead(9) == LOW || digitalRead(10) == LOW) { //Jeśli przycisk pierwszy lub drugi
digitalWrite(8, HIGH); //Włącz diodę zieloną
} else {
digitalWrite(8, LOW); //Wyłącz diodę zieloną
}
}
W praktyce najważniejsza część tego programu ogranicza się do jednej linijki. Konkretnie warunku, w którym za jednym razem sprawdzamy stany dwóch przycisków. Jeśli przynajmniej jeden z nich został wciśnięty, to dioda zostanie włączona.
Nasz program sprawdza, czy spełniono przynajmniej jeden warunek. W związku z tym dioda będzie również świeciła, gdy jednocześnie wciśniemy oba przyciski.
Rozbudujmy trochę program i dodajmy osobny warunek, który będzie włączał diodę czerwoną, tylko gdy jednocześnie wciśniemy oba przyciski:
void setup() {
pinMode(10, INPUT_PULLUP); //Przycisk jako wejście
pinMode(9, INPUT_PULLUP); //Przycisk jako wejście
pinMode(8, OUTPUT); //Dioda zielona jako wyjście
pinMode(7, OUTPUT); //Dioda czerwona jako wyjście
digitalWrite(8, LOW); //Wyłączenie diody zielonej
digitalWrite(7, LOW); //Wyłączenie diody czerwonej
}
void loop() {
if (digitalRead(9) == LOW || digitalRead(10) == LOW) { //Jeśli przycisk pierwszy lub drugi
digitalWrite(8, HIGH); //Włącz diodę zieloną
} else {
digitalWrite(8, LOW); //Wyłącz diodę zieloną
}
if (digitalRead(9) == LOW && digitalRead(10) == LOW) { //Jeśli przycisk pierwszy i drugi
digitalWrite(7, HIGH); //Włącz diodę zieloną
} else {
digitalWrite(7, LOW); //Wyłącz diodę zieloną
}
}
Działanie ostatecznej wersji programu widoczne jest na poniższym filmie:
Praktyczny przykład - czujnik odległości
Powyższe przykłady pokazywały, że układ działa, ale nie były zbyt użyteczne. Spróbujmy teraz zrobić coś bardziej praktycznego. Podłączmy do Arduino przycisk, czujnik odległości oraz buzzer. Układ będzie miał piszczeć brzęczykiem, jeśli przeszkoda znajdzie się w odległości między 20, a 40 cm lub, gdy wciśniemy przycisk.
Wyjdzie nam z tego połączenie czujników parkowania z klaksonem!
Do dzieła, najpierw łączymy potrzebny obwód. Aby było trochę trudniej, tym razem zamiast schematu montażowego podaję listę połączeń + pomocnicze zdjęcie. Na tym etapie kursie wszyscy powinni już dać radę złożyć taki układ samodzielnie:
- trigPin czujnika odległości do pinu nr 12
- echoPin czujnika odległości do pinu nr 9
- buzzer do pinu nr 11
- przycisk do pinu nr 10
Oczywiście dodatkowo należy podłączyć odpowiednio zasilanie Vcc (szynę dodatnią) do czujnika odległości, natomiast masę do buzzera, przycisku oraz oczywiście również do czujnika. U mnie w praktyce wyglądało to tak:
Pora na napisanie programu. Odczytywać odległość już potrafimy, tak samo sprawdzanie stanu przycisku nie stanowi już dla nas żadnego problemu. Dlatego skupimy się na przeanalizowaniu warunku. Tak jak napisałem, zależy nam na włączenie buzzera, gdy odczytana odległość znajduje się w zakresie od 20 do 40 cm.
W tym celu musimy sprawdzić, czy odczytana wartość jest większa od 20 i jednocześnie mniejsza od 40 cm. Zrobimy to oczywiście w jednym warunku:
if (dystans > 20 && dystans < 40) {
digitalWrite(11, HIGH); //Włącz buzzer
} else {
digitalWrite(11, LOW); //Wyłącz buzzer
}
Teraz pora na obsłużenie przycisku. Oczywiście moglibyśmy rozbić to na dwa osobne warunki:
if (dystans > 20 && dystans < 40) {
digitalWrite(11, HIGH); //Włącz buzzer
} else {
digitalWrite(11, LOW); //Wyłącz buzzer
}
if (digitalRead(10) == LOW) { //Jeśli przycisk wciśnięty
digitalWrite(11, HIGH); //Włącz buzzer
} else {
digitalWrite(11, LOW); //Wyłącz buzzer
}
Tylko po co? Nie powinniśmy powielać tych samych fragmentów kody, gdy tego nie musimy. W tym wypadku zbędne jest ponowne sterowanie włączeniem i wyłączeniem buzzera. Czy nie możemy warunku połączyć w jeden? Oczywiście, że możemy!
Sprawdzimy czy:
(zmierzony dystans jest większy od 20 i mniejszy od 40) lub (czy wciśnięto przycisk)
Przekładając to na język zrozumiały dla komputera będzie to:
if ((dystans > 20 && dystans < 40) || digitalRead(10) == LOW) {
digitalWrite(11, HIGH); //Włącz buzzer
} else {
digitalWrite(11, LOW); //Wyłącz buzzer
}
Tym samym cały program prezentuje się następująco:
#define trigPin 12
#define echoPin 9
void setup() {
pinMode(trigPin, OUTPUT); //Pin, do którego podłączymy trig jako wyjście
pinMode(echoPin, INPUT); //a echo, jako wejście
pinMode(10, INPUT_PULLUP); //Przycisk jako wejście
pinMode(11, OUTPUT); //Buzzer jako wyjście
digitalWrite(11, LOW); //Wyłączenie buzzera
}
void loop() {
long czas, dystans;
digitalWrite(trigPin, LOW);
delayMicroseconds(2);
digitalWrite(trigPin, HIGH);
delayMicroseconds(10);
digitalWrite(trigPin, LOW);
czas = pulseIn(echoPin, HIGH);
dystans = czas / 58;
if ((dystans > 20 && dystans < 40) || digitalRead(10) == LOW) {
digitalWrite(11, HIGH); //Włącz buzzer
} else {
digitalWrite(11, LOW); //Wyłącz buzzer
}
}
W praktyce program działa dokładnie tak jak przewidywaliśmy. Na poniższym filmie widać, że buzzer wydaje dźwięk, gdy przeszkoda znajduje się w odpowiedniej odległości lub, gdy wciśniemy przycisk:
Pamiętasz wcześniejsze wykresy rysowane z odczytów tego czujnika? To właśnie te zakłócenia/piki sprawiają, że czasami słyszymy delikatne piknięcia. Oczywiście można je programowo filtrować, jeszcze kiedyś do tego wrócimy!
Wykorzystanie operatorów logicznych do łączenia warunków jest bardzo proste, a ich odpowiednie użycie pozwala na rozwiązywanie naprawdę zawiłych problemów. Polecam potrenować we własnym zakresie rozbudowane warunki, chociażby rozwiązując poniższe zadanie domowe.
Zadanie domowe 10.4
Napisz programy, które losują liczbę z zakresu 0-100, a następnie sprawdzają, czy wylosowana wartość jest:
- mniejsza od 10 lub większa od 90
- większa od 50, ale nie mieści się w przedziale 70-85
- równa 50, 40, 30 lub 20
- mieści się w zakresie od 10 do 40 lub od 60 do 100
W każdym przypadku wyświetl na PC wylosowaną liczbę oraz informację, czy spełnia warunek.
Podsumowanie
Mam nadzieję, że wiedza, którą zdobyłeś podczas wykonywania ćwiczeń z tego odcinka kursu pomoże Ci w pisaniu jeszcze ciekawszych programów. Bardzo często, dla własnej wygody, będziesz korzystał z łączenia warunków oraz rysowania wykresów.
Poświęć odpowiednią ilość czasu na opanowanie tego materiału.
W kolejnym artykule na zajmiemy się... sprawdzeniem zdobytej tu wiedzy! Tak, pora na mały QUIZ, który pozwoli na ocenę swoich umiejętności. Będzie to sygnał dla Was, czy możecie iść już dalej, czy warto wrócić do niektórych lekcji. Pojawią się również konkretne informacje dotyczące kontynuacji kursu Arduino, czyli poziomu II.
Nawigacja kursu
Nie chcecie przeoczyć kolejnych odcinków? Korzystając z poniższego formularza możecie zapisać się na powiadomienia o nowych publikacjach!
Damian (Treker) Szymański
Powiązane wpisy
arduino, kurs, kursArduino, losowanie, programowanie, wykres
Trwa ładowanie komentarzy...