Arduino Ethernet-Shield

Webserver

Für dieses Projekt benötigst du ein sogenanntes „Shield“, eine Platine, die einfach auf den Arduino aufgesteckt wird. Auf ihr befinden sich ein LAN-Anschluss (RJ45) und ein SD-Karten-Modul.
Wird das SD-Karten-Modul verwendet stehen die Pins 11, 12 und 13 (⇒SPI-Pins) und der CS-Pin 4 nicht zur Verfügung.

An zwei Beispielen sollen die Variablen und Funktionen der Bibliothek Ethernet erläutert werden.

Es wird eine Testseite erstellt und der von der Testseite gesendete Buchstabe angezeigt. Du musst die im Seriellen Monitor angezeigt IP in der Adresszeile des Browsers eingeben, anschließend fügst du ein / und den Buchstaben hinzu.

So sieht es aus:

Benötigte Bibliothek:

oder: Sketch -> Bibliothek einbinden -> Bibliotheken verwalten

Binde die Bibliothek ein und definiere die benötigten Variablen.

#include "Ethernet.h"

// MAC-Adresse und IP definieren
byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};

// Name des Servers vergeben
EthernetServer WebServer(80);

#include "Ethernet.h"

// MAC-Adresse und IP definieren

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};

// Name des Servers vergeben

EthernetServer WebServer(80);

Der setup-Teil vergibt die IP, startet den Server und zeigt die vergebene IP an.

void setup()
{
  // Ethernet starten DHCP
  Ethernet.begin(mac);

  // Server starten
  WebServer.begin();
  Serial.begin(9600);

  // auf serielle Verbindung warten
  while (!Serial) {;}
  delay(500);

  // zur Kontrolle IP-Adresse anzeigen
  // localIP -> Adresse, die im Browser eingegeben wird
  Serial.print(F("IP Adresse: "));
  Serial.println(Ethernet.localIP());
}

void setup()

{

// Ethernet starten DHCP

Ethernet.begin(mac);

// Server starten

WebServer.begin();

Serial.begin(9600);

// auf serielle Verbindung warten

while (!Serial) {;}

delay(500);

// zur Kontrolle IP-Adresse anzeigen

// localIP -> Adresse, die im Browser eingegeben wird

Serial.print(F("IP Adresse: "));

Serial.println(Ethernet.localIP());

}

Der loop-Teil:

void loop()
{
  String Auswertung = "";

  // auf Klienten warten ...
  EthernetClient Client = WebServer.available();

  // neue Anfrage
  if (Client)
  {
    // solange der Client verbunden ist ...
    while (Client.connected())
    {
      if (Client.available())
      {
        // Zeichen vom Clienten lesen
        char Zeichen = Client.read();

        // String "zusammenbauen"
        // += ist die Kurzform von Auswertung = Auswertung + Zeichen;
        Auswertung += Zeichen;

        // \n = Seite vom Clienten vollständig geladen
        if (Zeichen == '\n')
        {
          // HTTP-Anforderung senden
          Client.println(F("HTTP/1.1 200 OK"));
          Client.println(F("Content-Type: text/html"));

          // Leerzeile zwingend erforderlich
          Client.println();

          /*
            HTML-Seite aufbauen
            die folgenden Anweisungen müssen
            mit print oder println gesendet werden
            println "verschönert" den Quelltext
            (jede Anweisung in einer eigenen Zeile)
          */
          Client.println(F("<!doctype html>"));
          Client.println(F("<html>"));
          Client.println(F("<body>"));
          Client.println(F("<h1>Testseite</h1>"));
          Client.println(F("<b>Gelesenes Zeichen: </b>"));
          Client.println(Auswertung);
          /*
            ein Zeichen hinter der IP nach dem /
            erzeugt eine GET-Anweisung in der Form
            GET /a HTTP/1.1 -> a auswerten
            GET /b HTTP/1.1 -> b auswerten
            indexOf durchsucht den String nach diesen Zeichen
            (> 0 = Zeichen gefunden)
          */
          if (Auswertung.indexOf("a") > 0)
          {
            Client.println(F("<hr>Der Buchstabe a wurde eingegeben!"));
          }
          if (Auswertung.indexOf("b") > 0)
          {
            Client.println(F("<hr>Der Buchstabe b wurde eingegeben!"));
          }

          // IPs anzeigen
          Client.print(F("<hr><b>Eigene IP: "));
          Client.print(Client.remoteIP());
          Client.println(F("<br>"));
          Client.println(F("IP des Ethernet-Shields: "));
          Client.print(Ethernet.localIP());
          Client.println(F("</b>"));
          Client.println(F("</body>"));
          Client.println(F("</html>"));

          // Zeit, um die Antwort zu übertragen
          delay(1);
          
          // Verbindung beenden
          Client.stop();
        }
      }
    }
  }
}

void loop()

{

String Auswertung = "";

// auf Klienten warten ...

EthernetClient Client = WebServer.available();

// neue Anfrage

if (Client)

{

// solange der Client verbunden ist ...

while (Client.connected())

{

if (Client.available())

{

// Zeichen vom Clienten lesen

char Zeichen = Client.read();

// String "zusammenbauen"

// += ist die Kurzform von Auswertung = Auswertung + Zeichen;

Auswertung += Zeichen;

// \n = Seite vom Clienten vollständig geladen

if (Zeichen == '\n')

{

// HTTP-Anforderung senden

Client.println(F("HTTP/1.1 200 OK"));

Client.println(F("Content-Type: text/html"));

// Leerzeile zwingend erforderlich

Client.println();

HTML-Seite aufbauen

die folgenden Anweisungen müssen

mit print oder println gesendet werden

println "verschönert" den Quelltext

(jede Anweisung in einer eigenen Zeile)

Client.println(F("<!doctype html>"));

Client.println(F("<html>"));

Client.println(F("<body>"));

Client.println(F("<h1>Testseite</h1>"));

Client.println(F("<b>Gelesenes Zeichen: </b>"));

Client.println(Auswertung);

ein Zeichen hinter der IP nach dem /

erzeugt eine GET-Anweisung in der Form

GET /a HTTP/1.1 -> a auswerten

GET /b HTTP/1.1 -> b auswerten

indexOf durchsucht den String nach diesen Zeichen

(> 0 = Zeichen gefunden)

if (Auswertung.indexOf("a") > 0)

{

Client.println(F("<hr>Der Buchstabe a wurde eingegeben!"));

}

if (Auswertung.indexOf("b") > 0)

{

Client.println(F("<hr>Der Buchstabe b wurde eingegeben!"));

}

// IPs anzeigen

Client.print(F("<hr><b>Eigene IP: "));

Client.print(Client.remoteIP());

Client.println(F("<br>"));

Client.println(F("IP des Ethernet-Shields: "));

Client.print(Ethernet.localIP());

Client.println(F("</b>"));

Client.println(F("</body>"));

Client.println(F("</html>"));

// Zeit, um die Antwort zu übertragen

delay(1);

// Verbindung beenden

Client.stop();

}

Das vollständige Programm:

#include "Ethernet.h"

// MAC-Adresse und IP definieren
byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};

// Name des Servers vergeben
EthernetServer WebServer(80);

void setup()
{
  // Ethernet starten DHCP
  Ethernet.begin(mac);

  // Server starten
  WebServer.begin();
  Serial.begin(9600);

  // auf serielle Verbindung warten
  while (!Serial) {;}
  delay(500);

  // zur Kontrolle IP-Adresse anzeigen
  // localIP -> Adresse, die im Browser eingegeben wird
  Serial.print(F("IP Adresse: "));
  Serial.println(Ethernet.localIP());
}

void loop()
{
  String Auswertung = "";

  // auf Klienten warten ...
  EthernetClient Client = WebServer.available();

  // neue Anfrage
  if (Client)
  {
    // solange der Client verbunden ist ...
    while (Client.connected())
    {
      if (Client.available())
      {
        // Zeichen vom Clienten lesen
        char Zeichen = Client.read();

        // String "zusammenbauen"
        // += ist die Kurzform von Auswertung = Auswertung + Zeichen;
        Auswertung += Zeichen;

        // \n = Seite vom Clienten vollständig geladen
        if (Zeichen == '\n')
        {
          // HTTP-Anforderung senden
          Client.println(F("HTTP/1.1 200 OK"));
          Client.println(F("Content-Type: text/html"));

          // Leerzeile zwingend erforderlich
          Client.println();

          /*
            HTML-Seite aufbauen
            die folgenden Anweisungen müssen
            mit print oder println gesendet werden
            println "verschönert" den Quelltext
            (jede Anweisung in einer eigenen Zeile)
          */
          Client.println(F("<!doctype html>"));
          Client.println(F("<html>"));
          Client.println(F("<body>"));
          Client.println(F("<h1>Testseite</h1>"));
          Client.println(F("<b>Gelesenes Zeichen: </b>"));
          Client.println(Auswertung);

          /*
            ein Zeichen hinter der IP nach dem /
            erzeugt eine GET-Anweisung in der Form
            GET /a HTTP/1.1 -> a auswerten
            GET /b HTTP/1.1 -> b auswerten
            indexOf durchsucht den String nach diesen Zeichen
            (> 0 = Zeichen gefunden)
          */
          if (Auswertung.indexOf("a") > 0)
          {
            Client.println(F("<hr>Der Buchstabe a wurde eingegeben!"));
          }
          if (Auswertung.indexOf("b") > 0)
          {
            Client.println(F("<hr>Der Buchstabe b wurde eingegeben!"));
          }

          // IPs anzeigen
          Client.print(F("<hr><b>Eigene IP: "));
          Client.print(Client.remoteIP());
          Client.println(F("<br>"));
          Client.println(F("IP des Ethernet-Shields: "));
          Client.print(Ethernet.localIP());
          Client.println(F("</b>"));
          Client.println(F("</body>"));
          Client.println(F("</html>"));

          // Zeit, um die Antwort zu übertragen
          delay(1);
          
          // Verbindung beenden
          Client.stop();
        }
      }
    }
  }
}

100

101

102

103

104

105

106

107

108

109

110

#include "Ethernet.h"

// MAC-Adresse und IP definieren

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};

// Name des Servers vergeben

EthernetServer WebServer(80);

void setup()

{

// Ethernet starten DHCP

Ethernet.begin(mac);

// Server starten

WebServer.begin();

Serial.begin(9600);

// auf serielle Verbindung warten

while (!Serial) {;}

delay(500);

// zur Kontrolle IP-Adresse anzeigen

// localIP -> Adresse, die im Browser eingegeben wird

Serial.print(F("IP Adresse: "));

Serial.println(Ethernet.localIP());

}

void loop()

{

String Auswertung = "";

// auf Klienten warten ...

EthernetClient Client = WebServer.available();

// neue Anfrage

if (Client)

{

// solange der Client verbunden ist ...

while (Client.connected())

{

if (Client.available())

{

// Zeichen vom Clienten lesen

char Zeichen = Client.read();

// String "zusammenbauen"

// += ist die Kurzform von Auswertung = Auswertung + Zeichen;

Auswertung += Zeichen;

// \n = Seite vom Clienten vollständig geladen

if (Zeichen == '\n')

{

// HTTP-Anforderung senden

Client.println(F("HTTP/1.1 200 OK"));

Client.println(F("Content-Type: text/html"));

// Leerzeile zwingend erforderlich

Client.println();

HTML-Seite aufbauen

die folgenden Anweisungen müssen

mit print oder println gesendet werden

println "verschönert" den Quelltext

(jede Anweisung in einer eigenen Zeile)

Client.println(F("<!doctype html>"));

Client.println(F("<html>"));

Client.println(F("<body>"));

Client.println(F("<h1>Testseite</h1>"));

Client.println(F("<b>Gelesenes Zeichen: </b>"));

Client.println(Auswertung);

ein Zeichen hinter der IP nach dem /

erzeugt eine GET-Anweisung in der Form

GET /a HTTP/1.1 -> a auswerten

GET /b HTTP/1.1 -> b auswerten

indexOf durchsucht den String nach diesen Zeichen

(> 0 = Zeichen gefunden)

if (Auswertung.indexOf("a") > 0)

{

Client.println(F("<hr>Der Buchstabe a wurde eingegeben!"));

}

if (Auswertung.indexOf("b") > 0)

{

Client.println(F("<hr>Der Buchstabe b wurde eingegeben!"));

}

// IPs anzeigen

Client.print(F("<hr><b>Eigene IP: "));

Client.print(Client.remoteIP());

Client.println(F("<br>"));

Client.println(F("IP des Ethernet-Shields: "));

Client.print(Ethernet.localIP());

Client.println(F("</b>"));

Client.println(F("</body>"));

Client.println(F("</html>"));

// Zeit, um die Antwort zu übertragen

delay(1);

// Verbindung beenden

Client.stop();

}

Buttons können auf die gleiche Weise ausgewertet werden:

#include "Ethernet.h"

// MAC-Adresse und IP definieren
byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};

// Name des Servers vergeben
EthernetServer WebServer(80);

void setup()
{
  // Ethernet starten DHCP
  Ethernet.begin(mac);

  // Server starten
  WebServer.begin();
  Serial.begin(9600);

  // auf serielle Verbindung warten
  while (!Serial) {;}
  delay(500);

  // zur Kontrolle IP-Adresse anzeigen
  // localIP -> Adresse, die im Browser eingegeben wird
  Serial.print(F("IP Adresse: "));
  Serial.println(Ethernet.localIP());
}

void loop()
{
  String Auswertung = "";

  // auf Klienten warten ...
  EthernetClient Client = WebServer.available();

  // neue Anfrage
  if (Client)
  {
    // solange der Client verbunden ist ...
    while (Client.connected())
    {
      if (Client.available())
      {
        // Zeichen vom Clienten lesen
        char Zeichen = Client.read();

        Auswertung += Zeichen;
        // entspricht:
        // Auswertung = Auswertung + Zeichen;

        // \n = Seite vom Clienten vollständig geladen
        if (Zeichen == '\n')
        {
          // HTTP-Anforderung senden
          Client.println(F("HTTP/1.1 200 OK"));
          Client.println(F("Content-Type: text/html"));

          // Leerzeile zwingend erforderlich
          Client.println();

          /*
            HTML-Seite aufbauen
            die folgenden Anweisungen müssen
            mit print oder println gesendet werden
            println "verschönert" den Quelltext
            (jede Anweisung in einer eigenen Zeile)
          */
          Client.println(F("<!doctype html>"));
          Client.println(F("<html>"));
          Client.println(F("<body>"));
          Client.println(F("<h1>Testseite mit Buttons</h1>"));

          // Button rot
          Client.print(F("<input style='background-color:red;cursor:pointer'"));
          Client.print(F(" border-radius:5px;border: 2px solid black;' type='button'"));
          Client.print(F(" type='button'"));
          Client.println(F(" onClick&nbsp;=\"location.href='rot'\""));
          Client.println(F(" value='rot'>"));

          // Button gelb
          Client.print(F("<input style='background-color:yellow;cursor:pointer'"));
          Client.print(F(" border-radius:5px;border: 2px solid black;'"));
          Client.print(F(" type='button'"));
          Client.println(F(" onClick&nbsp;=\"location.href='gelb'\""));
          Client.println(F(" value='gelb'>"));

          // Button grün
          Client.print(F("<input type='button' style='background-color:#92F099;cursor:pointer'"));
          Client.print(F(" border-radius:5px;border: 2px solid black;'"));
          Client.print(F(" type='button'"));
          Client.println(F(" onClick&nbsp;=\"location.href='gruen'\""));
          Client.println(F(" value='gr&uuml;n'>"));
          Client.println(F("<br><hr>"));

          Client.println(F("<b>Gelesenes Zeichen: </b>"));
          Client.println(Auswertung);

          /*
            ein Zeichen hinter der IP nach dem /
            erzeugt eine GET-Anweisung in der Form
            GET /gruen HTTP/1.1 -> Button gruen auswerten
            GET /gelb HTTP/1.1 -> Button gelb auswerten
            indexOf durchsucht den String nach diesen Zeichen (> 0 = Zeichen gefunden)
          */
          if (Auswertung.indexOf("rot") > 0)
          {
            Client.println(F("<hr>Der Button rot wurde gedrückt!"));
          }

          if (Auswertung.indexOf("gelb") > 0)
          {
            Client.println(F("<hr>Der Button gelb wurde gedrückt!"));
          }

          if (Auswertung.indexOf("gruen") > 0)
          {
            Client.println(F("<hr>Der Button grün wurde gedrückt!"));
          }

          // IPs anzeigen
          Client.print(F("<hr><b>Eigene IP: "));
          Client.print(Client.remoteIP());
          Client.println(F("<br>"));
          Client.println(F("IP des Ethernet-Shields: "));
          Client.print(Ethernet.localIP());

          Client.println(F("</b>"));
          Client.println(F("</body>"));
          Client.println(F("</html>"));

          // Zeit, um die Antwort zu übertragen
          delay(1);

          // Verbindung beenden
          Client.stop();
        }
      }
    }
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

#include "Ethernet.h"

// MAC-Adresse und IP definieren

byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};

// Name des Servers vergeben

EthernetServer WebServer(80);

void setup()

{

// Ethernet starten DHCP

Ethernet.begin(mac);

// Server starten

WebServer.begin();

Serial.begin(9600);

// auf serielle Verbindung warten

while (!Serial) {;}

delay(500);

// zur Kontrolle IP-Adresse anzeigen

// localIP -> Adresse, die im Browser eingegeben wird

Serial.print(F("IP Adresse: "));

Serial.println(Ethernet.localIP());

}

void loop()

{

String Auswertung = "";

// auf Klienten warten ...

EthernetClient Client = WebServer.available();

// neue Anfrage

if (Client)

{

// solange der Client verbunden ist ...

while (Client.connected())

{

if (Client.available())

{

// Zeichen vom Clienten lesen

char Zeichen = Client.read();

Auswertung += Zeichen;

// entspricht:

// Auswertung = Auswertung + Zeichen;

// \n = Seite vom Clienten vollständig geladen

if (Zeichen == '\n')

{

// HTTP-Anforderung senden

Client.println(F("HTTP/1.1 200 OK"));

Client.println(F("Content-Type: text/html"));

// Leerzeile zwingend erforderlich

Client.println();

HTML-Seite aufbauen

die folgenden Anweisungen müssen

mit print oder println gesendet werden

println "verschönert" den Quelltext

(jede Anweisung in einer eigenen Zeile)

Client.println(F("<!doctype html>"));

Client.println(F("<html>"));

Client.println(F("<body>"));

Client.println(F("<h1>Testseite mit Buttons</h1>"));

// Button rot

Client.print(F("<input style='background-color:red;cursor:pointer'"));

Client.print(F(" border-radius:5px;border: 2px solid black;' type='button'"));

Client.print(F(" type='button'"));

Client.println(F(" onClick =\"location.href='rot'\""));

Client.println(F(" value='rot'>"));

// Button gelb

Client.print(F("<input style='background-color:yellow;cursor:pointer'"));

Client.print(F(" border-radius:5px;border: 2px solid black;'"));

Client.print(F(" type='button'"));

Client.println(F(" onClick =\"location.href='gelb'\""));

Client.println(F(" value='gelb'>"));

// Button grün

Client.print(F("<input type='button' style='background-color:#92F099;cursor:pointer'"));

Client.print(F(" border-radius:5px;border: 2px solid black;'"));

Client.print(F(" type='button'"));

Client.println(F(" onClick =\"location.href='gruen'\""));

Client.println(F(" value='grün'>"));

Client.println(F("<br><hr>"));

Client.println(F("<b>Gelesenes Zeichen: </b>"));

Client.println(Auswertung);

ein Zeichen hinter der IP nach dem /

erzeugt eine GET-Anweisung in der Form

GET /gruen HTTP/1.1 -> Button gruen auswerten

GET /gelb HTTP/1.1 -> Button gelb auswerten

indexOf durchsucht den String nach diesen Zeichen (> 0 = Zeichen gefunden)

if (Auswertung.indexOf("rot") > 0)

{

Client.println(F("<hr>Der Button rot wurde gedrückt!"));

}

if (Auswertung.indexOf("gelb") > 0)

{

Client.println(F("<hr>Der Button gelb wurde gedrückt!"));

}

if (Auswertung.indexOf("gruen") > 0)

{

Client.println(F("<hr>Der Button grün wurde gedrückt!"));

}

// IPs anzeigen

Client.print(F("<hr><b>Eigene IP: "));

Client.print(Client.remoteIP());

Client.println(F("<br>"));

Client.println(F("IP des Ethernet-Shields: "));

Client.print(Ethernet.localIP());

Client.println(F("</b>"));

Client.println(F("</body>"));

Client.println(F("</html>"));

// Zeit, um die Antwort zu übertragen

delay(1);

// Verbindung beenden

Client.stop();

}

SD-Karten-Modul

Verzeichnis lesen mit ls

#include "SdFat.h"
SdFat SD;

// Datenpin der SD-Karte
int DatenPin = 4;

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

  // auf serielle Verbindung warten
  while (!Serial);
  delay(500);

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

  Serial.println(SD.ls(LS_DATE | LS_SIZE | LS_R));
}

void loop() 
{
  // bleibt leer, das Programm läuft nur einmal
}

#include "SdFat.h"

SdFat SD;

// Datenpin der SD-Karte

int DatenPin = 4;

void setup()

{

Serial.begin(9600);

// auf serielle Verbindung warten

while (!Serial);

delay(500);

SD-Karte mit Angabe des Datenpins starten

wenn die Intialisierung fehlschlägt

- keine SD-Karte vorhanden

- falsche Pinbelegung

-> es wird eine Fehlermeldung angezeigt

-> das Programm wird beendet

if (!SD.begin(DatenPin))

{

Serial.println("Initialisierung fehlgeschlagen!");

Serial.println("Programm angehalten ...");

while(1);

}

else Serial.println("Initialisierung abgeschlossen");

Serial.println(SD.ls(LS_DATE | LS_SIZE | LS_R));

}

void loop()

{

// bleibt leer, das Programm läuft nur einmal

}

Verzeichnis lesen mit OpenNext

#include "SdFat.h"
SdFat SD;

// Datenpin der SD-Karte
int DatenPin = 4;

void setup() 
{
  // Bezeichner für Verzeichnis und Dateien
  File Verzeichnis;
  File Datei;
  char Dateiname[20];

  Serial.begin(9600);

  // auf serielle Verbindung warten
  while (!Serial);
  delay(500);

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

  // Wurzelverzeichnis öffnen
  // wenn keine Dateien gefunden wurden -> Fehlermeldung anzeigen
  if (Verzeichnis.open("/")) 
  {
    /*
      SD-Karte mit openNext lesen
      getName Parameter:
      Dateiname und Größe in Bytes
    */
    while (Datei.openNext(&Verzeichnis, O_READ)) 
    {
      Datei.getName(Dateiname, sizeof(Dateiname));
      Serial.print(Dateiname);

      // wenn es sich um ein Verzeichnis handelt
      if (Datei.isDir()) 
      {
        Serial.println("/");
      }

      // es handelt sich um eine Datei
      else 
      {
        Serial.print('\t');
        int DateiGroesse = Datei.fileSize();
        Serial.print(DateiGroesse);
        Serial.println(" Bytes");
      }
      Datei.close();
    }
  } 
  else Serial.println("Keine Dateien gefunden!");
}

void loop() 
{
  // bleibt leer, das Programm läuft nur einmal
}

#include "SdFat.h"

SdFat SD;

// Datenpin der SD-Karte

int DatenPin = 4;

void setup()

{

// Bezeichner für Verzeichnis und Dateien

File Verzeichnis;

File Datei;

char Dateiname[20];

Serial.begin(9600);

// auf serielle Verbindung warten

while (!Serial);

delay(500);

SD-Karte mit Angabe des Datenpins starten

wenn die Intialisierung fehlschlägt

- keine SD-Karte vorhanden

- falsche Pinbelegung

-> es wird eine Fehlermeldung angezeigt

-> das Programm wird beendet

if (!SD.begin(DatenPin))

{

Serial.println("Initialisierung fehlgeschlagen!");

Serial.println("Programm angehalten");

while(1);

}

else Serial.println("Initialisierung abgeschlossen");;

// Wurzelverzeichnis öffnen

// wenn keine Dateien gefunden wurden -> Fehlermeldung anzeigen

if (Verzeichnis.open("/"))

{

SD-Karte mit openNext lesen

getName Parameter:

Dateiname und Größe in Bytes

while (Datei.openNext(&Verzeichnis, O_READ))

{

Datei.getName(Dateiname, sizeof(Dateiname));

Serial.print(Dateiname);

// wenn es sich um ein Verzeichnis handelt

if (Datei.isDir())

{

Serial.println("/");

}

// es handelt sich um eine Datei

else

{

Serial.print('\t');

int DateiGroesse = Datei.fileSize();

Serial.print(DateiGroesse);

Serial.println(" Bytes");

}

Datei.close();

}

else Serial.println("Keine Dateien gefunden!");

}

void loop()

{

// bleibt leer, das Programm läuft nur einmal

}

Daten in Datei schreiben und lesen

#include "SdFat.h"
SdFat SD;

// Datenpin der SD-Karte
int DatenPin = 4;

bool Schreiben = false;
void setup() 
{
  // Bezeichner für die Datei
  File Datei;

  Serial.begin(9600);

  // auf serielle Verbindung warten
  while (!Serial) { ; };
  delay(500);

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

  // char-Array für den Dateinamen erstellen
  char Dateiname[20] = "Zahlen.txt";

  String DatenSchreiben;
  /*
    O_CREAT -> Datei erstellen, wenn sie nicht existiert
    O_WRITE -> in die Datei schreiben
    O_AT_END -> Startposition zum Schreiben an das Ende der Datei setzen
  */
  Datei.open(Dateiname, O_CREAT | O_WRITE | O_AT_END);

  // Daten in Datei schreiben
  Serial.println("Daten eingeben und Eingabe mit # beenden:");

  // solange kein # eingegeben wurde und Schreiben false ist
  while (DatenSchreiben != "#" && !Schreiben) 
  {
    while (Serial.available() > 0) 
    {
      DatenSchreiben = Serial.readStringUntil('\n');
      Serial.println(DatenSchreiben);

      // wenn das erste eingegebene Zeichen # ist 
      // -> Schreiben auf true setzen -> while verlassen
      if (DatenSchreiben.startsWith("#")) Schreiben = true;

      // ansonsten Datensatz in Datei schreiben
      else Datei.println(DatenSchreiben);
    }
  }

  // Datei schließen
  Datei.close();
  Serial.println("\nDatei " + String(Dateiname) + " erfolgreich geschrieben!");
  
  // Datei Zahlen.txt öffnen
  Serial.println("Zeige " + String(Dateiname));
  if (Datei.open(Dateiname, O_RDONLY)) 
  {
    while (Datei.available()) 
    {
      // ... werden sie gelesen und im Seriellen Monitor ausgegeben
      Serial.write(Datei.read());
    }
   }

   // wenn die Datei Zahlen.txt nicht existiert ... 
   else 
   {
     // char-Array Dateiname muss in String umgewandelt werden
     Serial.print("Datei " + String(Dateiname) + " nicht gefunden!");
   }

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

void loop() 
{
  // bleibt leer, das Programm läuft nur einmal
}

#include "SdFat.h"

SdFat SD;

// Datenpin der SD-Karte

int DatenPin = 4;

bool Schreiben = false;

void setup()

{

// Bezeichner für die Datei

File Datei;

Serial.begin(9600);

// auf serielle Verbindung warten

while (!Serial) { ; };

delay(500);

SD-Karte mit Angabe des Datenpins starten

wenn die Intialisierung fehlschlägt

- keine SD-Karte vorhanden

- falsche Pinbelegung

-> es wird eine Fehlermeldung angezeigt

-> das Programm wird beendet

if (!SD.begin(DatenPin))

{

Serial.println("Initialisierung fehlgeschlagen!");

Serial.println("Programm angehalten ...");

while(1);

}

else Serial.println("Initialisierung abgeschlossen");

// char-Array für den Dateinamen erstellen

char Dateiname[20] = "Zahlen.txt";

String DatenSchreiben;

O_CREAT -> Datei erstellen, wenn sie nicht existiert

O_WRITE -> in die Datei schreiben

O_AT_END -> Startposition zum Schreiben an das Ende der Datei setzen

Datei.open(Dateiname, O_CREAT | O_WRITE | O_AT_END);

// Daten in Datei schreiben

Serial.println("Daten eingeben und Eingabe mit # beenden:");

// solange kein # eingegeben wurde und Schreiben false ist

while (DatenSchreiben != "#" && !Schreiben)

{

while (Serial.available() > 0)

{

DatenSchreiben = Serial.readStringUntil('\n');

Serial.println(DatenSchreiben);

// wenn das erste eingegebene Zeichen # ist

// -> Schreiben auf true setzen -> while verlassen

if (DatenSchreiben.startsWith("#")) Schreiben = true;

// ansonsten Datensatz in Datei schreiben

else Datei.println(DatenSchreiben);

}

// Datei schließen

Datei.close();

Serial.println("\nDatei " + String(Dateiname) + " erfolgreich geschrieben!");

// Datei Zahlen.txt öffnen

Serial.println("Zeige " + String(Dateiname));

if (Datei.open(Dateiname, O_RDONLY))

{

while (Datei.available())

{

// ... werden sie gelesen und im Seriellen Monitor ausgegeben

Serial.write(Datei.read());

}

// wenn die Datei Zahlen.txt nicht existiert ...

else

{

// char-Array Dateiname muss in String umgewandelt werden

Serial.print("Datei " + String(Dateiname) + " nicht gefunden!");

}

// Datei schließen

Datei.close();

}

void loop()

{

// bleibt leer, das Programm läuft nur einmal

}

Letzte Aktualisierung: Juli 24, 2026 @ 13:10