SD-Kartenmodul mit ESP32

In diesem Tutorial lernst du, wie du ein Micro SD-Kartenmodul mit dem ESP32 verbindest und grundlegende Dateioperationen durchführst. Wir behandeln das Auflisten von Verzeichnissen, Erstellen und Löschen von Dateien und Ordnern, Lesen und Schreiben von Daten und mehr. Am Ende hast du eine solide Grundlage, um SD-Kartenspeicher in deine eigenen Projekte zu integrieren.

Benötigte Teile

Im Folgenden findest du die für dieses Tutorial benötigten Komponenten. Ich habe ein älteres ESP32-Board verwendet, das zwar veraltet ist, aber noch sehr günstig erhältlich ist. Jedes andere ESP32-Board ist jedoch ebenfalls geeignet.

Außerdem benötigen wir ein Micro SD-Kartenmodul. Jedes Modul mit SPI-Schnittstelle und 3,3V-Logik funktioniert. Wenn du das SD-Kartenmodul an ein Arduino UNO anschließen möchtest, brauchst du ein Modul mit 5V-Logik oder einen Logikwandler. Ich habe ein sehr einfaches, kleines Modul ohne Logikwandler gewählt, da wir es an einen ESP32 mit 3,3V-Logik anschließen.

Grundlagen der SD-Kartenleser-Module

MicroSD-Kartenmodule dienen als Schnittstelle zwischen einem Mikrocontroller wie dem ESP32 und einer MicroSD-Karte. Sie ermöglichen dem Mikrocontroller, Daten von der Karte zu lesen und darauf zu schreiben, wodurch der Speicherplatz für Logging, Medien oder Konfigurationsdateien erweitert wird.

Funktionsweise von MicroSD-Kartenmodulen

MicroSD-Karten kommunizieren im Kern über das SPI-Protokoll (Serial Peripheral Interface). Das Modul enthält einen MicroSD-Kartensockel und bei Bedarf eine Pegelwandler-Schaltung, um die Spannungspegel zwischen Karte und Mikrocontroller anzupassen. Verbunden agiert der ESP32 als SPI-Master, sendet Befehle und empfängt Daten von der MicroSD-Karte, die als SPI-Slave fungiert.

Der SPI-Bus verwendet separate Leitungen für Dateneingang (MOSI), Datenausgang (MISO), Takt (SCK) und Chip Select (CS). Diese Vollduplex-Kommunikation ermöglicht schnelle und zuverlässige Datenübertragung, die für Dateisystemoperationen unerlässlich ist.

Warum SPI und nicht I2C?

SPI wird für die Kommunikation mit MicroSD-Karten bevorzugt, da es höhere Datenübertragungsraten und ein einfacheres Protokoll bietet. I2C ist ein Zweidraht-Bus für kurze Distanzen und niedrige Geschwindigkeiten, typischerweise bis 400 kHz oder 1 MHz im Fast-Modus. SPI hingegen kann problemlos mehrere MHz erreichen, was für effizientes Lesen und Schreiben großer Dateien entscheidend ist.

Außerdem unterstützt SPI Vollduplex-Kommunikation, also gleichzeitiges Senden und Empfangen von Daten, während I2C Halbduplex ist. Die MicroSD-Kartenspezifikation unterstützt explizit den SPI-Modus, was SPI zur natürlichen Wahl macht.

SPI-Pins

Die folgende Tabelle zeigt die für SPI benötigten Pins:

SPI-Pin	Funktion	Beschreibung
MOSI	Master Out Slave In	Überträgt Daten vom ESP32 zur MicroSD-Karte
MISO	Master In Slave Out	Überträgt Daten von der MicroSD-Karte zum ESP32
SCK	Serieller Takt	Synchronisiert die Datenübertragung
CS	Chip Select (Slave Select)	Wählt die MicroSD-Karte für die Kommunikation aus

Der ESP32 erlaubt in der Regel eine flexible Zuordnung dieser Pins über seine GPIO-Matrix, aber übliche Standardbelegungen sind GPIO 23 für MOSI, GPIO 19 für MISO, GPIO 18 für SCK und GPIO 5 für CS.

Typen von MicroSD-Kartenmodulen: 5V vs. 3,3V

Es gibt zwei Haupttypen von MicroSD-Kartenmodulen, basierend auf der Spannungs-Kompatibilität. Die meisten Arduino-Boards arbeiten mit 5V-Logikpegeln, daher enthalten für Arduino konzipierte Module Pegelwandler und Spannungsregler, um die 3,3V MicroSD-Karten sicher mit 5V Signalen und Strom zu verbinden.

Das Bild unten zeigt Vorder- und Rückseite eines 5V MicroSD-Kartenmoduls. Man sieht den Spannungsregler und den Pegelwandler-IC:

Wenn dein Mikrocontroller bereits mit 3,3V Logik arbeitet (ESP32), sind Spannungsregler und Pegelwandler nicht nötig. Du kannst dann ein einfacheres, günstigeres SD-Kartenlesermodul verwenden. Das folgende Bild zeigt Vorder- und Rückseite eines typischen 3,3V MicroSD-Kartenmoduls:

Bei genauer Betrachtung des 3,3V-Boards sieht man keine ICs für Spannungsregulierung oder Pegelwandlung. Es sollten aber 10K Pull-up-Widerstände für die SPI-Schnittstelle vorhanden sein:

Vermeide Module ohne diese Pull-up-Widerstände und schließe ein 3,3V MicroSD-Kartenmodul niemals an ein 5V Arduino an!

MicroSD-Kartengrößen und -typen

MicroSD-Karten gibt es in verschiedenen Speicherkapazitäten und Geschwindigkeitsklassen. Die gängigsten Größen reichen von 2GB bis 1TB mit folgenden Klassifizierungen:

Typ	Name	Größe
SDSC	Standard Capacity	Bis zu 2GB
SDHC	High Capacity	4GB bis 32GB
SDXC	Extended Capacity	64GB bis 2TB

Die SD-Bibliothek des ESP32 unterstützt Karten, die mit FAT32 formatiert sind.

MicroSD-Kartengeschwindigkeitsklassen

Geschwindigkeitsklassen definieren die minimale anhaltende Schreibgeschwindigkeit der Karte, was für Anwendungen wie Videoaufnahmen oder Datenlogging wichtig ist.

Geschwindigkeitsklasse	Minimale Schreibgeschwindigkeit	Beschreibung
Klasse 2	2 MB/s	Geeignet für Standard-Definition-Video
Klasse 4	4 MB/s	Geeignet für High-Definition-Video
Klasse 6	6 MB/s	Geeignet für HD-Videoaufnahmen
Klasse 10	10 MB/s	Geeignet für Full-HD-Video
UHS-I U1	10 MB/s	Ultra High Speed, geeignet für HD-Video
UHS-I U3	30 MB/s	Ultra High Speed, geeignet für 4K-Video

Für die meisten ESP32-Projekte bietet eine Klasse 10 oder UHS-I U1 Karte ein gutes Verhältnis von Geschwindigkeit und Preis. Schnellere Karten bringen wegen der Mikrocontroller- und SPI-Bus-Limitierungen nicht immer bessere Leistung.

Anschluss des SD-Kartenmoduls an den ESP32

Das Anschließen deines SD-Kartenmoduls an den ESP32 über SPI ist einfach. Das folgende Bild zeigt die Verkabelung zwischen einem ESP32 Lite und einem 3,3V MicroSD-Kartenmodul:

Zur Übersicht hier die Pinbelegung zwischen SD-Kartenmodul und ESP32:

SD-Kartenmodul Pin	ESP32 Pin
VCC	3,3V
GND	GND
MISO	GPIO 19
MOSI	GPIO 23
SCK/CLK	GPIO 18
CS (Chip Select)	GPIO 5

Achte darauf, den 3,3V-Pin des ESP32 zur Stromversorgung des SD-Kartenmoduls zu verwenden. Die SD-Karte arbeitet mit 3,3V, und 5V können sie beschädigen.

Formatieren der SD-Karte

Bevor du deine SD-Karte mit dem ESP32 verwendest, solltest du sicherstellen, dass sie richtig formatiert ist. Die meisten SD-Karten sind vorformatiert mit dem FAT32-Dateisystem, das mit der ESP32 SD-Bibliothek kompatibel ist.

Wenn deine Karte neu ist oder zuvor mit anderen Geräten verwendet wurde, kann eine Formatierung erforderlich sein. Du kannst die SD-Karte mit deinem Computer formatieren:

Windows

1. Stecke die SD-Karte in deinen PC.
2. Öffne Datei-Explorer und klicke mit der rechten Maustaste auf das SD-Kartenlaufwerk.
3. Wähle Formatieren.
4. Wähle als Dateisystem FAT32 aus.
5. Klicke auf Start, um zu formatieren.

macOS

1. Stecke die SD-Karte ein.
2. Öffne Festplattendienstprogramm.
3. Wähle die SD-Karte in der Seitenleiste aus.
4. Klicke auf Löschen.
5. Wähle als Format MS-DOS (FAT) aus.
6. Klicke auf Löschen, um zu formatieren.

Linux

Verwende den mkfsBefehl im Terminal. Ersetze /dev/sdX1durch die Gerätekennung deiner SD-Karte:

  sudo mkfs.vfat -F 32 /dev/sdX1

Wichtige Tipps

• Sichere alle wichtigen Daten vor dem Formatieren.
• Verwende kein exFAT oder NTFS, da diese von der ESP32 SD-Bibliothek nicht unterstützt werden.
• Nach dem Formatieren die Karte sicher auswerfen, bevor du sie ins SD-Kartenmodul einsetzt.

Maximale SD-Kartengröße

Unter Windows kannst du über den Datei-Explorer maximal 32GB große Karten formatieren. Es ist möglich, größere SD-Karten als FAT32 zu formatieren und mit dem ESP32 zu verwenden. Dafür benötigst du jedoch andere Softwaretools. Zum Beispiel gibt es FAT32Format oder guiformat-x64.

SD-Klasse

Die meisten Funktionen rund um SD-Karten findest du in der SD-Bibliothek und speziell in der SDClass. Der folgende Code zeigt die SDClass mit ihren Funktionsdeklarationen. Schau sie dir kurz an, in den nächsten Abschnitten lernst du, wie du die verschiedenen Funktionen der SDClass nutzt.

class SDClass {
    private:
      Sd2Card card;
      SdVolume volume;
      SdFile root;

      SdFile getParentDir(const char *filepath, int *indx);
	  
    public:
      // This needs to be called to set up the connection to the SD card
      // before other methods are used.
      bool begin(uint8_t csPin = SD_CHIP_SELECT_PIN);
      bool begin(uint32_t clock, uint8_t csPin);

      //call this when a card is removed. It will allow you to insert and initialise a new card.
      void end();

      // Note that currently only one file can be open at a time.
      File open(const char *filename, uint8_t mode = FILE_READ);
      File open(const String &filename, uint8_t mode = FILE_READ) {
        return open(filename.c_str(), mode);
      }

      bool exists(const char *filepath);
      bool exists(const String &filepath) {
        return exists(filepath.c_str());
      }

      bool mkdir(const char *filepath);
      bool mkdir(const String &filepath) {
        return mkdir(filepath.c_str());
      }

      bool remove(const char *filepath);
      bool remove(const String &filepath) {
        return remove(filepath.c_str());
      }

      bool rmdir(const char *filepath);
      bool rmdir(const String &filepath) {
        return rmdir(filepath.c_str());
      }

    private:
      int fileOpenMode;

      friend class File;
      friend bool callback_openPath(SdFile&, const char *, bool, void *);
  };

  extern SDClass SD;
};

Initialisierung des SD-Kartenmoduls

Bevor du mit Dateien auf deiner SD-Karte arbeiten kannst, musst du das SD-Kartenmodul mit deinem ESP32 initialisieren. Die Initialisierung richtet die Kommunikation zwischen ESP32 und SD-Karte ein und stellt sicher, dass die Karte für Dateioperationen bereit ist. Der folgende Code zeigt, wie das geht:

#include "FS.h"
#include "SD.h"
#include "SPI.h"

void setup() {
  Serial.begin(115200);
  if(!SD.begin()) {
    Serial.println("Card Mount Failed");
    return;
  }
  Serial.println("SD Card Initialized");
}

void loop() { }

Die SD.begin() Funktion gibt true zurück, wenn die Karte erfolgreich initialisiert wurde. Gibt sie false zurück, ist die Karte möglicherweise nicht richtig angeschlossen oder falsch formatiert. Prüfe auch die Verkabelung des SD-Kartenmoduls mit dem ESP32.

Beachte, dass SD.begin() Parameter hat, die du einstellen kannst, falls die Standardeinstellungen nicht funktionieren:

SD.begin(uint8_t ssPin=SS, 
         SPIClass &spi=SPI, 
         uint32_t frequency=4000000, 
         const char * mountpoint="/sd", 
         uint8_t max_files=5, 
         bool format_if_empty=false);

Vor allem kannst du hier die Pins für die SPI-Schnittstelle ändern. Die SD-Bibliothek verwendet standardmäßig die VSPI-Pins (23, 19, 18, 5).

Um die Pins zu ändern, definiere die Pin-Konstanten neu, erstelle eine Instanz der SPIClass und übergebe diese Instanz an die SD.begin()-Methode. Hier ein Beispiel:

#include "FS.h"
#include "SD.h"
#include "SPI.h"

#define SCK  17
#define MISO 19
#define MOSI 23
#define CS   5

SPIClass spi = SPIClass(VSPI);

void setup() {
  spi.begin(SCK, MISO, MOSI, CS);
  if (!SD.begin(CS, spi)) {
    Serial.println("Card Mount Failed");
  }
}

void loop() {}

Nach der Initialisierung ist die SD-Karte bereit für Dateioperationen wie Lesen, Schreiben und Verzeichnisverwaltung.

Auslesen des SD-Kartentyps

Nach der Initialisierung des SD-Kartenmoduls kannst du den Typ der angeschlossenen SD-Karte programmatisch ermitteln. Die sd.cardType() Funktion gibt eine Ganzzahl zurück, die den Kartentyp repräsentiert. Hier ein Beispiel, das den Kartentyp im Serial Monitor ausgibt:

#include "FS.h"
#include "SD.h"
#include "SPI.h"

void setup() {
  Serial.begin(115200);

  if (!SD.begin()) {
    Serial.println("Card Mount Failed");
    return;
  }

  uint8_t cardType = SD.cardType();
  if (cardType == CARD_NONE) {
    Serial.println("No SD card attached");
  } else if (cardType == CARD_MMC) {
    Serial.println("MMC Card");
  } else if (cardType == CARD_SD) {
    Serial.println("Standard SD Card");
  } else if (cardType == CARD_SDHC) {
    Serial.println("SDHC Card");
  } else {
    Serial.println("Unknown Card Type");
  }
}

void loop() { }

Wir starten mit der Initialisierung der SD-Karte mit SD.begin(). Dann rufen wir SD.cardType() auf, um den Kartentyp zu erhalten, und geben ihn schließlich im Serial Monitor aus.

Abrufen von SD-Karteninformationen

Die SD-Bibliothek bietet auch Funktionen, um die Größe einer SD-Karte, den verfügbaren Gesamtspeicher und den belegten Speicher abzurufen. Siehe folgenden Code:

#include "FS.h"
#include "SD.h"
#include "SPI.h"

void setup() {
  Serial.begin(115200);
  SD.begin();

  uint64_t MB = 1024 * 1024;

  uint64_t cardSize = SD.cardSize();
  Serial.printf("SD Card Size: %lluMB\n", cardSize / MB);

  uint64_t totalBytes = SD.cardSize();
  Serial.printf("Total space: %lluMB\n", totalBytes / MB);

  uint64_t usedBytes = SD.usedBytes();
  Serial.printf("Used space: %lluMB\n", usedBytes / MB);
}

void loop() {}

Verzeichnis auflisten

Die SD-Bibliothek hat leider keine Funktion, um alle Dateien und Ordner auf einer SD-Karte rekursiv aufzulisten. Diese Funktion musst du selbst implementieren. Hier ist der Code für eine printDir() Funktion, die die Ordner- und Dateistruktur im Serial Monitor ausgibt:

#include "FS.h"
#include "SD.h"
#include "SPI.h"

void printDir(const char *dirname, uint8_t levels = 0) {
  File root = SD.open(dirname);
  if (!root || !root.isDirectory()) return;

  File file = root.openNextFile();
  while (file) {
    for (int i = 0; i < levels; i++) Serial.print("  ");

    if (file.isDirectory()) {
      Serial.printf("[%s]\n", file.name());
      printDir(file.path(), levels + 1);
    } else {
      Serial.printf("%s (%d)\n", file.name(), file.size());
    }
    file = root.openNextFile();
  }
}

void setup() {
  Serial.begin(115200);
  SD.begin();
  printDir("/");
}

void loop() {}

Wenn du nur die Dateien in einem bestimmten Ordner brauchst, kannst du folgenden Code verwenden:

void printDir(const char *dirname) {
  File dir = SD.open(dirname);
  File file = dir.openNextFile();
  while (file) {
    if (!file.isDirectory()) {
      Serial.printf("%s (%d)\n", file.name(), file.size());
    }
    file = dir.openNextFile();
  }
}

Verzeichnisse erstellen oder löschen

Zum Erstellen oder Entfernen von Verzeichnissen bietet die SD-Bibliothek die Funktionen mkdir() und rmdir(). Hier ein Beispiel, das zuerst ein Verzeichnis erstellt und es dann löscht:

#include "FS.h"
#include "SD.h"
#include "SPI.h"

void setup() {
  Serial.begin(115200);
  SD.begin();

  const char *path = "/data";
  if (!SD.mkdir(path)) {
    Serial.println("mkdir failed");
  }

  if (!SD.rmdir(path)) {
    Serial.println("rmdir failed");
  }
}

void loop() {}

Beachte, dass du verschachtelte Ordner einzeln erstellen und löschen musst und dass Ordner leer sein müssen, bevor sie gelöscht werden können. Hier ein Beispiel, wie man eine verschachtelte Ordnerstruktur erstellt und löscht:

void setup() {
  SD.begin(); 

  SD.mkdir("/data");
  SD.mkdir("/data/temp");
  SD.mkdir("/data/temp/kitchen");


  SD.rmdir("/data/temp/kitchen");
  SD.rmdir("/data/temp");
  SD.rmdir("/data");
}

Dateifunktionen

Alle dateibezogenen Funktionen findest du in der File.cpp Datei der SD-Bibliothek. Hier eine kurze Übersicht der wichtigsten Funktionen:

File file = SD.open(path, FILE_WRITE);
File file = SD.open(path, FILE_APPEND);

file.write(buf, size); 
file.print(text);

file.read(buf, nbyte); 
file.read();
file.available();

uint32_t pos = file.position();
file.seek(pos);

file.size();

file.flush();
file.close();

SD.exists(path);
SD.remove(path);
SD.rename(path1, path2);

In den nächsten Abschnitten besprechen wir diese Funktionen ausführlicher.

Daten in Datei schreiben

Beim Schreiben von Daten in eine Datei musst du zuerst die Datei öffnen, die Daten schreiben und dann die Datei schließen. Hier ein Beispiel ohne Fehlerprüfung:

File file = SD.open("/readme.txt", FILE_WRITE);
file.print("This is the readme");
file.close();

Ich habe festgestellt, dass der Dateiname mit einem Schrägstrich (‚/‘) oder dem Pfad vom Root-Verzeichnis beginnen muss, z.B. „/text/readme.txt“. Andernfalls konnte ich keine Datei erstellen.

Beachte, dass es auch eine printf() Methode gibt, mit der du formatierten Text in eine Datei schreiben kannst, zum Beispiel:

File file = SD.open("/log.txt", FILE_WRITE);
file.printf("Temperature =  %.2f\n", 21.3);
file.close();

Um es einfacher zu machen, solltest du den Code zum Schreiben von Text in eine Datei typischerweise in eine Funktion verpacken:

void writeFile(const char *path, const char *text) {
  File file = SD.open(path, FILE_WRITE);
  if (!file) {
    Serial.println("Failed to open file for writing");
    return;
  }
  file.print(text);
  file.close();
}

Beachte auch, dass du statt Textdaten auch Binärdaten in eine Datei schreiben kannst:

File file = SD.open("/data.bin", FILE_WRITE);
uint8_t buffer[4] = { 0xDE, 0xAD, 0xBE, 0xEF };

size_t bytesWritten = file.write(buffer, sizeof(buffer));

if (bytesWritten != sizeof(buffer)) {
  Serial.println("Write error!");
} 

file.close();

Ein häufiger Anwendungsfall ist das Schreiben von Sensordaten. Du kannst eine Struktur mit deinen Sensordaten erstellen und diese dann als Datenblock in eine Binärdatei schreiben oder anhängen:

struct SensorData {
  uint32_t timestamp;
  int16_t temperature;
  int16_t humidity;
};

SensorData data = { millis(), 234, 81 };
File file = SD.open("/log.bin", FILE_WRITE);
file.write((uint8_t *)&data, sizeof(data));
file.close();

Nach dem Schreiben kannst du die binären Sensordaten wie folgt lesen:

SensorData data;

File file = SD.open("/log.bin");
file.read((uint8_t *)&data, sizeof(data));
file.close();

Serial.printf("timestamp:    %d\n", data.timestamp);
Serial.printf("temperature:  %d\n", data.temperature);
Serial.printf("humidity:     %d\n", data.humidity);

Wenn du mehrere Datenblöcke an eine Datei angehängt hast und einen bestimmten Block zurücklesen möchtest, kannst du die seek() Funktion verwenden:

SensorData data;

int n = 4; // Read 5ths sample (0...4)
File file = SD.open("/log.bin");
file.seek(n * sizeof(data));
file.read((uint8_t *)&data, sizeof(data));
file.close();

Wenn du während des Schreibens in eine Datei die aktuelle Position des Dateizeigers wissen musst, verwende die position() Funktion.

Daten an Datei anhängen

Wenn du Daten an eine Datei anhängen möchtest, anstatt den Inhalt zu überschreiben, verwende das Flag FILE_APPEND:

File file = SD.open("/readme.txt", FILE_APPEND);
file.print("This is more to read");
file.close();

Hier noch eine Komfortfunktion mit Fehlerprüfung zum Anhängen von Text an eine Datei:

void appendFile(const char* path, const char* text) {
  File file = SD.open(path, FILE_APPEND);
  if (!file) {
    Serial.println("Failed to open file for appending");
    return;
  }
  if (!file.print(text)) {
    Serial.println("Append failed");
  }
  file.close();
}

Dateiinhalt lesen

Du kannst den Inhalt einer Datei mit der read() Methode lesen:

File file = SD.open("/readme.txt");
while (file.available()) {
  Serial.write(file.read());
}
file.close();

Die read() Methode gibt eine Ganzzahl zurück und du musst sie wiederholt aufrufen, um die gesamte Datei zu lesen. Typischerweise machst du das in einer while-Schleife und nutzt die Funktion available(), um zu bestimmen, wann du stoppen musst. Du könntest aber auch eine for-Schleife verwenden, um z.B. die ersten n Zeichen einer Datei zu lesen.

Hier eine Komfortfunktion, die den Inhalt einer Datei im Serial Monitor ausgibt:

void printFile(const char* path) {
  File file = SD.open(path);
  if (!file) {
    Serial.println("Failed to open file for reading");
    return;
  }

  while (file.available()) {
    Serial.write(file.read());
  }
  file.close();
}

Datei puffern (Flush)

Wenn du eine Datei über längere Zeit offen hältst, z.B. um periodisch Sensordaten an eine Logdatei anzuhängen, solltest du den Datei-Puffer häufig flushen. Bei Stromausfall verringert das das Risiko von Datenverlust und Datenkorruption.

File file = SD.open("/log.txt", FILE_WRITE);
for(int i=0; i<10; i++) {
  file.print("temp = %d", i);
  file.flush();
  delay(1000);
}
file.close();

Datei löschen

Um eine Datei zu löschen, rufe die remove() Funktion mit dem Dateipfad auf. Du kannst vorher auch prüfen, ob die Datei existiert:

if (SD.exists("/log.txt")) {
  SD.remove("/log.txt");
}

Datei umbenennen

Eine Datei umzubenennen ist einfach. Rufe einfach die rename()-Funktion auf:

if (!SD.rename("/logs/old_log.txt", "/logs/new_log.txt")) { 
  Serial.println("Could not rename file");
}

Und das war’s. Jetzt kennst du alle Funktionen, die du brauchst, um Daten auf einer SD-Karte zu lesen und zu schreiben.

Fazit

In diesem Leitfaden hast du gelernt, wie du ein Micro SD-Kartenmodul mit dem ESP32 verbindest, die Karte formatierst und die Kommunikation initialisierst. Du hast außerdem erfahren, wie man Verzeichnisse auflistet, Ordner erstellt und löscht sowie Dateien liest, schreibt, anhängt, umbenennt und löscht. Für weitere Anwendungen siehe auch den examples Ordner der SD-Bibliothek.

Denke daran, deine Dateien zu schließen und zu flushen, um Datenkorruption zu vermeiden. Das ist besonders wichtig bei Datenloggern, die eine Datei über längere Zeit offen halten und anfällig für Stromausfälle sind.

Wenn du Fragen hast, kannst du sie gerne im Kommentarbereich stellen.

Viel Spaß beim Tüfteln!