160.png

Kolejnym generacjom Arduino rośnie rozmiar pamięci – z niegdyś skromnych 32 kB już do megabajtów, lecz w określonych zastosowaniach jest to wciąż mało. I niekoniecznie mowa o przechowywaniu filmów, nawet niewielka ilość komunikatów słownych szybko wykorzysta skromne pokładowe zasoby. Mamy te piękne czasy, że już nie trzeba szukać kostek pamięci i tworzyć im autorskich interfejsów. Wszystkie rozwiązania powszechnie stosowane jeszcze 20 lat temu zastąpiła niepozorna karta SD, a właściwie jej odmiana w rozmiarze microSD. Jej kariera, wraz z innymi typami nośników, zaczęła się jeszcze w wieku XX, w śmiesznie małych – dziś – pojemnościach, w wersji MMC, która z punktu widzenia użytkownika niczym się nie różni. Czas sprawił, że formaty konkurencyjne upadły bądź osiągnęły niszowe zastosowania, zaś SD stało się wszech standardem.Karty te oferują dziś właściwie dowolne pojemności, są tanie, trwałe i szybkie. Dla nas najważniejsze jest to, że wśród protokołów obsługujących je zawsze znajdziemy najprostszy: SPI, który łatwo zintegrować ze środowiskiem Arduino. Nie wykorzystuje on co prawda potencjału szybkości kart, ale w zastosowaniach typowych dla arduinowych rozwiązań czas dostępu jest wystarczający. Obsługę kart wspiera kilka bibliotek, zróżnicowanych pod względem opcji i użytych zasobów. Same zaś karty wymagają tanich czytników, często zintegrowanych z konwerterem napięć, gdyż one same pracują w logice trzywoltowej. W zastosowaniach amatorskich konwersję można przeprowadzić dzielnikami rezystorowymi. Przykładowe rozwiązanie aplikacji odtwarzającej dźwięki zapisane na karcie <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/154-obsluga-kart-sd">przedstawiłem tutaj.</a>

Kolejnym generacjom Arduino rośnie rozmiar pamięci – z niegdyś skromnych 32 kB już do megabajtów, lecz w określonych zastosowaniach jest to wciąż mało. I niekoniecznie mowa o przechowywaniu filmów, nawet niewielka ilość komunikatów słownych szybko wykorzysta skromne pokładowe zasoby. Mamy te piękne czasy, że już nie trzeba szukać kostek pamięci i tworzyć im autorskich interfejsów. Wszystkie rozwiązania powszechnie stosowane jeszcze 20 lat temu zastąpiła niepozorna karta SD, a właściwie jej odmiana w rozmiarze microSD. Jej kariera, wraz z innymi typami nośników, zaczęła się jeszcze w wieku XX, w śmiesznie małych – dziś – pojemnościach, w wersji MMC, która z punktu widzenia użytkownika niczym się nie różni. Czas sprawił, że formaty konkurencyjne upadły bądź osiągnęły niszowe zastosowania, zaś SD stało się wszech standardem.

Brakuje pamięci? Użyj karty!

!4.png

Czas na drugą zabawkę związaną z wykorzystaniem <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/139-arduino-i-mierniki-panelowe-cz-1">miernika panelowego:</a> zbudujemy sobie elektroniczną kostkę do gry. W tym celu podmienię tarczę na inną, nie tylko graficznie, ale też ideą. W wypadku zegara wartości były rozłożone na skali nieliniowo, ale liniowo elektrycznie. Teraz będzie na odwrót: podzieliłem skalę na równe części, co 12 stopni, symetrycznie względem środka i ustawiłem tam pozycje: sześć – jak w kostce do gry, bo będzie to właśnie kostka, tyle że elektroniczna.<hr><img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/14-694bfe326f5c2300659929.png" class="center" loading="lazy">Skrajne pozycje nie są opisane. Po lewej – wiadomo, mamy pozycję spoczynkową. Po prawej – maksymalne wychylenie podczas animacji związanej z losowaniem. Ale konkrety to już zobaczmy w programie.Najpierw jednak uruchomimy kalibrator <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/140-arduino-i-mierniki-panelowe-cz-2">z poprzedniego artykułu</a> i za pomocą potencjometru odpiszemy wartości PWM dla wskazówki ustawionej na wybranych pozycjach. Zapamiętajmy je, przydadzą się za chwilę. A konkretnie tutaj: oto szkic naszej elektronicznej kostki.<pre><code class="language-arduino">const byte miernik = 11; // Adres portu, do którego podłączony jest miernik.\nconst byte losuj = 8; // Przycisk uruchamiający losowanie.\nconst byte kostka[6] = { 41, 74, 107, 139, 174, 208 }; // Wartości "kostki" na panelu miernika.\n\nvoid setup() {\n pinMode(miernik, OUTPUT); // Deklaruj porty.\n pinMode(losuj, INPUT_PULLUP);\n}\nvoid loop() {\n\n if (digitalRead(losuj) == HIGH) { // Jeśli przycisk losowania zostanie wciśnięty...\n analogWrite(miernik, 0); // Przenieś wskazówkę na początek zakresu z pełną szybkością.\n delay(200); // Zaczekaj.\n for (byte x = 0; x &lt; 255; x++) { // Przenieś wskazówkę na koniec zakresu ze zwolnioną szybkością.\n analogWrite(miernik, x);\n delay(3); // Opóźnienie związane ze zwolnioną szybkością.\n }\n analogWrite(miernik, kostka[random(6)]); // Przenieś wskazówkę na wylosowaną pozycję.\n }\n}</code></pre>Wykorzystam teraz środkowy przycisk klawiaturki <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/plytka-edukacyjna-tme">płytki edukacyjnej TME,</a> który będzie włączał „rzut kostką”. Zaraz niżej mamy tablicę, w której siedzą pomierzone wartości.<pre><code class="language-arduino">const byte kostka[6] = { 41, 74, 107, 139, 174, 208 };</code></pre>Gdyby się nam rozkalibrowały, zawsze można je podmienić. W głównej pętli nie będzie się dziać za wiele. Po wciśnięciu przycisku losowania wyzerujemy strzałkę, zaczekamy chwilę, by się ustabilizowała i będziemy ją przesuwać aż do końca zakresu. Wartości opóźnień dobrałem na oko, każdy może sobie wpisać własne. Na końcu do rejestru PWM wpiszemy wylosowaną wartość z tablicy i to już wszystko. Wskazówka pozostanie ustawiona na wylosowanej pozycji do momentu kolejnego wciśnięcia przycisku losującego.Gdyby ktoś myślał, że da się tu oszukiwać – nie ma szans. Wyzwalanie mamy ręczne, więc kolejne losowania nie pozostają ze sobą w jakimkolwiek związku. Na dobrą sprawę w takim wypadku nie potrzeba nawet funkcji random, a wystarczyłoby szybkie liczenie modulo sześć, o rzędy wielkości szybsze od umiejętności człowieka do odliczania stałych interwałów. Przy kilkudziesięciu hercach nikt już nie dałby rady niczego przewidzieć.To tylko przykłady prostych zabawek. W ten sposób można tworzyć różnego rodzaju gry losowe, ruletki i inne urządzenia, bezpieczne jeśli używamy ich w domu i co najwyżej obstawiamy cukierki. A sam miernik możemy użyć do zbudowania minutnika czy wskaźnika jakiejkolwiek wartości mierzonej, z możliwością linearyzowania wyników – jak w ostatnim przykładzie. Rozdzielczość dziesięciobitowa jest w praktyce wystarczająca nawet dla najbardziej precyzyjnych mierników.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/15-694bfe391ec30950705035.png" class="center" loading="lazy">

[142] Arduino i mierniki panelowe cz. 4

20.png

Klawiatura MIDI nie ma aż takiej użyteczności, gdyż zwykle muzycy mają już jakąś klawiaturę. Tutaj raczej rozwiązania takie mogą się przydać do różnego rodzaju wyzwalaczy dźwięków samplowanych, które można zbudować w postaci efektownych konstrukcji scenicznych. Za to tam przydają się tak zwane przydasie MIDI, z których najpopularniejszym – zwłaszcza wśród gitarzystów – są przełączniki efektów. Co prawda tańsze multiefekty są zarazem przełącznikami i rzadko znajdziemy w nich gniazdko MIDI, ale część tych najwyższej klasy stanowi osobny moduł, który należy wyzwalać zdalnie. Niezależnie tak samo bywa z syntezatorami. Gdy utwór wymaga zmiany brzmień między fragmentami, sprawniej zrobić to przełącznikiem nożnym, a nie z panelu instrumentu, wymagającego oderwania rąk od klawiatury. Wróćmy więc do naszego HT700 <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/125-midi-jezyk-nie-tylko-instrumentow-cz-1">z pierwszego artykułu serii</a> i zaprojektujmy kilka wersji przełączników programów. Na początek – wersja najprostsza i przydatna najczęściej, którą ja nazywam zwrotkorefrenem.<hr>Czym jest piosenka, chyba każdy wie. Miewa zwrotki, refreny i czasem chwilę na solo. Bywa często tak, że zwrotki gra się brzmieniem łagodniejszym, refren – bardziej wyrazistym. Albo oba podobnym, a solo zdecydowanie innym. Czy to będzie gitarzysta, czy klawiszowiec, dobrze byłoby, gdyby miał pod nogą przełącznik: puszczony – brzmienie podstawowe, wciśnięty – brzmienie alternatywne.<pre><code class="language-arduino">const byte pstryczek = 8; // Adres pstryczka.\n\nvoid setup() {\n Serial.begin(31250); // Inicjuj port z nietypową szybkością 31250 bps\n pinMode(pstryczek, INPUT_PULLUP); // Deklaruj pin pstryczka jako wejścia podciągnięte wewnętrznie do wysokiego stanu.\n}\nvoid loop() {\n if (digitalRead(pstryczek) == HIGH) { // Jeśli pstryczek został wciśnięty...\n Serial.write(192); // Wyślij komunikat "zmień program" na kanale pierwszym.\n Serial.write(1); // Wyślij pierwszy numer programu.\n delay(50); // Zabezpieczenie na drgające styki.\n while (digitalRead(pstryczek) == HIGH) {} // Czekaj aż przycisk zostanie puszczony.\n Serial.write(192); // Wyślij komunikat "zmień program" na kanale pierwszym.\n Serial.write(0); // Wyślij zerowy numer programu.\n delay(50); // Zabezpieczenie na drgające styki.\n }\n}</code></pre>Program jest ogromnie prosty. Deklarujemy tylko adres przełącznika – ja tu korzystam jak zwykle <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/plytka-edukacyjna-tme">z płytki edukacyjnej TME.</a> Następnie definiujemy szybkość MIDI, pin – jako port wejściowy, a w głównej pętli nadsłuchujemy czy aby przełącznik nie został wciśnięty. Jeśli tak, to wysyłamy komunikat zmień program – jest on dwu, a nie trzybajtowy, jak to było w przypadku włączaniu dźwięków. Zaczyna się od adresu 192 – dla kanału pierwszego, więc taką wartość umieściłem. W drugim bajcie określa się numer programu – od zera do 127. Po wciśnięciu przycisku wyślemy prośbę o włączenie programu pierwszego. Następnie będziemy czekać na puszczenie przycisku i gdy to nastąpi, wyślemy prośbę o włączenie programu zerowego.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/21-68ce8b7b5eb8a619204789.png" class="center" loading="lazy">Jest pewien problem z tymi zerami. Zero w MIDI oznacza zwykle jedynkę na panelu instrumentu, bo programy zwykło się numerować od jedynki, a nie zera. Trzeba o tym pamiętać i brać poprawki na owo przesunięcie. Jak widać, mój instrument ma dziesięć przycisków, ale mamy jeszcze trzy przełączniki, dające w sumie dostęp do 6 banków, czyli 60 programów. Co oznacza, że sensowny zakres wysyłany zawiera się w przedziale 0-59. Wysłanie sześćdziesiątki nie zrobi cudownie kolejnego banku, tylko zostanie zignorowane. Ale różnie to bywa i tę rzecz trzeba sprawdzać w instrukcji obsługi konkretnego urządzenia.W programie znajdziemy jeszcze dwa opóźnienia eliminujące niestabilności przełącznika. Ponieważ my tu tylko zmieniamy brzmienia, takie uproszczenie, czy jak by to powiedzieli niektórzy, marnotrawstwo, jest dopuszczalne. Kompilujemy i teraz wciskanie przycisku na płytce zmienia program, co jest i słyszalne, i widzialne. No i fajnie, ale nie do końca: aktywacja pierwszego programu wymaga trzymania pstryczka. Czasem lepiej byłoby go po prostu wciskać i dostawać zmiany – raz program zero, raz jeden. A więc do dzieła.<pre><code class="language-arduino">const byte pstryczek = 8; // Adres pstryczka.\nbool flaga = false; // Zmienna negowana po każdym wciśnięciu pstryczka.\n\nvoid setup() {\n Serial.begin(31250); // Inicjuj port z nietypową szybkością 31250 bps\n pinMode(pstryczek, INPUT_PULLUP); // Deklaruj pin pstryczka jako wejścia podciągnięte wewnętrznie do wysokiego stanu.\n}\nvoid loop() {\n if (digitalRead(pstryczek) == HIGH) { // Jeśli pstryczek został wciśnięty...\n flaga = !flaga; // Zaneguj tzw. flagę.\n Serial.write(192); // Wyślij komunikat "zmień program" na kanale pierwszym.\n Serial.write(flaga); // Wyślij numer programu zgodny ze stanem flagi (zerowy albo pierwszy).\n delay(50); // Zabezpieczenie na drgające styki.\n while (digitalRead(pstryczek) == HIGH) {} // Czekaj aż przycisk zostanie puszczony.\n delay(50); // Zabezpieczenie na drgające styki.\n }\n}</code></pre>Powołamy do życia zmienną dwustanową, zwaną flagą – i tak ją nazwałem. Po wciśnięciu pstryczka będziemy ją negować, więc po każdym nieparzystym wciśnięciu będzie prawdą – czyli jedynką, a po parzystym – nieprawdą, czyli zerem. Teraz już można będzie ją wysłać jako argument polecenia zmiany programu.Teraz obsługa przycisku działa jak długopis. Raz wciskamy – program pierwszy, drugi raz wciskamy – program zerowy. I tak w kółko. Kilka słów wyjaśnień. Tutaj oczywiście mamy wybór między programem zero i jeden, ale możemy tam wpisać dowolne przesunięcie czy funkcję, by uzyskać dostęp do każdego programu. Przyjęło się jednak ładować użyteczne programy na scenę na najniższych pozycjach, by mieć do nich łatwy dostęp i pewną rutynę: w czasie grania nie ma czasu na zastanawianie się gdzieśmy upchali to właśnie brzmienie, które jest teraz potrzebne.Zróbmy teraz wersję pięciokanałową. Akurat taką, bo mam tyle przełączników na płytce, ale dopasowanie ich liczby będzie bardzo proste.<pre><code class="language-arduino">const byte iloscKlawiszy = 5; // Liczba klawiszy.\nconst byte adresKlawiatury[] = { 5, 4, 8, 7, 6 }; // Adresy klawiszy.\nconst byte numerProgramu[] = { 0, 1, 2, 3, 4 }; // Numery programów przyporządkowane klawiszom w powyższej tablicy.\n\nvoid setup() {\n Serial.begin(31250); // Inicjuj port z nietypową szybkością 31250 bps\n for (byte x = 0; x &lt; iloscKlawiszy; x++) // Dla każdego pstryczka...\n pinMode(adresKlawiatury[x], INPUT_PULLUP); // Deklaruj pin jako wejście podciągnięte wewnętrznie do wysokiego stanu.\n}\nvoid loop() {\n for (byte x = 0; x &lt; iloscKlawiszy; x++) // Wybieraj kolejne klawisze.\n if (digitalRead(adresKlawiatury[x]) == HIGH) { // Jeśli kolejny przycisk został wciśnięty...\n Serial.write(192); // Wyślij komunikat "zmień program" na kanale pierwszym.\n Serial.write(numerProgramu[x]); // Wyślij numer programu.\n delay(50); // Zabezpieczenie na drgające styki.\n while (digitalRead(adresKlawiatury[x]) == HIGH) {} // Czekaj aż przycisk zostanie puszczony.\n delay(50); // Zabezpieczenie na drgające styki.\n }\n}</code></pre>Sięgniemy po wersję z tablicą, która wystąpiła w poprzednim artykule. Przypomnę: będziemy bazować na dwóch równoległych tablicach. W jednej będą spisane adresy pinów, z których zrobimy port klawiatury, w drugiej – numery programów. U mnie – po kolei, ale można tu wpisać cokolwiek.Program bazuje na pętlach powtarzających się tyle razy, ile mamy przycisków, czyli tutaj: pięć. W pierwszej deklarujemy piny, robiąc z nich porty wejściowe, w drugiej, już w zasadniczej części programu, przepytujemy kolejno wszystkie przyciski. Jeśli któryś z nich został wciśnięty, wysyłamy komunikat zmiany programu i jego numer według indeksu drugiej z tablic. Potem jeszcze 50 milisekund przerwy, oczekiwanie na puszczenie przycisku, znowu 50 ms przerwy i powrót do pętli. Zauważmy, że indeksujemy dane zmiennymi lokalnymi, a nie jak poprzednio – globalną, ponieważ nie musimy już korzystać z podprogramu.Działa to znakomicie, ale na scenie, zwłaszcza gdy jest ciemno, dobrze mieć wyraźny podgląd co akurat jest włączone. <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/130-midi-jezyk-nie-tylko-instrumentow-cz-6">W kolejnym artykule</a> zrobimy użytek z diody RGB.

[129] MIDI - język nie tylko instrumentów cz. 5

0.png

O teoretycznych aspektach MIDI pisałem <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/125-midi-jezyk-nie-tylko-instrumentow-cz-1">w poprzednich artykułach.</a> Wiele zawartej tam wiedzy mogło wydawać się niezrozumiałej i zagmatwanej, dlatego od teraz będzie już tylko praktycznie. Przypomnę, że niezbędna będzie platforma sprzętowa, czyli dowolne Arduino, dwa oporniki i gniazdko DIN bo MIDI używa takiego starożytnego gniazdka do porozumiewania się między kolejnymi urządzeniami.<hr><img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/1-68ce8b7b72995880518285.png" class="center" loading="lazy">Ścieżka sygnału wygląda następująco: z pinu pierwszego, czyli portu TX, przez rezystor 220Ω do piątego styku gniazdka MIDI OUT. Czwarty styk tego gniazdka, przez taki sam rezystor 220Ω połączony jest z pięcioma woltami. Gdyby ktoś używał Arduino standardu trzywoltowego, rezystory powinny mieć 33Ω. I to całe lutowanie, prościej chyba się nie da.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/2-68ce8b7bad39e442756766.png" class="center" loading="lazy">Polecam jeszcze pewien dodatek: równolegle do styków dobrze dołożyć ultrajasną diodę czerwoną przez rezystor 3,3kΩ. Nie wpłynie ona zupełnie na pracę urządzeń, a uwidoczni przepływające komunikaty mruganiem. Bywa to przydatne, gdy coś nie gra i nie wiemy gdzie jest problem.Jak zwykle nasze ćwiczenia będę wykonywał, używając <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/plytka-edukacyjna-tme">płytki edukacyjnej TME,</a> ale to ze względu na wyposażenie jej w wyświetlacz, przyciski i resztę elementów. Każdy może sobie takie peryferia dołączyć do własnych rozwiązań. Zacznijmy więc od rzeczy najprostszej: klawiaturki MIDI. Tutaj powrócę <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/063-pwm-i-piski">do artykułu,</a> w którym prezentowałem ideę prościutkiego instrumentu wykorzystującego funkcję tone, która służy do wydawania dźwięków przez Arduino. Mając pięć przycisków, możemy zbudować bardzo prostą klawiaturę, ale da się na niej zagrać na przykład krakowski hejnał.<pre><code class="language-arduino">const byte g3 = 5; // Adres pstryczka włączającego dźwięk g3\nconst byte c4 = 4; // c2\nconst byte e4 = 8; // e2\nconst byte g4 = 7; // g2\nconst byte c5 = 6; // c3\n\nvoid setup() {\n Serial.begin(31250); // Inicjuj port z nietypową szybkością 31250 bps\n pinMode(g3, INPUT_PULLUP); // Deklaruj linie pstryczków jako wejścia podciągnięte wewnętrznie do wysokiego stanu.\n pinMode(c4, INPUT_PULLUP);\n pinMode(e4, INPUT_PULLUP);\n pinMode(g4, INPUT_PULLUP);\n pinMode(c5, INPUT_PULLUP);\n}\nvoid loop() {\n while (digitalRead(g3) == HIGH) { // Jeśli przycisk został wciśnięty...\n noteOn(55); // Włącz nutę.\n while (digitalRead(g3) == HIGH) {}; // Czekaj aż przycisk zostanie puszczony.\n noteOff(55); // Wyłącz nutę.\n }\n while (digitalRead(c4) == HIGH) {\n noteOn(60);\n while (digitalRead(c4) == HIGH) {};\n noteOff(60);\n }\n while (digitalRead(e4) == HIGH) {\n noteOn(64);\n while (digitalRead(e4) == HIGH) {};\n noteOff(64);\n }\n while (digitalRead(g4) == HIGH) {\n noteOn(67);\n while (digitalRead(g4) == HIGH) {};\n noteOff(67);\n }\n while (digitalRead(c5) == HIGH) {\n noteOn(72);\n while (digitalRead(c5) == HIGH) {};\n noteOff(72);\n }\n}\nvoid noteOn(byte wysokoscNuty) { // Włącz nutę o wysokości note.\n Serial.write(144); // Wyślij komunikat "włącz nutę" na kanale pierwszym.\n Serial.write(wysokoscNuty); // Wyślij wysokość nuty.\n Serial.write(64); // Wyślij głośność nuty.\n}\nvoid noteOff(byte wysokoscNuty) { // Wyłącz nutę o wysokości note.\n Serial.write(128); // Wyślij komunikat "wyłącz nutę" na kanale pierwszym.\n Serial.write(wysokoscNuty); // Wyślij wysokość nuty.\n Serial.write(0); // Wyślij głośność nuty.\n}</code></pre>Tak więc na początku ponazywamy kolejne klawisze zgodnie ze skalą muzyczną. Początek programu zainicjuje port z nietypową szybkością wymaganą przez MIDI i zadeklaruje klawiaturę.W głównej pętli spotkamy pięć bliźniaczych bloków. W każdym najpierw będziemy badać, czy dany przycisk nie został wciśnięty. Jeśli tak będzie, przejdziemy do podprogramu obsługującego komunikat włączenia nuty noteOn, przekazując jej wysokość. Tam przechwycimy wartość wysokości i wyślemy trzy bajty: komunikat włączenia nuty na kanale pierwszym, dane o tym która nuta ma być włączona i bajt głośności, czy raczej szybkości wciskania klawisza. Nasze przyciski są prościutkie, więc tutaj szybkość zawsze będzie interpretowana tak samo. Przyjąłem wartość środkową, czyli 64.Następnie, już w głównej pętli, będziemy oczekiwać na puszczenie przycisku i jeśli to nastąpi, udamy się do podprogramu obsługującego wyłączenie grającego dźwięku. Jest on bliźniaczy, tylko ma przesunięty adres o 16 w dół, bo taki offset mają komunikaty Note Off. No i wartość głośności jest ignorowana – przyjęło się wysyłać zero.Oczywiście jeśli klawisz będzie pozostawiony w spokoju, program przejdzie do kolejnego bloku i tak do końca. Właściwie to moglibyśmy ten program już skompilować, ale… No właśnie, chyba już najwyższy czas przejść na wyższy poziom programowania. Ten szkic jest prosty do analizy przez początkujących, ale ma mnóstwo powtarzalnych elementów. Spróbujmy wyeliminować dłużyzny na rzecz tablic i indeksów.<pre><code class="language-arduino">const byte iloscKlawiszy = 5; // Liczba klawiszy.\nconst byte adresKlawiatury[] = { 5, 4, 8, 7, 6 }; // Adresy klawiszy.\nconst byte wysokoscNuty[] = { 55, 60, 64, 67, 72 }; // Wysokości nut przyporządkowane klawiszom w powyższej tablicy.\nbyte indeks; // Zmienna licznika kolejnych pozycji tablic.\n\nvoid setup() {\n Serial.begin(31250); // Inicjuj port z nietypową szybkością 31250 bps\n for (indeks = 0; indeks &lt; iloscKlawiszy; indeks++) // Dla każdego pstryczka...\n pinMode(adresKlawiatury[indeks], INPUT_PULLUP); // Deklaruj pin jako wejście podciągnięte wewnętrznie do wysokiego stanu.\n}\nvoid loop() {\n for (indeks = 0; indeks &lt; iloscKlawiszy; indeks++) // Wybieraj kolejne klawisze.\n if (digitalRead(adresKlawiatury[indeks]) == HIGH) { // Jeśli kolejny przycisk został wciśnięty...\n noteOn(); // Włącz nutę.\n while (digitalRead(adresKlawiatury[indeks]) == HIGH) {} // Czekaj aż przycisk zostanie puszczony.\n noteOff(); // Wyłącz nutę.\n }\n}\nvoid noteOn() { // Włącz nutę.\n Serial.write(144); // Wyślij komunikat "włącz nutę" na kanale pierwszym.\n Serial.write(wysokoscNuty[indeks]); // Wyślij wysokość nuty.\n Serial.write(64); // Wyślij głośność nuty.\n}\nvoid noteOff() { // Wyłącz nutę.\n Serial.write(128);\n Serial.write(wysokoscNuty[indeks]);\n Serial.write(0);\n}</code></pre>Tablice oczywiście już pojawiały wielokrotnie i zawierały elementy, które były wyciągane po kolei – zwykle były to składniki obrazu czy dźwięku. Tymczasem możemy zeń korzystać częściej, wstawiając tam także zmienne innego charakteru. Na przykład – adresy klawiszy. Zwróćmy uwagę na to, że w naszym programie zachodzi ścisła zależność między adresem klawisza i wysokością nuty. Ale zarówno jedno jak i drugie nie da się opisać żadnym prostym wzorem, gdyż są to wartości niekolejne. Innymi słowy, i przyciski nie mają sensownej kolejności, i wysokości dźwięków, które mają wydawać. I właśnie do takich spraw najlepsze są tablice. Przeanalizujmy program.<pre><code class="language-arduino">const byte iloscKlawiszy = 5; // Liczba klawiszy.\nconst byte adresKlawiatury[] = { 5, 4, 8, 7, 6 }; // Adresy klawiszy.\nconst byte wysokoscNuty[] = { 55, 60, 64, 67, 72 }; // Wysokości nut przyporządkowane klawiszom w powyższej tablicy.\nbyte indeks; // Zmienna licznika kolejnych pozycji tablic.</code></pre>Gdzie tablice, tam indeks, czyli wskaźnik pozycji bieżącej. A gdzie indeks, tam maksimum, czyli ilość przycisków. Indeks się zmienia, maksimum jest stałe. W tablicy adresów klawiatury zamieściłem te same wartości, co poprzednio. Zauważmy, że nie mają już muzycznych nazw, bo nie ma takiej potrzeby. W drugiej tablicy siedzą wysokości nut, w kolejności wpisanych wcześniej adresów przycisków.<pre><code class="language-arduino">for (indeks = 0; indeks &lt; iloscKlawiszy; indeks++) // Dla każdego pstryczka...\n pinMode(adresKlawiatury[indeks], INPUT_PULLUP); // Deklaruj pin jako wejście podciągnięte wewnętrznie do wysokiego stanu.</code></pre>We wstępnej części programu – nowość: zamiast wstawiać pięć bliźniaczych deklaracji, mamy pętlę wykonującą się pięć razy, wyłuskującą kolejne adresy przycisków i ustawiające je jako porty wejściowe.<pre><code class="language-arduino">for (indeks = 0; indeks &amp;lt; iloscKlawiszy; indeks++) // Wybieraj kolejne klawisze.\n if (digitalRead(adresKlawiatury[indeks]) == HIGH) { // Jeśli kolejny przycisk został wciśnięty...\n noteOn(); // Włącz nutę.\n while (digitalRead(adresKlawiatury[indeks]) == HIGH) {} // Czekaj aż przycisk zostanie puszczony.\n noteOff(); // Wyłącz nutę.\n }</code></pre>W głównej pętli mamy bliźniaczą pętlę, tylko teraz sprawdzamy każdy przycisk według indeksu, czy aby nie został wciśnięty. Jeśli tak, przechodzimy do podprogramu wysyłającego komunikat włączenia nuty. Jest identyczny, z tym że nie przekazujemy tym razem wysokości jak poprzednio, a jest ona pamiętana w globalnej zmiennej indeks. Po to właśnie uczyniłem ją globalną na początku.Następnie, dopóki klawisz nie zostanie puszczony, program będzie trwał w pętli i gdy to nastąpi, zostanie uwolniony i oddelegowany do obsługi wyłączenia nuty. I tak dalej, dla wszystkich indeksów, aż dojdziemy do maksimum, czyli ilości klawiszy. A potem od początku. Zauważmy jeszcze, że ubyło nawiasów wąsatych. W pętlach for nie są one niezbędne, jeśli mamy w niej tylko jedną instrukcję, przy czym kolejny for albo if możemy tak traktować. Do tej pory tego nie robiłem, bo zaciemnia to logikę, lecz jesteśmy już pro, więc możemy czynić skróty.Jakie mamy zalety takiego potraktowania problemu? Po pierwsze: program jest krótszy, znacznie. Zajmuje też mniej zasobów, nie jakoś bardzo, bo około pięciu procent, co jest zasługą świetnego kompilatora, ale zawsze to coś. Po drugie, dane o adresach i wysokościach nut siedzą w jednym tylko miejscu. Raz, dwa – można je zmienić. W pierwszym przypadku były porozrzucane i multiplikowane, więc edycja wymagała więcej pracy. No i w końcu pozbyliśmy się nazw własnych klawiatury i powoływania do życia nadmiarowych zmiennych. W tym prostym przypadku nie jest tego dużo, ale dobrze przywyknąć do oszczędności.A wady jakieś są? Owszem. Idea jest nieodporna na złożone zadania. Jeśli każde zdarzenie będzie inne, np. będzie zawierać innego typu komunikat, system bierze w łeb i często metoda „na piechotę” będzie jedyną sensowną. Można też stosować sposób hybrydowy, czyli bliźniaki – jak tu, a wyjątki w dodatkowych warunkach.Skompilujmy kod i pobawmy się trochę. Hejnał możemy zagrać, zwłaszcza jak dołożymy trochę efektów. Ale po chwili odkryjemy, że oba szkice miały wady w założeniach: realizują pracę monofoniczną. Po wciśnięciu któregoś z klawiszy program zamarzał w nieskończonej pętli, do chwili jego puszczenia. Jeśli interesuje nas taka właśnie klawiatura, to oczywiście wszystko jest w porządku, ale to są przypadki rzadkie. Najczęściej potrzeba, by każdy klawisz niezależnie od innych włączał i wyłączał nuty. Zatem czekania w pętlach bez końca są tu wykluczone. Ale za naprawę tego zabierzemy się już <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/128-midi-jezyk-nie-tylko-instrumentow-cz-4">w kolejnym artykule.</a>

[127] MIDI - język nie tylko instrumentów cz. 3

Po nieco przydługim wstępie – krótka wprawka programowa, bo czymże byłoby Arduino bez oprogramowania? Stwórzmy prościutki sekwencer z jedną frazą, głównie po to, by sprawdzić czy mamy kontakt z instrumentem. Oczywiście potrzebny jest tutaj syntezator z wejściem MIDI, ale jeśli ktoś nie posiada – nie ma tragedii.<hr><img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/1-68aee85590b05172117593.png" class="center" loading="lazy">Wystarczy najprostszy interfejs MIDI i jakikolwiek komputer z oprogramowaniem, który sygnały z tego złącza wyśle do softwarowego syntezatora MIDI. Jeden taki mamy w systemie obowiązkowo i jest to uproszczony moduł GS Rolanda. Instrumentów wirtualnych VST są tysiące i większość darmowych, więc jest w czym wybierać. Ale to temat na inny artykuł, więc wróćmy do sedna.<pre><code class="language-arduino">void setup() {\n&nbsp; Serial.begin(31250); &nbsp;// Inicjuj port z nietypową szybkością 31250 bps\n}\nvoid loop() {\n&nbsp; zagraj(43, 43); &nbsp;// Wyślij parę nut - dla kanału arpeggiatora i basowego.\n&nbsp; zagraj(62, 0); &nbsp; // Nuta o wysokości 0 będzie ignorowana.\n&nbsp; zagraj(65, 55);\n&nbsp; zagraj(67, 0);\n}\nvoid zagraj(byte arpeggio, byte bas) { &nbsp;// Pozyskaj obie wysokości nut.\n&nbsp; Serial.write(145); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Wyślij komunikat "włącz nutę" na kanale drugim (arpeggiatora).\n&nbsp; Serial.write(arpeggio); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Wyślij wysokość nuty.\n&nbsp; Serial.write(64); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Wyślij głośność nuty.\n&nbsp; if (bas != 0) { &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Jeśli nuta nie ma wysokości zerowej...\n&nbsp; &nbsp; Serial.write(146); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Wyślij komunikat "włącz nutę" na kanale trzecim (basowym).\n&nbsp; &nbsp; Serial.write(bas); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Wyślij wysokość nuty.\n&nbsp; &nbsp; Serial.write(64); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Wyślij głośność nuty.\n&nbsp; }\n&nbsp; delay(100); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Wprowadź opóźnienie, stanowiące o tempie arpeggia.\n&nbsp; Serial.write(129); &nbsp; &nbsp; &nbsp; // Wyślij komunikat "wyłącz nutę" na kanale drugim (arpeggiatora).\n&nbsp; Serial.write(arpeggio); &nbsp;// Wyślij wysokość nuty.\n&nbsp; Serial.write(0); &nbsp; &nbsp; &nbsp; &nbsp; // Wyślij głośność nuty.\n&nbsp; if (bas != 0) { &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Jeśli nuta nie ma wysokości zerowej...\n&nbsp; &nbsp; Serial.write(130); &nbsp; &nbsp; // Wyślij komunikat "wyłącz nutę" na kanale trzecim (basowym).\n&nbsp; &nbsp; Serial.write(bas); &nbsp; &nbsp; // Wyślij wysokość nuty.\n&nbsp; &nbsp; Serial.write(0); &nbsp; &nbsp; &nbsp; // Wyślij głośność nuty.\n&nbsp; }\n}</code></pre>Jak pisałem w poprzednim artykule, nie będzie żadnych bibliotek. Zaczniemy od zainicjowania portu z tą nietypową szybkością równą 31250 bps. Arduino pozwala na taką. Co ciekawe, użyjemy portu, który służy programowaniu płytki. Konfliktu jednak nie będzie i wszystko zadziała.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/2-68aee85699a27521969360.png" class="center" loading="lazy">W pętli głównej będziemy wystawiać cztery pary nut, a w podprogramie przechwytywać owe wartości i wysyłać je najpierw na kanał drugi, który nazwałem arpeggiatorem, a potem na trzeci – basowy, bo moje Casio obsługuje trzy kanały, czyli jak gdyby siedzą w nim trzy niezależne instrumenty. Ponieważ basu chcę mniej, zastawiłem pułapkę na wysokość zerową. Jeśli taką napotkam, nutka nie zagra wcale. Po zagraniu jednej lub obu nut poczekamy 100 ms, wyłączymy je i wrócimy do pętli. Kompilujemy i… Dokładnie tę samą sekwencję, którą można pobrać z załącznika, stworzyłem blisko 40 lat temu, na tym samym instrumencie. Ależ nostalgia! :)<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/3-68aee85687dc8261203321.png" class="center" loading="lazy">

[126] MIDI - język nie tylko instrumentów cz. 2

137.png

Powszechnie uważa się, że dzieciom warto pokazywać „dorosłą” naukę jak najwcześniej, ale w sposób dla nich przystępny. A ową przystępność zapewnia zabawa i nawiązywanie do rozwiązań istniejących w życiu, którym nie tylko można się przyjrzeć, ale i mieć na nie wpływ. A takimi są na pewno światła na skrzyżowaniach. Tutaj edukacja obejmuje jeszcze naukę zachowań w takich miejscach, a zaraz potem – bezpieczeństwo związane z rowerem czy hulajnogą.Światła na skrzyżowaniu pojawiły się <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/060-swiatla-na-skrzyzowaniu">w jednym z artykułów,</a> gdzie to prezentowałem zarazem potencjał maleńkiej kostki ATtiny, wystarczającej dla takiego prostego symulatora. Jak widać, model świateł jest popularną zabawką edukacyjną, tworzoną jeszcze od czasów układów TTL czy nieśmiertelnego timera 555. W rozwiązaniu prezentowanym niedawno na portalu Arduino przestawiono system rozbudowany, z wyświetlaczem odliczającym czas i trzema sygnalizatorami. Te mają formę sprytnie zaprojektowanych płytek, z jednej strony wchodzących w płytkę testową, z drugiej – przypominających nieco rzeczywiste sygnalizatory świetlne. Zabawka jest znakomitym pomysłem wejścia w świat Arduino najmłodszych, ale może być także podstawą budowy świateł na makietach.

Powszechnie uważa się, że dzieciom warto pokazywać „dorosłą” naukę jak najwcześniej, ale w sposób dla nich przystępny. A ową przystępność zapewnia zabawa i nawiązywanie do rozwiązań istniejących w życiu, którym nie tylko można się przyjrzeć, ale i mieć na nie wpływ. A takimi są na pewno światła na skrzyżowaniach. Tutaj edukacja obejmuje jeszcze naukę zachowań w takich miejscach, a zaraz potem – bezpieczeństwo związane z rowerem czy hulajnogą.

Symulator skrzyżowania - zabawka edukacyjna dla najmłodszych

Na koniec serii artykułów o współczesnych źródłach dokładnego czasu koniecznie należy omówić najbardziej dziś oczywisty sposób na posiadanie zegarka, czyli pozyskiwanie czasu z sieci. Oczywiście do takich zadań niezbędne będzie Arduino, które z siecią potrafi się porozumieć, ale dziś to nie problem, bo modułów takich jest mnóstwo. Jak zwykle użyję Arduino Uno R4, lecz od razu dodam, że wcale nie jest to konieczne i zaprezentowane przykłady powinny bez problemu pracować z płytkami bazującymi na ESP32, które zresztą siedzi w nowym Uno.<hr>Cóż, na początek – nie będziemy potrzebowali niczego oprócz samej płytki Arduino. Szkic także będzie prosty dzięki bibliotekom robiącym za nas wszystko… no, prawie.<pre><code class="language-arduino">#include &lt;WiFi.h&gt; &nbsp; &nbsp; &nbsp; // Biblioteka obsługująca WiFi\n#include &lt;WiFiUdp.h&gt; &nbsp; &nbsp;// Biblioteka obsługująca protokół UDP\n#include &lt;NTPClient.h&gt; &nbsp;// Biblioteka pobierająca czas z sieci.\n\nconst char* nazwaSieciWiFi = "nazwaSieciWiFi"; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Nazwa sieci WiFi\nconst char* hasloSieciWiFi = "hasloSieciWiFi"; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Hasło sieci WiFi\nconst int przesuniecieCzasu = 7200; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Różnica w sekundach między czasem UTC (dla południka zerowego i czasu zimowego).\nWiFiUDP zrodloCzasu; &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; // Nazwa obiektu dla serwera czasu.\nNTPClient timeClient(zrodloCzasu, "pool.ntp.org", przesuniecieCzasu); &nbsp;// Adres serwera czasu.\n\nvoid setup() {\n&nbsp; Serial.begin(115200); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Inicjuj monitor.\n&nbsp; Serial.print("Lacze sie z siecia WiFi o nazwie ["); &nbsp;// Wyślij tekst.\n&nbsp; Serial.print(nazwaSieciWiFi); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Wyślij nazwę sieci WiFi.\n&nbsp; Serial.print("] ... "); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Wyślij tekst.\n&nbsp; WiFi.begin(nazwaSieciWiFi, hasloSieciWiFi); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Łącz się z siecią WiFi.\n&nbsp; while (WiFi.status() != WL_CONNECTED) { &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Czekaj na połączenie.\n&nbsp; &nbsp; delay(250); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Opóźnienie dla stabilizacji procesu łączenia.\n&nbsp; }\n&nbsp; Serial.println("sukces!"); &nbsp;// Udało się połączyć, wyślij tekst.\n&nbsp; timeClient.begin(); &nbsp; &nbsp; &nbsp; &nbsp; // Inicjuj klienta serwera czasu.\n&nbsp; delay(2000); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Opóźnienie dla ustabilizowania się połączenia.\n}\n\nvoid loop() {\n&nbsp; timeClient.update(); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Pobierz czas z serwera czasu.\n&nbsp; Serial.println(timeClient.getFormattedTime()); &nbsp;// Wyświetl czas.\n&nbsp; delay(1000);\n}</code></pre>Tak więc będą potrzebne trzy: od obsługi WiFi WiFi.h, protokołu UDP WiFiUdp.h i pobierania czasu NTPClient. Pierwsza jest związana z kontrolerem ESP32 siedzącym na płytce Uno R4, bądź – jak wspomniałem – innych płytkach, które wykorzystują tę kostkę. Druga obsługuje protokół UDP. W uproszczeniu to sposób porozumiewania się urządzeń w sieci, który jest prostszy od klasycznego TCP, a przez to bardziej zawodny, ale też mniej zasobożerny i szybszy. Używa się go do zadań niekrytycznych, jak przesyłanie obrazu czy dźwięku, zakładając że jeśli część pakietów przepadnie, to nie będzie tragedii. W tym narzeczu będziemy rozmawiać z serwerem dostarczającym czas.W końcu trzecia z bibliotek tym się właśnie będzie zajmować: pozyskiwaniem czasu z wybranego serwera. Następnie będziemy musieli zadeklarować nazwę sieci WiFi oraz hasło dostępu. Należy wybrać sieć pracującą w niższym paśmie, czyli 2,4 GHz, bo wyższej moduły zwykle nie obsługują.Stała przesuniecieCzasu będzie zawierać – jak sama nazwa wskazuje – przesunięcie w sekundach względem czasu uniwersalnego UTC, czyli wyznaczonego dla południka zerowego i czasu zimowego. W Polsce należy dodać 3600 sekund w zimie bądź 7200 w lecie. To oczywiście można zautomatyzować, ale na razie nie będę się tym zajmować.Kolejno znajdziemy nazwę obiektu dla serwera czasu: zrodloCzasu. Jak zwykle przypominam: dla odróżnienia stałych i zmiennych od funkcji programu i bibliotek, nadaję im polskie nazwy. To oczywiście nie ma znaczenia dla programu i kto chce być bardziej standardowy, może użyć skrótów angielskich.Kolejna linia zawiera: nazwę przed chwilą stworzonego obiektu zrodloCzasu, adres serwera czasu "pool.ntp.org" oraz przesunięcie przesuniecieCzasu, które ustaliliśmy wcześniej dla naszej strefy czasowej i czasu letniego. Jeśli chodzi o adres, ten nie jest jedynym i możemy sobie wybrać któryś z poniższej listy.Serwery firmowe<ul><li>time.windows.com (Microsoft)</li><li>time.apple.com (Apple)</li><li>time.google.com (Google)</li><li>ntp.ubuntu.com (Canonical - Ubuntu)</li></ul>Serwery państwowe<ul><li>north-america.pool.ntp.org (Ameryka Północna)</li><li>europe.pool.ntp.org (Europa)</li><li>ntp1.t-online.de (Niemcy)</li><li>ntp2.ptb.de (Niemcy)</li><li>ntp.nict.jp (Japonia)</li></ul>Polskie serwery<ul><li>0.pl.pool.ntp.org</li><li>1.pl.pool.ntp.org</li><li>2.pl.pool.ntp.org</li><li>3.pl.pool.ntp.org</li></ul>W pewnych wypadkach można ustalić czwarty parametr: interwał aktualizacji. Jeśli go nie podamy, domyślnie przyjmuje wartość 60 sekund.W części wstępnej programu inicjujemy monitor, na który wysyłamy tekst informujący o próbie nawiązania łączności przez WiFi. Będzie się to odbywało w pętli o czasie trwania ¼ sekundy. Gdy uzyskamy połączenie, dostaniemy stosowną informację i będziemy mogli zainicjować kontakt z serwerem. Po zainicjowaniu konieczne jest dwusekundowe opóźnienie. Jego brak zwróci nam pierwszy odczyt fałszywy i opóźniony o kilka sekund.Jesteśmy gotowi, można przejść do głównej pętli. Nic tam prawie nie ma: pierwsza linia pobiera czas z serwera, druga – wysyła sformatowany łańcuch w klasycznej postaci godzin, minut i sekund dzielonych dwukropkami. Opóźnienie zapobiega zasypaniu nas odczytami i to wszystko. Kompilujemy i w oknie monitora możemy zobaczyć coś takiego.<img style="text-align: ; text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/1-68aee4846be85424949167.png" class="center" loading="lazy">Spróbujmy nieco zmodyfikować kod, by otrzymać dane w postaci bardziej użytecznej. Zmodyfikujemy samą główną pętlę, dobierając się już nie do sformatowanego łańcucha, a konkretnych danych: godzin, minut i sekund i teraz formatowanie będziemy przeprowadzać samemu.<pre><code class="language-arduino">void loop() {\n&nbsp; timeClient.update(); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Pobierz czas z serwera czasu.\n&nbsp; byte godzina = timeClient.getHours(); &nbsp;// Pobierz elementy czasu.\n&nbsp; byte minuta = timeClient.getMinutes();\n&nbsp; byte sekunda = timeClient.getSeconds();\n\n&nbsp; if (godzina &lt; 10) Serial.print("0"); &nbsp;// Wstaw zero dla wartości mniejszych od 10\n&nbsp; Serial.print(godzina); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Wyświetl godzinę.\n&nbsp; Serial.print(":"); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Wyświetl dwukropek.\n&nbsp; if (minuta &lt; 10) Serial.print("0");\n&nbsp; Serial.print(minuta);\n&nbsp; Serial.print(":");\n&nbsp; if (sekunda &lt; 10) Serial.print("0");\n&nbsp; Serial.println(sekunda);\n&nbsp; delay(1000);\n}</code></pre>Powołujemy do życia trzy zmienne: godzina, minuta, sekunda i ładujemy do nich dane, za pomocą stosownych komend. Teraz z tych danych formujemy łańcuch dla wyświetlacza, dbając o wiodące zera dla wartości mniejszych od dziesięciu. Po co tak sobie życie utrudniać, skoro poprzednia funkcja dawała nam wszystko od razu? Ano po to, by móc załadować te dane na przykład do zegara RTC. Ale o tym napiszę później, zróbmy użytek z wyświetlacza, który znajduje się <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/plytka-edukacyjna-tme">na płytce edukacyjnej TME.</a><pre><code class="language-arduino">#include &lt;WiFi.h&gt; &nbsp; &nbsp; &nbsp; // Biblioteka obsługująca WiFi\n#include &lt;WiFiUdp.h&gt; &nbsp; &nbsp;// Biblioteka obsługująca protokół UDP\n#include &lt;NTPClient.h&gt; &nbsp;// Biblioteka pobierająca czas z sieci.\n\nconst char* nazwaSieciWiFi = "nazwaSieciWiFi"; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Nazwa sieci WiFi\nconst char* hasloSieciWiFi = "hasloSieciWiFi"; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Hasło sieci WiFi\nconst int przesuniecieCzasu = 7200; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Różnica w sekundach między czasem UTC (dla południka zerowego i czasu zimowego).\nWiFiUDP zrodloCzasu; &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; // Nazwa obiektu dla serwera czasu.\nNTPClient timeClient(zrodloCzasu, "pool.ntp.org", przesuniecieCzasu); &nbsp;// Adres serwera czasu.\n\n#include &lt;Wire.h&gt; &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;// Biblioteka obsługująca magistralę I2C\n#include &lt;hd44780.h&gt; &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; // Biblioteka obsługująca wyświetlacze HD44780\n#include &lt;hd44780ioClass/hd44780_I2Cexp.h&gt; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Dodatek obsługujący wyświetlacze podłączone do ekspandera I2C\nhd44780_I2Cexp lcd(0x20, I2Cexp_MCP23008, 7, 6, 5, 4, 3, 2, 1, HIGH); &nbsp;// Konfiguracja połączeń wyświetlacza LCD\n\nvoid setup() {\n&nbsp; lcd.begin(16, 2); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Inicjuj wyświetlacz LCD\n&nbsp; lcd.setCursor(0, 0); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Ustaw kursor.\n&nbsp; lcd.print("Lacze sie z WiFi"); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Wyślij tekst.\n&nbsp; lcd.setCursor(0, 1); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Ustaw kursor.\n&nbsp; lcd.print(nazwaSieciWiFi); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Wyślij nazwę sieci WiFi.\n&nbsp; WiFi.begin(nazwaSieciWiFi, hasloSieciWiFi); &nbsp;// Łącz się z siecią WiFi.\n&nbsp; while (WiFi.status() != WL_CONNECTED) { &nbsp; &nbsp; &nbsp;// Czekaj na połączenie.\n&nbsp; &nbsp; delay(250); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Opóźnienie dla stabilizacji procesu łączenia.\n&nbsp; }\n&nbsp; timeClient.begin(); &nbsp;// Inicjuj klienta serwera czasu.\n&nbsp; delay(2000); &nbsp; &nbsp; &nbsp; &nbsp; // Opóźnienie dla ustabilizowania się połączenia.\n&nbsp; lcd.clear(); &nbsp; &nbsp; &nbsp; &nbsp; // Wyczyść ekran.\n}\nvoid loop() {\n&nbsp; timeClient.update(); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Pobierz czas z serwera czasu.\n&nbsp; byte godzina = timeClient.getHours(); &nbsp;// Pobierz elementy czasu.\n&nbsp; byte minuta = timeClient.getMinutes();\n&nbsp; byte sekunda = timeClient.getSeconds();\n\n&nbsp; lcd.setCursor(4, 0); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Ustaw kursor.\n&nbsp; if (godzina &lt; 10) lcd.print("0"); &nbsp;// Wstaw zero dla wartości mniejszych od 10\n&nbsp; lcd.print(godzina); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Wyświetl godzinę.\n&nbsp; lcd.print(":"); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Wyświetl dwukropek.\n&nbsp; if (minuta &lt; 10) lcd.print("0");\n&nbsp; lcd.print(minuta);\n&nbsp; lcd.print(":");\n&nbsp; if (sekunda &lt; 10) lcd.print("0");\n&nbsp; lcd.print(sekunda);\n&nbsp; delay(1000);\n}</code></pre>Ogólnie rzecz ujmując, przekierujemy wszystkie przesłania z monitora na wyświetlacz, korzystając z wielokrotnie już przeze mnie prezentowanych sposobów. Przypomnę więc, będą potrzebne trzy kolejne biblioteki: obsługująca magistralę I2C Wire.h, wyświetlacze z układem HD44780 hd44780.h oraz takież, dołączone przez ekspander do magistrali szeregowej hd44780ioClass/hd44780_I2Cexp.h. Zaraz potem skonfigurujemy ten konkretny wyświetlacz: adres, organizację i numery pinów. W programie będziemy odwoływać się do wyświetlacza, zamieniając serial.print na lcd.print Trzeba pamiętać także o podawaniu pozycji, w których mają się pojawiać napisy. Po skompilowaniu kodu możemy się już cieszyć zegarkiem.<img style="text-align: ; text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/2-68aee48501ca2580306217.png" class="center" loading="lazy">Skoro mamy zegar, przydałby się kalendarz. Ale o tym i rozwiązaniu praktycznym zegara pozyskanego z sieci, czyli współpracy z zegarem RTC <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/124-zegar-z-sieci-cz-2">napiszę w drugiej części.</a>

[123] Zegar z sieci cz. 1

<a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/116-rtc-uklady-czasu-rzeczywistego-cz-1">W poprzednim artykule</a> opisałem zagadnienie zegarów RTC i przedstawiłem przykład: układ DS1302. Czas na nieco nowocześniejszy DS1307. Tutaj mamy już klasyczną magistralę I2C, więc potrzeba tylko dwóch linii do rozmów ze scalakiem. Pominę nieistotne dla nas dodatkowe wyjście, na którym może się pojawić jedna z częstotliwości do wyboru: 1 Hz, 4 lub 8 kHz albo częstotliwość kwarcu. Układ posiada 56 bajtów użytkownika, ale wymaga już pięciowoltowego standardu zasilania. Posiada też stały adres magistrali (dziesiętnie: 104), którego nie da się zmienić.<hr><img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/2-685afb236fcde488892373.png" class="center" loading="lazy">Ponieważ układ używa innej magistrali, należy go podłączyć do linii SDA i SCL. Na płytce Uno znajdziemy osobne piny połączone z tą magistralą, ale są to tak naprawdę linie A4 i A5, bo mają one – jak wszystkie inne – wielokrotną funkcjonalność.<img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/1-685afb21bbf60125034663.png" class="center" loading="lazy">Płytka, której tu użyłem zawiera dodatkowo kostkę pamięci EEPROM o rozmiarze 4kB. Można oczywiście użyć jej sobie, ale o tej pamięci kiedyś już pisałem i dziś temat pominę. Kostka nie przeszkadza niczemu i możemy ją zignorować.<pre><code class="language-arduino">#include &lt;DFRobot_DS1307.h&gt; // Biblioteka obsługująca zegar DS1307\nDFRobot_DS1307 zegar; // Deklaracja nazwy zegara.\nconst byte resetujZegar = 5; // Stan wysoki zezwala na reset zegara po resecie Arduino.\n\nvoid setup() {\n pinMode(resetujZegar, INPUT_PULLUP); // Deklaruj port resetu zegara.\n Serial.begin(115200); // Inicjuj monitor.\n while (!(zegar.begin())) { // Inicjuj sensor zegara.\n Serial.println("Brak łączności z układem DS1307"); // Brak łączności.\n delay(1000);\n }\n if (digitalRead(resetujZegar) == HIGH) { // Jeśli podczas resetu Arduino przycisk jest wciśnięty...\n // Metoda pierwsza - wysyłanie ciągu danych.\n unsigned int setTimeBuff[7] = { 57, 59, 23, 2, 31, 12, 2024 }; // Ustaw: sekundy, minuty, godziny, dzień tygodnia, miesiąca, miesiąc, rok.\n zegar.setTime(setTimeBuff); // Wyślij dane do układu zegara.\n // Metoda druga - ustawianie wybranych wartości.\n zegar.setTypeTime(zegar.eSEC, 57); // Sekunda.\n zegar.setTypeTime(zegar.eMIN, 59); // Minuta.\n zegar.setTypeTime(zegar.eHR, 23); // Godzina.\n zegar.setTypeTime(zegar.eDOW, 2); // Dzień tygodnia (1-7, nie jest obliczany wg kalendarza).\n zegar.setTypeTime(zegar.eDATE, 31); // Dzień miesiąca (uwzględniane są lata przestępne).\n zegar.setTypeTime(zegar.eMTH, 12); // Numer miesiąca.\n zegar.setTypeTime(zegar.eYR, 2024); // Rok (pełna, czterocyfrowa liczba).\n }\n}\nvoid loop() {\n Serial.print(zegar.getTypeTime(zegar.eYR)); // Rok (pełna, czterocyfrowa liczba).\n Serial.print("-");\n Serial.print(zegar.getTypeTime(zegar.eMTH)); // Numer miesiąca.\n Serial.print("-");\n Serial.print(zegar.getTypeTime(zegar.eDATE)); // Dzień miesiąca (uwzględniane są lata przestępne).\n Serial.print(" (");\n Serial.print(zegar.getTypeTime(zegar.eDOW)); // Dzień tygodnia (1-7, nie jest obliczany wg kalendarza).\n Serial.print(") ");\n Serial.print(zegar.getTypeTime(zegar.eHR)); // Godzina.\n Serial.print(":");\n Serial.print(zegar.getTypeTime(zegar.eMIN)); // Minuta.\n Serial.print(":");\n Serial.println(zegar.getTypeTime(zegar.eSEC)); // Sekunda.\n delay(1000);\n}</code></pre>Program będzie bardzo podobny, choć oczywiście w szczegółach będzie się różnił. Bibliotek także znajdziemy wiele, zdecydowałem się na firmową od producenta płytki: DFRobot_DS1307.h ponieważ w razie potrzeby wspiera także wspomnianą pamięć. Poza zmianami w deklaracjach związanych z biblioteką, zmienia się także format wyrażeń związanych z komunikacją z zegarem. Jego ustawianie możemy zrealizować na dwa sposoby: ciągiem – jak w poprzednim przykładzie, albo wygodniej, zmienna po zmiennej.<pre><code class="language-arduino">// Metoda druga - ustawianie wybranych wartości.\nzegar.setTypeTime(zegar.eSEC, 57); // Sekunda.\nzegar.setTypeTime(zegar.eMIN, 59); // Minuta.\nzegar.setTypeTime(zegar.eHR, 23); // Godzina.\nzegar.setTypeTime(zegar.eDOW, 2); // Dzień tygodnia (1-7, nie jest obliczany wg kalendarza).\nzegar.setTypeTime(zegar.eDATE, 31); // Dzień miesiąca (uwzględniane są lata przestępne).\nzegar.setTypeTime(zegar.eMTH, 12); // Numer miesiąca.\nzegar.setTypeTime(zegar.eYR, 2024); // Rok (pełna, czterocyfrowa liczba).</code></pre>Dzięki temu możemy ograniczyć się tylko do zerowania sekund bądź ustawiania samego czasu. Odczyt także jest możliwy jednym ciągiem, ale jego użyteczność jest niewielka, bo wynik należy rozbijać na składowe: nie mówię już o realizacji budzika, ale samo formowanie cyfr będzie tego wymagać. W przykładzie zademonstrowałem sposób kolejnego uzyskiwania danych. Przy ich wyświetlaniu, podobnie jak w poprzednim szkicu, musimy pamiętać o dokładaniu zer wiodących dla minut i sekund, inaczej prezentacja czasu będzie wyglądała źle. Trzeba też pamiętać o przesuwaniu pozostałych wartości, w zależności od tego, czy będą jedno, czy dwucyfrowe.Po skompilowaniu układ będzie pracował dokładnie tak samo. Pamiętajmy o wciśnięciu przycisku za pierwszym razem, gdy wstawimy baterię. Oczywiście po odłączeniu zasilania głównego zegar powinien pracować nadal.<img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/3-685afb242040f556198612.png" class="center" loading="lazy">Na koniec zostawiłem sobie nowe Uno. Zawiera ono bowiem w strukturze RTC i grzechem byłoby go nie wykorzystać.<img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/4-685afb244cfd5654526826.png" class="center" loading="lazy">Oczywiście ten element także potrzebuje podtrzymania zasilania baterią i napięcie podaje się go na jeden z trzech dodatkowych pinów, nieistniejących w poprzednich odsłonach Uno.<pre><code class="language-arduino">#include "RTC.h" // Biblioteka obsługująca zegar Uno R4\nconst byte resetujZegar = 5; // Stan wysoki zezwala na reset zegara po resecie Arduino.\n\nvoid setup() {\n pinMode(resetujZegar, INPUT_PULLUP); // Deklaruj port resetu zegara.\n Serial.begin(115200); // Inicjuj monitor.\n while (!Serial) {} // Czekaj dopóki nie będzie połączenia z portem szeregowym.\n RTC.begin(); // Inicjuj sensor zegara.\n if (digitalRead(resetujZegar) == HIGH) { // Jeśli podczas resetu Arduino przycisk jest wciśnięty...\n RTCTime zapiszCzas(31, Month::DECEMBER, 2024, 23, 59, 57, DayOfWeek::TUESDAY, SaveLight::SAVING_TIME_ACTIVE); // Ustaw: dzień miesiąca, miesiąc - słownie, rok, godziny, minuty, sekundy, dzień tygodnia - słownie, czas letni.\n RTC.setTime(zapiszCzas); // Wyślij dane do układu zegara.\n }\n}\nvoid loop() {\n RTCTime odczytajCzas; // Powołaj bufor na czas odczytany z układu RTC.\n RTC.getTime(odczytajCzas); // Załaduj go wartościami.\n Serial.print(odczytajCzas.getYear()); // Rok (pełna, czterocyfrowa liczba).\n Serial.print("-");\n Serial.print(Month2int(odczytajCzas.getMonth())); // Numer miesiąca (wymaga konwersji z reprezentacji tekstowej).\n Serial.print("-");\n Serial.print(odczytajCzas.getDayOfMonth()); // Dzień miesiąca (uwzględniane są lata przestępne).\n Serial.print(" (");\n DayOfWeek dzienTygodnia = odczytajCzas.getDayOfWeek(); // Dzień tygodnia (1-7, nie jest obliczany wg kalendarza, wymaga konwersji z reprezentacji tekstowej).\n Serial.print((int)dzienTygodnia);\n Serial.print(") ");\n Serial.print(odczytajCzas.getHour()); // Godzina.\n Serial.print(":");\n Serial.print(odczytajCzas.getMinutes()); // Minuta.\n Serial.print(":");\n Serial.println(odczytajCzas.getSeconds()); // Sekunda.\n delay(1000);\n}</code></pre>Zegar wraz z biblioteką ma więcej funkcji, między innymi możliwość wybudzenia uśpionej płytki o ustalonym czasie. Pomińmy na razie wszystkie możliwości poza podstawowymi. Biblioteka jest nieco zawiła i kiepsko opisana, toteż chwilę zajęło mi stworzenie kopii logicznej poprzednich szkiców. Ale wszystko już działa jak należy. Jak zwykle importujemy bibliotekę – tym razem RTC.h Samo zapisanie wartości w RTC różni się nie tylko kolejnością, ale też wymogiem określenia miesiąca i dnia tygodnia w postaci ciągów liter. Doszedł dodatkowo parametr czasu letniego.<pre><code class="language-arduino">RTCTime zapiszCzas(31, Month::DECEMBER, 2024, 23, 59, 57, DayOfWeek::TUESDAY, SaveLight::SAVING_TIME_ACTIVE); // Ustaw: dzień miesiąca, miesiąc - słownie, rok, godziny, minuty, sekundy, dzień tygodnia - słownie, czas letni.</code></pre>Odczyt także nie jest klarowny. Wymienione dwie wartości muszą być tłumaczone za pomocą instrukcji zwracającej liczbę. Kiedyś rozwinę temat, natomiast teraz po prostu skompilujmy kod i będziemy się cieszyć działającym zegarem.W każdym przypadku mamy już gotowy moduł do budowy choćby budzika, o którym pisałem niedawno. Dokładność takiego zegara będzie sięgała sekundy na dobę, co jest dużo wyższą wartością od zegara czysto programowego. Wciąż jednak zegar taki należy ustawiać ręcznie i kontrolować wartości przynajmniej raz na miesiąc. Mając WiFi można uzyskiwać zawsze dokładny czas nez ustawiania czegokolwiek. Zresztą nie jest to jedyna metoda, ale o tym napiszę kiedy indziej.

[117] RTC - układy czasu rzeczywistego cz. 2

Czas najwyższy zająć się tak zwanymi zegarami RTC. O czym mowa? Do tej pory źródłem czasu w moich przykładach było samo Arduino i źródło to miało dwie wady: nie było zbyt dokładne i jak brakło prądu, to ustawienia zegara przepadały. Profesjonalnie robi się to inaczej.RTC czyli Real Time Clock to układ scalony zaprojektowany tylko do jednego celu: bycia dokładnym zegarkiem, z własnym zasilaniem, zegarkiem tak oszczędnym, by wymiana baterii była konieczna jak najrzadziej. W praktyce baterie wystarczają na kilka lat i bardziej rozładowują się same z siebie niż z powodu podłączenia do obwodów zegara.<hr>Układy RTC mają zwykle bardzo niewielkie możliwości poza byciem zegarem i najczęściej dysponują dodatkowo kilkudziesięcioma gratisowymi bajtami do własnego zagospodarowania, których stan jest pamiętany dzięki bateryjce. W praktyce układy takie mają formę płytki z obsadką na baterię litową, zwykle 2032, ale zdarzają się mniejsze. Swego czasu jakiś diabeł wymyślił wersje, w których bateria znajdowała się wewnątrz przerośniętej obudowy. Takie zegary siedziały często w płytach głównych w czasach pierwszych Pentium. Problem w tym, że jednak w końcu baterie te wyczerpały się i jedyną metodą naprawy układu jest jego rozwiercenie, odłączenie martwego ogniwa – za pomocą miniaturowej szlifierki i podłączenie baterii z zewnątrz.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/4-685af8bc13203006413256.png" class="center" loading="lazy">Jedna z płyt z wczesnym Pentium przeszła u mnie udaną operację i służy mi w retro eksperymentach. Dziś jednak używa się nowocześniejszych układów, najczęściej z którymś ze współczesnych interfejsów. Wybrałem sobie dwie kostki i nimi teraz się zajmiemy.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/1-685af8bb642c6981822188.png" class="center" loading="lazy">Oto układ DS1302 wraz z towarzyszącym koszyczkiem na pastylkową baterię litową. Na płytce znajdziemy jeszcze typowy kwarc zegarkowy o częstotliwości 32768 Hz, czyli 2 do potęgi 15. Dlaczego tyle? To, że jest to potęga dwójki jest oczywiste: łatwo z tego uzyskać impulsy sekundowe. Wartość natomiast została wybrana kompromisowo, ze względu na zużycie energii, wymiary i specjalizację ogólnoświatową, dzięki czemu kwarce te są tanie i dokładne, mimo stosunkowo niskiej częstotliwości rezonansowej.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/2-685af8bb801f9864876851.png" class="center" loading="lazy">Mają charakterystyczną postać małej rurki i znajdziemy ten kształt w każdym zegarku elektronicznym czy urządzeniu używającym takiego zegara. Układ zlicza impulsy, by udostępnić czas: od sekund do lat, uwzględniając lata przestępne. Pozwala także zachować 31 bajtów użytkownika, zwykle konfiguracji urządzenia, loginów czy haseł i pracuje w szerokim zakresie napięć: od 2 do 5 i pół wolta.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/3-685af8ba7092b400536975.png" class="center" loading="lazy">Zasilanie rozwiązano tu sprytnie: mamy dwa wejścia, jedno jest przypisane baterii, akumulatorowi lub superkondensatorowi. Drugie – linii zasilającej. Dopóki drugie napięcie będzie wyższe od pierwszego, będzie zasilać całość. Domyślnie operacje zapisu i odczytu wykonujemy wówczas, gdy tak właśnie będzie, więc prąd zasilający z wejścia bateryjnego będzie bardzo mały.Wartości trochę nieszczęśliwie przechowywane są w kodzie BCD. To znaczy pojedyncze sekundy na czterech najmłodszych bitach, dziesiątki – na trzech starszych i tak dalej.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/5-685af8bb347f8912132300.png" class="center" loading="lazy">Z drugiej strony, wyłuskiwane wartości można wprost wysyłać na wyświetlacze, co czasem upraszcza kod programu. Zegar może pracować także w systemie dwunastogodzinnym i wówczas jeden z bitów określa czy mamy poranek, czy wieczór. Ciekawie wygląda sprawa z dniem tygodnia. Ponieważ niektórzy uważają, iż pierwszym jest niedziela, a inni – poniedziałek, nie zdefiniowano tu co jest czym. Po prostu o północy zwiększa się licznik modulo siedem, a już programista ustala sobie czy jedynka to poniedziałek, czy niedziela. Z tego powodu nie mamy tu magicznego kalendarza, który określi dzień tygodnia dla daty i numer dnia tygodnia należy wpisywać ręcznie przy ustawianiu zegara. Czas na realizację programową. Jak zwykle nie będziemy tego programować ręcznie, bo skoro istnieje biblioteka – dlaczego by z niej nie skorzystać?<pre><code class="language-arduino">#include &lt;virtuabotixRTC.h&gt; // Biblioteka obsługująca zegar DS1302\nvirtuabotixRTC zegar(6, 7, 8); // Piny, kolejno: CLK, DAT, RST\nconst byte resetujZegar = 5; // Stan wysoki zezwala na reset zegara po resecie Arduino.\n\nvoid setup() {\n pinMode(resetujZegar, INPUT_PULLUP); // Deklaruj port resetu zegara.\n Serial.begin(115200); // Inicjuj monitor.\n if (digitalRead(resetujZegar) == HIGH) { // Jeśli podczas resetu Arduino przycisk jest wciśnięty...\n zegar.setDS1302Time(57, 59, 23, 2, 31, 12, 2024); // Ustaw: sekundy, minuty, godziny, dzień tygodnia, miesiąca, miesiąc, rok.\n }\n}\nvoid loop() {\n zegar.updateTime(); // Funkcja ładująca dane z układu DS1302 do bufora.\n Serial.print(zegar.year); // Rok (pełna, czterocyfrowa liczba).\n Serial.print("-");\n Serial.print(zegar.month); // Numer miesiąca.\n Serial.print("-");\n Serial.print(zegar.dayofmonth); // Dzień miesiąca (uwzględniane są lata przestępne).\n Serial.print(" (");\n Serial.print(zegar.dayofweek); // Dzień tygodnia (1-7, nie jest obliczany wg kalendarza).\n Serial.print(") ");\n Serial.print(zegar.hours); // Godzina.\n Serial.print(":");\n Serial.print(zegar.minutes); // Minuta.\n Serial.print(":");\n Serial.println(zegar.seconds); // Sekunda.\n delay(1000);\n}</code></pre>Bibliotekę o nazwie virtuabotixRTC.h należy sobie ściągnąć z sieci, bo w zestawieniu bibliotek w Arduino Uno nie znajdziemy jej. Wymaga nazwania zegara – oczywiście nazwałem go zegar i zadeklarowania linii zegara, danych i restartu. Szkic jest prosty i stanowi tak naprawdę tylko przykład do implementacji we własnych rozwiązaniach. Toteż demonstruje jedynie dwa elementy: programowanie czasu i jego odczyt.<pre><code class="language-arduino">zegar.setDS1302Time(57, 59, 23, 2, 31, 12, 2024); // Ustaw: sekundy, minuty, godziny, dzień tygodnia, miesiąca, miesiąc, rok.</code></pre>W pierwszym przypadku należy podać ciąg liczb w kolejności: sekundy, minuty, godziny, dzień tygodnia – umownie, jak mówiłem, dzień miesiąca, miesiąc i rok. W pętli głównej będziemy wyłuskiwać elementy zegara za pomocą zdefiniowanych przez twórcę biblioteki komend. Wysyłam je raz na sekundę na monitor. W nawiasie siedzi sobie dzień tygodnia.Program działa, ale po resecie zawsze ustawia ostatnie sekundy sylwestra – bo tak mu kazałem dla przykładu. A przecież dobrze byłoby na chwilę odłączyć zasilanie i zobaczyć, czy zegar nadal będzie pracować. Jednak każdorazowy reset ustawia wartości domyślne. Dlatego wprowadziłem dodatkowy element – wykorzystując przycisk na mojej <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/plytka-edukacyjna-tme">płytce edukacyjnej TME.</a> Teraz zaprogramowanie zegara wartościami domyślnymi będzie możliwe wyłącznie z chwilą, gdy podczas resetu ten przycisk będzie wciśnięty. Zresetujmy więc ustawienia i odłączmy zasilanie na kilka minut. Jeśli po ponownym uruchomieniu zegara, nie dotykając przycisku, uzyskamy wyniki kilka minut późniejsze – znaczy zegarek działa i bateria jest sprawna.<a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/117-rtc-uklady-czasu-rzeczywistego-cz-2">W kolejnym artykule</a> przedstawię inny nieco układ: DS1307 oraz RTC siedzące w nowym Arduino Uno R4.

[116] RTC - układy czasu rzeczywistego cz. 1

122.png

Czym jest MIDI? To standardowy interfejs instrumentów muzycznych i innych urządzeń związanych z produkcją muzyki i sceną. Wkrótce opiszę go dokładniej i poznamy kilka urządzeń wykorzystujących tę magistralę. A tytułem zapowiedzi – słówko tylko. MIDI zostało zdefiniowane na samym początku lat osiemdziesiątych i z założenia miało być odporne na ogromną ilość zakłóceń towarzyszących estradzie, pochodzących zwłaszcza od świateł scenicznych, regulowanych wówczas zwykle tyrystorami. Jedyna technologia, która dawała sobie radę, a nie była zbyt droga to pętla prądowa i izolacja galwaniczna. Przepływ prądu o natężeniu 5 mA lub jego brak reprezentował zera i jedynki, a każde urządzenie zawierało na wejściu transoptor zasilany owym prądem, eliminując problemy z pętlami masy, a także niebezpieczeństwa porażeń przy rozłączaniach.Szybkość ustalono na 31250 bps, co było wartością niestandardową, na tyle jednak szybką, by uniknąć słyszalnych opóźnień, a jednocześnie na tyle wolną, by móc użyć elementów tanich. Najciekawsze, że MIDI, które ma już 45 lat, wiąż żyje i ma się dobrze, a typowe dla tego formatu gniazdka DIN spotyka się obowiązkowo w każdym szanującym się sprzęcie muzycznym. Komputery najczęściej pracują z MIDI za pomocą konwerterów z USB, zwykle mieszczącym się na kablu.MIDI służy do włączania i wyłączania dźwięków – zgodnie z klawiaturą instrumentów, ale także do zdalnego operowania manipulatorami, zmianą programów i konfiguracji i ma bardzo wiele innych zastosowań, bo jest systemem otwartym. Jeśli czegoś nie uwzględniono w standardzie, zawsze można to dodać za pomocą niestandardowych łańcuchów danych o dowolnym formacie. MIDI służy więc zarówno do zdalnej kontroli w czasie rzeczywistym jak również do rejestracji wszystkich ruchów muzyka i odtwarzania ich w dowolnym czasie. Ale MIDI to nie tylko świat dźwięków i w późniejszym terminie dowiemy się jak za pomocą urządzeń MIDI obrabiać zdjęcia w Lightroomie.

Czym jest MIDI? To standardowy interfejs instrumentów muzycznych i innych urządzeń związanych z produkcją muzyki i sceną. Wkrótce opiszę go dokładniej i poznamy kilka urządzeń wykorzystujących tę magistralę. A tytułem zapowiedzi – słówko tylko. MIDI zostało zdefiniowane na samym początku lat osiemdziesiątych i z założenia miało być odporne na ogromną ilość zakłóceń towarzyszących estradzie, pochodzących zwłaszcza od świateł scenicznych, regulowanych wówczas zwykle tyrystorami. Jedyna technologia, która dawała sobie radę, a nie była zbyt droga to pętla prądowa i izolacja galwaniczna. Przepływ prądu o natężeniu 5 mA lub jego brak reprezentował zera i jedynki, a każde urządzenie zawierało na wejściu transoptor zasilany owym prądem, eliminując problemy z pętlami masy, a także niebezpieczeństwa porażeń przy rozłączaniach.

MIDI

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

Początkujący

Przeglądaj wg kategorii

Nasi partnerzy