Jak zabezpieczyć kartę przed szybkim zużyciem?

03.png

<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><code class="language-arduino">if (millis() - lastWrite &amp;gt;= interval &amp;amp;&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}</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

01.png

<a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/161-karta-sd-cz-1-1">W poprzednim artykule</a> poznaliśmy karty SD z punktu widzenia arduinowca. Wiemy już jak je podłączać i sprawdzać czy mają ochotę na dialog z naszym systemem. Czas więc nauczyć się rozmawiać z kartami. Na początek – taki trochę DOS: przeprowadzimy szereg operacji na plikach. Stwórzmy więc nowy szkic.<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("\\nCzy na karcie istnieje plik DANE.TXT ?")); // Wykrywanie plików.\n if (SD.exists("DANE.TXT")) { // Sprawdzam czy na karcie istnieje plik DANE.TXT\n Serial.println(F("Znaleziono na karcie plik DANE.TXT"));\n } else {\n Serial.println(F("Nie znaleziono pliku DANE.TXT"));\n }\n\n Serial.println(F("\\nStworzę plik DANE.TXT...")); // Tworzenie plików.\n file = SD.open("DANE.TXT", FILE_WRITE); // Otwieram plik DANE.TXT, który będzie zapisywany.\n file.close(); // Zapisuję wcześniej otwarty plik na karcie.\n if (SD.exists("DANE.TXT")) { // Sprawdzam czy na karcie istnieje plik DANE.TXT\n Serial.println(F("Powodzenie, stworzyłem plik DANE.TXT"));\n } else {\n Serial.println(F("Niepowodzenie, nie dałem rady stworzyć pliku DANE.TXT"));\n }\n\n Serial.println(F("\\nUsunę plik DANE.TXT...")); // Usuwanie plików.\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ę katalog FOLDER...")); // Tworzenie katalogów.\n SD.mkdir("FOLDER"); // Tworzę katalog FOLDER.\n if (SD.exists("FOLDER")) { // Sprawdzam czy na karcie istnieje katalog FOLDER\n Serial.println(F("Powodzenie, stworzyłem katalog FOLDER"));\n } else {\n Serial.println(F("Niepowodzenie, nie dałem rady stworzyć katalogu FOLDER"));\n }\n\n Serial.println(F("\\nUsunę katalog FOLDER...")); // Usuwanie katalogów.\n SD.rmdir("FOLDER"); // Usuwam katalog FOLDER.\n if (SD.exists("FOLDER")) { // Sprawdzam czy na karcie istnieje katalog FOLDER\n Serial.println(F("Niepowodzenie, nie dałem rady usunąć katalogu FOLDER"));\n } else {\n Serial.println(F("Powodzenie, usunąłem katalog FOLDER"));\n }\n\n Serial.println(F("\\nStworzę plik dane.txt w katalogu FOLDER...")); // Tworzenie plików w katalogach.\n SD.mkdir("FOLDER"); // Tworzę katalog FOLDER.\n file = SD.open("FOLDER/DANE.TXT", FILE_WRITE); // Otwieram plik DANE.TXT w katalogu FOLDER, który będzie zapisywany.\n file.close(); // Zapisuję wcześniej otwarty plik na karcie.\n if (SD.exists("FOLDER/DANE.TXT")) { // Sprawdzam czy na karcie istnieje plik DANE.TXT\n Serial.println(F("Powodzenie, stworzyłem plik FOLDER/DANE.TXT"));\n } else {\n Serial.println(F("Niepowodzenie, nie dałem rady stworzyć pliku FOLDER/DANE.TXT"));\n }\n\n Serial.println(F("\\nUsunę plik FOLDER/DANE.TXT oraz katalog FOLDER...")); // Usuwanie plików z katalogów wraz z katalogiem.\n SD.remove("FOLDER/DANE.TXT"); // Usuwam plik FOLDER/DANE.TXT\n SD.rmdir("FOLDER"); // Usuwam katalog FOLDER.\n if (SD.exists("FOLDER/DANE.TXT")) { // Sprawdzam czy na karcie istnieje plik FOLDER/DANE.TXT\n Serial.println(F("Niepowodzenie, nie dałem rady usunąć pliku FOLDER/DANE.TXT"));\n } else {\n Serial.println(F("Powodzenie, usunąłem plik FOLDER/DANE.TXT oraz katalog FOLDER"));\n }\n}\nvoid loop() {}</code></pre>Początek będzie podobny: zaczytanie biblioteki i deklaracja niezbędnego dla jej funkcjonowania obiektu. Różnicę mamy już na wstępie: wykorzystamy alternatywny wobec poprzedniego sposób inicjacji karty. Instrukcja card.init(SPI_HALF_SPEED, cardCS) pozwalała zdefiniować szybkość, metoda SD.begin(cardCS) jest uproszczona i sprowadza się tylko do deklaracji pinu linii dostępu.Pobawmy się plikami. W pierwszym etapie sprawdzimy czy na karcie znajduje się plik DANE.TXT.<pre><code class="language-arduino">Serial.println(F("\\nCzy na karcie istnieje plik DANE.TXT ?")); // Wykrywanie plików.\nif (SD.exists("DANE.TXT")) { // Sprawdzam czy na karcie istnieje plik DANE.TXT\n Serial.println(F("Znaleziono na karcie plik DANE.TXT"));\n} else {\n Serial.println(F("Nie znaleziono pliku DANE.TXT"));\n}</code></pre>Za pomocą instrukcji SD.exists("nazwa pliku"), zwracającej prawdę albo fałsz, dostaniemy odpowiedź. Ponieważ takiego pliku tam nie umieszczałem, utworzę go.<pre><code class="language-arduino">Serial.println(F("\\nStworzę plik DANE.TXT...")); // Tworzenie plików.\nfile = SD.open("DANE.TXT", FILE_WRITE); // Otwieram plik DANE.TXT, który będzie zapisywany.\nfile.close(); // Zapisuję wcześniej otwarty plik na karcie.\nif (SD.exists("DANE.TXT")) { // Sprawdzam czy na karcie istnieje plik DANE.TXT\n Serial.println(F("Powodzenie, stworzyłem plik DANE.TXT"));\n} else {\n Serial.println(F("Niepowodzenie, nie dałem rady stworzyć pliku DANE.TXT"));\n}</code></pre>Jakiekolwiek operacje związane z manipulowaniem treścią plików wymagają operacji otwarcia na początku i zamknięcia na końcu tzw. obiektu, który jest plikiem jako takim, a już jego nazwę definiuje się na miejscu. Tylko jeden plik jednocześnie może być otwarty, więc jeśli będziemy chcieli zająć się innym, musimy zamknąć bieżący. Wszelkie zmiany pliku – jeśli są wymagane – zostaną przeprowadzone właśnie w chwili jego zamknięcia. Pominięcie etapu zamknięcia pliku pogubi nam dane.Przejdźmy więc do etapu drugiego: stwórzmy plik DANE.TXT Otwieramy plik o takiej nazwie w trybie zapisu, po czym go zapisujemy. Na razie będzie pusty. Ponownie sprawdzamy czy na karcie istnieje taki plik. Oczywiście istnieje, bo właśnie go stworzyliśmy. Przetestujmy więc kolejną instrukcję, która usuwa pliki.<pre><code class="language-arduino">Serial.println(F("\\nUsunę plik DANE.TXT...")); // Usuwanie plików.\nSD.remove("DANE.TXT"); // Usuwam plik DANE.TXT\nif (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}</code></pre>Tutaj wykorzystuje się prostą instrukcję, przy czym nie trzeba tym razem otwierać i zamykać obiektu, bo tym razem nie interesuje nas jego treść, a on sam jako całość. Zaraz potem jak zwykle sprawdzam, czy zadanie usuwania zakończyło się powodzeniem.<pre><code class="language-arduino">Serial.println(F("\\nStworzę katalog FOLDER...")); // Tworzenie katalogów.\nSD.mkdir("FOLDER"); // Tworzę katalog FOLDER.\nif (SD.exists("FOLDER")) { // Sprawdzam czy na karcie istnieje katalog FOLDER\n Serial.println(F("Powodzenie, stworzyłem katalog FOLDER"));\n} else {\n Serial.println(F("Niepowodzenie, nie dałem rady stworzyć katalogu FOLDER"));\n}</code></pre>W końcu zajmiemy się katalogami, tudzież – po nowemu: folderami. Katalog tworzymy poleceniem mkdir, przy czym nic tu nie otwieramy i nie zamykamy, bo katalogi to nie pliki. Jak zwykle sprawdzamy, czy powstał taki twór.<pre><code class="language-arduino">Serial.println(F("\\nUsunę katalog FOLDER...")); // Usuwanie katalogów.\nSD.rmdir("FOLDER"); // Usuwam katalog FOLDER.\nif (SD.exists("FOLDER")) { // Sprawdzam czy na karcie istnieje katalog FOLDER\n Serial.println(F("Niepowodzenie, nie dałem rady usunąć katalogu FOLDER"));\n} else {\n Serial.println(F("Powodzenie, usunąłem katalog FOLDER"));\n}</code></pre>Teraz usuniemy katalog dopiero co powstały katalog pleceniem rmdir i znowu sprawdzimy, czy się nam to udało. Pamiętajmy, że usuwać możemy tylko katalogi puste. Jeśli mamy wewnątrz jakiekolwiek pliki – musimy je wcześniej usunąć osobno.<pre><code class="language-arduino">Serial.println(F("\\nStworzę plik dane.txt w katalogu FOLDER...")); // Tworzenie plików w katalogach.\nSD.mkdir("FOLDER"); // Tworzę katalog FOLDER.\nfile = SD.open("FOLDER/DANE.TXT", FILE_WRITE); // Otwieram plik DANE.TXT w katalogu FOLDER, który będzie zapisywany.\nfile.close(); // Zapisuję wcześniej otwarty plik na karcie.\nif (SD.exists("FOLDER/DANE.TXT")) { // Sprawdzam czy na karcie istnieje plik DANE.TXT\n Serial.println(F("Powodzenie, stworzyłem plik FOLDER/DANE.TXT"));\n} else {\n Serial.println(F("Niepowodzenie, nie dałem rady stworzyć pliku FOLDER/DANE.TXT"));\n}</code></pre>Na koniec zostawiłem sobie przypadek pliku w katalogu. Generalnie nie różni się on niczym od tego, co już przedstawiłem. Należy tylko zachować logiczną kolejność. A więc: najpierw tworzymy katalog FOLDER, potem wewnątrz niego – plik DANE.TXT Aby teraz usunąć wszystko, najpierw usuwamy plik, a następnie katalog.<pre><code class="language-arduino">Serial.println(F("\\nUsunę plik FOLDER/DANE.TXT oraz katalog FOLDER...")); // Usuwanie plików z katalogów wraz z katalogiem.\nSD.remove("FOLDER/DANE.TXT"); // Usuwam plik FOLDER/DANE.TXT\nSD.rmdir("FOLDER"); // Usuwam katalog FOLDER.\nif (SD.exists("FOLDER/DANE.TXT")) { // Sprawdzam czy na karcie istnieje plik FOLDER/DANE.TXT\n Serial.println(F("Niepowodzenie, nie dałem rady usunąć pliku FOLDER/DANE.TXT"));\n} else {\n Serial.println(F("Powodzenie, usunąłem plik FOLDER/DANE.TXT oraz katalog FOLDER"));\n}</code></pre>A co będzie gdy stworzymy plik, który już istnieje? Oryginał pozostanie nienaruszony, a przy zapisie nowe treści dołączą do treści już istniejących. Ponowne stworzenie istniejącego już katalogu także nie daje błędu, ale nie wpływa na nic. Poniżej zamieszczam zrzut z monitora ze szkicu, który omawiałem. Niestety w zasobach nie ma instrukcji kopiowania plików, ich przenoszenia po katalogach czy zmiany nazw. Te rzeczy trzeba czynić naokoło, otwierając pliki i przerzucając między nimi ich zawartość.<pre><code>Czekam na sygnał z karty SD...\nPowodzenie, wykryto kartę.\n\nCzy na karcie istnieje plik DANE.TXT ?\nNie znaleziono pliku DANE.TXT\n\nStworzę plik DANE.TXT...\nPowodzenie, stworzyłem plik DANE.TXT\n\nUsunę plik DANE.TXT...\nPowodzenie, usunąłem plik DANE.TXT\n\nStworzę katalog FOLDER...\nPowodzenie, stworzyłem katalog FOLDER\n\nUsunę katalog FOLDER...\nPowodzenie, usunąłem katalog FOLDER\n\nStworzę plik dane.txt w katalogu FOLDER...\nPowodzenie, stworzyłem plik FOLDER/DANE.TXT\n\nUsunę plik FOLDER/DANE.TXT oraz katalog FOLDER...\nPowodzenie, usunąłem plik FOLDER/DANE.TXT oraz katalog FOLDER</code></pre>I to byłoby na tyle w temacie manipulacji plikami. <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/163-karta-sd-cz-3">W kolejnym artykule</a> zajmiemy się już zmienianiem treści plików.

[162] Karta SD cz. 2

O formatach, pojemnościach i dostępności kart w świecie Arduino

0.png

O kartach SD pisałem niedawno, ale temat ograniczyłem do konkretnego zastosowania takiej karty – była nośnikiem dźwięków, które Arduino odtwarzało. Czas wrócić do tematu i przyjrzeć się tej pamięci dokładniej. W maleństwie widocznym na zdjęciu, o wymiarach centymetr na półtora, mieszczą się prawie 2 biliony dwieście miliardów bajtów. Nawet przy upakowaniu 4 bitów w jednej komórce, jest ich tam ponad 4 biliony. Można tam zmieścić na przykład wszystkie istotne dane wszystkich mieszkańców ziemi. Albo 20 milionów książek. Największa biblioteka świata ma ich półtora razy więcej. Dla mnie jest to… co najmniej intrygujące. Ale nie od razu tak było, pierwsze karty pamięci sięgały pojedynczych megabajtów, nie mówiąc o ich protoplastach, które po prostu były pamięciami statycznymi z pokładową baterią.<hr>Czasy różnorodności kart szczęśliwie są już za nami. Wygrał format, można chyba rzec: najlepszy. Ewoluował, kilka razy malał, ale zachował kompatybilność w dół, mechaniczną w pełni, a funkcjonalną w pewnym, wystarczającym jednak praktycznie zakresie. I choć karty SD już pojawiały się w kilku artykułach, dziś będę chciał się nimi zająć stricte.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/1-6a09a27821ea5619294721.png" class="center" loading="lazy">Jak chyba każdy wie, karty SD występują w kilku kształtach, z czego szerzej znane są dwa: historyczny – duży i współczesny: micro. Do ostatnich zwykle dodawano przejściówkę, z której dawno temu można było zbudować interfejsy, bezkarnie lutując przewody do styków. Ale to było w czasach, gdy jeszcze fabrycznych interfejsów nie sprzedawano i dziś to trochę sensu już nie ma. Chcąc używać kart z Arduino, należy za kilka złotych kupić sobie taką płytkę.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/2-6a09a27857c61276164969.png" class="center" loading="lazy">Zwykle siedzi tam także konwerter napięć. Otóż małą niedogodnością jest praca w logice trzywoltowej. Ośmiobitowe Arduino pracują zwykle w pięciu woltach i by spiąć ze sobą urządzenia, potrzebujemy dopasować poziomy. Można to zrobić w prymitywny sposób, za pomocą kilku rezystorów. Będzie to działać dobrze, ale profesjonalne rozwiązania wykorzystują specjalizowane układy konwerterów. Szczegóły połączeń opisałem <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/154-obsluga-kart-sd">w tym artykule,</a> więc nie będę się powtarzać.Karty SD porozumiewają się ze światem kilkoma narzeczami, z których nowoczesne nie będą dostępne dla ośmiobitowych Arduino. Na szczęście kompatybilność oferuje najstarszy interfejs, SPI. Arduino dysponuje nim sprzętowo, a jedyna niedogodność polega na braku możliwości przeorganizowania trzech z czterech linii: piny 11, 12 i 13 będą na stałe przyporządkowane do karty. Skoro wiemy już wszystko co nam będzie potrzebne, podłączmy kartę zgodnie ze sztuką i przetestujmy podstawowe operacje z nią związane. Czwarta linia – dostępu – może być podłączona gdziekolwiek, użyję pinu czwartego. Interfejs widoczny na zdjęciu do pracy potrzebuje pięciu woltów.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/3-6a09a2788c0dc634632046.png" class="center" loading="lazy">Ze względu na zawiły sposób komunikacji z kartami wykorzystuje się tutaj biblioteki. Jest ich kilka, oferują różną liczbę opcji kosztem zasobów. Znajdziemy także ograniczone rozwiązania specjalizowane, na przykład współpracujące z kartami tylko w ramach pobierania danych audio i taki sposób już przedstawiałem. Domyślna biblioteka obsługi kart SD jest już osadzona w środowisku i tej się przyjrzymy, modyfikując na nasze potrzeby przykładowe pliki.<pre><code class="language-arduino">#include &lt;SD.h&gt; // Biblioteka obsługi karty SD\nSd2Card card;\nSdVolume volume;\nSdFile root;\nconst byte cardCS = 4; // Deklaracja adresu linii CS4\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 (!card.init(SPI_HALF_SPEED, cardCS)) { // Inicjuj kartę w trybie SPI z połową szybkości, określając port CS\n Serial.println(F("Niepowodzenie, nie wykryto karty.")); // Karta nie została wykryta.\n while (1) // Koniec programu.\n ;\n } else {\n Serial.println(F("Powodzenie, wykryto kartę.")); // Karta została wykryta.\n }\n Serial.print(F("\\nTyp karty: "));\n switch (card.type()) { // Określ typ karty.\n case SD_CARD_TYPE_SD1: // SD wersja 1\n Serial.println(F("SD v1 (FAT, &lt; 2 GB)"));\n break;\n case SD_CARD_TYPE_SD2: // SD wersja 2\n Serial.println(F("SD v2 (FAT32, &lt; 32 GB)"));\n break;\n case SD_CARD_TYPE_SDHC: // SDHC\n Serial.println(F("SDHC (FAT32, &lt; 32 GB)"));\n break;\n default:\n Serial.println(F("Nieznany.")); // Typ karty nierozpoznany.\n }\n if (!volume.init(card)) { // Inicjacja systemu plików na karcie.\n Serial.println(F("Nie wykryto systemu FAT lub FAT32"));\n while (1) // Koniec programu.\n ;\n }\n unsigned long blocksPerClusterVolume = volume.blocksPerCluster(); // Liczba bloków na klaster.\n Serial.print(F("\\nRozmiar klastra: "));\n Serial.print(blocksPerClusterVolume * 512); // Rozmiar klastra.\n Serial.print(F(" B\\nLiczba klastrów: "));\n Serial.println(volume.clusterCount()); // Liczba klastrów.\n Serial.print(F("Liczba bloków na klaster: "));\n Serial.println(blocksPerClusterVolume); // Liczba bloków na klaster.\n Serial.print(F("Liczba wszystkich bloków: "));\n Serial.println(blocksPerClusterVolume * volume.clusterCount()); // Liczba wszystkich bloków.\n\n Serial.print(F("\\nSystem plików: FAT"));\n Serial.println(volume.fatType(), DEC); // Typ systemu plików.\n unsigned long cardSize = (volume.blocksPerCluster() * volume.clusterCount()) / 2; // Pojemność karty w kB\n Serial.print(F("\\nRozmiar karty (kB): "));\n Serial.println(cardSize);\n Serial.print(F("Rozmiar karty (MB): "));\n Serial.println(cardSize / 1024);\n Serial.print(F("Rozmiar karty (GB): "));\n Serial.println((float)(cardSize / 1024) / 1024.0, 2);\n\n Serial.println(F("\\nZawartość karty:"));\n Serial.println(F("----Nazwa----|---Data---|--Czas--|-Rozmiar"));\n root.openRoot(volume); // Otwarcie głównego katalogu.\n root.ls(LS_R | LS_DATE | LS_SIZE); // Listing: z podkatalogami, z atrybutem czasu, z atrybutem rozmiaru.\n root.close(); // Zamknięcie głównego katalogu.\n}\nvoid loop(void) {}</code></pre>Zadaniem pierwszego szkicu jest test karty. Zwróci on nam istotne informacje na jej temat, pozwalając w razie potrzeby sformatować ją w trybie kompatybilnym z biblioteką. Trzeba pamiętać, że generalnie biblioteki wspierają tylko formaty FAT i FAT32, pojemności do 32 GB i system nazw pochodny z DOS-u, a więc składających się z ośmioznakowej nazwy i trzech znaków rozszerzenia. Unikajmy także polskich liter i innych, dziwnych znaczków. Biblioteka SD.h wspiera katalogi, ale niekoniecznie będą to robić biblioteki lekkie. Przejdźmy więc do analizy.<pre><code class="language-arduino">#include &lt;SD.h&gt; // Biblioteka obsługi karty SD\nSd2Card card;\nSdVolume volume;\nSdFile root;\nconst byte cardCS = 4; // Deklaracja adresu linii CS4\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 (!card.init(SPI_HALF_SPEED, cardCS)) { // Inicjuj kartę w trybie SPI z połową szybkości, określając port CS\n Serial.println(F("Niepowodzenie, nie wykryto karty.")); // Karta nie została wykryta.\n while (1) // Koniec programu.\n ;\n } else {\n Serial.println(F("Powodzenie, wykryto kartę.")); // Karta została wykryta.\n }</code></pre>Na początku oczywiście zaczytujemy bibliotekę SD.h obsługującą karty SD i deklarujemy nazwy obiektów z nią związanych. Kolejno deklarujemy port dostępu, czyli dla linii CS. Jak mówiłem, w przeciwieństwie do pozostałych trzech, może on być obsługiwany dowolnym wolnym pinem. Ponieważ wszystkie testy będziemy przeprowadzać korzystając z monitora, należy go zainicjować, po czym można będzie wysłać komunikat oczekiwania na sygnał z karty. Następnie inicjujemy kartę do pracy z interfejsem SPI, z szybkością połowy maksymalnej, co jest zalecane przy współpracy z ośmiobitowym Arduino. W razie potrzeby mamy jeszcze 1/4 i 1/8 szybkości, ale obecnie tak kiepskich kart się nie spotyka. Pełną szybkość można wybrać po weryfikacji konkretnego przypadku. Drugim argumentem funkcji jest adres pinu dostępu, czyli linii CS. W razie niepowodzenia inicjacji pojawi się stosowny komunikat i program pozostanie w tym miejscu. Jeśli karta dogada się z Arduino, program powiadomi nas o tym i przejdzie do kolejnych testów.<pre><code class="language-arduino">Serial.print(F("\\nTyp karty: "));\nswitch (card.type()) { // Określ typ karty.\n case SD_CARD_TYPE_SD1: // SD wersja 1\n Serial.println(F("SD v1 (FAT, &lt; 2 GB)"));\n break;\n case SD_CARD_TYPE_SD2: // SD wersja 2\n Serial.println(F("SD v2 (FAT32, &lt; 32 GB)"));\n break;\n case SD_CARD_TYPE_SDHC: // SDHC\n Serial.println(F("SDHC (FAT32, &lt; 32 GB)"));\n break;\n default:\n Serial.println(F("Nieznany.")); // Typ karty nierozpoznany.\n}\nif (!volume.init(card)) { // Inicjacja systemu plików na karcie.\n Serial.println(F("Nie wykryto systemu FAT lub FAT32"));\n while (1) // Koniec programu.\n ;\n}</code></pre>Teraz określimy typ karty i system plików. Interesują nas pierwsze trzy generacje kart, oznaczane jako SD wersja pierwsza, druga i SDHC. Pierwszy przypadek jest najstarszy i wspiera karty do 2 GB. Domyślnym systemem plików jest FAT. Drugi typ daje dostęp do 32 GB, więc wymaga systemu FAT32. SDHC wspiera pojemności od 4 do 32 GB, także wymaga systemu FAT32 i tak naprawdę różni się wewnętrzną architekturą struktury plików, co dla nas będzie nieistotne. Inne systemy plików, w szczególności exFAT nie są wspierane i jeśli osadzimy tak sformatowaną kartę, dostaniemy stosowny komunikat.<pre><code class="language-arduino">unsigned long blocksPerClusterVolume = volume.blocksPerCluster(); // Liczba bloków na klaster.\nSerial.print(F("\\nRozmiar klastra: "));\nSerial.print(blocksPerClusterVolume * 512); // Rozmiar klastra.\nSerial.print(F(" B\\nLiczba klastrów: "));\nSerial.println(volume.clusterCount()); // Liczba klastrów.\nSerial.print(F("Liczba bloków na klaster: "));\nSerial.println(blocksPerClusterVolume); // Liczba bloków na klaster.\nSerial.print(F("Liczba wszystkich bloków: "));\nSerial.println(blocksPerClusterVolume * volume.clusterCount()); // Liczba wszystkich bloków.</code></pre>Kolejny blok oblicza nam: rozmiar klastra, ich liczbę, liczbę bloków na klaster i sumę wszystkich bloków. Klaster jest jak gdyby kartką papieru do zapisania. Możemy zapisać tylko jedną literę – jeden bajt – a i tak musimy użyć całej kartki. Jeśli liczba liter – czyli u nas rozmiar pliku – przekroczy pojemność klastra, będziemy musieli sięgnąć do kolejnego i tak dalej, nawet gdy braknie miejsca tylko dla jednego nadmiarowego bajtu.Liczba bloków na klaster określa jego rozmiar. Klaster może składać się minimalnie z jednego bloku, a maksymalnie z 64. Warunkowo ze 128. Blok zawsze zawiera 512 bajtów, więc klaster może przyjmować rozmiar od tej wartości do 32 kB (warunkowo do 64). Im większy klaster, tym więcej miejsca zmarnujemy – pamiętajmy, że nawet jeden bajt zapisu zaokrąglany jest do pełnej pojemności klastra. Z drugiej strony deklarowanie zbyt małego klastra zwolni pracę z kartą. Deklaracje rozmiaru klastra możemy przeprowadzić podczas formatowania karty. W końcu program podaje nam liczbę wszystkich bloków, czyli obszarów po 512 bajtów.<pre><code class="language-arduino">Serial.print(F("\\nSystem plików: FAT"));\nSerial.println(volume.fatType(), DEC); // Typ systemu plików.\nunsigned long cardSize = (volume.blocksPerCluster() * volume.clusterCount()) / 2; // Pojemność karty w kB\nSerial.print(F("\\nRozmiar karty (kB): "));\nSerial.println(cardSize);\nSerial.print(F("Rozmiar karty (MB): "));\nSerial.println(cardSize / 1024);\nSerial.print(F("Rozmiar karty (GB): "));\nSerial.println((float)(cardSize / 1024) / 1024.0, 2);</code></pre>Kolejny blok szkicu określa rodzaj systemu plików oraz pojemność karty w kB, MB i GB. System plików zwraca zmienna fatType, a rozmiary liczymy ze zmiennych poznanych przed chwilą, przy czym widoczny wzór oblicza pojemność w kilobajtach. Pozostałe jednostki otrzymujemy z dzieleń, a dla gigabajtów używamy wartości ułamkowych z dwoma miejscami po przecinku. I to już wszystko jeśli chodzi o strukturę karty.<pre><code class="language-arduino"> Serial.println(F("\\nZawartość karty:"));\n Serial.println(F("----Nazwa----|---Data---|--Czas--|-Rozmiar"));\n root.openRoot(volume); // Otwarcie głównego katalogu.\n root.ls(LS_R | LS_DATE | LS_SIZE); // Listing: z podkatalogami, z atrybutem czasu, z atrybutem rozmiaru.\n root.close(); // Zamknięcie głównego katalogu.</code></pre>Teraz program wylistuje jej zawartość. Zacząć należy od otwarcia głównego katalogu karty – po to, by móc w nim przeprowadzać operacje, w naszym przypadku – odczytu. Następnie wysyłamy rozkaz wyświetlenia zawartości, przy czym pierwszy argument każe analizować także wszystkie podkatalogi, drugi dodatkowo wyświetla czas zmiany zawartości plików, trzeci – ich rozmiary. Zawsze po użyciu karty należy zamknąć dostęp tą komendą.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/4-sd-64mfat-6a09c14b4de51930463746.png" class="center" loading="lazy">Przetestujmy sobie teraz kilka kart. Na początek – taka prastara, o pojemności 64 MB, wyciągnięta z jakieś dwudziestowiecznej Nokii.<pre><code>Czekam na sygnał z karty SD...\nPowodzenie, wykryto kartę.\nTyp karty: SD v1 (FAT, &lt; 2 GB)\nRozmiar klastra: 1024 B\nLiczba klastrów: 61056\nLiczba bloków na klaster: 2\nLiczba wszystkich bloków: 122112\nSystem plików: FAT16\nRozmiar karty (kB): 61056\nRozmiar karty (MB): 59\nRozmiar karty (GB): 0.06\nZawartość karty:\n----Nazwa----|---Data---|--Czas--|-Rozmiar\nKATALOG/ 2026-03-29 20:06:04\nPLIK_3.TXT 2026-03-29 20:07:08 12\nPLIK_1.TXT 2026-03-29 20:04:20 11\nPLIK_2.TXT 2026-03-29 20:05:38 10</code></pre>Jak widać, tak małe pojemności pracują w systemie FAT. Na tej i na kolejnej karcie umieściłem trzy pliki, w tym jeden w katalogu, po to, byśmy mogli przetestować je także czysto praktycznie. Listing ukazuje się w postaci typowego drzewka, co niestety przesuwa formatowanie.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/5-sd-2gfat-6a09c14b81a9e242862220.png" class="center" loading="lazy">Następna karta ma pojemność 2 GB, co było granicą w pierwszych latach ich używania.<pre><code>Czekam na sygnał z karty SD...\nPowodzenie, wykryto kartę.\nTyp karty: SD v2 (FAT32, &lt; 32 GB)\nRozmiar klastra: 32768 B\nLiczba klastrów: 61109\nLiczba bloków na klaster: 64\nLiczba wszystkich bloków: 3910976\nSystem plików: FAT16\nRozmiar karty (kB): 1955488\nRozmiar karty (MB): 1909\nRozmiar karty (GB): 1.86\nZawartość karty:\n----Nazwa----|---Data---|--Czas--|-Rozmiar\nKATALOG/ 2026-03-29 20:06:04\nPLIK_3.TXT 2026-03-29 20:07:08 12\nPLIK_1.TXT 2026-03-29 20:04:20 11\nPLIK_2.TXT 2026-03-29 20:05:38 10</code></pre>O ile w poprzednim przypadku rozmiar klastra wynosił kilobajt, tutaj osiągnął największą wartość: 32 kB. To duża strata przy zapisie małych plików, jakie w świecie Arduino mają zwykle miejsce, na przykład podczas zrzucania jakichś wartości mierzonych cyklicznie. Dlatego warto takie karty formatować w systemie FAT32. Spójrzmy na kolejny przykład.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/6-sd-4gfat32-6a09c14bb573c452233186.png" class="center" loading="lazy"><pre><code>Czekam na sygnał z karty SD...\nPowodzenie, wykryto kartę.\nTyp karty: SDHC (FAT32, &lt; 32 GB)\nRozmiar klastra: 4096 B\nLiczba klastrów: 964992\nLiczba bloków na klaster: 8\nLiczba wszystkich bloków: 7719936\nSystem plików: FAT32\nRozmiar karty (kB): 3859968\nRozmiar karty (MB): 3769\nRozmiar karty (GB): 3.68\nZawartość karty:\n----Nazwa----|---Data---|--Czas--|-Rozmiar\nKATALOG/ 2026-03-29 20:06:04\nPLIK_3.TXT 2026-03-29 20:07:08 12\nPLIK_1.TXT 2026-03-29 20:04:20 11\nPLIK_2.TXT 2026-03-29 20:05:38 10</code></pre>Ta karta jest dwukrotnie większa, a klaster zmalał ośmiokrotnie. Taka wartość – 4 kB – jest optymalna ze względu na zużycie miejsca i szybkość dostępu do danych.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/7-sd-32gfat32-6a09c14be9fd2115539309.png" class="center" loading="lazy">Maksymalna pojemność, jaką obsługuje ta biblioteka to 32 GB. Być może dało by się pracować z kartami o dwukrotnie większej pojemności, ale nie mogę tego potwierdzić, a karty o takiej pojemności nie posiadam. W takiej sytuacji należy po prostu użyć innej biblioteki, jak na przykład SdFat. Spójrzmy na raport po wstawieniu karty 32 GB<pre><code>Czekam na sygnał z karty SD...\nPowodzenie, wykryto kartę.\nTyp karty: SDHC (FAT32, &lt; 32 GB)\nRozmiar klastra: 16384 B\nLiczba klastrów: 1946656\nLiczba bloków na klaster: 32\nLiczba wszystkich bloków: 62292992\nSystem plików: FAT32\nRozmiar karty (kB): 31146496\nRozmiar karty (MB): 30416\nRozmiar karty (GB): 29.70\nZawartość karty:\n----Nazwa----|---Data---|--Czas--|-Rozmiar\nKATALOG/ 2026-03-29 20:06:04\nPLIK_3.TXT 2026-03-29 20:07:08 12\nPLIK_1.TXT 2026-03-29 20:04:20 11\nPLIK_2.TXT 2026-03-29 20:05:38 10</code></pre>Klaster urósł czterokrotnie, ale możemy podczas formatowania wymusić zmniejszenie jego rozmiaru do 8 kB. A co będzie, gdy wstawimy kartę sformatowaną w systemie exFAT, NTFS bądź zbyt dużą – w tym wypadku 256 GB?<pre><code>Czekam na sygnał z karty SD...\nPowodzenie, wykryto kartę.\nTyp karty: SDHC (FAT32, &lt; 32 GB)\nNie wykryto systemu FAT lub FAT32</code></pre>Dostaniemy lakoniczny komunikat, choć może nieco mylić opis. Dokładniejszych danych trzeba szukać, podłączając kartę do komputera. Na dziś to wszystko, <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/162-karta-sd-cz-2">w kolejnym artykule</a> spróbujemy kartę wykorzystać praktycznie.

[161] Karta SD cz. 1

167.png

Podczas gdy społeczność elektroników w naszym kraju często z lekceważeniem podchodzi do tematu Arduino, w czasie ostatnio odbywających się Dni Arduino, w Wietnamie na czterech uniwersytetach jednocześnie zorganizowano zajęcia dla ponad tysiąca studentów, zaznajamiając ich z tematem, z którym wielu spotkało się pierwszy raz w życiu. Oprócz typowych zajęć informujących o idei i wyjaśniających czym jest Arduino, był też czas dla ćwiczeń praktycznych, podczas których głównym zadaniem było zbudowanie urządzenia monitorującego pomiar tętna i poziomu saturacji krwi. Wybranie takich przykładów zamiast nudnego migania diodami uświadamiało rzeczywistą wartość idei i jej potencjał.Skupiono się również na możliwości wykorzystania sztucznej inteligencji w edukacji, która okazuje się być świetnym nauczycielem, tym bardziej, że skala jest tu zupełnie inna niż w przypadku dużych aplikacji i już dziś wyniki współpracy człowieka i AI są obiecujące. Podkreślano jednak, iż takiej współpracy trzeba się nauczyć, nie traktując AI jak generatora gotowych rozwiązań, a raczej jak partnera, który realizuje za człowieka mniej ciekawe, a uciążliwe etapy, dając czas dla opracowania konceptu i doszlifowania gotowego projektu w zakresie często niedocenianym: ergonomii, niezawodności, a nawet ceny gotowego projektu.

Podczas gdy społeczność elektroników w naszym kraju często z lekceważeniem podchodzi do tematu Arduino, w czasie ostatnio odbywających się Dni Arduino, w Wietnamie na czterech uniwersytetach jednocześnie zorganizowano zajęcia dla ponad tysiąca studentów, zaznajamiając ich z tematem, z którym wielu spotkało się pierwszy raz w życiu. Oprócz typowych zajęć informujących o idei i wyjaśniających czym jest Arduino, był też czas dla ćwiczeń praktycznych, podczas których głównym zadaniem było zbudowanie urządzenia monitorującego pomiar tętna i poziomu saturacji krwi. Wybranie takich przykładów zamiast nudnego migania diodami uświadamiało rzeczywistą wartość idei i jej potencjał.

Arduino w Wietnamie

O ditheringu i jego wpływie na brzmienie

Czy jest możliwe, by bardzo prosty – jak na dzisiejsze standardy – ośmiobitowy mikrokontroler klasy ATmega328, któremu w zasadzie bliżej do Z80 z lat siedemdziesiątych, niż do tego, co siedzi w smartfonach, mógł odtwarzać muzykę z kart SD i to z jakością więcej niż przyzwoitą? I tak, i nie. Nie – jeśli byśmy chcieli napisać całą obsługę tego procederu sami, bez wstawek asemblerowych. Tak – bo zdolni ludzie zrobili to za nas i takie rozwiązanie dziś właśnie opiszę.<hr>Na początek wiadomość zła i dobra. Arduino Uno i pochodne nie mają przetworników cyfrowo-analogowych, więc teoretycznie żadnego audio nie może tu być bez podłączenia przetworników zewnętrznych. Ale możemy tutaj znaleźć sześć wyjść PWM, które – o czym już pisałem niejeden raz – autonomicznie generują przebieg o ustalonej częstotliwości, ale o zmiennym wypełnieniu. Po scałkowaniu takiego sygnału, czy to filtrem dolnoprzepustowym, czy samym odbiornikiem (żarówką, głośnikiem itd.), może się okazać, że oczekiwane rezultaty będą satysfakcjonujące.To działa świetnie w przypadku diod świecących, gdzie elementem całkującym są nasze oczy, widzące powyżej pewnej częstotliwości sterującej jedynie różne poziomy świecenia, a nie mruganie. W przypadku silników także to działa dobrze. I tutaj całkowanie zapewniała bezwładność samego silnika, co najwyżej brzęczącego cicho do taktu częstotliwości pracy wyjścia PWM. A czy da się taką sztukę zrobić z dźwiękiem, skoro wymienione doświadczenia z silnikami dostarczały nam zakłócających pisków?Owszem, pod jednym warunkiem: częstotliwość pracy generatora musi znajdować się dużo wyżej od podwójnej wartości najwyższej częstotliwości, którą chcemy odtworzyć. A najlepiej daleko w ultradźwiękach, żeby wszelkie zakłócenia brzęczały sobie tam, gdzie i tak ich nie usłyszymy. Z tego wynika, że częstotliwość pracy przetworników musi wynosić co najmniej 40 kHz. Jak się to ma do wartości 490 Hz, która jest typową częstotliwością PWM w Arduino?Otóż nie jest to jedyna dostępna wartość. Dla każdego z trzech timerów, które sterują przetwornikami, mamy kilka ustalonych częstotliwości i na szczęście znajdziemy tam jedną z pasma ultradźwięków, równą 62,5 kHz. Zatem przynajmniej teoretycznie – da się zrealizować przetwornik cyfrowo analogowy do zadań audio, z wykorzystaniem wyjść PWM w Arduino Uno R3.Czas na drugą wiadomość złą i dobrą. Pamięć pokładowa to 32 kB. Przy czym musi się tam zmieścić jeszcze program. To śmiesznie mała ilość, jeśli przechowywać w niej sample, aczkolwiek da się i przykład całkiem praktycznego rozwiązania <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/152-gadajacy-woltomierz-cz-1">przedstawiałem niedawno.</a> Zatem do mówienia „dzień dobry” urządzenie nadaje się już i na tym etapie moglibyśmy opowieść zakończyć. Zapewne jednak każdy chciałby słuchać własnego „dzień dobry”, a nie mojego. Nic prostszego: należy na kartę wrzucić własne nagranie. Ale nie tak hop-siup.I tutaj mamy drugie ograniczenie, związane z częstotliwością wyjścia PWM. Jak mówiłem, pracuje ono z szybkością 62,5 kHz i taką właśnie częstotliwość próbkowania winny mieć pliki wrzucane na kartę. Mało tego, powinny być to pliki ośmiobitowe w standardzie bezznakowym i pozbawione nagłówka. Zatem popularne WAV-y czy empetrójki należy przekonwertować do takiego formatu. Źródła biblioteki opisują metody takiej konwersji i można z nich skorzystać, ale ja za chwilę zaproponuję coś lepszego. Bo skoro już wszystko gra, przyszedł czas na analizę jakości owego grania.Wśród załączników przygotowałem kilka testów. Są to kompilacje tak często prezentowane przeze mnie w filmach na moim kanale o różnych urządzeniach audio. Pierwszym z nich będzie 8bit.asf, który jest właśnie przekonwertowanym – zgodnie z zaleceniem autora biblioteki – plikiem testowym. Ach, bo nie wspomniałem: przełączymy teraz pracę w tryb stereo, wyciskając ostatnie poty z małego Arduino. Zatem należy także odłączyć głośnik i podłączyć wyjście 9 i 10 do wzmacniacza, na wejście liniowe, dla bezpieczeństwa najlepiej przez rezystor 1k.<pre><code class="language-arduino">#include &lt;SimpleSDAudio.h&gt; &nbsp;// Biblioteka odtwarzania sampli z karty SD.\n\nvoid setup() {\n&nbsp; SdPlay.init(SSDA_MODE_FULLRATE | SSDA_MODE_STEREO | SSDA_MODE_AUTOWORKER); &nbsp;// Inicjalizacja biblioteki.\n&nbsp; SdPlay.setFile("8bit.afs"); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Pobierz plik "8bit.afm"\n&nbsp; SdPlay.play(); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Odtwórz go.\n}\nvoid loop() {}</code></pre>Program nie różni się niczym od tego, co prezentowałem w poprzednim artykule, z jedną jednak różnicą: wymuszamy pracę stereo. Po skompilowaniu programu i oczywiście wrzuceniu pliku na kartę powinniśmy usłyszeć mniej więcej to, co możemy pod nazwą 8bit.mp3 znaleźć wśród załączników.Niestety, to jest plik ośmiobitowy i słychać całe dobrodziejstwo ubogiej rozdzielczości. W każdym, nieco cichszym miejscu, coś tam namolnie trzeszczy, a gdy głośność spada poniżej pewnego poziomu nagle robi się głucha cisza. I teoretycznie tutaj byśmy sprawę mogli zamknąć jako nierozwiązywalną. Na szczęście rozwiązanie autora biblioteki przewiduje pracę szesnastobitową, ale w mono bądź z połową częstotliwości, co niestety miałoby wpływ na utratę wysokich tonów.I teraz wjeżdża, cała na biało, fizyka, a w zasadzie psychoakustyka, z bohaterem o nazwie dithering. O zjawisku napisano tomy, w uproszczeniu polega na dodaniu szumu o bardzo niskim poziomie, który maskuje zniekształcenia harmoniczne i wszelkie błędy kwantyzacji, na przykład te, które było wyraźnie słychać na przegwiździe. A będzie jeszcze lepiej, gdy użyjemy dodatkowej metody, tak zwanego kształtowania szumu, która to ów dodany szum w większości wrzuci – no właśnie, mając tak wysoką częstotliwość próbkowania – poza zakres słyszalny, czyli w ultradźwięki.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/1-69c81b13d5079482415225.png" class="center" loading="lazy">Jednak sprawna kontrola tego zjawiska jest możliwa tylko w bardziej zaawansowanych programach do obróbki dźwięku. Użyłem wspomnianego już programu Adobe Audition, w którym można sobie włączyć ową opcję z wieloma różnymi funkcjami. Plik nazwałem stereo.afs i tym będziemy się teraz bawić. Zatem kompilujemy i… możemy od razu posłuchać płytki z Arduino albo wersji zgranej do załącznika o nazwie stereo.mp3. To naprawdę dalej jest osiem bitów? Brzmi świetnie! Choć trochę szumi, zupełnie jak magnetofon. W paśmie do 18 kHz mamy tutaj dynamikę około 45 dB. Zważywszy, że to szum, który nie robi uszom takiej krzywdy, jest dobrze. Ale o czymś zapomniałem.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/2-69c81b14bee8d895533627.png" class="center" loading="lazy">Spójrzmy na widmo: powyżej 20 kHz mamy stały, spory poziom szumów, który robi dla nas dobrą robotę, ale zarazem także wpada na wejście wzmacniacza, a tego już robić nie powinien. Zatem należy sprzętowo ograniczyć pasmo. Najprościej – wsadzając dwa ceramiczne kondensatory 10 bądź 22 nF. Ambitniej należałoby zrobić porządne filtry albo ukraść te z lepszych radioodbiorników, blokujących sygnał MPX. Często są to filtry wyższego rzędu, wykorzystujące cewki i poradziłyby sobie tutaj znakomicie. Ograniczyłem się jednak do filtrów najprostszych, które niestety obcinają nieco pasmo słyszalne. Dlatego już po nagraniu wyrównałem charakterystykę, ale bez podbijania dźwięków wyższych niż 20 kHz. Po takich zabiegach całość zabrzmi świetnie. Dynamika do 18 kHz sięgnie 52 dB i żadnych świerszczy tutaj słychać nie będzie. Oczywiście nie jest to tak doskonałe jak prawdziwe 16 bitów ze współczesnych przetworników audio, ale w zasadzie do wszystkich zadań stawianych przed Arduino wystarczy. Trzeba też pamiętać, ze przetworniki cyfrowo – analogowe zrealizowane w ten sposób mają cyfrową liniowość, na pewno lepszą niż wszelkie drabinki rezystorów i tego typu rozwiązania tanie.<a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/156-arduino-i-perkusja-z-sampli">W kolejnym artykule</a> zbudujemy sobie coś praktycznego… a, nie będę zdradzał, niech to będzie niespodzianką :)

[155] Arduino Hi-Fi

<a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/152-gadajacy-woltomierz-cz-1">Poprzedni artykuł</a> zakończyłem wtłoczeniem w pamięć Arduino Uno trzy i półsekundowego sampla. Myślę, że niejednego zaskoczy fakt, iż ten komunikat zajmuje tylko 26 kB. Oczywiście głośniczek podłączony wprost pod pin nie da wielkiej głośności i w razie potrzeby będzie trzeba wstawić wzmacniacz, choćby najprostszy, z jednego tranzystora. Po chwili zachwytów jednak zacznie nas irytować pisk. Cóż, PWM pracuje z częstotliwością 8 kHz, a to jest słyszalne i niemiłe. Zróbmy coś z tym.<hr><pre><code class="language-arduino">#include &lt;avr/pgmspace.h&gt; &nbsp;// Zapisy co prawda nie są wymagane, ale zalecane.\n#include &lt;avr/interrupt.h&gt;\n\nconst unsigned char sample[] PROGMEM = { &nbsp;// Tablica zawierająca próbki sampla.\n&nbsp; 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x81, 0x81, 0x81, 0x81,\n&nbsp; 0x81, 0x81, 0x80, 0x80, 0x81, 0x82, 0x81, 0x81, 0x80, 0x80, 0x81, 0x80,\n&nbsp; 0x80, 0x81, 0x81, 0x7F, 0x7F, 0x81, 0x81, 0x81, 0x80, 0x82, 0x83, 0x80,\n&nbsp; // Dla czytelności usunąłem pozostałe wiersze tablicy.\n&nbsp; 0x80, 0x7F, 0x80, 0x81, 0x80, 0x80, 0x80, 0x80\n};\nconst int sampleLen = sizeof(sample); &nbsp;// Długość sampla (dźwięku).\nvolatile int samplePos = 0; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Adres aktualnie odtwarzanej próbki sampla.\nvolatile byte oversampling = 0; &nbsp; &nbsp; &nbsp; &nbsp;// Licznik ominięcia zmiany stanu PWM dla nadpróbkowania.\n\nvoid setup() {\n&nbsp; pinMode(9, OUTPUT); &nbsp; // Ustaw port PWM jako wyjściowy.\n&nbsp; TCCR1A = 0b10000010; &nbsp;// Konfiguruj timer 1: nieodwracające PWM, szybkie PWM.\n&nbsp; TCCR1B = 0b00011001; &nbsp;// Zliczaj do ICR1, praca bez prescalera (16 MHz)\n&nbsp; ICR1 = 499; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Ustaw częstotliwość przerwań na 32 kHz (16MHz/32kHz-1)\n&nbsp; OCR1A = 128; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Startuj od wartości ciszy.\n&nbsp; samplePos = 0; &nbsp; &nbsp; &nbsp; &nbsp;// Zeruj adres odtwarzanej próbki sampla.\n&nbsp; TIMSK1 = 0b00000010; &nbsp;// Podłącz do przerwań źródło pochodzące z timera 1\n&nbsp; sei(); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Włącz przerwania.\n}\n\nvoid loop() {\n}\n\nISR(TIMER1_COMPA_vect) { &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Obsługa przerwań od timera 1\n&nbsp; if (++oversampling &amp; 3) return; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Opuszczaj trzy na cztery wejścia w przerwanie.\n&nbsp; if (samplePos &lt; sampleLen) { &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Jeśli wciąż trwa obsługa odtwarzania sampla...\n&nbsp; &nbsp; OCR1A = pgm_read_byte(&amp;sample[samplePos++]); &nbsp;// Ładuj próbkę z tablicy do rejestru PWM i zwiększ jej adres.\n&nbsp; } else { &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Jeśli to już była ostatnia próbka...\n&nbsp; &nbsp; TIMSK1 = 0; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Wyłącz przerwania.\n&nbsp; }\n}</code></pre>Poprawka będzie prosta: powołamy do życia jeszcze jedną zmienną oversampling. W przerwaniu tym razem pozostaniemy co czwarty raz. Pozostałe trzy będziemy opuszczać od razu. Po co tak? Teraz PWM będzie pracować szybciej – z częstotliwością 32 kHz. Taki dźwięk siedzi już wysoko w ultradźwiękach. Ale nasz plik ma nadal częstotliwość próbkowania równą 8 kHz, więc dane nie będą się zmieniać w czterech kolejnych cyklach. Nazywa się to PWM oversampling, bo dotyczy tylko sygnału taktującego. Nie ma wpływu na poprawienie jakości samego odtwarzania, ale usuwa irytujący pisk. Teraz nasza pozytywka zabrzmi już czysto.Czas zrobić coś użytecznego. Będziemy mierzyć napięcia na pinie A1, do którego <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/plytka-edukacyjna-tme">na płytce edukacyjnej TME</a> podpięto potencjometr. Oczywiście w praktycznych rozwiązaniach można sobie tam podpiąć jakąkolwiek wartość mierzoną. Żeby Arduino nie gadało bez końca, odczyt nastąpi po naciśnięciu przycisku przypiętego do pinu ósmego. Na chwilę wrócimy do mojego pliku z poprzedniego artykułu i podzielimy go, zgodnie z wcześniej narysowanymi markerami na dziesięć fragmentów.<img style="text-align: ; display: block" src="https://arduino.pl/api/client/download/file/5-69c66cbb7d764164399048.png" class="center" loading="lazy">Każdy będzie reprezentował jedną z cyfr. Ważne jest, by w miejscach podziału głośność schodziła do zera, inaczej odtwarzanie będzie pełne stuków. Teraz czeka nas mozolna konwersja każdej cyferki na tablicę – zgodnie ze sposobem przedstawionym w poprzednim artykule. W związku z czym tablic będzie dziesięć i będą się nazywać sample z cyfrą, która będzie tam zapisana.<pre><code class="language-arduino">#include &lt;avr/pgmspace.h&gt; &nbsp;// Zapisy co prawda nie są wymagane, ale zalecane.\n#include &lt;avr/interrupt.h&gt;\n\nconst unsigned char sample0[] PROGMEM = { &nbsp;// Tablice zawierająca próbki sampli.\n&nbsp; 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x81, 0x81, 0x81, 0x81,\n&nbsp; 0x81, 0x81, 0x80, 0x80, 0x81, 0x82, 0x81, 0x81, 0x80, 0x80, 0x81, 0x80,\n&nbsp; 0x80, 0x81, 0x81, 0x7F, 0x7F, 0x81, 0x81, 0x81, 0x80, 0x82, 0x83, 0x80,\n&nbsp; // Dla czytelności usunąłem pozostałe wiersze tablicy i wszystkie w pozostałych tablicach.\n&nbsp; 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80\n};\nconst unsigned char sample1[] PROGMEM = {\n};\nconst unsigned char sample2[] PROGMEM = {\n};\nconst unsigned char sample3[] PROGMEM = {\n};\nconst unsigned char sample4[] PROGMEM = {\n};\nconst unsigned char sample5[] PROGMEM = {\n};\nconst unsigned char sample6[] PROGMEM = {\n};\nconst unsigned char sample7[] PROGMEM = {\n};\nconst unsigned char sample8[] PROGMEM = {\n};\nconst unsigned char sample9[] PROGMEM = {\n};\nconst int sampleLens[] PROGMEM = { &nbsp;// Tablica z długościami sampli (dźwięków).\n&nbsp; sizeof(sample0), sizeof(sample1), sizeof(sample2), sizeof(sample3),\n&nbsp; sizeof(sample4), sizeof(sample5), sizeof(sample6), sizeof(sample7),\n&nbsp; sizeof(sample8), sizeof(sample9)\n};\nconst byte *const samples[] PROGMEM = { &nbsp;// Tablica z indeksami tablic z samplami.\n&nbsp; sample0, sample1, sample2, sample3, sample4,\n&nbsp; sample5, sample6, sample7, sample8, sample9\n};\nconst int divisors[4] PROGMEM = { 1000, 100, 10, 1 }; &nbsp;// Tablica z podzielnikami dla kolejnych cyfr mierzonej wartości.\n\nvolatile int samplePos = 0; &nbsp; &nbsp; &nbsp; &nbsp;// Adres aktualnie odtwarzanej próbki sampla.\nvolatile byte oversampling = 0; &nbsp; &nbsp;// Licznik ominięcia zmiany stanu PWM dla nadpróbkowania.\nvolatile byte currentDigit = 0; &nbsp; &nbsp;// Bieżąca cyfra do odtwarzania (0-3)\nvolatile int value = 0; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Wartość mierzona.\nvolatile bool leadingZero = true; &nbsp;// Flaga pomijania nieznaczących zer.\nstatic bool lastButton = LOW; &nbsp; &nbsp; &nbsp;// Poprzedni stan przycisku wyzwalającego czytanie napięcia.\nconst byte button = 8; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Adres przycisku wyzwalającego czytanie napięcia.\nconst byte voltmeter = A1; &nbsp; &nbsp; &nbsp; &nbsp; // Adres portu pomiaru napięcia.\n\nvoid setup() {\n&nbsp; pinMode(button, INPUT_PULLUP); &nbsp;// Ustaw port przycisku jako wejściowy.\n&nbsp; pinMode(9, OUTPUT); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Ustaw port PWM jako wyjściowy.\n&nbsp; TCCR1A = 0b10000010; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Konfiguruj timer 1: nieodwracające PWM, szybkie PWM.\n&nbsp; TCCR1B = 0b00011001; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Zliczaj do ICR1, praca bez prescalera (16 MHz)\n&nbsp; ICR1 = 499; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Ustaw częstotliwość przerwań na 32 kHz (16MHz/32kHz-1)\n&nbsp; OCR1A = 128; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Startuj od wartości ciszy.\n&nbsp; sei(); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Włącz przerwania.\n}\nvoid loop() {\n&nbsp; bool presentButton = digitalRead(button); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Czytaj stan przycisku.\n&nbsp; if (presentButton == HIGH &amp;&amp; lastButton == LOW) { &nbsp;// Jeśli został wciśnięty i był puszczony...\n&nbsp; &nbsp; value = analogRead(voltmeter); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Odczytaj napięcie z portu.\n&nbsp; &nbsp; currentDigit = 0; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Zacznij odczyt od pierwszej cyfry.\n&nbsp; &nbsp; leadingZero = true; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Ustaw status nieznaczących zer.\n&nbsp; &nbsp; samplePos = 0; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Zeruj adres odtwarzanej próbki sampla.\n&nbsp; &nbsp; TIMSK1 = 0b00000010; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Podłącz do przerwań źródło pochodzące z timera 1\n&nbsp; }\n&nbsp; lastButton = presentButton; &nbsp;// Przenieś do poprzedniego stanu przycisku stan obecny.\n}\n\nISR(TIMER1_COMPA_vect) { &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; // Obsługa przerwań od timera 1\n&nbsp; if (++oversampling &amp; 3) return; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Opuszczaj trzy na cztery wejścia w przerwanie.\n&nbsp; byte numberDigit = (value / pgm_read_word(&amp;divisors[currentDigit])) % 10; &nbsp;// Wyłuskaj ze zmiennej value aktualną cyfrę.\n&nbsp; if (leadingZero &amp;&amp; numberDigit == 0 &amp;&amp; currentDigit &lt; 3) { &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Jeśli wykryłeś wiodące zero...\n&nbsp; &nbsp; currentDigit++; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Pomiń czytanie.\n&nbsp; &nbsp; return; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Zakończ obsługę przerwania.\n&nbsp; }\n&nbsp; leadingZero = false; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Nie ma już zer nieznaczących.\n&nbsp; if (samplePos &lt; pgm_read_word(&amp;sampleLens[numberDigit])) { &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Jeśli wciąż trwa obsługa odtwarzania sampla...\n&nbsp; &nbsp; OCR1A = pgm_read_byte((byte *)pgm_read_word(&amp;samples[numberDigit]) + samplePos++); &nbsp;// Ładuj próbkę z tablicy do rejestru PWM.\n&nbsp; } else if (++currentDigit &gt; 3) { &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;// Jeśli to była ostatnia cyfra...\n&nbsp; &nbsp; TIMSK1 = 0; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Wyłącz przerwania.\n&nbsp; } else { &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Jeśli nie ostatnia...\n&nbsp; &nbsp; samplePos = 0; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Zeruj adres odtwarzanej próbki sampla.\n&nbsp; }\n}</code></pre>Wyciąłem je tutaj wszystkie oprócz fragmentu zerowej, bo to zajmuje mnóstwo miejsca, ale chyba wiadomo o co chodzi. Tablic będzie tu więcej. W kolejnej sampleLens mamy długości każdego z sampli, a w jeszcze następnej – samples indeksy, czyli nazwy tablic, by program mógł je łatwo wybierać za pomocą liczb. W końcu mamy jeszcze pomocniczą tablicę divisors z podzielnikami do konwersji czterocyfrowych liczb na cztery oddzielne cyfry.Przybyło trochę stałych, związanych głównie z zamienianiem czterocyfrowej liczby na składowe, pomijaniem zer nieznaczących i obsługę przycisku. Część startowa nie różni się wiele od tego, co było w poprzednim szkicu, natomiast pętla główna nie jest już pusta. Sczytujemy tutaj stan przycisku i porównujemy ze stanem sczytanym w poprzednim przebiegu pętli. Tylko po jego dopiero co wciśnięciu zmierzymy napięcie, przygotujemy domyślny zestaw zmiennych i włączymy przerwania. Dzięki temu odczyt nastąpi zawsze po wciśnięciu przycisku, ale nie będzie się powielał. Resztą zajmują się już przerwania.Mechanizm jest ten sam, co poprzednio, ale całość jest mocno zagmatwana, ponieważ teraz trzeba będzie sięgać do różnych tablic, jako że mamy dziesięć sampli odpowiadających dziesięciu cyfrom. Najpierw wyciągamy jedną z czterech cyfr ze zmierzonej wartości. Jeśli jest to zero wiodące – z wyjątkiem ostatniej liczby – opuszczamy przerwanie.Jeśli odczytano jakąkolwiek inną liczbę, zerujemy flagę zer nieznaczących, żeby nie pominąć zera w środku liczby. Następnie wyciągamy adres konkretnej próbki, tym razem rozbudowanym wzorem, uwzględniającym także wyciągniętą przed chwilą cyfrę. Jeśli wysłaliśmy ostatni bajt ostatniej cyfry, kończymy odtwarzanie.Teraz już możemy się bawić albo wykorzystać ten moduł jakoś pożyteczniej. Moduł jest w pełni użyteczny, choć ma wyraźne ograniczenie: nie łączy cyfr i nie odmienia ich. Nie przeszkadza to w pracy, ale jeśli ktoś chciałby posiąść bardziej elegancki woltomierze – zapraszam do kolejnego artykuł. I na koniec jeszcze – to nie wszystko, co można wycisnąć z 32 kB pamięci. Istnieje możliwość użycia kompresji ADPCM, która redukuje zużycie pamięci jeszcze dwukrotnie. Ale o tym innym razem.W załączniku można znaleźć pełną wersję szkicu oraz sample użyte w projekcie.

[153] Gadający woltomierz cz. 2

Jak zmieścić trzy i pół sekundy dźwięku w Arduino Uno?

Prawdziwą przyjemnością podczas zabaw z Arduino jest wyciskanie z tego komputerka tak zwanych siódmych potów, a dzisiejszy projekt do takich będzie należeć. Tak, Arduino jest komputerem i to ośmiobitowym – jeśli mowa o Uno R3 i pochodnych. Co oznacza, że w roku 2026 patrzy się na niego z pogardą. Tymczasem dla tych, którzy lubią panować nad układami mikroprocesorowymi w pełni bez patrzenia nań jak na czarną skrzynkę, to właśnie ośmiobitowce są wdzięcznym poligonem do zabaw, ponieważ ich złożoność nie przekracza możliwości poznawczych ludzkiego mózgu, niekoniecznie mózgu geniusza.<hr>Dzisiaj postaram się wycisnąć co nieco z tego przestarzałego, a jednak wciąż użytecznego serca Arduino. Zbudujemy mówiący woltomierz, ale – uwaga – bez dodawania do Arduino czegokolwiek z wyjątkiem głośnika. Innymi słowy, całe źródło gadania wraz z kodem musi się zmieścić w pamięci pokładowej, której mamy 32 kB. Z punktu widzenia audio – żałośnie mało. Czy aby na pewno?Zacznijmy od założeń. Niech nasze Arduino informuje o mierzonym napięciu za pomocą dźwięków – konkretnie serii wyrazów od zera do dziewięciu. To nieco ułomne, bo w przypadku na przykład 235 woltów usłyszymy: dwa, trzy, pięć. Ułomne, ale użyteczne. Taki woltomierz jest w miarę czytelny, a ma jedną, ogromną zaletę: uwalnia wzrok od cyferek czy wskazówki, pozwalając na pomiary w układzie bez wstępnego podłączania kabli. Ale tym się zajmiemy później. Na razie przeanalizujmy sprawy audio.Nagrajmy sobie odliczanie: od zera do dziewięciu. Proponuję raczej liczyć żwawo, dynamicznie, bez wyróżniania jakiejkolwiek cyfry. Mój przykład można usłyszeć w załączniku pierwszym. Teraz trzeba owo nagranie przygotować do stawianych zadań. Do tego celu będę używał aplikacji Adobe Audition, ale wskazówki tu przedstawione są uniwersalne i niezależne od edytora.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/1-69c66cbb498cd501639500.png" class="center" loading="lazy">Najpierw więc wytnijmy najniższe basy: nic nie wnoszą, a zabierają energię przekazowi.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/2-69c66cba9e22c579080386.png" class="center" loading="lazy">Proponuję także podbić okolice 3-4 kHz, tak o 3 dB, nie więcej. Zwiększy nam to czytelność komunikatów.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/3-69c66cbb16226937163851.png" class="center" loading="lazy">Kolejnym elementem będzie użycie kompresora, który wyrówna głośności zarówno poszczególnych wyrazów jak i ich fragmentów.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/4-69c66cbbe82c3922131952.png" class="center" loading="lazy">Ostatni efekt to użycie deesera, czyli kompresora głosek syczących. On znowu przywróci równowagę między różnymi rodzajami odgłosów.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/5-69c66cbb7d764164399048.png" class="center" loading="lazy">Czeka nas teraz mozolna praca: należy wyciąć wszystkie przerwy i marudzenia, scalając ze sobą wypowiedziane wyrazy – zupełnie nierozdzielone. Taki plik brzmi to dziwnie, ale docelowo nie będziemy używać całego nagrania, a fragmentów. Dlatego podczas tej operacji trzeba pozaznaczać granice między cyframi. Potem potniemy ten słowotok na kawałki. Zauważmy, że wszystkie dziesięć cyfr po tej operacji udało się zawrzeć w trzech i trzech dziesiątych sekundy. Ile to jest bajtów? Przyjmijmy: zapis mono, 44,1 kHz przy 16 bitach zajmie nam 2,34 MB. Arduino, które dysponuje 32 kB, zupełnie się do odtwarzania takich sampli nie nadaje. I tu powinniśmy historię zakończyć, sięgając po przynajmniej jakiegoś ARM-a albo kartę pamięci. Tymczasem należy się zastanowić, czy da się obniżyć jakość tak, by zmieścić ponad dwa megabajty danych w 32 kB.Mowa ludzka jest w pełni czytelna po ograniczeniu pasma do 4 kHz, a nawet niżej. Wszak pierwszy program polskiego radia nadający na falach długich nie przekracza kilku kiloherców pasma. Więc mamy pierwszy potencjał. Drugi tkwi w rozdzielczości. Dla tak dynamicznych i krótkich komunikatów słownych obniżenie jej do ośmiu bitów będzie praktycznie niesłyszalne. Zatem – do roboty.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/6-69c66cbbb3d59770294481.png" class="center" loading="lazy">A teraz posłuchajmy wyniku, którego możemy posłuchać w załączniku drugim. Dźwięk jak gdyby zmatowiał, ale nadal jest czytelny. Najważniejsze jest jednak to, że teraz zajmuje – uwaga: 26 kB. A to nam się spokojnie zmieści w pamięci pokładowej Arduino Uno.Trzeba teraz opracować sposób na to, by ten plik wepchnąć do Arduino i jakoś go wygenerować. Na temat generacji dźwięków przez Arduino napisałem kilka artykułów, jednak zawsze korzystaliśmy z kart pamięci. Dziś nie będziemy potrzebować niczego. Jak zwykle skorzystam <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/plytka-edukacyjna-tme">z płytki edukacyjnej TME,</a> gdzie mogę podpinać różne rzeczy, w szczególności głośnik. Zbudujemy przedstawiany już przeze mnie kiedyś prymitywny przetwornik cyfrowo analogowy z użyciem PWM.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/7-69c66cbc7ea6e911478371.png" class="center" loading="lazy">Po szczegóły zapraszam <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/063-pwm-i-piski">do wspomnianego artykułu,</a> tutaj tylko przypomnę: jeśli częstotliwość pracy PWM będzie wystarczająco duża i będziemy zmieniać wypełnienie zgodnie z danymi z pliku audio, w głośniku pojawi się dźwięk bliski temu, co nagraliśmy. Tak więc mamy do rozwiązania następujące problemy: przenieść plik z dźwiękiem do szkicu i napisać program, który te dane wyśle na głośnik. Przypomnę, że głośnik musi mieć przynajmniej setkę omów, a jeśli użyjemy bardziej zwyczajnego – należy podłączyć go przez rezystor.Do pierwszego etapu będą potrzebne następujące działania. Najpierw zapiszemy nasz ośmiobitowy dźwięk o częstotliwości próbkowania osiem kiloherców nie jako typowy WAV, a plik bez nagłówka, tak zwany surowy RAW w formacie „bez znaku”.<img style="text-align: ; text-align: ; display: block" src="https://arduino.pl/api/client/download/file/8-69c66cbc28130670086051.png" class="center" loading="lazy">Będzie to znaczyło, że wartości przyjmą liczby naturalne od zera do 255, przy poziomie ciszy na pozycji 128. Innymi słowy, wykres przesunie się o połowę zakresu, by uniknąć liczb ujemnych. Powstanie bliźniaczy plik z rozszerzeniem PCM, ale troszkę mniejszy, bo nie będzie zawierać żadnych danych poza samym dźwiękiem.Teraz musimy sobie zrobić z tego tablicę przyjazną dla języka C, którą wkleimy potem do szkicu. W sieci znalazłem malutki program: bin2hex, który zamienia pliki binarne na tekstowe tablice. Program nie ma interfejsu, ale składnia jest prosta. W wyniku jego działania dostaniemy wielką tablicę.Czas na drugi etap. Program będzie dość prosty, choć wybiegnie poza typowe arduinowe elementy, bo wprost będziemy operować na rejestrach kontrolera, przystosowując je dla naszego odtwarzacza.<pre><code class="language-arduino">#include &lt;avr/pgmspace.h&gt; &nbsp;// Zapisy co prawda nie są wymagane, ale zalecane.\n#include &lt;avr/interrupt.h&gt;\n\nconst unsigned char sample[] PROGMEM = { &nbsp;// Tablica zawierająca próbki sampla.\n&nbsp; 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x81, 0x81, 0x81, 0x81,\n&nbsp; 0x81, 0x81, 0x80, 0x80, 0x81, 0x82, 0x81, 0x81, 0x80, 0x80, 0x81, 0x80,\n&nbsp; 0x80, 0x81, 0x81, 0x7F, 0x7F, 0x81, 0x81, 0x81, 0x80, 0x82, 0x83, 0x80,\n&nbsp; // Dla czytelności usunąłem pozostałe wiersze tablicy.\n&nbsp; 0x80, 0x7F, 0x80, 0x81, 0x80, 0x80, 0x80, 0x80\n};\nconst int sampleLen = sizeof(sample); &nbsp;// Długość sampla (dźwięku).\nvolatile int samplePos = 0; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Adres aktualnie odtwarzanej próbki sampla.\n\nvoid setup() {\n&nbsp; pinMode(9, OUTPUT); &nbsp; // Ustaw port PWM jako wyjściowy.\n&nbsp; TCCR1A = 0b10000010; &nbsp;// Konfiguruj timer 1: nieodwracające PWM, szybkie PWM.\n&nbsp; TCCR1B = 0b00011001; &nbsp;// Zliczaj do ICR1, praca bez prescalera (16 MHz)\n&nbsp; ICR1 = 1999; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Ustaw częstotliwość przerwań na 8 kHz (16MHz/8kHz-1)\n&nbsp; OCR1A = 128; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Startuj od wartości ciszy.\n&nbsp; samplePos = 0; &nbsp; &nbsp; &nbsp; &nbsp;// Zeruj adres odtwarzanej próbki sampla.\n&nbsp; TIMSK1 = 0b00000010; &nbsp;// Podłącz do przerwań źródło pochodzące z timera 1\n&nbsp; sei(); &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Włącz przerwania.\n}\n\nvoid loop() {\n}\n\nISR(TIMER1_COMPA_vect) { &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Obsługa przerwań od timera 1\n&nbsp; if (samplePos &lt; sampleLen) { &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Jeśli wciąż trwa obsługa odtwarzania sampla...\n&nbsp; &nbsp; OCR1A = pgm_read_byte(&amp;sample[samplePos++]); &nbsp;// Ładuj próbkę z tablicy do rejestru PWM i zwiększ jej adres.\n&nbsp; } else { &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;// Jeśli to już była ostatnia próbka...\n&nbsp; &nbsp; TIMSK1 = 0; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; // Wyłącz przerwania.\n&nbsp; }\n}</code></pre>Na początek – osadzamy dwie biblioteki: pgmspace.h oraz interrupt.h. W zasadzie tych wpisów może tu nie być, ale są zalecane, więc nie dyskutowałem z tym. Następnie znajdziemy tablicę, w którą należy wkleić to, co przed chwilą wygenerowaliśmy. Dla czytelności pozostawiłem tu tylko cztery wiersze, w oryginale jest ich ponad dwa tysiące. Kolejno definiujemy stałą zawierającą liczbę bajtów, które wykorzystuje nasz plik z dźwiękiem. Zamiast liczyć te bajty, zlecimy to zadanie kompilatorowi, używając instrukcji sizeof() Dzięki temu będziemy mogli łatwo podmieniać dźwięki, nie zawracając sobie głowy czasem ich trwania. Ostatnia zmienna samplePos to adres aktualnie odtwarzanej próbki, początkowo – zerowy.W części wstępnej najpierw zadeklarujemy pin 9 jako port PWM. Architektura narzuca użycie tylko jednego z dwóch pinów: 9 albo 10. Następnie mamy serię wpisów do rejestrów związanych z timerem pierwszym, który będzie generował cykliczne przerwania używane do generacji dźwięku. Nie wchodząc w szczegóły, musimy ten licznik skonfigurować w ten sposób, by generował impulsy z częstotliwością 8 kHz, bo z taką zapisaliśmy nasz dźwięk. W końcu po ustawieniu poziomu na nasze umowne „zero” czyli ciszę – pamiętajmy o przesunięciu wykresu – można podłączyć przerwania do timera, a następnie włączyć je globalnie.W głównej pętli nic się nie dzieje, odtwarzanie ma miejsce w przerwaniach. Muszą mieć one taką właśnie dziwną nazwę. Wewnątrz jednak nie ma większych tajemnic. Jeśli wciąż odtwarzamy dźwięk, tzn. nie doszliśmy jeszcze do końca, należy załadować kolejną próbkę z tablicy zgodnie z aktualnym jej adresem, po czym adres należy zwiększyć. Natomiast gdy dojdziemy do końca, należy odłączyć licznik od przerwań. Jak więc widać, program jednorazowo odtwarza zapisaną frazę, po czym pozostaje w pętli bez końca aż do kolejnego resetu. Samo w sobie nie ma to jeszcze sensu, ale pozwoli nam posłuchać wyników i w ogóle sprawdzić, czy niczego nie pomyliliśmy. W załączniku trzecim znajdziecie ten szkic z niewyciętą tablicą, a <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/153-gadajacy-woltomierz-cz-2">w kolejnym artykule</a> uczynimy z tej procedury coś użytecznego, czyli „gadający woltomierz”.

[152] Gadający woltomierz cz. 1

162.png

Nowoczesne kontrolery, o nieporównywalnie większych możliwościach obliczeniowych mogą przenosić automatykę na wyższy poziom. O ile różnego rodzaju manipulatorom wystarczyło osiem bitów, rozwiązanie prezentowane w tym artykule zdecydowanie wymaga więcej. Mamy tutaj bowiem skomplikowany układ czujników dłoni, które analizują jej ruch podczas tak złożonych operacji jak na przykład granie na instrumentach muzycznych. Ogromna ilość danych spływających tą drogą otwiera możliwość przede wszystkim uczenia samego dawcy owych danych, analizując błędy, postępy czy frazy krytyczne, co w rezultacie może usprawnić proces opanowania instrumentu. Dane te jednak mogą być co najmniej równie przydatne dla nauczania innych, zwłaszcza jeśli stworzy je muzyczny wirtuoz. W końcu, a może przede wszystkim, wiedza ta będzie przydatna robotom, które niekoniecznie zastąpią ludzi przy fortepianie, ale w nieciekawej, a skomplikowanej manualnie pracy, będąc częścią pakietów złożonych z obrazów, dźwięków i i takich właśnie jak na zdjęciu typu czujników. O projekcie więcej można poczytać <a target="_blank" rel="noopener noreferrer nofollow" href="https://blog.arduino.cc/2026/03/17/teaching-your-hands-to-remember-hapticus-and-the-future-of-motor-learning/?utm_source=segment&amp;utm_medium=email&amp;utm_campaign=weekly-newsletter">tutaj.</a>

Nano 33 BLE czyta ruchy dłoni

161.png

Miłośnicy małych pociągów pokochali Arduino, bo jest to wręcz wymarzone urządzenie do zarządzania makietami. I to na dwóch obszarach: zarządzania logiką zdarzeń, czy to nawiązującą wprost do świata dorosłej kolei, czy pracującej według fantazji właściciela zabawki oraz jako sterownik silników lokomotyw. Klasyczne sterowanie prostymi zasilaczami zwykle nie daje poczucia jazdy prawdziwego pociągu, który nigdy nie zachowuje się tak nerwowo jak w przypadku obsługi wersji miniaturowej za pomocą gałki takiego zasilacza. Prawdziwe pociągi cechują się bezwładnością, łagodnymi przyspieszeniami i hamowaniami.Innym problemem jest niestabilność ruchu modeli przy niskich szybkościach, przy których wbudowane silniki pracują nieefektywnie. Aby jakoś temu zaradzić, należy opracować indywidualny model zasilania impulsowego konkretnego silnika, który będzie wykorzystywał jego bezwładność do całkowania ruchu. Takie rozwiązanie <a target="_blank" rel="noopener noreferrer nofollow" href="https://arduino.pl/articles/072-arduino-i-lokomotywa-cz-1">prezentowałem kiedyś ja,</a> a dziś pragnę zwrócić uwagę na <a target="_blank" rel="noopener noreferrer nofollow" href="https://community.element14.com/challenges-projects/element14-presents/project-videos/w/documents/72036/building-a-super-smooth-z-scale-train-controller-with-arduino----episode-705">to rozwiązanie,</a> w którym autor zbudował sterownik lokomotywy pracującej w skali Z, a więc najmniejszej, wymagającej jeszcze większej uwagi w zakresie emulacji dynamiki jazdy prawdziwych pociągów.

Miłośnicy małych pociągów pokochali Arduino, bo jest to wręcz wymarzone urządzenie do zarządzania makietami. I to na dwóch obszarach: zarządzania logiką zdarzeń, czy to nawiązującą wprost do świata dorosłej kolei, czy pracującej według fantazji właściciela zabawki oraz jako sterownik silników lokomotyw. Klasyczne sterowanie prostymi zasilaczami zwykle nie daje poczucia jazdy prawdziwego pociągu, który nigdy nie zachowuje się tak nerwowo jak w przypadku obsługi wersji miniaturowej za pomocą gałki takiego zasilacza. Prawdziwe pociągi cechują się bezwładnością, łagodnymi przyspieszeniami i hamowaniami.

Arduino steruje pociągami (małymi)

<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