00.png

Na płytce Arduino Q znajdziemy 104 diody świecące, ułożone w matrycę 13x8. Rzecz taka pojawiła się już w Uno R4, a tutaj przybyła dodatkowa kolumna. Do czego można użyć takiego wyświetlacza? Do wielu rzeczy. Zacznijmy od prezentacji liczb. Układ dla takich zastosowań nie jest najszczęśliwszy, minimalna matryca dla cyfry do 4x5 diod, czyli mając ich 104, można byłoby przedstawić cztery znaki. W naszym przypadku wstawimy trzy na matrycy 4x6, nieco czytelniejszej i zostanie jeszcze miejsce na przecinek lub apostrof. Albo na diody stanu. Przypomnę, że jedna kolumna w matrycy musi się zmarnować na odstęp.<hr><img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/11-69ef80a18bf87420559918.png" class="center" loading="lazy">Jak się to realizuje programowo? Trochę naokoło.<pre><code class="language-arduino">#include &lt;Arduino_LED_Matrix.h&gt; &nbsp;// Biblioteka rysująca tablice na wyświetlaczu.\nArduino_LED_Matrix display; &nbsp; &nbsp; &nbsp;// Deklaruj nazwę tablicy.\nbyte picture[104] = { &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Tablica zapalonych diod.\n&nbsp; 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1,\n&nbsp; 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1,\n&nbsp; 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0,\n&nbsp; 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0,\n&nbsp; 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0,\n&nbsp; 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0,\n&nbsp; 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,\n&nbsp; 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0\n};\nvoid setup() {\n&nbsp; display.begin(); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Inicjuj tablicę.\n&nbsp; display.setGrayscaleBits(1); &nbsp;// Ustaw dwustanową jasność.\n&nbsp; display.draw(picture); &nbsp; &nbsp; &nbsp; &nbsp;// Przenieś zawartość tablicy na wyświetlacz.\n}\nvoid loop() {}</code></pre>Zacznijmy od zaprojektowania całej grafiki, tj. ustawienia wszystkich diod. W tym celu należy sięgnąć do biblioteki Arduino_LED_Matrix.h, która skraca działania, ograniczając naszą potrzebę wywoływania adresu każdej diody. Są one podłączone do kolejnej grupy pinów kontrolera, nie będącej dostępną na wyprowadzeniach płytki.Następnie trzeba zdefiniować nazwę obiektu display, czyli naszego wyświetlacza i zbudować tablicę picture, w której jedynki to zapalone diody, a zera – zgaszone. Można to zrobić ręcznie, nie jest to trudne, bo wszystko widać wprost. Można też skorzystać z edytorów, między innymi oficjalnego, który wygeneruje tablicę po wyklikaniu obrazka.Następnie inicjujemy procedurę, ustawiamy tryb graficzny – bo mamy dwa, ale o tym zaraz i wywołujemy przepisanie tablicy na wyświetlacz. A jak wyświetlić albo zgasić konkretny piksel? No właśnie, naokoło.<pre><code class="language-arduino">#include &lt;Arduino_LED_Matrix.h&gt; &nbsp;// Biblioteka rysująca tablice na wyświetlaczu.\nArduino_LED_Matrix display; &nbsp; &nbsp; &nbsp;// Deklaruj nazwę tablicy.\nbyte picture[104] = { &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Tablica zapalonych diod.\n&nbsp; 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n&nbsp; 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n&nbsp; 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n&nbsp; 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n&nbsp; 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n&nbsp; 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n&nbsp; 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n&nbsp; 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n};\nvoid setup() {\n&nbsp; display.begin(); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Inicjuj tablicę.\n&nbsp; display.setGrayscaleBits(1); &nbsp;// Ustaw dwustanową jasność.\n&nbsp; bitSet(picture[14], 0); &nbsp; &nbsp; &nbsp; // Zaświeć piksel o adresie 14.\n&nbsp; bitSet(picture[89], 0); &nbsp; &nbsp; &nbsp; // Zaświeć piksel o adresie 89.\n&nbsp; display.draw(picture); &nbsp; &nbsp; &nbsp; &nbsp;// Przenieś zawartość tablicy na wyświetlacz.\n}\nvoid loop() {}</code></pre>W tym celu musimy tak samo jak poprzednio, powołać do życia tablicę picture, ale z wyłączonymi wszystkimi diodami. By włączyć konkretną diodę, trzeba będzie odwołać się do jej adresu za pomocą linii bitSet(picture[numer diody], 0). Diody liczymy od zerowej, po kolei i kończymy na sto trzeciej. Powyższy szkic da nam taki efekt:<img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/12-69ef80a20d037163112407.png" class="center" loading="lazy">Jeśli byśmy chcieli diodę zgasić, należy użyć funkcji bitClear. Tak na marginesie, na oficjalnej ściądze jest błąd: diody liczy się od jedynki, a nie od zera.<img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/13-69ef80a31ba55920866374.png" class="center" loading="lazy">Wykorzystanie tego sposobu pozwala stworzyć matrycę kontrolek. Jeśli zdecydujemy się na kwadraty o wymiarach 3x3 piksele, dostaniemy ich sześć. Ten szkic aktywuje miganie kontrolki pierwszej i piątej.<pre><code class="language-arduino">#include &lt;Arduino_LED_Matrix.h&gt; &nbsp;// Biblioteka rysująca tablice na wyświetlaczu.\nArduino_LED_Matrix display; &nbsp; &nbsp; &nbsp;// Deklaruj nazwę tablicy.\nbyte picture[104] = { &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Tablica zapalonych diod.\n&nbsp; 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0,\n&nbsp; 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,\n&nbsp; 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0,\n&nbsp; 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n&nbsp; 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0,\n&nbsp; 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,\n&nbsp; 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0,\n&nbsp; 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n};\nvoid setup() {\n&nbsp; display.begin(); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Inicjuj tablicę.\n&nbsp; display.setGrayscaleBits(1); &nbsp;// Ustaw dwustanową jasność.\n}\nvoid loop() {\n&nbsp; bitSet(picture[15], 0); &nbsp;// Zaświeć piksel o adresie 15\n&nbsp; bitSet(picture[71], 0); &nbsp;// Zaświeć piksel o adresie 71.\n&nbsp; display.draw(picture); &nbsp; // Przenieś zawartość tablicy na wyświetlacz.\n&nbsp; delay(250);\n&nbsp; bitClear(picture[15], 0); &nbsp;// Zaświeć piksel o adresie 15.\n&nbsp; bitClear(picture[71], 0); &nbsp;// Zaświeć piksel o adresie 71.\n&nbsp; display.draw(picture); &nbsp; &nbsp; // Przenieś zawartość tablicy na wyświetlacz.\n&nbsp; delay(250);\n}</code></pre>Mniej czytelna podstawa 2x2 da nam 12 kontrolek i w tym wypadku aktywna jest pierwsza, szósta i dwunasta. Kolejne inwencje pozostawiam czytelnikom.<img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/14-69ef80a34d4f9019055996.png" class="center" loading="lazy">Na koniec przedstawię jeszcze jedną możliwość wyświetlacza: zmianę jasności świecenia diod. Tutaj właśnie wrócę do tajemniczego setGrayscaleBits – parametru, który może przyjmować kilka różnych wartości, z czego sensowne są dwie: jedynka i trójka. Stanowią one o głębokości bitowej jasności. Jedynka oznaczała diodę włączoną lub wyłączoną, trójka umożliwia użycie siedmiu stopni jasności. Jasność tę koduje się w tablicy, osadzając teraz liczby od zera do siedmiu.<pre><code class="language-arduino">#include &lt;Arduino_LED_Matrix.h&gt; &nbsp;// Biblioteka rysująca tablice na wyświetlaczu.\nArduino_LED_Matrix display; &nbsp; &nbsp; &nbsp;// Deklaruj nazwę tablicy.\nbyte picture[104] = { &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Tablica zapalonych diod.\n&nbsp; 0, 0, 0, 0, 1, 2, 3, 2, 1, 0, 0, 0, 0,\n&nbsp; 0, 0, 0, 1, 2, 3, 4, 3, 2, 1, 0, 0, 0,\n&nbsp; 0, 0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 0, 0,\n&nbsp; 0, 1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1, 0,\n&nbsp; 0, 1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1, 0,\n&nbsp; 0, 0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 0, 0,\n&nbsp; 0, 0, 0, 1, 2, 3, 4, 3, 2, 1, 0, 0, 0,\n&nbsp; 0, 0, 0, 0, 1, 2, 3, 2, 1, 0, 0, 0, 0\n};\nvoid setup() {\n&nbsp; display.begin(); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Inicjuj tablicę.\n&nbsp; display.setGrayscaleBits(3); &nbsp;// Ustaw trzybitową jasność.\n&nbsp; display.draw(picture); &nbsp; &nbsp; &nbsp; &nbsp;// Przenieś zawartość tablicy na wyświetlacz.\n}\nvoid loop() {}</code></pre>Zakodowałem w ten sposób taką grafikę. Żeby utrzymać symetrię, musiałem zrezygnować z najjaśniejszej wartości. Wygląda to bardzo fajnie.<img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/15-69ef80a37febf498761260.png" class="center" loading="lazy">Sterowanie pojedynczymi pikselami także jest możliwe, ale mamy tu kolejny błąd i jasność tych pikseli może być ustawiana tylko w trzech krokach – od zera do dwójki.<pre><code class="language-arduino">#include &lt;Arduino_LED_Matrix.h&gt; &nbsp;// Biblioteka rysująca tablice na wyświetlaczu.\nArduino_LED_Matrix display; &nbsp; &nbsp; &nbsp;// Deklaruj nazwę tablicy.\nbyte picture[104] = { &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Tablica zapalonych diod.\n&nbsp; 0, 0, 0, 0, 1, 2, 3, 2, 1, 0, 0, 0, 0,\n&nbsp; 0, 0, 0, 1, 2, 3, 4, 3, 2, 1, 0, 0, 0,\n&nbsp; 0, 0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 0, 0,\n&nbsp; 0, 1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1, 0,\n&nbsp; 0, 1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1, 0,\n&nbsp; 0, 0, 1, 2, 3, 4, 5, 4, 3, 2, 1, 0, 0,\n&nbsp; 0, 0, 0, 1, 2, 3, 4, 3, 2, 1, 0, 0, 0,\n&nbsp; 0, 0, 0, 0, 1, 2, 3, 2, 1, 0, 0, 0, 0\n};\nvoid setup() {\n&nbsp; display.begin(); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Inicjuj tablicę.\n&nbsp; display.setGrayscaleBits(3); &nbsp;// Ustaw trzybitową jasność.\n&nbsp; bitSet(picture[0], 0); &nbsp; &nbsp; &nbsp; &nbsp;// Zapal piksele w rogach, ze zmieniającą się jasnością.\n&nbsp; bitSet(picture[12], 1);\n&nbsp; bitSet(picture[91], 2);\n&nbsp; display.draw(picture); &nbsp;// Przenieś zawartość tablicy na wyświetlacz.\n}\nvoid loop() {}</code></pre>Należy pamiętać, że zgaszenie tych pikseli będzie możliwe tylko wtedy, jeśli zadeklarujemy im tę samą jasność, w przeciwnym razie czynność będzie zignorowana.<img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/16-69ef80a27a769225188261.png" class="center" loading="lazy">Mimo tego postanowiłem zakończyć dzisiejszą opowieść napisaniem miłego wygaszacza, który korzysta z możliwości indywidualnego zapalania pikseli ze zróżnicowanym poziomem.<pre><code class="language-arduino">#include &lt;Arduino_LED_Matrix.h&gt; &nbsp;// Biblioteka rysująca tablice na wyświetlaczu.\nArduino_LED_Matrix display; &nbsp; &nbsp; &nbsp;// Deklaruj nazwę tablicy.\nbyte picture[104] = { &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Tablica zapalonych diod.\n&nbsp; 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n&nbsp; 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n&nbsp; 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n&nbsp; 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n&nbsp; 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n&nbsp; 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n&nbsp; 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n&nbsp; 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0\n};\nvoid setup() {\n&nbsp; display.begin(); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Inicjuj tablicę.\n&nbsp; display.setGrayscaleBits(3); &nbsp;// Ustaw trzybitową jasność.\n&nbsp; display.draw(picture); &nbsp; &nbsp; &nbsp; &nbsp;// Przenieś zawartość tablicy na wyświetlacz.\n}\nvoid loop() {\n&nbsp; bitSet(picture[random(104)], 0);\n&nbsp; bitSet(picture[random(104)], 1);\n&nbsp; bitSet(picture[random(104)], 2);\n&nbsp; bitClear(picture[random(104)], 0);\n&nbsp; bitClear(picture[random(104)], 1);\n&nbsp; bitClear(picture[random(104)], 2);\n&nbsp; bitClear(picture[random(104)], 0);\n&nbsp; bitClear(picture[random(104)], 1);\n&nbsp; bitClear(picture[random(104)], 2);\n&nbsp; bitClear(picture[random(104)], 0);\n&nbsp; bitClear(picture[random(104)], 1);\n&nbsp; bitClear(picture[random(104)], 2);\n&nbsp; display.draw(picture);\n&nbsp; delay(10);\n}</code></pre>W pierwszej kolejności zapalamy trzy piksele na losowych pozycjach, a każdy z inną jasnością. Następnie gasimy również losowe piksele z każdą z trzech jasności, ale tych gaszeń wprowadziłem trzykrotnie więcej. Dzięki temu wyświetlacz nie jest „przegadany” świecącymi się diodami i efekt – mimo prymitywizmu algorytmu – wygląda świetnie, przywołując pulpity różnych maszyn starych filmów science fiction, na których bez sensu najczęściej mrugały sobie światełka.<img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/17-69ef80a2ac6c2499975611.png" class="center" loading="lazy">W sieci znajdziemy biblioteki wyświetlające napisy na tym prostym wyświetlaczu, łącznie z ich przewijaniem oraz konwertery animacji i filmów. Tych ostatnich raczej nie pooglądamy sobie, ale animacje mogą wyglądać ciekawie.

[160] Arduino Q cz. 7

0.png

Przyznaję, że bardzo ciekawiło mnie praktyczne użycie przetworników cyfrowo-analogowych do emisji strumieni audio. Ponieważ w tej serii artykułów omawiamy różne elementy nowego kontrolera Arduino Q, dziś tylko pobieżnie – opiszę najprostszą realizację samplera, podobną do tego, co już przedstawiłem <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/152-gadajacy-woltomierz-cz-1">w artykule o „gadającym woltomierzu”,</a> ale wykorzystującą świeży potencjał. Po pierwsze więc: mamy tutaj prawdziwy przetwornik D/A, po drugie zaś – 2 MB pamięci FLASH. Wstawiłem więc nowe Arduino w <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/plytka-edukacyjna-tme">płytkę edukacyjną TME</a> i wziąłem na warsztat kompilację, którą często przepuszczam przez różne urządzenia pokazywane w mojej serii YouTube’owej Towary Modne, a która świetnie wykrywa różne problemy z torem audio. Postanowiłem odtworzyć ją na Arduino Q.<hr>Myślę sobie: dwa megabajty dla audio to niewiele, ale dwadzieścia sekund muzyki wejdzie. Jakim cudem? Ano po pierwsze – monofonicznej, po drugie – ośmiobitowej. Skoro kontroler jest znacznie mocniejszy od ośmiobitowego ATmega, użyję zmodyfikowanego patentu ze wspomnianego filmu: będziemy bazować tylko na ośmiu bitach, lecz przy dużo wyższej częstotliwości próbkowania: 96 kHz. Po co tak? By móc użyć szumu ditheringu, który zamaskuje niedoskonałości ośmiobitowego formatu. We wspomnianym rozwiązaniu pracowaliśmy z częstotliwością 62,5 kHz, przenosząc się jeszcze wyżej dostaniemy mnóstwo przestrzeni do zaszumienia, że się tak wyrażę i praktyczna dynamika będzie sięgała 60 dB. Teoretyczna dynamika dwunastobitowego zapisu to 72 dB, ale obcięty sygnał szesnastobitowy wprost da cichutkie, a nieprzyjemne brzęczenie w najcichszych fragmentach, zwłaszcza podczas zakończeń utworów. Metoda z ditheringiem obiektywnie brzmi lepiej, szum także jest słyszalny – wyłącznie przy dużej głośności i niskich poziomach sygnału właściwego, ale nie ma charakteru „dzwoniącego” i przede wszystkim nie rezonuje z samym sygnałem, jeśli miałby on takie właściwości.<img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/1-69ef80a07f670917547731.png" class="center" loading="lazy">Podsumowując: próbkę zapisałem jako RAW bez nagłówka, używając wcześniej konwersji przy widocznych tutaj parametrach. Oczywiście 20 sekund nie nadaje się do zrobienia walkmana, ale jak najbardziej można z tego zrobić interfejs głosowy, choćby taki jak wystąpił we wspomnianych filmach, bez użycia dodatkowych kart SD. Jeśli chcielibyśmy sobie zrobić grajka nieograniczonego czasem, możemy użyć karty pamięci. Przy okazji wspomnę, że metoda nie dotyczy tylko widocznego tu Arduino Q, a także wszelkich nowoczesnych kontrolerów z większą ilością pamięci FLASH.Tym razem szkic podzieliłem na dwoje. O ile poprzednio próbki zajmowały niecałe 30 kB, w naszym przypadku tak dużą tablicę z próbkami warto trzymać osobno. Aby ją zbudować, przypomnę: należy przekonwertować treść sampla na format zgodny z C. Użyłem do tego małego programu bin2hex, ale metod na to jest mnóstwo.Teraz należy utworzyć dwa pliki, oba z rozszerzeniem ino, położone w jednym katalogu. Pierwszym, o nazwie player.ino będzie nasz szkic właściwy:<pre><code class="language-arduino">extern const byte sample[]; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Tablica zawierająca próbki sampla.\nextern const unsigned long sampleLen; &nbsp;// Długość sampla (dźwięku).\nunsigned long samplePos = 0; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Adres aktualnie odtwarzanej próbki sampla.\nvoid setup() {\n&nbsp; analogWriteResolution(8); &nbsp;// Deklaracja głębokości bitowej przetwornika D/A\n}\nvoid loop() {\n&nbsp; for (samplePos = 0; samplePos &lt;= sampleLen; samplePos++) { &nbsp;// Powtarzaj dla wszystkich próbek sampla.\n&nbsp; &nbsp; unsigned long sampleStart = micros(); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Zapamiętaj stan zmiennej micros.\n&nbsp; &nbsp; analogWrite(DAC0, sample[samplePos]); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Wyślij kolejną próbkę z tablicy na wyjście D/A\n&nbsp; &nbsp; while (micros() - sampleStart &lt; 9) {} &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Zaczekaj, aż micros zwiększy się o 10.\n&nbsp; }\n}</code></pre>W drugi, o nazwie sample.ino wrzucimy przekonwertowane dane oraz deklarację tablicy – na początku i linię, która oblicza jej długość – na końcu.<pre><code class="language-arduino">const byte sample[] PROGMEM = { &nbsp;// Tablica zawierająca próbki sampla.\n&nbsp; 0x80, 0x80, 0x80, 0x81, 0x7E, 0x81, 0x80, 0x81, 0x7F, 0x7F, 0x81, 0x80,\n&nbsp; 0x81, 0x7F, 0x7F, 0x80, 0x81, 0x81, 0x7E, 0x81, 0x80, 0x7D, 0x82, 0x80,\n&nbsp; 0x82, 0x7D, 0x79, 0x83, 0x86, 0x82, 0x7C, 0x7E, 0x83, 0x83, 0x7E, 0x78,\n};\nconst unsigned long sampleLen = sizeof(sample); &nbsp;// Długość sampla (dźwięku).</code></pre>Spójrzmy na typy zmiennych: dane w tablicy sample to bajty, zadeklarowane na stałe. Wymusiłem nieprzenoszenie ich do pamięci RAM dopisując polecenie PROGMEM. Liczbę elementów sampleLen określamy typem long bez znaku, bo tablica zawiera blisko dwa miliony sampli i oczywiście domyślny int nie jest w stanie pomieścić takiej wartości. Powyższy listing zawiera tylko trzy wiersze danych, pełen zestaw jest dostępny do pobrania w załączniku pod artykułem.We właściwym programie należy zacząć od importu tablicy sample oraz jej długości sampleLen. Robi się to komendą extern, bacząc by zachować typ zmiennych – także fakt ich niezmienności. Deklarujemy też bieżący adres sampla samplePos, który będzie pobierał dane do wystawienia na port przetwornika.Kolejno należy zadeklarować jego rozdzielczość. Gdybyśmy pominęli linię analogWriteResolution(8), domyślną wartością stałoby się 12, a ośmiobitowe sample wypełniłyby najmłodsze bity i dźwięk stałby się cichszy o 24 dB, jako że każdy bit daje 6 dB spadku lub wzrostu sygnału. Tak przy okazji, ładując ośmiobitowe sample bez ditheringu i przy standardowych częstotliwościach próbkowania, można się pokusić o wypełnienie pozostałych czterech bitów szumem, co dałoby lepsze efekty niż surowe puszczanie ośmiobitowych sampli. Ale to historia na inną okazję.Moim celem jest tylko sprawdzenie brzmienia takiego przetwornika, więc samo odtwarzanie jest proste, żeby nie powiedzieć: prostackie i niezgodne ze sztuką – ale jak mówię, po to tylko, by sprawdzić, że działa. Toteż utworzymy sobie pętlę o długości całej tablicy, która będzie pobierać kolejnego sampla i czekać… no właśnie. Okazuje się, że i z funkcją delaymicroseconds coś jest nie tak i nie przyjmuje ona dowolnych wartości, a skokowe. Wyłączanie przerwań nic nie dało, internetowe porady także. Cóż, choroby wieku niemowlęcego…Użyłem więc alternatywnej metody. Jak już nieraz mówiłem, Arduino ma na pokładzie zegar tykający co mikrosekundę. Wystarczy więc na początku pętli sczytać jego wartość do zmiennej sampleStart, potem zrobić swoje – czyli wyjąć z tablicy wartość próbki, wysłać ją na przetwornik i zaczekać, aż delaymicroseconds będzie większe od 9 od sczytanej. Tyle mniej więcej wyszło na ucho, bo to nie jest żadna dokładna metoda, a przybliżona, jeśli wziąć pod uwagę wysokość odtwarzanej próbki.I już miałem posłuchać muzyki, gdy tymczasem wyleciał kolejny błąd. Okazało się, że kompilator na razie nie lubi tablic większych od 512 kB. Należałoby ją podzielić na cztery części albo po prostu ograniczyć się do pięciu sekund – wystarczy do testów. Przyciąłem więc tablicę do ¼ pierwotnej wartości i po chwili dźwięk z przetworników kontrolera wreszcie popłynął.Cóż, mimo że to bardzo prymitywny sposób odtwarzania, nieużywający przerwań, to co było słychać zabrzmiało brzmi świetnie. I to bez jakiegokolwiek filtru; sygnał pobrałem wprost z pinu A0, który pełni alternatywną funkcję przetwornika, a każdy chętny może go posłuchać po ściągnięciu z załącznika. Jak pisałem, stereofonię, obsługę kart i profesjonalne rozwiązanie odtwarzania pozostawimy na inną okazję. Najważniejsze jest to, że to gra i robi to dobrze. Przy okazji pragnę przypomnieć, że mowa jest cały czas o kontrolerze, a nie procesorze, który ma własny tor audio, dostępny także przez USB czy BT. Na razie pozostawmy ten temat i rzućmy okiem na ostatni na razie blok, o którym tylko wspomniałem, czyli na blok diod świecących – ale to już w kolejnym artykule.

[159] Arduino Q cz. 6

<a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/153-gadajacy-woltomierz-cz-2">W poprzednim artykule</a> odtwarzaliśmy sample, używając pamięci pokładowej Arduino. W przypadku emisji dźwięków ile by jej nie było, zawsze będzie za mało. Czas więc sięgnąć po najtańszy i jakże wygodny nośnik pamięci: karty SD. I tu mamy złą wiadomość: Arduino Uno R3 i pozostałe ośmiobitowe układy tej serii nie mają natywnego interfejsu współpracy z jakimikolwiek kartami pamięci jak również nie będą współpracować z pendrive’ami. Jeśli czegoś nie ma, to trzeba to zrobić, a więc w tym wypadku napisać. Powstało kilka bibliotek współpracy z kartami SD, gdyż takie są najbardziej popularne. Co prawda łatwiej dobrać się do kart CF, ale te już prawie wyginęły, a poza tym pracują z interfejsem równoległym, zjadającym sporo wyprowadzeń.<hr><img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/1-69c6cba95b1e7302040097.png" class="center" loading="lazy">Karty SD rozmawiają ze światem w wielu narzeczach, w zależności od generacji. Jedyne sensowne do rozmów z ośmiobitowym mikroprocesorem będzie zarazem najstarszym – to protokół SPI, który w Arduino został zaimplementowany sprzętowo. Karty te odziedziczyły go jeszcze po wersji MultiMediaCard, prawie identycznych rozmiarami, ale nieco cieńszych i posiadających więcej wyprowadzeń.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/2-69c6cba820c53131740544.png" class="center" loading="lazy">Spójrzmy na szczegóły: karta taka potrzebuje trzech linii danych, czwartej – linii aktywacji oraz zasilania. Zatem podłączenie do Arduino będzie proste, lecz tylko o ile wybierzemy wersję pracującą z trzema woltami, bo w takim standardzie pracują karty. Problem w tym, że po pierwsze: Uno pracuje z pięcioma woltami, a po drugie: przy niższym napięciu nie pogonimy mikrokontrolera z pełną szybkością, a więc 16 MHz. A przy zadaniach audio każdy megaherc jest na wagę złota.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/3-69c6cba8aeef3349711357.png" class="center" loading="lazy">Na szczęście rozwiązanie problemu jest proste: wystarczy sześć rezystorów, które zabezpieczą kartę przed niebezpiecznym dla niej napięciem.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/4-69c6cbaa1db9c370502023.png" class="center" loading="lazy">Coś takiego możemy sobie zlutować sami, używając nawet starego adaptera do kart w wersji micro albo też możemy kupić za kilka złotych i w tutaj dostaniemy nie tylko czytnik, ale i porządny konwerter napięć oraz zasilacz. Skoro o sprzęcie wiemy już wszystko, zmajstrujmy sobie odtwarzacz dźwięków.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/5-69c6cbaa74b41626719723.png" class="center" loading="lazy">Na początek – czytnik. Podłączamy go do wyprowadzeń: 11, 12, 13 i 4, przy czym tylko ten ostatni możemy sobie zmienić. Jak zwykle użyję <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/plytka-edukacyjna-tme">płytki edukacyjnej TME,</a> bo mam tam klawiaturkę, która mi się za chwilę przyda.Wyjście audio także jest związane z jedyną parą PWM, która może hulać z wymaganą częstotliwością. Zatem na początek podłączmy mały głośnik – koniecznie przez kondensator kilkadziesiąt mikrofaradów – do pinu 9 i masy. Ja bym jeszcze wstawił w szereg rezystor 100 omów i to będzie wszystko. Choć – nie. Potrzebna jest jeszcze karta pamięci i pliki, które na nią wrzucimy. Prezentowany projekt współpracuje z kartami sformatowanymi w FAT16 albo FAT32. Ze względu na uproszczenia, wymaga się, by pliki tkwiły w głównym katalogu i trzymały się zasady DOS-a, czyli do ośmiu liter nazwy i do trzech rozszerzenia.Autor biblioteki postawił na jakość audio kosztem uproszczeń współpracy z kartą, w związku z czym mamy jeszcze dwa ograniczenia: pliki nie mogą być pofragmentowane, ponieważ adres położenia ustala się tylko na początku odtwarzania, a potem czytanie leci zgodnie z licznikiem bajtów. Dlatego przed zabawą należy kartę sformatować w trybie pełnym, a następnie można tam dorzucać dowolną liczbę plików, niekoniecznie wszystkie od razu, ale nie należy niczego usuwać.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/6-69c6cba8624b3454132624.png" class="center" loading="lazy">Jeśli chcemy usunąć zbędny nadmiar, znowu formatujemy kartę i wrzucamy wszystko, co nam będzie potrzebne. Mamy jeszcze jedno ograniczenie, które paradoksalnie zrobi nam świetną robotę, ale o tym za chwilę.Kartę z zawartością znajdującą się w załączniku pierwszym wsadzamy do adaptera i uruchamiamy edytor.<pre><code class="language-arduino">#include &lt;SimpleSDAudio.h&gt; &nbsp;// Biblioteka odtwarzania sampli z karty SD.\n\nvoid setup() {\n&nbsp; SdPlay.init(SSDA_MODE_FULLRATE | SSDA_MODE_MONO | SSDA_MODE_AUTOWORKER); &nbsp;// Inicjalizacja biblioteki.\n&nbsp; SdPlay.setFile("mono.afm"); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Pobierz plik "mono.afm"\n&nbsp; SdPlay.play(); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Odtwórz go.\n}\nvoid loop() {}</code></pre>Szkic będzie śmiesznie mały i ograniczy się do importu biblioteki SimpleSDAudio.h którą należy sobie wcześniej ściągnąć, jej inicjalizacji, importu pliku według nazwy, który znajduje się na karcie i włączenia odtwarzania. Jak widać, używamy biblioteki zawierającej zarówno obsługę karty SD jak i odtwarzania plików. Po skompilowaniu powinniśmy usłyszeć to, co znajdziemy w załączniku drugim. Skoro już wiemy, jak przechowywać dźwięki na karcie SD – czas na coś ambitniejszego. Ale o tym napiszę w kolejnym artykule.

[154] Obsługa kart SD

164.png

Obok niedawnej premiery rewolucyjnego Uno Q pojawiła się kolejna – tym razem o nazwie VENTUNO Q. Jest to jednak <a target="_blank" rel="noopener noreferrer nofollow" href="https://www.arduino.cc/product-ventuno-q">płytka zupełnie inna,</a> fizycznie bardziej podobna do płyty głównej współczesnego komputera. Wyposażono ją także w dwie jednostki: kontroler to STM32H5 i jest przeznaczony do typowych zadań dla tego typu jednostki, a więc krytycznych czasowo, związanych z zadaniami przemysłowymi. Mikroprocesor natomiast to Qualcomm Dragonwing IQ8, którego głównym zadaniem jest lokalna praca AI. Dlatego na wyposażeniu posiada akcelerator NPU o wydajności 40 TOPS, a także typowe dodatki z GPU włącznie. Podobnie jak to było z Uno Q, płytka może pracować w dwóch trybach: jako urządzenie samodzielne, wspierające klawiaturę, mysz i wyświetlacz, a więc zachowujące się jak typowy komputer z Linuxem na pokładzie. Można jej też używać jak typowego Arduino, podłączonego do komputera.Na pokładzie osadzono 16 GB RAM-u oraz 64 GB pamięci eMMC, więc zupełnie obiektywnie urządzenie jest całkiem sprawnym komputerem. Głównym zadaniem płytki jest wsparcie robotyki. Platforma obsługuje ROS 2, system stworzony właśnie dla takich zadań i współpracuje z App Lab, który premierę miał wraz z Uno Q. Platformy z lokalnym AI, niezależnym od sieci i lagów z nią związanych, będą podstawą robotyzacji świata. Pamiętajmy, że w tym wypadku AI to nie generowanie tańczących kotów ku uciesze oglądających, a całkiem praktyczne zadania, jak obserwacja środowiska, w których roboty funkcjonują i podejmowanie decyzji w czasie rzeczywistym.

Obok niedawnej premiery rewolucyjnego Uno Q pojawiła się kolejna – tym razem o nazwie VENTUNO Q. Jest to jednak <a target="_blank" rel="noopener noreferrer nofollow" href="https://www.arduino.cc/product-ventuno-q">płytka zupełnie inna,</a> fizycznie bardziej podobna do płyty głównej współczesnego komputera. Wyposażono ją także w dwie jednostki: kontroler to STM32H5 i jest przeznaczony do typowych zadań dla tego typu jednostki, a więc krytycznych czasowo, związanych z zadaniami przemysłowymi. Mikroprocesor natomiast to Qualcomm Dragonwing IQ8, którego głównym zadaniem jest lokalna praca AI. Dlatego na wyposażeniu posiada akcelerator NPU o wydajności 40 TOPS, a także typowe dodatki z GPU włącznie. Podobnie jak to było z Uno Q, płytka może pracować w dwóch trybach: jako urządzenie samodzielne, wspierające klawiaturę, mysz i wyświetlacz, a więc zachowujące się jak typowy komputer z Linuxem na pokładzie. Można jej też używać jak typowego Arduino, podłączonego do komputera.

Arduino VENTUNO Q

10.png

Przyjrzyjmy się teraz wejściom analogowym, ale tutaj przedstawię kolejną zmianę, która może mieć czasem istotne znaczenie. Każdy chyba zna i docenia współpracę z terminalem, czyli zrzucanie na zewnątrz ciągów danych, które zwłaszcza podczas uruchamiania aplikacji przydają się, by wiedzieć co się tam dzieje. Do tej pory używaliśmy polecenia Serial, jednak w nowym Arduino działa ono wyłącznie bezpośrednio, to znaczy dane są wysyłane na port szeregowy używający pinów 0 i 1. Żeby dane te zobaczył terminal, czy to wbudowany w IDE, czy w App Lab, trzeba użyć programowego mostka, który puści strumień przez pokładowy procesor płytki. Dlatego musimy osadzić bibliotekę, a polecenie Serial zamienimy nowym: Monitor. Ma tę samą składnię, ale współpracuje z wymienionym mostkiem, a nie portem wprost.<hr><pre><code class="language-arduino">#include &lt;Arduino_RouterBridge.h&gt; // Biblioteka umożliwiająca przesyłanie danych do monitora.\nconst byte potPort = A1; // Adres portu, do którego podłączony jest potencjometr.\nint potValue; // Mierzona wartość.\nvoid setup() {\n Monitor.begin(115200); // Inicjuj monitor.\n}\nvoid loop() {\n potValue = analogRead(potPort); // Zmierz napięcie.\n Monitor.println(potValue); // Prześlij zmierzoną wartość do monitora.\n delay(100);\n}</code></pre>Napisałem prostą aplikację zrzucającą mierzone napięcie z portu A1 na monitor. Użyłem jak zwykle <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/plytka-edukacyjna-tme">płytki edukacyjnej TME,</a> gdzie na pinie A1 osadzono ślizgacz potencjometru. Szkic działa, w zależności od położenia gałki potencjometru zmieniają się wartości.<img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/11-699f54619483d278125461.png" class="left" loading="lazy">Problem w tym, że widzimy tu kolejnego babola: co jakiś czas polecenie zmiany wiersza jest ignorowane, a potem wychodzi zdublowane. Stąd taki szczerbaty wygląd tego strumienia. Wszelkie sieciowe porady nic nie zmieniły więc pozostaje czekać na poprawki. Na szczęście to nie ma znaczenia dla samego działania przetwornika i psuje jedynie estetykę.Kręcąc potencjometrem zwróćmy uwagę na to, że jest on tu podpięty do pięciu woltów i od dwóch trzecich zakresu regulacji daje przepełnienie. Mało tego, nie powinno się na port A1 posyłać wyższego napięcia niż 3,3 wolta, więc uważajmy i nie przekraczajmy progu przepełnienia. Wróćmy teraz do istoty: przetworniki analogowo-cyfrowe mają rozdzielczość dwa bity większą. By sięgnąć po tę zwiększoną dokładność, należy ją zadeklarować wpisem:<pre><code class="language-arduino">analogReadResolution(12); &nbsp;// Deklaracja głębokości bitowej przetwornika A/D</code></pre>Po kompilacji dostaniemy ciąg wartości do 4095. Mało tego, system potrafi zaoferować wyższą rozdzielczość, ale jest to już tworzone programowo. Mimo to może być przydatne, w szczególnych wypadkach oszczędzając nam dodatkowych obliczeń.<img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/12-699f5461c67d9995952493.png" class="left" loading="lazy">Nowy układ oferuje także szeroką ofertę napięć referencyjnych. Domyślnie przetwornik pracuje, biorąc za bazę napięcie zasilania, czyli 3,3 wolta. Tym poleceniem możemy jednak wybrać kilka innych napięć:<pre><code class="language-arduino">analogReference(AR_INTERNAL2V05); &nbsp;// Napięcie odniesienia dla przetwornika A/D</code></pre>Widoczna tu wartość 2V05, wraz z jedenastobitową dokładnością da nam wprost woltomierz mierzący nieco ponad dwa wolty z rozdzielczością jednego miliwolta. Do wyboru mamy jeszcze napięcia: półtora wolta, jeden i osiem dziesiątych, dwa i pół oraz napięcie zewnętrzne, podawane na pin AREF, byle nie wyższe od 3,3 wolta i nie niższe od dwóch.Na koniec omówię nowość – parę przetworników cyfrowo – analogowych, czyli coś, czego dotąd nie było, a co zastępowaliśmy filtrowanymi PWM. Płytka oferuje dwa takie, niezależne wyjścia o rozdzielczości 12 bitów. Zatem możemy z tego uczynić wyjście audio. Co prawda 12 bitów to nie 16, ale w pionierskich czasach cyfrowych takimi rozdzielczościami dysponował sprzęt profesjonalny i dziś, słuchając płyt z lat osiemdziesiątych nawet nie domyślamy się, że wiele brzmień pochodzi z instrumentów dwunastobitowych.<img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/13-699f546432546485093249.png" class="center" loading="lazy">Jednak głównym zadaniem tych wyjść jest oferowanie naprawdę stałego napięcia, bez kombinacji z filtrami – jak to bywa z PWM.<pre><code class="language-arduino">#include &lt;Arduino_RouterBridge.h&gt; // Biblioteka umożliwiająca przesyłanie danych do monitora.\nconst byte potPort = A1; // Adres portu, do którego podłączony jest potencjometr.\nint potValue; // Mierzona wartość.\nvoid setup() {\n Monitor.begin(115200); // Inicjuj monitor.\n analogReadResolution(12); // Deklaracja głębokości bitowej przetwornika A/D\n analogWriteResolution(12); // Deklaracja głębokości bitowej przetwornika D/A\n}\nvoid loop() {\n potValue = analogRead(potPort); // Zmierz napięcie.\n analogWrite(DAC0, potValue); // Prześlij wartość zmierzoną na port D/A\n Monitor.println(potValue); // Prześlij zmierzoną wartość do monitora.\n delay(100);\n}</code></pre>W pierwszym przykładzie będziemy przesyłać wartość napięcia ślizgacza potencjometru na wyjście przetwornika cyfrowo-analogowego. Jak widać, podłączenie tutaj wprost woltomierza pokazuje zmiany, a napięcie oczywiście sięga maksymalnie 3,3 wolta.<pre><code class="language-arduino">void setup() {\n analogWriteResolution(12); // Deklaracja głębokości bitowej przetwornika D/A\n}\nvoid loop() {\n for (int x = 0; x &lt; 4096; x++) { // Zwiększaj napięcie w 4096 krokach.\n analogWrite(DAC0, x); // Prześlij wartość zmierzoną na port D/A\n }\n}</code></pre>Drugi przykład generuje przebieg piły, który uzyskaliśmy w prosty, żeby nie powiedzieć: prostacki sposób: wartość napięcia jest cyklicznie zwiększana aż do 4095, po czym jest zerowana.<img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/14-699f54639bc59717477285.png" class="center" loading="lazy">W kolejnych artykułach będę chciał się zająć praktycznym zastosowaniom elementów, których dokładność wzrosła, w szczególności generacji dźwięków. W 2 MB można upchać nieporównywalnie więcej próbek wobec 32 kB, siedzących w ośmiobitowym Arduino. Poza tym na przegląd czeka jeszcze matryca diod, o której dotąd napisałem tylko tyle, że istnieje.

[151] Arduino Q cz. 5

Jakoś przypadkiem znalazłem w sieci dyskusję: co w nowym Arduino jest cenniejsze: komputer czy mikrokontroler? Wydawałoby się oczywiste: komputer jest potężny, ma gigaherce i gigabajty, a kontroler to tylko kontroler. No i nie do końca, bo gdy przyjrzymy się mu z bliska, okazuje się, że to rzecz interesująca i cenna, nawet jeśli zapomnimy o całym tym Linuxie i App Labie. Dlatego postanowiłem go wziąć pod lupę i wskazać różnice względem tego co znamy, a także poszukać nowości.<hr>Przypomnę, że jest to kostka firmy STM o symbolu STM32U585 w wersji maksymalnej, czyli ze 169 wyprowadzeniami. Na temat tego co tam wewnątrz siedzi, znajdziemy bardzo długą listę. Dużo tu wszystkiego, co jest charakterystyczne dla współczesnych, zaawansowanych kontrolerów. Mamy więc bloki związane z kryptografią, rozbudowane systemy oszczędzania energii startujące już od 160 nA, 17 timerów, 22 magistrale komunikacyjne, matematyczny koprocesor, a nawet akcelerator graficzny i interfejs kamery. I wiele innych dóbr, więc postanowiłem spojrzeć na rzecz z perspektywy arduinowicza, skupiając się na tym, co już znamy, a co się zmieniło albo ulepszyło.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/1-699f54624a845808340910.png" class="center" loading="lazy">Pomogą nam w tym klasyczne ściągi tworzone przez organizację Arduino, które od lat towarzyszą kolejnym płytkom. Jak widać, podstawy wciąż są takie same. Mamy więc rządek pinów cyfrowych, adresowanych jak zwykle, z alternatywnymi funkcjami. Po drugiej stronie siedzi mniejszy rządek – analogowy z opcją cyfrową, czyli po staremu. Jak już pisałem ostatnio – z jedną różnicą: to jest logika trzywoltowa. Ale na szczęście akceptuje poziomy pięciowoltowe, więc w praktyce dla pracy cyfrowej nic się nie zmieniło. Dla analogowej jednak już tak dobrze nie jest: wejścia mogą mierzyć napięcia nie wyższe od napięcia zasilającego, czyli 3,3 wolta. Przedział do pięciu woltów da przepełnienie, ale nie popsuje portów z wyjątkiem A0 i A1 – tym nie wolno podawać napięcia wyższego od 3,3 wolta i już.Porty cyfrowe pracują jak to było w czasach ośmiobitowego Arduino. Nowością jednak są dwa nowe adresy, które dawniej były dublowane z dwoma ostatnimi pinami z grupy analogowej: można się do nich dostać za pomocą adresów 20 i 21. Przy czym na razie jest z tym problem: są one dublowane z adresami odpowiednio 18 i 19, tak jak gdyby były ze sobą zwarte parami – jak było w starym Uno. Mimo porad znalezionych w sieci, na razie nie udało mi się rozdzielić adresowania. Tak więc góra płytki, przynajmniej teoretycznie daje dostęp do 22 portów, z czego sześć może być portami wejść analogowych, a na sześć innych – jak dawniej – może wysyłać przebieg PWM, ale… o tym za chwilę. Pozostańmy jeszcze przy funkcji czysto cyfrowej. Skoro kontroler ma prawie 170 wyprowadzeń, ograniczenie do 22 portów byłyby marnotrawstwem.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/2-699f5462cb298634313486.png" class="center" loading="lazy">Na szczęście po drugiej stronie płytki znajdziemy dwa nowe gniazda o dwukrotnie gęściejszym rastrze – niestety – ale dzięki temu zmieściło się tam dużo sygnałów. Prawe gniazdo na razie nie będzie nas interesować, bo jest związane z procesorem. Lewe natomiast dzieli się z nim i kontrolerem. Wystawiono tutaj kolejne 25 portów, które mogą być adresowane… No właśnie, znowu mamy bałagan wieku niemowlęcego. Nigdzie nie ma informacji o adresach! Zbudowałem więc prostą sondę z diody świecącej i kiloomowego rezystora, do których przylutowałem cienkie wyprowadzenia, wchodzące w te cieniutkie gniazda. Metodą prób i błędów ustaliłem, że zastosowano tu logiczny porządek: pin z numerem jeden ma adres 25 i tak dalej, aż do pinu dwudziestego piątego, który adresujemy liczbą 49. Jeśli zdobędziemy gdzieś wtyk pasujący tutaj, zyskamy kolejne 25 cyfrowych portów.Tak więc zasoby ilościowo odpowiadają połowie drogi między Uno, a Mega, które – przypomnę – ma 70 pinów do zagospodarowania. Czas na słówko o jakości. O ile funkcje cyfrowe są proste i niewiele się tu doda, z analogowymi jest dużo ciekawiej. Zacznijmy do PWM i klasycznego przebiegu pięćdziesięcioprocentowego.<pre><code class="language-arduino">const byte pwmPort = 3; // Adres portu PWM\nbyte pwmValue = 128; // Wartość wysyłana na port PWM\nvoid setup() {\n analogWrite(pwmPort, pwmValue); // Prześlij wartość deklarowaną na port PWM\n}\nvoid loop() {\n}</code></pre>Podłączę się na pin trzeci, wrzucę domyślne parametry i uruchomię mój programowy oscyloskop, <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/120-zegar-z-nieba-czyli-wstep-do-gps-u">o którym kiedyś już pisałem.</a> Jak widać, wszystko jest zgodne z oczekiwaniami.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/3-699f546369c96952635659.png" class="center" loading="lazy">Zmieńmy wartość pwmValue na 1, co da najmniejsze możliwe wypełnienie. To jednak nie wszystko. O ile stare Arduino umożliwiało pod pewnymi warunkami generację szesnastobitowego przebiegu przy częstotliwości ledwo sięgającej kiloherca, w przypadku Q mamy możliwość wybrania rozdzielczości w szerokich granicach i przy częstotliwościach daleko wychodzących ponad akustykę. Spróbujmy więc zmodyfikować szkic.<pre><code class="language-arduino">const byte pwmPort = 3; // Adres portu PWM\nint pwmValue = 1; // Wartość wysyłana na port PWM\nvoid setup() {\n analogWriteResolution(14); // Deklaracja głębokości bitowej PWM\n analogWrite(pwmPort, pwmValue); // Prześlij wartość deklarowaną na port PWM\n}\nvoid loop() {\n}</code></pre>Nowym poleceniem analogWriteResolution() zwiększymy rozdzielczość do 14 bitów. Żeby zobaczyć impuls o szerokości jednej szesnastotysięcznej okresu, musiałem wzmocnić poziom stukrotnie, do tego stopnia, że szumy własne przetwornika karty audio uwydatniły się na przebiegu.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/4-699f546329de3574136336.png" class="center" loading="lazy">To otwiera zupełnie nowe możliwości, przede wszystkim w dziedzinie akustyki. Szesnastobitowe PWM z nadpróbkowaniem to już czyste HiFi, jeśli tylko zadbamy o dobre filtrowanie sygnału. Nie będzie z tym problemu, bo częstotliwość pracy możemy wysłać w dalekie ultradźwięki. Tak na marginesie, przy ośmiu bitach częstotliwości te mogą sięgać kilkudziesięciu megaherców, co daje potencjał zastosowań w dziedzinie radiowej. Tylko że na razie mamy jeden problem, a właściwie całą ich grupę. Mamy – jak pisałem – wiek niemowlęcy całego ekosystemu, a zerowe numery przy bibliotekach świadczą o tym najlepiej. I tak: jedenasty pin nie potrafi w ogóle wykrzesać z siebie przebiegu, a pozostałe pracują na razie poprawnie przy dziesięciobitowej rozdzielczości. Czternastobitowy eksperyment zadziała tylko w początkowej 1/16 zakresu. Cóż, tym którzy chcieliby skorzystać z nowych możliwości pozostaje czekać. Łatki schodzą każdego dnia, więc tempo napraw jest spore. <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/151-arduino-q-cz-5">W kolejnym artykule</a> przyjrzymy się wejściom analogowym i nie tylko.

[150] Arduino Q cz. 4

30.png

<a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/148-arduino-q-cz-2">W poprzednich artykułach</a> przyglądaliśmy się nowemu Arduino Q, traktując je jak stare wersje tej najpopularniejszej płytki Uno. Jednak Q to coś zdecydowanie więcej i dziś poznamy jego drugą twarz. Najpierw jednak musimy zgromadzić następujące elementy.<hr><img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/31-699c0a745e0a2116369724.png" class="center" loading="lazy">Po pierwsze: hub USB z wyjściem na monitor, wejściem na zasilacz i dwoma, a najlepiej czterema gniazdami USB. Jeśli będzie tam jeszcze wyjście audio oraz gniazdo na karty SD, będziemy mieć już wszystko. W moim akurat brakuje wyjścia dźwiękowego, ale podłączając monitor z głośnikami obsługiwanymi przez HDMI, problem się rozwiąże. Zasilanie może być zorganizowane dwojako: klasycznie – za pomocą typowego wejścia dla zasilacza z wtyczką współosiową oraz w trybie Power Delivery, przez przeznaczone do tego wejście USB C. Drugie rozwiązanie zapewnia możliwość wystawiania ponadstandardowych mocy na pozostałe gniazda USB, wymaga jednak odpowiedniego zasilacza.<img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/32-699c0a788fe67122667096.png" class="center" loading="lazy">Ponieważ Q potrzebuje 5 woltów i 3 amperów łącznie z HUB-em, w moim wypadku wystarczył taki zasilacz, dający akurat tyle energii ile tu potrzeba. Gdybyśmy chcieli podłączyć jeszcze na przykład dysk twardy, wówczas należałoby użyć mocniejszego zasilacza, który w drodze negocjacji może zaoferować wyższe napięcia.<img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/33-699c0a72c2e56845833797.png" class="center" loading="lazy">Kolejnym elementem już wspomnianym przeze mnie jest monitor z wejściem HDMI. Do celów serwisowych użyłem takiego monitorka, zaprojektowanego do podglądu obrazu z kamer. Ma odpowiednie gniazdko i na początek da radę, choć obraz będzie mały.<img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/34-699c0a7829222756100039.png" class="center" loading="lazy">Na koniec, jak się można domyślić, przyda się jeszcze klawiatura USB i takaż mysz. Użyłem czegoś takiego: miniaturowej klawiatury z panelem dotykowym. Nie jest to wygodne, ale zajmuje mało miejsca. Urządzenie jest bezprzewodowe, ale odbiornik to taka mała wtyczka USB, więc nie trzeba będzie tu niczego konfigurować.Czas wszystko połączyć. Kolejno: HUB z monitorem, odbiornik sygnałów z klawiatury do jednego z wejść USB, zasilacz do kontaktu, a jego kabel do wejścia USB przeznaczonego dla zasilacza. Czekamy kilka sekund, bo sam HUB to niezły komputer w środku i delikatnie podłączamy jego wejście do Arduino. Teraz czeka nas chwila cierpliwości. Przez kilkanaście sekund ekran będzie czarny, lecz po chwili powinniśmy zobaczyć litanię komend i okienko logowania. Po wpisaniu hasła ujrzymy klon obrazu, który już widzieliśmy – aplikację App Lab.<img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/35-699c0a7cef329066813403.png" class="center" loading="lazy">Co z tego wynika? Fakt, iż Arduino można teraz programować z… Arduino! Nie jest już potrzebny komputer. Aby się upewnić, że tak jest, ponownie wysłałem Blinka do kontrolera. Po chwili dioda zaczęła mrugać, czyli mamy kontrolę nad maszyną i możliwość programowania, że tak powiem, lokalnego.Na razie opuśćmy aplikację, spójrzmy na to co nowe w świecie Arduino. Zacznijmy od tego, że właśnie patrzymy na Linuxa w wersji Debian, z graficznym środowiskiem Xfce.<img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/36-699c0a7ec54e9598794358.png" class="center" loading="lazy">Taką dystrybucję wybrano i taki interfejs, poniekąd słusznie: Debian uznawany jest za stabilny, a interfejs – lekki, elegancki i łatwy w użytkowaniu także dla początkujących. Zapraszam więc na wycieczkę po systemie.<img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/37-699c0a801ca22274795478.png" class="center" loading="lazy">Z racji przeznaczenia i jednak skromnych zasobów jak na współczesne komputery, aplikacji jest tu niewiele, co oczywiście nie znaczy, że nie można doinstalować kolejnych. Należałoby jednak zacząć od skonfigurowania połączenia z siecią, bo dopiero wtedy wykorzystamy potencjał. Prawdę powiedziawszy, zrobiłem to wcześniej, ale proces jest typowy i nie ma tu żadnych niespodzianek. Q pracuje także z sieciami 5 GHzSkoro mamy zasięg, rzućmy okiem na przeglądarkę. Osadzono tutaj Chromium, na której Google buduje Chrome, więc kto używa tamtej, nie poczuje się tu obco. Z ciekawości odpaliłem stronę <a target="_blank" rel="noopener noreferrer nofollow" href="http://Arduino.pl">Arduino.pl</a>, a potem <a target="_blank" rel="noopener noreferrer nofollow" href="https://adamsmialek.com/index.htm">własną</a> – obie pracują jak należy.<img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/38-699c0a7dc645c022124307.png" class="center" loading="lazy">Tak na marginesie, rozdzielczość domyślna 1280x720 pikseli jest dziś trochę za mała dla celów stricte komputerowych. Wszystko można zmienić w ustawieniach. Przełączyłem się na swój dyżurny monitor, został rozpoznany i zasugerowano mi tu rozdzielczość HD. Wędrując po ustawieniach można się zatracić w ulepszaniu pulpitu i pozostałych elementów, ale lepiej mieć takie możliwości niż ich nie mieć. Z rzeczy przydatnych mamy tutaj BT, który od razu odkrył moje głośniki, więc nie będzie problemu z dźwiękiem. Oczywiście możemy teraz podpiąć bezprzewodową mysz i klawiaturę w tym standardzie. Jak mówiłem, jeśli monitor wspiera dźwięk – możemy go wskazać w ustawieniach.<img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/39-699c0a808558f500236114.png" class="center" loading="lazy">Zainstalowano tu skromną liczbę aplikacji: między innymi obowiązkowy edytor Vim, przeglądarkę obrazów i menadżer plików. Jak widać, zasobów trochę pozostało. Jeśli komuś mało – zawsze można wybrać płytkę z podwójną ilością RAM-u i przestrzeni dyskowej. Przy intensywnym korzystaniu z Linuxa jest to właściwie zalecane, 2 GB pozwalają na płynność tylko przy niewielkiej liczbie aplikacji uruchomionych jednocześnie. Z ciekawości wsunąłem do HUB-a kartę SD, została natychmiast rozpoznana, więc na duże zbiory, na przykład media, ta forma ich przechowywania będzie optymalna.<img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/40-699c0a7f479d1711455543.png" class="center" loading="lazy">Pamiętajmy, że to nie jest ośmiobitowe Arduino i zamykanie systemu wymaga kultury. Co prawda szansa, że wyszarpanie z gniazdka wtyczki popsuje system jest niewielka, lecz należy to robić w ten sposób.Na sam koniec wspomnę o czymś, co mi umknęło: zmienił się status diod na płytce. Mamy teraz cztery diody, ale wszystkie RGB. Druga para daje echo stanów na pinach od 10 do 15, czyli także tych spoza złącza, ale mogących być adresowanymi. Pierwsza para natomiast odwołuje się do adresów mikroprocesora i drugiej przyporządkowano wstępnie stany: czerwony – awaria, zielony – połączenie z WiFi, niebieski – z BT. Pomijając samą matrycę ledów, mamy więc 12 diod do wykorzystania na wstępie w jednoznacznych barwach, co z pewnością ułatwi programowania i zastawianie różnego rodzaju pułapek na etapie uruchamiania projektów.Tak więc mamy dwa w jednym: Arduino i komputer, który od razu można przerobić na przykład na platformę medialną. No ale trochę nie do tego służy Q, a konkrety będę przedstawiać w kolejnych artykułach.

[149] Arduino Q cz. 3

20.png

Po otwarciu pudełeczka – którego wygląd ma chyba dłuższą tradycję niż samo Uno – ze środka wyskakuje znanych kształtów płytka. Jak zwykle od razu pomyślałem, by wsadzić ją <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/plytka-edukacyjna-tme">w moje laboratorium do uruchamiania różnych aplikacji na etapie wstępnym</a> i tak też zrobiłem. Zachęcony jednak przewodnikiem z oficjalnej strony Arduino postanowiłem chwilę zaczekać z podłączaniem jej do komputera. Co prawda płytka współpracuje ze starym dobrym IDE, ale dopiero App Lab – nowe środowisko – pozwoli wykorzystać potencjał mocy w pełni. Na razie poprzestańmy na tym, że to po prostu kolejne środowisko uruchomieniowe, o większych możliwościach. Udałem się zatem pod wskazany adres i po chwili ukazał się taki widok.<hr><img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/21-699c0d82c9f07175547011.png" class="center" loading="lazy">Postanowiłem zaryzykować bezpośrednie połączenie płytki z USB C w komputerze, które powinno zapewnić wymagane trzy ampery prądu. Udało się, płytka została rozpoznana i od razu rozpoczął się długotrwały, ale na szczęście automatyczny proces ściągania różnego rodzaju łatek – dla aplikacji jak i dla obu procesorów na płytce. Po kilku minutach pojawiła się barwa nadziei – zielona i zostałem poproszony o zrestartowanie aplikacji. Znowu trzeba było odczekać kilka minut, cóż – takie mamy czasy, w każdym razie we współczesnej elektronice. W końcu pojawiło się okienko z prośbą o ustalenie hasła. Musi mieć ono osiem znaków – takie wymagania. Najlepiej wymyślić coś prostego do wklepywania, tajnych rzeczy tam nie będzie, a hasło owo trzeba będzie wpisywać często. Po chwili ukazał się taki panel.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/22-699c0a73641e1048196034.png" class="center" loading="lazy">Na razie, trochę w ciemno postanowiłem uruchomić cokolwiek, a nazwa Blink wydawała mi się najwłaściwsza. Projekt wygląda zupełnie inaczej niż w IDE, dużo tu ściąg, rysunków i pomocy.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/23-699c0a716661b380131065.png" class="center" loading="lazy">Chwilowo postanowiłem tego nie studiować, a od razu kliknąć w Run, licząc na ujrzenie migającej diody. I rzeczywiście, po czasie zdecydowanie dłuższym i kilkudziesięciu, jeśli nie kilkuset komunikatach, ujrzałem migającą czerwoną diodę. No cóż, komputer tej klasy do migania to trochę przesada, ale nie to jest ważne, a fakt nawiązania dialogu z płytką, zakończony powodzeniem.Skoro jednak jest to płytka Uno, chciałem sprawdzić, czy stare, dobre środowisko wciąż daje radę. Po pierwszym otwarciu IDE program pobierze elementy dla nowej płytki, co trwa jakieś dwie minuty. Po chwili Uno Q pojawi się automatycznie w okienku płytek. Znów nie chciałem szaleć i ponownie wgrałem Blinka, by zobaczyć czy ta aplikacja też działa poprawnie. Ale żeby widzieć różnicę, przyspieszyłem miganie. Po kliknięciu w prześlij, tym razem wyskakuje okienko, w które należy wpisać ustalone hasło. Programowanie trwa zdecydowanie dłużej niż to było w przypadku płytek ośmiobitowych, lecz w końcu miganie się pojawia, zgodnie z ustawieniami – szybsze.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/24-699c0d134baa7631532205.png" class="center" loading="lazy">Tak przy okazji, jakże fajnie wygląda monit: wykorzystano 1032 bajty z... prawie dwóch milionów. RAM-u także mamy pół miliona z hakiem. A jeszcze przed chwilą były sobie dwa kilobajty…Podczas szukania Blinka zauważyłem nowy zbiór przykładów – specjalnie dla wersji Q. Zaintrygował mnie ten o nazwie video. Treść nic mi na razie nie mówi, ale postanowiłem to przesłać do płytki. Po chwili matryca diod ożyła wyświetlając jakąś bliżej nieokreśloną animację. Nowością jest modulacja jasności diod, co znakomicie maskuje marną rozdzielczość takiego pseudowyświetlacza.No dobrze, a jak jest z nieco poważniejszą kompatybilnością? Sięgnąłem po jeden ze starszych projektów, który przedstawiał mierzoną wartość napięcia na wyświetlaczu LCD.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/25-699c0a8154773743386216.png" class="center" loading="lazy">Nie było żadnych problemów z kompilacją, wyjściowa logika trzywoltowa jest kompatybilna z pięciowoltową, a nowe Uno akceptuje napięcia pięciowoltowe. Z jednym wyjątkiem: potencjometr dzieli napięcie pięć woltów, ale przetworniki tego nie akceptują. Co prawda nie nastąpi katastrofa, lecz ostatnia 1/3 zakresu leży już ponad poziomem maksymalnym rozpoznawanym przez kontroler i w rezultacie użyteczna część obrotu potencjometru skraca się do 2/3. Docelowo potencjometry należy zasilać napięciem 3,3 wolta albo referencyjnym, ustalanym oddzielnie.Podsumowując, działa nowe, działa stare. No ale trochę nie po to kupuje się tak mocny sprzęt, żeby migać diodami, mierzyć napięcia czy ogólnie, robić to wszystko, co można znacznie tańszą płytką z ośmiobitowcem. Na chwilę zapomnijmy o całym tym Arduino, C++ i spójrzmy na Q z zupełnie innej strony. Do tej pory wystarczyła wtyczka podłączona z drugiej strony do portu USB C. Teraz już tak prosto nie będzie – ale o tym <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/149-arduino-q-cz-3">napiszę w kolejnym artykule.</a>

[148] Arduino Q cz. 2

W świecie Arduino ostatnio dużo się mówi o nowince, której nikt się nie spodziewał: nowym, już trzecim Uno z literką Q. I to powstałej wyjątkowo szybko po premierze drugiego Arduino, zwanego R4, bo zaledwie dwa lata później. Przypomnę, że Uno ośmiobitowe, czyli pierwsze, pojawiło się w roku 2010. Niestety wraz z premierą zaistniało nieciekawe zjawisko: chaos. Na licznych portalach możemy się dowiedzieć o przełomie, wspaniałych możliwościach, nawet obejrzeć sobie zestawienie parametrów, ale niewiele z tego wynika. Tak naprawdę brakuje podstawowych informacji: dlaczego tak i po co? Postanowiłem uporządkować nieco wiedzę na temat nowej płytki, co nie jest takie proste, bo tej wiedzy jeszcze prawie nigdzie nie ma. Z pewnością wiele rzeczy się zweryfikuje, ale czas leci, a przede wszystkim Arduino Q rzucili do sklepu i oprócz teorii można w końcu zająć się praktyką. Zatem do dzieła.<hr><img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/1-699c0a7c2bb0c820547071.png" class="center" loading="lazy">Najpierw jednak musimy skubnąć odrobinę historii. Po kilku latach od pojawienia się pomysłu na Arduino... A kiedy on się pojawił, tego do końca nie da się określić, bo to nie było tak, że pewnego dnia wymyślono ideę. Umownie około 2005 powstały założenia bliskie współcześnie istniejącym. Więc: pięć lat później zdecydowano się na uporządkowanie zasad i stworzenie standardu. I tak powstało Uno, czyli pierwsze – jako że po raz pierwszy wyznaczało zasady, które odtąd miały już obowiązywać zawsze. Chronologicznie tak naprawdę była to dziewiąta płytka, a bezpośredni poprzednik Uno już od niego wiele się nie różnił.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/2-699c0a79564a4243980444.png" class="center" loading="lazy">Uno miało prawie identyczne trzy wersje, różniące się poprawkami. Oczywiście mowa o oficjalnych płytkach, bo jako że to standard otwarty, kopii powstało mnóstwo i niektóre zasad tak ściśle nie chciały się trzymać. Wszystkie jednak bazowały na ośmiobitowym mikrokontrolerze ATmega 328.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/3-699c0a7fbb64d948443969.png" class="center" loading="lazy">Czas płynął, konkurencja poszła w moce rzędy wielkości większe i Uno, przy wystarczających możliwościach dla zadań typowych dla mikrokontrolerów, jako komputerek jednopłytowy był już archaizmem. W końcu 32 bity wkroczyły na salony w innych seriach, Uno jednak opierało się temu długo. Dopiero trzy lata temu zdecydowano się wybrać kandydata na serce nowego Uno, a stał się nim ARM Cortex M4. Prędkość zegara wzrosła trzykrotnie, pamięć – odpowiednio ośmio- i szesnastokrotnie no i oczywiście sam procesor jest zupełnie inną klasą wydajności. To w wersji podstawowej płytki, o nazwie Uno R4 Minima, ale powstała także widoczna poniżej Uno R4 WiFi, gdzie dołożono drugi procesor, tak naprawdę silniejszy, ESP32.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/4-699c0a7c923a7303091197.png" class="center" loading="lazy">Ideą jest on traktowany jako koprocesor w służbie wymienionego wcześniej, ale nie ma przeszkód, by dobrać się do niego i zlecić mu jakieś ambitniejsze zadania. A ponieważ płytka Uno jest spora jak na potrzeby współczesnych scalaków, postanowiono wypełnić ją matrycą czerwonych diod świecących o organizacji 12x8, pełniących funkcję prymitywnego wyświetlacza.Tak zwane nowe Uno (obecnie już nie nowe) pozwoliło na rzeczy dotąd niedostępne: od obróbki sygnałów, po pracę w chmurze, z którą wersja WiFi integruje się zgrabnie. Kilka projektów związanych z tą płytką pojawiło się już na portalu, ale dziś miałem pisać o najnowszym Arduino, więc do rzeczy.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/5-699c0a7c5e66b753175731.png" class="center" loading="lazy">Nawiązanie współpracy Arduino z Qualcomm zaskoczyło wszystkich, jak również ukazanie się nowej płytki o nazwie Q. Wprawdzie po cichu liczono na nową ideę, ale nastąpiło to wyjątkowo szybko. Na czym owa idea polega? Otóż po to był cały ten wstęp, by zrozumieć dotychczasowy pomysł na Arduino: to po prostu mikrokontroler, dla którego powstał standard programowania w języku C++, ale bez potrzeby pamiętania tych wszystkich adresów rejestrów, liczenia zegarów i zabawy w „asemblery”. Powstała też idea bibliotek, czyli procedur związanych przede wszystkich z peryferiami czy jakimiś bardziej zaawansowanymi obliczeniami, które po prostu karmi się danymi w formie przyjaznej dla ludzi i robią swoje. To sprawia, że na przykład odtwarzanie dźwięku z karty SD wymaga pięciu minut programowania, a nie całego dnia, a do tego zostało przetestowane na dziesiątą stronę.Tymczasem Q, po dwóch dekadach zmieniło zasady. Na płytce mamy teraz dwa bloki, ale nie tak jak w R4, gdzie mikrokontrolerowi służył procesor oferujący usługi sieciowe. Tutaj oba bloki są równie ważne i każdy z nich ma konkretne zadania.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/6-699c0a82815cb923112564.png" class="center" loading="lazy">Pierwszym blokiem jest mikrokontroler Cortex M33, tym razem już pędzący z szybkością 160 MHz, z 2 MB pamięci Flash i 786 kB RAM-u. Jest mikrokontrolerem, a to znaczy, że nadaje się do sterowań czasu rzeczywistego, czyli tego, co robiła ATmega w pierwszym Uno. Co ciekawe, tym razem pracuje na systemie Zephyr, specjalnym systemie operacyjnym czasu rzeczywistego, który już w rodzinie Arduino pojawił się w najnowszych seriach układów.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/7-699c0a812000f988637287.png" class="center" loading="lazy">Drugim blokiem jest zupełnie od niego niezależny mikroprocesor tym razem, czterordzeniowy Cortex A53 pracujący z szybkością 2 GHz, mający do pomocy koprocesor graficzny, 2 GB RAM-u i 16 GB pamięci eMMC. Domyślnie jest tam zainstalowany Linux, konkretnie Debian. Innymi słowy, Arduino Q jest tak naprawdę samodzielnym komputerem. Pytanie: po co dwa bloki? Czy nie dałoby się tego wszystkiego, co oczekuje się po sterownikach klasy Arduino, zrobić za pomocą jednego kontrolera?Nie do końca. W miarę wzrostu złożoności zadań wzrasta także ryzyko opóźnień, zwykle prostych operacji, ale krytycznych czasowo – na przykład sterowania silnikami. W takim przypadku jeden z bloków zajmuje się tylko takimi prostymi zadaniami, drugi zaś ma ogromne moce dla analiz tego, co dostarcza tamten blok, oprogramowanie albo świat zewnętrzny. I na tym polega idea – dwóch partnerów od dwóch rodzajów zadań, którzy współpracują, nie wchodząc sobie w drogę.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/8-699c0a8051225618127846.png" class="center" loading="lazy">Rzućmy sobie okiem na płytkę. Przede wszystkim wymiarami to stare, dobre Uno. Sprawdziłem czy będzie mi pasować <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/plytka-edukacyjna-tme">w płytce edukacyjnej TME,</a> która ma różne przydatne peryferia i pasuje. Otwory na śrubki także. Jeśli chodzi o napięcia, wystawiane są nieco niższe poziomy wysokie, zgodne z logiką 3,3 wolta, natomiast tolerancja dla cyfrowych napięć wejściowych sięga pięciu woltów, więc w zasadzie mamy tutaj pełną zgodność, ponieważ 3,3 wolta mieści się w bezpiecznym zakresie wysokim standardu pięciowoltowego. W przypadku wejść analogowych maksymalne napięcia nie powinny przekraczać 3,6 wolta, więc niektóre projekty mogą wymagać podania niższego napięcia odniesienia bądź założenia dzielników rezystorowych. W każdym razie odpaliłem naprędce jeden ze starszych projektów, który wykorzystuje pokładowy wyświetlacz i wszystko ruszyło bez jakichkolwiek zmian.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/9-699c0a81c0059483041762.png" class="center" loading="lazy">Na górze znajdziemy mikroprocesor Qualcomm QRB2210. Nad nim znajduje się kostka pamięci RAM – 2 GB albo 4 w wersji płytki z większą ilością pamięci. Mały układ po lewej stronie o nazwie ANX7625 łączy sygnały obrazu, dźwięku i danych i przesyła je przez USB. Dzięki temu po zastosowaniu HUB-a z wyjściami na monitor i głośniki możemy stworzyć funkcjonalny komputer: z monitorem, kamerą, klawiaturą i myszą. Równocześnie także układ zarządza energią pozyskiwaną stamtąd, więc to samo złącze służy do zasilania płytki. Układ wspiera rozdzielczość 4k, acz ograniczono się tutaj do pełnego HD, przy czym interfejs zaprojektowano na niższą rozdzielczość: 1280x720 pikseli, bo jest optymalna dla niewielkich monitorów – domyślnie przeznaczonych dla takich rozwiązań.Układ PM4125 widoczny z prawej strony to centrum zarządzania energią. Poszczególne elementy wymagają napięć: 0,6 V, 1,1, 1,8, 3, 3,3 oraz 3,8 więc jeden układ serwujący aż tak duży wachlarz napięć jest niezbędny. Wszystko jest monitorowane i raportowane. Ma on także w strukturze elementy związane z zarządzaniem akumulatorem litowym.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/10-699c0a7ab62c5139946847.png" class="center" loading="lazy">W końcu ta mała, charakterystyczna płytka o nazwie WCBN3536A jest elementem związanym z sieciami bezprzewodowymi: WiFi i BT.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/11-699c0a7bdef76670041689.png" class="center" loading="lazy">Z drugiej strony znajdziemy dwa układy scalone: pamięć eMMC w ilości 16 bądź 32 GB oraz mikrokontroler STM32U585, czyli dziedzictwo starego Arduino. Oczywiście wejście USB jest zgodne z najnowszym standardem 3.1 i wymaga ponadstandardowych trzech amperów. Dlatego powinno się używać ładowarek zgodnych z Power Delivery, acz najprostszych – używających tylko napięcia 5 woltów. Oczywiście ładowarek z możliwością wystawienia napięć wyższych także można używać, tylko po prostu zmarnuje się potencjał.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/12-699c0a7f7c5b9005990498.png" class="center" loading="lazy">Oprócz standardowego złącza Uno mamy trochę nowości. Pominę te o wybitnie serwisowym charakterze. Na spodzie płytki pojawiły się długie, drobne gniazda. Jedno służy do podłączania mediów: przede wszystkim kamer i wyświetlaczy. Drugie wystawia sygnały z procesora i kontrolera i ma charakter uniwersalny, serwując to, co nie zmieściło się na złączach Uno. Mamy także złącze nowego standardu: Qwiic, które służy do łańcuchowego przyłączania kompatybilnych peryferiów używających szyny I2C. Na koniec dodam, że na złączu Uno, wśród wejść analogowych mamy także parę takich wyjść. Ich rozdzielczość sięga 12 bitów, a rozdzielczość wejść poszerzono do 14 bitów.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/13-699c0a8187e9e772733175.png" class="center" loading="lazy">No i na płytce jest coś jeszcze: podobna matryca ledów, jaką można było po raz pierwszy znaleźć w modelu R4, ale troszkę gęściejsza – 13x8, w kolorach niebieskich tym razem i przede wszystkim mogąca pracować ze zmiennym natężeniem jasności. Animacje, mimo niskiej rozdzielczości, wyglądają teraz znakomicie. <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/148-arduino-q-cz-2">W kolejnych artykułach</a> opiszę pierwsze wrażenia po uruchomieniu płytki. Zrobimy to dwa razy, w zupełnie innych warunkach.

[147] Arduino Q cz. 1

000.png

Ostatnio wpadła mi taka rzecz do ręki i jak się okazało, wyświetlacz ten jest bardzo wygodny, bo wymaga tylko czterech przewodów do działania. Portale sprzedażowe zalało właśnie takimi wyświetlaczami. Występują w trzech grupach: czterocyfrowe z dwukropkiem – jak w zegarku, z kropkami – jak w kalkulatorze i sześciocyfrowe. Wyświetlacz jak wyświetlacz, mało to ich? Lecz ten ma trzy konkretne zalety. Po pierwsze: rynek nimi zalało – jak mówiłem, a to znaczy że można śmiało w nie zainwestować i gdy trzeba będzie jutro kupić kolejny, nie znikną tak po prostu z dnia na dzień. Po drugie – kosztują pięć złotych. To akurat normalna cena dla czterech cyferek, ale po trzecie – z drugiej strony przylutowano układ scalony będący interfejsem, który w prosty sposób połączy nam owo cudo z Arduino tylko dwoma liniami sygnałowymi. Tak więc potrzeba czterech przewodów (razem z zasilaniem), co redukuje plątaninę kabli, zajętość portów i jeszcze kosztuje owo pięć złotych. Na dodatek mamy biblioteki w prosty sposób wyświetlające liczby, sterujące jasnością, a jak będzie trzeba, możemy wyświetlić cokolwiek. Zamówiłem więc sobie cztery takie cyferblaty i dziś się nimi pobawię.<hr><img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/21-69789558af7fb505525964.png" class="center" loading="lazy">TM1637 nazywa się układ znajdujący się z tyłu, który odpowiada za atrakcyjność wyświetlacza. Może on sterować sześcioma siedmiosegmentowymi zespołami z kropkami oraz matrycą klawiatury z 16 przyciskami.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/22-69789553ed269472153762.png" class="center" loading="lazy">Układ możemy oczywiście kupić solo i wyrzeźbić sobie własny wyświetlacz, lecz cała frajda polega na tym, że całość jest oferowana już w komplecie w kilku konfiguracjach. Co ciekawe, producenci zupełnie zlekceważyli opcję klawiatury, podobnie jak programiści oferujący biblioteki. Ale jeśli ktoś by potrzebował – da się wykorzystać.Bohater naszego artykułu zawiera cztery cyferki i tylko jedną kropkę dziesiętną, która jest tu dwukropkiem. Na krawędź wysunięto cztery goldpiny (choć nie gold dosłownie), więc połączenie z Arduino Uno <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/plytka-edukacyjna-tme">na płytce edukacyjnej TME</a> jest śmiesznie proste. Co ciekawe, w systemie można używać tych wyświetlaczy jednocześnie więcej – aż się skończą piny. Cyfry okazały się świecić na czerwono na tyle jasno, że w warunkach przyciemnionego pokoju ustawiłem jasność minimalną, a i tak było to zbyt wiele. Zawsze jednak można dołożyć jakiś filtr czerwony. Na początek nawiążmy z wyświetlaczem kontakt, niech się coś pojawi.Jak wszystko, co idealne, idealne nie jest. Wydawałoby się, że to jakieś I2C, a tu bieda – ani adresów, ani kompatybilności. Innymi słowy, dialog z wyświetlaczem trzeba uprawiać na piechotę. Na szczęście wielu już ten język opanowało, a organizacja Arduino rekomenduje bibliotekę TM1637Display. Obsługuje czterocyfrowe wersje i wprowadza kilka poleceń. Tutaj skorzystamy z dwóch, ale po kolei.<pre><code class="language-arduino">#include &lt;TM1637Display.h&gt; // Biblioteka obsługująca układ TM1637\nTM1637Display display(3, 4); // Deklarowanie portów wyświetlacza: CLK, DIO\n\nvoid setup() {\n display.setBrightness(0); // Ustawianie jasności: od zera do 15\n}\n\nvoid loop() {\n for (int x = -999; x &lt; 10000; x++) { // Utwórz pętlę: od -999 do 9999\n display.showNumberDecEx(x, 0); // Wyświetl liczbę (-999...9999), 64 - dwukropek.\n delay(100); // Opóźnienie.\n }\n}</code></pre>Najpierw importujemy bibliotekę, którą trzeba ściągnąć wcześniej z zasobów wydanych oficjalnie. Następnie deklarujemy ten konkretny wyświetlacz, nadając mu nazwę i określając piny dla linii zegara i danych. Można takich wyświetlaczy zadeklarować więcej, nadając im różne nazwy. Na początku zmniejszyłem jasność do zera, co wcale nie wygasza wyświetlacza, tylko wprowadza wypełnienie równe 1/16 poziomu maksymalnego. W pętli głównej będziemy odliczać od -999 do 9999, bo taki zakres wyświetlacz może pokazać za pomocą prostego polecenia showNumberDec. Kolejna linia wyświetla liczbę, która jest zwiększana w pętli, zwiększając ją 10 razy na sekundę. Jeśli chcielibyśmy zobaczyć dwukropek, należy drugą z liczb ustawić na 64 – zaświeci się on mam wówczas. Stąd wersja alternatywna polecenia, z literami Ex na końcu, która obsługuje kropki i dwukropki.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/23-69789557e113e448097614.png" class="center" loading="lazy">Po kompilacji ujrzymy przykładowy stoperek. Możemy zmienić kształt wybranych cyfr, edytując plik biblioteki z rozszerzeniem cpp, ale chyba widoczne tu zadowolą większość. Skoro wszystko działa, czas na jakąś praktyczną realizację urządzenia z takim wyświetlaczem. Postanowiłem przebudować miernik migawek i lamp błyskowych, <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/144-arduino-mierzy-czasy-migawek-aparatow-klasycznych-cz-2">o którym pisałem niedawno.</a> Wykorzystując Arduino Nano czy Mini, za kilkanaście złotych możemy zbudować kompletne urządzenie, używając jedynie czterech przewodów. Ale na razie uruchomię układ z płytką edukacyjną, pozostawiając przed chwilą zestawianą konfigurację i dodając fototranzystor ze wspomnianych artykułów.<pre><code class="language-arduino">#include &lt;TM1637Display.h&gt; // Biblioteka obsługująca układ TM1637\nTM1637Display display(3, 4); // Deklarowanie portów wyświetlacza: CLK, DIO\n\nvolatile unsigned long openingMoment = 0; // Moment otwarcia migawki.\nvolatile unsigned long closingMoment = 0; // Moment zamknięcia migawki.\nvolatile bool isMeasuring = false; // Flaga - ustawiona, jeśli trwa pomiar.\nconst byte phototransistorPort = 2; // Adres portu fototranzystora (2 albo 3)\nconst byte colon[4] = { 0, 128, 0, 0 }; // Tablica dwukropka.\n\nvoid setup() {\n pinMode(phototransistorPort, INPUT); // Deklaruj port fototranzystora jako wejście.\n display.setBrightness(15); // Ustawiaw jasność wyświetlacza (0...15)\n display.setSegments(colon); // Prześlij na wyświetlacz zawartość powyższej tablicy.\n attachInterrupt(digitalPinToInterrupt(phototransistorPort), interrupt, CHANGE); // Włącz przerwania z portu fototranzystora.\n}\nvoid loop() {\n if (closingMoment &gt; 0) { // Jeśli pomiar jest zakończony...\n unsigned long exposureTime = closingMoment - openingMoment; // Policz czas migawki.\n if (exposureTime &lt; 1000000UL) { // Jeśli czas migawki jest krótszy od sekundy...\n display.showNumberDecEx((1000000UL / exposureTime), 0, false, 4, 0); // Wyświetl czas migawki w formie fotograficznej.\n } else { // Jeśli czas migawki jest równy sekundzie lub dłuższy...\n display.showNumberDecEx((exposureTime / 10000), 64, false, 4, 0); // Wyświetl czas migawki z dwoma miejscami po przecinku (dwukropku).\n }\n closingMoment = 0; // Wyzeruj licznik dla kolejnego pomiaru.\n }\n}\nvoid interrupt() {\n if (digitalRead(phototransistorPort) == LOW) { // Jeśli migawka została otwarta...\n if (!isMeasuring) { // Jeśli nie było mierzenia...\n openingMoment = micros(); // Wpisz stan micros do zmiennej momentu otwarcia migawki.\n isMeasuring = true; // Włącz flagę mierzenia.\n }\n } else { // Jeśli migawka została zamknięta...\n if (isMeasuring) { // Jeśli było mierzenie...\n closingMoment = micros(); // Wpisz stan micros do zmiennej momentu zamknięcia migawki.\n isMeasuring = false; // Wyłącz flagę mierzenia.\n }\n }\n}</code></pre>I znowu ideą program różnić się nie będzie jakoś znacząco. Także w przerwaniach mierzymy czas otwarcia migawki, wykorzystując zmienną systemową micros. Jednak zamiast dużego wyświetlacza mamy tylko cztery cyfry z dwukropkiem i trzeba jakoś przeorganizować wizualizację danych. Pozbądźmy się więc wyświetlania w mikrosekundach – bo nie ma dla tej wartości miejsca. Będziemy ukazywać czasy w systemie fotograficznym. Dla tych, które są krótsze od sekundy, będzie się pojawiać wartość mianownika, jak w aparatach. Dla dłuższych czasów – pierwsze dwie pozycje to sekundy, dwie ostatnie – setne jej części. Wykorzystamy dwukropek, by tę wartość przedzielić i jednoznacznie ukazać różnicę między wartościami krótszymi. A ponieważ nie mamy tutaj przecinków, możemy przejść z wartości zmiennoprzecinkowych na liczby naturalne. Takie obliczenia są znacznie szybsze.A teraz konkretnie: na wstępie pojawiła się tablica colon (dwukropek). Użyjemy tu kolejnej funkcji związanej z biblioteką, wyświetlanie dowolnej treści. Coś takiego można uzyskać za pomocą setSegments i ciągu czterech bajtów, adresujących konkretne segmenty. Dwukropek to najstarszy bit drugiego bajtu. Wyświetlimy go zaraz po resecie, co będzie znaczyło oczekiwanie na pierwsze pstryknięcie aparatem.W głównej pętli zaczynamy od ustalenia czasu naświetlania fototranzystora w mikrosekundach. Stanie się to, jeśli pomiar będzie zakończony. I teraz jeśli wartość ta jest mniejsza od miliona, wyświetlimy wynik miliona podzielonego przez czas migawki. Funkcję tę widzieliśmy w poprzednich szkicach, ale doszły tu jeszcze dodatkowe argumenty. Pierwszym więc jest liczba, przypomnę: od -999 do 9999. Drugim – wyświetlenie przecinka, jeśli wstawimy tu 64 albo jego brak, przy zerze. Jeśli trzecia oznacza prawdę, pojawią się zera znaczące, jeśli fałsz – będą tam puste miejsca. Czwarta to liczba cyfr na wyświetlaczu, a piąta – pozycja startowa. Zbędnych danych nie trzeba podawać, ale podobno ich podanie przyspiesza działanie funkcji.Natomiast jeśli zmierzony czas jest równy sekundzie lub ma wartość dłuższą, dzielimy ową wartość przez 10 tysięcy i wyświetlamy, włączając tym razem dwukropek, w ten sposób dostając jeszcze dodatkowy – wizualny podzielnik przez sto. Mamy więc pomiar tych czasów z dokładnością do setnej części sekundy, a zakres do 100 sekund. A co będzie, gdy ów czas przekroczymy? Zginie pozycja setek. Wypadałoby więc wstawić tutaj pułapkę i wyświetlić jakiś symbol przekroczenia zakresu, ale tak długich czasów tym mierzyć nie będziemy, więc tak to zostawiłem. Jeśli ktoś chce mieć elegancko, niech sobie dopisze jeszcze jeden warunek.No właśnie, dokładność powyżej sekundy jest wystarczająca, ale poniżej bardzo marna i zwiększa się ona dopiero przy migawkach rzędu jedna kilkudziesiętna sekundy. Naprawmy to <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/146-praktyczny-wyswietlacz-z-czterema-przewodami-cz-2">w kolejnym artykule.</a>

[145] Praktyczny wyświetlacz z czterema przewodami cz. 1

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

Sprzęt

Przeglądaj wg kategorii

Nasi partnerzy