185.png

Wkrótce będzie można się spodziewać wysypu instrumentów wirtualnych bazujących na Arduino Q, które ma wystarczający potencjał mocy, by zrealizować nawet skomplikowane, polifoniczne syntezatory. Pierwsze jaskółki już powstają, a wobec instrumentów wirtualnych wykorzystujących komputery, tutaj mamy dodatkowo baterię portów, które mogą tworzyć interfejs potencjometrów, przycisków, klawiatur muzycznych, enkoderów i wszystkiego tego, co występuje we współczesnych syntezatorach. Z pomocą AI prawdopodobnie w najbliższym czasie powstaną liczne otwartoźródłowe aplikacje najróżniejszych instrumentów, dotąd kosztujących spore pieniądze. Pierwsze jaskółki już się pojawiają, z wykorzystaniem modułu Q oraz manipulatorów w standardzie Qwiic można zbudować prostą <a href="https://projecthub.arduino.cc/Arduino_Genuino/diy-synth-a794df">maszynę perkusyjną.</a>

Nowe Arduino sercem instrumentów

03.png

31.png

Nasz pong jest grywalny, ale ubogi graficznie. Spróbujmy narysować boisko – jak w oryginalnych grach sprzed połowy wieku. Dodamy sobie podprogram, który wyrysuje kontur i osadzimy odwołanie tam, gdzie już odwołujemy się do rysowania paletek i piłki

[177] Pong na oscyloskopie cz. 3

183.png

Czy da się sterować dziewięciuset diodami WS2812 jednym modułem Arduino? Zapewne jest to możliwe nawet dla ośmiobitowego Uno, ale już tworzenie zawiłych animacji wymaga szybkiego modułu 32-bitowego. W projekcie użyto aż czterech EPS32-S3, ale bezpośrednio diodami steruje jeden. Kolejny – tworzy model animacji, następny analizuje audio, a ostatni zajmuje się interfejsem w postaci dotykowego siedmiocalowego ekranu. Projekt jest czysto użytkowy, ale również obrazuje współpracę modułów w zakresie dzielenia zadań przez system wieloprocesorowy. <a href="https://projecthub.arduino.cc/alaindesbrousses/omegastar-900-led-esp32-s3-lighting-star-2dd8a9">Link do projektu.</a>

900 ledów sterowanych jednym modułem.

182.png

Edge Link łączy Arduino z profesjonalnymi systemami przemysłowymi za pośrednictwem standardów takich jak Modbus, RS-485 i inne. Pasując na szynę DIN nie tylko służy do naprawiania tego, co ze względu na wiek jest już trudne do serwisowania, ale może więcej – w zakresie monitorowania oraz funkcji AI, pierwotnie niedostępnych. Przykładowo, awaria systemu nadzorowanego może wywołać szereg działań dodatkowcych, pierwotnie niedostępnych, by ograniczyć straty w systemach niezwiązanych bezpośrednio z nadzorowanym. Automatyka AI może podejmować decyzję z dużo większą szybkością, jeszcze przed ingerencją człowieka, co czasem może znacząco ograniczać straty. W końcu systemy takie mogą zaoferować możliwości pierwotnie niedostępne ze względu na złożoność, a obecnie oferowane dzięki modułom uczenia i uproszczeniu tworzenia logiki, nad szczegółami której człowiek nie musi już spędzać tyle czasu co kiedyś.

Arduino łata przemysł

180.png

Przy okazji premier nowych płytek Arduino słyszy się o środowisku Zephyr. Czym ono jest? To zupełnie inne podejście do projektowania oprogramowania. Gdy klasyczne Arduino pracuje w nieskończonej pętli loop, wykonując wszystkie zadania kolejno (przy czym sprzętowe przerwania jedynie wstrzymują na chwilę tę pętlę, obsługując zawsze tylko jedną operację naraz), Zephyr przekształca płytkę Arduino w mały komputer. Jest on zdolny do bezpiecznego wykonywania wielu zadań równolegle – w praktyce mogą być ich dziesiątki – dzięki podziałowi programu na niezależne wątki o różnych priorytetach. Na przykład gdy jeden wątek analizuje dane z czujników, drugi może w tym samym mikrosekundowym oknie obsługiwać transmisję bezprzewodową, a trzeci precyzyjnie sterować silnikiem. System wspiera też zaawansowane zarządzanie energią. Gdy klasyczne szkice wprowadzały blokujące procesor pętle delay, tutaj nieaktywny wątek po prostu przechodzi w stan uśpienia, oddając całą moc obliczeniową pozostałym zadaniom. Dodatkowo środowisko zawiera certyfikowane stosy sieciowe w popularnych standardach (m.in. Wi-Fi, BLE czy Thread) i zostało zaprojektowane z myślą o bezpiecznych urządzeniach IoT. Oczywiście taka wielozadaniowość wymaga odpowiedniej architektury, z której proste, 8-bitowe mikrokontrolery są wykluczone. Wśród płytek kompatybilnych z ArduinoCore-Zephyr znajdziemy nowoczesne platformy takie jak seria UNO Q oraz VENTUNO Q, UNO R4, Nano 33 BLE, Portenta, Nicla oraz wybrane układy ESP32.

Czym jest Zephyr?

178.png

Wyświetlacze klapkowe albo flip-disc, były kiedyś bardziej popularne, zanim zastąpiły je diody. Wciąż jednak są bezkonkurencyjne w pełnym słońcu, ponieważ nie świecą własnym światłem, a odbijają światło padające. Składają się z klapek – odpowiedników pikseli, które mogą się obracać. Jedna strona jest malowana w jaskrawej barwie – zwykle żółtej, druga jest czarna. W zależności od położenia klapki piksel świeci się albo nie. Ten, wydawałoby się prymitywny sposób pracy, ma jedną zaletę: nie ma ograniczeń co do rozmiarów. Klapki mogą tworzyć matryce albo na przykład segmenty typowych ósemek i wówczas zegar stworzony z takich elementów może mieć rozmiary metrowe, będące przydatne na dworcach czy ogólniej, w przestrzeni publicznej.Komplikacją takiego zegara jest konieczność użycia elektromagnesu pod każdą z klapek. W tym wypadku postąpiono inaczej: stworzono rodzaj plotera, który obraca indywidualnie każdą klapką wedle potrzeby. Uprościło to budowę wyświetlacza, lecz zarazem bardzo spowolniło proces aktualizacji treści. Takie wyświetlacze jednak z zasady służyły informacjom zmienianym rzadko, jak rozkłady odjazdów, zegary bez sekundników, termometry itp., więc sam proces uaktualniania nie jest krytyczny. Dziś tego typu wyświetlacze mają już zastosowanie tam tylko, gdzie nie sprawdzą się LED-y, a więc na szczytach budynków w świetle słonecznym i przy rozmiarach rzędu metra i większych. Więcej informacji <a href="https://blog.arduino.cc/2026/08/31/p-a-r-is-a-flip-squisk-display-that-draws-your-pixel-art/">tutaj.</a>

Zegar klapkowy na nowo

11.png

Kontynuując <a href="https://arduino.pl/articles/167_klawiatura_matrycowa_dla_zaawansowanych_cz_1">temat klawiatury matrycowej</a> przyjrzyjmy się zmiennym konfigurującym zachowanie się biblioteki keypad.h I tak, jeśli użylibyśmy jakiejś mało precyzyjnej klawiatury, dającej wielokrotne odczyty na skutek niepewnych styków, możemy wydłużyć blokadę na stany przejściowe. Używa się do tego poniższej instrukcji.<pre class="jodit-code"><code class="language-cpp">keypad.setDebounceTime(50); &nbsp;// Wydłuż czas stabilizacji klawiatury z 10 do 50 ms</code></pre>Domyślnie blokuje pracę klawiszy na 10 ms, można ją wydłużyć dla zadowalającej wartości. Kolejne ustawienie określa jak długo klawisz ma być trzymany, by biblioteka zarejestrowała go jako przytrzymany właśnie, nadając mu status HOLD <pre class="jodit-code"><code class="language-cpp">keypad.setHoldTime(500); &nbsp; &nbsp; // Skróć czas przejścia klawisza w tryb HOLD z 1000 do 500 ms</code></pre>To przydaje się na przykład do stworzenia alternatywnej odpowiedzi klawiatury przytrzymanej dłużej. Domyślną wartością jest tysiąc milisekund. No to teraz przetestujmy sobie owe statusy, bo jest ich więcej. Biblioteka generuje cztery: klawisz wciśnięto, czyli PRESSED, klawisz wciśnięto i przytrzymano dłużej – przez czas, o którym właśnie pisałem, czyli HOLD, klawisz właśnie puszczono – RELEASED i niczego nie wciśnięto – IDLE. Poniższy program zobrazuje nam to najlepiej. <pre class="jodit-code"><code class="language-cpp">#include &lt;Wire.h&gt; // Biblioteka obsługująca magistralę I2C
#include &lt;hd44780.h&gt; // Biblioteka obsługująca wyświetlacze 44780
#include &lt;hd44780ioClass/hd44780_I2Cexp.h&gt; // Dodatek obsługujący wyświetlacze podłączone do ekspandera I2C
hd44780_I2Cexp lcd(0x20, I2Cexp_MCP23008, 7, 6, 5, 4, 3, 2, 1, HIGH); // Konfiguracja połączeń wyświetlacza LCD

#include &lt;Keypad.h&gt; // Biblioteka obsługująca klawiaturę.
const byte rowsKeypad = 4; // Liczba wierszy matrycy klawiatury.
const byte colsKeypad = 4; // Liczba kolumn matrycy klawiatury.
byte rowPins[rowsKeypad] = { 7, 6, 5, 4 }; // Adresy kolejnych wierszy klawiatury.
byte colPins[colsKeypad] = { 3, 2, 1, 0 }; // Adresy kolejnych kolumn klawiatury.
char keys[rowsKeypad][colsKeypad] = { // Tablica znaków dla kolejnych klawiszy.
 { '1', '2', '3', 'A' },
 { '4', '5', '6', 'B' },
 { '7', '8', '9', 'C' },
 { '*', '0', '#', 'D' }
};
Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, rowsKeypad, colsKeypad); // Definiuj klawiaturę zgodnie z powyższymi deklaracjami.
char lastKey; // Zmienna przechowująca ostatni sczytany znak z klawiatury.

void setup() {
 lcd.begin(16, 2); // Inicjuj wyświetlacz.
 keypad.setDebounceTime(50); // Wydłuż czas stabilizacji klawiatury z 10 do 50 ms
 keypad.setHoldTime(1000); // Ustaw czas przejścia klawisza w tryb HOLD na 1000 ms
}

void loop() {
 char key = keypad.getKey(); // Pozyskaj znak klawiatury.
 if (key != NO_KEY) { lastKey = key; } // Jeśli coś wciśnięto, zapisz to w zmiennej.
 lcd.clear(); // Wyczyść wyświetlacz.
 switch (keypad.getState()) { // Analizuj stan wciśniętego klawisza.
 case PRESSED: // Klawisz wciśnięto.
 lcd.print("PRESSED: ");
 lcd.print(lastKey);
 break;
 case HOLD: // Klawisz przytrzymano.
 lcd.print("HOLD: ");
 lcd.print(lastKey);
 break;
 case RELEASED: // Klawisz puszczono.
 lcd.print("RELEASED: ");
 lcd.print(lastKey);
 break;
 case IDLE:
 lcd.print("IDLE"); // Niczego nie wciśnięto.
 break;
 default:
 lcd.print("UNKNOWN"); // Brak zwróconej informacji o klawiaturze.
 lcd.print(lastKey);
 break;
 }
 delay(250);
}
</code></pre>Początek nie różni się niczym. Jednak po pozyskaniu kodu klawisza, wstawiamy go do zmiennej lastKey. Czyścimy wyświetlacz i teraz czytamy ów status z tej zmiennej systemowej biblioteki. Zaraz po wciśnięciu pojawi nam się napis PRESSED (klawisz został wciśnięty). Jeśli będziemy ten klawisz trzymać dłużej, status zmieni się na HOLD (klawisz jest już wciśnięty od co najmniej sekundy). Po puszczeniu klawisza na chwilę pojawi się RELEASED (właśnie puszczono klawisz), a po chwili – IDLE (klawisze są zwolnione), do czasu kolejnego wciśnięcia dowolnego klawisza. Gdyby coś poszło nie tak, ujrzymy jeszcze jeden komunikat UNKNOWN, pojawiający się na skutek braku statusu. Teraz możemy się pobawić, wciskając, trzymając i puszczając przyciski. Każde ze zdarzeń daje status, co można wykorzystać we własnych pomysłach na realizację klawiatury. W jakich na przykład? Proszę bardzo, oto kolejna propozycja. Napiszemy program, który będzie podwajał liczbę znaków osiąganych z klawiaturki i to bez jakiegokolwiek shiftu czy temu podobnego klawisza.<pre class="jodit-code"><code class="language-cpp">#include &lt;Wire.h&gt; // Biblioteka obsługująca magistralę I2C
#include &lt;hd44780.h&gt; // Biblioteka obsługująca wyświetlacze 44780
#include &lt;hd44780ioClass/hd44780_I2Cexp.h&gt; // Dodatek obsługujący wyświetlacze podłączone do ekspandera I2C
hd44780_I2Cexp lcd(0x20, I2Cexp_MCP23008, 7, 6, 5, 4, 3, 2, 1, HIGH); // Konfiguracja połączeń wyświetlacza LCD

#include &lt;Keypad.h&gt; // Biblioteka obsługująca klawiaturę.
char lastKey; // Zmienna przechowująca ostatni sczytany znak z klawiatury.
const byte rowsKeypad = 4; // Liczba wierszy matrycy klawiatury.
const byte colsKeypad = 4; // Liczba kolumn matrycy klawiatury.
byte rowPins[rowsKeypad] = { 7, 6, 5, 4 }; // Adresy kolejnych wierszy klawiatury.
byte colPins[colsKeypad] = { 3, 2, 1, 0 }; // Adresy kolejnych kolumn klawiatury.

const char keys[rowsKeypad][colsKeypad] = { // Tablica znaków dla kolejnych klawiszy.
 { '1', '2', '3', 'a' },
 { '4', '5', '6', 'b' },
 { '7', '8', '9', 'c' },
 { '*', '0', '#', 'd' }
};
const char keysHold[rowsKeypad][colsKeypad] = { // Tablica znaków dla dla kolejnych klawiszy trzymanych dłużej.
 { '!', '@', '#', 'A' },
 { '$', '%', '^', 'B' },
 { '&amp;', '*', '(', 'C' },
 { '+', ')', '-', 'D' }
};
Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, rowsKeypad, colsKeypad); // Definiuj klawiaturę zgodnie z powyższymi deklaracjami.
bool statusHold = false; // Zmienna statusu trzymania klawisza.
bool lockRelease = false; // Zmienna zabezpieczająca przed autorepetycją.
byte activeRow = 0; // Współrzędne wciśniętego klawisza.
byte activeCol = 0;

void setup() {
 lcd.begin(16, 2); // Inicjuj wyświetlacz.
}
void loop() {
 char key = keypad.getKey(); // Pozyskaj znak klawiatury.
 KeyState state = keypad.getState(); // Pozyskaj status klawiatury.

 if (key != NO_KEY) { // Jeśli coś wciśnięto...
 lastKey = key; // Zapisz to w zmiennej.
 statusHold = false; // Zeruj stan trzymania klawisza.
 lockRelease = false; // Odblokuj możliwość wypisania znaku dla nowego wciśnięcia.

 for (byte r = 0; r &lt; rowsKeypad; r++) { // Pozyskaj współrzędne wciśniętego klawisza.
 for (byte c = 0; c &lt; colsKeypad; c++) {
 if (keys[r][c] == key) {
 activeRow = r;
 activeCol = c;
 }
 }
 }
 }
 if (state == HOLD) { // Jeśli klawisz otrzymał status HOLD...
 statusHold = true; // Ustaw status trzymania klawisza.
 }
 if (state == RELEASED &amp;&amp; lastKey != NO_KEY &amp;&amp; !lockRelease) { // Jeśli puszczono klawisz i wcześniej zapisano jakiś znak...
 char activeKey; // Utwórz zmienną kodu klawisza.
 if (statusHold) { // Jeśli ten klawisz był trzymany dłużej...
 activeKey = keysHold[activeRow][activeCol]; // Wybierz kod znaku z alternatywnej tablicy.
 } else { // W przeciwnym razie...
 activeKey = keys[activeRow][activeCol]; // Wybierz kod znaku z głównej tablicy.
 }
 lcd.print(activeKey); // Wyślij kod znaku na LCD.
 lastKey = NO_KEY; // Zeruj zmienną kodu znaku.
 statusHold = false; // Zeruj zmienną trzymania klawisza.
 lockRelease = true; // Zablokuj kolejne powtórzenia znaku aż do nowego kliknięcia.
 }
 if (state == IDLE) { // Jeśli żaden klawisz nie jest wciśnięty...
 lockRelease = false; // Zeruj blokadę autorepetycji.
 }
}
</code></pre>Podstawowe znaki będą wychodzić zwyczajnie – po przyciskaniu klawiszy, alternatywne natomiast pojawią się po chwilowym ich przytrzymaniu. Ponieważ jest to wersja szkoleniowa, uprościłem nieco program i znaki będą się pojawiać dopiero po puszczeniu przycisków – z tym sobie poradzimy później. Niestety biblioteka nie oferuje prostej funkcji podmiany tablicy i będziemy musieli to czynić nieco naokoło. Zadeklarujemy dwie tablice: keys oraz keysHold, w drugiej będą znaki alternatywne. W przypadku liter – małe i duże, dla cyfr – znaki, które znajdziemy na klawiaturze peceta. Można oczywiście wpisać tam cokolwiek. Będą nam też potrzebne różne zmienne pomocnicze, zaraz się wyjaśni która do czego.Na początku pozyskujemy znak klawiatury key i status klawiatury state. Jeśli coś w ogóle wciśnięto, zapamiętamy to w lastKey i wyzerujemy zmienną trzymania przycisku statusHold, równocześnie odblokowując możliwość wysłania znaku później lockRelease. Następnie musimy przepytać całą klawiaturę, by zidentyfikować który to klawisz wciśnięto.Kolejno analizujemy czy klawisz jest już trzymany wymagany czas, by mógł zostać określony jako dociśnięty. Dopiero teraz przeanalizujemy czy klawisz został puszczony, czy nie był nieokreślony i czy zezwolono na dalsze procedury, czyli zabezpieczono się przed autopowielaniem. Po spełnieniu tych wszystkich warunków powołujemy do życia zmienną kodu klawisza activeKey, którą potem wyślemy na ekran.I teraz w zależności od tego czy klawisz był trzymany długo czy krótko, pobierzemy jego kod z tablicy – alternatywnej albo głównej. Kod wyjdzie na ekran, wyzerujemy stosowne zmienne i zablokujemy autorepetycję, bo bez tego kody wylatywałyby bez końca, aż klawisz zostałby zwolniony. Tę możemy odblokować dopiero po rzeczywistym puszczeniu klawisza.&nbsp;Program, czy raczej moduł, działa zgodnie z ideą. W tym wypadku jednak dobrze byłoby mieć jakieś powiadomienie o działaniu klawiaturki.<pre class="jodit-code"><code class="language-cpp">#include &lt;Wire.h&gt; // Biblioteka obsługująca magistralę I2C
#include &lt;hd44780.h&gt; // Biblioteka obsługująca wyświetlacze 44780
#include &lt;hd44780ioClass/hd44780_I2Cexp.h&gt; // Dodatek obsługujący wyświetlacze podłączone do ekspandera I2C
hd44780_I2Cexp lcd(0x20, I2Cexp_MCP23008, 7, 6, 5, 4, 3, 2, 1, HIGH); // Konfiguracja połączeń wyświetlacza LCD

#include &lt;Keypad.h&gt; // Biblioteka obsługująca klawiaturę.
char lastKey; // Zmienna przechowująca ostatni sczytany znak z klawiatury.
const byte rowsKeypad = 4; // Liczba wierszy matrycy klawiatury.
const byte colsKeypad = 4; // Liczba kolumn matrycy klawiatury.
byte rowPins[rowsKeypad] = { 7, 6, 5, 4 }; // Adresy kolejnych wierszy klawiatury.
byte colPins[colsKeypad] = { 3, 2, 1, 0 }; // Adresy kolejnych kolumn klawiatury.
const byte buzzer = 9; // Port sterujący buzzerem.

const char keys[rowsKeypad][colsKeypad] = { // Tablica znaków dla kolejnych klawiszy.
 { '1', '2', '3', 'a' },
 { '4', '5', '6', 'b' },
 { '7', '8', '9', 'c' },
 { '*', '0', '#', 'd' }
};
const char keysHold[rowsKeypad][colsKeypad] = { // Tablica znaków dla dla kolejnych klawiszy trzymanych dłużej.
 { '!', '@', '#', 'A' },
 { '$', '%', '^', 'B' },
 { '&amp;', '*', '(', 'C' },
 { '+', ')', '-', 'D' }
};
Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, rowsKeypad, colsKeypad); // Definiuj klawiaturę zgodnie z powyższymi deklaracjami.
bool statusHold = false; // Zmienna statusu trzymania klawisza.
bool lockRelease = false; // Zmienna zabezpieczająca przed autorepetycją.
byte activeRow = 0; // Współrzędne wciśniętego klawisza.
byte activeCol = 0;

void setup() {
 lcd.begin(16, 2); // Inicjuj wyświetlacz.
 pinMode(buzzer, OUTPUT); // Inicjuj port sterujący buzzerem.
}
void loop() {
 char key = keypad.getKey(); // Pozyskaj znak klawiatury.
 KeyState state = keypad.getState(); // Pozyskaj status klawiatury.

 if (key != NO_KEY) { // Jeśli coś wciśnięto...
 lastKey = key; // Zapisz to w zmiennej.
 statusHold = false; // Zeruj stan trzymania klawisza.
 lockRelease = false; // Odblokuj możliwość wypisania znaku dla nowego wciśnięcia.
 for (byte r = 0; r &lt; rowsKeypad; r++) { // Pozyskaj współrzędne wciśniętego klawisza.
 for (byte c = 0; c &lt; colsKeypad; c++) {
 if (keys[r][c] == key) {
 activeRow = r;
 activeCol = c;
 }
 }
 }
 beep(); // Piknij.
 }
 if (state == HOLD) { // Jeśli klawisz otrzymał status HOLD...
 statusHold = true; // Ustaw status trzymania klawisza.
 beep(); // Piknij.
 }
 if (state == RELEASED &amp;&amp; lastKey != NO_KEY &amp;&amp; !lockRelease) { // Jeśli puszczono klawisz i wcześniej zapisano jakiś znak...
 char activeKey; // Utwórz zmienną kodu klawisza.
 if (statusHold) { // Jeśli ten klawisz był trzymany dłużej...
 activeKey = keysHold[activeRow][activeCol]; // Wybierz kod znaku z alternatywnej tablicy.
 } else { // W przeciwnym razie...
 activeKey = keys[activeRow][activeCol]; // Wybierz kod znaku z głównej tablicy.
 }
 lcd.print(activeKey); // Wyślij kod znaku na LCD.
 lastKey = NO_KEY; // Zeruj zmienną kodu znaku.
 statusHold = false; // Zeruj zmienną trzymania klawisza.
 lockRelease = true; // Zablokuj kolejne powtórzenia znaku aż do nowego kliknięcia.
 }
 if (state == IDLE) { // Jeśli żaden klawisz nie jest wciśnięty...
 lockRelease = false; // Zeruj blokadę autorepetycji.
 }
}
void beep() {
 digitalWrite(buzzer, HIGH);
 delay(1);
 digitalWrite(buzzer, LOW);
}</code></pre> Wprowadziłem prostą funkcję piknięcia, wykorzystującą osadzony na mojej płytce piszczek. Piknięcia pojawią się po każdym wciśnięciu przycisku – raz i po przekroczeniu czasu trzymania klawisza. W tym wypadku będzie to już pikanie ciągłe. Można to zmienić, wstawiając kolejną pułapkę na jednorazowe piknięcie, ale to już pozostawię czytelnikom. <a href="https://arduino.pl/articles/169_budujemy_zamek_szyfrowy_cz_1">W kolejnym artykule</a> wrócimy do wspomnianego na początku zamka szyfrowego.

Kontynuując temat klawiatury matrycowej przyjrzyjmy się zmiennym konfigurującym zachowanie się biblioteki keypad.h I tak, jeśli użylibyśmy jakiejś mało precyzyjnej klawiatury, dającej wielokrotne odczyty na skutek niepewnych styków, możemy wydłużyć blokadę na stany przejściowe. Używa się do tego poniższej instrukcji

[168] Klawiatura matrycowa dla zaawansowanych cz. 2

0.png

2.png

1.png

3.png

4.png

5.png

6.png

7.png

21.png

Postanowiłem zbudować zamek szyfrowy – ale najpierw dokładniej przyjrzymy się jednemu z elementów, który pojawia się w takich konstrukcjach: klawiaturze. Zamki szyfrowe i nie tylko one, są kojarzone z klawiaturką, na której wystukujemy kod, otwierając drzwi, bramę albo schowek. Klawiatury najczęściej zawierają dziesięć przycisków numerycznych i dwa dodatkowe. Jeden zwykle otwiera zamek po wpisaniu kodu, drugi – cofa pomylone znaki. Zanim zabierzemy się do samego zamka, pobawimy się klawiaturą jako taką, bo to pożyteczny element, który można wykorzystywać w wielu różnych projektach. Może mieć kilka dosłownie pozycji albo kilkadziesiąt, udając typową klawiaturę komputerową. O klawiaturach pisałem już wiele razy, dziś jednak chciałbym do tematu powrócić, aby go zgłębić dokładnie i kompletnie.<img src="https://cdzpcayhaa.cloudimg.io/v7/_ard_/1-6a67584473e62.png?force_format=webp&amp;ci_sign=5ccc446e757b7d749d21bed4b66c8f82f4bb04ce" alt="1.png" style="max-width:100%; height:auto; margin: 16px auto">Ćwiczyć będziemy na takiej, jakże popularnej klawiaturce o organizacji cztery wiersze na cztery kolumny, co daje 16 przycisków. Używając dwustronnych goldpinów możemy ją wetknąć w zduplikowane gniazdo Arduino Uno, które mieści się na <a href="https://arduino.pl/tme-educational-board">płytce edukacyjnej TME.</a><a href="https://arduino.pl/tme-educational-board"><img src="https://cdzpcayhaa.cloudimg.io/v7/_ard_/31-6a675846cfb19.png?force_format=webp&amp;ci_sign=5e358a7b980c4f3d31de42281b5bacb15202d7f3" alt="31.png" style="max-width:100%; height:auto; margin: 16px auto"></a>I już na początku mamy problem: Uno z niezrozumiałych dla mnie powodów ma przesunięcie pinów między siódmym, a ósmym. Oznacza to, że tylko pierwszych osiem pinów stoi sobie równo w rzędzie, umożliwiając wpięcie gniazdka bez użycia dodatkowych przewodów. Niby okej, jednak pin zerowy i pierwszy używane są do programowania kontrolera oraz zrzucania danych na monitor. Co to dla nas oznacza? Jeśli będziemy korzystać z tych pinów, nie będzie można niczego nie wciskać na klawiaturze podczas programowania i trzeba będzie zrezygnować z użycia funkcji serial do wysyłania danych. Ponieważ jednak mam tu wyświetlacz, a poza tym w zamkach szyfrowych nie używa się monitora, problemu nie ma. Gdyby jednak komuś to przeszkadzało, niech ominie pierwsze dwa piny.Klawiatury pasywne, to znaczy nie wysyłające kodów znaków na jakiejś konkretnej magistrali, możemy podzielić na trzy grupy. Pierwsza to jeden pin – jeden klawisz.<img src="https://cdzpcayhaa.cloudimg.io/v7/_ard_/3-6a675843b7814.png?force_format=webp&amp;ci_sign=c578852358ec3d8ea5f7142abd10c11416452e15" alt="3.png" style="max-width:100%; height:auto; margin: 16px auto">Ma sens tylko przy maksymalnie kilku przyciskach. Druga to klawiatury matrycowe.<img src="https://cdzpcayhaa.cloudimg.io/v7/_ard_/4-6a6758443419e.png?force_format=webp&amp;ci_sign=25cc7dd41be28d77ea3363cafad072f5c7f4a19d" alt="4.png" style="max-width:100%; height:auto; margin: 16px auto">W tym wypadku liczba przycisków to iloczyn wierszy i kolumn. Z tego wniosek, że najlepiej, gdy jednych i drugich jest tyle samo. Nasza klawiatura wymaga ośmiu pinów, dając 16 klawiszy. Przy dziesięciu liczba rośnie do 25 i tak dalej. Trzeci rodzaj klawiatur to klawiatury analogowe, które zwierają rezystory dzielące napięcia na wspólnej linii.<img src="https://cdzpcayhaa.cloudimg.io/v7/_ard_/5-6a675844397f8.png?force_format=webp&amp;ci_sign=37b1bc27513986766c50de120ef588853540b71f" alt="5.png" style="max-width:100%; height:auto; margin: 16px auto">W tym wypadku mierzy się przedziały napięć i takie rozwiązania stosuje się dla klawiaturek obejmujących 2-5 przycisków. Zajmują tylko jeden pin, ale tym się na razie zajmować nie będziemy.<img src="https://cdzpcayhaa.cloudimg.io/v7/_ard_/6-6a675846048dd.png?force_format=webp&amp;ci_sign=398b0c7c789be9669bc47667ec4ffe65fecf4927" alt="6.png" style="max-width:100%; height:auto; margin: 16px auto">Nasza klawiatura to klasyka matrycowa i idea pracy z taką klawiaturą jest prosta: Na jednym z wierszy ustawia się stan niski, na pozostałych – wysoki. Następnie czyta się stany każdej z kolumn i jeśli na którejś pojawi się stan niski, oznacza to, że wciśnięto przycisk znajdujący się na skrzyżowaniu tego wiersza i tej kolumny. Do kompletu trzeba wykonać cztery takie analizy, zmieniając za każdym razem wiersz, któremu podaje się stan niski. Można zamienić aktywne stany miejscami, to już jest kwestia konkretnej umowy i czasem też wymagań sprzętu.Jak się można domyślić, stworzenie algorytmu dla takiego zadania nie byłoby wyzwaniem ambitnym, jednak postanowiłem skorzystać z biblioteki, bo tak będzie prościej. Zadbano tam o szczegóły i nie jest zasobożerna, zadowalając się półtora kilobajtem pamięci. Napiszmy sobie na początek szkic podstawowy, który pozwoli nam przetestować pracę naszej klawiatury. Jak mówiłem, kody wciskanych znaków będziemy wysyłać na wyświetlacz, a nie na monitor, więc należy tu zadbać o niego, co już wielokrotnie czyniłem więc powtarzać się nie będę.<pre class="jodit-code"><code class="language-cpp">#include &lt;Wire.h&gt; // Biblioteka obsługująca magistralę I2C
#include &lt;hd44780.h&gt; // Biblioteka obsługująca wyświetlacze 44780
#include &lt;hd44780ioClass/hd44780_I2Cexp.h&gt; // Dodatek obsługujący wyświetlacze podłączone do ekspandera I2C
hd44780_I2Cexp lcd(0x20, I2Cexp_MCP23008, 7, 6, 5, 4, 3, 2, 1, HIGH); // Konfiguracja połączeń wyświetlacza LCD

#include &lt;Keypad.h&gt; // Biblioteka obsługująca klawiaturę.
const byte rowsKeypad = 4; // Liczba wierszy matrycy klawiatury.
const byte colsKeypad = 4; // Liczba kolumn matrycy klawiatury.
byte rowPins[rowsKeypad] = { 7, 6, 5, 4 }; // Adresy kolejnych wierszy klawiatury.
byte colPins[colsKeypad] = { 3, 2, 1, 0 }; // Adresy kolejnych kolumn klawiatury.
char keys[rowsKeypad][colsKeypad] = { // Tablica znaków dla kolejnych klawiszy.
 { '1', '2', '3', 'A' },
 { '4', '5', '6', 'B' },
 { '7', '8', '9', 'C' },
 { '*', '0', '#', 'D' }
};
Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, rowsKeypad, colsKeypad); // Definiuj klawiaturę zgodnie z powyższymi deklaracjami.

void setup() {
 lcd.begin(16, 2); // Inicjuj wyświetlacz.
}

void loop() {
 char key = keypad.getKey(); // Pozyskaj znak klawiatury.
 if (key) { lcd.print(key); } // Jeśli się pojawił, wyślij go na wyświetlacz.
}
</code></pre>Sprawy związane z klawiaturą znajdują się poniżej. Najpierw zaczytujemy bibliotekę keypad.h Jest ona rekomendowana przez organizację Arduino, zatem prześwietlona na wylot. Kolejne dwie linie określają liczbę wierszy oraz kolumn. Następne – przyporządkowują porty dla wierszy i kolumn, czyniąc port klawiatury. Tutaj najlepiej określić sobie wstępnie miernikiem wykrywającym zwarcia co jest co, albo dopasowywać grupy metodą prób i błędów. W końcu mamy matrycę znaków, która przyporządkowuje kody konkretnym przyciskom. To te znaki będą się nam pojawiać potem na wyświetlaczu.Kolejno inicjujemy bibliotekę takim rozciągniętym wyrażeniem. Keypad keypad to takie trochę mało maślane: pierwsze słowo oznacza definicję biblioteki, drugie jest nazwą tej konkretnej klawiatury i przyjęło się nazywać ją właśnie tak, ale to nie jest obowiązkowe. Mało tego, można sobie zorganizować kilka klawiatur i wtedy należy nadać im tutaj niepowtarzalne nazwy. To co wewnątrz nawiasu, zostało opisane wcześniej, więc nie będę tego wyjaśniał.Pozostaje jeszcze zainicjować wyświetlacz i można testować klawiaturę. Instrukcja keypad.getKey() zwraca kod wciśniętego przycisku. Kolejna zaś wysyła go na wyświetlacz, jeśli oczywiście pojawiło się zdarzenie wciśnięcia. Siedemnasty znak z kolei już się nam nie zmieści na ekranie i żeby testować klawiaturę dalej, trzeba będzie wcisnąć reset.<img src="https://cdzpcayhaa.cloudimg.io/v7/_ard_/7-6a67584652088.png?force_format=webp&amp;ci_sign=d6d826f78e8d01f6761424a8518e8c7da8661f5c" alt="7.png" style="max-width:100%; height:auto; margin: 16px auto">Program działa, co oznacza prawidłowe podłączenie wszystkiego i sprawność samej klawiatury. Na tym etapie można już przystąpić do konkretów z wykorzystaniem tej biblioteki, ale ona potrafi więcej, zatem trzeba będzie poznać inne jej możliwości. Ale o tym napiszę w kolejnym artykule.

Postanowiłem zbudować zamek szyfrowy – ale najpierw dokładniej przyjrzymy się jednemu z elementów, który pojawia się w takich konstrukcjach: klawiaturze. Zamki szyfrowe i nie tylko one, są kojarzone z klawiaturką, na której wystukujemy kod, otwierając drzwi, bramę albo schowek. Klawiatury najczęściej zawierają dziesięć przycisków numerycznych i dwa dodatkowe. Jeden zwykle otwiera zamek po wpisaniu kodu, drugi – cofa pomylone znaki. Zanim zabierzemy się do samego zamka, pobawimy się klawiaturą jako taką, bo to pożyteczny element, który można wykorzystywać w wielu różnych projektach

[167] Klawiatura matrycowa dla zaawansowanych cz. 1

Jak zabezpieczyć kartę przed szybkim zużyciem?

<a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/163-karta-sd-cz-3">Nasze zabawy w tworzenie plików i ich edycję</a> mają ciemną stronę: nieumiejętnie wdrożone mogą szybko doprowadzić do zużycia i w rezultacie uszkodzenia karty. Jak się przed tym ustrzec? Poznajmy dwa przykłady: zły i dobry. Złym będzie modyfikacja pewnego szkicu z biblioteki, który – owszem, działa, ale nie nadaje się do użycia praktycznego, w każdym razie w tej postaci. Ale po kolei.<pre><code class="language-arduino">#include &lt;SD.h&gt; // Biblioteka obsługi karty SD\nFile file;\nconst byte cardCS = 4; // Deklaracja adresu linii CS11\nconst byte Loudness = A0; // Port mikrofonu.\nconst byte Potentiometer = A1; // Port potencjometru.\nconst byte Temperature = A2; // Port termometru.\nconst byte Brightness = A3; // Port fotorezystora.\n\nvoid setup() {\n Serial.begin(115200); // Inicjuj port monitora.\n Serial.println(F("\\nCzekam na sygnał z karty SD...")); // Wyślij komunikat.\n if (!SD.begin(cardCS)) { // Inicjuj kartę określając port CS (jeśli brak - pin 10)\n Serial.println(F("Niepowodzenie, nie wykryto karty.")); // Karta nie została wykryta.\n while (1) // Koniec programu.\n ;\n }\n Serial.println(F("Powodzenie, wykryto kartę."));\n\n Serial.println(F("\\nUsunę plik DANE.TXT..."));\n SD.remove("DANE.TXT"); // Usuwam plik DANE.TXT\n}\n\nvoid loop() {\n String sensorsString = F(""); // Powołujemy do życia zmienną tekstową.\n\n sensorsString += F("Czas: "); // Sygnatura czasowa w sekundach.\n sensorsString += String(millis() / 1000);\n\n sensorsString += F(", Głośność: "); // Port mikrofonu.\n sensorsString += String(analogRead(Loudness));\n\n sensorsString += F("/1023, Potencjometr: "); // Port potencjometru.\n sensorsString += String(analogRead(Potentiometer));\n\n sensorsString += F("/1023, Temperatura: "); // Port termometru.\n sensorsString += String(analogRead(Temperature) * 0.125 - 22.0);\n\n sensorsString += F(", Jasność: "); // Port fotorezystora.\n sensorsString += String(analogRead(Brightness));\n sensorsString += F("/1023\\n");\n\n file = SD.open("DANE.TXT", FILE_WRITE); // Otwieram plik DANE.TXT, który będzie zapisywany.\n if (file) { // Jeśli udało się otworzyć plik...\n file.println(sensorsString); // Zapisuję w nim tekst ze stanami sensorów.\n file.close(); // Zapisuję otwarty plik na karcie.\n Serial.println(sensorsString); // Wysyłam ten tekst także na monitor.\n } else {\n Serial.println(F("Niepowodzenie, nie dałem rady zapisać pliku DANE.TXT"));\n }\n delay(1000); // Zapisy wykonuj nie częściej niż to konieczne!\n}</code></pre>Oto program, już bardzo praktyczny, który co jakiś czas zapisuje stan czterech czujników wraz ze znacznikiem czasu. To bardzo popularna aplikacja różnego rodzaju loggerów – choćby termometrów monitorujących warunki transportu. <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/plytka-edukacyjna-tme">Na płytce edukacyjnej TME</a> zamontowano termometr, fototranzystor, mikrofon i potencjometr i wszystko to teraz wykorzystam. W związku z tym na początku deklaruję adresy portów sensorów. Potem mamy znany nam już blok inicjacji karty. Następnie usuniemy sobie ewentualnie istniejący już plik z tak zwanymi logami, czyli cyklicznymi wpisami z odczytanymi parametrami. Oczywiście można to zrobić jeśli chcemy zawsze mieć nowy, czysty plik po resecie albo pominąć usuwanie, jeśli chcemy się dopisać do zrzutów powstałych wcześniej.<pre><code class="language-arduino">String sensorsString = F(""); // Powołujemy do życia zmienną tekstową.\n\nsensorsString += F("Czas: "); // Sygnatura czasowa w sekundach.\nsensorsString += String(millis() / 1000);\n\nsensorsString += F(", Głośność: "); // Port mikrofonu.\nsensorsString += String(analogRead(Loudness));\n\nsensorsString += F("/1023, Potencjometr: "); // Port potencjometru.\nsensorsString += String(analogRead(Potentiometer));\n\nsensorsString += F("/1023, Temperatura: "); // Port termometru.\nsensorsString += String(analogRead(Temperature) * 0.125 - 22.0);\n\nsensorsString += F(", Jasność: "); // Port fotorezystora.\nsensorsString += String(analogRead(Brightness));\nsensorsString += F("/1023\\n");</code></pre>W pętli głównej będziemy budować zmienną typu string, która będzie się składać z opisów oraz mierzonych wartości przekształconych w znaki. Więc po kolei: najpierw powołujemy zmienną do życia. Następnie wypełniamy ją napisem „Czas: „ i dodajemy zrzut zmiennej millis, która jest pokładowym zegarem, zwiększającym wartość co 1/1000 sekundy. Aż takiej dokładności nam nie potrzeba, wystarczy sekundowy znacznik – więc podzielimy ją przez tysiąc.Tu dygresja: w warunkach praktycznych znacznik czasowy najlepiej określić bardziej zwyczajnie, tj. za pomocą kalendarza i zegara. Obie te rzeczy można napisać albo skorzystać z zegara RTC, który istnieje w niektórych wersjach płytek Arduino. My tutaj skupiamy się na czymś innym, więc pominąłem ten etap. Zainteresowanych zapraszam do <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/116-rtc-uklady-czasu-rzeczywistego-cz-1">artykułów o zegarze.</a>Teraz do łańcucha tekstu będziemy doklejać kolejne składniki: opisy oraz odczytane z przetworników dane. Nie zawracam sobie głowy konwersją na jakieś konkrety z wyjątkiem temperatury, która wyrazi się Celsjuszami po przeprowadzeniu takiej prostej konwersji. Zbieranie danych kończymy tym wpisem, oznaczającym złamanie wiersza – a to w celu zachowania porządku w pliku.<pre><code class="language-arduino">file = SD.open("DANE.TXT", FILE_WRITE); // Otwieram plik DANE.TXT, który będzie zapisywany.\nif (file) { // Jeśli udało się otworzyć plik...\n file.println(sensorsString); // Zapisuję w nim tekst ze stanami sensorów.\n file.close(); // Zapisuję otwarty plik na karcie.\n Serial.println(sensorsString); // Wysyłam ten tekst także na monitor.\n} else {\n Serial.println(F("Niepowodzenie, nie dałem rady zapisać pliku DANE.TXT"));\n}\ndelay(1000); // Zapisy wykonuj nie częściej niż to konieczne!</code></pre>Teraz nastąpi zapis na karcie. W tym celu otworzymy ją, dopiszemy do pliku string, zamkniemy, wyślemy go dodatkowo na monitor i zaczekamy tak długo, jak często będą nam potrzebne zapisy, czyli tutaj – co sekundę.Cóż, po kompilacji możemy chwilkę zaczekać, poświecić w fototranzystor, pokrzyczeć w mikrofon, pokręcić gałką, w końcu wyłączyć zasilanie i przenieść kartę do czytnika. Znajdziemy tam plik z zapisami, więc wszystko działa. Tylko że prawdopodobnie… no i właśnie nie wiadomo jak długo – czy po miesiącu, czy później – karta zacznie wykazywać błędy, które będą skutkiem cosekundowego dużego zapisu. Dlaczego dużego, skoro łańcuch ma tylko kilkadziesiąt bajtów? Otóż każde otwarcie i zamknięcie karty, choćby w celach zapisu jednego tylko bajtu, powoduje, że dochodzi do przeorganizowania struktury obejmującej znacznie większe obszary – rzędu kilobajtów. Dodatkowo jeśli będziemy kasować choćby najmniejszy plik, zakres działań jest jeszcze większy. Co prawda każda karta ma wbudowane mechanizmy rozkładania zapisów w celu wyrównania zużycia, więc cykliczne zapisywanie małego pliku nie jest tożsame z deklarowaną ilością zapisów kart przez producenta, jednak na zimne należy dmuchać i podejść do problemu inaczej.<pre><code class="language-arduino">#include // Biblioteka obsługi karty SD\nFile file;\nconst byte cardCS = 4; // Deklaracja adresu linii CS11\nconst byte Loudness = A0; // Port mikrofonu.\nconst byte Potentiometer = A1; // Port potencjometru.\nconst byte Temperature = A2; // Port termometru.\nconst byte Brightness = A3; // Port fotorezystora.\nconst byte saveButton = 8; // Port przycisku zamknięcia pliku.\n\nbool fileReady = false; // Flaga gotowości pliku do zapisu.\nchar sensorsString[128]; // Tablica dla bufora ramki, tj. pojedynczego odczytu sensorów.\nunsigned long lastWrite = 0; // Czas ostatniego zapisu.\nconst unsigned long interval = 1000; // Przerwa pomiędzy odczytami sensorów w milisekundach.\n\nvoid setup() {\n pinMode(saveButton, INPUT_PULLUP); // Deklaruj port przycisku jako wejście.\n Serial.begin(115200); // Inicjuj port monitora.\n Serial.println(F("\\nCzekam na sygnał z karty SD...")); // Wyślij komunikat.\n if (!SD.begin(cardCS)) { // Inicjuj kartę określając port CS (jeśli brak - pin 10)\n Serial.println(F("Niepowodzenie, nie wykryto karty.")); // Karta nie została wykryta.\n while (1) // Koniec programu.\n ;\n }\n Serial.println(F("Powodzenie, wykryto kartę."));\n\n Serial.println(F("\\nUsunę plik DANE.TXT..."));\n SD.remove("DANE.TXT"); // Usuwam plik DANE.TXT\n if (SD.exists("DANE.TXT")) { // Sprawdzam czy na karcie istnieje plik DANE.TXT\n Serial.println(F("Niepowodzenie, nie dałem rady usunąć pliku DANE.TXT"));\n } else {\n Serial.println(F("Powodzenie, usunąłem plik DANE.TXT"));\n }\n\n Serial.println(F("\\nStworzę plik DANE.TXT..."));\n file = SD.open("DANE.TXT", FILE_WRITE); // Otwieram plik DANE.TXT, który będzie zapisywany.\n if (file) { // Sprawdzam czy na karcie istnieje plik DANE.TXT\n Serial.println(F("Powodzenie, stworzyłem plik DANE.TXT\\n"));\n fileReady = true; // Plik jest gotowy do zapisu.\n } else {\n Serial.println(F("Niepowodzenie, nie dałem rady stworzyć pliku DANE.TXT"));\n }\n}\nvoid loop() {\n if (millis() - lastWrite &gt;= interval &amp;&amp; fileReady) { // Czy minął czas interwału między odczytami sensorów?\n\n snprintf(sensorsString, sizeof(sensorsString), // Buduję w tablicy łańcuch stringów oraz wartości.\n "Czas: %lu, Głośność: %i/1023, Potencjometr: %i/1023, Temperatura: %i/1023, Jasność: %i/1023\\n", // Szablon.\n millis() / 1000, // Argumenty.\n analogRead(Loudness),\n analogRead(Potentiometer),\n analogRead(Temperature),\n analogRead(Brightness));\n\n file.print(sensorsString); // Dopisuję zawartość tablicy do karty.\n lastWrite = millis(); // Aktualizuję czas dla obliczania interwału.\n Serial.print(sensorsString); // Wysyłam zawartość tablicy na monitor.\n }\n\n if (digitalRead(saveButton) == HIGH) { // Jeśli przycisk zamknięcia pliku został wciśnięty...\n file.flush(); // Zapisuję bufor do pliku.\n file.close(); // Zamkykam plik\n Serial.println(F("\\nZamykam plik DANE.TXT i kończę pracę programu."));\n while (1) // Koniec programu.\n ;\n }\n}</code></pre>Przekształcimy nasz szkic w taki, który o wiele łagodniej postępuje z kartą. Początek jest identyczny, poza deklaracją dodatkowych zmiennych, które przydadzą się nam później. Natomiast otwarcie karty nastąpi tylko raz, jeszcze przed główną pętlą.W tejże będziemy nieco inaczej postępować z budową wyrażenia zapisywanego na karcie. Otóż używanie funkcji string może prowadzić do różnych problemów związanych z defragmentacją pamięci, a zauważmy, że praca z kartą już na wstępie sporo jej rezerwuje. Stąd wszędzie w napisach wymusiłem trzymanie ich w pamięci flash. Lepiej tworzyć łańcuch w zadeklarowanej wstępnie tablicy – o długości wziętej z zapasem na najdłuższy wpis. 128 bajtów wystarczy aż za dość. <pre class="jodit-code"><code class="language-cpp">if (millis() - lastWrite &gt;= interval &amp;&amp; fileReady) { // Czy minął czas interwału między odczytami sensorów?

 snprintf(sensorsString, sizeof(sensorsString), // Buduję w tablicy łańcuch stringów oraz wartości.
 "Czas: %lu, Głośność: %i/1023, Potencjometr: %i/1023, Temperatura: %i/1023, Jasność: %i/1023\
", // Szablon.
 millis() / 1000, // Argumenty.
 analogRead(Loudness),
 analogRead(Potentiometer),
 analogRead(Temperature),
 analogRead(Brightness));

 file.print(sensorsString); // Dopisuję zawartość tablicy do karty.
 lastWrite = millis(); // Aktualizuję czas dla obliczania interwału.
 Serial.print(sensorsString); // Wysyłam zawartość tablicy na monitor.
}</code></pre>Najpierw jednak określimy interwał – już nie za pomocą funkcji delay, a obliczenia różnicy pokładowego zegara. Gdy nadejdzie czas, utworzymy łańcuch w tablicy. Idea jest podobna, ale wykonanie zupełnie inne. Najpierw tworzymy szablon składający się ze znaków oraz zmiennych, które rozpoczyna znak procentu. I tak: lu oznacza typ long bez znaku, i – int i tak dalej. Niestety ośmiobitowe Arduino zostało tu ogryzione ze zmiennej typu float, więc temperaturę będę zapisywał za pomocą int. Jeśli byłby to problem, należy wcześniej zamienić ten format na zmiennoprzecinkowy, reprezentowany znakami i osadzić go tutaj – ale nie to jest podmiotem rozważań, więc odpuściłem.Mając już szablon, należy wymienić argumenty – w tej samej kolejności, oddzielane przecinkami. Tablica powstała, możemy ją wysłać do karty. Ale bez otwierania, bo karta została już otwarta i także bez zamykania – dzięki czemu pozbędziemy się problemu szybkiego zużywania karty.No dobrze, działa to fajnie, tylko jak zakończyć proces? Otwarta karta wyjęta z czytnika to pokusa, by wszystko się rozleciało. I tu mamy problem. Rozwiązałem to prościutko: wykorzystałem jeden z przycisków na płytce.<pre><code class="language-arduino">if (digitalRead(saveButton) == HIGH) { // Jeśli przycisk zamknięcia pliku został wciśnięty...\n file.flush(); // Zapisuję bufor do pliku.\n file.close(); // Zamkykam plik\n Serial.println(F("\\nZamykam plik DANE.TXT i kończę pracę programu."));\n while (1) // Koniec programu.\n ;\n}</code></pre>Jego wciśnięcie natychmiast zapisze wszystko, co siedzi w pamięci RAM karty w jej komórki i zamknie ją, a następnie zakończy program. Innymi słowy, to taki odpowiednik „Można teraz bezpiecznie wyłączyć komputer” z Windows 95. W praktyce używa się watchdoga albo innych metod wykrywających spadek napięcia zasilającego i na ostatnim tchnieniu zapisują się dane na karcie, po czym następuje jej zamknięcie. Dobrze też cyklicznie, np. raz na kilkaset zapisów, użyć funkcji flush, która zrzuca bufor danych do komórek karty. No i w zastosowaniach przemysłowych raczej nie stosuje się takiego formatu, a same, surowe dane rozdzielone np. przecinkami, który to format łatwo importować choćby do Excela. Opisy zamieściłem tylko na nasze potrzeby, by wszystko było jasne i zrozumiałe.

Nasze zabawy w tworzenie plików i ich edycję mają ciemną stronę: nieumiejętnie wdrożone mogą szybko doprowadzić do zużycia i w rezultacie uszkodzenia karty. Jak się przed tym ustrzec? Poznajmy dwa przykłady: zły i dobry

[164] Karta SD cz. 4

02.png

Czas na operacje wewnątrz plików. W końcu <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/162-karta-sd-cz-2">dotąd uprawialiśmy sztukę dla sztuki,</a> pliki to nośniki danych i teraz te dane stworzymy, a potem je odczytamy.<hr><pre><code class="language-arduino">#include &lt;SD.h&gt; // Biblioteka obsługi karty SD\nFile file;\nconst byte cardCS = 4; // Deklaracja adresu linii CS11\n\nvoid setup() {\n Serial.begin(115200); // Inicjuj port monitora.\n Serial.println(F("\\nCzekam na sygnał z karty SD...")); // Wyślij komunikat.\n if (!SD.begin(cardCS)) { // Inicjuj kartę określając port CS (jeśli brak - pin 10)\n Serial.println(F("Niepowodzenie, nie wykryto karty.")); // Karta nie została wykryta.\n while (1) // Koniec programu.\n ;\n }\n Serial.println(F("Powodzenie, wykryto kartę."));\n\n Serial.println(F("\\nUsunę plik DANE.TXT..."));\n SD.remove("DANE.TXT"); // Usuwam plik DANE.TXT\n\n Serial.println(F("\\nStworzę plik DANE.TXT...")); // Zapis w pliku.\n file = SD.open("DANE.TXT", FILE_WRITE); // Otwieram plik DANE.TXT, który będzie zapisywany.\n if (file) { // Jeśli udało się otworzyć plik...\n Serial.println(F("Powodzenie, stworzyłem plik DANE.TXT"));\n Serial.println(F("\\nW pliku DANE.TXT zapiszę zdanie: Ala ma kota..."));\n file.println(F("Ala ma kota.")); // Zapisuję w nim zdanie "Ala ma kota."\n file.close(); // Zapisuję wcześniej otwarty plik na karcie.\n Serial.println(F("Plik został zapisany."));\n } else {\n Serial.println(F("Niepowodzenie, nie dałem rady stworzyć pliku DANE.TXT"));\n }\n\n Serial.println(F("\\nOdczytam plik DANE.TXT...")); // Odczyt zawartości pliku.\n file = SD.open("DANE.TXT"); // Otwieram plik DANE.TXT, który będzie odczytywany.\n if (file) { // Jeśli udało się otworzyć plik...\n Serial.print(F("Zawartość pliku DANE.TXT: "));\n while (file.available()) { // Powtarzam do ostatniego bajtu w pliku...\n Serial.write(file.read()); // Czytam bajt i wysyłam go na monitor.\n }\n file.close(); // Zamykam otwarty plik.\n } else {\n Serial.println(F("Niepowodzenie, nie dałem rady otworzyć pliku DANE.TXT"));\n }\n}\nvoid loop() {}\n</code></pre>Początek programu jest identyczny. Następnie stworzymy – albo też otworzymy, jeśli istniał wcześniej – plik DANE.TXT To będzie istotne, ale do tego wrócę zaraz. Ten proces już przeprowadzaliśmy.<pre><code class="language-arduino">Serial.println(F("\\nStworzę plik DANE.TXT...")); // Zapis w pliku.\nfile = SD.open("DANE.TXT", FILE_WRITE); // Otwieram plik DANE.TXT, który będzie zapisywany.\nif (file) { // Jeśli udało się otworzyć plik...\n Serial.println(F("Powodzenie, stworzyłem plik DANE.TXT"));\n Serial.println(F("\\nW pliku DANE.TXT zapiszę zdanie: Ala ma kota..."));\n file.println(F("Ala ma kota.")); // Zapisuję w nim zdanie "Ala ma kota."\n file.close(); // Zapisuję wcześniej otwarty plik na karcie.\n Serial.println(F("Plik został zapisany."));\n} else {\n Serial.println(F("Niepowodzenie, nie dałem rady stworzyć pliku DANE.TXT"));\n}</code></pre>Po otwarciu pliku zapiszemy w nim zdanie „Ala ma kota.”, po czym plik zamkniemy – pamiętajmy, bez tej operacji dane poginą. Ufamy jednak, że się zapisały, ale co sprawdzone to pewne.<pre><code class="language-arduino">Serial.println(F("\\nOdczytam plik DANE.TXT...")); // Odczyt zawartości pliku.\nfile = SD.open("DANE.TXT"); // Otwieram plik DANE.TXT, który będzie odczytywany.\nif (file) { // Jeśli udało się otworzyć plik...\n Serial.print(F("Zawartość pliku DANE.TXT: "));\n while (file.available()) { // Powtarzam do ostatniego bajtu w pliku...\n Serial.write(file.read()); // Czytam bajt i wysyłam go na monitor.\n }\n file.close(); // Zamykam otwarty plik.\n} else {\n Serial.println(F("Niepowodzenie, nie dałem rady otworzyć pliku DANE.TXT"));\n}</code></pre>Zatem teraz znowu otworzymy nasz plik i za pomocą instrukcji file.read odczytamy jego zawartość. Tutaj słówko wyjaśnienia: instrukcja czyta tylko jeden bajt, z adresu tak zwanego kursora. Więc aby przeczytać całość, musimy powtarzać odczyt tyle razy, ile bajtów siedzi w pliku. Po to w pętli występuje druga instrukcja: zwraca liczbę bajtów od pozycji bieżącej do końca zawartości pliku. Adres bieżący zmienia się automatycznie przy każdym odczycie, więc nie trzeba o nim myśleć. Gdy liczba bajtów osiągnie wartość zero, wychodzimy z procedury przekazu zawartości pliku na monitor, zamykamy plik i kończymy zabawę. Tak wygląda zrzut z monitora.<pre><code>Czekam na sygnał z karty SD...\nPowodzenie, wykryto kartę.\n\nStworzę plik DANE.TXT...\nPowodzenie, stworzyłem plik DANE.TXT\n\nW pliku DANE.TXT zapiszę zdanie: Ala ma kota...\nPlik został zapisany.\n\nOdczytam plik DANE.TXT...\nZawartość pliku DANE.TXT: Ala ma kota.</code></pre>Problem pojawi się po resecie. Za każdym razem przybędzie kolejna Ala i kolejny kot. Dlaczego? Bo na końcu pozostawiliśmy plik na karcie, nie usuwając go. Wobec tego instrukcja powołująca do życia ten plik widząc go zignorowała jego tworzenie, a blok zapisujący zdanie „Ala ma kota.” dopisywał je do tego, co znalazł. Po każdym resecie pojawiał się nowy wpis i w ten sposób plik mógł puchnąć w nieskończoność. Dopisanie polecenia usunięcia pliku sprawę rozwiąże.Generalnie biblioteka ogranicza zabawy z plikami do typowych zadań arduinowych. Nie mamy więc tutaj narzędzi do edycji plików. Jest to możliwe tylko po wydobyciu ich zawartości, przepisaniu do pamięci, przeprowadzeniu wymaganych operacji i zapisaniu ich z powrotem – uwzględniając ewentualne wyczyszczenie wcześniejszej zawartości, co najłatwiej uczynić usuwając plik i tworząc nowy, o tej samej nazwie.No właśnie – o ile czytać karty można w nieskończoność, zapisywać bez opamiętania nie wolno. Chyba każdy słyszał o ograniczonej żywotności kart SD i jeśli napiszemy program, który nie uwzględni pewnych zasad z tym związanych, możemy kartę zamordować dosłownie w kilka dni. O tym jak się przed tym ustrzec, <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/164-karta-sd-cz-4">napiszę w ostatniej części serii</a> poświęconej kartom SD.

[163] Karta SD cz. 3

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

Metody

Przeglądaj wg kategorii

Nasi partnerzy