MMC SD library FAT16 FAT32 read write

@ Alex (Gast)
Hallo,
und wie läuft es ? Neuigkeiten von der Front?

Grüße Daniel

Huch garnicht eingeloggt gewesen...

Hallo zusammen.

@ Alex (Gast)
Schön das es jetzt funktioniert :)
Das mit dem Freien Platz ermitteln wollt ich schon immer mal einbauen, 
komme aber nicht dazu. Eigentlich müsste man ja nur die freien Cluster 
in der Fat durchgehen und zählen. Das mit Sektoren pro Cluster 
multiplizieren und fertig...

@  Helmut (Gast)
Ist es denn so zeitkritisch?
Weil eigentlich muss man ja alles, was beim schließen auch gemacht wird, 
bei einem kompletten update der Datei Daten auch machen. Es schadet ja 
übrigens auch nicht eine Datei länger geöffnet zu haben.

Grüße Daniel

Soo, hier mal auf die schnelle eine Funktion, die die Anzahl der freien 
Bytes bestimmt.
Es sollte aber mindestens ein Cluster frei bleiben am Ende, also nicht 
voll schreiben bis zum Anschlag ! Besser wäre sogar einfach 1 MB frei zu 
lassen...

1

unsigned long long int fat_getCntFreeBytes(void){

2

3

  unsigned long long int cnt=0;

4

  unsigned long int count=0;

5

  unsigned long int secOfFirstPartition;

6

  unsigned long int fatSz;

7

8

  if(TRUE==mmc_read_sector(0,fat.sector)){

9

10

      // bestimmen des 1. sektors der partition

11

      void *vsector=&fat.sector[454];

12

      secOfFirstPartition=*(unsigned long int*)vsector;

13

      if(secOfFirstPartition==0x6964654d){

14

        secOfFirstPartition=0;

15

      }

16

      else{

17

        mmc_read_sector(secOfFirstPartition,fat.sector);

18

      }

19

20

      // anzahl sektoren bestimmen die von einer fat belegt werden

21

      if(fat.fatType==32){

22

        vsector=&fat.sector[36];

23

        fatSz=*(unsigned long int *)vsector-1;

24

        fatSz*=128;

25

      }

26

      else{

27

        vsector=&fat.sector[22];

28

        fatSz=*(unsigned short*)vsector-1;

29

        fatSz*=256;

30

      }

31

32

      fatSz-=1;

33

      // zählen der freien cluster in der fat

34

      do{

35

        if(0==fat_getNextCluster(count)) cnt++;

36

        count++;

37

      }while(count<fatSz);

38

39

      // multiplizieren um auf bytes zu kommen

40

      cnt=cnt*(fat.secPerClust*512);

41

      return cnt;

42

  }

43

}

Grüße Daniel

Hallo...

@ Alex (Gast)
Wow 15 Sekunden das ist lang. Hatte das garnicht auf realer Hardware 
getestet muss ich gestehen. Aber 15 Sekunden ist zu viel! Da muss ich 
mal überlegen wie das optimaler geht.

@ holger (Gast)
Ja stimmt schon, long long int auf nem AVR 8 Bit :) das muss man nicht 
unbedingt haben. Mal sehn was ich da mache...
Wegen der Code Größe ist mir das eigentlich egal, wer so was braucht 
muss halt platz haben, aber die Geschwindigkeit sollte stimmen.

Grüße Daniel

Hallo Daniel,
was müsste man ändern, damit Dateien mit korrektem Datum/Uhrzeit 
angelegt werden?

Ansonsten gute Arbeit! Deine lib scheint die einzige zu sein, die 
wirklich schnelles schreiben auf SD-Karten ermöglicht.

Mfg,
Kurt

Hallo Kurt,
man müsste die Funktion "fat_makeRowDataEntry" in der fat.c dazu 
bewegen, da wo jetzt dummy werte geschrieben werden, richtige werte zu 
schreiben. Also das Datum und die Zeit. In den beiden Zeilen, die mit

1

// unnoetige felder beschreiben

kommentiert sind.
Die dummy Werte sind 0x01010101, also 4 Byte als Hex.
Wo jetzt genau Datum und Zeit steht, müsste ich selber mal genau 
nachschauen. In der Lib werden 12 Byte mit den dummy werten beschrieben, 
da irgendwo muss das hin :)

Grüße Daniel

Hallo,
hier die Lösung:
Zuerst Datum und Uhrzeit besorgen:

1

uint32_t get_datetime()

2

{

3

  uint8_t year,month,day,hour,minute,second;

4

5

  //Die Werte von der RTC holen

6

  year = 2009 - 1980;

7

  month = 12;

8

  day = 2;

9

  hour = 11;

10

  minute = 45;

11

  second = 26 / 2;

12

13

  return (uint32_t) ((year * 33554432) | (month * 2097152) | (day * 65536) | (hour * 2048) | (minute *32) | (second * 1) );

14

}

Dann folgende Funktionen mit zusätzlichem Parameter unsigned long 
datetime ausrüsten: ffopen, ffclose, ffmkdir, flushFileData, 
fat_makeFileEntry, fat_makeRowDataEntry.

Nun fat_makeRowDataEntry abändern:

1

void fat_makeRowDataEntry(unsigned short row, unsigned char name [],unsigned char attrib,unsigned long int cluster,unsigned long int length, unsigned long datetime){

2

3

  fat.bufferDirty=1;                // puffer beschrieben, also neue daten darin(vor lesen muss geschrieben werden)

4

5

  row=row<<5;                    // multipliziert mit 32 um immer auf zeilen anfang zu kommen (zeile 0=0,zeile 1=32,zeile 2=62 ... zeile 15=480)  

6

7

  unsigned char i;                // byte zähler in reihe von sektor (32byte eintrag)

8

  unsigned char  *bytesOfSec=&fat.sector[row];  // zeiger auf sector bytes

9

  void *vsector;

10

11

  for(i=0;i<11;i++) *bytesOfSec++=name[i];        // namen schreiben

12

  *bytesOfSec++=attrib;                  // attrib schreiben

13

14

  *bytesOfSec++=0x01;  //reserviert

15

  *bytesOfSec++=0x01;  //erstellzeitpunkt in 10ms, von 0 bis 199

16

17

  //unsigned long datetime: (date_high,date_low,time_high,time_low)

18

  *bytesOfSec++=datetime;    //erstellzeitpunkt lowbyte

19

  *bytesOfSec++=datetime>>8;  //erstellzeitpunkt highbyte

20

21

  *bytesOfSec++=datetime>>16;  //erstelldatum lowbyte

22

  *bytesOfSec++=datetime>>24;  //erstelldatum highbyte

23

24

  *bytesOfSec++=datetime>>16;  //datum des letzten zugriffs lowbyte

25

  *bytesOfSec++=datetime>>24;  //datum des letzten zugriffs highbyte

26

27

  vsector=&fat.sector[row+20];

28

  *(unsigned short*)vsector=(cluster&0xffff0000)>>16;// low word  von cluster

29

30

  bytesOfSec += 2;        // 2 überspringen (für low word von cluster)

31

  *bytesOfSec++=datetime;    //zeit der letzten änderung lowbyte

32

  *bytesOfSec++=datetime>>8;  //zeit der letzten änderung highbyte

33

34

  *bytesOfSec++=datetime>>16;  //datum der letzten änderung lowbyte

35

  *bytesOfSec++=datetime>>24;  //datum der letzten änderung highbyte

36

37

  vsector=&fat.sector[row+26];

38

  *(unsigned short*)vsector=(cluster&0x0000ffff);  // high word von cluster

39

40

  vsector=&fat.sector[row+28];

41

  *(unsigned long int*)vsector=length;        // laenge

42

}

Natürlich sind die Werte für Erstellung, letzer Änderung und letztem 
Zugriff auf die Datei gleich. Ist das nicht gewünscht, muss man halt 
noch 2 weiter parameter übertragen.

Mfg,
Kurt

Hi,

ich würde gerne die SD-Karte mit dem µC formatieren. Kann mir mal jemand 
weiterhelfen, wie dazu die Funktion aussehen müsste?!

Gruß,
Matze

Hallo,
das mit dem Formatieren ist nicht so einfach,
mach das lieber mit einem Pc :)
Man müsste die Register der Karte auslesen, um herauszufinden wieviele 
Sekoren die hat. Dann berechnen wieviele Fat Sektoren man braucht, wo 
dann das Root-Dir hin muss usw.
Dann ist immer noch die Frage ob man das so gemacht hat, dass ein 
Betriebssystem das auch lesen kann...

Grüße Daniel

Hallo,
hier eine neue Version.
Neu ist:

- SDHC Unterstützung
- Eine Funktion die den freien Platz in Bytes ermittelt 
"fat_getFreeBytes()"
- Zeit Stempel Unterstützung beim Anlegen und ändern von 
Dateien/Ordnern,
dazu müssen 2 Funktionen mit leben gefüllt werden. "fat_getDate()" und 
"fat_getTime()" in der fat.c, dort ist auch dokumentiert wie das Format 
der Zeit und des Datums auszusehen haben.
- Kleinere Optimierungen

Viele Grüße

Daniel

Im Anhang: die Lib mit Linux Makefile

Und noch die AvrStudio Variante

Hallo,
hast du in der config.h auch das gemacht?

1

#define MMC_SMALL_FILE_SYSTEM   FALSE

Grüße Daniel

Ein normaler Aufruf würde z.B. so aussehen:

1

unsigned char file_name[12]="TEST    TXT";

2

3

ffrm(file_name); // löscht datei mit namen test.txt

Natürlich müsste vorher die Karte und die Fat initialisiert sein...

Hallo,
also ich würde dir empfehlen, einen Stepup-Wandler für die 
Versorgungsspannung zu benutzen. Der Akku wird mit der Zeit mit der 
Spannung runter gehen. Mit nem Stepup könnte man bei um die 1V 
Akkuspannung noch arbeiten. Also das ganze mit nem Stepup auf 3,3V und 
gut is.
Generell kann man mit nem SD-Kommando die Karte fragen was sie für ne 
Spannung mitmacht. 3,3 Volt machen alle, aber es geht eventuell auch 
weniger.

Grüße Daniel

Hallo,
ich hab keine Ahnung von Lipo Akkus :)

Bezugnehmend auf die Simplifyied SD-Spezifkation 2.0, die ich jetzt 
nochmal rausgekramt hab.

Also man übergibt der Karte mit CMD8 die Spannung in der man sie 
betreiben möchte, in dem Fall der Lib wären das 2,7-3,6 Volt. Antwortet 
die Karte korrekt, kann man diese Spannung anlegen. Nur wenn die Karte 
korrekt antwortet initialisiert die Lib die Karte.

Soviel dazu. Ob jetzt 0,1 Volt mehr tödlich für die Karte sind bezweifle 
ich mal stark ;)

Vielleicht hält sich aber auch dein Kartenhersteller nicht genau an die 
Spezifikation...

Hab aber auch schon gehört, dass Leute MMC/SD Karten einfach mit 5V 
betrieben haben, ohne das die kaputt gegangen wären. In der Regel sind 
das ja alles werte, unter denen das dann garantiert läuft...

Grüße Daniel

Hallo,
ja geht ganz einfach.

1

unsigned char file_flag=fat_loadFileDataFromDir(name);

"file_flag" ist jetzt TRUE wenn die Datei schon existiert oder FALSE 
wenn eben nicht. Nach dem Aufruf von "fat_loadFileDataFromDir(name)" 
sind sogar alle möglichen Daten über die Datei schon bekannt, wenn die 
Datei existiert...

Siehe auch "ffopen()" in der file.c


Grüße Daniel

Ich denke du meinst wieviele Sektoren von der Fat belegt werden?
Das ist schon schwieriger.

1

unsigned long int fatSz;

2

3

4

  mmc_read_sector(0,fat.sector);

5

6

  void *vsector=&fat.sector[454];

7

  fatSz=*(unsigned long int*)vsector;

8

  if(fatSz==0x6964654d){

9

    fatSz=0;

10

    }

11

  else{

12

    mmc_read_sector(fatSz,fat.sector);

13

    }

14

15

16

  if(fat.fatType==32){

17

    vsector=&fat.sector[36];

18

    fatSz=(*(unsigned long int *)vsector)-1;

19

    fatSz*=128;

20

    }

21

  else{

22

    vsector=&fat.sector[22];

23

    fatSz=(*(unsigned short*)vsector)-1;

24

    fatSz*=256;

25

  }

Jetzt ist auf der Variable "fatSz" die Anzahl der Sektoren gespeichert, 
die eine bzw. die erste Fat belegt. Der erste Sektor, also ab wo die Fat 
los geht steht auf der Variable "fat.fatSec".

Der hier gepostete Code ist aus der Funktion "fat_getFreeBytes()" aus 
der fat.c...

Grüße Daniel

Hallo,
ja Anzahl der Sektoren * 512.

Ich weiß ja nicht was du vor hast, aber zur Sicherheit solltest du evtl. 
noch einen Sektor dazu zählen wenn du irgendwas nach der Fat machen 
möchtest.
Falls es irgendwas mit der Fat ist wird da schon ein Sektor abgezogen, 
um auf garkeinen Fall über das Ende der Fat hinaus zu kommen.

Upps, ich seh grad da bekommst du die Cluster Anzahl raus die in einer 
Fat stehen. Bei dem Code oben muss einmal das "fatSz*=128;" und das 
"fatSz*=256;" weg !

Also so:

1

unsigned long int fatSz;

2

3

4

  mmc_read_sector(0,fat.sector);

5

6

  void *vsector=&fat.sector[454];

7

  fatSz=*(unsigned long int*)vsector;

8

  if(fatSz==0x6964654d){

9

    fatSz=0;

10

    }

11

  else{

12

    mmc_read_sector(fatSz,fat.sector);

13

    }

14

15

16

  if(fat.fatType==32){

17

    vsector=&fat.sector[36];

18

    fatSz=(*(unsigned long int *)vsector)-1;

19

    }

20

  else{

21

    vsector=&fat.sector[22];

22

    fatSz=(*(unsigned short*)vsector)-1;

23

  }

Grüße Daniel

Hi,

ich habe grad ein verzwickes Problem.
Ich würde gerne in eine Datei, die schon einen Text enthält, Text 
einfügen.
BSP:

aus:
    "Hallo, dieser text steht schon drin."

soll:
    "Hallo, dieser text steht schon 1234567890 drin."

werden.

Man könnte jetzt natürliche den restlichen Text überscheiben und neu 
schreiben. Aber das geht nicht, da der Text hinter dem, was eingefügt 
werden soll mehrere MB groß ist und zum Auslagern fehlt mir zum einen 
der Platz und zum anderen die Zeit...

Gibts dafür eine Lösung?!

Gruß,
Matze

Hallo,
nein dafür gibt es so noch keine Lösung.

Man müsste Prinzipiell wie in dem an gehangenen Bild vorgehen.
Allerdings müsste das noch weiter verallgemeinert werden.
Also auf Cluster anstelle von 512 Byte Sektoren und auf größere 
einzufügende Sektoren/Cluster.
Mal sehen wie sich das optimal einbauen lässt.
Da komme ich aber auch wohl erst in 2 Wochen dazu, wird auch nicht so 
einfach werden, da das ziemlich tief in die Sektor/Cluster Verwaltung 
eingreift.

Grüße Daniel

müsste das nich so sein... ich meine, man will ja evtl mehr als 512 byte 
einfügen. außerdem müsste es zwischen zwei blöcken geschrieben werden.
dein zeichnung würde "ersetzen mit einem anderen sector" bedeuten.
aber sonst meinen wir das selbe! und cool, daß du das machen willst, ich 
steige da nämlich nicht so richtig durch...!

gruß und danke schon mal,
matze :)

Hallo,
hm wo ich so darüber nachdenke, könnte das übler werden als ich dachte. 
Wenn man nicht genau 512 Bytes dazu macht, oder ein ganzes vielfaches 
davon, läuft das wohl doch auf ein wildes kopieren hinaus. Man hat 
irgendwie immer ein paar Bytes über...
Muss ich mal in Ruhe darüber nachdenken.

Grüße Daniel

naja, ob das so weit gehen muss?! Ja, ok, schön wäre es, jedes Bit auf 
der Karte auszunutzen, aber sein wir doch mal ehrlich, wer Datenmengen 
kleiner als 512 Byte schreiben will, schreibt eh nur Text und der ist eh 
meistens kurz. von daher verschenk man nur wenig, selbst wenn man nur 1 
Byte / Sector schreibt.
Auf der anderen Seite: wenn man, so wie ich das Plane, ca. 175.000 
Einfügevorgänge machen wird, ist schon eine ganze Ecke an verschwendetem 
Speicherplatz (ich habs mal überschalgen: etwas mehr als 80MB - wenn ich 
mich nicht verrechnet habe).
Jedoch, bei der verfügbaren Kapazität heutiger Speicherkarten auch nicht 
mehr so viel... :)

Mach dir also nich so einen Kopf drüber. Die Abfrage, welcher Sektor 
wieviele Bytes noch übrig hat, ist, denke ich, unnötig und 
wahrscheinlich eh viel zu langsam - bzw. wenn man es in eine Variable 
schreibt, viel zu Speicheraufwendig (bei knapp 4,2 mio Sektoren auf 
einer 2GB Speicherkarte)

Grüße,
Matze

Hallo,
Auszug aus der fatgen103:

1

[BPB_FATSz32 (byte) 36 (bytes) 4]

2

3

This field is only defined for FAT32 media and does not exist on

4

FAT12 and FAT16 media. This field is the FAT32 32-bit count of

5

sectors occupied by ONE FAT. BPB_FATSz16 must be 0.

,das korrespondiert mit der Prüfung:

1

if(fat.fatType==32){

2

    vsector=&fat.sector[36];

3

    fatSz=(*(unsigned long int *)vsector)-1;

4

    }

jetzt sollte auf der Variablen fatSz laut Spezifikation die Anzahl der 
Sektoren stehen die von einer Fat belegt werden. Wenn du ja genauer 
schreiben würdest wozu du das überhaupt brauchst könnte ich da 
vielleicht auch mehr zu sagen :)
Wenn du jetzt die Anzahl der Bytes haben willst musst du deine 3742 ja 
noch mit 512 Multiplizieren.

Grüße Daniel

Aha,
da musst du anders ran gehen.

Auf FatSz steht jetzt die Anzahl der Sektoren die eine Fat belegt.
In einem Sektor der von der Fat belegt wird, können 128 Cluster 
"Adressiert" werden.
Wenn man jetzt fat.secPerClust*512 rechnet, bekommt man die Anzahl der 
Bytes die einem Cluster zugeordnet werden.
Die Anzahl der Sektoren die zu einem Cluster zusammengefasst werden ist 
immer eine 2er Potenz. Wahrscheinlich bei einer 2Gb Karte 4 oder 8. 
Damit ist die kleinste Zuordnung 2048 oder 4096 Bytes groß.

Damit solltest du jetzt rechnen können :)

Also:

FatSz*128 = Anzahl Cluster auf der Karte

512 * fat.secPerClust = Bytes in einem Cluster

1MByte / Bytes in einem Cluster = nötige Cluster Anzahl, für die 1 MByte

Anzahl Cluster auf der Karte / nötige Cluster Anzahl für die 1 MByte = 
Maximale Anzahl der der 1 MByte Dateien

Stimmst du dem zu? Könnte mich auch verrechnet haben, war jetzt nur so 
auf die schnelle...Man müsste auch mal schauen wie man rundet um da 
überall save zu sein ;)


Grüße Daniel

hi
ich hätte eine frage zu deinem code
ich bekomme über die serielle schnittstelle strings mit der länge von 
2048 zeichen und würde nun gerne wissen wie das geht das ich diese 2048 
zeichen dann schreibe
wenn ich nur 512 zeichen lange  Blöcke bekomme geht es wunderbar
hoffe du kannst mir helfen

danke und mfg alex

Hallo,
du könntest eine Ringpuffer machen. Dessen Größe müsstest du dann noch 
ermitteln, damit da nichts schief geht. So könnten dann schonmal 512 
Bytes geschrieben werden, während noch weitere abgeholt werden (falls du 
einen Interrupt zum abholen der Daten benutzt).
Siehe auch: 
http://de.wikipedia.org/wiki/Warteschlange_(Datenstruktur)#Implementierung_als_Ringpuffer

Das es nicht klappt könnte auch daran liegen, dass du die Schnittstelle 
ohne Flow-Control verwendest, vermute ich mal.
Während die Daten auf die Karte geschrieben werden kommen ja über die 
serielle Schnittstelle neue Daten an die werden aber wohl nicht abgeholt 
während die Lib noch Daten auf die Karte schreibt. Das schreiben der 
Daten auf die Karte benötigt ja eine gewisse Zeit.

Falls dir das nicht weiterhilft, könntest du mal etwas Code Posten, 
damit könnte man sich einen besseren Überblick verschaffen.

Viele Grüße

Daniel

ich hätte mir vorgestellt das ich die 2048 zeichen was ich als einen 
string bekomme auf mehrere kleine strings mit 256 zeichen oder so 
aufteile und dann schreibe. wäre das prinzipell möglich?

Besser immer 512er Blöcke. Es werden nämlich immer 512 Bytes von der Lib 
gepuffert bevor diese geschrieben werden.

hi ich wenn ich einen block mit 512 byts schreiben will. geht das bei 
mir nicht und es kommt auf der seriellen schnittstelle ein neues boot. 
was kann da sein
ich lese die 512 byts über die serielle schnittstelle ein. ich kann 
maximal 256 byts auf einmal schreiben mit deinem code

Hallo zusammen.

@ Alex (Gast), schön das es jetzt klappt :)

@ Alex Glaser (almalex) ,welchen Mikrocontroller benutzt du denn? Wenn 
da erneut "Boot..." steht vermute ich mal einen Reset wegen Ramknappheit 
?!? Poste doch mal ein bisschen Code, damit man sehen kann was du da 
genau machst und wie du das machst. Am besten sogar den ganzen Code.

Grüße Daniel

hab das problem schon gfunden. habe ein bit zuviel gesendet und dadruch 
hat der buffer nicht gepasst. verwende einen 644 aber trotzdem danke
jetzt wende ich mich dem problem das ich einen string von 2048 zeichen 
empfangen will und denn dann schreiben will und dann einen bit zurück 
senden will wann der nächste gesendet werden soll

Hi
ich hab ne frage
ich habe es jetzt geschafft 2048 Zeichen auf die SD karte zu schreiben 
wenn ich die daten über die serielle schnittstelle vom PC schicke. wenn 
ich nun die selben Daten über den 2ten µC erzeuge und zu dem sende der 
es auf die SD karte schreiben soll, funktioniert es nicht. ich poste mal 
den code. die main.c ist die datei die auf den µC gespielt wird, welcher 
die daten zu dem 2ten sendet.
main_simple.c ist deine datei nur wenig verändert

hoffe du kannst mir helfen

Hallo zusammen.


@ Juergen (Gast)

Ja stimmt, ich bin davon ausgegangen, dass man nur am Anfang die freien 
Sektoren bestimmt...
Das wird geändert. Dein Vorschlag funktioniert so.


@ Alex Glaser (almalex)

Um mir das genauer anzuschauen fehlt mir momentan einfach die Zeit. 
Vielleicht so in 1,5-2 Wochen, sorry.

Es gibt auch noch einen kleinen Bug, der nur auftritt wenn man die Lib 
im Read-Only Modus betreibt. Dann hat nämlich ffopen evtl. nicht immer 
einen Rückgabewert... Ist aber eigentlich kein Funktionaler Fehler.

Grüße Daniel

Hallo,
erstmal solltest du besser die neuste Version auf Codevision portierten.

Dann ist das so nicht richtig wie du das machst. So wird nur ein mal 
versucht die mmc/sd karte zu initialisieren...

Das wäre richtig:

1

while (0!=mmc_init()){

2

    LED_Rot^=1;

3

  }

4

LED_Gruen^=1;

jetzt wird rot bei jedem versuch getoggelt und grün nach erfolgreichem 
initialisieren...

Grüße Daniel

Hallo,
ich könnte mir da zwei Möglichkeiten vorstellen, warum das nicht klappt.

1. Versuchs mal so:

1

*(unsigned char*)firstCluster=sector[row+26];

2

firstCluster++;

2. Versuchs mal so:

1

*(unsigned char*)firstCluster++=(unsigned char*)sector[row+26];

Klappt da was von?
Das ist wegen dem CodeVision Compiler, da müsste man mal raus finden 
warum der den void Pointer so an meckert..

Mit nimm die neuste Version zum anpassen meinte ich die Version 0.5.7

Grüße Daniel

Hallo,

1

loop_until_bit_is_set(SPSR,SPIF)

ist ein Makro aus der avr-libc, SPSR ist ein Register und SPIF ist ein 
Bit in dem Register. Das Makro ist sehr schnell, daher benutze ich es. 
Dahinter steckt eigentlich:

1

do { } while ((!((*(volatile uint8_t *)(((uint16_t) &(SPSR)))) & (1 << (SPIF)))))

Ändere mal das Makro so wie hier beschrieben. Dann wirst du 
wahrscheinlich noch nen Haufen anderer Fehler bekommen wegen den 
unterschiedlichen Register Namen, die musst du alle ändern.

Poste doch mal die Fehlermeldungen, vielleicht kann man dann mehr sagen. 
Du kannst ja die Teile die in der CodeVision_SDLIB_v0.4.4 stehen 
vergleichen mit den stellen aus der 0.5.7 die nicht auf Anhieb laufen...
Oder du fragst mal nett bei  "Lolipop Er (lolipoper)" ob er nicht 
nochmal die 0.5.7 auf CodeVision portieren mag. Oder du nimmst den 
avr-gcc anstelle von CodeVision :)

Viele Grüße Daniel

Persönliche Nachricht an "Lolipop Er (lolipoper)" : 
http://www.mikrocontroller.net/user/show/lolipoper

Hallo,
der Matze hat es schon erwähnt, es hängt von verschiedenen Faktoren 
ab...

Ich sage mal so, mit einer neueren SD Karte und im Multiblock-write 
Modus, bei 10 MHZ SPI Takt etwa 40 Sekunden für 10 MBytes.

Hallo,
wenn man jetzt so etwas wie "flush" beim schreiben machen würde, also um 
den Dateieintrag zu updaten und die aktuell gepufferten Daten zu 
schreiben, müsste man genau die Dinge machen, die bei einem ffclose 
auftreten. Das einzige was man evtl. übergehen könnte wäre das suchen 
der Datei im Verzeichnis, beim erneuten öffnen. Das wirkt sich aber nur 
bei vielen Dateien in einem Verzeichnis aus.
Generell mach ich mir aber mal Gedanken ob da nicht was zu machen ist.
Umgehen könnte man dass, wenn man nicht nur 512 Bytes puffern würde, 
sondern 1024 Bytes. Dann wären die Möglichkeiten wesentlich größer, aber 
so muss alles durch den 512 Bytes Puffer.
In FAT32 ist ein Journal nicht vorgesehen, wie es bei allen neueren 
Dateisystemen Standard ist. Da muss man dann über dem Standard selber 
was machen...

Viele Grüße

Daniel

Hallo,
nein mit dem Tool WinHex, das läuft auch unter Linux gut.
Generell muss man aber nur alle Sektoren einer Karte in eine Datei 
packen, das reicht dann schon...

Grüße Daniel

hallo

tolles projekt!
ich habe diese library auf einem mega328 im einsatz. wobei daten die 
ausgewertet wurden auf einem lcd angezeigt werden und auf die sd karte 
geschrieben werden. und noch immer mehr als die hälfte an speicher platz 
;-)


möchte noch zusätzlich gps implementieren, wie könnte man das am 
einfachsten realisieren?
kann ich hierbei die uart so verändern, damit sie nur mit dem gps modul 
kommuniziert oder ist diese systembedingt erforderlich?

und wie kann man den syste der einträger in der txt verändern, zb dass 
durchnummerierungen erfolgen

Hallo,
ja die UART kann man einfach benutzen, es wird nur SPI von der Lib 
benutzt.

>und wie kann man den syste der
>einträger in der txt verändern, zb dass
>durchnummerierungen erfolgen

Wie meinst du das?

Willst du eine große Datei erstellen in der alle NMEA Einträge stehen?
Dann musst du die Lib im überschreiben Modus benutzen, dann kannst du 
einfach die Datei öffnen und was anhängen...


Grüße Daniel

super!

hab gesehn, man kann echt viel mit deinen libs anstellen ;-)
wie wirkt es sich aus, wenn der ffwrites(text) oder andere aktivitäten 
der sd von einem interrupt unterbrochen werden?

habe zb einen interrupt laufen der jede ms ausgelöst wird, brauch diese 
zeit um die flanken eines externen interrupts zu messen.
auf die karte sollte im sek takt geschriben werden. habe bemerkt, dass 
nach einiger zeit anscheinend der schreib prozess wesentlich länger 
braucht. macht sich bemerkbar da das lcd in der selben schleife hängt 
und manchmal 5sek und länger nicht aktualisiert wird. liegt das 
vielleicht an interrupts?
nur wenn ich die interrupts deaktiviere für den sd schreib prozess, kann 
ich einige sekunden keine messwerte empfangen.

Das ist so schwer zu sagen, da ich nicht genau sehen kann wie du die Lib 
in deinem Code benutzt.
Aber wenn du die Anbindung an die Karte mit Hardware SPI machst, sollte 
eine Unterbrechung keine Probleme machen, da SPI per Definition Clock 
hörig ist. Also könnte man zwischen 2 zu Übertragenden Bytes auch Pausen 
einlegen. Ich gehe mal davon aus, dass wenn man ein Byte auf die 
Hardware SPI gibt, dies auch nicht von Interrupts unterbrochen wird, 
weil Hardware...
Schließt und öffnest du die Datei in die du schreibst bei jedem 
Messwert?

Grüße Daniel

da ich derzeit noch am erproben bin, verwende ich deine lib im großen 
und ganzen original nur leichte anpassung für mega328. aufrufe werden 
nach der mainsimple vorlage gemacht, wobei die datei auch jedesmal 
geschlossen wird

mir ist in der nacht noch etwas eingefallen. da ich noch freien speicher 
habe, könnte ich ca 60sek am mega328 speichern und dann gesammelt 
übetragen mit intterupt disable (2-3fehlende werte in einer min ist 
nicht so schlimm)

kann sein, dass das spulen zum dateiende nach einiger zeit länger 
dauert?!

1

2

      sprintf(text,"%u",(int)heartbeat_output);

3

4

// Dateinamen müssen in diesem Format sein !

5

    unsigned char file_name[20]="TEST    TXT";

6

7

    // string zum in die datei schreiben schreiben

8

    //unsigned char str[13]="Hallo Datei!";

9

//    unsigned char str[13]="heartbeat_output";

10

11

12

    // Datei existiert nicht, also anlegen !

13

    if(MMC_FILE_NEW == ffopen(file_name)){

14

15

       // schreibt String

16

       //ffwrites(str);

17

     ffwrites(text);

18

19

       // neue Zeile in der Datei

20

       ffwrite(0x0D);

21

       ffwrite(0x0A);

22

23

       // schließt Datei

24

       ffclose();

25

     }

26

27

28

29

     // Datei existiert, also anhaengen !

30

     else{

31

32

       ffseek(file.length);   // spult bis zum Dateiende vor um anzuhaengen !

33

34

       // schreibt String

35

       //ffwrites(str);

36

     ffwrites(text);

37

38

39

       // neue Zeile in der Datei

40

       ffwrite(0x0D);

41

       ffwrite(0x0A);

42

43

       // schließt Datei

44

       ffclose();

45

     }

46

47

48

     // Datei existiert, also kann man lesen.

49

     if(MMC_FILE_EXISTS == ffopen(file_name)){

50

51

        // setzen einer Variable und dann runterzaehlen geht am schnellsten !

52

        unsigned long int seek=file.length;

53

54

        // lesen eines chars und Ausgabe des chars.

55

        // solange bis komplette Datei gelesen wurde.

56

        do{

57

           uputc(ffread());

58

        }while(--seek);

59

60

        ffclose();

Hallo,

>kann sein, dass das spulen zum dateiende
>nach einiger zeit länger dauert?!

Das kommt auf die Datenmenge an, da man sich durch die schon verketteten 
Cluster suchen muss. Ist die Datei um die mehreren MB oder sogar GB kann 
das dauern.

>..und manchmal 5sek und länger..

5 Sekunden ist ne verdammt lange Zeit. Stimmt da vielleicht irgend etwas 
anderes nicht? In 5 Sekunden würde man wenn es gut läuft 1,3 Millionen 
Bytes auf eine Karte schreiben können.
Blockiert der Interrupt sich selber oder so?

Poste doch mal den ganzen Code, als Datei Anhang. So kann ich da nicht 
viel dazu sagen. In dem von dir gezeigten Code sehe ich keinen Fehler...

Grüße Daniel

Daniel R. schrieb:
> 5 Sekunden ist ne verdammt lange Zeit. Stimmt da vielleicht irgend etwas
> anderes nicht? In 5 Sekunden würde man wenn es gut läuft 1,3 Millionen
> Bytes auf eine Karte schreiben können.
> Blockiert der Interrupt sich selber oder so?
>
> Poste doch mal den ganzen Code, als Datei Anhang. So kann ich da nicht
> viel dazu sagen. In dem von dir gezeigten Code sehe ich keinen Fehler...

hab mich ein bisschen herumgespielt.
habe testweise werte nacheinander auf die karte geschrieben, mit 
systemzeit in ms. dabei ist mir aufgefallen, dass der datenstring sehr 
schnell ca.20ms auf die karte geschrieben wird.
also am schreiben kanns nicht liegen.
testweise, habe ich die datei nicht geschlossen, selbes problem, je 
länger die datei wird desto länger hält sich der mega328 mit der sd 
karte auf.

und dann ist mir eingefallen, dass in deinem beispiel die datei über den 
uart wieder ausgelesen wird. diese funktion ist zwar in meinem code auch 
vorhanden, nur wird sie nicht gebraucht!
und na klar nach 30x25 Zeichen braucht das auslesen über den uart schon 
ne zeit...

also auslesen raus und alles super toll jetzt! danke für den support 
hier und tolle libs für die sd-card hast du geschrieben, die tadelos 
funktioniern!! danke!

der fehler war mein programm...
der fehler war wie immer menschlich ;-)

Schön das es jetzt klappt :)

Oft muss man Geduld haben wenn etwas nicht klappt und man nicht richtig 
Debuggen kann wegen fehlender Geräte wie z.b. Spektrum-Analyzer oder 
Logik-Analyzer... Da ist Kreativität gefragt ;)

Viele Grüße

Daniel

Weißt du, daß es hier auf dem Forum svn gibt, in das man solche Projekte 
einchecken kann?

Beitrag "Hinweis: Artikelsammlung"

Das macht es deutlich einfacher, die aktuelle Version zu finden ;-)

Hm, ja hatte mir das mit dem SVN auch schon mal überlegt.
Werde das mal in Angriff nehmen.

Auf http://www.mikrocontroller.net/articles/AVR_FAT32 unter "4. Der 
Code"
ist aber auch immer die neuste Version verlinkt.

Aber stimmt schon SVN wäre schöner.

Viele Grüße

Daniel

Hallo,
das mit dem MMC_Chip_Select Pin hatte ich einfach so von Ulrich Radig 
übernommen, ohne viel darüber nachzudenken. Warum genau es nicht klappt, 
wenn man den richtigen SPI SS Pin nimmt weiß ich nicht genau. Müsste man 
mal im Datenblatt nachschauen, vielleicht muss man da nur noch was 
einstellen, damit es klappt.
Kannst du nicht einfach einen anderen Pin nehmen?

Grüße Daniel

Das ist mir schön öfter aufgefallen. Manche Leute haben regelrecht Angst 
vor dem SS Pin. Könnte das evtl. mit dem (berechtigterweise) miserablen 
Image des Namens zu tun haben?
 :-\

Hallo,
zeig mal den Code, hast du in der config.h etwas geändert?

Besorg dir für 20 Cent nen HC4050 als Pegelwandler oder lass den Atmega 
mit 3,3 Volt laufen.

Du könntest auch mal probieren ob die Einstellung in der config.h,

1

#define MMC_MAX_SPEED FALSE

etwas bringt.

Viele Grüße

Daniel

So, es gibt jetzt ein SVN-Repository für die Bibliothek.
Dort wird immer die Neuste Version zu haben sein.
Immer als AvrStudio Projekt und mit Linux Makefile.

Das jetzige Update enthält eigentlich nur 2 Fixes.
1. Ein return wert ist dazu gekommen in der Funktion ffopen
2. In der fat_getFreeBytes wird der Sektor anders geladen.

Zusätzlich sind noch ein paar Funktionen static geworden.

Viele Grüße

Daniel

Link zu allen SVN:
http://www.mikrocontroller.net/svn/list

Link zur Bib.:
http://www.mikrocontroller.net/svnbrowser/avr-fat32

Hallo,
klappt es denn jetzt?

Mit Linux hab ich es nie hin bekommen, dass bei einer frisch 
formatierten Karte das Root Directory mit 0x0fffffff abgeschlossen wird. 
Linux hat da, immer 0x08ffffff oder so draus gemacht. Wenn das Dir dann 
nicht mehr leer ist, ist korrekter Weise 0xffffffff draus geworden.

Kannst du dir die Sektoren der Karte anschauen? Wenn ja sieh mal nach 
wie der Root-Dir Cluster in der Fat aussieht. Hilfreiches Tool dafür 
WinHex. Läuft auch unter Linux.

Viele Grüße

Daniel

Hallo,
mkfs.vfat formatiert das komisch... hast du keinen Windows Rechner zum 
Formatieren zur Hand?
Es liegt an dem blöden Eintrag für das Root-Dir.

Grüße Daniel

>ups 0x#FFFFFF8 != 0x8ffffff !?!?
Kommt auf die Endianness an ;)


>fat.c@172
>  while(!((  (i>=0x8ffffff && i<=0xfffffff )
>&&fat.fatType==32)||(i==0xffff&&fat.fatType==16))){// prueft ob weitere
>sektoren zum lesen da sind (fat32||fat16)

Ja sollte so laufen, bläht das den Code auf? Keine Ahnung wie viel mehr 
Aufwand ein größer gleich im Gegensatz zu gleich ist...

>append funktioniert bei mir nicht
>wenn die Datei leer ist.

Das schau ich mir mal an. Aber eigentlich sollte das kein Problem sein, 
weil ans Ende spulen bei Dateigröße 0 kein Problem ist.

file.c@168
while( offset>=512 ){ ...

offset ist hier die Byte Stelle zu der man spulen möchte. Bei Dateigröße 
0 ist das 0 und 0 ist nicht >= 512, also wird in ffseek nichts 
sinnvolles gemacht...

Nur um sicher zu gehen, du appendest ;) ja so oder?

1

if(MMC_FILE_EXISTS == ffopen(file_name)){

2

   ffseek(file.length);

3

   uputc('a');

4

   ffclose();

5

}

Grüße Daniel

Ja krass, das hatte ich doch tatsächlich immer überlesen.
Wird geändert werden, danke.
Gewundert hatte es mich doch schon warum Linux das so seltsam formatiert 
:)

Grüße Daniel

kann es sein das man bestimmte ascii zeichen nicht schreiben kann? weil 
ich schicke den richtigen string, und wenn ich die zeichen einzeln 
ausgebe stimmen sie auch, nur auf der sd karte stehen sie nicht
danke mfg alex

Wenn du Strings mit der Funktion ffwrites schreibst, darf in dem String 
logischerweise kein '\0' alias 0x00 vorkommen, da dies ja ein String 
Ende markiert. Bei anderen Steuerzeichen bin ich mir nicht sicher ob die 
gehen.

Mit ffwrite kannst du jedes Byte Zeichen auf die Karte schreiben.

Falls das immer noch nicht geht, müsstest du mal ein bisschen Code 
zeigen und die Zeichen die du schreiben möchtest.

Viele Grüße

Daniel

Da kann ich nur aus dem eigenen Nähkästchen plaudern: signed char ist 
einfach nur krank, wenn es Zeichen und keine int-Werte enthält.

Aber vielleicht ist es auch Gewohnheitssache, mit den Abstrusitäten von 
signed char - Vergleichen zurecht zu kommen.

habe heute versucht daten über den uart einzulesen, lib ist ja 
vorhanden.

verwende ich jedoch

1

 ugetc();

zum auslesen, dann bekomme ich beim kompilieren folgenden fehler

:369: undefined reference to `ugetc'

1

#include "uart.h"

 ist im maincode geaddet und initalisieren und

1

 uputc(ffread());

 funktioniert im main programm auch, beim kompilieren dabei gibts auch 
keine fehler. nur wenn ich ugetc aufrufen möcte schreit er eine 
fehlermeldung.
kann das bitte mal wer testetn obs ähnliche fehler gibt?!

mfg
low

hab die einstellung gefunden die geändert werden muss config.h ;-)

MS-Patent für FAT bleibt gültig:
http://www.heise.de/newsticker/meldung/Bundesgerichtshof-haelt-Microsofts-FAT-Patent-aufrecht-985124.html

Hm,
hab ich da was überlesen oder geht es im Prinzip nur um vfat, also mit 
langen Dateinamen?

Das die da so auf dem fat noch herumreiten, wird wohl eher irgendwie 
exFat mit Zusammenhängen ?!?

Fat16/32 ist ja schon ziemlich in die Jahre gekommen. Wenn man mal so 
moderne Dateisysteme sieht...

hallo

wenn ich einen string mit vielen zeichen schreiben will hängt sich das 
programm auf. hab schon vieles probiert. \0 macht auch keinen 
unterschied. anscheinend gibt es ein limit für die stringlänge?! denn 
mit strings die kürzer sind funktioniert alles problemlos. anbei ein 
beispiel für eine länge die bei mir nicht mehr klappt.

1

char map_start[] = "awedawereeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeawedawereeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeawedawereeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\0 ";

2

ffwrites(map_start);

hat wer einen tipp?!

ps. fat32 formatierte karten klappen derzeit auch nicht, kann man das wo 
umstellen?!

speicher ist eigentlich noch da
Program:   14360 bytes (43.8% Full)
(.text + .data + .bootloader)

Data:       1528 bytes (74.6% Full)
(.data + .bss + .noinit)

Hallo,
ich vermute mal Ram Überlauf. Wo in deinem Programm kommst du auf die 
1528 bytes Ramverbrauch??

Pack den String mal ins Flash und probier das nochmal.
Oder mach ein kleines Array und schreib das wiederholt auf die Karte...

Mit was Fat32 Formatiert? Mit Windows?
Welche Version der Lib nutzt du?
Was genau meinst du mit klappt nicht ?!?

Wenn du ein CharArray so erstellst brauchst du das '\0' am Ende nicht! 
Das wird dann automatisch mit dran gemacht.

1

char map_start[] = "awedaweree";

Welchen Controller benutzt du?

Grüße Daniel

Hallo,
und wie sieht es aus? Läufts?

Daniel R. schrieb:
> Hallo,
> ich vermute mal Ram Überlauf. Wo in deinem Programm kommst du auf die
> 1528 bytes Ramverbrauch??
>
> Pack den String mal ins Flash und probier das nochmal.
> Oder mach ein kleines Array und schreib das wiederholt auf die Karte...
>
> Mit was Fat32 Formatiert? Mit Windows?
> Welche Version der Lib nutzt du?
> Was genau meinst du mit klappt nicht ?!?
>
> Wenn du ein CharArray so erstellst brauchst du das '\0' am Ende nicht!
> Das wird dann automatisch mit dran gemacht.
>
>

1

> char map_start[] = "awedaweree";

2

>

>
>
> Welchen Controller benutzt du?
>
> Grüße Daniel

ok, mal wieder ein programmfehler meinerseits ;-)
anscheinend is das ram übergelaufen. habe mal die ganzen strings ins 
eeprom des avr (atmega328p) abegelegt und jetzt klappts das beschreiben 
mit langen strings auf die sd problemlos.
mein ram ist so voll weil ich große array habe ca. 100 uint16_t array 
und dann noch lcd/sd/gps. und alles sehr unaufgeäumt.
das mit fat32 muss ich noch testen, aber ich tipp mal drauf es 
funkt.formatiert ist jedenfalls alles it windows.
bin derzeit ganz zufieden mit fat16 läuft alles super und prima!!  danke 
daniel!!
hab das programm jetzt soweit geschireben, dass ich auf der sd-karte ein 
kml file für google earth  erstelle und die gps koordinaten reinschreib.

mfg low

Hallo,
es gibt auf http://www.mikrocontroller.net/svnbrowser/avr-fat32/ eine 
neue Version, in der ist nur die Bestimmung des Cluster Endes geändert.
Das behebt das Problem mit Linux formatierten Karten :)

Wurde hier thematisiert 
Beitrag "Re: MMC SD library FAT16 FAT32 read write"

Danke  Amega (Gast)


Grüße Daniel

Hallo,
orientier dich einfach an dem Beispiel in der main.c

Oder hier dran: 
http://www.mikrocontroller.net/articles/AVR_FAT32#Einfaches_Code_Beispiel

Da ist ein einfaches Beispiel wie man die schreib/lese Funktionen 
benutzt.
Wenn du speziellere Hilfe möchtest, musst du schon ein bisschen mehr 
verraten :)

Oder noch besser ein wenig Code Posten, zu dem man Hilfestellung geben 
kann.

Grüße Daniel

Hallo Daniel,
erstmal meinen herzlichsten Dank für deine Arbeit an diesem Projekt, das 
über die Zeit wirklich hervorragend geworden ist!

@alle: Mein Dank gilt natürlich auch für alle anderen, die sich an 
diesem Projekt beteiligt haben oder wertvolle Vorarbeit geleistet haben!

Ich verwende die SD-Library (leicht angepasst) auf einem ATmega64 unter 
IAR und soweit läuft auch alles perfekt mit unterschiedlichsten 
SD-Karten.
Nun sind mir aber 3 Dinge/fehler aufgefallen, die ich hier mal 
ansprechen wollte, weil ich die in den bisherigen Diskussionen noch 
nicht finden konnte.

1.) Fehler in der Funktion "fat_loadFileDataFromCluster"?
Beim Vergleich des Dateinamens werden in der folgenden Zeile nur 10 
Zeichen verglichen, obwohl der Dateiname aus 11 Zeichen besteht. 
Folglich wird also das letzte Zeichen ignoriert, wodurch "MEINFILE1.TXT" 
und "MEINFILE1.TX2" im Vergleich identisch sind!
Bisher:

1

if(0==strncmp((char*)file.name,(char*)name,10)){

Korrigiert:

1

if(0==strncmp((char*)file.name,(char*)name,11)){

2.) Fehler in der Funktion "fat_loadSector"?
Am Ende der Funktion steht "return FALSE;" wobei diese Stelle niemals 
erreicht werden kann. Diese Funktion kann in der bestehenden Form nur 
"TRUE" zurückgeben, weshalb sich eine Prüfung auf Fehler bisher auch 
völlig erübrigt. Bei welcher Bedingung, hätte denn FALSE zurückgegeben 
werden sollen?

3.) Hier (http://www.mikrocontroller.net/articles/MMC-_und_SD-Karten) 
steht:
"Nachdem die Karte deselektiert wurde (/CS auf high), die Taktleitung 
noch einige Male pulsen, damit die Karte DO hochohmig/tri-state schaltet 
(vgl. Chans Erläuterungen)."
Das wird in der SD-Library bisher noch nicht gemacht, weshalb ich das 
bei mir noch eingefügt habe. Das könnte z.B. folgendermaßen gelöst 
werden. An jeder Stelle, wo im Source "MMC_Disable()" steht, müsste nur 
ein Schreibbefehl folgen, oder?. So z.B.:

1

MMC_Disable();  // CS High

2

mmc_write_byte(0xFF); // dummy write, 8 CLK-Pulse nachdem CS High, damit die Karte DO tri-state schaltet

Viele Grüße
Nig

Hallo.

@ Nig G. (nig)

Bei Punkt 1 und 2 hast du recht, ist mir irgendwie durchgegangen :)
Wird geändert.

Zu Punkt 3, diese Karten sind SPI hörig, also brauchen eigentlich für 
alles einen CLK um was zu machen, zumindest die meisten. Das mit dem "DO 
hochohmig/tri-state" wirkt sich aber auch nur aus, wenn man mehrere 
"Geräte" am selben SPI Bus hat, sonst wäre das egal.
Wird aber geändert.

Danke für die Unterstützung.

@ test (Gast)

Man kann jede Karte nehmen, auch so ganz billige für 2-3 Euro. Wichtig 
nur, es müssen MMC, SD oder SDHC Karten sein.

Viele Grüße

Daniel

Ach ja, ich überlege grade die Prüfung in fat_loadSector ganz raus zu 
nehmen, ist zwar nicht so schön ohne Fehler Prüfung, aber so wie es bis 
jetzt immer war bringt es ja auch nix...

Mal als Zwischenlösung:

1

unsigned char fat_loadSector(unsigned long int sec){

2

3

  if(sec!=fat.currentSectorNr){

4

  #if (MMC_WRITE==TRUE)

5

    if(fat.bufferDirty==1){      

6

             fat.bufferDirty=0;

7

             if(FALSE==mmc_write_sector(fat.currentSectorNr,fat.sector)) return FALSE; 

8

    }

9

  #endif

10

  if(FALSE==mmc_read_sector(sec,fat.sector)) return FALSE; 

11

  fat.currentSectorNr=sec;      

12

  }  

13

14

  return TRUE;             

15

}

Hallo,
oha du versuchst da die Version 0.3 zu kompilieren...
Nimm die aus dem SVN und dann sollte das ohne Probleme gehen.

Viele Grüße

Daniel

PS: In der SVN Version ist auch eine AVR-Studio Projektdatei dabei...

Aktuelle Version: 0.5.9
http://www.mikrocontroller.net/svnbrowser/avr-fat32

Hi,
nein gibt es noch nicht.
Hab da aber eine Idee, wie man da tatsächlich reguläre Unterstützung für 
lange Dateinamen hin bekommt ohne nochmal 256 Byte Ram zu brauchen :)
Aber vor Mitte Juli wird da nix draus werden...

Aber es ist jeder herzlich eingeladen mit zu entwickeln. Ich pflege das 
dann in die Lib ein.

Viele Grüße

Daniel

Hallo,
kannst du mal zeigen an welchen Stellen du da delays reingebaut hast, 
weil eigentlich ist selbst 20 MHz SPI nicht zu schnell für SD/MMC 
Karten...

Viele Grüße

Daniel

Hallo,
ja guter Einwand. Die Initialisierung im Software SPI Modus schau ich 
mir nochmal an. Bin eh grade eine ordentliche Platine für eine SD Karte 
am machen. Wenn das fertig ist, gibt es eine neue Version...

Danke und viele Grüße

Daniel