Sensordaten in TXT.Datei auf SD Karte speichern

Hallo Ihr da draußen,

ich hätte da mal ein Problem. Meine Arduino-Erfahrungen beschränken sich auf das an und ausschalten von LED`s. Jetzt versuche ich mich an was neuem und zwar Sensordaten auf eine TXT.Datei auf einer SD Karte speichern. Der SD Karten Slot sitz auf einem Ethernet shield von AUKRU. Mein Arduino ist ein NOname Nachbau vom Mega 2560. Und ja ich weiß Originalteile sind besser. Aber für den Anfang und zum zerstören… da kann ich gut… sollte das günstige Board reichen.

Für den Anfang habe ich erstmal mit den Beispiel Dateien aus der Software angefangen.

SD Cardinfo.

/*
  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
// MKRZero SD: SDCARD_SS_PIN
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 native USB port only
  }

  Serial.print("\nInitializing SD card...");
  // 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 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) {
}

Das Ergebnis ist folgendes:

Initializing SD card…Wiring is correct and a card is present.
Card type: SD2
Volume type is FAT16
Volume size (bytes): 1018413056
Volume size (Kbytes): 994544
Volume size (Mbytes): 971
Files found on the card (name, date and size in bytes):

Was mich hier schon wundert ist das er die Dateien und Ordner nicht auflistet. Sollte er das nicht?
Die Karte ist im FAT (Standard) Formatiert und enthält 1 TXT Datei und ein Ordner mit einer TXT Datei.

Als weiteres habe ich versuche das SD Read/Write auszuführen.

/*
  SD card read/write
 This example shows how to read and write data to and from an SD card file
 The circuit:
 * SD card attached to SPI bus as follows:
 ** MOSI - pin 11
 ** MISO - pin 12
 ** CLK - pin 13
 ** CS - pin 4 (for MKRZero SD: SDCARD_SS_PIN)
 created   Nov 2010
 by David A. Mellis
 modified 9 Apr 2012
 by Tom Igoe
 This example code is in the public domain.
 */
#include <SPI.h>
#include <SD.h>
File myFile;
void setup() {
  // Open serial communications and wait for port to open:
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for native USB port only
  }

  Serial.print("Initializing SD card...");
  if (!SD.begin(4)) {
    Serial.println("initialization failed!");
    return;
  }
  Serial.println("initialization done.");
  // open the file. note that only one file can be open at a time,
  // so you have to close this one before opening another.
  myFile = SD.open("test.txt", FILE_WRITE);
  // if the file opened okay, write to it:
  if (myFile) {
    Serial.print("Writing to test.txt...");
    myFile.println("testing 1, 2, 3.");
    // close the file:
    myFile.close();
    Serial.println("done.");
  } else {
    // if the file didn't open, print an error:
    Serial.println("error opening test.txt");
  }
  // re-open the file for reading:
  myFile = SD.open("test.txt");
  if (myFile) {
    Serial.println("test.txt:");
    // read from the file until there's nothing else in it:
    while (myFile.available()) {
      Serial.write(myFile.read());
    }
    // close the file:
    myFile.close();
  } else {
    // if the file didn't open, print an error:
    Serial.println("error opening test.txt");
  }
}
void loop() {
  // nothing happens after setup
}

da bekomme ich folgende Meldung im Seriellen Monitor

Initializing SD card...initialization done.
error opening test.txt
error opening test.txt

Jetzt meine Frage.
Wo könnte mein Fehler liegen?
Ich habe auch schon probiert die Karte in anderen Formaten zu formatieren hat aber auch keine Verbesserung gebracht.

Hier nochmal die Daten von den benutzten Geräten:

Arduino Nachbau

The SainSmart Mega 2560 is a microcontroller board based on the ATmega2560. It has 54 digital input/output pins (of which 14 can be used as PWM outputs), 16 analog inputs, 4 UARTs (hardware serial ports), a 16 MHz crystal oscillator, a USB connection, a power jack, an ICSP header, and a reset button. It contains everything needed to support the microcontroller; simply connect it to a computer with a USB cable or power it with a AC-to-DC adapter or battery to get started. The Mega is compatible with most shields designed for the Arduino Duemilanove or Diecimila.

Summary:

Microcontroller: ATmega2560
Operating Voltage: 5V
Input Voltage (recommended): 7-12V
Input Voltage (limits): 6-20V
Digital I/O Pins: 54 (of which 14 provide PWM output)
Analog Input Pins: 16
DC Current per I/O Pin: 40 mA
DC Current for 3.3V Pin: 50 mA
Flash Memory: 256 KB of which 8 KB used by bootloader
SRAM: 8 KB
EEPROM: 4 KB
Clock Speed: 16?MHz

Ethernet Shield -

Aukru W5100 Ethernet Schild shield mit Micro-SD Kartensteck für Arduino UNO mega 2560 1280 328
This Ethernet Shield is based on the Wiznet W5100 Ethernet Chip and gives you an easy way to get your Arduino online. It is directly supported by the official Arduino Ethernet Library. It also includes an additional micro-SD card slot.
Kontroller: w5100
Konpatibel mit Arduino Main board, 2009 , UNO, mega 1280, mega 2560 usw.

Lieferumfang
1 x Ethernet-Shield

Arduino-compatible;Hinweis: Diese ist nicht original Arduino product.it ist nur ein Ersatz-Zubehör aus Aukru.

Es wäre ganz toll wenn sich da jemand mal der Sache annehmen könnte und mir ein Tip geben wo evtl. der Fehler liegt.
Bitte wenn es geht in normaler Sprache. bin 39 Jahre und des GUI/API/CPU/MFG Slang nicht mächtig. Ich bin auch eher ein Anwender der fertigen Programme und sehe mir die sehe mir die .h und .cpp Dateien eher mit knoten in den Augen an.

Grüße aus dem Rodgau

Fabian

Das Ergebnis ist folgendes:Was mich hier schon wundert ist das er die Dateien und Ordner nicht auflistet.

Prüfe mal nach, ob ALLE auf der SD-Karte angelegten Ordnernamen und Dateinamen der 8.3. Konvention für kurze Dateinamen entsprechen.

Die Standardmäßige SD-Library kann nur 8.3 Dateinamen.

Mit einem Alter von 39 Jahren kennst Du ja wohl kein MS-DOS-Betriebsssystem der achtziger Jahre, also hier mal ein Crash-Kurs in 8.3 Ordner und Dateinamen:

Ein Ordner oder Dateiname kann bis zu acht(!) Zeichen lang sein!
Kürzer ist erlaubt, länger NICHT!

Also gültige Ordnernamen wären beispielsweise "2016", "2017", "Texte" oder "Bilder".

Ungültig sind im FAT-System Namen, die länger sind, zum Beispiel "Meine Texte".
Wobei "Meine Texte" auch noch aus einem zweiten Grund ein ungültiger 8.3 Dateiname ist: Da ist ein (nicht erlaubtes) Leerzeichen drin!

Außerdem darf am Ende des Namens ein Punkt folgen, und weitere drei Zeichen als Dateiendung, wovon man hauptsächlich bei Dateinamen und nicht bei Ordnernamen gebrauch macht.

Also checke Deine SD-Karte nochmal nach:

  • entsprechen alle(!) Datei- und Ordnernamen auf der Karte der 8.3 Namenskonvention?

Wenn nicht, dann kannst Du sie mit der SD-Library, die mit der ARduino IDE mitgeliefert wird, NICHT lesen.

Wie gerade schon im anderen Therard mich hat das ganze auch Kopfzerbrechen bereitet.

Verbinde mal deine SD Karte mit dem PC und gehe auf Einstellungen-> Freigabe -> Erweiterte Freigabe

Dort gib die SD-Karte frei und bei Berechtigungen den Vollzugriff aktivieren und dann probiere es noch einmal

Und achte darauf dass die SD Karte den Schlater an der Seite nicht auf look steht.

LG

Hallo

danke für Deine schnelle Rückmeldung, ich versuche mir die Lektion zu merken.

Dateinamen gecheckt und alle 8.3. Konvorm

TEST.txt
[Ordner: Test] Inhalt :Test.txt

Leider weiterhin nur die info der karte (micro-SD) aber keine Dateien.

Ich hatte auch noch hier gelesen das die Formatierung nicht in Schnell sein sollte und die Karte ordentlich ausgeworfen sein sollte. Das hab ich in sozialistischer Reihenfolge gemacht aber keine Änderung.

Gruß FS

Ich habe Deinen Sketch auf meinen UNO geladen und eine 4 GByte Karte in das "SD Card Module" eingesteckt:

Initializing SD card...Wiring is correct and a card is present.

Card type: SDHC

Volume type is FAT32

Volume size (bytes): 4066902016
Volume size (Kbytes): 3971584
Volume size (Mbytes): 3878

Files found on the card (name, date and size in bytes):
REZEPTE.CSV 2016-11-05 12:01:36 212
ALONGN~1.TXT 2015-03-24 07:26:02 147

Die letzte Datei hat einen längeren Namen, der auf 8.3 gekürzt wird.

Ich habe 256 MByte, 1 GByte und eben auch 4 GByte probiert, alle mit dem gleichen positiven Ergebnis.

Eine Karte vom Typ SD2 konnte ich bei mir nicht finden.

Ahhhhh daher könnte der Wind ja auch wehen.

Die Karte ist aus einem alten Handy... am end ist das für die lib. eine nicht unterstütze Steinzeitkarte.
mal sehen ob ich noch eine andere Karte irgendwo finden kann.

danke für den Tip

gruß FS

Ich meine mal was gelesen zu haben, dass die SD-Slots auf den Ethernet-Shields gerne Probleme machen. Und das evtl. mit dem CS-Pin zu tun hat ... wabert bei mir aber nur ganz dunkel in der grauen Masse.

Vielleicht mal eine bekannte Suchmaschine bemühen - oder die Pinbelegung mal checken.

fabi4711:
Ahhhhh daher könnte der Wind ja auch wehen.
Die Karte ist aus einem alten Handy... am end ist das für die lib. eine nicht unterstütze Steinzeitkarte.
mal sehen ob ich noch eine andere Karte irgendwo finden kann.

Das Alter der Karte spielt keine Rolle.
Die für Mikrocontroller benötigte "SPI-Mode" Betriebsart wird von uralten wie auch von brandneuen SD-Karten unterstützt, und wenn eine frische "FAT" Formatierung drauf ist, kannst Du das Dateisystem praktisch nur dadurch ungültig machen, dass Du die Karte in ein Gerät mit einem modernen Betriebssystem einlegst und es das Dateisystem dann durch Erzeugen ungültiger Ordner- oder Dateinamen (Dateinamen, die nicht der 8.3 Namenskonvention entsprechen) zerstörst und unbrauchbar machst für Zugriffe mit Libraries, die nur 8.3 Dateinamen beherrschen, wie die SD-Library aus der Arduino-IDE.

Wenn Du Dir nicht sicher bist, was auf der alten SD-Karte an Dateien und Ordnern drauf ist und mit welchem Betriebssystem was darauf gespeichert wurde: Eine frische FAT-Formatierung drauf, dann sollte sie mit der SD-Library der ARduino-IDE laufen.

so jetzt nochmal die Karte formatiert. FAT (16 Kb) ausgeworfen KEINE Dateien draufgespeichert.

ins Shield gesteckt und ReadWrite ausgeführt

/*
SD card read/write

This example shows how to read and write data to and from an SD card file
The circuit:

  • SD card attached to SPI bus as follows:
    ** MOSI - pin 11
    ** MISO - pin 12
    ** CLK - pin 13
    ** CS - pin 4 (for MKRZero SD: SDCARD_SS_PIN)

created Nov 2010
by David A. Mellis
modified 9 Apr 2012
by Tom Igoe

This example code is in the public domain.

*/

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

File myFile;

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

Serial.print(“Initializing SD card…”);

if (!SD.begin(4)) {
Serial.println(“initialization failed!”);
return;
}
Serial.println(“initialization done.”);

// open the file. note that only one file can be open at a time,
// so you have to close this one before opening another.
myFile = SD.open(“test.txt”, FILE_WRITE);

// if the file opened okay, write to it:
if (myFile) {
Serial.print(“Writing to test.txt…”);
myFile.println(“testing 1, 2, 3.”);
// close the file:
myFile.close();
Serial.println(“done.”);
} else {
// if the file didn’t open, print an error:
Serial.println(“error opening test.txt”);
}

// re-open the file for reading:
myFile = SD.open(“test.txt”);
if (myFile) {
Serial.println(“test.txt:”);

// read from the file until there’s nothing else in it:
while (myFile.available()) {
Serial.write(myFile.read());
}
// close the file:
myFile.close();
} else {
// if the file didn’t open, print an error:
Serial.println(“error opening test.txt”);
}
}

void loop() {
// nothing happens after setup
}

mit folgendem Ergebniss

Initializing SD card…initialization done.
error opening test.txt
test.txt:

hmmm wie kann ich das mit dem CS PIN überprüfen? Das schield ist direkt auf dem Mega aufgesteckt.

Gruß Fabian

fabi4711:
Das schield ist direkt auf dem Mega aufgesteckt.

Gruß Fabian

Wenn das Shield auf einem Board steckt und Du für SPI-Zugriffe nicht den hardwaremäßigen ChipSelect/SlaveSelect Pin der ControllerHardware auf dem Board verwendest, sondern einen anderen Pin (in Deinem Fall Pin-4), dann solltest Du den SlaveSelect Pin des Controllers auf OUTPUT setzen, bevor Du zugreifst.

Füge mal die pinMode-Zeile in Deinem Sketch zusätzlich ein, bevor Du SD.begin aufrufst

  pinMode(SS,OUTPUT);

Ändert sich dann etwas?

Das originale cardinfo.ino aufgespielt, microSD in den Slot auf dem Ethernetshield (Fat32 vorformatiert). 2 Lange Dateinamen, einer mit Blank drin drauf.
Werden ordentlich in der 8.3-Umsetzung ausgegeben.

Gruß Tommy

jurs:
Wenn das Shield auf einem Board steckt und Du für SPI-Zugriffe nicht den hardwaremäßigen ChipSelect/SlaveSelect Pin der ControllerHardware auf dem Board verwendest, sondern einen anderen Pin (in Deinem Fall Pin-4), dann solltest Du den SlaveSelect Pin des Controllers auf OUTPUT setzen, bevor Du zugreifst.

Füge mal die pinMode-Zeile in Deinem Sketch zusätzlich ein, bevor Du SD.begin aufrufst

  pinMode(SS,OUTPUT);

Ändert sich dann etwas?

Nix hat sich geändert. Hier ein auszug vom CODE.

Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for native USB port only
}

Serial.print("Initializing SD card...");
pinMode(SS,OUTPUT);
if (!SD.begin(4)) {
Serial.println("initialization failed!");
return;
}

ich werde mal weiter nach einer anderen sdkarte sehen.

So hallo Allerseits,

heute gabs beim "S"-Planeten eine SD-Karte zu erwerben. 8B SDHC Micro Dingsi.

Natürlich gleich getestet und siehe da es funzt. Es lag an der Karte.

Also alte Karte beerdigen und mit der neuen spielen.

Demnach ist die hier gestellte Frage gelöst und kann geschlossen werden.

Ich melde mich aber gleich wieder mit einem neuen Problem.

Gruß FS

Danke für die Rückmeldung! :slight_smile:

Bin gerade auch dabei, mich mit dem Thema SD Speicher anzufreunden.
Meine Tests und Recherchen haben bislang ein diffuses Bild zu diesem Thema ergeben; die Arduino-Entwickler sammeln momentan viele Negativ-Feedbacks und versuchen, das Problem asap zu lösen.

Meine Erkenntnisse bisher:
Die Ergebnisse, ob man mit SDCards Erfolg hat oder nicht, sind abhängig von:

  1. IDE version (angeblich Probleme ab Version "1.6.8")
  2. SD Bibliotheks-Version (aktueller Vorschlag der Arduino-Entwickler: downgrade auf SD library 1.09, wenn man schon 1.10 drauf hat)
  3. Betriebssystem bzw. Formatier-Programm: Es wird davon abgeraten, eine SD-Karte mit Windows oder Mac und deren Bordmitteln oder Zusatzsoftware zu formatieren; vielmehr soll "SDFormatter" genommen werden (SDFormatter gibt es in Version 4.0 von der SD-Association, d.h. die Organisation, die die Standards von SD-Karten herausgibt).
  4. SD-Karten selbst, je nach Hersteller und verwendetem Standard (SD/SDHC/SDXC)

Testkonstellationen:

  • Test-Sketch: CardInfo (aus IDE-Beispielen) bzw. SdInfo (aus SdFat library)
  • angepasst bzgl. CS-Pin (Nano: 4; UNO mit Ethernet-Shield: 10)
  • pinMode(10, OUTPUT); digitalWrite (10, HIGH);
  • unterschiedliche Karten SD, SDHC 1GB, 4GB, 8GB von unterschiedlichen Herstellern
  • UNO mit Ethernet-Shield und integriertem SD-Karten-Modul
  • Nano mit SD-Card Board (Adafruit-Clone mit logic level shifter)

Meine Ergebnisse bislang
a) Unter IDE 1.8 / SD library 1.10 und 1.09 (jeweils für FatSD und SD getestet) wurden alle normal, d.h. mit meinem Mac oder Windows formatierten Karten NICHT initialisiert
b) Gleiches Ergebnis für mit SDFormatter formatierten Karten (kein Quickformat benutzt)
c) Gleiche Negativ-Erlebnisse für UNO/Ethernet-Shield bzw. Nano mit externem SDCard-Modul

Per Zufall habe ich dann noch einmal eine Karte mit dem SDFormatter neu formatiert und diesmal die Option "Interoperability" ausgewählt.
Resultat: BINGO !!!

Habe dann alle anderen SDKarten ebenso mit dieser Option formatiert und getestet (bislang nur auf dem Ethernet-Shield und mit SDInfo): Alles funktioniert!

Werde die Tests jetzt erweitern und berichten, wenn ich neue Erkenntnisse habe.

Werde die Tests jetzt erweitern und berichten, wenn ich neue Erkenntnisse habe.

Mein bisheriger Stand : alte IDE und alte 256 MB Karte in FAT16 ist nicht sehr befriedigend.
Weil es solche Karten kaum noch gibt.

Bin sehr gespannt auf neue Erkenntnisse.

Hallo

Kämpfe mit ähnlichem Problem auf Arduino Mega 2560 mit Ethernet Shield:

const int chipSelect = 4;

//SD Card initialisieren
  Serial.print(F("Initialisierung SD-Card....."));
  if (!card.init(SPI_HALF_SPEED, chipSelect)) {
    Serial.println(F("Card nicht gefunden!"));
    // don't do anything more:
  }
  else{
    Serial.println(F("Card initialisiert."));
    SD.begin(chipSelect);
  }

Nach ca jedem zweiten Start wird die SD Card nicht gefunden.

Könnte hier der Pin4 das Problem sein?

Nach ca jedem zweiten Start wird die SD Card nicht gefunden.

Könnte hier der Pin4 das Problem sein?

Meine bisherigen Erkenntnisse zeigen auf, dass es sehr auf den Kartentyp und die Formatierung ankommt. Pin4 ist sicher nicht das Problem, da ChipSelect mit dem Ethernet-Shield nur auf Pin4 funktioniert.

Meine Tests mit dem Nano ergaben, dass man anstelle von Pin 10 auch "SS" als default-Wert für "normale" SPI-Kommunikation nehmen kann; beim Ethernet-Shield versagt das aber wg. der "Nicht-Standard"-Verdrahtung des shields bzgl. SPI. Hier ist CS unlösbar mit Pin 4 verbunden.

Mein bisheriger Stand : alte IDE und alte 256 MB Karte in FAT16 ist nicht sehr befriedigend.
Weil es solche Karten kaum noch gibt.

Bin sehr gespannt auf neue Erkenntnisse.

Kann ich bestätigen; meine 1GB Noname-SD-Karte bringt leider unter den gleichen Testbedingungen wie eine neuere 2GB-Karte rein binäre Ergebnisse: geht / geht nicht / geht ..

Um diesen Thread jetzt nicht weiter off-topic zu überfrachten oder zu kidnappen, mache ich einen neuen Thread zum Thema SD-Karten-Test auf und werde dort meine Ergebnisse je nach Stand vorstellen. Ggf. erweitere ich gleich den Thread um mein eigentliches Projektziel, die SD-Daten in regelmäßigen Abständen auszulesen und an eine Datenbank zu übertragen, zunächst kabelgebunden, ggf. später drahtlos.

Danke für die Rückmeldung.
Bin auch sehr gespannt auf deinen neuen Thread.

Mein Projektziel ist ähnlich: brauche die SD als Puffer für meine Sensordaten, welche schlussendlich in der DB landen.