139.png

Trochę mnie to przeraża, gdy o odtwarzaczach MP3 mówi się: retro. No, ale czas biegnie szybko ostatnio. Jednak tutaj określenie „retro” jest uzasadnione: na wyświetlaczu urządzenia widzimy animację przedstawiającą tamę magnetofonową, a samo sterowanie bardziej przypomina to z walkmanów niż empetrójek. Oczywiście oprócz ruchomego obrazka możemy dowiedzieć się szczegółów o nagraniu zawartych w TAG-u.Twórca projektu wykorzystał tutaj UNO R4 oraz układ VS1053, zajmujący się dekodowaniem strumieni skompresowanych. Możliwe jest także użycie ośmiobitowych płytek, jednak wówczas pozbędziemy się dodatku animacji. W każdym przypadku wykorzystuje się karty SD w sposób uproszczony: bez katalogów i z ograniczeniem do ośmioznakowych nazw plików.Arduino i MP3 to wdzięczny pomysł na budowę własnego odtwarzacza, wciąż jeszcze mającego sens – mimo powszechnej przesiadki na media strumieniowe. A ponieważ niedawno zajmowałem się tym tematem, wkrótce, w cyklu artykułów przedstawię własny pomysł na empetrójkę.Link do projektu: <a target="_blank" rel="noopener noreferrer nofollow" href="https://github.com/KaledSouky/VS1053_for_Arduino_AVR_and_UNO_R4">https://github.com/KaledSouky/VS1053_for_Arduino_AVR_and_UNO_R4</a>

Trochę mnie to przeraża, gdy o odtwarzaczach MP3 mówi się: retro. No, ale czas biegnie szybko ostatnio. Jednak tutaj określenie „retro” jest uzasadnione: na wyświetlaczu urządzenia widzimy animację przedstawiającą tamę magnetofonową, a samo sterowanie bardziej przypomina to z walkmanów niż empetrójek. Oczywiście oprócz ruchomego obrazka możemy dowiedzieć się szczegółów o nagraniu zawartych w TAG-u.

Retro odtwarzacz MP3

0.png

Skoro już <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/118-arduino-i-telewizor-cz-1">opanowaliśmy wyświetlanie znaków na ekranie telewizora,</a> czas na obrazki. To aż takie proste nie jest, ponieważ potrzebny jest tutaj konwerter – biblioteka nie rozumie żadnych bitmap, plików GIF i tego typu znanych nam elementów. I tutaj z pomocą przychodzi coś, o czym już kiedyś pisałem: strona konwertująca obrazy do postaci zrozumiałej przez bibliotekę. Jednak zanim zajmiemy się tworzeniem własnych grafik, przetestujmy program na gotowcu dostarczonym z biblioteką. Będzie zresztą niezbędny, by stworzyć własną wersję.<hr><pre><code class="language-arduino">#include &lt;TVout.h&gt; // Biblioteka tworząca obraz telewizyjny.\n#include "obraz.h" // Plik z obrazkiem.\nTVout telewizor; // Definicja obiektu.\n\nvoid setup() {\n telewizor.begin(PAL, 120, 96); // Szerokość i wysokość obrazu.\n telewizor.bitmap(0, 0, obraz); // Wyświetlenie obrazka.\n}\nvoid loop() {\n}</code></pre>Tym razem całość sprowadzi się do dwóch nowych elementów: dołączenia pliku obraz.h oraz wywołania rysowania bitmapy. Druga z komend dysponuje także współrzędnymi prawego górnego roku – tak więc obrazem można umieścić w dowolnym miejscu. Zmieniłem tutaj nazwy na bardziej nam przyjazne, ale to nie wszystko. W katalogu ze szkicem musimy mieć dwa takie pliki: w cpp siedzi treść samego obrazu, a w h – dane konfiguracyjne. W każdym wypadku musimy zmienić domyślną nazwę na naszą, lokalną.<pre><code class="language-arduino">// obraz. cpp\n#include "obraz.h"\nPROGMEM const unsigned char obraz[] = {\n120,96,\n0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,\n0x0F,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFF,0xFE,\n0x08,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x00,0x02,\n0x08,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x00,0x02,\n// Dalsze linie z treścią obrazu.\n};</code></pre><pre><code class="language-arduino">// obraz.h\n#include &lt;avr/pgmspace.h&gt;\n#ifndef obraz_H\n#define obraz_H\nextern const unsigned char obraz[];\n#endif</code></pre>Po skompilowaniu ujrzymy grafikę, którą widzieliśmy na początku, w wersji demonstracyjnej. Czas na coś własnego. Najpierw oczywiście musimy znaleźć dawcę: najlepiej prostego, kontrastowego, który przeżyje redukcję do jednobitowej przestrzeni 120x96 pikseli.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/1-688262257b3d9220407585.png" class="center" loading="lazy">Wybrałem nieco niezgodne z tym, co właśnie powiedziałem zdjęcie z Tatr, by zobaczyć jak się obroni w tak skromnych warunkach.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/2-688262251777f680683861.png" class="center" loading="lazy">Wchodzimy na stronę o adresie <a target="_blank" rel="noopener noreferrer nofollow" href="https://javl.github.io/image2cpp">https://javl.github.io/image2cpp</a> i kolejno: wrzucamy nasz plik, ustawiamy docelową rozdzielczość i sposób emulacji pośrednich tonów. Mamy kilka algorytmów do wyboru oraz współczynnik szarości. Dobieramy parametry do własnego widzimisię, które podziwiamy piętro niżej. Jeśli obrazek będzie zadowalający, generujemy kod.Teraz już dane z widocznej ramki musimy wkleić w plik obraz.cpp, który poprzednio zawierał obrazek demo. Możemy skompilować szkic i… cóż, nie wygląda to rewelacyjnie, ale w czasach ośmiobitowców nikt nie grymasiłby.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/3-688262251faa8296411351.png" class="center" loading="lazy">Można pokusić się w tym wypadku o zwiększenie rozdzielczości. W moim wypadku udało się dobić do 151x103 piksele i obrazek zyskał nieco. Jednak sztuka nie uda się, jeśli użyjemy trybu tekstowego, gdyż – jak wspominałem wcześniej – zasoby skończą się przy niższej rozdzielczości. Na koniec przedstawię komendy związane z rysowaniem prostych grafik.<pre><code class="language-arduino">#include &lt;TVout.h&gt; // Biblioteka tworząca obraz telewizyjny.\nTVout telewizor; // Definicja obiektu.\n\nvoid setup() {\n telewizor.begin(PAL, 120, 96); // Szerokość i wysokość obrazu.\n}\nvoid loop() {\n telewizor.clear_screen(); // Czyść ekran.\n\n telewizor.draw_circle(59, 47, 47, WHITE); // Rysuj okrąg: środek X, środek Y, promień.\n telewizor.delay(1000); // Zmodyfikowany delay dla szkiców z biblioteką TVout.\n telewizor.draw_circle(59, 47, 27, WHITE, INVERT);\n telewizor.delay(1000);\n\n telewizor.draw_rect(0, 0, 119, 94, WHITE); // Rysuj prostokąt: górny lewy, dolny prawy.\n telewizor.delay(1000);\n telewizor.draw_rect(10, 10, 99, 74, WHITE, INVERT);\n telewizor.delay(1000);\n\n telewizor.draw_line(0, 0, 119, 95, WHITE); // Rysuj linię: górny lewy, dolny prawy.\n telewizor.delay(1000);\n telewizor.draw_line(0, 95, 119, 0, WHITE);\n telewizor.delay(1000);\n telewizor.draw_line(59, 0, 59, 95, INVERT);\n telewizor.delay(1000);\n telewizor.draw_line(0, 47, 119, 47, INVERT);\n telewizor.delay(2000);\n}</code></pre>I tak: draw_circle kreśli okręgi, albo raczej elipsy, ze względu na mocne zniekształcenie. Pierwsze dwa parametry to środek koła, trzeci – promień, ostatni może przybierać wartość BLACK, WHITE albo INVERT. Pierwsze – nie muszę wyjaśniać, ostatni sprawia, że kolor jest zamieniany z tym, co było namalowane pod spodem. W ten sposób można zamiast okręgów malować koła, co zastosowałem w kolejnej linii.<img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/4-68828075647b4294967424.png" class="center" loading="lazy">draw_rect rysuje prostokąty o współrzędnych górnego lewego i dolnego prawego rogu, a line – odcinki, gdzie cztery parametry parami oznaczają początek i koniec. Należy pamiętać, że piksele liczymy od górnego lewego rogu i od zera. Stąd ostatnia kolumna jest sto dziewiętnasta. Trzeba też uważać przy kreśleniu figur i starać się pozostawiać jednopikselowy margines, inaczej fragmenty na obrzeżach będą cieńsze albo w ogóle nie będą rysowane.<img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/5-68828075dc67a505989035.png" class="center" loading="lazy">Procedury są bardzo szybkie. Proste demo praktycznie natychmiast zamalowuje ekran szumem i dopiero sztuczne zwolnienie do 50 ms na odcinek pokazuje o co chodziło.<pre><code class="language-arduino">#include &lt;TVout.h&gt; // Biblioteka tworząca obraz telewizyjny.\nTVout telewizor; // Definicja obiektu.\n\nvoid setup() {\n telewizor.begin(PAL, 120, 96); // Szerokość i wysokość obrazu.\n}\nvoid loop() {\n telewizor.draw_line(random(119), random(95), random(119), random(95), INVERT);\n // telewizor.delay(50);\n}</code></pre>Pozwala to na tworzenie emulacji 3D, jak w fabrycznym przykładzie demonstracyjnym, a trzeba wiedzieć, że mimo programowego tworzenia obrazu zużycie zasobów w tym wypadku to 16% pamięci flash i tylko 56 bajtów RAM-u. Tak więc zapasu jest dość, potrzeba tylko wyobraźni i czasu na zabawę. Zachęcam też do analizy fabrycznych przykładów, jest tam jeszcze kilka ciekawych komend.

[119] Arduino i telewizor cz. 2

Od dawna chciałem zgłębić ten temat: Arduino jako karta graficzna, a konkretnie generator obrazu telewizyjnego. Prawdę powiedziawszy, to kolejna odsłona, jak by nie było, ośmiobitowego komputerka, która mnie zaskoczyła: z pomocą tylko dwóch rezystorów powstał komputer meritumopodobny. Owszem, bardzo skromna jest ta grafika, ale do jej generacji wykorzystujemy tutaj wyłącznie to, co znajduje się w układzie ATMega328 i skromniutkie 2 kB RAM-u, a oprócz literek możemy wyświetlać także grafiki i to wcale skomplikowane, korzystające z pełnej rozdzielczości. Cały proces, mimo programowej realizacji, jest niezwykle szybki, pozostawiając moce na własne działania.<hr>Jednak dwa kilobajty to bardziej niż mało, więc rozdzielczość wynosi skromne 128x96 pikseli i nie mamy tutaj koloru. Czy to ma sens? Historycznie – pierwsze komputery tyle oferowały i marzono o nich, a kosztowały niejedną pensję – zachodnią, dodajmy. Jednak i dziś, w określonych warunkach może być to przydatne, głównie do emulacji retro obrazów. Wyświetlaczy z wejściem wizyjnym wciąż na rynku jest sporo i można sobie wyobrazić sytuacje, w których coś takiego uatrakcyjni przekaz. Nie do mnie jednak należy wymyślanie zastosowań takiej aplikacji, przedstawię ją po prostu, krok po kroku.<img style="text-align: ; text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/1-68825d9dbda07499010202.png" class="center" loading="lazy">Pierwszym będzie zdobycie dwóch rezystorów, kabelka i samego monitora. Jeden z nich będzie mieć wartość kilooma, drugi – połowę. Posłużę się <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/plytka-edukacyjna-tme">płytką edukacyjną TME,</a> więc wszystko będzie proste i przejrzyste. Mam tutaj oczywiście Arduino Uno, lecz biblioteka wspiera wiele innych ośmiobitowych mikrokontrolerów. Szczegóły można znaleźć w dokumentacji.<img style="text-align: ; text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/2-68825d9e0ead1075228135.png" class="center" loading="lazy">Kiloomowy rezystor podłączymy do pinu dziewiątego, ten o wartości 470 omów – do siódmego. Z drugiej strony oba oporniki łączymy razem i podłączamy do wejścia wideo, tak zwanego kompozytowego. Sporo monitorów posiada go jako jedyne wejście, siedzi także na jednym z pinów w eurozłączu. W przypadku monitorów komputerowych potrzebny będzie układ konwertujący, jakiego używa się, chcąc podłączyć stare komputery do HDMI czy wejść VGA. Oczywiście łączymy ze sobą także masy urządzeń.I to już wszystko, jeśli chodzi o sprzęt. Oprogramowanie będzie wykorzystywać bibliotekę – jak zwykle i tym razem napisanie jej na piechotę byłoby zadaniem skomplikowanym ze względu na wymagania sygnału zgodnego ze standardami telewizyjnymi ustalonymi ponad 70 lat temu. Bibliotekę TVout można po prostu ściągnąć z zasobów bibliotek, ale tak prosto to nie zadziała. W pakiecie znajdziemy katalog TVoutfonts, który trzeba przenieść ręcznie folder wyżej – czyli do katalogu ze wszystkimi bibliotekami. Jeśli tego nie zrobimy, otrzymamy komunikat błędu bez wyjaśnienia jego przyczyny.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/3-68827f4d6cd3b602571482.png" class="center" loading="lazy">Zacznę od dema, które dostarczył autor biblioteki, a które obrazuje możliwości graficzne. Po prostu skompilujmy je i przypatrzmy się temu, co pojawi się na wyświetlaczu. Jeśli połączenia są wykonane prawidłowo, a monitor sprawny, ujrzymy kolejno: przesuwający się obrazek, kilka napisów, kolejny obrazek, zestaw skalowanych napisów, demo rysowanych grafik: kół, prostokątów i odcinków oraz proste, acz efektowne demo 3D. To wszystko wygląda ładnie, ale użyteczne będzie dopiero, gdy nad tym zapanujemy. Czas więc rozłożyć program na czynniki pierwsze, co nie będzie takie proste z braku jakichkolwiek komentarzy czy dokumentacji. Ale od tego ja tu jestem. Zaczniemy więc od napisów.<pre><code class="language-arduino">#include &lt;TVout.h&gt; // Biblioteka tworząca obraz telewizyjny.\n#include &lt;fontALL.h&gt; // Biblioteka dołączająca zestawy czcionek.\nTVout telewizor; // Definicja obiektu.\n\nvoid setup() {\n telewizor.begin(PAL, 120, 96); // Szerokość i wysokość obrazu.\n telewizor.select_font(font6x8); // Dołącz bibliotekę czcionek.\n\n telewizor.print("ABCDEFGHIJKLMNOPQRST"); // Drukuj napis.\n telewizor.print("abcdefghijklmnopqrst");\n telewizor.print("1234567890!@#$%^&amp;amp;*()");\n telewizor.print("ABCDEFGHIJKLMNOPQRST");\n telewizor.print("abcdefghijklmnopqrst");\n telewizor.print("1234567890!@#$%^&amp;amp;*()");\n telewizor.print("ABCDEFGHIJKLMNOPQRST");\n telewizor.print("abcdefghijklmnopqrst");\n telewizor.print("1234567890!@#$%^&amp;amp;*()");\n telewizor.print("ABCDEFGHIJKLMNOPQRST");\n telewizor.print("abcdefghijklmnopqrst");\n}\nvoid loop() {\n}</code></pre>Jak zwykle, szkic będzie się zaczynał od zaciągnięcia bibliotek – sterującej monitorem i obsługującej czcionki. Ta druga będzie potrzebna tylko, gdy będziemy korzystać z możliwości umieszczania napisów. Należy także zdefiniować obiekt, czyli nazwę dla naszych nowych funkcji.Inicjacja niesie ze sobą także zdefiniowanie rozdzielczości. Tutaj niby sprawa jest oczywista: 120x96 pikseli, ale nie do końca. Te parametry gwarantują poprawną pracę układu w każdych warunkach. Potencjał jednak jest większy i wszystko zależy… trudno powiedzieć do końca od czego. Metodą prób i błędów udało mi się uzyskać dodatkowych piętnaście pikseli w poziomie i cztery w pionie. Załóżmy jednak, że nie jest to metoda uniwersalna, a taki obraz kaprysi w zależności od treści.<img style="text-align: ; text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/4-68825d9dcd0e9639423852.png" class="center" loading="lazy">Rysowanie napisów jest realizowane komendą telewizor.print() Przy rozdzielczości domyślnej, w przypadku użycia czcionki 6x8 pikseli możemy otrzymać 11 wierszy po 20 znaków w każdym, czyli 220 liter.<img style="text-align: ; text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/5-68825d9de02b7647067710.png" class="center" loading="lazy">Zwiększenie rozdzielczości do 128x98 pikseli pozwala dołożyć jedną literkę w każdej kolumnie i dodatkowy wiersz – zysk oznaczyłem literami X Obejrzyjmy sobie inne czcionki.<img style="text-align: ; text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/6-68825d9df34a8239371990.png" class="center" loading="lazy">Font 8x8 jest typowy dla ośmiobitowców, ale zarazem za duży dla tej niewielkiej rozdzielczości. Mamy go, więc możemy wykorzystać w razie potrzeby. Jak w poprzednim przypadku, wychodząc ponad standard rozdzielczości, możemy uzyskać 12 wierszy po 16 liter w każdym.<img style="text-align: ; text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/7-68825d9dd5932858622492.png" class="center" loading="lazy">Istnieje też alternatywny krój o tym wymiarze, chyba ładniejszy.<img style="text-align: ; text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/8-68825d9e249f9715857796.png" class="center" loading="lazy">W końcu ostatni dostępny font jest najmniejszym i bazuje na siatce 4x6 pikseli. Liter zmieści się dużo: 16 wierszy i trzydzieści kolumn, ale czytelność jest marna. Ten krój można wykorzystać jako uzupełniający, bo czcionki możemy mieszać. W jaki sposób? A to już zobaczymy w kolejnym szkicu.<pre><code class="language-arduino">#include &lt;TVout.h&gt; // Biblioteka tworząca obraz telewizyjny.\n#include &lt;fontALL.h&gt; // Biblioteka dołączająca zestawy czcionek.\nTVout telewizor; // Definicja obiektu.\n\nvoid setup() {\n telewizor.begin(PAL, 120, 96); // Szerokość i wysokość obrazu.\n telewizor.select_font(font4x6); // Dołącz bibliotekę czcionek.\n\n telewizor.select_font(font4x6); // Wybór aktywnego kroju.\n telewizor.println("Rozmiar maly\\n"); // ln oraz \\n dodają znak przeniesienia wiersza.\n telewizor.select_font(font6x8);\n telewizor.println("Rozmiar domyslny\\n");\n telewizor.select_font(font8x8);\n telewizor.println("Rozmiar duzy, I zestaw\\n");\n telewizor.select_font(font8x8ext);\n telewizor.println("Rozmiar duzy, II zestaw\\n");\n}\nvoid loop() {\n}</code></pre>Komenta selcect_font pozwoli wybrać aktywny krój, natomiast zarówno println jak \\n wymuszają złamanie wiersza. Wstawienie obu tych elementów jednocześnie dodaje także pusty wiersz.<img style="text-align: ; text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/9-68825d9c6048d769725259.png" class="center" loading="lazy">No dobrze, ale nie mamy tutaj polskich znaków. Jak je uzyskać? Niestety trzeba będzie pogrzebać w plikach z krojami. Nie jest to szczególnie trudne, o ile chodzi o mniejsze fonty, gdyż zakodowano je w postaci binarnej, więc wszystko widać.<img style="text-align: ; text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/10-68825d9aadf86531493218.png" class="center" loading="lazy">Wystarczy zastąpić jakieś nieużywane znaki, choć lepiej byłoby poszerzyć zestaw ponad 96 znaków. Przy okazji można byłoby poprawić krój podstawowy, bo nie wygląda najlepiej. Można też próbować importować kroje z innych projektów, jak choćby z bibliotek obsługujących <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/elektroniczny-papier">elektroniczny papier</a> czy <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/048-wyswietlacz-z-nokii-cz-1">wyświetlacze z telefonów,</a> o których kiedyś już pisałem. <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/119-arduino-i-telewizor-cz-2">W kolejnym artykule</a> zajmiemy się rysowaniem grafik.

[118] Arduino i telewizor cz. 1

116.png

Pewnie, że można! I w ten sposób Arduino upodabnia się do komputera ośmiobitowego z lat osiemdziesiątych. A nawet z siedemdziesiątych, bo skromne dwa kilobajty pozwalają tylko na 120x96 monochromatycznych pikseli. Ale w tym wypadku o zabawę chodzi przecież, choć nie do końca, bo odpalenie jakiejś grafiki na historycznym już telewizorze zaczyna robić wrażenie.Biblioteka TVout wykorzystująca ośmiobitowe Uno nie tylko pozwala wyświetlać teksty – z dowolnych krojów, także modyfikowanych przez użytkownika – ale także wspiera rysowanie grafik wektorowych: linii, prostokątów i okręgów jak również umożliwia wyświetlanie obrazów w pełnej rozdzielczości. Ta zresztą nie jest zdefiniowana sztywno i można ją nieco przekraczać, ale wszystko zależy od konkretnego projektu i telewizora, tolerującego pewne wyjścia ze standardu, który ma już ponad siedemdziesiąt lat.Najważniejsze, że zbudowanie interfejsu jest wyjątkowo proste: potrzebne są tylko dwa rezystory. Sama biblioteka jest bardzo wydajna i pozostawia dla użytkownika sporo zasobów, dzięki czemu jest możliwe kreślenie nawet dość skomplikowanych struktur trójwymiarowych. O zagadnieniu dokładniej napiszę wkrótce.

Pewnie, że można! I w ten sposób Arduino upodabnia się do komputera ośmiobitowego z lat osiemdziesiątych. A nawet z siedemdziesiątych, bo skromne dwa kilobajty pozwalają tylko na 120x96 monochromatycznych pikseli. Ale w tym wypadku o zabawę chodzi przecież, choć nie do końca, bo odpalenie jakiejś grafiki na historycznym już telewizorze zaczyna robić wrażenie.

Czy do Arduino można podłączyć telewizor?

091.png

Kto osiągnął odpowiedni wiek, dobrze pamięta romantyczne czasy ośmiobitowców, gdy nocami programował (a najczęściej grał) na takich maszynach jak Spectrum, Commodore czy Atari. Prawie wszyscy, stawiający wówczas pierwsze programistyczne kroki, poznawali BASIC-a: język poleceń interpretowanych na bieżąco. Mimo licznych wad, BASIC był prosty i łatwy do przyswojenia na poziomie użytecznym. Wadą, oprócz uczenia złych nawyków – czego ja osobiście nie widzę, bo czego człowiek się nauczy, może się zawsze oduczyć – była ślamazarność. Na tę bolączkę wymyślono kompilatory, które zamieniały BASIC w nieprzyjemną dla człowieka maszynową kupę bajtów, pracującą nawet kilkadziesiąt razy szybciej.Projekt zamienia ośmiobitowe Arduino w komputer klasy ZX81, który posiada kilobajt przestrzeni na kod użytkownika, ekran mieszczący cztery wiersze po 20 znaków, pełną klawiaturę QWERTY no i oczywiście BASIC, zajmujący prawie całą pamięć Arduino. Idea nie polega tylko na przedstawieniu programu, ale całości, toteż komputerek został umieszczony w zgrabnej, miniaturowej obudowie, która zawiera wszystko, by móc się komputerkiem pobawić. W projekcie cenna jest nie tylko dokumentacja techniczna sprzętu, ale przede wszystkim oprogramowania, które można analizować linia po linii. A ja prywatnie dodam, że ktoś mi skradł pomysł: myślałem o takim komputerku już w czasach 8051, ciągle przekładając pracę na później, bo powiedzmy sobie szczerze: poza elementem edukacyjnym użyteczność takiego współczesnego Sinclaira będzie symboliczna. Mimo to zachęcam do odwiedzenia strony projektu:<a target="_blank" rel="noopener noreferrer nofollow" href="https://community.element14.com/challenges-projects/element14-presents/project-videos/w/documents/28271/handheld-basic-computer-in-badge-format-with-the-arduino-uno----episode-612">https://community.element14.com/challenges-projects/element14-presents/project-videos/w/documents/28271/handheld-basic-computer-in-badge-format-with-the-arduino-uno----episode-612</a>

Kto osiągnął odpowiedni wiek, dobrze pamięta romantyczne czasy ośmiobitowców, gdy nocami programował (a najczęściej grał) na takich maszynach jak Spectrum, Commodore czy Atari. Prawie wszyscy, stawiający wówczas pierwsze programistyczne kroki, poznawali BASIC-a: język poleceń interpretowanych na bieżąco. Mimo licznych wad, BASIC był prosty i łatwy do przyswojenia na poziomie użytecznym. Wadą, oprócz uczenia złych nawyków – czego ja osobiście nie widzę, bo czego człowiek się nauczy, może się zawsze oduczyć – była ślamazarność. Na tę bolączkę wymyślono kompilatory, które zamieniały BASIC w nieprzyjemną dla człowieka maszynową kupę bajtów, pracującą nawet kilkadziesiąt razy szybciej.

Ciekawe projekty – Arduino komputerkiem z BASIC-iem

Zegar z pięćdziesięcioletnimi wyświetlaczami

<a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/053-tajemniczy-wyswietlacz-5082-cz-1">Skoro podłączyliśmy nasze wyświetlacze</a> dokładnie wszystko sprawdzając, czas na napisanie programu. Zaczniemy od zaimportowania biblioteki zegarowej TimeLib, która już występowała w moich projektach. Zaraz potem deklarujemy wszystkie linie łączące się z wyświetlaczami. Nie ma w tym żadnego porządku, po prostu połączyłem wszystko tak, by plątanina przewodów była jak najmniejsza. Nie ma tutaj także żadnych ograniczeń, możemy korzystać z dowolnych portów, byle nie wejść w paradę z klawiaturą, która wykorzystuje porty 4, 7 i 8. Powołam do życia także zmienną X, której zwykle używam jako notatniczka. Wiem oczywiście, że lokalne zmienne powinny być lokalnymi, ale to jest tak mały projekt, że byłaby to sztuka dla sztuki.<hr><pre><code class="language-arduino">#include &lt;TimeLib.h&gt; // To jest biblioteka obsługi zegara.\n\nconst byte input1 = 10; // Adresy portów połączonych z wejściami BCD wszystkich wyświetlaczy.\nconst byte input2 = 2;\nconst byte input4 = 11;\nconst byte input8 = 12;\n\nconst byte enable6 = A1; // Adresy portów połączonych z wejściami ENABLE poszczególnych wyświetlaczy.\nconst byte enable5 = A2;\nconst byte enable4 = A5;\nconst byte enable3 = A4;\nconst byte enable2 = 9;\nconst byte enable1 = A3;\n\nconst byte pstryczekGodzina = 4; // Adres pstryczka zmiany godzin.\nconst byte pstryczekMinuta = 8; // Adres pstryczka zmiany minut.\nconst byte pstryczekSekunda = 7; // Adres pstryczka zerowania sekund.\n\nbyte x; // Zmienna pomocnicza.\n\nvoid setup() {\n\n pinMode(input1, OUTPUT); // Deklaruj porty współpracujące z wyświetlaczami.\n pinMode(input2, OUTPUT);\n pinMode(input4, OUTPUT);\n pinMode(input8, OUTPUT);\n\n pinMode(enable1, OUTPUT);\n pinMode(enable2, OUTPUT);\n pinMode(enable3, OUTPUT);\n pinMode(enable4, OUTPUT);\n pinMode(enable5, OUTPUT);\n pinMode(enable6, OUTPUT);\n\n pinMode(pstryczekGodzina, INPUT_PULLUP); // Deklaruj porty pstryczków jako wejścia podciągnięte wewnętrznie do wysokiego stanu.\n pinMode(pstryczekMinuta, INPUT_PULLUP);\n pinMode(pstryczekSekunda, INPUT_PULLUP);\n\n setTime(23, 59, 57, 01, 01, 2000); // Ustaw przykładowy czas.\n}\nvoid loop() {\n\n wyswietl(); // Wyświetl czas.\n\n if (digitalRead(pstryczekGodzina) == HIGH) { // Jeśli wciśnięto pstryczek zmiany godzin, to...\n x = hour(); // Pobierz aktualną godzinę.\n x++; // Zwiększ jej wartość.\n if (x &amp;gt; 23) { // Jeśli przekroczono maksymalną legalną wartość, to...\n x = 0; // Zeruj jej wartość.\n }\n setTime(x, minute(now()), second(now()), 01, 01, 2000); // Ustaw nową wartość godzin.\n while (digitalRead(pstryczekGodzina) == HIGH) {} // Czekaj, aż pstryczek pozostanie puszczony.\n }\n\n if (digitalRead(pstryczekMinuta) == HIGH) { // Jeśli wciśnięto pstryczek zmiany minut, to...\n x = minute(); // Pobierz aktualną minutę.\n x++; // Zwiększ jej wartość.\n if (x &amp;gt; 59) { // Jeśli przekroczono maksymalną legalną wartość, to...\n x = 0; // Zeruj jej wartość.\n }\n setTime(hour(now()), x, second(now()), 01, 01, 2000); // Ustaw nową wartość minut.\n while (digitalRead(pstryczekMinuta) == HIGH) {} // Czekaj, aż pstryczek pozostanie puszczony.\n }\n\n if (digitalRead(pstryczekSekunda) == HIGH) { // Jeśli wciśnięto pstryczek zerowania sekund, to...\n setTime(hour(now()), minute(now()), 0, 01, 01, 2000); // Zeruj sekundy.\n }\n\n delay(100); // Tutaj jest miejsce na resztę programu (np. budzik itp.)\n}\n\nvoid wyswietl() { // Procedura wyświetlająca czas.\n\n x = second() % 10; // Młodsza cyfra sekund (reszta z dzielenia przez 10).\n wyslijBCD(); // Zaświeć segmenty według wzorców z tablicy.\n digitalWrite(enable6, LOW); // Aktywuj czytanie danych przez wyświetlacz.\n digitalWrite(enable6, HIGH); // Zatrzaśnij wysłaną wartość.\n\n x = second() / 10; // Starsza cyfra sekund.\n wyslijBCD();\n digitalWrite(enable5, LOW);\n digitalWrite(enable5, HIGH);\n\n x = minute() % 10; // Młodsza cyfra minut.\n wyslijBCD();\n digitalWrite(enable4, LOW);\n digitalWrite(enable4, HIGH);\n\n x = minute() / 10; // Starsza cyfra minut.\n wyslijBCD();\n digitalWrite(enable3, LOW);\n digitalWrite(enable3, HIGH);\n\n x = hour() % 10; // Młodsza cyfra godzin.\n wyslijBCD();\n digitalWrite(enable2, LOW);\n digitalWrite(enable2, HIGH);\n\n x = hour() / 10; // Starsza cyfra godzin.\n if (x == 0) { // Wyświetl spację, jeśli godzina &amp;lt; 10\n x = 10; // Pod adresem dziesiątym znajduje się spacja.\n }\n wyslijBCD();\n digitalWrite(enable1, LOW);\n digitalWrite(enable1, HIGH);\n}\n\nvoid wyslijBCD() { // Zaświeć segmenty według wzorców z tablicy.\n\n digitalWrite(input1, LOW); // Zeruj wszystkie wejścia BCD wyświetlaczy.\n digitalWrite(input2, LOW);\n digitalWrite(input4, LOW);\n digitalWrite(input8, LOW);\n\n switch (x) { // Wysyłamy wartość zakodowaną w BCD na poszczególne wejścia wyświetlaczy.\n case 1:\n digitalWrite(input1, HIGH);\n break;\n case 2:\n digitalWrite(input2, HIGH);\n break;\n case 3:\n digitalWrite(input1, HIGH);\n digitalWrite(input2, HIGH);\n break;\n case 4:\n digitalWrite(input4, HIGH);\n break;\n case 5:\n digitalWrite(input4, HIGH);\n digitalWrite(input1, HIGH);\n break;\n case 6:\n digitalWrite(input4, HIGH);\n digitalWrite(input2, HIGH);\n break;\n case 7:\n digitalWrite(input4, HIGH);\n digitalWrite(input2, HIGH);\n digitalWrite(input1, HIGH);\n break;\n case 8:\n digitalWrite(input8, HIGH);\n break;\n case 9:\n digitalWrite(input8, HIGH);\n digitalWrite(input1, HIGH);\n break;\n case 10:\n digitalWrite(input8, HIGH);\n digitalWrite(input4, HIGH);\n }\n}\n</code></pre>W sekcji setup, jak zwykle należy zadeklarować który port czym jest.<pre><code class="language-arduino">setTime(23, 59, 57, 01, 01, 2000); // Ustaw przykładowy czas.</code></pre>Ta linia definiuje początkowe parametry zegara. Takie, wydawałoby się dziwne ustawienie czasu początkowego pozwoli nam po resecie zobaczyć efekciarskie przewinięcie cyferek, a nie same smutne zera, jak to bywa zwykle w zegarkach po ich włączeniu.W głównej pętli mamy cztery procedury: wyświetlanie czasu, zwiększanie godzin, zwiększanie minut i zerowanie sekund. Wyświetlanie od razu prowadzi do procedury wyswietl(), więc tam się przenieśmy.Cała procedura wyświetlania czasu będzie się odbywać od tyłu, czyli najpierw sekundy, dziesiątki sekund, minuty, dziesiątki minut, godziny i dziesiątki godzin – razem sześć bliźniaczych bloków. Biblioteka TimeLib zwraca nam godziny, minuty i sekundy, ale w postaci liczb naturalnych. My jednak potrzebujemy dwucyfrową liczbę zamienić na dwie cyfry. Trzeba użyć pewnego fortelu.<pre><code class="language-arduino">x = second() % 10; // Młodsza cyfra sekund (reszta z dzielenia przez 10).</code></pre>Pojedyncze sekundy uzyskamy dzięki funkcji reszty z dzielenia, oznaczonej znakiem procentów. Jeśli weźmiemy resztę z dzielenia sekund, na przykład 37 przez 10, otrzymamy 7 – i to jest interesująca nas pozycja pojedynczych sekund.<pre><code class="language-arduino">x = second() / 10; // Starsza cyfra sekund.</code></pre>Dziesiątki sekund uzyskać już łatwiej, należy wartość sekund podzielić przez 10. A że są to liczby naturalne, reszta przepadnie, ale nie jest nam już potrzebna. Identycznie będzie z minutami i godzinami.Gdy już w X siedzi sobie sformatowana cyfra, należy ją wyświetlić na odpowiedniej pozycji. Będziemy się zatem odwoływać sześć razy do procedury przesyłania danych, sześć – bo mamy sześć cyfr. Zaczynamy od aktywacji konkretnego wyświetlacza, czyli otwarcia go na przyjmowanie danych. Zaczniemy od końca, czyli od sekund aż do dziesiątek godzin. Dane będziemy formować w procedurze wyslijBCD(), do której teraz się udamy.<pre><code class="language-arduino">void wyslijBCD() { // Zaświeć segmenty według wzorców z tablicy.\n\n digitalWrite(input1, LOW); // Zeruj wszystkie wejścia BCD wyświetlaczy.\n digitalWrite(input2, LOW);\n digitalWrite(input4, LOW);\n digitalWrite(input8, LOW);\n\n switch (x) { // Wysyłamy wartość zakodowaną w BCD na poszczególne wejścia wyświetlaczy.\n case 1:\n digitalWrite(input1, HIGH);\n break;\n case 2:\n digitalWrite(input2, HIGH);\n break;\n case 3:\n digitalWrite(input1, HIGH);\n digitalWrite(input2, HIGH);\n break;\n case 4:\n digitalWrite(input4, HIGH);\n break;\n case 5:\n digitalWrite(input4, HIGH);\n digitalWrite(input1, HIGH);\n break;\n case 6:\n digitalWrite(input4, HIGH);\n digitalWrite(input2, HIGH);\n break;\n case 7:\n digitalWrite(input4, HIGH);\n digitalWrite(input2, HIGH);\n digitalWrite(input1, HIGH);\n break;\n case 8:\n digitalWrite(input8, HIGH);\n break;\n case 9:\n digitalWrite(input8, HIGH);\n digitalWrite(input1, HIGH);\n break;\n case 10:\n digitalWrite(input8, HIGH);\n digitalWrite(input4, HIGH);\n }\n}</code></pre>Jak już pokazywałem nieraz, wzorce możemy przechowywać w tablicach albo ładować bezpośrednio i to na wiele sposobów. Metoda z tablicami jest elegancka, ale niekoniecznie uzasadniona w każdym wypadku. Tutaj zaprezentuję metodę kombinowaną, czyli bezpośrednią, ale z dodaniem pewnego wstępnego warunku.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/1-6654e33f756f3207077044.png" class="center" loading="lazy">Spójrzmy na tablicę prawdy wyświetlacza, bo tak się to nazywa. Występuje tam 25 stanów niskich i 15 wysokich. Z tego wniosek, że bardziej będzie się opłacało ustawiać tylko stany wysokie tam, gdzie jest taka potrzeba, resetując na wstępnie wszystkie stany do poziomu niskiego. Policzmy sobie oszczędności: 15 instrukcji zamiast 40 – to jest zysk konkretny. Ale jeszcze trzeba na wstępie wyzerować wszystkie stany, więc musimy napisać 19 instrukcji – nadal zysk przekracza połowę.Co tracimy? Czas. Oprócz wysłania czterech zer w każdym przypadku z wyjątkiem liczby zero dochodzi nam jedna, dwie bądź trzy instrukcje nadmiarowe, czyli odkręcanie tego, co na wstępie wyzerowaliśmy. Czy to ma sens? Zależy. Czasem potrzeba czasu, czasem bajtów. Moim celem nie jest tutaj wybór słusznej metody, tylko ukazanie, że mamy dwie.<pre><code class="language-arduino">if (x == 0) { // Wyświetl spację, jeśli godzina &amp;lt; 10\n x = 10; // Pod adresem dziesiątym znajduje się spacja.\n}</code></pre>Na końcu serii wysyłek danych na wyświetlacz znajdziemy jeszcze fragment aktywujący dziesiąty stan. Co to takiego? Spacja. To jest kod wygaszonego wyświetlacza, a potrzebny on jest nam wtedy, gdy liczba godzin będzie niższa od dziesięciu. Zegar bez zera na początku wygląda po prostu lepiej.Po wysłaniu danych wracamy do głównej pętli. Będziemy tam sprawdzać, czy aby nie przyciśnięto któregoś z przycisków: pstryczekGodzina zwiększa stan godzin, pstryczekMinuta – minut, a pstryczekSekunda zeruje sekundy.<pre><code class="language-arduino">if (digitalRead(pstryczekGodzina) == HIGH) { // Jeśli wciśnięto pstryczek zmiany godzin, to...\n x = hour(); // Pobierz aktualną godzinę.\n x++; // Zwiększ jej wartość.\n if (x &amp;gt; 23) { // Jeśli przekroczono maksymalną legalną wartość, to...\n x = 0; // Zeruj jej wartość.\n }\n setTime(x, minute(now()), second(now()), 01, 01, 2000); // Ustaw nową wartość godzin.\n while (digitalRead(pstryczekGodzina) == HIGH) {} // Czekaj, aż pstryczek pozostanie puszczony.\n}</code></pre>W przypadku godzin i minut procedury są bliźniacze. Jeśli wciśnięto przycisk, do aktualnej godziny dodaje się kolejną i sprawdza, czy aby wynik nie przekracza 23. Jeśli tak – godziny są zerowane. Następnie zmienna zostaje wprowadzona do biblioteki zegarowej. A ponieważ należy tutaj także określić dzień, miesiąc i rok, a te rzeczy nie biorą udziału w naszej zabawie, możemy wprowadzić cokolwiek.Procedura regulacji minut różni się tylko warunkiem – zamiast 23, sprawdzamy czy nie przekroczono 59. Natomiast wciśnięcie przycisku zerującego sekundy natychmiastowo zeruje ten parametr biblioteki i nie robi nic nadto.Na końcu wprowadziłem funkcję delay, ale z komentarzem. To nie jest tak, że nie mam pomysłu na to, co tu wstawić i wrzucam tę nielubioną instrukcję. Po prostu nie ma sensu odświeżać wyświetlacza z pełną mocą Arduino, jeśli cyfry zmieniają się i tak raz na sekundę. Oszczędza to energię, redukuje zakłócenia elektromagnetyczne i nijak nie wpływa na efekty końcowe. Miejsce to powinno się wypełnić dodatkowymi funkcjami zegara: budzikiem, termometrem i tak dalej. Ale to już pozostawiam zainteresowanym.I to już wszystko. Cyferki wyglądają ślicznie, choć zegarek zjadający od trzech do pięciu watów, w zależności od godziny, to dziś rozpusta. Pragnę jeszcze zwrócić uwagę na jedno: oba środowiska dzieli pół wieku, a jednak bez problemów współpracują ze sobą. Bo współczesna elektronika, z pewnymi uproszczeniami, ma już ponad 50 lat.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/2-6654e33fcbbde785301401.png" class="center" loading="lazy">

[054] Tajemniczy wyświetlacz 5082 cz. 2

Skąd w ogóle pomysł, by do pracy zaprząc dziś wyświetlacze mające 50 lat? Otóż zrobiła się moda na wszystko co stare, a właściwie pochodzące w ery narodzin tego, co dziś otacza nas dookoła. Nie inaczej było z wyświetlaczami. I nie rzecz w tym, że te pierwsze były po prostu pierwsze. Istotą tamtych czasów był brak standardów. Wielu producentów opracowywało własne pomysły na urządzenie pokazujące ludziom takie czy inne wyniki. Oczywiście ludzie posługiwali się cyframi dużo wcześniej, więc naturalną rzeczą było ukazywanie cyfr w kształtach już znanych.<hr><img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/1-6654e19f85092498474327.png" class="center" loading="lazy">I w tym tkwi właśnie magia wyświetlaczy czasów pierwotnych: bardzo często usiłowano przedstawiać wzory podobne do pisma czy druku. Gdy spojrzymy na wyświetlacz siedmiosegmentowy, który obecnie stanowi absolutny standard, dopatrzymy się sporych jednak różnic między tym, co wskazuje, a znanymi nam od dawna cyframi. Nauczyliśmy się nowych, uproszczonych kształtów i obecnie nikt z tym nie ma problemu, jednak na początku było to obce.Widoczne tu wyświetlacze otrzymałem w prezencie i należą do oryginalnych ze względu na krój cyferek. W zasadzie siatka stanowi wzór siedmiosegmentowego standardu, ale tworzy go dwadzieścia niezależnych świecących punktów, nie licząc punktu dziesiętnego. Dało to większą swobodę projektantowi i ten z niej skorzystał: cyfry wyglądają niepowtarzalnie.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/3-6654e1a2aa519695891667.png" class="center" loading="lazy">Wyświetlacze te najprawdopodobniej opracował Hewlett Packard w 1972 roku. Zatem pochodzą właściwie z początku czasów powszechnego użycia diod świecących w wyświetlaczach. Z jakiego okresu pochodzą te konkretne? Nie umiem tego określić. Data zakodowana jest tutaj liczbą 706, co albo było niezgodne ze standardem czterocyfrowym, oznaczającym rok i tydzień, albo jest to wyjątkowo wczesna wersja, jeszcze z roku 70, a dostępna dokumentacja nie jest pierwszym opracowaniem. Pozostawmy tę zagadkę nierozwiązaną.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/4-6654e1a2dc965248946336.png" class="center" loading="lazy">Istotą niniejszego opracowania będą dwa zagadnienia: próba ożywienia takich elementów za pomocą Arduino oraz umiejętność czytania dokumentacji i opracowywania ścieżki działań w wymienionym celu.Mamy zatem same wyświetlacze, opisane zarówno na obudowie jak i w opakowaniu. W prezencie otrzymałem trzy odmiany owych świecidełek i jak się okazuje, należą do jednej rodziny, z której zestawia się konkretne konfiguracje, zgodnie z potrzebami.Zatem pierwsza paczka zawiera wskaźniki wyświetlające cyfry i znak minusa oraz kropkę z prawej strony, druga – to odmiana z kropką z lewej strony, zaś trzecia zawiera tylko jedynkę oraz znak minusa i plusa. Istnieje jeszcze jedna rodzina, która może wyświetlać dodatkowo litery od A do F.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/5-6654e1a235427146928313.png" class="center" loading="lazy">Wyświetlacze mają osiem nóżek, zatem na wstępie można się domyślić, że musimy mieć wewnątrz elektronikę albo diody ułożone są w multiplex. Nawet bez dokumentacji widać, że pod cyferką siedzi struktura układu scalonego, więc wyświetlacz zawiera jakąś inteligencję i należy się do niego dobrać przez magistralę.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/6-6654e1a2372d3048001247.png" class="center" loading="lazy">Zanim jednak weźmiemy się za to, rzućmy okiem: całość sieci w czerwonym, przejrzystym tworzywie, stanowiącym filtr barwny. Dodatkowo chroni on delikatniejszą warstwę hermetyzującego silikonu, znajdującego się pod spodem, który izoluje strukturę od warunków otoczenia. Parametry pracy i wykonanie kwalifikują wyświetlacz do zadań profesjonalnych, w tym wojskowych. Znosi on temperaturę pracy od -20 do 85 stopni, a przechowywania – w jeszcze szerszych granicach. Ze względu na wiek nie jest to urządzenie oszczędne, jedna cyfra konsumuje od połowy do jednego wata. Z tego powodu podczas pracy temperatura wyświetlaczy osiągnęła aż 45 stopni, ale tak ma być.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/7-6654e1a040dde585928758.png" class="center" loading="lazy">Przejdźmy do dokumentacji. Po pierwsze – mamy tutaj standard TTL, czyli pracujemy w logice pięciowoltowej, w jakiej pracuje Arduino Uno. Zatem będziemy mogli się podłączać bezpośrednio.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/8-6654e19fb16f3363538370.png" class="center" loading="lazy">Po drugie, widzimy, że wyświetlacz przygotowany jest do pracy na magistrali równoległej, co było charakterystyczne dla peryferiów epoki ośmiobitowej. Elektronika obecna wewnątrz przetwarza kod znaku na konkretne kształty, na które nie mamy wpływu. Znaki są kodowane w systemie BCD, czyli naturalnie, na czterech bitach według wagi. Zero to same zera, dziewiątka wymaga, by pierwszy i czwarty bit był ustawiony i tak dalej. Mamy jeszcze możliwość wyświetlania spacji, minusa i wszystkich diod naraz, już poza standardem BCD, ale wykorzystuje się tutaj nieużywane słowa czterobitowe.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/9-6654e19f4e69c585465996.png" class="center" loading="lazy">W końcu dane mogą być zapamiętywane, jak na pełnokrwiste peryferium przystało. Przypominam, że te wyświetlacze powstały w chwili, gdy narodził się pradziadek wszystkich mikroprocesorów, jeszcze czterobitowy Intel 4004 i były stworzone do współpracy z tą architekturą. Za zapamiętywanie podanej wartości odpowiedzialne jest wejście enable, a konkretnie zmiana poziomu z niskiego na wysoki.Podsumujmy: cztery wejścia wyświetlanej cyfry na czterech bitach, piąte – wejście enable, szóste i siódme to zasilanie. Ostatnie wejście zupełnie niezależnie wyświetla kropkę dziesiętną, gdy podać tam stan niski. Jeśli nam ta kropka nie będzie potrzebna, możemy to wejście zignorować.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/10-6654e1a30124e019708843.png" class="center" loading="lazy">Czas podłączyć całość. Nie miałbym serca lutować tych wyświetlaczy tak na chwilę tylko, więc skorzystam z płytki testowej. Musiałem naciąć drucików łączących wspólne wyprowadzenia i złożyć dwie standardowe płytki, ponieważ mamy tutaj sześć szyn wspólnych, a typowa płytka ma takowe tylko cztery. Przypomnę, łączymy razem masy, zasilania i wejścia BCD, wszystko równolegle. Do tego każde z wejść enable poszczególnych wyświetlaczy, więc także sześć linii, bo zdecydowałem się na zegar z sekundnikiem. Dwanaście przewodów przeprowadziłem do Arduino siedzącego w płytce edukacyjnej TME, w której tkwią także mikrostyki, które wykorzystam w projekcie.Wyświetlacze postanowiłem zaprezentować w formie zegara, w którym wszystkie cyfry będą się świecić statyczne, bez charakterystycznego dla multipleksu migotania. Oczywiście zegar jest tylko przykładem, choć użytecznym. Przypomnę, że podmiotem artykułu jest sposób rozmawiania Arduino z wyświetlaczami.Pragnę jeszcze zwrócić uwagę na dwie rzeczy: płytki stykowe mają w połowie szyn długich przerwę, więc trzeba je zmostkować. Druga rzecz to kondensatory blokujące zasilanie. Dobrym zwyczajem w świecie cyfrowym jest blokowanie linii zasilających przy każdym układzie scalonym kondensatorem o pojemności około 100 nF, a do tego co jakiś czas niewielkim elektrolitem. Ponieważ te wyświetlacze możemy traktować jak układy scalone, wsunąłem między zasilanie, a masę, dwa kondensatory, w tym jeden elektrolit. Uprościłem nieco zasadę, gdyż powinno się użyć po jednym kondensatorze na wyświetlacz, jak najbliżej jego nóżek, ale to tylko układ testowy. Tak naprawdę bez tych elementów także wszystko działa poprawnie, lecz nie wypada tak robić.Skoro wszystko zostało już podłączone i sprawdzone – trzykrotnie, bo pomyłka może być bolesna – czas uruchomić nasz retro zegar. Ale o tym napiszę <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/054-tajemniczy-wyswietlacz-5082-cz-2">w kolejnym artykule.</a>

[053] Tajemniczy wyświetlacz 5082 cz. 1

051 Retro wyswietlacz 5082 0.png

Kolejny element w kąciku retro jest bardzo egzotyczny. To wyświetlacz w zasadzie numeryczny o symbolu 5802, opracowany prze firmę Hewlett Packard w roku 1972. Z racji choćby tej daty warty jest omówienia.Wyświetlacz składa się z 20 diod świecących ułożonych klasycznie, a więc w mozaikę zgodną z wyświetlaczami siedmiosegmentowymi. Jednak kształty cyfr, które zostały tu zapisane w pamięci stałej, są dalekie od tego, co znamy i bliższe temu, co rysujemy, używając długopisu. Tak wyświetlane cyfry wyglądają niezwykle efektownie.Wrażenie wzmaga barwa diod, charakterystycznie rubinowa, którą pod koniec dekady zastąpiła czerwień bardziej zwyczajna, ale już nie tak inspirująca. Wyświetlacz jest elementem aktywnym, zaopatrzonym w pamięć znaków, zatrzask i czterobitową magistralę, na którą wystawiamy adresy znaków w kodzie BCD. W rodzinie były wyświetlacze serwujące same cyfry, cyfry wraz z literami od A do F oraz jedynkę i znak plusa i minusa. Tak więc używanie tych wyświetlaczy z Arduino jest bardzo proste i <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/053-tajemniczy-wyswietlacz-5082-cz-1">w tym artykule opisałem przykładową aplikację.</a><img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/051-retro-wyswietlacz-5082-1-6659eff3468ca663561237.png" class="center" loading="lazy">Trzeba pamiętać, że jedna cyfra pobiera nawet pół wata, zatem zegar złożony z wyświetlaczy będzie ładny, acz nieoszczędny. Biorąc również pod uwagę utrudnioną dostępność jak i cenę rynkową takich kostek, z pewnością nie będą one używane do celów użytecznych, a czysto estetycznych – choćby do stworzenia swoistej „elektronicznej biżuterii”.

Kolejny element w kąciku retro jest bardzo egzotyczny. To wyświetlacz w zasadzie numeryczny o symbolu 5802, opracowany prze firmę Hewlett Packard w roku 1972. Z racji choćby tej daty warty jest omówienia.

Kącik retro - wyświetlacz 5082

050 Retro wyswietlacz CQYP95 0.png

Od czasu do czasu będę starał się wrzucać informację o elementach pozornie zupełnie nie pasujących do tematyki portalu, gdyż ich kariera miała miejsce kilkadziesiąt lat temu. Jednakże nastała obecnie moda na retro i wyciągane z głębokich zapasów elementy, jeśli są interesujące, robią wtórną karierę, przywołując zdziwienie i nostalgię.Zaczniemy od czegoś z rodzimego rynku, choć jak w większości przypadków polskiej elektroniki w czasach peerelowskich, jest to kopia wyświetlacza NSA1198 National Semiconductor. W naszym wykonaniu nosił symbol CQYP95 i był zespołem dziewięciu wyświetlaczy siedmiosegmentowych połączonych w multipleks.Był dość popularny, znajdując sobie miejsce głównie w kalkulatorach serii Brda. Charakteryzował się głęboką czerwienią malutkich cyferek, powiększanych do rozmiaru ułatwiającego obserwację za pomocą zespolonej z wyświetlaczem soczewki.<img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/050-retro-wyswietlacz-cqyp95-1-6659eff2c67b2264966473.png" class="center" loading="lazy">Używając wyświetlacza we współczesnych projektach należy uważać na maksymalny dopuszczalny prąd segmentów, nieprzekraczający 3 mA. Nie liczmy też na jakieś wyjątkowo duże poziomy jasności. Wraz z marnym wymiarem cyferek element nie nadaje się do zastosowań czysto użytkowych, ale raczej hobbystycznych. Na pewno robi wrażenie, a biorąc pod uwagę to, że jest już skrosowany wewnątrz, jego podłączenie do Arduino jest bardzo proste: wystarczy osiem rezystorów i to wszystko. Projekt wykorzystujący ten wyświetlacz pojawi się wkrótce.

Od czasu do czasu będę starał się wrzucać informację o elementach pozornie zupełnie nie pasujących do tematyki portalu, gdyż ich kariera miała miejsce kilkadziesiąt lat temu. Jednakże nastała obecnie moda na retro i wyciągane z głębokich zapasów elementy, jeśli są interesujące, robią wtórną karierę, przywołując zdziwienie i nostalgię.

Kącik retro - wyświetlacz CQYP95

<a href="https://www.tme.eu/pl/details/tme-edu-ard-2/rozwiazania-kompatybilne-z-arduino/transfer-multisort-elektronik/">Sprawdź Tutaj</a>

Retro

Przeglądaj wg kategorii

Nasi partnerzy