SD Datalogger

http://sites.prenninger.com/arduino-uno-r3/sd-datalogger

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                             Wels, am 2014-08-18

BITTE nützen Sie doch rechts OBEN das Suchfeld  [                                                              ] [ Diese Site durchsuchen]

DIN A3 oder DIN A4 quer ausdrucken
**********************************************************************************
DIN A4  ausdrucken
*********************************************************
                     SD Datalogger


Der Arduino Ethernet hat einen SD-Slot, ansonsten auch das Ethernet- oder WiFi-Shield, siehe auf der Hauptseite 


Learning   Examples | Foundations | Hacking | Links

Examples > SD Datalogger


Lernen Beispiele | Grundlagen | Hacking | Verbindungen

Beispiele> SD Datenlogger


Mit Hilfe der SD-Bibliothek, um Daten zu protokollieren

Dieses Beispiel zeigt, wie man die SD-Karte-Bibliothek verwenden, um Daten aus drei analoge Sensoren zu einer SD-Karte anmelden. 

Bitte klicken Sie hier für weitere Informationen auf der SD-Bibliothek.

Hardware erforderlich

  • Drei analoge Sensoren
  • Arduino-Board
  • SD-Karte Bord
  • Formatierte SD-Karte


Schaltung

Bild entwickelt mit Fritzing . Weitere Schaltungsbeispiele finden Sie in der Projekt-Seite Fritzing

Der folgende Code ist für die Verwendung mit einem Ethernet-Schild, das einen integrierten SD-Slot konfiguriert hat. In der setup() , rufen SD.begin() , Namensgebung Pin-4 als CS-Pin.
Dieser Stift variiert je nach Marke von Schild oder Brett.
In der loop() wird ein String erstellt, um die Informationen von drei analogen Sensoren halten.
Die Code durchläuft der Sensoren, indem sie ihre Daten auf den String.
Als nächstes wird die Datei auf der SD-Karte, indem Sie geöffnet SD.open() .
Sobald zur Verfügung, werden die Daten auf die Karte geschrieben, wenn dataFile.println() verwendet wird.
Die Datei muss mit geschlossen werden dataFile.close() , um die Informationen zu speichern.


/*
  SD card datalogger
 
 This example shows how to log data from three analog sensors
 to an SD card using the SD library.
   
 The circuit:
 * analog sensors on analog ins 0, 1, and 2
 * SD card attached to SPI bus as follows:
 ** MOSI - pin 11
 ** MISO - pin 12
 ** CLK - pin 13
 ** CS - pin 4
 
 created  24 Nov 2010
 modified 9 Apr 2012
 by Tom Igoe
 
 This example code is in the public domain.
     
 */

#include <SD.h>

// On the Ethernet Shield, CS is pin 4. Note that even if it's not
// used as the CS pin, the hardware CS pin (10 on most Arduino boards,
// 53 on the Mega) must be left as an output or the SD library
// functions will not work.
const int chipSelect = 4;

void setup()
{
 // Open serial communications and wait for port to open:
  Serial.begin(9600);
   while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }


  Serial.print("Initializing SD card...");
  // make sure that the default chip select pin is set to
  // output, even if you don't use it:
  pinMode(10, OUTPUT);
 
  // see if the card is present and can be initialized:
  if (!SD.begin(chipSelect)) {
    Serial.println("Card failed, or not present");
    // don't do anything more:
    return;
  }
  Serial.println("card initialized.");
}

void loop()
{
  // make a string for assembling the data to log:
  String dataString = "";

  // read three sensors and append to the string:
  for (int analogPin = 0; analogPin < 3; analogPin++) {

    int sensor = analogRead(analogPin);
    dataString += String(sensor);
    if (analogPin < 2) {
      dataString += ",";
    }
  }

  // open the file. note that only one file can be open at a time,
  // so you have to close this one before opening another.
  File dataFile = SD.open("datalog.txt", FILE_WRITE);

  // if the file is available, write to it:
  if (dataFile) {
    dataFile.println(dataString);
    dataFile.close();
    // print to the serial port too:
    Serial.println(dataString);
  }  
  // if the file isn't open, pop up an error:
  else {
    Serial.println("error opening datalog.txt");
  }
}



Quelle:

See Also:



http://arduino.cc/en/Tutorial/Datalogger
http://arduino.cc/en/pmwiki.php?n=Tutorial/Datalogger



SD-Bibliothek

Die SD-Bibliothek ermöglicht das Lesen von und Schreiben auf SD-Karten, zB auf der Arduino Ethernet-Schild.
Es ist auf gebaut sdfatlib von William Greiman. Die Bibliothek unterstützt FAT16 und FAT32-Dateisysteme auf Standard-SD-Karten und SDHC-Karten.
Es nutzt kurzen 8.3-Namen für Dateien. Die Dateinamen auf die SD-Bibliothek Funktionen übergeben können Pfade durch zukunftsSchrägStriche, /, zB "Verzeichnis / filename.txt" getrennt sind.
Da das Arbeitsverzeichnis ist immer die Wurzel der SD-Karte, ein Name bezieht sich auf die gleiche Datei, ob es einen Schrägstrich (zB "/file.txt" ist gleichbedeutend mit "datei.txt").
Ab der Version 1.0 unterstützt der Bibliothek Öffnen mehrerer Dateien.
Die Kommunikation zwischen dem Mikrocontroller und der SD-Karte verwendet SPI , der auf digitale Stifte 11, 12 stattfindet, und 13 (am meisten Arduino Boards) oder 50, 51 und 52 (Mega Arduino).
Zusätzlich muss ein weiterer Stift verwendet werden, um die SD-Karte zu wählen.
Dies kann die Hardware-SS Stift sein - Pin 10 (bei ​​den meisten Arduino-Boards) oder Pin 53 (auf der Mega) - oder einem anderen Stift in dem Aufruf SD.begin () angegeben
Beachten Sie, dass, auch wenn Sie nicht mit der Hardware. SS Pin, muss sie als Ausgang gelassen werden oder die SD-Bibliothek wird nicht funktionieren.

Hinweise zur Benutzung der Bibliothek und verschiedene Schilde

Beispiele

  • Datenlogger : Verwendung von SD-Bibliothek Log-Daten aus drei analoge Sensoren an eine SD-Karte
  • DumpFile : Lesen Sie eine Datei von einer SD-Karte mit SD-Bibliothek und senden Sie es über die serielle Schnittstelle
  • Dateien : Erstellen Sie eine Datei und zerstören auf einer SD-Karte
  • Readwrite : Lesen und Schreiben von Daten in und aus einer Datei auf einer SD-Karte
  • Card : Holen Sie sich Informationen über eine SD-Karte



Referenz Startseite
Korrekturen, Vorschläge und neue Dokumentation sollte auf die gebucht werden Forum .
Der Text der Arduino Referenz unter einer Lizenz Creative Commons Attribution-ShareAlike 3.0 License .
Code-Beispiele in der Referenz werden in die Öffentlichkeit freigegeben.

Quelle:
http://arduino.cc/en/Reference/SD



ARDUINO Datenlogger

http://forum.arduino.cc/index.php?topic=186379.0

Kommt drauf an, wieviel Du basteln möchtest.

Im einfachsten Fall steckst Du irgendein ordentliches "Shield mit SD-Kartenschacht" auf, z.B. ein "Ethernet-Shield" auf und bekommst
- Netzwerkanbindung
- Micro-SD Kartenschacht
- und einen erhöhten Stromverbrauch
ohne jegliche Bastelarbeit.
Dafür kannst Du gleich einen IP-Kartenlogger realisieren, bei dem die Daten über Netzwerk abrufbar sind.
Kosten für Ethernet-Shields von China-Versendern teils unter 10 EUR. Nachteil: Kein Batteriebetrieb wg. Stromverbrauch des Ethernet-Moduls.

Die von Dir angesprochenen SD-Kartenmodule ohne Pegelwandler (im "LC Studio" Design) für ca. 2 EUR vom Chinesen (oder teils auch 12 EUR von deutschen Versendern) funktionieren auch.
Allerdings kommt es drauf an. Manche schließen diese Module "einfach so" mit ihren Arduinos zusammen und powern die Daten-Leitungen mit 5 Volt weit außerhalb der Spezifikation.
Das machen die wenigstens SD-Karten mit.
Die Karten gehen zwar nicht kaputt, denn die Betriebsspannung wird von diesen Modulen von 5V einwandfrei auf 3.3V gewandelt, aber sie funktionieren vielfach einfach nicht wegen falscher Pegel auf den Datenleitungen.
Du kannst dann per Selektion SD-Karten suchen, die auf diese Art trotzdem funktionieren.
Solche SD-Karten gibt es durchaus, insbesondere bei älteren Karten bis 2 GB Speicherkapazität.
Funktion trotz Schaltungspfusch, das finden viele Hobbybastler durchaus ausreichend.

Oder Du mußt für eine einwandfreie Schaltung zwischen diese einfachen SD-Kartenmodule und den Arduino bei einigen Leitungen zusätzliche Spannungsteiler-Schaltungen mit Widerständen einbauen.
Korrekt beschaltet für 5V-Arduinos würde das so aussehen wie auf dem Bild, das ich dranhänge.
Diese Widerstände würdest Du zusätzlich zum SD-Kartenmodul benötigen.
Auf diese Bastelei haben hier viele der Arduino-Bastler null Bock, wenn ich das vielfache Jammern hier im Forum über das Nichtfunktionieren dieser chinesischen SD-Kartenmodule richtig interpretiere.

Anmerkung: Die Pin-Nummern im Schaltbild sind für UNO, für andere Boards die SPI-Pins entsprechend anpassen.

P.S.: Außer den deutschen Versendern, die chinesische € 2,- 
SD-Module ohne Pegelwandler für teils knapp über € 12,-  verkaufen gibt es aber für praktisch denselben Preis einen Anbieter, der ein SD-Kartenmodul mit Pegelwandler anbietet
(falls Du nicht mit den extra Widerständen zur Pegelwandlung herumbasteln möchtest und Du Dir das was kosten lassen möchtest ein direkt am Arduino anschließbares Modul zu bekommen, das mit korrekten Pegeln arbeitet):
http://www.watterott.com/de/MicroSD-card-breakout-board-v1
Für dieses Watterott-SD-Modul gilt das von mir gezeigte Anschlussbild NICHT, das wird direkt angeschlossen.

Das Anschlußbild ist nur für die chinesischen "LC Studio" Kartenmodule gültig.


Quelle:
 Arduino-SD-Module-Schaltung.png (31.23 KB, 508x541 - viewed 76 times.)

wenn Du das Ethernet-Modul nicht brauchst, musst Du es ja nicht nehmen.
Ich habe mir z.B. vor ein paar Tagen bei Amazon ein einzelnes kleines Board mit SD-Kartenleser, den Widerständen für die Spannungsteiler und einem 3,3V-Spannungsregulator bestellt.
Hat um die € 3,-  gekostet und funktioniert bestens.
Und es muss nichts mit Strom versorgt werden, was doch nicht benutzt wird.




Details zu  SD Memory Card Kartenleser Module Slot Socket SPI Reader für Arduino ARM MCU NEU




Quelle:

http://www.ebay.de/itm/SD-Memory-Card-Kartenleser-Module-Slot-Socket-SPI-Reader-fuer-Arduino-ARM-MCU-NEU-/400557656421?ssPageName=ADME:L:OU:DE:3160



Logger shield for Arduino


Quelle:
http://www.ladyada.net/make/logshield/design.html


Data Logging Shield v1 (Fa. Adafruit)

Das Board ist ideal zum Datenloggen mit Hilfe eines Arduino Boards.
Das Adafruit Data Logging Shield besitzt einen SD Kartensockel, Batterie gepufferte Real Time Clock, sowie eine Protoarea.
Dieses Shield kommt als Komplettbausatz, durch die bedrahteten Teile ist der AUfbau recht einfach.



Quelle:
https://learn.adafruit.com/adafruit-data-logger-shield
http://www.watterott.com/de/Adafruit-Data-Logging-Shield

Arduino SD card example





Code

#include <SD.h>

const int chipSelect = 4;

void setup()
{

Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect.
}
Serial.print(“Initializing SD card…”);
pinMode(10, OUTPUT);

//iniot SD card
if (!SD.begin(chipSelect))
{
Serial.println(“Card failed, or not present”);
return;
}
Serial.println(“card initialized.”);
}

void loop()
{

String dataString = “”;

// read three sensors and append to the string
for (int analogPin = 0; analogPin < 3; analogPin++)
{
int sensor = analogRead(analogPin);
dataString += String(sensor);
if (analogPin < 2)
{
dataString += “,”;
}
}

// open the file.
File dataFile = SD.open(“data.txt”, FILE_WRITE);

// if the file is available, write to it:
if (dataFile)
{
dataFile.println(dataString);
dataFile.close();
}
// if the file isn’t open
else
{
Serial.println(“error opening data.txt”);
}
}


Quelle:
http://www.getmicros.net/arduino-sd-card-example.php




Arduino Shield List
Quelle:
http://shieldlist.org/


Arduino, Adafruit, Watterott,




*********************************************************
Sensordaten auf SD Karte speichern
In diesem Post geht es darum, wie man Sensorwerte vom #Arduino (Temperatur) auf einer SD Karte speichern kann.

In diesem Post möchte ich ein kleines Anwendungsbeispiel zur Verwendung von SD Karten zum Speichern von Sensorwerten liefern. 
Dabei möchte ich nur mit dem Arduino die Temperatur messen, und dann die Temperatur mit der aktuellen Zeit auf der SD Karte speichern.

Quelle:
http://michaelsarduino.blogspot.co.at/2015/10/temperatur-messen-nur-mit-dem-arduino.html





Die Hardware

Auf der Hardware Seite benötigt man nur einen Arduino, sowie einen SD Card Reader samt SD Karte. 
Dieser Sketch funktioniert prinzipiell mit jedem SD Card Reader, da sie alle über SPI mit dem Arduino kommunizieren. 


Das Pinout des SPI Headers des Uno ist:

1: MISO, oder digital 12
2: Ground
3: SCK, oder digital 13
4: MOSI, oder digital 11
5: Reset
6: +5V
https://www.arduino.cc/en/Reference/SPI
http://michaelsarduino.blogspot.co.at/2015/10/sd-card-reader-fur-den-arduino.html


Zur Messung der Temperatur benötigt man durch einen kleinen Trick keine Zusatzhardware, sondern nur den Arduino.
Wie das geht habe ich in diesem Post erklärt.
http://michaelsarduino.blogspot.co.at/2015/10/temperatur-messen-nur-mit-dem-arduino.html

Der Sketch
Um jeweils die aktuelle Uhrzeit zu haben, muss man vor dem Einsatz des Sketches die aktuelle Uhrzeit in der Methode setTime() angeben.
Das ist die einfachste und kostengünstigste Art.
Dabei kann die Uhr jedoch bei längeren Einsätzen leider start abweichen.
Welche Arten die Zeit zu bekommen es für den Arduino gibt, habe ich bereits hier erklärt.
http://michaelsarduino.blogspot.co.at/2015/10/uhrzeit-mit-dem-arduino.html

Um die Temperatur zu messen kann man einfach die vordefinierte Funktion des verlinkten Post nehmen und anwenden, durch aufrufen von readTemp().

Um die Werte nun auf die SD Karte zu speichern, verkette ich das Datum als String mit der Uhrzeit als String und der gemessenen Temperatur.

1  :  11  :  2016  |  13 : 58  |  22
1  :  11  :  2016  |  13 : 58  |  22
1  :  11  :  2016  |  14 : 0  |  22
1  :  11  :  2016  |  14 : 1  |  22


GitHub  Temp_SD_Ardu.ino
Der gesamte Arduino Sketch sieht so aus:
#include <SPI.h>
#include <SD.h>
#include <Time.h>

File Datei;

void setup() {
  Serial.begin(9600);
  
  setTime(13,58,10,01,11,15);
  
  Serial.print(hour());
  Serial.print(":");
  Serial.print(minute());
  Serial.print(":");
  Serial.print(second());
  Serial.print("|");
  Serial.print(day());
  Serial.print(".");
  Serial.print(month());
  Serial.print(".");
  Serial.println(year());
  
  pinMode(10, OUTPUT);

  SD.begin(10);  
  
  Datei = SD.open("temp.txt", FILE_WRITE); 
    
  
}

void loop() {
  long temp = readTemp();
  long zwe = temp / 10000;
  long temperaturinc = zwe - 5;
  int tag_g = day();
  int mon_g = month();
  int jahr_g = year();
  String doppel = " : ";
  String datum = tag_g + doppel + mon_g + doppel + jahr_g;
  int stunde_g = hour();
  int minute_g = minute();
  String zeit = stunde_g + doppel + minute_g;
  String zeile = datum + " | " + zeit + " | " + temperaturinc;
  Datei.println(zeile);
  Datei.flush(); 

  delay(60000);
}

long readTemp() {
  long result;
  // Read temperature sensor against 1.1V reference
  ADMUX = _BV(REFS1) | _BV(REFS0) | _BV(MUX3);
  delay(2); // Wait for Vref to settle
  ADCSRA |= _BV(ADSC); // Convert
  while (bit_is_set(ADCSRA,ADSC));
  result = ADCL;
  result |= ADCH<<8;
  result = (result - 125) * 1075;
  return result;
}

Nun wird jede Minute die aktuelle Raumtemperatur als weitere Zeile in das Textdokument TEMP hinzugefügt.

Falls man vorhat die Daten genauer auszuwerten, sollte man überlegen sie in eine SQL Tabelle einzufügen. Dadurch kann man Abfragen nach dem Typus: Wann war es wärmer als 25 °C, oder was ist die Durchschnittstemperatur um 20:00 stellen.





SD Card Reader für den Arduino
In diesem Post geht es darum, wie man einen SD Card Reader mit dem #Arduino verwendet. 
Dadurch kann man SD Karten mit dem Arduino lesen und beschreiben, was die Speicherkapazität des Arduino extrem erweitert.


Die Verkabelung

Welchen SD Card Reader für den Arduino man wählt, ist eigentlich egal, da sie alle mittels dem SPI Protokoll mit dem Arduino kommunizieren
Dementsprechend kann man sie alle mit der Standard SD Library des Arduino verwenden. 

Da der Reader und der Arduino über SPI kommunizieren, muss man nur 6 Pins verbinden. 
Dabei gibt es vier Datenpins: MISO, MOSI, SCK und SS, manchmal auch als CS bezeichnet. 
Dabei könnt ihr für MISO, MOSI und SCK entweder den SPI Header verwenden, oder Pin-11 bis 13, wobei sie mit dem selben Pin am Mikrocontroller verbunden sind. 
Das heißt, wenn du den SPI Header statt den digital Pins verwendest, kannst du die digital Pins trotzdem nicht anderweitig verwenden.
SS beziehungsweise CS ist am Arduino Uno immer digital Pin 10.

Das Pinout des SPI Headers des Uno ist:

1: MISO, oder digital 12
2: Ground
3: SCK, oder digital 13
4: MOSI, oder digital 11
5: Reset
6: +5V

Solltet ihr einen anderen Arduino als den Arduino Uno verwenden, können die Pins abweichen, das Prinzip ist jedoch das Selbe. 

Bei meinem SD Reader gibt es komischerweise 2 Ground Pins und 5V und 3.3V.
Diese müssen alle vier angeschlossen werden, damit der Reader aktiviert ist. 


Die Software

Praktischerweise gibt es, wie bereits erwähnt, eine einheitliche SD Library für den Arduino, welche mit allen Modellen von SD Card Reader zusammen arbeiten kann. 
Dabei ist die Bibliothek schon mit der Arduino IDE installiert, muss also nur noch im Sketch nachgeladen werden.

Zusätzlich ist ein Beispielsketch (Datei > Beispiele > SD > CardInfo) mitgeliefert, mithilfe dessen man die Schaltung, den SD Card Reader und die SD Karte selbst testen kann. 
Dabei müsst ihr nur angeben, was der SS beziehungsweise CS Pin eures Arduinos ist, beim Uno beispielsweise 10.



GitHub  SD_Reader_TestSketch.ino
Hier ist der Sketch nochmal abgebildet:

/*
  SD card test

 This example shows how use the utility libraries on which the'
 SD library is based in order to get info about your SD card.
 Very useful for testing a card when you're not sure whether its working or not.

 The circuit:
  * SD card attached to SPI bus as follows:
 ** MOSI - pin 11 on Arduino Uno/Duemilanove/Diecimila
 ** MISO - pin 12 on Arduino Uno/Duemilanove/Diecimila
 ** CLK - pin 13 on Arduino Uno/Duemilanove/Diecimila
 ** CS - depends on your SD card shield or module.
 		Pin 4 used here for consistency with other Arduino examples


 created  28 Mar 2011
 by Limor Fried
 modified 9 Apr 2012
 by Tom Igoe
 */
// include the SD library:
#include <SPI.h>
#include <SD.h>

// set up variables using the SD utility library functions:
Sd2Card card;
SdVolume volume;
SdFile root;

// change this to match your SD shield or module;
// Arduino Ethernet shield: pin 4
// Adafruit SD shields and modules: pin 10
// Sparkfun SD shield: pin 8
const int chipSelect = 10;

void setup()
{
  // Open serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }


  Serial.print("\nInitializing SD card...");
  // On the Ethernet Shield, CS is pin 4. It's set as an output by default.
  // Note that even if it's not used as the CS pin, the hardware SS pin
  // (10 on most Arduino boards, 53 on the Mega) must be left as an output
  // or the SD library functions will not work.
  pinMode(10, OUTPUT);     // change this to 53 on a mega


  // we'll use the initialization code from the utility libraries
  // since we're just testing if the card is working!
  if (!card.init(SPI_HALF_SPEED, chipSelect)) {
    Serial.println("initialization failed. Things to check:");
    Serial.println("* is a card is inserted?");
    Serial.println("* Is your wiring correct?");
    Serial.println("* did you change the chipSelect pin to match your shield or module?");
    return;
  } else {
    Serial.println("Wiring is correct and a card is present.");
  }

  // print the type of card
  Serial.print("\nCard type: ");
  switch (card.type()) {
    case SD_CARD_TYPE_SD1:
      Serial.println("SD1");
      break;
    case SD_CARD_TYPE_SD2:
      Serial.println("SD2");
      break;
    case SD_CARD_TYPE_SDHC:
      Serial.println("SDHC");
      break;
    default:
      Serial.println("Unknown");
  }

  // Now we will try to open the 'volume'/'partition' - it should be FAT16 or FAT32
  if (!volume.init(card)) {
    Serial.println("Could not find FAT16/FAT32 partition.\nMake sure you've formatted the card");
    return;
  }


  // print the type and size of the first FAT-type volume
  uint32_t volumesize;
  Serial.print("\nVolume type is FAT");
  Serial.println(volume.fatType(), DEC);
  Serial.println();

  volumesize = volume.blocksPerCluster();    // clusters are collections of blocks
  volumesize *= volume.clusterCount();       // we'll have a lot of clusters
  volumesize *= 512;                            // SD card blocks are always 512 bytes
  Serial.print("Volume size (bytes): ");
  Serial.println(volumesize);
  Serial.print("Volume size (Kbytes): ");
  volumesize /= 1024;
  Serial.println(volumesize);
  Serial.print("Volume size (Mbytes): ");
  volumesize /= 1024;
  Serial.println(volumesize);


  Serial.println("\nFiles found on the card (name, date and size in bytes): ");
  root.openRoot(volume);

  // list all files in the card with date and size
  root.ls(LS_R | LS_DATE | LS_SIZE);
}


void loop(void) {

}

Wenn ihr nun nach dem Upload des Sketches die serielle Konsole mit Datenrate 9600 öffnet, werdet ihr die, auf der SD Karte gespeicherten, Dateien sehen:






Fazit

SD Karten sind eine gute Möglichkeit die Speicherkapazität des Arduinos zu erweitern, insbesondere da sie billiger und größer sind als externer EEPROM, und zusätzlich dank der SPI Kommunikation einfach zu verbinden. 
Sehr empfehlen kann ich euch für den Einstieg diesen SD Card Reader auf Amazon.




Arbeiten mit Daten auf SD Karte
In diesem Post geht es darum, wie man mit dem  #Arduino  mit Dateien arbeiten kann(neue erstellen, lesen, bearbeiten), welche auf einer SD Karte gespeichert sind.

In diesem Post geht es darum, wie man mittels der SD Library des Arduino mit Dateien arbeitet, welche auf einer SD Karte gespeichert sind, welche über einen SD Card Reader mit dem Arduino verbunden ist.

Wer den gestrigen Post verpasst hat, empfehle ich, ihn sich noch anzuschauen, da erklärt, wie man einen SD Card Reader mit dem Arduino korrekt verbindet und einen ersten Test durchführt. 
Prinzipiell kann man jeden SD Card Reader für den Arduino mit der SD Library benutzen.
 Ich kann euch diesen SD Card Reader auf Amazon empfehlen.

Um eure SD Karte überhaupt zu verwenden, müsst ihr sie erst initialisieren. 
Das funktioniert über den Befehl SD.begin(). Dabei muss man in Klammern den SS beziehungsweise CS Pin eures Arduinos angeben. 
 Beim Arduino Uno würde man die SD Karte also über SD.begin(10) initialisieren. 
Dieser Befehl würde bei einem Fehler eine Fehlermeldung zurück geben. Deshalb sollte man SD.begin() in eine if Abfrage stecken, und im Fall der Fälle den Sketch abbrechen lassen.

Um eine Datei zu bearbeiten beziehungsweise zu lesen, muss man sie, wie am PC, erst einmal öffnen: Objekt Datei = SD.open("Name der Datei", Art). 
Dabei gibt es zwei unterschiedliche Arten eine Datei zu öffnen. Den "Lesemodus" und den "Schreibmodus". 
Wenn du eine neue Datei erstellen willst, so öffnest du sie einfach im Schreibmodus und sie wird automatisch erstellt. 
Der "Lesemodus" wird durch FILE_READ und der "Schreibmodus" durch FILE_WRITE angegeben.

Sobald man das Lesen/Schreiben einer Datei abgeschlossen hat, muss man sie über Datei.close() schließen. 
Datei steht hierbei stellvertretend für das Objekt der Klasse File, das du erzeugt hast, durch das Öffnen einer Datei.


GitHub  Datein_oeffnen.ino
Hier ein kleines Codebeispiel zum Erstellen/Öffnen einer Datei:
#include <SPI.h>
#include <SD.h>

File Datei;

void setup() {
  Serial.begin(9600);
  
  if(!SD.begin(10))
  {
    Serial.println("Verbindung zur SD Karte fehlgeschlagen");
    return;
  }
    

  Datei = SD.open("beispiel.txt", FILE_WRITE);
  Datei.close();
}


void loop() {
  // put your main code here, to run repeatedly:

}

Das Schreiben in eine Datei beziehungsweise das Auslesen einer Datei gestaltet sich sehr ähnlich, wie das Arbeiten mit einer seriellen Verbindung. 
Das bedeutet zum Schreiben in eine Datei kann man den Befehl Datei.println("Dieser Text wird in die Datei geschrieben"); verwenden.

Um eine Datei auszulesen muss man die Funktion Datei.read() verwenden. Dabei gibt read immer nur das nächste Zeichen zurück. 
Um also die gesamte Datei auszulesen, muss man den Befehl in einer while Schleife unterbringen, welche über Datei.available() überprüft, ob noch Zeichen "übrig" sind.



GitHub  Datei_schreiben.ino
Ein einfaches Beispiel zum Schreiben in eine Datei, und dem Auslesen aus einer Datei, sieht so aus:

#include <SPI.h>
#include <SD.h>

File Datei;

void setup() {
  Serial.begin(9600);
  
  if(!SD.begin(10))
  {
    Serial.println("Verbindung zur SD Karte fehlgeschlagen");
    return;
  }
    

  Datei = SD.open("beispiel.txt", FILE_WRITE);
  Datei.println("Dieser Text wird in die Datei geschrieben");
  Datei.close();
  
  Datei = SD.open("beispiel.txt", FILE_READ);
  while (Datei.available()) {  
    Serial.write(Datei.read());
  }
  Serial.println(" ");  
  Datei.close();

}


void loop() {
  // put your main code here, to run repeatedly:

}



Quelle:
http://michaelsarduino.blogspot.co.at/2015/10/arbeiten-mit-dateien-auf-sd-karte.html





*********************************************************
6.1.3 Daten auf SD-Karte speichern
ARDUINO Ethernet Shield + SD

Größere Datenmengen zu speichern und anschließend auf dem eigenen Rechner auszuwerten und weiterzuverarbeiten, kann mit den bisher beschriebenen Methoden zur Datenspeicherung nicht realisiert werden.
Daten von einem Temperatursensor oder die Luftfeuchtigkeit können zwar im EEPROM gespeichert werden.
Wir haben aber gesehen, dass einerseits die Anzahl der Bearbeitungszyklen im EEPROM zu beachten ist und andererseits die Größe des möglichen Speichers noch nicht für große Datenmengen ausgelegt ist.

Im PC- und Fotobereich werden größere Datenmengen auf einfach zu nutzenden Memory Cards, beispielsweise SD-Karten gespeichert.
Diese Karten sind robust, können einfach transportiert und auf dem Zielsystem wieder gelesen werden.

Somit ist es naheliegend, diese Art von Speichermedium für den Einsatz im Arduino-Umfeld zu nutzen.
Für den Datenzugriff auf eine SD-Karte ist ein entsprechender SD-Card-Adapter nötig.
Ein solcher SD-Card-Adapter ist beispielsweise auf dem Ethernet Shield verfügbar.
Der Zugriff auf die SD-Karte erfolgt über den SPI-Bus (Serial Peripheral Interface).
Der SPI-Bus ist eine Schnittstelle vom Microcontroller zu externen Komponenten und digitalen Schaltungen.
Die SPI-Kom-munikation erfolgt hierbei als synchrone Datenübertragung, das heißt, dass das Senden und Empfangen von Daten parallel ablaufen kann, da für beide Datenrichtungen eigene Signalleitungen zur Verfügung stehen.
Das Arduino-Board nutzt für die SPI-Kommunikation die Portleitungen Dio bis D13.

Die Signale sind dabei:
Dm: Slave Select (SS)
Dii: Master Out, Slave In (MOSI)
D12: Master In, Slave Out (MIS 0)
D13: Clock (SCK)

nur bei ARDUINO Ethernet-Shield mit SD
Hinweis
Da die Ethernet-Schnittstelle standardmäßig auch über SPI mit dem Microcontroller kommuniziert, wird für die Nutzung der SD-Card zusätzlich noch ein Slave Select benötigt, dieser ist auf dem Ethernet Shield auf Pin 4 (üblicherweise Pin-10)  geführt.
Der Slave Select für die Ethernet-Schnittstelle, der an Pin-10 ist, bleibt bei dieser SD-Card-Anwendung ungenutzt.



SD Card Library
Ab der IDE-Version 0022 wird standardmäßig eine Bibliothek für das Schreiben und Lesen einer SD-Card mitgeliefert.
Die Beispiel-Sketches der SD CARD-Library ermöglichen dem Anwender einen einfachen und schnellen Einsatz.

Das Beispiel »Datalogger« schreibt eingelesene Analogwerte auf die SD-Karte.
Zur Kontrolle der Funktionalität werden Statusmeldungen auf die serielle Schnittstelle geschrieben.
Die erfassten Messwerte der analogen Ports werden nun, durch
Komma getrennt, in die Textdatei datalog.txt geschrieben.

Nach dem Einbinden der SD CARD-Bibliothek wird der Chip-Select-Port definiert


#include <SD.h>
// Chip Select, Signal SS (Slave Select)
const int chipSelect = 4;

Dies ist, wie oben erwähnt, das Select-Signal für die SD-Card.

In der Setup-Routine wird die serielle Schnittstelle initialisiert und der Standard-Chip-Select des SPI als Ausgang definiert.
Anschließend wird geprüft, ob die Karte bereit ist.


void setupO
{
Serial.begin(9600);
Serial.print("Initialisierung SD-Card...");
// SPI Chip Select als Ausgang setzen, auch wenn nicht genutzt
pinMode(10, OUTPUT);

// Prüfen, ob SD-Card bereit für Initialisierung
if (!SD.begin(chipSelect))
{
Serial.println("SD-Card nicht bereit oder fehlend");
// nichts weiter zu tun
return;
}
Serial.println("SD-Card initialisiert");
}


Zu Beginn der Hauptroutine wird ein Datenstring datastring definiert.
In diesem String werden alle Daten zusammengefügt, die anschließend als Zeile im File auf der SD-Card erscheinen.
Nach jedem Schreiben einer Zeile auf die Speicherkarte wird wieder ein neuer, leerer String erzeugt.


void loop()
{
// String für Daten
String dataString = "";


In einer Schleife werden die drei analogen Ports Ao bis A3 gelesen und die Daten mittels Kommazeichen getrennt in den Datenstring geschrieben.

// 3 analoge Ports lesen und zusammenfügen
// Trennzeichen ist Komma (,)
for (int analogPin = 0; analogPin < 3; analogPin++)
int sensor = analogRead(analogPin);
dataString += String(sensor);
if (analogPin < 2) {
dataString += ",";
}
}

Nun erfolgt der Zugriff auf die Speicherkarte und das Datenfile wird geöffnet.

// Datenfile öffnen
// es kann immer nur ein File gleichzeitig geöffnet werden
File dataFile = SD.open("datalog.txt", FILE_WRITE);

Falls das File bereit ist, werden die Daten in die Datei

// falls File bereit, Daten schreiben
if (dataFile)
{
dataFile.println(dataString);
dataFile.close();
// Daten auf seriellen Port schreiben
Serial.println(dataString);
}

Ist die Datei nicht bereit, erfolgt die Ausgabe einer Fehlermeldung auf die serielle Schnittstelle.

}
// Falls Fehler beim Öffnen des Files, Meldung ausgeben
else
{
Serial.println("Fehler beim Öffnen des Datenfiles datalog.txt");
}





buch2_kap6_1_3_datenlogger.ino
ident mit scetch zu ARDUINO ETHshield SD

In Listing 6.4 ist der gesamte Datenlogger dargestellt.

#include <SD.h>

// Chip Select, Signal SS (Slave Select)
const int chipSelect = 4;

void setup()
{
Serial.begin(9600);
Serial.print("Initialisierung SD-Card...");
// SPI Chip Select als Ausgang setzen, auch wenn nicht genutzt
pinMode(10, OUTPUT);

// Prüfen, ob SD-Card bereit für Initialisierung
if (!SD.begin(chipSelect))
{
Serial.println("SD-Card nicht bereit oder fehlend");
// nichts weiter zu tun
return;
}
Serial.println("SD-Card initialisiert");
}


void loop()
{
// String für Daten
String dataString = "";
// 3 analoge Ports lesen und zusammenfügen
// Trennzeichen ist Komma (,)
for (int analogPin = 0; analogPin < 3; analogPin++) {
int sensor = analogRead(analogPin);
dataString += String(sensor);
if (analogPin < 2) {
dataString += ",";
}
}

// Datenfile öffnen
// es kann immer nur ein File gleichzeitig geöffnet werden
File dataFile = SD.open("datalog.txt", FILE_WRITE);
// falls File bereit, Daten schreiben
if (dataFile)

{
dataFile.println (dataString) ;
dataFile.close();
// Daten auf seriellen Port schreiben
Serial.println (dataString) ;
}
// Falls Fehler beim Öffnen des Files, Meldung ausgeben
else
{
Serial.println("Fehler beim Öffnen des Datenfiles datalogst .txt");
}
}

Listing 6.4: Datenlogger — Daten speichern auf SD-Card



Eingebaut in eine kleine Box kann dieser einfache Datenlogger unabhängig Daten sammeln und intern speichern.
Um die Daten auf einer Zeitachse auszuwerten, fehlt dem Datenlogger ein Zeitstempel.
Die genaue Zeit kann mit einem speziellen Uhrenbaustein, beispielsweise einem DS1307 (siehe Abschnitt 4.4.3), oder einem DCF-77 Empfänger ermittelt werden.
Falls der Datenlogger GPS-Daten erfasst, kann die genaue Uhrzeit direkt aus dem Datenstring des GPS-Moduls ausgelesen werden.

SD Card Shield
Neben dem SD-Card-Adapter auf dem Ethernet Shield gibt es weitere Hardware-Lösungen mit integriertem SD-Card-Adapter.
Diese Lösungen sind meist als Shield realisiert und können direkt auf ein Arduino-Board gesteckt werden.
Je nach Bauform und Art und Größe des Shields können SD-Cards oder Mini-SD-Cards eingesteckt werden.
Da diese Kartenadapter, wie beim Ethernet Shield, über den SPI-Bus angesprochen werden, kann die Standard-Bibliothek SD für den Datenzugriff eingesetzt werden.
Falls einige Hardware-Varianten diese Bibliothek nicht unterstützen, ist das in der Produktbeschreibung erwähnt.
Nachfolgend ein paar Hardware-Lösungen, die für Datenlogger-Anwendungen genutzt werden können.

Logger Shield (Adafruit)
http://www.ladyada.net/make/logshield/index.html
Das Logger Shield von Adafruit ist ein verbreitetes Shield mit integriertem SD-Card-Adapter.
Zusätzlich zum Adapter für die Speicherkarte ist auf dieser Lösung eine Uhrenschaltung mit Speicherbatterie vorhanden, die für Zeitstempel in Datenloggeranwendungen verwendet werden kann.
Daneben ist auf dem Shield Platz für eigene Schaltungen vorhanden.



Stackable SD Card Shield (ITead Studio)
http://iteadstudio.com/store/index.php?main_page=product_info&cPath=18&products_id=232

Dieses Shield für Speicherkarten ist mit zusätzlichen Buchsenleisten ausgerüstet, um weitere Shields aufzunehmen.
Das Shield besitzt zwei Adapter für Speicherkarten, einen SD-Card-Adapter auf der Oberseite und einen Adapter für Micro-SD auf der Unterseite.

Memoire Shield (Snootlab)
http://shop.snootlab.com/lang-en/snootlab-shields/86-memoire.html
Das Memoire Shield vom französischen Hersteller Snootlab hat neben dem Kartenadapter für SD-Speicherkarten auch einen Uhrenbaustein mit Speicherbatterie und ein kleines Protoshield integriert.

SD-Card-Schaltung
Die Ansteuerung der SD-Card benötigt nur die vier Signalleitungen des SPI und kann für eigene Anwendungen selbst aufgebaut werden.
Da die Speicherkarte mit 3,3V Signalen angesteuert werden muss, wird ein Pegelwandler benötigt, um die 5V Pegel des Arduino auf die erforderlichen Pegel zu wandeln.
Ein Pegelwandler kann dabei mit Widerständen realisiert werden. Abbildung 6.2 zeigt die konventionelle Ansteuerschaltung eines SD-Card-Adapters.


Abb. 6.2: Ansteuerung SD-Card-Adapter
Die Reihenschaltung der Widerstände mit 1,8k Ohm und 3,3k Ohm ist eine so genannte Spannungsteilerschaltung.
Die Signalspannung vom Arduino-Port wird über die Reihenschaltung der beiden Widerstände geteilt und gemäß ohmschen Gesetz fällt dabei über dem 3,3k Ohm-Widerstand von 3,23 Volt ab.

Berechnung des Strom durch die Reihenschaltung:
I=U/R=5V / (1k8+3k3) = 0,98 mA

Somit ergibt das einen Spannungsabfall am 3,3-kOhm-Widerstand von

U=I * R = 0,98mA * 3k3 = 3.23 V

Für das SPI-Signal MISO (Master In, Slave Out) ist kein Spannungsteiler nötig, da dieses Signal vom Slave (SD-Card) zum Master (Arduino) gesendet wird.
Ein 3,3-V-Signal wird dabei vom Arduino-Port als HIGH eingelesen und benötigt darum keine Signalwandlung mehr.
Die restlichen drei Signale der SPI-Kommunikation (SCK, MOSI, SS) sind jeweils Signale vom Master zum Slave.

Die Spannungsversorgung der SD-Card, die 3,3 V beträgt, wird vom Arduino-Board über die 3,3-V-Versorgung geliefert.



7.2.3 Datalogger und GPS Shield
http://www.ladyada.net/make/gpsshield/
Sensordaten erfassen und gleichzeitig die aktuelle Uhrzeit und die geografische Position des erfassten Datenwertes speichern, kann mit Ladyadas Datenlogger-und GPS-Shield realisiert werden.
Diese standortbasierte Lösung als Arduino-Shield besitzt neben einem Adapter für die SD-Karte zusätzlich die Anschlussmöglichkeit eines seriellen GPS-Moduls.
Die ermittelten Sensordaten können direkt auf die Speicherkarte geschrieben werden, wobei die aktuelle Uhrzeit und der Standort Informationen sind, die vom GPS-Modul geliefert werden.
Mit diesem Shield können natürlich auch andere standortbasierte (geo-based) Anwendungen realisiert werden.
Für Wanderer oder Naturbeobachter kann beispielsweise ein GPS-Modul mit Tracking-Funktion realisiert werden.
Die geografische Position wird dabei laufend auf der Speicherkarte gesichert.
Zu Hause können dann die gespeicherten Wegpunkte der Wanderung mittels Zusatztools, wie beispielsweise dem Online-Tool GP SVisualizer
http://www.gps-visualizer.com/), konvertiert und in Kartenanwendungen weiterverarbeitet werden.
Werden die Wegdaten ins KML-Format umgewandelt, kann die gesamte Wanderung anschließend mit Google Earthhttp://earth.google-com/) visualisiert werden.
Auf der Website dieses Shields stehen auch Beispiel-Sketches für den Zugriff auf das GPS-Modul sowie zur Datenspeicherung zur Verfügung.


7.2.9 SD Card Shield
Die Möglichkeit der Speicherung von Daten auf einer SD-Speicherkarte wurde auf verschiedenen Erweiterungsplatinen bereits realisiert.
Der Nachteil dabei ist aber, dass jeweils noch Zusatzelektronik für andere Anwendungen, wie ein GPS-Modul oder auch eine Ethernet-Verbindung, auf demselben Board vorhanden ist.
Das macht die SD-Funktionalität unnötig teuer. Ein einfaches SD Card Shield ohne Zusatzelektronik bietet Seeedstudio.
http://www.seeedstudio.com/depot/sd-card-shield-for-arduino-v21-p-492.html
Diese kleine Erweiterungsplatine beinhaltet nur den Adapter für die SD-Karte sowie ein paar Widerstände für die Spannungsteilung.
Der Adapter beansprucht den kompletten Platz eines Standard-Shields. Darum kann bei der Verwendung der SD-Karte keine weitere Erweiterungsplatine aufgesteckt werden.

Die Ansteuerung der SD-Karte erfolgt über SPI (Serial Peripheral Interface), das auf dem Arduino Uno die Pins jc), II, 12 und 13 verwendet.

Die Ansteuerung der SD-Karte und die Speicherung von Daten sind in Kapitel 6 beschrieben.

Hinweis:
Beim Einsatz des SPI sind die Ports 10 bis 13 des Arduino belegt und können nicht für andere Anwendungen genutzt werden. Der parallele Betrieb eines Ethernet Shields ist deshalb nicht möglich.



Quelle:
BUCH:Arduino Praxiseinstieg  Seite 272








DIN A4 ausdrucken
*********************************************************

Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:schaltungen@schaltungen.at
ENDE





Comments