Zegar cyfrowy LED z bajerami – Część I: matryca LED

Od paru miesięcy śledzę z wypiekami stronę majsterkowo.pl, ale dopiero kilka tygodni temu kupiłem swój pierwszy zestaw startowy Arduino Uno w firmie Nettigo. W kolejnym tygodniu biegałem już niemal codziennie do paczkomatu, odbierać drogocenne, słodko grzechoczące kartoniki, pełne sensorów, potencjometrów, tasiemek, rezystorów, wyświetlaczy i przeróżnego elektronicznego złomu, który teraz zalega każdy zakamarek mojego biurka i niecierpliwie czeka na swoją kolej.

Chwilę później okazało się, że moja stara lutownica pistoletowa nadaje się w zasadzie głownie do niczego i nieodzownym było doposażenie warsztatu w kilka innych niespodziewanie niezbędnych narzędzi. A wszystko tylko po to, by po ciężkim dniu pracy pośród gęstych i słodkawych oparów kalafonii oddawać się swej nowej pasji. Ale wystarczy tego barwnego wstępu, reasumując: wydaje mi się, że dojrzałem by podzielić się z Wami swymi nowo nabytymi doświadczeniami. A jak mi wyjdzie, to się jeszcze okaże. No to przejdźmy do rzeczy.

Zepsuł mi się zegar. Taki niespecjalnie ładny i niespecjalnie dokładny, więc nie było mi go jakoś szczególnie żal, ale wiadomo: bez zegara – jak bez ręki. Żona wiecznie narzeka, że potyka się o kable z tego mojego nowego hobby i wszędzie po kątach znajduje ukradkiem wypluwane kawałki izolacji, to pomyślałem sobie: hola hola, może w końcu się przyda moja pasja?

Wymyśliłem sobie początkowo zegar z dużą matrycą LED, taką przynajmniej 32×16, ale pooglądałem ceny, momentalnie posiwiałem i zdecydowałem się na wersję ULTRA-ECONO. Postanowiłem sklecić matrycę z dwóch kostek TC12-11HWA. Matryca ta posiada 5×7 diód, ale po ustawieniu dwóch matryc poziomo uzyskujemy matryce 14×5. Z szybkich szkiców na kartce w kratkę wynikło, że spokojnie wystarczy do wyświetlenia 4 cyfr w formacie 3×5:

Kiedy przyszły wyczekiwane matryce, spotkała mnie pierwsza niespodzianka. Nigdzie nie znalazłem jak oznaczony jest pin nr 1. Ani w dokumentacji producenta, ani na samej matrycy nie ma żadnego oznaczenia! Oglądałem je chyba z 10 minut z każdej strony. Absolutnie nic. Pomyślałem: ZMIERZĘ! I jak zacząłem mierzyć to okazało się, że wyprowadzenia zrobione są tak sprytnie, że obojętnie jak odwrócimy matrycę w pionie, to 1 zawsze będzie na dole po lewej. Nie wierzycie??? Sprawdźcie sami.

Oto moja po partyzancku polutowana matryca:

Trzyma się to wszystko kupy dzięki sztywnym kablom ze skrętki, które umieściłem poprzecznie (wspólna katoda).

Na zdjęciu pewnie niektórzy dociekliwi wypatrzą niechlujnie przyczajoną diodę. Na wyświetlaczu zabrakło miejsca na “mrugający sekundnik”, więc postanowiłem dorobić swój :D będzie o nim jeszcze za chwilę. Na razie zapominamy że istnieje.

Matryca 14×5 jak łatwo policzyć wymaga 14 linii do sterowania kolumnami (szyna danych), oraz 5 linii do sterowania wierszami (szyna adresowa).

Aż 19 pinów?? Zdawałoby się, że to za dużo jak na nasze małe Arduino. Nic bardziej mylnego! Zwiększymy sobie ilość wyjść używając ośmiobitowych rejestrów przesuwnych 74HC595. W tzw. “internetach” można znaleźć wiele przykładów użycia tego i innych rejestrów wraz z Arduino, więc nie będę się tutaj wielce rozwodził nad zasadą jego działania. W skrócie: działa tak, że podajemy mu bajt (8 bitów) na szynę szeregową (kolejno), a po zamknięciu zatrzasku (latch), układ wystawia nam podany bajt na wyjście równoległe – czyli osiem pinów.

Do komunikacji szeregowej z rejestrem potrzebujemy 2 piny + 1 pin(zatrzask), co pozwala nam tylko trzema pinami sterować poziomem 8 wyjść. Oczywiście dzieje się to nieco kosztem szybkości, ale to już osobna historia. Potrzebujemy 19 wyjść, więc użyjemy trzech układów 595. W zestawie startowym z Nettigo, dostałem jeden egzemplarz, który zdążyłem już nieco powyginać, więc musiałem niezwłocznie dokupić. Oczywiście od razu zrobiłem zapas licząc w duchu, że kiedyś poskładam większą matrycę :)

Nasze trzy układy 75HC595 łączymy kaskadowo. Co to oznacza? W normalnej sytuacji do sterowania trzema układami 595 potrzebowalibyśmy 3 wyjść szeregowych (6 pinów) i wspólnego zatrzasku. Cóż za niepotrzebne marnotrawstwo pinów! Z pomocą przyjdzie nam tajemnicza nóżka Q7′ układu 74HC595. Podłączamy ją do wejścia kolejnego rejestru i otrzymujemy rejestr 16 bitowy sterowany tylko jednym wejściem szeregowym!

Jak to działa?

Pierwszy bit podany na wejście układu ustawia się na wyjściu o numerze Q0. Po podaniu kolejnego bitu bit z pozycji Q0 przesuwa się na Q1, a nowy wskakuje na Q0. Kolejne bity podawane na wejściu układu wyskakują kolejno na wejście Q0, przesuwając wszystkie na wyższych pozycjach o jeden. Po podaniu 8 bitów mamy zapełnione wszystkie pozycje naszego rejestru, jeżeli jednak nie zamkniemy w tym momencie zatrzasku, tylko podamy kolejne bity to w drobnym uproszczeniu bit z pozycji Q7 “wyskoczy” nam na pozycję Q7′. Stąd możemy go “zabrać” do następnego układu na wyjście Q0. I tam znów będzie kolejno przesuwany, aż do zapełnienia wszystkich rejestrów które połączymy w kaskadę i/lub zamknięcia zatrzasku. Uff… a miałem nie opowiadać jak działa rejestr przesuwny. Wszystkich znudzonych “wyjadaczy” przepraszam.

A oto schemat:

(wykonano w programie FRITZING)

Poniżej mój gotowy układ sterownika matrycy:

Najmocniej przepraszam za brak sesji z “making of”, ale na pomysł wpisu wpadłem już po ukończeniu pierwszej (mam nadzieję) wersji projektu.

Znowu wyjadacze moga przeskoczyć do następnego akapitu, ale szybkie wyjaśnienie dla takich nowicjuszy jak ja. Matryca nie świeci cały czas jak monitory LCD. Zapalane są kolejne wiersze lub kolumny matrycy, w bardzo krótkich odstępach czasu. Bezwładność ludzkiego oka powoduje że widzimy stały obraz. Trochę jak w starych kineskopach CRT, ale tylko trochę. I podobnie będzie w naszym wypadku. Tutaj wybrałem zapalanie kolejnych wierszy.

I tu kolejna – prócz ceny – zaleta małej matrycy. W każdym cyklu zapalane jest maksymalnie 14 diód. Gdybym miał matrycę o szerokości 32, obawiam się, że prąd który mogę “wyciągnąć” z rejestru, do zasilenia wiersza mógłby nie wystarczyć do zapalenia wszystkich 32 diód. Musiałbym zastosować kluczowane tranzystorem osobne zasilanie poszczególnych wierszy (i ogólnie takie rozwiązanie byłoby zgrabniejsze, wiem). Ale w małej matrycy gdzie mamy 14 diód – nawet przy zasilaniu z Arduino poprzez USB, wyświetlacz jest całkiem czytelny, choć widać różnicę jasności pomiędzy wierszami w których jest zapalonych więcej lub mniej diód. Przy podłączeniu zewnętrznego zasilacza różnice są prawie niezauważalne. Więc nie będziemy się bawić w kluczowanie tranzystorem.

Sterowanie matrycą będzie przebiegało w następujący sposób:

W każdym cyklu do rejestrów przesyłamy 3 bajty danych, nazwijmy je sobie L P i W z których dwa (L P) ustawiają piny rejestrów podłączonych do kolumn wyświetlaczy, odpowiednio lewego i prawego, a trzeci bajt (W) ustawia wyjścia rejestru w taki sposób, że zwiera do masy (ustawia logiczne zero) odpowiedni pin dla wiersza który właśnie zapalamy (oto i znowu nasza wspólna katoda!).

Nasze trzy rejestry ośmiobitowe dają nam 24 wyjścia z 19 potrzebnych. Dla wygody samej konstrukcji płytki wykorzystałem tylko najbardziej znaczące bity rejestru, czyli dla bajtów L i P gdzie potrzebujemy tylko po 7 linii do kolumn odrzuciłem wyjście Q0, a dla rejestru adresowego (5 wierszy) odrzuciłem wyjścia Q0,Q1,Q2.

Przykładowy  cykl danych dla napisu “DATA” dla wszystkich pięciu wierszy:

Widać jak wędruje nam “zero” w rejestrze W :)

No to najwyższy czas podłączyć nasze cacko do Arduino.

Podłączamy:

• PIN 2 -> zegar
• PIN 3 -> szyna danych
• PIN 4 -> zatrzask

nie zapominając o:

• +5V -> +5V
• GND -> GND

i próbujemy załadować poniższy kod:

TADAM!!!

 I znowu kilka słów wyjaśnienia:

Może nie wszyscy wiedzą, do czego służy polecenie:

shiftOut(pin_danych,pin_zegara,kolejność_bitów,bajt).

Wysyła ono szeregowo bajt, na pinach podanych jako pierwsze dwa argumenty. Czyli dokładnie to czego potrzebujemy aby “naładować” nasze rejestry. Parametr trzeci może mieć dwie wartości: MSBFIRST lub LSBFIRST. Oznaczają one odpowiednio: najbardziej znaczący bit pierwszy lub najmniej znaczący bit pierwszy. Czyli upraszczając: czy podajemy bity kolejno od lewej czy prawej strony.

Jak już jesteśmy przy kolejności, to pewnie zauważyliście, że kolejne bajty podaję w odwrotnym szyku niż wcześniej podałem. Szynę danych podłączyłem do rejestru L (lewy wyświetlacz). Potem kaskadowo R i W. Czyli aby po podaniu trzech bajtów w rejestrze W mieć adres wiersza, musimy podać go jako pierwszy, a zawartość lewego wyświetlacza jako ostatni bajt.

I tutaj triumfalnie powraca  nasza doklejona dioda! Podłączyłem jej anodę (przez rezystor 220R) do niewykorzystanego wyjścia Q0 rejestru pierwszego (L – lewy wyświetlacz) a katodę do wiersza 4 w rejestrze trzecim (W – wiersz).

(wykonano w programie FRITZING)

Teraz zamieniając tylko jedną liczbę w naszym kodzie (202 na 203 w ostatnim wysyłanym bajcie) zapalamy sekundnik! Proste i bez wykorzystania dodatkowych pinów z Arduino.

Oczywiście wyświetlanie i odświeżanie w ten sposób zawartości wyświetlacza byłoby niezwykle uciążliwe, więc zanim zabrałem się za dalsze lutowanie, postanowiłem przygotować dedykowaną bibliotekę, która do minimum uprości sterowanie wyświetlaczem. Wykorzystamy do tego przerwania zegarowe i sprzętowy interfejs SPI Arduino.

Ale to ze względu na późną porę, będzie tematem kolejnego wpisu. Oczywiście o ile ten pierwszy spotka się z Waszą aprobatą. Na zachętę wrzucam dwa malutkie zdjęcia gotowego prototypu.

Pozdrawiam i zapraszam do komentowania.