Der Arduino Ethernet hat einen SD-Slot, ansonsten auch das Ethernet- oder WiFi-Shield, siehe auf der Hauptseite
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.
Im einfachsten Fall steckst Du irgendein ordentliches "Shield mit SD-Kartenschacht" auf, z.B. ein "Ethernet-Shield" auf und bekommst
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.
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):
Für dieses Watterott-SD-Modul gilt das von mir gezeigte Anschlussbild NICHT, das wird direkt angeschlossen.
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.
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.
In diesem Post möchte ich ein kleines Anwendungsbeispiel zur Verwendung von SD Karten zum Speichern von Sensorwerten liefern.
Dadurch kann man SD Karten mit dem Arduino lesen und beschreiben, was die Speicherkapazität des Arduino extrem erweitert.
Die Verkabelung
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 8const 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:
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.
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:[email protected]
ENDE
