ESP32 SD karta – przykładowy kod Arduino, obsługa SD.h i SD_MMC.h, logowanie danych

Pytanie

ESP32 karta SD przykładowy kod

Odpowiedź Sztucznej Inteligencji

Bezpośrednia odpowiedź na pytanie

• Najprostszy, sprawdzony przykład dla ESP32 (Arduino IDE ≥ v2.0.11) polega na wykorzystaniu biblioteki SD.h (SPI) lub – gdy wymagana jest wyższa przepustowość – SD_MMC.h (interfejs SD-MMC w trybie 1-/4-bit).
• Wystarczy podłączyć czytnik microSD do magistrali VSPI (CLK 18, MISO 19, MOSI 23, CS 5) i skompilować poniższy szkic.

#include <SPI.h>
#include <SD.h>
constexpr uint8_t CS = 5;        // Chip-Select
constexpr uint32_t SPI_FREQ = 20'000'000; // 20 MHz – najczęściej stabilne
void setup() {
  Serial.begin(115200);
  if (!SD.begin(CS, SPI, SPI_FREQ)) {           // inicjalizacja z podaniem częstotliwości
    Serial.println("⛔ Błąd inicjalizacji SD");
    return;
  }
  Serial.println("✅ Karta SD OK");
  // zapis
  File f = SD.open("/hello.txt", FILE_WRITE);
  f.println("Witaj świecie z ESP32!");
  f.close();
  // odczyt
  f = SD.open("/hello.txt");
  while (f.available()) Serial.write(f.read());
  f.close();
}
void loop() {}

Kluczowe punkty
• zasilanie 3 V3 oraz integralny stabilizator/moduł poziomów logicznych
• format FAT32 ≤ 32 GB (Arduino-core 2.0.14+ umożliwia także exFAT przez SdFat, lecz wymaga ręcznej aktywacji)
• osobny pin CS dla innych urządzeń SPI

Szczegółowa analiza problemu

1. Interfejsy sprzętowe

1.1 SPI (najczęstszy) – dowolne piny, najprostsza konfiguracja, do ~10 M B/s.
1.2 SD-MMC (wbudowany peryferyjny kontroler) – dedykowane GPIO (2, 4, 12–15), tryb 1- lub 4-bit, realna prędkość 18–25 M B/s.
1.3 HSPI/VSPI – w ESP32 dostępne dwie pełne magistrale; SD i inne peryferia można rozdzielić.

2. Biblioteki i wersje

• SD.h (wrapper nad SdFat v1) – stabilne, w rdzeniu esp32-arduino od v2.0.0.
• SdFat_ESP32 – (od v2.1) obsługuje exFAT, posix-style, DMA.
• SD_MMC.h – korzysta z drivera ESP-IDF; w Arduino-core ≥ v2.0.11 naprawiono problem z plikami >4 GiB.
• LittleFS/SPIFFS – alternatywa wbudowana w flash, przydatna gdy karta SD nie jest wymagana.

3. Typowa sekwencja w programie

1. Inicjalizacja magistrali:
   SPI.begin(SCK, MISO, MOSI, CS); – jeśli chcemy niestandardowe piny.
2. Montowanie karty:
   SD.begin(CS, SPI, F_CPU_SPI) lub SD_MMC.begin("/sdcard", true)
3. Operacje na plikach/katalogach: open() / read() / write() / rename() / remove()
4. Ochrona przed jednoczesnym dostępem (np. z RTOS) → semafor lub xSemaphoreCreateMutex().

4. Diagnostyka

• SD.cardType(), SD.cardSize(), SD.totalBytes(), SD.usedBytes() – szybki check.
• „init failed” → 80 % przypadków to błąd CS lub zasilania; 15 % – format exFAT z kartą >32 GB; 5 % – uszkodzony czytnik.

5. Wydajność

Teoretycznie:
\[
t{transfer} = \frac{N\text{Bajtów}}{f_{SPI}/8}
\]
Praktycznie przy 40 MHz (maks. w SdFat DMA) odczyt ciągły ~5 MB/s; SPI 20 MHz ~2,5 MB/s. Tryb 4-bit SD-MMC potrafi przekroczyć 15 MB/s.

6. Przykład dla SD_MMC (4-bit)

#include "SD_MMC.h"
void setup() {
  Serial.begin(115200);
  if(!SD_MMC.begin("/sdcard", true)) { // true = 1-bit, false = 4-bit
    Serial.println("SD_MMC mount FAIL");
    return;
  }
  File f = SD_MMC.open("/log.csv", FILE_APPEND);
  f.printf("%lu,%0.2f,%0.2f\n", millis(), temp, hum);
  f.close();
}
void loop() {}

Aktualne informacje i trendy

• Rdzeń Arduino-ESP32 2.0.14 (maj 2024) domyślnie kompiluje SdFat v2.2 z opcjonalnym exFAT.
• Espressif wprowadza „wear-leveling” dla SD-MMC (IDF v5.2).
• Coraz więcej projektów używa SD jako „web content storage” – serwowanie plików przez esp32_async_webserver.
• Moduły zgodne z UHS-I (SDR50/104) są wspierane w nowych układach ESP32-S3 (wymaga PCB 50 Ω).

Wspierające wyjaśnienia i detale

• Pull-up 47 kΩ na liniach DAT0-3 w trybie SD-MMC jest wymagany (wewnętrzne 50–100 kΩ bywają za słabe).
• Prąd rozruchowy karty może chwilowo przekroczyć 200 mA ⇒ kondensator 100 µF blisko gniazda.
• Karty klasy 10 UHS-I są szybsze, ale również bardziej wrażliwe na długość przewodów.

Aspekty etyczne i prawne

• Implementacje FAT32/exFAT w ESP32 wykorzystują kod typu open-source (SdFat, FATFS) – zgodność z licencjami MIT/BSD/LGPL należy zachować przy dystrybucji firmware.
• Dane osobowe logowane na SD muszą być szyfrowane zgodnie z RODO, jeśli mogą zidentyfikować użytkownika.
• exFAT jest opatentowany przez Microsoft; wbudowana implementacja FATFS ma licencję pozwalającą na użytek komercyjny w postaci binarnej.

Praktyczne wskazówki

• Staraj się trzymać przewody < 10 cm, skręć SCK z GND.
• Przy równoległej obsłudze Wi-Fi ustaw SD.begin(..., SPI_HALF_SPEED) – obniża zakłócenia.
• Do testów wydajności: uint32_t t = millis(); testFileIO(SD, "/bench.dat"); Serial.println(millis()-t);
• Ogranicz liczbę open()/close() – lepiej buforować.
• Regularnie wywołuj fsync() lub file.flush() aby uniknąć utraty danych przy zaniku zasilania.

Ewentualne zastrzeżenia lub uwagi dodatkowe

• Karty >32 GB nie zawsze startują w trybie SPI; wymuś CMD0 z CS=0 dłużej niż 74 cykle lub użyj SdFat SD_CONFIG(SD_CS, SD_SCK_MHZ(50)).
• SPI over‐clock >40 MHz działa tylko na krótkich ścieżkach, bez taśm breadboard-owych.
• Wersje ESP32-C3/H są ograniczone do HSPI (brak SD-MMC).

Sugestie dalszych badań

• Porównanie zużycia energii SD vs. QSPI-flash vs. PSRAM dla loggerów bateryjnych.
• Szyfrowanie karty SD przy użyciu ESP32-AES-hardware (mapowanie FATFS do szyfrowanych bloków).
• Zbadanie trwałości kart industrialnych SLC w aplikacjach IoT (-40 °C…+85 °C).

Krótkie podsumowanie

Karta SD na ESP32 działa pewnie zarówno przez SPI (SD.h), jak i szybciej przez natywny SD-MMC (SD_MMC.h). Kluczowe są: poprawne piny, poziomy 3 V3, FAT32 lub exFAT (najnowsze SdFat), oraz stabilne zasilanie. Przykładowy kod przedstawiony powyżej pozwala natychmiast rozpocząć pracę i łatwo go rozszerzyć o logowanie danych, serwowanie plików czy aktualizacje OTA.