Najczęściej w projektach bazujących na Arduino używane są wyświetlacze tekstowe, stosunkowo rzadko pojawiają się LCD graficzne.
Zaskakująco dużo osób zapomina o trzeciej opcji, czyli o wyświetlaczach 7-segmentowych. Za ich pomocą możliwe jest prezentowanie stosunkowo prostych informacji. Na pewno każdy kojarzy je z zegarów cyfrowych lub multimetrów.
Większość wyświetlaczy, z którymi się spotykamy, składa się z pikseli, czyli małych, świecących punktów. To właśnie z nich formowane są teksty/grafiki. W przypadku omawianych tu wyświetlaczy 7-segmentowych jest zupełnie inaczej - one zbudowane są z 7 dużych "punktów".
Każdy z nich jest diodą świecącą zbliżoną kształtem do prostokąta. Segmenty przyjęto oznaczać literami: a, b, c, d, e, f, g - ich rozmieszczenie jest zawsze identyczne, zgodne z poniższym:
Opis segmentów wyświetlacza.
Wyświetlenie określonego znaku polega na zaświeceniu odpowiednich segmentów. Przykładowo cyfra 1 wymaga załączenia segmentów B i C, a cyfra 2 segmentów A, B, D, E, G itd.
Niektóre wyświetlacze maja dodatkowo osobne "ósme segmenty" oznaczone jako P. Są to kropki, które mogą przydać się podczas wyświetlania wartości niecałkowitych. Mogą również być użyte w zupełnie innej roli - wszystko zależy od pomysłu konstruktora. Element ten można traktować jako osobną diodę świecącą. Nie jest to kluczowa funkcja takiego wyświetlacza.
Czasami, mimo fizycznej obecności kropki na froncie wyświetlacza zdarza się,
że wcale nie ma tam diody i nie możemy nią sterować.
Konfiguracje wyświetlaczy 7-segmentowych
W sprzedaży znaleźć można wyświetlacze w przeróżnych konfiguracjach. Po pierwsze, mogą one mieć różne rozmiary i kolory. Po drugie, najczęściej w obudowie znajdziemy jeden wyświetlacz, ale są oczywiście produkowane również wersje, które mogą prezentować kilka cyfr obok siebie.
Przykłady różnych wyświetlaczy 7-segmentowych.
Sposób rozmieszczenia wyprowadzeń z obudowy może być w każdym przypadku inny, dlatego zawsze warto wspierać się notą katalogową wyświetlacza. Oczywiście można też starać się samodzielnie zidentyfikować wszystkie wyprowadzenia, ale zajmie to więcej czasu.
Wspólna katoda/anoda
Tak samo jak w przypadku diod RGB, tak również tutaj dla zaoszczędzenia miejsca wewnątrz tych wyświetlaczy producenci łączą katody/anody poszczególnych segmentów. W praktyce oznacza to, że wewnątrz obudowy znajdziemy jeden z poniższych wariantów:
Konfiguracja: wspólna katoda.
Konfiguracja: wspólna anoda.
Mówiąc najprościej: w jednej konfiguracji połączone są wszystkie "minusy" diod, wtedy segment zaświeci się po podaniu "plusa" na jego wejście. Natomiast w drugiej konfiguracji połączone są "plusy", więc segmenty zaczynają świecić, po podaniu na wejście "minusa".
Koniec jednak teoretyzowania, pora przejść do praktyki...
Gotowe zestawy do kursów Forbota
Komplet elementów Gwarancja pomocy Wysyłka w 24h
Części do wykonania ćwiczeć z kursu Arduino (poziom 2) dostępne są w formie gotowych zestawów! W komplecie m.in. diody programowalne, termometry analogowe i cyfrowe, wyświetlacze 7-segmentowe oraz czujnik ruchu (PIR).
Masz już zestaw? Zarejestruj go wykorzystując dołączony do niego kod. Szczegóły »
Testowany wyświetlacz
W zestawach elementów do tego kursu znajduje się podwójny wyświetlacz ze wspólną katodą. Symbol producenta, zależnie do zestawu, to: LDD040AUE-101A lub LDD040AAG-101. Wyświetlacze te są identyczne, różnią się tylko kolorem świecenia (nie ma więc różnicy, który dokładnie posiadasz).
Teraz potrzebny jest rzut oka do noty katalogowej, aby znaleźć opis wyprowadzeń:
Opis wyprowadzeń użytego wyświetlacza.
Jak widać struktury wewnątrz wyświetlacza są kompletnie niezależne - na dobrą sprawę mamy tu dwa osobne wyświetlacze w jednej obudowie. Warto przy okazji zauważyć, że nie ma tutaj żadnej informacji na temat pinów sterujących wyprowadzeniem P (kropka). Tak jak wspomniałem wcześniej, zdarza się, że punkt ten nie jest aktywny - tak będzie w tym przypadku.
Uwaga! Mam nadzieję, że na tym etapie kursu jest jasne, że diody trzeba zasilać przez rezystory. Tutaj jest to jeszcze ważniejsze diody umieszczone wewnątrz wyświetlacza przepalają się jeszcze łatwiej od zwykłych LEDów!
Pozostaje rozwiązanie zagadki, jak numerowane są wyprowadzenia. Tutaj będzie łatwo, ponieważ odpowiednie numerki (1 i 16) producent umieścił na odwrocie wyświetlacza:
Opis numeracji wyprowadzeń wyświetlacza.
Podłączmy teraz pierwszy z dwóch wyświetlaczy do Arduino. Tutaj mam złą wiadomość. Ładne podłączenie całego układu z tej części kursu będzie trudne. Można to oczywiście zrobić szybciej, w bardziej chaotyczny sposób. W moich rozwiązaniach starałem się zrobić to jednak dość ładnie..
Podłączenie wyświetlacza do Arduino
Interesuje nas pierwszy wyświetlacz, czyli segmenty podłączone do nóżek 1, 2, 3, 13, 14, 15, 16. Oczywiście do każdego z wyprowadzeń koniecznie musimy podłączyć rezystory i od tego warto zacząć. Diody w wyświetlaczu są jasne, więc spokojnie sprawdzi się tutaj rezystor 1k.
Zaczynamy więc od podłączenia rezystorów do każdego segmentu wyświetlacza nr 1. Zależy nam, aby później można było połączyć każdy rezystor przewodem z Arduino. U mnie wyglądało to tak:
Rezystory podłączone do wyświetlacza.
Widok bez wyświetlacza.
W związku z tym, że płytka jest wąska (każdy sygnał ma tylko 5 wspólnych pinów) dla ładnego rozłożenia rezystorów musiałem również wykorzystać miejsce, które jest pod wyświetlaczem. Właśnie tą drogą poprowadziłem rezystor do nóżki nr 13 (segment B):
Rezystor prowadzony pod spodem.
Widok z uniesionym wyświetlaczem.
Kolejny krok jest prosty, łączymy każdy rezystor przewodem z Arduino UNO. Kolejność może być dowolna, ja przyjąłem następującą:
wyprowadzenie nr 1 (segment C), do pinu Arduino nr 2,
wyprowadzenie nr 2 (segment E), do pinu Arduino nr 3,
wyprowadzenie nr 3 (segment D), do pinu Arduino nr 4,
wyprowadzenie nr 13 (segment B), do pinu Arduino nr 5,
wyprowadzenie nr 14 (segment G), do pinu Arduino nr 6,
wyprowadzenie nr 15 (segment A), do pinu Arduino nr 7,
wyprowadzenie nr 16 (segment F), do pinu Arduino nr 8.
Pierwsze 3 połączenia.
Kolejne połączenia.
Na sam koniec pozostaje podłączyć masę do czwartego wyprowadzenia Arduino. Na poniższym zdjęciu widać, że zrobiłem to niebieskim przewodem oraz kawałkaiemodciętej nóżki rezystora.
Podłączenie masy do wyświetlacza.
Teraz można przejść do programu, który jest trywialny, po prostu sterujemy 7 diodami... Poniższy przykład powinien uruchamiać po kolei każdy z segmentów (od A do F).
Oczywiście wszystko można napisać krócej, szybciej i lepiej. Skupiłem się jednak na tym, aby cały program był czytelny i prosty. Wszystkie segmenty działają poprawnie, gdy efekt jest następujący:
Test poszczególnych segmentów (animacja jest zapętlona, w praktyce na końcu wszystkie elementy będą się świecić cały czas).
Wyświetlanie pojedynczych cyfr
Na razie (!) sytuacja jest jeszcze prosta, więc bardzo łatwo możemy napisać własną funkcję, która jako argument będzie przyjmowała cyfrę, którą następnie ustawi na wyświetlaczu. Idealna będzie tutaj instrukcja switch opisana w 6. części pierwszego kursu Arduino.
Włączanie i wyłączanie poszczególnych elementów rozpisałem na podstawie rozmieszczenia segmentów. Oczywiście każdy może wprowadzić swoje zmiany, aby dostosować "czcionkę". Wystarczy mieć przed sobą poniższą rozpiskę:
Opis segmentów wyświetlacza.
Przykładowo cyfrę "1" można również wyświetlać na segmentach F oraz E.
Licznik na wyświetlaczu 7-segmentowym
Pora sprawdzić, czy napisana funkcja wyświetla kolejne cyfry. Poniższy program testowy składa się z pętli for (działającej w zakresie 0 - 9), która wywołuje kolejne cyfry:
Poprawne działanie programu widoczne jest na poniższej animacji:
Efekt działania licznika.
Zadanie dodatkowe 6.1
Rozbuduj funkcję wyswietlacz(), tak aby potrafiła wyświetlić informację o przekroczeniu zakresu. Jeśli na wejściu podamy wartość większą od 9, to naszym oczom powinien ukazać się symbol błędu składający się z zapalonych segmentów A, G, D.
W komentarzach jako rozwiązanie umieszczajcie
kody oraz zdjęcie działającego układu!
Zadanie dodatkowe 6.2
Do układu dodaj przyciski, które pozwolą zbudować licznik:
S1 - zwiększenie cyfry pokazywanej na wyświetlaczu o 1,
S2 - zmniejszenie cyfry pokazywanej na wyświetlaczu o 1,
S3 - zerowanie układu.
W komentarzach jako rozwiązania umieszczajcie swój kod oraz film z działania układu!
Wykorzystanie drugiego wyświetlacza
Teraz zrobi się trudniej... Przynajmniej od strony połączeń. Uruchomimy teraz drugi wyświetlacz. Najwygodniej byłoby go podłączyć do kolejnych 7 pinów w Arduino, jednak wtedy nie mielibyśmy już prawie żadnych wolnych wyprowadzeń.
Co gorsze, podłączenie większej ilości wyświetlaczy (np. 3) nigdy
nie byłoby możliwe. Na szczęście można zrobić to trochę sprytniej!
Na początku połączmy ze sobą segmenty obu wyświetlaczy. Dzięki temu korzystając z 7 pinów będziemy pokazywać wartości na obu wyświetlaczach jednocześnie - na razie będzie to taka sama cyfra. Wyświetlaniem różnych wartości zajmiemy się trochę później.
Czyli dążymy teraz do takiej sytuacji:
Uruchomienie drugiego wyświetlacza.
Połączenie segmentów obu wyświetlaczy można zrobić "ładnie" korzystając z nóżek odciętych od rezystorów. Jednak wymaga to pewnego ryzykownego rozwiązania. W związku z ograniczoną ilością miejsca będziemy umieszczać po 2 druciki w jednej dziurce płytki stykowej.
Rozwiązanie to jest ryzykowne i raczej nie należy go często stosować, bo może powodować ciężkie do zdiagnozowania usterki. Jednak przy tak prostym układzie, możemy zaryzykować.
Dla przypomnienia raz jeszcze rozpiska wyprowadzeń:
Opis wyprowadzeń użytego wyświetlacza.
Zaczynamy od segmentów C, D oraz E. Musimy więc połączyć wyprowadzenia w takiej kolejności:
1 > 8
2 > 7
3 > 6
Można to zrobić następująco:
Połączenie segmentów dwóch wyświetlaczy.
Oczywiście, aby to połączenie było możliwe koniecznie trzeba odpiąć drucik, który doprowadzał masę do pierwszego wyświetlacza. Teraz masy wyprowadzimy na boki (w lewo od pierwszego, a w prawo od drugiego):
Wyprowadzenia wspólnych katod (mas) wyświetlaczy.
Kolejny krok, to połączenia pozostałych segmentów, czyli łączymy wyprowadzenia:
13 > 12
14 > 11
15 > 10
16 > 9
U mnie całość udało się złożyć w następujący sposób:
Komplet połączeń.
Prawie gotowy układ…
Oczywiście na koniec koniecznie trzeba dołożyć brakujące połączenia z masą. Na razie wystarczy proste połączenie przewodami. Na poniższym zdjęciu zawinąłem je w pętelki, aby było czytelniej:
Wyświetlanie tych samych wartości na wyświetlaczach.
Działanie wyświetlaczy jest sprawdzone, więc pora iść krok dalej. Podwójne wyświetlanie tej samej wartości raczej nam się nigdy nie przyda...
Multipleksowanie wyświetlaczy
Rozwiązaniem problemu jest multipleksowanie. Jeśli będziemy na zmianę włączać i wyłączać każdy z wyświetlaczy, to przy szybkiej zmianie wyświetlanej wartości będziemy mogli pokazywać na każdym wyświetlaczu inną cyfrę (takie będzie złudzenie dzięki bezwładności naszego wzroku)! Oczywiście nie będziemy odłączać katod od masy ręcznie. Wykorzystamy Arduino!
Przy włączeniu wszystkich segmentów cały wyświetlacz może pobrać
"z katody" ponad 20 mA, więc nie powinniśmy podłączać jej bezpośrednio do Arduino!
Sterowanie wyświetlaczami przez tranzystory
Dla bezpieczeństwa, Arduino będzie sterowało wspólnymi katodami przez tranzystory typu NPN. W zestawie elementów znajdują się tranzystory BC547, które sprawdzą się tu idealnie.
Mam nadzieję, że każdy już opanował tranzystory w praktyce.
Jeśli nie, to odsyłam do odpowiedniego odcinka kursu podstaw elektroniki!
Podłączenie będzie następujące:
Kolektory tranzystorów łączymy bezpośrednio z katodami wyświetlaczy. Czyli kolektor pierwszego tranzystora łączymy z nóżką nr 4 wyświetlacza, a kolektor drugiego BC547 łączymy z nóżką nr 5.
Bazy tranzystorów łączymy przez rezystor 10k z pinami Arduino. Bazę pierwszego tranzystora łączymy z pinem Arduino nr 10, a drugiego z pinem nr 9.
Emitery obu tranzystorów łączymy z masą.
Powyższe połączenie można zrealizować w następujący sposób:
Widok na cały układ.
Dodane tranzystory NPN.
Od teraz podanie stanu wysokiego na piny Arduino nr 9 lub 10
uruchomi jeden z wyświetlaczy.
Multipleksowanie w praktyce
Teraz pora wykorzystać dodane tranzystory w praktyce. Najpierw trzeba dodać nowe definicje:
#define WYSW_1 10
#define WYSW_2 9
Drugi krok to dodanie konfiguracji wyjść:
pinMode(WYSW_1, OUTPUT);
pinMode(WYSW_2, OUTPUT);
Teraz można już wykorzystać wyświetlacze osobno. Zacznijmy od programu, który będzie na zmianę (co sekundę) uruchamiał jeden z wyświetlaczy, pokazywał na nim jakąś wartość, a po chwili włączał drugi wyświetlacz z inną wartością. Czyli spodziewamy się takiego efektu:
Wyświetlanie różnych wartości na wyświetlaczach (animacja).
W pętli głównej programu musimy cyklicznie włączać pierwszy wyświetlacz, pokazywać na nim np. wartość 5. Następnie po sekundzie wyłączać go, włączać drugi wyświetlacz i pokazywać na nim wartość 3. Zadanie to realizuje poniższy program:
Koniecznie sprawdź, co dzieje się, gdy będziemy zmniejszać stopniowo czas pomiędzy zmianami. Warto sprawdzić np. 100 ms, 50 ms, 20 ms i 10 ms.
Miganie – 100 ms.
Miganie – 50 ms.
Przy bardzo szybkich zmianach zaczniemy "korzystać" z tego, że ludzkiego oko nie jest w stanie zauważyć tak częstych zmian. Przy ~10 ms, zamiast migania, będziemy widzieć stałą wartość 53!
O to właśnie chodziło - pamiętaj, że wyświetlacze podłączone
są praktycznie tak samo, a widzimy na nich różne wartości!
Zadanie dodatkowe 6.3
Napisz program licznika, którego wartość zmienia się od 0 do 99. Zmiana wartości może odbywać się automatycznie (co stały, ustalony czas) lub np. po wciśnięciu przycisku. Tak jak poprzednio w komentarzach oprócz kodów umieszczajcie zdjęcia/filmy pokazujące działanie układu.
Jak korzystać z takiego rozwiązania w praktyce?
Wszystkie podłączenia elektroniczne, które tutaj zrobiliśmy są dobre i na pewno można je użyć w wielu projektach. Jednak jeśli chodzi o stronę programistyczną, to takie podejście... jest słabe!
Pisząc bardziej rozbudowane programy nie możemy pozwolić sobie,
aby wstrzymywać całość za pomocą takich opóźnień!
Celem powyższych ćwiczeń było praktyczne pokazanie jak działają wyświetlacze 7-seg. i na czym polega ich multipleksowanie. W praktyce sensowne multipleksowanie wymaga użycia bardziej skomplikowanych mechanizmów, które są wbudowane w mikrokontrolery.
Arduino znane jest jednak z tego, że do wszystkich zawiłych rzeczy
możemy znaleźć gotowe biblioteki!
Gotowa biblioteka do wyświetlaczy 7-seg.
Oczywiście do "sensownego" korzystania z wyświetlaczy 7-segmentowych znajdziemy wiele bibliotek, które zrobią w tle trudniejsze rzeczy. Nie chciałem od razu zaczynać od gotowca, bo część czytelników mogłaby nie zrozumieć zasady działania takiego wyświetlacza - stąd takie ręczne rzeźbienie kodu "na około"...
Pora uruchomić nasze wyświetlacze 7-segmentowe z wykorzystaniem gotowej biblioteki, co ułatwi ich wykorzystywanie w innych projektach. W Internecie znaleźć można przynajmniej kilka takich gotowych funkcji, podczas dalszego opisu skorzystamy z SevSeg Library.
Na powyższej stronie znajduje się informacja, że aktualny kod znajdziemy na GitHubie, aby pobrać bibliotekę korzystamy z przycisku Clone or download → Download ZIP:
Pobieranie najnowszej wersji kodu z GitHuba.
Następnie rozpakowujemy archiwum i kopiujemy z jego wnętrza cały folder SevSeg-master, który następnie wklejamy do katalogu z bibliotekami Arduino, w moim przypadku było to:
C:\Users\Damian\Documents\Arduino\libraries
Po ponownym uruchomieniu Arduino IDE w menu Plik → Przykłady znajdziemy nową kategorię nazwaną SevSeg. Oznacza to, że biblioteka została zainstalowana poprawnie. Nie będziemy teraz jednak korzystać z gotowych przykładów.
Spróbujmy samodzielnie uruchomić wyświetlacze - powinny do tego wystarczyć informacje podane w dokumentacji. Na początku znajdujemy fragment przykładowej konifguracji:
byte numDigits = 4;
byte digitPins[] = {2, 3, 4, 5};
byte segmentPins[] = {6, 7, 8, 9, 10, 11, 12, 13};
bool resistorsOnSegments = false; // Use 'true' if on digit pins
byte hardwareConfig = COMMON_ANODE; // See README.md for options
sevseg.begin(hardwareConfig, numDigits, digitPins, segmentPins, resistorsOnSegments);
[...]
Oczywiście musimy go teraz dostosować do naszego sprzętu. Po pierwsze, zaczynamy od zmiany szerokości wyświetlacza (z 4 cyfr, do 2). Pierwsza linijka konfiguracji powinna więc wyglądać tak:
byte numDigits = 2;
Dalej podajemy numery pinów, do których podłączone zostały tranzystory "sterujące cyframi":
byte digitPins[] = {10, 9};
Następnie musimy dostarczyć informacje do biblioteki na temat połączenia segmentów (A-G):
byte segmentPins[] = {7, 5, 2, 4, 3, 8, 6};
W kolejnym kroku dodajemy informacje na temat sposobu podłączenia:
bool resistorsOnSegments = true; // Use 'true' if on digit pins
byte hardwareConfig = N_TRANSISTORS; // See README.md for options
Pierwsza linia informuje o tym, że każdy z segmentów zasilany jest przez własny rezystor. Jak widać biblioteka dopuszcza również wersję bez takiego zabezpieczenia, jednak zdecydowanie odradzam zabawy z taką konfiguracją - bardzo łatwo uszkodzić wtedy wyświetlacz!
W drugiej linii podajemy natomiast informację na temat sposobu sterowania cyframi. Wykorzystanie tranzystora BC547 sprawiło, że cyfrę włączamy podając stan wysoki, więc z opisu udostępnionego w dokumentacji biblioteki najlepiej pasuje wersja "N_TRANSISTORS":
N_TRANSISTORS - If you use N-type transistors to sink current
(or any other active-high, low-side switches).
Po uzupełnieniu powyższych informacji nasz szkic bazowy wygląda następująco:
Od teraz w programie możemy korzystać z obiektu sevseg. Zacznijmy od wyświetlenia liczby:
#include "SevSeg.h"
SevSeg sevseg; //Instantiate a seven segment controller object
void setup() {
byte numDigits = 2;
byte digitPins[] = {10, 9};
byte segmentPins[] = {7, 5, 2, 4, 3, 8, 6};
bool resistorsOnSegments = true; // Use 'true' if on digit pins
byte hardwareConfig = N_TRANSISTORS; // See README.md for options
sevseg.begin(hardwareConfig, numDigits, digitPins, segmentPins, resistorsOnSegments);
}
void loop() {
sevseg.setNumber(34, 2); //Wyswietl liczbę 34, korzystając z dwóch wyswietlaczy
sevseg.refreshDisplay();
}
Pierwsza linia w pętli loop() odpowiada za wyświetlenie liczby 34 korzystając z 2 wyświetlaczy. W naszym przypadku drugim argumentem funkcji zawsze będzie 2, ponieważ nie mamy możliwości włączenia "kropek" w wyświetlaczu. Gdyby taka opcja istniała, to parametrem tym moglibyśmy ustawiać sposób formatowania liczb np. wartość 3 mogłaby być pokazywana jako "03" lub "3.0".
Druga linia programu sevseg.refreshDisplay(); odpowiada za odświeżanie ekranu, czyli jego multipleksowanie, które poprzednio robiliśmy ręcznie. Biblioteka sama wylicza, na podstawie naszej konfiguracji, jak często należy przełączać wyświetlacze, aby obraz był stabilny.
Efekt działania programu, widoczny jest poniżej:
Wartość wyświetlona dzięki bibliotece SevSeg.
Omawiana biblioteka pozwala wykorzystać wyświetlacze 7-segmentowe w bardziej rozbudowany sposób. Przykładowo zdefiniowano tam również litery/symbole. Oczywiście większość z nich będzie wyświetlana słabo (lub wcale) przez ograniczoną ilość segmentów...
Jednak spokojnie da się odczytać litery typu A, b, H, C itd. Aby to zrobić należy użyć nowej funkcji sevseg.setChars();. Poniższy przykład wyświetli napis AC:
Efekt działania kodu widoczny jest na poniższym zdjęciu:
Tekst "AC" wyświetlony dzięki bibliotece SevSeg.
Wszystkie zdefiniowane znaki można podejrzeć w pliku SevSeg.cpp (który jest głównym plikiem omawianej biblioteki. Sam fragment z definicją wszystkich znaków wygląda następująco:
W ramach przykładu praktycznego warto byłoby podłączyć do Arduino czujnik, z którego informacje byłyby później pokazywane na wyświetlaczu. Idealnie sprawdzi się tutaj "coś", co można odczytać w sposób analogowy. Może być to np. fotorezystor podłączony w układzie dzielnika napięcia.
Rozwiązanie to było wykorzystywane w kursie wiele razy, więc pomijam tę część sprzętową. Każdy pewnie znajdzie coś, co chciałby tam podłączyć. Na potrzeby mojego testu wykorzystałem ostatnie wolne miejsce na płytce stykowej i umieściłem tam potencjometr.
W celu wyświetlenia aktualnej wartości na wyświetlaczu konieczne jest jej przeskalowanie. Tutaj oczywiście pomocna jest funkcja map(). Cały program widoczny jest poniżej:
#include "SevSeg.h"
SevSeg sevseg; //Instantiate a seven segment controller object
void setup() {
byte numDigits = 2;
byte digitPins[] = {10, 9};
byte segmentPins[] = {7, 5, 2, 4, 3, 8, 6};
bool resistorsOnSegments = true; // Use 'true' if on digit pins
byte hardwareConfig = N_TRANSISTORS; // See README.md for options
sevseg.begin(hardwareConfig, numDigits, digitPins, segmentPins, resistorsOnSegments);
}
void loop() {
int potencjometr = analogRead(A0); //Odczytaj informacje z fotorezystora
potencjometr = map(potencjometr, 0, 1023, 0, 99); //Przeskaluj na wyswietlacz
sevseg.setNumber(potencjometr, 2);
sevseg.refreshDisplay();
}
Po jego uruchomieniu, na wyświetlaczu 7-segmentowym, ukaże się wartość z zakresu 0-99, którą możemy płynnie zmieniać za pomocą potencjometru:
Płynna regulacja wartości.
Biblioteka nie rozwiązuje wszystkich problemów
Opisana tutaj biblioteka pomaga w łatwiejszym skonfigurowaniu i uruchomieniu wyświetlaczy tego typu. Nie rozwiązuje ona jednak wszystkich problemów. Cały czas "problemem" jest konieczność częstego multipleksowania wyświetlaczy. W tym przypadku wymusza to częste wywoływanie funkcji sevseg.refreshDisplay();
W związku z powyższym programy, które mają działać z wyświetlaczami
7-segmentowymi nie mogą korzystać z funkcji opóźniającej delay()!
Wszystkie opóźnienia należy zastąpić bardziej rozbudowanym mechanizmem opartym o funkcję millis(). Zainteresowanych odsyłam do odpowiedniej dokumentacji Arduino oraz do przykładu umieszczonego w bibliotece SevSeg, czyli: Plik → Przykłady → SevSeg → SevSeg_Counter.
Podczas tego kursu nie omawiam funkcji milis(), ponieważ tym tematem zajmę się
prawdopodobnie w osobnej serii dotyczącej "wielowątkowości w Arduino".
Podsumowanie
Ten odcinek kursu wyszedł trochę przewrotny. Powstawał kilka razy praktycznie od zera, bo za każdym razem był na niego trochę inny plan. Mam nadzieję, że ostatecznie udało się za jego pomocą wyjaśnić działanie wyświetlacza, co pozwoli lepiej wykorzystywać go później w praktyce.
W kolejnym odcinku zajmiemy się nowymi czujnikami. Tym razem poznamy w praktyce analogowe oraz cyfrowe czujniki temperatury.
Czy wpis był pomocny? Oceń go:
Średnia ocena 4.6 / 5. Głosów łącznie: 162
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ć!
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 na bazie Arduino i Raspberry Pi.
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...