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.

Deek-Robot - Data logging board
Deek-Robot – Data logging board

Das Data logging Shield hat 8 Pins welche wiefolgt belegt sind:

PINs vom Data logging board
PINs vom Data logging board
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 2GB Speicherkarte welche im FAT32 Format formatiert wurde.

Micro SD Card
Micro SD Card

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)…

Nachdem die oben genannten Bibliotheken in der Arduino IDE eingebunden wurden 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 35mm x 35mm

Schaltplan

Data logger Shield am Arduino Nano
Data logger Shield am Arduino Nano
Data loggíng Shield am Arduino Nano
Data loggíng Shield am Arduino Nano
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 einpaar 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äd 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

 

 

 

 

 

8 Gedanken zu „Arduino Lektion 27: Daten loggen mit dem Logging Shield

  • Pingback:NodeMCU - "Einer für (fast) Alles!" - Technik Blog

  • Pingback:Wemos D1 mini Shield: SD Card Shield mit RealTimeClock - Technik Blog

  • Juli 27, 2018 um 09:44
    Permalink

    Guten Tag Herr Draeger

    Ich wollte ihr Datenlogger mit Pufferbatterie nachbauen.
    Ich habe exakt dieselben Komponenten wie Sie.
    Jedoch bekomme ich eine Fehlermeldung beim beschreiben der Zeit.

    „DS1307 Communication Error :-{ Please check your circuitry“

    Nach mir ist die Verkabelung OK.
    Ich bin momentan ziemlich ratlos.

    Freundliche Grüsse Roman

    Antwort
    • Juli 27, 2018 um 11:25
      Permalink

      Hallo Roman,

      sende mir doch mal per E-Mail ein Foto deines Aufbaus. Es sieht nach der Fehlermeldung so aus das ggf. ein Pin falsch gesetzt / gesteckt ist.

      Gruß,

      Stefan

      Antwort
    • Juli 29, 2018 um 10:00
      Permalink

      Pullups am I2C vergessen? Die sind nämlich nicht auf dem Nano bestückt. Einen 4k7 über 5V auf SDA und einen an SCL bestücken, dann sollte es gehen.

      Antwort
  • Januar 22, 2019 um 14:53
    Permalink

    Hallo Herr Draeger, habe diesen Datenlogger seit ein paar Tagen und auch die Sketches SetTime und ReadTest erfolgreich getestet. Seit Gestern leuchtet die rote LED auf dem Shield. Ich bin mir ziemlich sicher, dass sie vorher nicht geleuchtet hat. Die Pufferbatterie habe ich gewechselt. Auf die MicroSD Karte warte ich gerade. Ich finde auch keine Beschreibung im Netz.

    Antwort
  • Mai 12, 2019 um 21:41
    Permalink

    Hallo Herr Draeger,
    ich habe mich dran versucht das Beispiel auf zB den DHT11 oder DHT22 zu übertragen, aber ich komme nicht weiter? Wäre das ggf ein neues kleines Projekt für Sie?
    Vielen Dank fürs drüber nachdenken …
    Beste Grüße,
    Michael

    Antwort
    • Mai 14, 2019 um 09:47
      Permalink

      Hallo Herr Hagemann,

      das Projekt würde also bedeuten das Sie die Daten von einem DHT11 / DHT22 Sensor
      in einem Intervall x auf eine SD-Karte mit einem Zeitstempel schreiben wollen?

      Hier würde ich noch zusätzlich einen deep sleep implementieren um einen Batteriebetrieb über einen langen
      Zeitraum zu ermöglichen.

      Gruß,

      Stefan Draeger

      Antwort

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.