Mehrere Dateien mit gleichem Namen auf microSD

[Mark M. (mom-jovi)]

Mein MSP430 schreibt über das FAT-System (zu finden bei Google über 
"sham176") Textdateien auf eine microSD. Soweit funktioniert alles. 
Manchmal aber sind nach der Messung mehrere Dateien auf der Karte, die 
alle denselben Namen (+ Endung) haben, aber unterschiedliche Größe.
Der Inhalt ist bei allen Dateien identisch und man kann sie auch alle 
öffnen.
Wenn ich eine der Dateien lösche, kommt die übliche Windows-Abfrage, die 
man mit Ja bestätigen muss. Ist diese erste Datei gelöscht, kommt die 
Abfrage erneut, bis alle Duplikate der Datei weg sind.

Hat jemand ne Idee, was hier vorliegt?

[Guest (Gast)]

FAT-Tabelle fehlerhaft

[Mark M. (mom-jovi)]

Guest schrieb:
> FAT-Tabelle fehlerhaft

Hab ich mir auch gedacht.
Und wie passiert sowas? Das ist ja nur ab und zu.
Ist es ein Formatierungsproblem (nach vielen Schreibaktionen ohne 
Formatierung von Windows), oder liegt es am µC?

[Rufus Τ. F. (rufus)]

Dein Verzeichnis ist fehlerhaft, bzw. Deine Routine zum Anlegen neuer 
Dateien prüft nicht, ob die betreffende Datei schon existiert, und legt 
weitere Verzeichniseinträge gleichen Namens an.

[Simon H. (simi)]

Könnte es sein, dass im uC mehrere Tasks auf das Filesystem zugreifen? 
Sprich:

- Läuft irgendein Task-Scheduler auf Deinem uC?
- Falls ja: Hat mehr als ein Task Zugriff auf Dein FAT-System?
- Falls ja: Ist Dein FAT-System reentrant?
- Falls nein: Hast Du eine eigene Zugriffskontrolle (Mutex) gemacht, so 
dass nie zwei Tasks gleichzeitig Zugriff auf die FAT haben?

Das ist, was mir spontan dazu einfällt.

Gruäss
Simon

[Rufus Τ. F. (rufus)]

Dateinamen werden nicht in der FAT, sondern im Verzeichnis gespeichert - 
und genau das wird fehlerhaft sein.

[Mark M. (mom-jovi)]

Die Datei wird nur einmal zu Beginn geöffnet und anschließend 
beschrieben.

Die zum-Schreiben-öffnen-Funktion gab ursprünglich beim Vorhandensein 
einer Datei einen Fehler zurück und hat dann nichts mehr gemacht. Das 
habe ich geändert.
Führt das zu Fehlern, wenn eine Datei schon vorhanden ist? Aber es 
passeirt auch, wenn ich davor am PC alle Dateien lösche.

[U.R. Schmitt (Gast)]

Mark M. schrieb:
> Die zum-Schreiben-öffnen-Funktion gab ursprünglich beim Vorhandensein
> einer Datei einen Fehler zurück und hat dann nichts mehr gemacht. Das
> habe ich geändert.

Tja bloss wie hast Du es geändert? Richtig wäre daß entweder ein Fehler 
kommt oder die alte Datei überschrieben wird, je nach deinem Gusto.
Du wirst es so geändert haben, daß eine 2. gleichen Namens angelegt 
wird.

[Mark M. (mom-jovi)]

U.R. Schmitt schrieb:
> Tja bloss wie hast Du es geändert? Richtig wäre daß entweder ein Fehler
> kommt oder die alte Datei überschrieben wird, je nach deinem Gusto.
> Du wirst es so geändert haben, daß eine 2. gleichen Namens angelegt
> wird.

Meine Änderungen dafür sind unten im Kommentar angegeben, ich habe 
einfach die Zeile ersetzt, in der -2 für eine schon existierende Datei 
zurückgegeben wird (siehe Block A).

Dann ist mich aber noch eine andere Frage aufgekommen:

Macht es Sinn, eine -1 zurückzugeben, wenn der pathname invalid ist? So 
wie ich das sehe, kommt die -1 zurück, wenn cluster == 0 ist.
Da aber cluster = fileSys gesetzt wird, welches global nur 0 oder 1 sein 
kann, ist cluster nach erfolgreicher FAT-Initialisierung immer 1. Und 
cluster hat schon gar nichts mit pathname zu tun.
Stattdessen wird bei einem ungültigen Pathname - nämlich, wenn mehr als 
ein Backslash vorkommt, die -128 zurückgegeben. Sollte die -1 nicht dort 
stehen?

#define UNKNOWN 0
#define FAT16   1

/**
 *  opens the file indicated by the input path name.  If the pathname
 *  points to a valid path, the file is created and added to the list of
 *  currently opened files for writing and the unique file handle is returned.
 *
 *  @param  pathname  a pointer to the location of the file to be opened
 *
 *  @return  -1      invalid pathname
 *  @return  -2      file already exist
 *  @return  -3      file already opened for writing
 *  @return  -4      no directory entries left
 *  @return -10      no handles available
 *  @return  -20      memory card error
 *  @return  -128    other error
 *  @return  (non-negative)  file handle of sucessfully opened file
 **/
signed char fat_openWrite(const char *pathname)
{
   unsigned char buf[SECTOR_SIZE];
   const char *tempPathname;
   unsigned long cluster;
   unsigned long tempCluster;
   unsigned long fileSize = 0;
   signed char i = 0;
   signed char index = -1;

   if(detectCard() == FALSE)
   {
      return -20;
   }
   if(filesOpenedWrite >= BUFFER_SIZE)
   {
      return -10;
   }
   else
   {
      while((i < BUFFER_SIZE) && (index < 0))
      {
         if(openedWrite[i].fileHandle == -1)
         {
            index = i;
         }
         i++;
      }
   }
   cluster = fileSys;  //fileSys ist entweder UNKNOWN oder FAT16 (s. oben 0 oder 1)
  
   if(*pathname == 0x5C)
   {
      pathname++;
   }
   tempPathname = pathname;
   while(*tempPathname)
   {
      if(*tempPathname == 0x5C)
         return -128;
      tempPathname++;
   }  

   tempPathname = pathname;
   if(cluster != 0)
   {
      tempCluster = cluster;
      cluster = getFirstCluster(tempPathname, cluster, buf, FILE, &fileSize);
      if(cluster != 0)
      {
         return -2; // anstelle dieser Zeile BLOCK A eingefügt
      }
      else
      {  
         cluster = createNewEntry(tempPathname, tempCluster, buf, FILE);
         if(cluster != 0)
         {
/* *****************************************************************
 * BLOCK A
 * ****************************************************************/
            openedWrite[index].currentCluster = cluster;
            openedWrite[index].dirLocation = tempCluster;
            openedWrite[index].fileHandle = getFileHandle();
            openedWrite[index].fileSize = 0;
            openedWrite[index].sectorCount = 0;
            openedWrite[index].firstCluster = cluster;
            openedWrite[index].byteCount = 0;
            openedWrite[index].updateDir = FALSE;
            filesOpenedWrite++;
            return openedWrite[index].fileHandle;
/* *****************************************************************
 * ENDE BLOCK A
 * ****************************************************************/
         }
         else
         {
            return -4;
         }
      }
   }
   else
   {
      return -1;
   }
   return -128;
}

[Karl H. (kbuchegg)]

Mark M. schrieb:

> Meine Änderungen dafür sind unten im Kommentar angegeben, ich habe
> einfach die Zeile ersetzt, in der -2 für eine schon existierende Datei
> zurückgegeben wird (siehe Block A).

Und wie hast du sie ersetzt?

So einfach wird das nicht sein, sonst hätte das wohl der Originalautor 
auch so gemacht. Das mindeste was du tun musst, ist die bereits 
existierende Datei zu löschen, damit die Löschroutine die FAT und das 
Directory aufräumt.

Aber eigentlich ist es üblich, dass nicht das Filesystem solche Dinge 
entscheidet, sondern der Anwendercode. Ein Basissystem sollte nicht 
eigenmächtig (ausser es ist dokumentiert) destruktive Dinge machen, wenn 
sie im Anwendercode leicht durchgeführt werden können.

> Stattdessen wird bei einem ungültigen Pathname - nämlich, wenn mehr als
> ein Backslash vorkommt, die -128 zurückgegeben. Sollte die -1 nicht dort
> stehen?

Das kann man so nicht sagen. Dazu müsste man wissen, was die Doku zum 
Fehlercode -1 zu sagen hat.

[Karl H. (kbuchegg)]

Karl heinz Buchegger schrieb:

>> Stattdessen wird bei einem ungültigen Pathname - nämlich, wenn mehr als
>> ein Backslash vorkommt, die -128 zurückgegeben. Sollte die -1 nicht dort
>> stehen?
>
> Das kann man so nicht sagen. Dazu müsste man wissen, was die Doku zum
> Fehlercode -1 zu sagen hat.


Ooops. seh gerade, dass das ja im Funktionskommentar drinnen steht.
Ja, das würde ich mal als 'misslungene' Fehlermeldung klassifizieren.