SD-Karten-Modul

Lese­zeit: 7 Minu­ten

Das SD-Kartenmodul wird mit einer Micro-SD-Karte bestückt. Es kön­nen Ver­zeich­nis­se und Datei­en erstellt und gelöscht wer­den. In eine Datei kön­nen fort­lau­fend­Da­ten geschrie­ben wer­den, die Daten kön­nen zei­len­wei­se auch wie­der gele­sen werden. 

Ach­te auf die Pin-Belegung des SD-Karten-Moduls!
Die SD-Karte muss mit FAT32 for­ma­tiert sein!

Metho­den der Biblio­thek SdFat

Metho­deFunktion/Beispiel
begin(Datenpin)Modul star­ten

int DatenPin = 4;
begin(DatenPin);
exists(Dateiname)Vor­han­den­sein einer Datei prüfen

exits("Lottozahlen.txt");
remove(Dateiname)Datei ent­fer­nen

remove("Lottozahlen.txt");
clo­se()Datei schlie­ßen

file Lottozahlen;
Lottozahlen.close();

open(Dateiname, FILE_WRITE)
print()
println()
Daten in Datei schreiben

file Lottozahlen;
if (Lottozahlen)
{
  open("Lottozahlen.txt", FILE_WRITE);

  // Daten in Datei schreiben
  println("1 15 8 21 37 16 34");

  // Datei schließen
  Lottozahlen.close();
}
open(Dateiname)
available()
read()
Datei öff­nen und Daten lesen

file Lottozahlen;
Lottozahlen = SD.open("Lottozahlen.txt");
if (Lottozahlen)
{
  // solange sich Zeilen in der Datei befinden ...
  while (Lottozahlen.available())
  {
    // ... werden sie gelesen und im Seriellen Monitor ausgegeben
    Serial.write(ZiehungLotto.read());
  }

  // Datei schließen
  Lottozahlen.close();
}
mkdir(Verzeichnisname)Ver­zeich­nis erstellen

mkdir("Zahlen");
rmdir(Verzeichnisname)Ver­zeich­nis löschen

rmdir("Zahlen");
ls(Parameter)Inhalt der SD-Karte anzeigen
Parameter:

LS_R Inhalt rekur­siv anzeigen
LS_SIZE Datei­en mit Grö­ße anzeigen
LS_DATE Datei mit Datum anzeigen
Die Para­me­ter kön­nen auch kom­bi­niert werden:
ls(LS_DATE | LS_SIZE | LS_R);

Jeder Metho­de muss der Name des SD-Karten-Moduls mit abschlie­ßen­den . vor­an­ge­stellt werden!

Das Bei­spiel­pro­gramm liest, schreibt oder löscht eine Datei mit Zufallszahlen.

# include <SdFat.h>

// Name des SD-Karten-Moduls
SdFat SD;

// Name der Datei, die geschrieben werden soll
File ZahlenZeigen;

// Datenpin für das SD-Kartenmodul
int DatenPin = 4;

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

  // Zufallsgenerator starten
  randomSeed(analogRead(0));

  /*
     SD-Karte mit Angabe des Datenpins starten
     wenn die Intialisierung fehlschlägt
     - keine SD-Karte vorhanden
     - falsche Pinbelegung
     -> es wird eine Fehlermeldung angezeigt
  */
  if (!SD. begin(DatenPin))
  {
    Serial.println("Initialisierung fehlgeschlagen!");
  }
  else Serial.println("Initialisierung abgeschlossen");

  // Menü
  Serial.println("-----------------------------");
  Serial.println("Start mit 's', Dateien entfernen mit 'l'");
}

void loop()
{
  while (Serial.available() > 0)
  {
    // solange lesen, bis return \n = return eingegeben wurde
    String Eingabe = Serial.readStringUntil("\n");

    // das letzte Zeichen ist return = \n → soll entfernt werden (-1)
    Eingabe = Eingabe.substring(0, Eingabe.length() - 1);

    // Datei löschen
    if (Eingabe == "l")
    {
      // wenn die Datei Zahlen.txt existiert -> Datei löschenn (remove)
      if (SD.exists("Zahlen.txt"))
      {
        SD.remove("Zahlen.txt");
        Serial.println("Datei Zahlen.txt entfernt!");
      }
      else
      {
        Serial.println("Datei Zahlen.txt existiert nicht!");
      }

      // Menü
      Serial.println("-----------------------------");
      Serial.println("Start mit 's', Dateien entfernen mit 'l'");
    }

    if (Eingabe == "s")
    {
      /*
        Datei zum Schreíben (FILE_WRITE) öffnen
        wenn sie noch nicht existiert, wird sie erstellt
      */
      ZahlenZeigen = SD.open("Zahlen.txt", FILE_WRITE);

      if (ZahlenZeigen)
      {
        Serial.println("Schreibe Zahlen in Zahlen.txt ...");
        Serial.println("-----------------------------");

        // Zufallszahlen in die Datei schreiben
        for (int i = 0; i < 7; i++)
        {
          ZahlenZeigen.println(random(1, 100));
        }

        // Datei schließen
        ZahlenZeigen.close();
        Serial.println("Abgeschlossen.");
        Serial.println("-----------------------------");
      }
      else
      {
        Serial.println("Datei Zahlen.txt konnte nicht gelesen werden");
      }

      // Datei öffnen
      ZahlenZeigen = SD.open("Zahlen.txt");
      if (ZahlenZeigen)
      {
        Serial.println("Lese Datei Zahlen.txt ...");
        Serial.println("-----------------------------");

        // solange sich Zeilen in der Datei befinden ...
        while (ZahlenZeigen.available())
        {
          // ... werden sie gelesen und im Seriellen Monitor ausgegeben
          Serial.write(ZahlenZeigen.read());
        }

        // Datei schließen
        ZahlenZeigen.close();
        Serial.println("-----------------------------");

        Serial.println("Abgeschlossen.");
        Serial.println("-----------------------------");
      }
      else
      {
        Serial.println("Zahlen.txt konnte nicht ge\u00f6ffnet werden");
      }
    }
  }
}

Das Bei­spiel­pro­gramm zeigt die Metho­den Ord­ner und Datei­en erstel­len und löschen, schreibt Daten in eine Datei und liest sie wie­der aus. „l“ löscht die Ver­zeich­nis­se und Datei­en, „s“ legt sie an und füllt sie mit Zufalls­zah­len und zufäl­li­gen Sätzen. 

So sieht es aus:

# include <SdFat.h>
/*
  Anschlussbelegung:
  CS   -> Pin 4
  SCK  -> Pin 13
  MISO -> Pin 12
  MOSI -> Pin 11
  VCC  -> 5V
  GND  -> GND
*/

SdFat SD;

File ZahlenZeigen;
File TexteZeigen;

// Datenpin für das SD-Kartenmodul
int DatenPin = 4;

// Array Fahrzeuge
String Fahrzeuge [7] =
{"Der Bus", "Das Auto", "Die U-Bahn", "Das Motorrad", "Der Rennwagen", "Die Stra\u00dfenbahn", "Das Fahrrad"};

// Aktionen
String Aktionen [7] =
{ "h\u00e4lt an der Haltestelle", "f\u00e4hrt in  die Garage", "stoppt im Bahnhof",
  "stoppt an der roten Ampel", "flitzt \u00fcber die Autobahn", "parkt im Parkhaus", "h\u00e4lt an der Kreuzung"
};

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

  // Zufallsgenerator starten
  randomSeed(analogRead(0));

  /*
     SD-Karte mit Angabe des Datenpins starten
     wenn die Intialisierung fehlschlägt
     - keine SD-Karte vorhanden
     - falsche Pinbelegung
     -> es wird eine Fehlermeldung angezeigt
  */
  if (!SD. begin(DatenPin))
  {
    Serial.println(F("Initialisierung fehlgeschlagen!"));
  }
  else Serial.println(F("Initialisierung abgeschlossen"));

  // Menü
  Serial.println(F("-----------------------------"));
  Serial.println(F("Start mit 's', Dateien entfernen mit 'l'"));
}

void loop()
{
  while (Serial.available() > 0)
  {
    // solange lesen, bis return \n = return eingegeben wurde
    String Eingabe = Serial.readStringUntil("\n");

    // das letzte Zeichen ist return = \n → soll entfernt werden (-1)
    Eingabe = Eingabe.substring(0, Eingabe.length() - 1);

    // Dateien und Ordner löschen
    if (Eingabe == "l")
    {
      // Dateien löschen
      if (SD.exists("/Zahlen/Zahlen.txt"))
      {
        SD.remove("/Zahlen/Zahlen.txt");
        Serial.println(F("Datei Zahlen.txt entfernt!"));
      }
      else
      {
        Serial.println(F("Datei Zahlen.txt existiert nicht!"));
      }

      if (SD.exists("/Texte/Texte.txt"))
      {
        SD.remove("/Texte/Texte.txt");
        Serial.println(F("Datei Texte.txt entfernt!"));
      }
      else
      {
        Serial.println(F("Datei Texte.txt existiert nicht!"));
      }

      // Ordner löschen
      if (!SD.rmdir("Zahlen"))
      {
        Serial.println(F("Ordner 'Zahlen' existiert nicht!"));
      }
      else  Serial.println(F("Ordner 'Zahlen' entfernt!"));

      if (!SD.rmdir("Texte"))
      {
        Serial.println(F("Ordner 'Texte' existiert nicht!"));
      }
      else  Serial.println(F("Ordner 'Texte' entfernt!"));

      // Inhaltsverzeichnis lesen
      Serial.println(F("Inhalt der SD-Karte: "));
      Serial.println(SD.ls(LS_R));

      // Menü
      Serial.println(F("-----------------------------"));
      Serial.println(F("Start mit 's', Dateien entfernen mit 'l'"));
    }

    if (Eingabe == "s")
    {
      // Ordner erstellen
      if (!SD.mkdir("Zahlen"))
      {
        Serial.println(F("Ordner 'Zahlen' existiert bereits!"));
      }
      else  Serial.println(F("Ordner 'Zahlen' erstellt!"));

      if (!SD.mkdir("Texte"))
      {
        Serial.println(F("Ordner 'Texte' existiert bereits!"));
      }
      else  Serial.println(F("Ordner 'Texte' erstellt!"));

      /*
        Datei zum Schreíben (FILE_WRITE) öffnen
        wenn sie noch nicht existiert, wird sie erstellt
      */
      ZahlenZeigen = SD.open("/Zahlen/Zahlen.txt", FILE_WRITE);

      if (ZahlenZeigen)
      {
        Serial.println(F("Schreibe Zahlen in Zahlen.txt ... "));
        Serial.println(F("-----------------------------"));

        // Daten in die Datei schreiben
        for (int i = 0; i < 7; i++)
        {
          ZahlenZeigen.println(random(1, 100));
        }

        // Datei schließen
        ZahlenZeigen.close();
        Serial.println(F("Abgeschlossen."));
        Serial.println(F("-----------------------------"));
      }
      else
      {
        Serial.println(F("Datei Zahlen.txt konnte nicht gelesen werden"));
      }

      // Datei öffnen
      ZahlenZeigen = SD.open("/Zahlen/Zahlen.txt");
      if (ZahlenZeigen)
      {
        Serial.println(F("Lese Datei Zahlen.txt ..."));
        Serial.println(F("-----------------------------"));

        // solange sich Zeilen in der Datei befinden ...
        while (ZahlenZeigen.available())
        {
          // ... werden sie gelesen und im Seriellen Monitor ausgegeben
          Serial.write(ZahlenZeigen.read());
        }

        // Datei schließen
        ZahlenZeigen.close();
        Serial.println(F("-----------------------------"));

        Serial.println(F("Abgeschlossen."));
        Serial.println(F("-----------------------------"));
      }
      else
      {
        Serial.println(F("Zahlen.txt konnte nicht ge\u00f6ffnet werden"));
      }

      // zufällige Sätze erstellen und und in den Ordner Texte schreiben
      TexteZeigen = SD.open("/Texte/Texte.txt", FILE_WRITE);

      if (TexteZeigen)
      {
        Serial.println(F("Schreibe Texte in Texte.txt ... "));
        Serial.println(F("-----------------------------"));

        // Daten in die Datei schreiben
        for (int i = 0; i < 6; i++)
        {
          TexteZeigen.println(Fahrzeuge[random(0, 7)] + " " + Aktionen[random(0, 7)] + ".");
        }

        // Datei schließen
        TexteZeigen.close();

        Serial.println(F("Abgeschlossen."));
        Serial.println(F("-----------------------------"));
      }
      else
      {
        Serial.println("F(Datei Texte.txt konnte nicht gelesen werden)");
      }

      // Datei öffnen
      TexteZeigen = SD.open("/Texte/Texte.txt");
      if (TexteZeigen)
      {
        Serial.println(F("Lese Datei Texte.txt ..."));
        Serial.println(F("-----------------------------"));

        // solange sich Zeilen in der Datei befinden ...
        while (TexteZeigen.available())
        {
          // ... werden sie gelesen und im Seriellen Monitor ausgegeben
          Serial.write(TexteZeigen.read());
        }

        // Datei schließen
        TexteZeigen.close();
      }

      else
      {
        Serial.println(F("Texte.txt konnte nicht ge\u00f6ffnet werden"));
      }
    }
    Serial.println(F("-----------------------------"));
    Serial.println(F("Abgeschlossen."));
    Serial.println(F("-----------------------------"));

    // Inhaltsverzeichnis lesen
    Serial.println(F("Inhalt der SD-Karte: "));
    Serial.println(SD.ls(LS_SIZE | LS_R));
  }
}

Bildergalerie Bildergalerie