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:

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.

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.

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:

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...

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ń:

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.

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:

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:

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):

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.

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.

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:

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.

Nasza funkcja może wyglądać następująco:

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ę:

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:

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.

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ń.

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:

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.

Dla przypomnienia raz jeszcze rozpiska wyprowadzeń:

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:

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):

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:

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:

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!

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.

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 BC546 łą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:

Multipleksowanie w praktyce

Teraz pora wykorzystać dodane tranzystory w praktyce. Najpierw trzeba dodać nowe definicje:

Drugi krok to dodanie konfiguracji wyjść:

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:

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.

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!

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! 

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.

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:

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:

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:

Dalej podajemy numery pinów, do których podłączone zostały tranzystory "sterujące cyframi":

Następnie musimy dostarczyć informacje do biblioteki na temat połączenia segmentów (A-G):

W kolejnym kroku dodajemy informacje na temat sposobu podłączenia:

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:

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:

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:

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:

Ostatni przykład z wyświetlaczem 7-seg.

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.

Podłączenie było następujące:

• skrajne lewe wyprowadzenie do 5V,
• środkowe wyprowadzenie do A0,
• skrajne prawe wyprowadzenie do masy.

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:

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:

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();

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.

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.

Autor kursu: Damian (Treker) Szymański

7-seg, arduino, kurs, kursArduino2, segmentowy, UNO, wyświetlacz