Arduino Lektion 27: Daten loggen mit dem Logging Shield

Das Data Logging Shield von „Deek-Robot“ wird mit einer RTC  (DS1307)geliefert und hat somit ein extra Fach für eine Knopfzelle (CR1220 – 3V). Des Weiteren besitzt dieses Shield ein Mini SD Karten Schacht.

Das Data logging Shield hat 8 Pins welche wie folgt belegt sind:

PIN	Beschreibung
CS	Chip Select
MOSI	Master Output, Slave Input
MISO	Master Input, Slave Output
SCK	Clock
SCL	Clock Line
SDA	Data
GND	Ground
5V	Versorgungsspannung

Der SD Card Slot

Der SD Card Slot ist für Micro SD Cards entworfen. Eine maximale Speicherkarten Größe konnte aus keiner Quelle gefunden werden, für die nachfolgenden Beispiele verwende ich eine 2 GB Speicherkarte welche im FAT32 Format formatiert wurde.

Das RTC Modul

Die Real Time Clock (DS1307) dient als Zeitgeber und kann durch den Einsatz einer Pufferbatterie (CR1220) die Zeit vorhalten. Somit kann nach einem eventuellen Stromausfall der Messvorgang mit der korrekten Uhrzeit fortgesetzt werden.

Technische Daten

• Auflösung: Jahr, Monat, Tag, Stunden, Minuten
• Schaltjahr kompensation
• Kalender bis ins 2100 Jahr
• 1Hz Frequenz

Anschluss am Arduino Nano

Die RTC wird wie folgt angeschlossen:

PIN – Data Logger	Arduino Nano
SDA	A4
SCL	A5

Quellcode

Für die Programmierung des DS1307 RTC Moduls benötigt man folgende Bibliotheken (außer man möchte natürlich alles selber schreiben)…

• Time Library
• DS1307RTC Library

Nachdem die oben genannten Bibliotheken in der Arduino IDE eingebunden worden sind 2 Beispiele zum DS1307 vorhanden, einmal ReadTime und einmal SetTime. In dem Beispiel 3 dieses Tutorials habe ich dieses Modul implementiert. Durch die Time Bibliothek ist es möglich auch OHNE Batterie die korrekte Uhrzeit zu bekommen, dieses funktioniert jedoch, nur wenn der Arduino mit einem PC verbunden wurde.

Technische Daten

• Betriebsspannung 5V
• Abmaße 35 mm x 35 mm

Schaltplan

PIN – Data Logger	Arduino Nano
CS	digital D10
MOSI	digital D11
MISO	digital D12
SCK	digital D13
GND	GND
5V	5V

Quellcode

#include <SD.h>   //SD Card Bibliothek
#include <SPI.h>  //Bibliothek zum zugriff auf die SPI Schnittstelle des Arduinos

File outFile; // Die Datei welche geschrieben bzw. gelesen werden soll
int pinCS = 53; // Chip Select Pin 10 auf dem Arduino Uno
String filename = "test.txt"; //Dateiname der zu lesenden bzw. schreibenden Datei

void setup() {
  Serial.begin(9600); //Serielle Kommunikation mit 9600 Baud beginnen
  pinMode(pinCS, OUTPUT);
  if (SD.begin()){ //Wenn die SD Card initialisiert werden konnte dann....
    Serial.println("SD Karte konnte erfolgreich geladen werden!"); //Ausgabe des Textes auf der Seriellen Schnittstelle
  } else {
    //Dieser Block wird ausgeführt wenn die SD Card nicht initialisiert werden konnte.
    Serial.println("SD Karte konnte NICHT erfolgreich geladen werden!"); //Ausgabe des Textes auf der Seriellen Schnittstelle
    Serial.println("---Programm wird beendet!"); //Ausgabe des Textes auf der Seriellen Schnittstelle
    return; //vorzeitiges beenden der setup Methode
  }
}

lesen von der SD Card

void readContent(){
  outFile = SD.open(filename); //Öffnet bzw. erzeugt die Datei (im nur lese Modus)
  if (outFile) { //Wenn die Datei existiert dann...
    Serial.println("Lese Daten:"); //Ausgabe des Textes auf der Seriellen Schnittstelle
    // Sollange Text in der Datei enthalten ist...
    while (outFile.available()) {
      Serial.write(outFile.read()); //Ausgabe des Textes auf der Seriellen Schnittstelle
    }
    outFile.close();//Schließen der Datei
  } else {
    //Dieser Block wird ausgeführt wenn die Datei nicht gelesen werden konnte.
    Serial.println("Fehler beim öffnen der Datei test.txt"); //Ausgabe des Textes auf der Seriellen Schnittstelle
  }
}

schreiben auf der SD Card

void writeContent(){
  outFile = SD.open(filename, FILE_WRITE); //Öffnet bzw. erzeugt die Datei im Modus schreibend
  if (outFile) { //Wenn die Datei existiert dann...
    Serial.println("Schreiben von Daten..."); //Ausgabe des Textes auf der Seriellen Schnittstelle
    outFile.println("Hallo Welt!"); //Schreiben der Zeile in die Textdatei
    outFile.close(); //Schließen der Datei (Dieses ist wichtig da sonst beim beenden des Sketches dies Daten verloren gehen können.)
    Serial.println("Fertig!"); //Ausgabe des Textes auf der Seriellen Schnittstelle
  } else {
    //Dieser Block wird ausgeführt wenn die Datei nicht erzeugt werden konnte.
    Serial.println("Fehler beim öffnen der Datei test.txt"); //Ausgabe des Textes auf der Seriellen Schnittstelle
  }
}

Beispiel 1 – Hallo Welt in CSV

#include <SD.h>   //SD Card Bibliothek
#include <SPI.h>  //Bibliothek zum zugriff auf die SPI Schnittstelle des Arduinos

File outFile; // Die Datei welche geschrieben bzw. gelesen werden soll
int pinCS = 53; // Chip Select Pin 10 auf dem Arduino Uno
String filename = "test.txt"; //Dateiname der zu lesenden bzw. schreibenden Datei

void setup() {
  Serial.begin(9600); //Serielle Kommunikation mit 9600 Baud beginnen
  pinMode(pinCS, OUTPUT);
  if (SD.begin()){ //Wenn die SD Card initialisiert werden konnte dann....
    Serial.println("SD Karte konnte erfolgreich geladen werden!"); //Ausgabe des Textes auf der Seriellen Schnittstelle
  } else {
    //Dieser Block wird ausgeführt wenn die SD Card nicht initialisiert werden konnte.
    Serial.println("SD Karte konnte NICHT erfolgreich geladen werden!"); //Ausgabe des Textes auf der Seriellen Schnittstelle
    Serial.println("---Programm wird beendet!"); //Ausgabe des Textes auf der Seriellen Schnittstelle
    return; //vorzeitiges beenden der setup Methode
  }

  writeContent();
  readContent();
}

void writeContent(){
  outFile = SD.open(filename, FILE_WRITE); //Öffnet bzw. erzeugt die Datei im Modus schreibend
  if (outFile) { //Wenn die Datei existiert dann...
    Serial.println("Schreiben von Daten..."); //Ausgabe des Textes auf der Seriellen Schnittstelle
    outFile.println("Hallo Welt!"); //Schreiben der Zeile in die Textdatei
    outFile.close(); //Schließen der Datei (Dieses ist wichtig da sonst beim beenden des Sketches dies Daten verloren gehen können.)
    Serial.println("Fertig!"); //Ausgabe des Textes auf der Seriellen Schnittstelle
  } else {
    //Dieser Block wird ausgeführt wenn die Datei nicht erzeugt werden konnte.
    Serial.println("Fehler beim öffnen der Datei test.txt"); //Ausgabe des Textes auf der Seriellen Schnittstelle
  }
}

void readContent(){
  outFile = SD.open(filename); //Öffnet bzw. erzeugt die Datei (im nur lese Modus)
  if (outFile) { //Wenn die Datei existiert dann...
    Serial.println("Lese Daten:"); //Ausgabe des Textes auf der Seriellen Schnittstelle
    // Solange Text in der Datei enthalten ist...
    while (outFile.available()) {
      Serial.write(outFile.read()); //Ausgabe des Textes auf der Seriellen Schnittstelle
    }
    outFile.close();//Schließen der Datei
  } else {
    //Dieser Block wird ausgeführt wenn die Datei nicht gelesen werden konnte.
    Serial.println("Fehler beim öffnen der Datei test.txt"); //Ausgabe des Textes auf der Seriellen Schnittstelle
  }
}

void loop() {
  // Leere Methode die gesamte Logik wird im Setup erledigt
}

Beispiel 2 – Temperaturwerte in CSV

In diesem Beispiel möchte ich eine Temperatur messen und diese in eine CSV Datei schreiben. Als Sensor verwende ich den Temperatursensor LM35.

#include <SD.h>   //SD Card Bibliothek
#include <SPI.h>  //Bibliothek zum zugriff auf die SPI Schnittstelle des Arduinos

File outFile; // Die Datei welche geschrieben bzw. gelesen werden soll
int pinCS = 53; // Chip Select Pin 10 auf dem Arduino Uno
String filename = "temp.txt"; //Dateiname der zu lesenden bzw. schreibenden Datei

int val;   
int dat;  

int temperatursensorPin = 0 ;// Bestimmen das der Temperatursensor LM35 an den analogen PIN 0 angeschlossen ist.

int index = 0;

void setup() {
  Serial.begin(9600); //Serielle Kommunikation mit 9600 Baud beginnen
  pinMode(pinCS, OUTPUT);
  if (SD.begin()){ //Wenn die SD Card initialisiert werden konnte dann....
    Serial.println("SD Karte konnte erfolgreich geladen werden!"); //Ausgabe des Textes auf der Seriellen Schnittstelle
  } else {
    //Dieser Block wird ausgeführt wenn die SD Card nicht initialisiert werden konnte.
    Serial.println("SD Karte konnte NICHT erfolgreich geladen werden!"); //Ausgabe des Textes auf der Seriellen Schnittstelle
    Serial.println("---Programm wird beendet!"); //Ausgabe des Textes auf der Seriellen Schnittstelle
    return; //vorzeitiges beenden der setup Methode
  }
}

void writeContent(int temp){
  outFile = SD.open(filename, FILE_WRITE); //Öffnet bzw. erzeugt die Datei im Modus schreibend
  if (outFile) { //Wenn die Datei existiert dann...
    outFile.print(++index);
    outFile.print(",");
    outFile.print(temp);
    outFile.println("");
    outFile.close(); //Schließen der Datei (Dieses ist wichtig da sonst beim beenden des Sketches dies Daten verloren gehen können.)
  } else {
    //Dieser Block wird ausgeführt wenn die Datei nicht erzeugt werden konnte.
    Serial.println("Fehler beim öffnen der Datei test.txt"); //Ausgabe des Textes auf der Seriellen Schnittstelle
  }
}

int readTemperatur(){
  val = analogRead(temperatursensorPin); // Den analogen Wert des Temperatursensors lesen.
  dat = (125*val)>>8 ; // Aus dem gelesenen Wert die Temperatur berechnen.
  return dat;  // Temperatur zurück gegeben
}

void loop() {
  int temperatur = readTemperatur();
  writeContent(temperatur);
  delay(2000);
}

Ausgabe in der CSV Datei

1,21
1,22
2,21
3,21
4,21
5,21
6,21
7,21
8,21
9,21
10,21
11,21
12,21
.....

Beispiel 3 – Temperatur und Zeit in CSV Datei speichern

Da ich noch keine Batterie für das RTC Modul gefunden habe, lese ich beim Starten des Sketches die Zeit vom Kompilieren ein, dieses ist nicht auf die Sekunde genau, da der Schritt des Hochladens des Sketches noch ein paar Sekunden benötigt. Aber für dieses Beispiel ist es ausreichend. Im Beispiel 4 werde ich das ganze erneut mit einer Batterie darstellen.

Für das nachfolgende Beispiel wird unter anderem die Bibliothek TimeLib.h benötigt, diese kann man vom GitHub Repository von PaulStoffregen herunterladen werden.

#include <SD.h>   //SD Card Bibliothek
#include <SPI.h>  //Bibliothek zum zugriff auf die SPI Schnittstelle des Arduinos
#include <Wire.h>
#include <TimeLib.h>
#include <DS1307RTC.h>

File outFile; // Die Datei welche geschrieben bzw. gelesen werden soll
int pinCS = 53; // Chip Select Pin 10 auf dem Arduino Uno
String filename = "temptime.txt"; //Dateiname der zu lesenden bzw. schreibenden Datei

int val;   
int dat;  

int temperatursensorPin = 0 ;// Bestimmen das der Temperatursensor LM35 an den analogen PIN 0 angeschlossen ist.

int index = 0;

const char *monthName[12] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
tmElements_t tm;

void setup() {
  Serial.begin(9600); //Serielle Kommunikation mit 9600 Baud beginnen
  pinMode(pinCS, OUTPUT);
  if (SD.begin()){ //Wenn die SD Card initialisiert werden konnte dann....
    Serial.println("SD Karte konnte erfolgreich geladen werden!"); //Ausgabe des Textes auf der Seriellen Schnittstelle
    configureDS1307(); //Konfigurieren des RTC DS1307 Moduls
  } else {
    //Dieser Block wird ausgeführt wenn die SD Card nicht initialisiert werden konnte.
    Serial.println("SD Karte konnte NICHT erfolgreich geladen werden!"); //Ausgabe des Textes auf der Seriellen Schnittstelle
    Serial.println("---Programm wird beendet!"); //Ausgabe des Textes auf der Seriellen Schnittstelle
    return; //vorzeitiges beenden der setup Methode
  }
}

//Diese Methode wird nur benötigt wenn KEINE Batterie eingelegt ist.
void configureDS1307(){ 
  //Von der Kompilierungszeit das Datum und die Uhrzeit auslesen
  if (getDate(__DATE__) && getTime(__TIME__)) {
    //Die gelesenen Werte auf die RTC schreiben
    RTC.write(tm);
  }
}

String getTimestamp(){ 
  tmElements_t tm;
  String timestamp = "-error-"; //Meldung wenn die Zeit nicht gelesen werden konnte.
  if (RTC.read(tm)) { //Lesen der aktuellen Zeit
    timestamp = "";
    timestamp += get2digits(tm.Day); //Tag
    timestamp += ".";
    timestamp += get2digits(tm.Month); //Monat
    timestamp += ".";
    timestamp += get2digits(tmYearToCalendar(tm.Year)); //Jahr
    timestamp += " ";
    timestamp += get2digits(tm.Hour); //Stunde
    timestamp += ":";
    timestamp += get2digits(tm.Minute); //Minute
    timestamp += ":";
    timestamp += get2digits(tm.Second); //Sekunde
  }
  delay(1000);
  Serial.println(timestamp);
  return timestamp;
}

//Die Funktion liefert einen String Wert zurück welcher bei Zahlen < 10 mit führender Null beginnt.
String get2digits(int number) {
  String val = "";
  if (number >= 0 && number < 10) {
    val += "0";
  }
  val += String(number);
return val;
}


//Parsen der Uhrzeit
bool getTime(const char *str){
  int Hour, Min, Sec;
  if (sscanf(str, "%d:%d:%d", &Hour, &Min, &Sec) != 3) return false;
  tm.Hour = Hour;
  tm.Minute = Min;
  tm.Second = Sec;
  return true;
}

//Parsen des Datums
bool getDate(const char *str){
  char Month[12];
  int Day, Year;
  uint8_t monthIndex;

  if (sscanf(str, "%s %d %d", Month, &Day, &Year) != 3) return false;
  for (monthIndex = 0; monthIndex < 12; monthIndex++) {
    if (strcmp(Month, monthName[monthIndex]) == 0) break;
  }
  if (monthIndex >= 12) return false;
  tm.Day = Day;
  tm.Month = monthIndex + 1;
  tm.Year = CalendarYrToTm(Year);
  return true;
}

void writeContent(int temp){
  outFile = SD.open(filename, FILE_WRITE); //Öffnet bzw. erzeugt die Datei im Modus schreibend
  if (outFile) { //Wenn die Datei existiert dann...
    outFile.print(++index);
    outFile.print(",");
    outFile.print(temp);
    outFile.print(",");
    outFile.print(getTimestamp());   
    outFile.println("");
    outFile.close(); //Schließen der Datei (Dieses ist wichtig da sonst beim beenden des Sketches dies Daten verloren gehen können.)
  } else {
    //Dieser Block wird ausgeführt wenn die Datei nicht erzeugt werden konnte.
    Serial.println("Fehler beim öffnen der Datei test.txt"); //Ausgabe des Textes auf der Seriellen Schnittstelle
  }
}

int readTemperatur(){
  val = analogRead(temperatursensorPin); // Den analogen Wert des Temperatursensors lesen.
  dat = (125*val)>>8 ; // Aus dem gelesenen Wert die Temperatur berechnen.
  return dat;  // Temperatur zurück gegeben
}

void loop() {
  int temperatur = readTemperatur();
  writeContent(temperatur);
  delay(2000);
}

Ausgabe in der CSV Datei

1,21,13:31:55 01.04.2017
2,21,13:31:58 01.04.2017
3,21,13:32:01 01.04.2017
4,21,13:32:04 01.04.2017
5,21,13:32:07 01.04.2017
6,21,13:32:10 01.04.2017
7,21,13:32:13 01.04.2017
8,21,13:32:16 01.04.2017
9,21,13:32:19 01.04.2017

Beispiel 4 – Temperatur und Zeit in CSV Datei speichern (mit Pufferbatterie)

Nachdem nun die Pufferbatterie erschienen ist, kann ich den Quellcode folgendermaßen anpassen:

• es entfällt die Funktion configureDS1307();
• es entfällt die Funktion getTime(); & getDate();

Bevor jedoch der Sketch hochgeladen werden kann, muss zuerst das Datum und die Uhrzeit geschrieben werden. Dazu öffnet man das Beispielsketch „SetTime“ aus der Bibliothek „DS1307RTC“ und lädt dieses einmalig auf den Arduino im seriellen Monitor sollte man nach dem erfolgreichen Kompilieren und Hochladen dann einen Zeitstempel sehen.

#include <Wire.h>
#include <TimeLib.h>
#include <DS1307RTC.h>

const char *monthName[12] = {
  "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
};

tmElements_t tm;

void setup() {
  bool parse=false;
  bool config=false;

  // get the date and time the compiler was run
  if (getDate(__DATE__) && getTime(__TIME__)) {
    parse = true;
    // and configure the RTC with this info
    if (RTC.write(tm)) {
      config = true;
    }
  }

  Serial.begin(9600);
  while (!Serial) ; // wait for Arduino Serial Monitor
  delay(200);
  if (parse && config) {
    Serial.print("DS1307 configured Time=");
    Serial.print(__TIME__);
    Serial.print(", Date=");
    Serial.println(__DATE__);
  } else if (parse) {
    Serial.println("DS1307 Communication Error :-{");
    Serial.println("Please check your circuitry");
  } else {
    Serial.print("Could not parse info from the compiler, Time=\"");
    Serial.print(__TIME__);
    Serial.print("\", Date=\"");
    Serial.print(__DATE__);
    Serial.println("\"");
  }
}

void loop() {
}

bool getTime(const char *str)
{
  int Hour, Min, Sec;

  if (sscanf(str, "%d:%d:%d", &Hour, &Min, &Sec) != 3) return false;
  tm.Hour = Hour;
  tm.Minute = Min;
  tm.Second = Sec;
  return true;
}

bool getDate(const char *str)
{
  char Month[12];
  int Day, Year;
  uint8_t monthIndex;

  if (sscanf(str, "%s %d %d", Month, &Day, &Year) != 3) return false;
  for (monthIndex = 0; monthIndex < 12; monthIndex++) {
    if (strcmp(Month, monthName[monthIndex]) == 0) break;
  }
  if (monthIndex >= 12) return false;
  tm.Day = Day;
  tm.Month = monthIndex + 1;
  tm.Year = CalendarYrToTm(Year);
  return true;
}

Als Nächstes kann nun der Sketch zum Schreiben der Temperaturwerte hochgeladen werden. Die Uhrzeit geht dabei nicht verloren und wird durch die Pufferbatterie aufrechterhalten / gespeichert.

#include <SD.h>   //SD Card Bibliothek
#include <SPI.h>  //Bibliothek zum zugriff auf die SPI Schnittstelle des Arduinos
#include <Wire.h>
#include <TimeLib.h>
#include <DS1307RTC.h>

File outFile; // Die Datei welche geschrieben bzw. gelesen werden soll
int pinCS = 53; // Chip Select Pin 10 auf dem Arduino Uno
String filename = "temptime.txt"; //Dateiname der zu lesenden bzw. schreibenden Datei

int val;   
int dat;  

int temperatursensorPin = 0 ;// Bestimmen das der Temperatursensor LM35 an den analogen PIN 0 angeschlossen ist.

int index = 0;

const char *monthName[12] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
tmElements_t tm;

void setup() {
  Serial.begin(9600); //Serielle Kommunikation mit 9600 Baud beginnen
  pinMode(pinCS, OUTPUT);
  if (SD.begin()){ //Wenn die SD Card initialisiert werden konnte dann....
    Serial.println("SD Karte konnte erfolgreich geladen werden!"); //Ausgabe des Textes auf der Seriellen Schnittstelle
   // configureDS1307(); //Konfigurieren des RTC DS1307 Moduls
  } else {
    //Dieser Block wird ausgeführt wenn die SD Card nicht initialisiert werden konnte.
    Serial.println("SD Karte konnte NICHT erfolgreich geladen werden!"); //Ausgabe des Textes auf der Seriellen Schnittstelle
    Serial.println("---Programm wird beendet!"); //Ausgabe des Textes auf der Seriellen Schnittstelle
    return; //vorzeitiges beenden der setup Methode
  }
}

//Diese Methode wird nur benötigt wenn KEINE Batterie eingelegt ist.
void configureDS1307(){ 
  //Von der Kompilierungszeit das Datum und die Uhrzeit auslesen
  if (getDate(__DATE__) && getTime(__TIME__)) {
    //Die gelesenen Werte auf die RTC schreiben
    RTC.write(tm);
  }
}

String getTimestamp(){ 
  tmElements_t tm;
  String timestamp = "-error-"; //Meldung wenn die Zeit nicht gelesen werden konnte.
  if (RTC.read(tm)) { //Lesen der aktuellen Zeit
    timestamp = "";
     timestamp += get2digits(tm.Day); //Tag
    timestamp += ".";
    timestamp += get2digits(tm.Month); //Monat
    timestamp += ".";
    timestamp += get2digits(tmYearToCalendar(tm.Year)); //Jahr
    timestamp += " ";
    timestamp += get2digits(tm.Hour); //Stunde
    timestamp += ":";
    timestamp += get2digits(tm.Minute); //Minute
    timestamp += ":";
    timestamp += get2digits(tm.Second); //Sekunde
  }
  delay(1000);
  Serial.println(timestamp);
  return timestamp;
}

//Die Funktion liefert einen String Wert zurück welcher bei Zahlen < 10 mit führender Null beginnt.
String get2digits(int number) {
  String val = "";
  if (number >= 0 && number < 10) {
    val += "0";
  }
  val += String(number);
return val;
}


//Parsen der Uhrzeit
bool getTime(const char *str)
{
  int Hour, Min, Sec;
  if (sscanf(str, "%d:%d:%d", &Hour, &Min, &Sec) != 3) return false;
  tm.Hour = Hour;
  tm.Minute = Min;
  tm.Second = Sec;
  return true;
}

//Parsen des Datums
bool getDate(const char *str)
{
  char Month[12];
  int Day, Year;
  uint8_t monthIndex;

  if (sscanf(str, "%s %d %d", Month, &Day, &Year) != 3) return false;
  for (monthIndex = 0; monthIndex < 12; monthIndex++) {
    if (strcmp(Month, monthName[monthIndex]) == 0) break;
  }
  if (monthIndex >= 12) return false;
  tm.Day = Day;
  tm.Month = monthIndex + 1;
  tm.Year = CalendarYrToTm(Year);
  return true;
}

void writeContent(int temp){
  outFile = SD.open(filename, FILE_WRITE); //Öffnet bzw. erzeugt die Datei im Modus schreibend
  if (outFile) { //Wenn die Datei existiert dann...
    outFile.print(++index);
    outFile.print(",");
    outFile.print(temp);
    outFile.print(",");
    outFile.print(getTimestamp());   
    outFile.println("");
    outFile.close(); //Schließen der Datei (Dieses ist wichtig da sonst beim beenden des Sketches dies Daten verloren gehen können.)
  } else {
    //Dieser Block wird ausgeführt wenn die Datei nicht erzeugt werden konnte.
    Serial.println("Fehler beim öffnen der Datei test.txt"); //Ausgabe des Textes auf der Seriellen Schnittstelle
  }
}

int readTemperatur(){
  val = analogRead(temperatursensorPin); // Den analogen Wert des Temperatursensors lesen.
  dat = (125*val)>>8 ; // Aus dem gelesenen Wert die Temperatur berechnen.
  return dat;  // Temperatur zurück gegeben
}

void loop() {
  int temperatur = readTemperatur();
  writeContent(temperatur);
  delay(2000);
}

Download