Arduino: SD-Library - Karte entfernen

[Manfred (Gast)]

Ich habe mir heftig den Wolf gesucht und Stunden im Google zugebracht, 
das Problem scheint bekannt, aber keine Lösung:

Ich kann eine SD-Karte beschreiben und lesen. Wenn diese beim Start 
meiner Software nicht eingesteckt ist, wird das erkannt. Nun will ich 
aber auch erkennen, wenn diese im laufenden Betrieb gezogen wird oder 
verreckt.

Ob die SD-Library aus der IDE 1.7.4 oder jene aus der 1.8.5 eingesetzt 
wird, mach keinerlei Unterschied.

Die angehängte Software erfüllt keinen produktiven Sinn, lässt lediglich 
4 LEDs als Lauflicht tackern und schreibt alle paar Sekunden Daten auf 
die Karte. Nach jeweils sechs geschriebenen Datensätzen wird der Inhalt 
der Datei gelesen und seriell ausgegeben, auch da passiert Unfug.

/*
  SD card test
  Hardware: Nano

 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.

 ** MOSI - pin 11
 ** MISO - pin 12
 ** CLK -  pin 13
 ** CS -   pin 2

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

String Version = "V 2018-02-10";

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

const int chipSelect = 2; // 31.12.2015 
File myFile;

void setup()
{
  pinMode(6, OUTPUT);
  digitalWrite (6, LOW);
  pinMode(7, OUTPUT);
  digitalWrite (7, LOW);
  pinMode(8, OUTPUT);
  digitalWrite (8, LOW);
  pinMode(9, OUTPUT);
  digitalWrite (9, LOW);
  pinMode(10, OUTPUT);
//  digitalWrite (10, LOW);
  
  // Open serial communications and wait for port to open:
  Serial.begin(57600); // 31.12.2015
  Serial.println(F("Test SD-Card"));
  Serial.print(F("Version "));
  Serial.print(Version);
  Serial.println(F(" gestartet"));
  Serial.print(F("Initializing 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(F("initialization failed. Things to check:"));
    Serial.println(F("* is a card is inserted?"));
    Serial.println(F("* Is your wiring correct?"));
    return;
  } else {
    Serial.println(F("Wiring is correct and a card is present."));
  }

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

  // Now we will try to open the 'volume'/'partition' - it should be FAT16 or FAT32
  if (!volume.init(card)) {
    Serial.println(F("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(F("Volume type is FAT"));
  Serial.println(volume.fatType(), DEC);

  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(F("Volume size (bytes): "));
  Serial.println(volumesize);
  Serial.print(F("Volume size (Kbytes): "));
  volumesize /= 1024;
  Serial.println(volumesize);
  Serial.print(F("Volume size (Mbytes): "));
  volumesize /= 1024;
  Serial.println(volumesize);

  Serial.println(F("\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);
  
  Serial.println(F("Pause 1 Sek"));
  delay(1000);
  
  if (!SD.begin(chipSelect)) {
    Serial.println(F("initialization failed!"));
    return;
  }
  Serial.println(F("initialization done."));
  
  SD.remove("test.txt");  // debug Datei loeschen
  myFile = SD.open("test.txt", FILE_WRITE);

  // if the file opened okay, write to it:
  if (myFile) {
    Serial.print(F("Writing to test.txt..."));
    myFile.println(F("** write started in setup **"));
    myFile.println(Version);
    myFile.print(millis());
    myFile.println(F(" ms"));
    // close the file:
    myFile.close();
    Serial.println(F("first write done / myFile = "));
    Serial.print(myFile);
  } else {
    // if the file didn't open, print an error:
    Serial.println(F("error opening test.txt for write"));
  }
  Serial.println(F(" ")); // Leerzeile erzeugen
    // open a file for reading:
  myFile = SD.open("test.txt");
  if (myFile) {
    Serial.println(F("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(F("error opening test.txt for read"));
  }
  
} // Ende Setup

int Loopct = 0;

void loop(void) {
 digitalWrite (6, HIGH);
 delay(300);
 digitalWrite (7, HIGH);
 delay(300);
 digitalWrite (8, HIGH);
 delay(300);
 digitalWrite (9, HIGH);
 delay(300);
 // digitalWrite (10, HIGH);
 // delay(2000);
 // digitalWrite (10, LOW);
 // delay(300);
 digitalWrite (9, LOW);
 delay(300);
 digitalWrite (8, LOW);
 delay(300);
 digitalWrite (7, LOW);
 delay(300);
 digitalWrite (6, LOW);
 delay(2000);

  if (!SD.exists("test.txt")) {
    Serial.println(F("** SD.exists negativ **"));
    return;
  }

 myFile = SD.open("test.txt", FILE_WRITE);
 Serial.print(F("return myFile = "));
 Serial.println(myFile);
  if (myFile) {
    Serial.print(F("Loop writing to test.txt... "));
    myFile.println(F("testing 1, 2, 3."));
    myFile.println(Version);
    myFile.print(millis());
    int lastwrite = myFile.println(F(" ms Zeile zwei"));
    // close the file:
    myFile.close();
    Serial.println(F("done."));
    Serial.print(F("return myFile closed = "));
    Serial.print(myFile);
    Serial.print(F(" / return from write = "));
    Serial.println(lastwrite);

  } else {
    // if the file didn't open, print an error:
    Serial.println(F("error"));
  }
 Loopct ++;
 if (Loopct > 5) {
   Loopct = 0;
   readfile();
 }   

} // Ende loop

void readfile() {
  myFile = SD.open("test.txt");
  if (myFile) {
    Serial.println(F("read test.txt"));
    // read from the file until there's nothing else in it:
    while (myFile.available()) {
      Serial.write(myFile.read());
    }
    myFile.close();
  } else {
    // if the file didn't open, print an error:
    Serial.println(F("error opening test.txt for read"));
  }
} // Ende readfile

In Zeile 180 frage ich, ob die Datei existiert - das Ergebnis bleibt 
wahr, wenn die Karte nach ein paar Schreibzyklen gezogen wird.

In Zeile 202 sollte das Programm aussteigen, wenn sd.open false liefert 
- egal, das ist immer true, auch wenn die Karte gezogen wird.

In Zeile 193 hole ich mir den Rüchgabewert des write-Befehls, der wird 
tatsächlich null, wenn die Karte fehlt - mein derzeit einziger Ansatz.

Ideen dazu?

---

Ein weiteres Problem habe ich beim Lesen: Wenn die Karte gezogen wurde, 
findet die Leseroutine offenbar kein Ende und gibt per Serial.print 
tagelang unsinnige Zeichen aus. Tut nicht wirklich weh, da ich in der 
beabsichtigten Endanwendung nicht lesen muß, eine Lösung hätte ich 
dennoch gerne.

[Stefan F. (Gast)]

Ich glaube, da musst Du Dir mal den Quelltext der SD Library genau 
anschauen. Du brauchst ein harmloses Kommando, dass du an die Karte 
schicken kannst und welches sich im Fehlerfall nicht in eine 
Endlosschleife aufhängt.

Manche SD Karten Slots enthalten einen Schaltkontakt, der durch das 
Einstecken der Karte betätigt wird.

[Manfred (Gast)]

Stefan U. schrieb:
> Du brauchst ein harmloses Kommando, dass du an die Karte
> schicken kannst und welches sich im Fehlerfall nicht in eine
> Endlosschleife aufhängt.

Jetzt ist mein Gerät so weit, dass ich mich um die Karte kümmern muß. 
Einzig zuverlässig scheint der Rückgabewert geschriebener Bytes: "int 
BytesWritten = myFile.print(" ms");"

Ist dieser Null, kann ich "card.init" wiederholen - eine nachträglich 
gesteckte Karte wird dann erkannt und beschrieben.

---------

Jetzt treibt mich aber eine andere Sache um: Aus Gründen der Verdrahtung 
habe ich CS auf D2 gelegt und D10 als Steuerausgang benutzt. Sobald ich 
den SPI anfasse, wird D10 high :-(

Weder in SPI.h noch SD.h bzw. *.cpp finde ich Zugriffe auf D10, wohl 
aber im Internet, dass diese Verknüfung im AT328 fest vorgegeben sei. 
Mist, muss ich wohl den Lötkolben nehmen und umpfuschen.