MMC/SD-Karte mit FAT16 an AVR

[Meini (Gast)]

Soweit ich dein Schaltbild verstehe, sieht alles bis auf eines gut aus.
Du solltest Three-State auf 5Volt legen. Oder schaltbar machen wenn du 
strom sparen willst! Jedenfall muss laut Datenblatt 5Volt anliegen wenn 
der Level Shifter arbeiten soll. ( ich hab die Pin zu Pin Richtigkeit 
deiner Schaltung nicht kontrolliert)

[Meini (Gast)]

Ach ja noch was:

Wenn du mit dem µC erkennen willst welche Karte eingesteckt wurde 
solltest du die Schalter an den SD Slots getrennt abfragen. Ansonsten 
erkennst du immer nur einen Zustand, also Karte(n) drin.
Aber das ist nur wichtig wenn du auch wirklich beide Kartenslots 
verwenden willst, was ja gar nicht geht weil du nur ein CS durch 
schaltest und keine weiteren Ports am Level Shifter frei hast.

Aber würd ich mir noch vorher überlegen bevor du ein Layout machst.

[Martin J. (bluematrix)]

das sind zwei verschiede adapter layouts
die liegen auf der platine übereinander.
Ich kann daher nur eins bestücken, je nachdem welches isch zu erst zu 
kaufen bekommmen und welches günstiger ist

[Ingo S. (ingo-s)]

Hi,

ich beabsichtige Rolands card library auf der "OpenLog" Hardware Basis 
als Logger (Modellflug) einzusetzen. Das Problem ist nur, das das System 
irgentwann Spannungslos wird.

Es ist nicht kritisch, wenn die letzte Minute nicht geloggt ist. Wie ist 
der Filezustand in diesem Falle wenn die Karte anschliessend in einem PC 
ausgelesen werden soll? Ist das File leer, oder ist es bis zum letzten 
geschriebenen Buffer gefüllt?

Müsste man zwingend zyklisch einen "sync" durchführen oder sogar 
zyklisch das File schliessen und neu im append Mode öffnen? Es fallen 
alle 340ms 512 Byte Daten an.

Gruß Ingo

[holger (Gast)]

>Das Problem ist nur, das das System
>irgentwann Spannungslos wird.

Dann musst du die Spannung überwachen!

>Es ist nicht kritisch, wenn die letzte Minute nicht geloggt ist. Wie ist
>der Filezustand in diesem Falle wenn die Karte anschliessend in einem PC
>ausgelesen werden soll? Ist das File leer, oder ist es bis zum letzten
>geschriebenen Buffer gefüllt?

Wenn du Pech hast und bei zu wenig Spannung schreibst kann die
ganze Datei Schrott sein. Eventuell sogar das komplette Dateisystem
auf der Karte zerstört werden.

>Müsste man zwingend zyklisch einen "sync" durchführen oder sogar

Kann man machen. Siehe aber auch oben.

>zyklisch das File schliessen und neu im append Mode öffnen? Es fallen
>alle 340ms 512 Byte Daten an.

Das könnte zu lange dauern.

[Torsten S. (tse)]

> Es ist nicht kritisch, wenn die letzte Minute nicht geloggt ist. Wie ist
> der Filezustand in diesem Falle wenn die Karte anschliessend in einem PC
> ausgelesen werden soll? Ist das File leer, oder ist es bis zum letzten
> geschriebenen Buffer gefüllt?

Es fehlt einfach nur das was in den 512 Bytes 'großen' raw_block' noch 
gepasst hätte. Die Datei selbst ist immer ok und sogar für m$ lesbar.

> Müsste man zwingend zyklisch einen "sync" durchführen oder sogar
> zyklisch das File schliessen und neu im append Mode öffnen? Es fallen

Das muß man nicht denn es ist ja gerade Absicht erst einmal alles zu 
puffern und dann in einem Rutsch diesen Sektor auf die Karte zu 
schreiben.

> alle 340ms 512 Byte Daten an.

Das müßte man ausprobieren.
In meinem Fall, wo nur wenige hundert Bytes über einen langen Zeitraum 
geschrieben werden, mache ich zur Sicherheit immer einen sync. Freilich 
kostet das Performance. Hatte aber noch nie Datenverlust.

> Gruß Ingo
Torsten

[Ingo S. (ingo-s)]

Hi,

bei Spannungsverlust kann ich nur über die BrownOut detection arbeiten, 
da ich auf der super kleinen Platine nicht herumlöten will.

Wenn die Datei außer dem letzten raw_block ok ist, dann ist das mehr als 
ich gehofft habe. Ich hatte befürchtet, das durch fehlende Einträge in 
der File allocation Table zu viel fehlt bzw. nicht darauf zugegriffen 
werden kann.

Also werde ich das Projekt mal angehen, die Demo Main von Rolands card 
library funktioniert schon auf der "OpenLog" Platine.

Gruß Ingo

[Roland R. (roland)]

Hi zusammen,

Im Anhang findet Ihr die neueste Version von sd-reader. Im Vergleich zur 
letzten Version wurden drei Fehler behoben:
- Ausgabe gleicher Dateinamen bei zwei direkt aufeinander folgenden 
8.3-Dateinamen.
- Berechnung falscher Clusterpositionen oberhalb von 4GB.
- Endlose Auflistung des Verzeichnisinhalts bei gültigem Eintrag direkt 
am Ende des letzten Verzeichnis-Clusters.

Viel Spaß damit!

Gruß,
Roland

[Tobias M. (obi)]

Hi!

Ich möchte mir einen Datenlogger mit SD bauen.
Gibt es da irgendwelche Beschränkungen?
Also wie groß darf die SD- Karte maximal sein und was für einen µC 
braucht man mindestens?

Danke und Gruß
Tobias

[Morbit (Gast)]

Hallo,

Ich konnte es noch nicht richtig zum laufen bringen. Ich bin jetzt mal 
Schrittweise durchgegangen und habe zwei Dinge probiert, zum einen lasse 
ich eine Datei erstellen und einmal lasse ich eine auf der SD-Karte 
befindliche Datei öffnen. Letzteres klappt nicht, es kommt zum Fehler. 
Das Erstellen von Dateien klappt auch nicht richtig. Schieb ich die 
SD-Karte zum Lesen in den PC, so wird zwar die Datei angezeigt, möchte 
ich sie aber öffnen, so sagt mir Windows, dass die Datei nicht existiert 
und ob sie erstellt werden soll.

Nutze einen ATmega16L @ 8MHz und eine SanDisk 2 GB und den Code habe ich 
aus der beiliegenden main.c übernommen bzw. angepasst...

Es geht in dem Code unten nur die grüne LED an, also sollte beim 
Erstellen kein Fehler auftreten?!
Wenn ich die (von mir erstellte) Datei öffne (unten auskommentiert) 
leuchtet die rote LED, sprich ein Fehler tritt auf.

Was ich noch nicht ausprobiert habe, ist, was passiert, wenn ich eine 
Datei erstellen lasse und sie dann öffne.

Die SD-Karte formatier ich über Windows 7 und habe auch schon das Tool 
SDFormatter V2.0, welches auf der Homepage von Roland stand.

int main(void) {
  sd_raw_init();

  struct partition_struct* partition = partition_open(sd_raw_read,
                            sd_raw_read_interval,
                            sd_raw_write,
                            sd_raw_write_interval,
                            0);

  if (!partition) {
    partition = partition_open(sd_raw_read,
                  sd_raw_read_interval,
                  sd_raw_write,
                  sd_raw_write_interval,
                  -1);

    if (!partition) {
    }
  }
  
  struct fat_fs_struct* fs = fat_open(partition);
  struct fat_dir_entry_struct directory;
  fat_get_dir_entry_of_path(fs, "/", &directory);
  struct fat_dir_struct* dd = fat_open_dir(fs, &directory);

  struct fat_dir_entry_struct file_entry;
  if (!fat_create_file(dd, "Test.log", &file_entry)) {
    //LED_RED_ON;
  } else {
    //LED_GREEN_ON;
  }

  /*
  struct fat_file_struct* fd = open_file_in_dir(fs, dd, "Track.log");
  if (!fd) {
    LED_RED_ON;
  } else {
    LED_GREEN_ON;
  }

  char* data = "abc";
  uint8_t data_len = 3;
  if (fat_write_file(fd, (uint8_t*) data, data_len) != data_len) {
    LED_RED_ON;
  }

  sd_raw_sync();
  */
  if (!sd_raw_sync()) {
    LED_RED_ON;
  } else {
    LED_GREEN_ON;
  }
  delay_s(5);
  LED_GREEN_OFF;
  LED_RED_OFF;
//  fat_close_file(fd);
  fat_close_dir(dd);
  fat_close(fs);
  partition_close(partition);

  return 0;
}

[Werner F. (frewer)]

Hallo,

habe mir die Platine nach Riegel/Radig aufgebaut und versuche nun mal 
mit einer SD Karte 128MB zu testen. Als Prozessor verwende ich den 
ATmega328p. Die Software-Version 20101010 konnte ich ohne weiteres 
compilieren (Studio4) und mit Burn O Mat-USBasp in den Prozessor laden.
Mit einem Terminal Programm kann ich auch kommunizieren.
Ergebnis:
> disk
manuf:  0x02
oem:    TM
prod:   SD128
rev:    07
serial: 0x67783a65
date:   5/4
size:   120MB
copy:   0
wr.pr.: 0/0
format: 0
free:   122290176/125861888
> ls
DCIM/                                0
Test/                                0
> touch Myfile
error creating file: Myfile
> cat Test
error opening Test

DCIM enthält Bilder, Test enthält einen mit Editor geschriebenen kurzen 
Text.
Was mache ich falsch oder was habe ich noch nicht kapiert??

mfG
frewer

[Roland R. (roland)]

Hallo Werner,

Schau bitte mal in die FAQ auf meiner Homepage:
  http://www.roland-riegel.de/sd-reader/faq/#faq_writefails
  http://www.roland-riegel.de/sd-reader/faq/#faq_socketcdcl

Gruß,
Roland

[Werner F. (frewer)]

Hallo Klaus,

danke für Deinen Tipp. Nun ich habe gelesen und gelesen, konnte es aber 
noch nicht verwerten. Bin also genau dort noch, wo ich war. Werde mich 
doch viel tiefer in die Materie einlassen müssen, obwohl überall 
geschrieben steht, dass es ganz einfach sei.

Hi Roland,
habe die Änderungen in die config.h eingebaut, weil ich meinen Sockel 
ohne die Erkennung eingebaut habe. Die Kapazitäten waren schon immer 
drin und die Dioden aktiviere ich mit einem 2KOhm Widerstand, so dass 
immer die ca 3,5V anliegen (zusätzlich mit 1µ Tantal abgeblockt).
Trotzdem meldet die Eingabe > cat Test wieder "error opening Test".
>touch Myfile hingegen legt jetzt offenbar einen File an, denn ich bekomme mit

>ls
DCIM/     0
Test/     0
Myfile    0
>
und mit
>write Myfile 'Diesen Text sollte ich in Myfile wiederfinden'
bekomme ich
>ls
DCIM/     0
Test/     0
Myfile    35
>
und mit
>cat Myfile
00000000: 74 20 73 6f 6c 6c 74 65  't sollte'
00000008: 20 69 63 68 20 69 6e 20  ' ich in '
00000014: 4d 79 66 69 6c 65 20 77  'Myfile w'
00000018: 69 65 64 65 72 66 69 6e  'iederfin'
00000020: 64 65 6e 65 72 66 69 6e  'denerfin'

nun ein bisschen komisch aber vielleicht liegt das auch meiner Eingabe. 
Werde mal noch etwas experimentieren.
Jedenfalls vielen Dank, es geht schon was.

mfG
frewer

Sorry, hatte dazwischgeschrieben!!!!
Nun interpretiere ich das Ergebnis, dass die Datei Test keinen Inhalt 
hat (0) obwohl dort drin steht "Das Wetter ist schön" (mit dem PC über 
einen Cardreader beschrieben). Hat das mit der Methode des Schreibens 
mit dem PC zu tun???

[Roland R. (roland)]

Hi Werner,

1. Schau Dir mal die Syntax für den write-Aufruf an, Du verwendest den 
Befehl falsch.
2. Das mit den Dioden und dem Widerstand hab ich nicht verstanden.
3. "Test" ist doch ein Ordner, was erwartest Du denn da als Größe??
4. Bei Interpretation der cat-Ausgabe braucht man die Dateigröße, da der 
Einfachkeit halber die letzte Zeile nicht entsprechend der Dateigröße 
abgeschnitten wird. In Deinem Beispiel sind also nur noch die Bytes 0x20 
bis 0x22 gültig.

Gruß,
Roland

[frewer (Gast)]

Hallo Roland,

vielen Dank für Deinen Kommentar.
Mittlerweile bin ich einen Schritt weiter und verstehe auch nach 
detaillierter Durchsicht des "main" Deine diversen Befehle.
Mit dem Widerstand zwischen der letzten Diode und Masse erzeuge ich eine 
kontinuierliche Vorspannung am SD-Adapter auch, wenn die Karte entnommen 
wird.
Nicht ganz kapiere ich bis jetzt die Anzeige für die Datei Test\ mit der 
Angabe der Größe 0. Denn die Datei enthält, genau wie meine Datei Myfile 
einen kurzen Text und ist kein Directory. Warum kann ich also Myfile 
lesen aber Test nicht?

Bin jetzt dabei, mal ein paar eigene Befehle zu schreiben. Mal gespannt 
wie das klappt.

mfG
Werner

[Roland R. (roland)]

Hi Werner,

"Test" wird als Verzeichnis interpretiert, das zeigt der Schrägstrich 
nach dem Namen an. Insofern ist auch klar, warum Du "Test" nicht 
ausgeben kannst.

Kannst Du mit
> cd Test
in das Verzeichnis wechseln? Wenn ja, was zeigt
> ls
an?

Gruß,
Roland

[Werner F. (frewer)]

Hallo Roland,
ja, das hat funktioniert. Ich komme in das Verzeichnis Test mit cd .. 
und finde dann eine Datei mit meinem Text. Um nicht dauernd die Wandlung 
HEX in Zeichen händisch machen zu müssen, habe ich Deine Routine cat 
geändert und bekomme nun den Text der Datei als Zeichen ausgedruckt. 
Allerdings nur gewandelt, d.h. auch der alte Müll in der Datei wird 
ausgedruckt. Meine Frage ist, warum wird das Endezeichen der Datei nach 
der Eingabe nicht gesetzt und warum der Ausdruck nicht an diesem 
Endezeichen beendet? Sowohl in cat ... als auch in "meinem" read, das ja 
identisch Deinem cat .. ist.

// Eingabe read: - Datei-Inhalt als Text ausgeben
            else if(strncmp_P(command, PSTR("read "), 5) == 0)
            {
                command += 5;
                if(command[0] == '\0')
                    continue;

                /* search file in current directory and open it */
                struct fat_file_struct* fd = open_file_in_dir(fs, dd, 
command);
                if(!fd)
                {
                    uart_puts_p(PSTR("error opening "));
                    uart_puts(command);
                    uart_putc('\n');
                    continue;
                }

                /* print file contents !!meine kleine Änderung!!*/
                uint8_t buffer[8];
                while(fat_read_file(fd, buffer, sizeof(buffer)) > 0)
                {
                 for (i=0;i<8;i++) {uart_putc(buffer[i]);}
                }
                uart_putc('\n');
                fat_close_file(fd);
            }
///
Kann das sein, dass das '\0' im write command nicht bei jeder Eingabe 
als Endekennung geschrieben wird?

mfG
Werner

[Roland R. (roland)]

Hallo Werner,

Es gibt kein "Endezeichen" in einer Datei. Jedes Byte in einer Datei ist 
gültig, somit kann es kein Byte mit einer Sonderbedeutung geben. Auch 
'\0' hat keine besondere Bedeutung. Den FAT-Funktionen werden deshalb 
die Daten immer als Tupel (Puffer, Länge) übergeben, und nicht nur als 
(Puffer).

Mein write-Befehl schreibt die eingegebenen Zeilen nacheinander in die 
Datei, ohne Trennung dazwischen (auch kein Leerzeichen, es sei denn man 
gibt es explizit ein). Wenn Du da Null-Bytes oder was auch immer 
dazwischen haben willst, musst Du die write-Implementierung eben 
entsprechend abändern.

Dass "alter Müll" in der Datei steht, liegt daran, dass die Datei nicht 
gekürzt wird. Wenn Du z.B.
> write test.txt 25
sagst, wird der Dateiinhalt ab Byte-Offset 25 mit den von Dir 
eingegebenen Zeichen überschrieben, bzw. an die Datei angehängt. Wenn Du 
aber weniger Zeichen eingibst als die Datei bereits lang ist, bleiben 
die alten (nicht überschriebenen) Daten eben bestehen. Auch das kannst 
Du natürlich ändern (fat_resize_file()).

Denk bitte auch daran, dass der Puffer für die Kommandozeile nur 24 
Zeichen lang ist und beim Erreichen der Maximallänge implizit ein Enter 
angenommen wird.

Viele Grüße,
Roland

[Werner F. (frewer)]

merci Roland,
ich glaube, dass ich die Syntax jetzt verstanden habe.
Mit meinem \0 dachte ich an das Ende eines STRING und diesen Wert wollte 
ich zum Begrenzen der Ausgabe benutzen. Wenn ich das write Kommando 
richtig verstehe, dann wird auch \0 abgefragt und in die Datei 
geschrieben. D.h. ich kann in meinem Read Kommando die "Endeabfrage" 
implementieren ohne das write Kommando anzutasten.

Jetzt verstehe ich auch, warum immer wieder bei der Eingabe das < 
Zeichen kam. Hatte mich schon gewundert. Aber dem Grunde nach verändert 
das ja nicht den Inhalt in der datei.

Summa summarum läuft es mit meinem kleinen ATmega328p und der Karte 
richtig prima. Wenn ich noch was vertrauter bin, dann kann ich damit 
"durchstarten". Z.Zt. bin ich dabei, die Routinen zu verstehen - was 
schon ganz schön schwierig ist (bin halt älteres Semester) - aber ich 
komme langsam voran.

Nochmals Dank und bis zur nächsten Frage
mfG
Werner

[Werner F. (frewer)]

Hi Roland,

habe noch ein Versuchsergebnis mit dem ich noch nicht umgehen kann.
Ich habe folgende Baum auf der SD-Karte:

DCIM/
Test/
Myfile

Ich gehe mit cd Test in ein das Directory Test und beschreibe dort zB 
einen File. Jetzt möchte ich in das Directory DCIM/ mit zB cd DCIM oder 
cd /DCIM. Wäre schön geht aber nicht. Auch komme ich nicht in das Root 
Dir außer natürlich mit "init".

Gibt es da eine Hilfestellung?
Grüße vom Rhein nach ??
Werner

[Roland R. (roland)]

Hallo Werner,

In der Beispiel-Shell der main.c beziehen sich die meisten Operationen 
auf das aktuelle Verzeichnis. FAT stellt für jedes Verzeichnis die 
Spezialnamen "." und ".." bereit. Dabei steht "." für das aktuelle 
Verzeichnis und ".." für das übergeordnete Verzeichnis.

Dein Ziel erreichst Du also so:
> cd Test
> ls
...
> cd ..
> cd DCIM
> ls
...

Denk bitte dran, das ist ein ganz primitiver Prompt, mit relativen 
Pfaden und dergleichen kann der nichts anfangen (wenngleich man das 
natürlich programmieren könnte).

Viele Grüße,
Roland

[Werner F. (frewer)]

Hallo Roland,

bei aller Liebe, die Variante der Eingabe konnte ich Deiner Beschreibung 
nicht entnehmen. Aber man lernt ja nicht aus. Es klappt prima so. Nun, 
das ganze ist ja mehr zum Lernen als zum Anwenden gedacht. Meine Absicht 
ist eh nur einfache Datenspeicherung. Aber Deine Programmsystem hat mich 
gleich fasziniert, weil es für mich sehr professionell aussieht und mich 
beim Durcharbeiten immer wieder überrascht, weil ich die gegenseitigen 
Links immer suche und außer den eindeutigen Zuordnungen FAT_, 
Partition_,sd_raw usw immer lange suche, bis ich den "Link" finde. Aber 
es macht viel Spaß.

Danke für die rasche Hilfe und Grüße von der Hochwasser-Front
Werner

[Roland R. (roland)]

Hallo alle miteinander,

Als kleines Update zwischendurch gibts eine neue sd-reader-Ausgabe. Die 
wichtigsten Änderungen:
- Umbenennung bzw. Verschieben von Dateien und Verzeichnissen.
- Korrekturen bei der Behandlung von Little-Endian-Integern auf 16- und
  32-Bit-Architekturen.
- Zusätzlichen Rückgabewert für fat_create_file(), um bereits
  existierende Dateien zu erkennen.
- Doku zum Auslesen der aktuellen Dateiposition mittels fat_seek_file().

Wie immer findet Ihr das Update im Anhang oder unter
  http://www.roland-riegel.de/sd-reader/

Gruß,
Roland

[Martin (Gast)]

Hallo,

für ein Projekt benötige ich die folgenden Funktionen.
 - get Anzahl der Zeilen in einem file
 - get Zeile, Nummer ... aus dem file zurück

Hat schon jemand solch eine Funktion geschrieben und würde diese mir zur 
verfügung stellen?

Vielen Dank
martin

[Stefan W. (stepw)]

eine kleine Frage, kann man die SD-Karte an beliebigen Ports anschließen 
oder muß es immer Hardware-MOSI/MISO/SCK sein?

[Martin (Gast)]

vom Programm wird nur der Hardware SPI unterstützt...
Software SPI wäre aber auch möglich, muss du dann nur selber 
implementieren.

[Stefan W. (stepw)]

danke für die info - schade, da wüßte ich jetzt nicht wie das gehen 
sollte.

[Martin (Gast)]

So ich hab jetzt mal einen ersten entwurf meiner getLine funktion 
geschrieben. Die funktion läuft.

Hat jemand vielleicht noch eine Idee wie man die Funktion schneller und 
effektiver gestalten kann. Vielleicht könnte man auch einen Zeielen 
Abschnitt sich zurückgeben lassen... also von Zeile x bis Zeile y.

Ich hoffe es haben einige Interesse.

//##########################################################################################
uint8_t file_getLine(uint16_t lineNr,char* zielbuffer)// anzahl Zeilen aktuelles file
{ // Rückgabe der Zeilenlänge
  // maximale Zeilenlänge von 40 Zeichen
  
  if(fd)
  {
    if (lineNr < 1 ) {return 0;}
    
    uint16_t   counterLines  =0;
    int32_t   pos_after_last_enter   = 0;
    uint8_t   arbeitsbuffer[40];  
    uint8_t    count;

    //########## Anfang der n-ten Zeile suchen und position in "pos_after_last_enter" zurückgeben
    //########## es werden alle '\n' gezählt bis die Anfangsposition der gesuchten Zeile gefunden ist
        
    while(counterLines < lineNr-1)
      {
      if(!fat_seek_file(fd, &pos_after_last_enter, FAT_SEEK_SET)) {/* error*/}
      
      count = fat_read_file(fd, arbeitsbuffer, 40);
      for(intptr_t i = 0; i < count; ++i)
        {
        if(arbeitsbuffer[i] == '\n')  
          {
          counterLines++;
          pos_after_last_enter+=i+1;// Zeiger auf Zeichen nach dem letzten Enter
          break;
          }
        }
      }
    
    //########## Daten ab der gefundenen Position auslesen und in Zielbuffer schreiben    
    if(!fat_seek_file(fd, &pos_after_last_enter, FAT_SEEK_SET)) {/* error*/}
    count = fat_read_file(fd, arbeitsbuffer, 40);
    
    for(intptr_t i=0; i<count; ++i)
      {
      zielbuffer[i] = arbeitsbuffer[i];      
      if(arbeitsbuffer[i] == '\n')  
        {
        zielbuffer[i+1] = 0;
        return i; // return Zeilenlänge
        }
      }
  }
  return 0;
}

[nlsgs (Gast)]

Zu erst möchte Ich “danke schon” sagen. Ihr Project hilft mir wirklich 
schnell voran. Aber dann habe ich noch eine frage;

Moderne AVR können sich selbst programmieren. Wäre es möglich einen AVR 
aus eine Datei zu laden? Sagen wir mal das wenn es auf eine SD-Karte 
eine Datei namens „imageXXX.avr“ gibt diese geladen wird falls der 
Nummer XXX größer ist als die heutige Versionsnummer. Oder müsste man 
eine .hex Datei laden können?

Verzeihung für mein Deutsch, aber ich nehme an man versteht wo die 
Gedanken gehen.

[Werner B. (werner-b)]

@nlsgs,

siehe Beitrag "MMC/SD Bootloader füt ATMega16"

[Steffen (Gast)]

Hallo Roland,

erstmal ein großes danke schön für die Bibliohek. Nach einigen 
Startschwierigkeiten bin ich nun doch in der Lage, damit Dateien zu 
lesen, anzulegen und zu schreiben. Allerdings möchte ich mit der 
Bibliothek MP3's auslesen und zu einem Decoder schicken. Hier gibt es 
aber Probleme. Habe zum Testen nun eine .txt angelegt mit 64 Zeichen 
Inhalt.
Die ersten 32 werden auch korrekt in den Buffer gelesen, das wars dann 
aber auch. Das Programm durchläuft einmal die Schleife und springt dann 
raus, obwohl noch 32 neue Bytes darauf warten, gelesen zu werden.

void play_sound(const char *file_name, struct fat_fs_struct* fs, struct fat_dir_struct* dd)
{
  int32_t bytesRead = 0;
  int32_t totalBytesRead = 0;
  int countVar;
        uint8_t songbuffer[32];
        struct fat_file_struct* fd;

  fd = open_file_in_dir(fs, dd, file_name);   
        bytesRead = fat_read_file(fd, songbuffer, 32);
  
        while(bytesRead > 0)  
  {
    totalBytesRead+=bytesRead;
    fat_close_file(fd);
    unselect_card();

// hier steht ein Routine zum senden des Buffer-Inhaltes an den Decoder
...
//
                select_card();
                fd = open_file_in_dir(fs, dd, file_name);
          fat_seek_file(fd,&totalBytesRead,FAT_SEEK_SET); 
    bytesRead = fat_read_file(fd, songbuffer, 32);
   }
    fat_close_file(fd);
}

Hoffe, mir kann geholfen werden.

Gruß
Steffen

[Roland R. (roland)]

Hallo Steffen,

Mal davon abgesehen, dass das so fürchterlich ineffizient ist, sollte es 
schon funktionieren.

Könntest Du bitte zuerst mal sicherstellen, dass alle Funktionsaufrufe 
Erfolg zurückmelden? Was passiert, wenn die Datei 32 Bytes länger ist? 
Wird dann die Schleife einmal mehr durchlaufen? Was macht eigentlich das 
select_card()/unselect_card() in der Schleife?

Gruß,
Roland

[Steffen (Gast)]

Hallo Roland!

Danke für die Antwort. Hatte ich vergessen mit reinzuschreiben, der 
Decoder hängt auch am SPI, daher muss ich die MMC vor jedem neuen 
Leseaufruf neu anwählen bzw. bevor ich die Daten zum Decoder schicke 
abwählen. Und ja, wenn mehr als 32 Bytes zu lesen sind, soll die 
Schleife nochmal durchlaufen werden.
Wie würde denn eine effizientere Variante aussehen? Bin für Hinweise 
etc. offen. :)

Gruß
Steffen

[Steffen (Gast)]

Mal ein kleines Update: Ohne SPI-Übertragung an den Decoder wird die 
Datei jetzt ordentlich ausgelesen. Wenn ich allerdings die Übertragung 
wieder mit reinnehme, wird mir im zweiten Schleifendurchlauf beim Aufruf 
von fat_read_file eine -1 zurückgegeben. Laut Debugger wird der Fehler 
direkt bei der Parameterüberprüfung in fat_read_file ausgegeben.
Kann mir das nicht erklären, ich verändere weder fd, noch den songbuffer 
noch die Bufferlänge.

Gruß
Steffen

[Steffen (Gast)]

Scheinbar geht die Information für fd verloren, obwohl der es über 
open_file_in_dir nach dem Übertragen an den Decoder wieder geladen wird. 
Jedenfalls gibt er bei der Parameterüberprüfung von fd in fat_read_file 
-1 zurück.

[Steffen (Gast)]

Hallo Roland,

hab das Problem gelöst gekriegt. Manchmal hilft es, wenn man sich 
nochmal alle Pin-Deklaration anguckt.
Du meintest, dass meine Variante sehr ineffizient ist. Das macht sich 
auch akustisch bemerkbar. Wie würde Deiner Meinung nach eine 
effizientere Funktion aussehen?

Gruß
Steffen

[holger (Gast)]

>Du meintest, dass meine Variante sehr ineffizient ist. Das macht sich
>auch akustisch bemerkbar. Wie würde Deiner Meinung nach eine
>effizientere Funktion aussehen?

So vieleicht? Datei offen halten bis der Song fertig ist.

void play_sound(const char *file_name, struct fat_fs_struct* fs, struct fat_dir_struct* dd)
{
  int32_t bytesRead = 0;
  int countVar;
        uint8_t songbuffer[32];
        struct fat_file_struct* fd;

  fd = open_file_in_dir(fs, dd, file_name);   
  if(fd)
   {
    do
    {
     bytesRead = fat_read_file(fd, songbuffer, 32);

// hier steht ein Routine zum senden des Buffer-Inhaltes an den Decoder
...
//
    } while(bytesRead > 0)  
    fat_close_file(fd);
  }
}

[holger (Gast)]

Nachtrag: kleine Verbesserung;)

void play_sound(const char *file_name, struct fat_fs_struct* fs, struct fat_dir_struct* dd)
{
  int32_t bytesRead = 0;
  int countVar;
        uint8_t songbuffer[32];
        struct fat_file_struct* fd;

  fd = open_file_in_dir(fs, dd, file_name);   
  if(fd)
   {
    do
    {
     bytesRead = fat_read_file(fd, songbuffer, 32);
     if(bytesRead > 0)
     {
// hier steht ein Routine zum senden des Buffer-Inhaltes an den Decoder
...
//
     }
    } while(bytesRead > 0)  
    fat_close_file(fd);
  }
}

[Roland R. (roland)]

Hallo Steffen,

So wie Holger geschrieben hat, sollte es schon wesentlich besser 
funktionieren. Es ist einfach nicht notwendig, die Datei ständig zu 
schließen, wieder zu öffnen und die Leseposition neu zu setzen. Das sind 
alles Operationen, die relativ aufwendig sind. Je nachdem, wieviel RAM 
Du noch frei hast, sollte der Puffer zum Lesen der Daten auch noch 
wesentlich vergrößert werden. Das ist im Vergleich zu den 
Dateioperationen aber nicht mehr ganz so wichtig.

Gruß,
Roland

[Steffen (Gast)]

Hallo zusammen!

An der Stelle wollte ich mich einfach nochmal für die schnelle Hilfe 
bedanken, die mir zuteil wurde. :)

Gruß
Steffen

[Daniel (Gast)]

Hallo Roland,

ich möchte Daten (Texte) mit einem ATmega2560 auf eine SD-Card 
schreiben, die dann später am PC ausgelesen werden sollen.
Deine Daten (Version 20110243) habe ich übernommen. Da an meiner MCU ein 
LCD und einige Taster sind, benötige ich "alles" mit "uart" nicht. 
Meldungen gehen ans LCD.
Nun das Problem: "sd_raw_init" und "Partition_open" wird ausgeführt, 
aber dann kommt die Meldung "opening filesystem failed".
Ich vermute, dass die Hardware OK ist, da "...init" und "...open" 
durchlaufen werden. Wieso es aber bei "fs_open" nicht geht weis ich 
(noch) nicht.
Über Infos würde ich mich freuen.

Vielen Dank!
MfG Daniel

[Frank H. (gowi)]

Alex K. schrieb:
> Martin Wende schrieb:
>> Im 8.3 Format muss der Dateiname komplett aus Großbuchstaben bestehen.
>> Sonst zickt win wenns auf der SD Karte liegt.
> Juhu, das wars.... !!!
> DANKE!!!!!!!!
>
> Meine Einstellungen sind nun:
>
> #define FAT_LFN_SUPPORT 0
> #define FAT_DELAY_DIRENTRY_UPDATE 0
> #define SD_RAW_SDHC 0
> #define SD_RAW_WRITE_BUFFERING 1
>
> und ein sd_raw_sync(); nach jedem schreiben.
>
> Danke euch, ihr habt meinen Tag gerettet...

Also ich habe das gleiche Problem. Es werden zwar Dateien auf der 
SD-Karte erzeugt (microSD mit 2 GB, FAT16, kein SDHC), aber die sind 
leer. Ich habe die gleichen Optionen eingestellt und nur Großbuchstaben 
benutzt. Leider keine Änderungen. Wenn ich chkdsk /F durchlaufen lassen, 
bekomme ich die Meldung, dass "verlorene Ketten" gefunden wurden. Wenn 
chkdsk diese Dateien wiederherstellt, kann ich mir den Inhalt der 
Dateien im Ordner "FOUND.000" anzeigen lassen. Mein Code sieht so aus:

int main()
{
        /* setup sd card slot */
        if(!sd_raw_init())
        {
#if DEBUG
            uart_puts_p(PSTR("MMC/SD initialization failed\n"));
#endif
            continue;
        }

        /* open first partition */
        struct partition_struct* partition = partition_open(sd_raw_read,                                              sd_raw_read_interval,
                                                            0,
                                                            0,
                                                            0
                                                           );

        if(!partition)
        {
            /* If the partition did not open, assume the storage device
             * is a "superfloppy", i.e. has no MBR.
             */
            partition = partition_open(sd_raw_read,
                                       sd_raw_read_interval,
                                       0,
                                       0,
                                       -1
                                      );
            if(!partition)
            {
#if DEBUG
                uart_puts_p(PSTR("opening partition failed\n"));
#endif
                continue;
            }
        }

        /* open file system */
        struct fat_fs_struct* fs = fat_open(partition);
        if(!fs)
        {
#if DEBUG
            uart_puts_p(PSTR("opening filesystem failed\n"));
#endif
            continue;
        }

        /* open root directory */
        struct fat_dir_entry_struct directory;
        fat_get_dir_entry_of_path(fs, "/", &directory);

        struct fat_dir_struct* dd = fat_open_dir(fs, &directory);
        if(!dd)
        {
#if DEBUG
            uart_puts_p(PSTR("opening root directory failed\n"));
#endif
            continue;
        }
        
  struct fat_dir_entry_struct fdes;
  uint8_t ret_value;
  struct fat_file_struct* ffs;
  ret_value = fat_create_file(dd, "ABDEEFGH.TXT", &fdes);
  if (ret_value == 1) {
    ffs = fat_open_file(fs, &fdes);
    if (!ffs) {
      uart_puts_p("a");
    }
    fat_write_file(ffs, "Hello World", 12);
    fat_close_file(ffs);
    /* close directory */
    fat_close_dir(dd);
    /* close file system */
    fat_close(fs);
    /* close partition */
    partition_close(partition);
    while (1) {}
}

[Torsten S. (tse)]

Probier mal sd_raw_sync() nach write/close damit die buffer vom ram auch 
auf die Karte geschrieben werden bevor Du diese entfernst oder den Saft 
abdrehst.

[Martin (Gast)]

Hallo,
ich versuche mich gerade am Erzeugen einer Datei und komme dabei nicht 
weiter, mein Code sieht so aus:

int connect_sd(void)
{
  struct partition_struct* partition;
  struct fat_dir_struct* dd;
  struct fat_fs_struct* fs;
  
  if(!sd_initiated)
  {
    if(!sd_raw_init())
    {
      uart_puts("MMC/SD initialization failed\n");
    }
    else
    {
      sd_initiated=1;
      uart_puts("MMC/SD initialization successful\n");
    }
  }
  if(sd_initiated)
  {
    struct partition_struct* partition = partition_open(  sd_raw_read,
    sd_raw_read_interval,
    sd_raw_write,
    sd_raw_write_interval,
    0
    );
    if(!partition)
    {
      partition = partition_open(sd_raw_read,
      sd_raw_read_interval,
      sd_raw_write,
      sd_raw_write_interval,
      -1
      );
      if(!partition)
      {
        uart_puts("opening partition failed\n");
      }
    }
    if(partition!=0)
    {
      sd_partitioned = 1;
      uart_puts("partition found\n");
      fs = fat_open(partition);
      if(!fs)
      {
        uart_puts("opening filesystem failed\n");
      }
      struct fat_dir_entry_struct directory;
      fat_get_dir_entry_of_path(fs, "/", &directory);
      dd = fat_open_dir(fs, &directory);
      if(!dd)
      {
        uart_puts("opening root directory failed\n");
      }
      else
      {
        uart_puts("opening root directory successful\n");
        sd_root=1;
      }
    }
    if(sd_root!=0)
    {
      struct fat_dir_entry_struct* fd;
      struct fat_file_struct* ffs;
      if(fat_create_file(dd,"BLABLA.TXT",&fd)!=0)
      {
        ffs = fat_open_file(fs,&fd);
        fat_write_file(ffs,"teststring",11);
      }
      else
      {
        uart_puts("failed to create file\n");
      }
      fat_close(fs);
      partition_close(partition);
    }
  }
  return sd_root;
}

Bis zum öffnen des root Verzeichnisses klappt es, dann bekomme ich die 
Fehlermeldung "failed to create file". Wäre super wenn hier jemand einen 
Tipp hätte!
Viele Grüße,
Martin

[Martin (Gast)]

Am Schluss muss es natürlich

if(sd_root!=0)
    {
      struct fat_dir_entry_struct* fd;
      struct fat_file_struct* ffs;
      ffs = fat_create_file(dd,"BLABLA.TXT",&fd);
      if(ffs!=0)
      {
        ffs = fat_open_file(fs,&fd);
        fat_write_file(ffs,"teststring",11);
      }
      else
      {
        uart_puts("failed to create file\n");
      }
      fat_close(fs);
      partition_close(partition);
    }

 heissen!

[Martin (Gast)]

Bekomme jetzt war "writing successfull", die Datei "TEST.TXT" bleibt 
aber leer. Woran könnte das liegen?

if(sd_root!=0)
    {
      struct fat_file_struct* fd = open_file_in_dir(fs, dd, "TEST.TXT");
      if(!fd)
      {
        uart_puts("could not open test.txt\n");
      }
      else
      {
        fat_write_file(fd,"testzeile",15);
        sd_raw_sync();
        uart_puts("writing sucessfull\n");
      }
      
      fat_close(fs);
      partition_close(partition);
    }

[Martin (Gast)]

Habe es nun gelöst, der Fehler lag im Schreibschutz, hatte das im 
config-file nicht richtig angepasst. Ansonsten danke für die super Bib!

[Dirk B. (garag)]

Martin schrieb:
>

if(sd_root!=0)
>     {
>       struct fat_dir_entry_struct* fd;
>       struct fat_file_struct* ffs;
>       ffs = fat_create_file(dd,"BLABLA.TXT",&fd);
>       if(ffs!=0)
>       {
>         ffs = fat_open_file(fs,&fd);
>         fat_write_file(ffs,"teststring",11);
>       }
>       else
>       {
>         uart_puts("failed to create file\n");
>       }
>       fat_close(fs);
>       partition_close(partition);
>     }

Die Funktion fat_create_file() erwartet doch einen Zeiger auf die 
fat_dir_entry_struct Struktur und keinen Zeiger auf einen Zeiger.

Müsste es nicht wie folgt anfangen (vor fd kein Stern)?

if(sd_root!=0)
{
    struct fat_dir_entry_struct fd;
    struct fat_file_struct* ffs;
    ffs = fat_create_file(dd,"BLABLA.TXT",&fd);

[Sven W. (sven_w18)]

Hi !

Ich habe ein Problem mit dem Timing beim Öffnen einer Datei.

Und zwar liest mein Programm WAV-Dateien von der SD und gibt diese über 
den PWM des Atmega168 wieder. Die Daten werden gepuffert.

Die Dateien werden per Dateiname ausgewählt.

Nur habe ich, wenn ich die Datei wechseln will, eine unschöne Pause 
zwischen den Tracks.


sound_file=open_file_in_dir(fs, dd, dateiname);

Dauert verhältnismäßig lange.


Ziel des Programms soll sein, eine Schaltung mit Lagesensor und Tastern, 
die jeh nach Lage oder Tastendruck einen Sound wiedergibt.
z.B. Modellbau-Schiff: Motor an, Motor läuft schnell, Motor läuft 
langsam, Hupe, Motor aus usw.


Hat jemand eine Idee, wie ich ohne nennenswerte Zeitverzögerung die 
Dateien hintereinander abspielen kann?

uint8_t find_file_in_dir(struct fat16_fs_struct* fs, struct fat16_dir_struct* dd, const char* name, struct fat16_dir_entry_struct* dir_entry)
{
    while(fat16_read_dir(dd, dir_entry))
    {
        if(strcasecmp(dir_entry->long_name, name) == 0)
        {
            fat16_reset_dir(dd);
            return 1;
        }
    }

    return 0;
}

//***************************************************************

struct fat16_file_struct* open_file_in_dir(struct fat16_fs_struct* fs, struct fat16_dir_struct* dd, const char* name)
{
    struct fat16_dir_entry_struct file_entry;
    if(!find_file_in_dir(fs, dd, name, &file_entry))
        return 0;

    return fat16_open_file(fs, &file_entry);
}

[ruepel (Gast)]

Servus,

an dieser Stelle möchte ich mich bei Roland Riegel bedanken.
Die Sourcen arbeiten einwandfrei.

Egal, ob MMC, SD, 32GB oder 2GB.

Gut gemacht. Ich hatte mir eine zeitlang überlegt, auf FatFs von ELM 
umzusteigen, aber das braucht es nicht.

Gruß Klaus