MMC SD library FAT16 FAT32 read write

Hallo Friedrich K.,
wie läuft es? Gibt es Fortschritte?

Viele Grüße

Daniel

Hey Daniel,

sehr nett, dass du nachfragst. Aber leider funktionierts noch nicht 
zufriedenstellend. Habe mir mal den Beispielcode geschnappt und 
stückchenweise modifiziert. Die Idee war dann tatsächlich mit ffwrite 
(ohne s) wegzuschreiben und zwar auf knopfdruck == trigger.

Es bleiben dabei zwei Probleme: Ich habe es immernoch nicht geschafft 
ausser beim Beispielcode eine Datei nach dem entnehmen der Karte und 
neuinitialisierung wieder zu öffen und zu beschreiben.
Das zweite Problem ist mehr eine Frage. Ich konnte nicht ganz ausmachen, 
an welcher Stelle des Codes wirklich echt vom RAM auf die Karte 
geschrieben wird. Denn ich würde gern auf Knopfdruck ebenfalls den rest 
der im RAM steht, auf die Karte schreibt, sodass man sie entnehmen kann. 
Wenn ich das recht sehe, dann tut das ffclose nicht allein, sondern 
setzt nur die Flags null.

Am besten poste ich mal wie ich den Beispielcode modifiziert habe. 
Vielleicht ist da was schief gelaufen, was ich nicht seh...

Was du da siehst, ist meine "wunsch-Konfiguration". Sie funktioniert 
nicht. Habe vorher Stückchenweise ausprobiert und sobald ich das ffclose 
auf knopfdruck aufrufe, funktionierts nicht mehr. Die Datei kann nicht 
gelesen werden unter windows (beschädigt) es wird aber eine realistische 
größe angezeigt.

1

    while(1)

2

    {

3

      if(!((PINC&0x01)==0x01))

4

      {

5

        if((PINC&0x01)==0x01)  //<<---- Erst beim Loslassen schreiben.

6

        {

7

             // Datei existiert, also anhaengen !

8

            if(MMC_FILE_EXISTS == ffopen(file_name))

9

            {

10

11

             // bewusst kein ffseek, weil ja, nicht geschlossen und Flags noch gesetzt

12

13

             // schreibt "String" Alternativ While Schleife

14

             ffwrite(48);

15

             ffwrite(49);

16

             ffwrite(50);

17

             ffwrite(51);

18

             ffwrite(52);

19

             ffwrite(53);

20

             ffwrite(54);

21

             ffwrite(55);

22

             ffwrite(56);

23

             ffwrite(51);

24

25

26

27

             // neue Zeile in der Datei

28

             ffwrite(0x0D);

29

             ffwrite(0x0A);

30

31

             /// Bewusst kein ffclose, da erst auf knopfdruck schließen soll

32

33

            }

34

          }

35

36

      }

37

      if(!((PINC&0x04)==0x04))  // <<--- Kontroll LED

38

      {

39

      ffclose();

40

      PORTD=0xCC;

41

      }

42

    }

Aber Fortschirtte gibts schon. Das ganze soll ein Wasserzähler werden 
der kalt und Warmwsser loggt. Die alte ochsentour mit dem 
selbstdefinirtem RAM hat ja einigermaßen fuktioniert, sodass ich ihn 
schon 24h hab laufen lassen können. Hab mal das Histogramm angehängt ;-)

Gruß, Fiete

Hallo.

>Ich habe es immernoch nicht geschafft
>ausser beim Beispielcode eine Datei nach
>dem entnehmen der Karte und
>neuinitialisierung wieder zu öffen und zu beschreiben.

Ich vermute mal, dass Du bevor Du die Karte entfernst nicht ffclose 
aufrufst. Mach es doch so, dass Du eine LED einschaltest wenn Du ffopen 
aufrufst und aus, wenn du ffclose aufrufst. So kannst Du genau sehen ob 
die Datei geöffnet oder geschlossen ist.

>Ich konnte nicht ganz ausmachen,
>an welcher Stelle des Codes wirklich
>echt vom RAM auf die Karte...

Bei einem fflushFileData() wird alles was aktuell im Ram ist auf die 
Karte geschrieben. Zudem wird der Dateieintrag geupdatet. Das ist 
prinzipiell ein ffclose(), nur dass die Datei danach nicht neu geöffnet 
werden muss um weiter zu schreiben. Sollte aber so selten wie möglich 
aufgerufen werden, da viele Schreiboperationen auf der Karte gemacht 
werden.

Sind die Taster ordentlich entprellt? Vielleicht geht da einiges 
durcheinander.

So wie ich das sehe, öffnest Du die Datei mehrfach, bevor Du sie 
schließt.
Versuch mal das:

1

   if(MMC_FILE_EXISTS == ffopen(file_name))

2

   {

3

      // Datei existiert, also zum Ende spulen

4

      ffseek(file.length);

5

6

      // hier Status LED an

7

   }

8

9

   while(1)

10

   {

11

      // Pin1 gedrückt?

12

      if(!((PINC&0x01)==0x01))

13

      {

14

         // hier warten bis Taste losgelassen wird!

15

         while( !((PINC&0x01)==0x01) );;

16

17

         // schreibt "String" Alternativ While Schleife

18

         ffwrite(48);

19

         ffwrite(49);

20

         ffwrite(50);

21

         ffwrite(51);

22

         ffwrite(52);

23

         ffwrite(53);

24

         ffwrite(54);

25

         ffwrite(55);

26

         ffwrite(56);

27

         ffwrite(51);

28

29

         // neue Zeile in der Datei

30

         ffwrite(0x0D);

31

         ffwrite(0x0A);        

32

      }             

33

34

      // Pin4 gedrückt?

35

      if(!((PINC&0x04)==0x04))  

36

      {

37

         ffclose();

38

39

         // Status LED hier aus, alles OK. Karte kann entfernt werden!

40

41

         break;   // um aus endlosschleife zu kommen

42

      }

43

44

  }

Ohne den Code so laufen zu lassen, denke ich sollte das gehen.

Hoffe irgendwas hiervon hilft :)

Viele Grüße

Daniel

Hey Daniel, danke für deine Antwort. Ich werds gleich heute abend mal 
ausprobieren.

Zum Prellen: ich habe mir eigentlich entprellte Taster besorgt. Lese 
gerade, dass man da noch Vorkehrungen treffen muss. Ich bin bisher immer 
davon ausgegangen, das es bei entprellten tastern kein Problem ist... 
Vielleicht hat er bei ffclose deshalb probleme bekommen...

Zu Kontroll LEDs: Ja, hab kontroll LEDs eingefügt, bei denen ich seh, wo 
er grad ist. Ich konnte sogar sehen, dass er auf die Karte geschrieben 
hat, weil er dann läger im ffwrite war und so die LED nen bissel länger 
geleuchtet hatte. In dem code den ich dir schickte, sind die LEDs nur 
noch zum teil drin. Ich schiebe die immer rum im code, um zu gucken, wo 
er grad "hängt".

Zu ffclose: Stört es, wenn ffclose mehrfach aufgerufen wird? Weil die 
Verrenkung dass er erst beim Losassen aus der Schleife steigt, hab ich 
mir bei ffclose gespart.

Zu fflushFileData: Muss man danach noch ffclose aufrufen? Wenn ichs 
recht sehe ja.

Kann es eventuell sein, dass die Karte einen knacks hat?

Ich werde wie gesagt mich heute Abend mal damit auseinander setzen und 
bericht erstatten.

Danke nochmal.

Gruß, Fiete

Hallo.

>...Verrenkung dass er erst beim
>Losassen aus der Schleife steigt...

Die Verrenkung ist doch nur ein "break;" um aus der Schleife raus zu 
kommen. Ob jetzt bei Taste gedrückt oder losgelassen ist ja nur die 
Abfrage im if...

>Stört es, wenn ffclose mehrfach aufgerufen wird?

Eigentlich nicht, ist aber unnötig. Muss halt so programmiert werden das 
es nicht vor kommt :)

>Zu fflushFileData: Muss man danach
>noch ffclose aufrufen? Wenn ichs
>recht sehe ja.

fflushFileData ist eigentlich dazu gedacht, dass wenn ein Gerät z.B. 
über Tage läuft und Daten loggt, man zwischendurch mal zur Sicherheit 
fflushFileData aufruft. So hat man die Daten bis dahin schonmal 
gesichert, falls der Strom ausfällt oder ähnliches. Dadurch spart man 
sich ein ffclose und ffopen.


Funktioniert die Karte denn unter Windows noch ordentlich? Also 
beschreibbar, lesbar und keine Fehler beim Formatieren? Wenn es da keine 
Probleme gibt, sollte die Karte noch OK sein.



Viele Grüße

Daniel

Hallo.
Ich bin hier neu im Forum und habe bis jetzt nicht so viel Erfahrung mit 
AVRs. Deswegen bitte sich nicht über meine dummen Fragen ärgern.

Ich werde mein Atmega32L mit 3,3V versorgen und mit 8MHz takten. Meine 
Karte hat 2GB. Ich möchte Fat32 benutzen.

Soll sie zuerst mit dem PC mit FAT32 formatiert werden oder macht das 
dein Programm?
Kanst du mir bitte sagen an welche Pins des Atmega32 ich die SD Karte 
anschliesen muss?
Wo soll ich im Code eine Umstellung von Fat16 auf Fat32 machen?
Mit welcher Funktion wird eine neue Datei erzeugt?
Mit welcher Funktion wird eine Datei beschrieben?

Grüße,
Lukas

Hey Lukas,

also das mit den SD-Karten ist nicht so ganz ohne. Du solltest schon 
mindestens nen bisschen C mitbringen und das AVR Tutorial wäre auch 
nicht schlecht, einfach, damit du nen bissel weißt, was du tust. Es ist 
jedenfalls im seltensten Fall so, dass man es einschaltet und alles 
funktioniert. Guck dir mal in der Artikelübersicht 
http://www.mikrocontroller.net/articles/MMC-_und_SD-Karten da steht 
schonmal ne Menge drin.

Gruß, fiete

Hallo.
Man verwendet Belegung wie sie in der "mmc-0.2.H" Datei angegeben ist. 
Habe ich das richtig verstanden? Warum wird denn der SPI-Port für den 
Anschluss verwendet. Das ist doch unpraktisch, jedesmal die Karte 
auszustecken um zu programmieren??
Hast du deine Karte auch an PORTB abgeschlossen?

Grüße,
Lukas

Der SPI-Port stehllt das Protokoll bereit, das mit der Karte 
kommuniziert. Das ist eine Bus-Kommuikation. Es können also mehrere 
Bauteile angeschlossen werden und nur das, welches aktivirt ist, fühlt 
sich auch angesprochen. Aktivirt wird wenn ichs richtig im kopf hab wenn 
pin 0 auf high gezogen wird...

Hallo Lukas.

Hier gibt es auch noch mehr Informationen
http://www.mikrocontroller.net/articles/AVR_FAT32

Die neuste Version ist immer unter
http://www.mikrocontroller.net/svnbrowser/avr-fat32
zu bekommen.

Dabei ist auch ein Beispiel Programm wo die Benutzung gezeigt wird.

Viele Grüße

Daniel

Ich versuche gerade die Software mit Keil µVision4 auf einen LPC2148 zu 
portieren. Der Compiler spuckt aber Fehler aus. Da soll wohl noch was 
umgecastet werden?

1

fat.c(120): error:  #852: expression must be a pointer to a complete object type

2

fat.c:                  vsector+=   6;

3

fat.c:                  ^

4

fat.c(123): error:  #852: expression must be a pointer to a complete object type

5

fat.c:                  vsector+=2;

6

fat.c:                  ^

7

fat.c(422): error:  #852: expression must be a pointer to a complete object type

8

fat.c:                          *(unsigned char*)vsector++ = 0x00;

9

fat.c:                                           ^

10

fat.c(431): error:  #852: expression must be a pointer to a complete object type

11

fat.c:                          *(unsigned char*)vsector++ = toupper(name[i]);

12

fat.c:                                           ^

13

fat.c(439): error:  #852: expression must be a pointer to a complete object type

14

fat.c:          vsector++;

15

fat.c:          ^

16

fat.c(478): error:  #852: expression must be a pointer to a complete object type

17

fat.c:                  vsector+=8;

18

fat.c:                  ^

19

fat.c(482): error:  #852: expression must be a pointer to a complete object type

20

fat.c:                  vsector+=6;

21

fat.c:                  ^

22

fat.c(486): error:  #852: expression must be a pointer to a complete object type

23

fat.c:                  vsector+=2;

24

fat.c:                  ^

1

void fat_loadRowOfSector(unsigned short row){

2

3

  #if (MMC_ENDIANNESS_LITTLE==TRUE)

4

    void *vsector;                  // voidpointer, damit man schoen umbiegen kann :)

5

6

    vsector=&fat.sector[row+20];          // row ist byteoffset einer reihe

7

8

    file.firstCluster=*(unsigned short*)vsector;  // high word von first.cluster (20,2)

9

    file.firstCluster=file.firstCluster<<16;

10

11

    vsector+=   6;

12

13

    file.firstCluster|=*(unsigned short*)vsector;  // low word von first.cluster (26,2)

14

    vsector+=2;

15

16

    file.length=*(unsigned long int*)vsector;    // 4 byte von file.length (28,4)

17

  #else

18

    unsigned char *psector =& fat.sector[row+31];

19

20

    file.length =  *psector--;    // 31    hoechstes byte

21

    file.length <<= 8;

22

    file.length |=  *psector--;    // 30

23

    file.length <<= 8;

24

    file.length |=  *psector--;    // 29

25

    file.length <<= 8;

26

    file.length |=  *psector;    // 28

27

28

    psector-=7;

29

    file.firstCluster =  *psector--;          // 21  hoechstes byte

30

    file.firstCluster <<= 8;

31

    file.firstCluster = file.firstCluster | *psector;  // 20

32

    file.firstCluster <<= 8;

33

34

    psector+=7;

35

    file.firstCluster = file.firstCluster | *psector--;  // 27

36

    file.firstCluster <<= 8;

37

    file.firstCluster = file.firstCluster | *psector;  // 26

38

  #endif

39

}

1

void fat_makeSfnDataEntry(unsigned char name [],unsigned char attrib,unsigned long int cluster,unsigned long int length){

2

3

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

4

  void *vsector;         // void zeiger auf sektor, um beliebig casten zu können

5

  unsigned short row;    // reihe in dem sektor

6

7

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

8

  row = file.row;

9

  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)

10

  vsector =& fat.sector[row];  // anfangs adresse holen ab der stelle auf sector geschrieben werden soll

11

12

  #if (MMC_TIME_STAMP==TRUE)

13

    unsigned char new=FALSE;

14

    // pruefung ob eintrag neu ist.

15

    if(fat.sector[row]==0xE5||fat.sector[row]==0x00)   new=TRUE;

16

  #endif

17

18

  #if (MMC_TIME_STAMP==FALSE)

19

    // alle felder nullen...

20

    i = 20;

21

    do{

22

      *(unsigned char*)vsector++ = 0x00;

23

    }while( i-- );

24

    vsector =& fat.sector[row];

25

  #endif

26

27

  // namen schreiben (0,10)

28

  i = 0;

29

  do{

30

    #if (MMC_LFN_SUPPORT==TRUE)

31

      *(unsigned char*)vsector++ = toupper(name[i]);

32

    #else

33

      *(unsigned char*)vsector++ = name[i];

34

    #endif

35

  }while( ++i < 11);

36

37

  // attrib schreiben (11,1)

38

  *(unsigned char*)vsector = attrib;

39

  vsector++;

40

41

  #if (MMC_TIME_STAMP==TRUE)

42

    unsigned short time=fat_getTime();

43

    unsigned short date=fat_getDate();

44

45

    // reserviertes byte und milisekunden der erstellung (12,2)

46

    *(unsigned short*)vsector=0x0000;

47

    vsector+=2;

48

49

    if(new==TRUE){

50

      // creation time,date (14,4)

51

      *(unsigned long int*)vsector=date;

52

      *(unsigned long int*)vsector=*(unsigned long int*)vsector<<16;

53

      *(unsigned long int*)vsector|=time;

54

    }

55

    vsector+=4;

56

57

    // last access date (18,2)

58

    *(unsigned short*)vsector=date;

59

    vsector+=2;

60

61

    // low word von cluster (20,2)

62

    *(unsigned short*)vsector=(cluster&0xffff0000)>>16;

63

    vsector+=2;

64

65

    // last write time,date (22,4)

66

    *(unsigned long int*)vsector=date;

67

    *(unsigned long int*)vsector=*(unsigned long int*)vsector<<16;

68

    *(unsigned long int*)vsector|=time;

69

    vsector+=4;

70

71

    // high word von cluster (26,2)

72

    *(unsigned short*)vsector=(cluster&0x0000ffff);

73

    vsector+=2;

74

75

    // laenge (28,4)

76

    *(unsigned long int*)vsector=length;

77

  #else

78

    vsector+=8;

79

80

    // low word  von cluster (20,2)

81

    *(unsigned short*)vsector=(cluster&0xffff0000)>>16;

82

    vsector+=6;

83

84

    // high word von cluster (26,2)

85

    *(unsigned short*)vsector=(cluster&0x0000ffff);

86

    vsector+=2;

87

88

    // laenge (28,4)

89

    *(unsigned long int*)vsector=length;

90

  #endif

91

}

Hallo,
versuch mal "#define MMC_ENDIANNESS_LITTLE FALSE" in der config.h
Damit fliegen überall die void Pointer raus. Ist aber evtl. nicht so 
schnell dann.

Es gibt da mit mehreren Kompilern Probleme wegen void Pointern. Verstehe 
ich nicht ganz, weil das eigentlich normaler C Standard sein sollte...

Viele Grüße

Daniel

Hi,

ich hab da auch mal wieder ne Frage.
Ich will mit der neuen Version (0.6.1) einen Ordner anlegen. In der 
Config.h ist #define MMC_LFN_SUPPORT            TRUE. So weit, so gut!
Aber wenn ich nun alle:

1

unsigned char datum_verzeichnis[8];    //Beispiel: "33-33-33

2

datum_verzeichnis[0] = datum[0];

3

datum_verzeichnis[1] = datum[1];

4

datum_verzeichnis[2] = '-';        

5

datum_verzeichnis[3] = datum[3];        

6

datum_verzeichnis[4] = datum[4];        

7

datum_verzeichnis[5] = '-';

8

datum_verzeichnis[6] = datum[6];

9

datum_verzeichnis[7] = datum[7];        

10

11

ffmkdir(datum_verzeichnis);

12

ffcd(datum_verzeichnis);

ein Verzeichnis anlegen will, dann geht das nicht. Windoofs will da wohl 
am ende der Eingabe noch ein abschließedendes Zeichen haben. Kann mir 
bitte jemand verraten, welches das ist?
Und mit einem HEX-Editor kann ich leider kein Verzeichnis öffnen... Bei 
normalen Dateien kann man ja "spicken" wie bestimmte Steuerzeichen 
aussehen. Bei Ordner geht das nich...

Danke für alle guten Tipps!
Matze

Danke Daniel. Das lesen von Dateien geht jetzt ohne Probleme. Aber beim 
fclose nach dem schreiben in eine Datei bleibt er hängen. Ein Hardware 
Problem schließe ich aus, da das lesen funktioniert. Timing Probleme 
dürften es auch nicht sein da ich den Prozessor bis auf 12MHz 
runtergetaktet habe.

Im Anhang ist das komplette µVison Projekt, lauffähig mit debug 
Ausgaben, und die debug Meldungen. Er bleibt ganz am Schluss zwischen 
Kontrollpunkt D und E hängen, obwohl er vorher mehrmals korrekt bis E 
durchläuft.

Ich höffe es ist einigermaßen verständlich was ich meine. ;-)


Mfg,
Kurt


PS: Ich habe die Software auch auf einem Mega32 mit 18,x MHz getestet, 
da funktionieren lesen und schreiben wunderbar!

Das war natürlich die falsche Datei!
@Moderatoren: bitte löschen.

Hier kommt die richtige.

so gehts:

1

unsigned char datum_verzeichnis[9];    //Beispiel: "33-33-33

2

datum_verzeichnis[0] = datum[0];

3

datum_verzeichnis[1] = datum[1];

4

datum_verzeichnis[2] = '-';        

5

datum_verzeichnis[3] = datum[3];        

6

datum_verzeichnis[4] = datum[4];        

7

datum_verzeichnis[5] = '-';

8

datum_verzeichnis[6] = datum[6];

9

datum_verzeichnis[7] = datum[7];

10

datum_verzeichnis[8] = 0x00;        

11

12

ffmkdir(datum_verzeichnis);

13

ffcd(datum_verzeichnis);

Aber da muss man erstmal drauf kommen... ;)

Leider waren doch meine SPI (SSP) Funktionen falsch! Also bitte meine 
beiden letzten Beiträge ignorieren.

ABER: In der fat_loadSector() ist anscheinend ein return FALSE zuviel?

Mfg,
Kurt

Hallo zusammen.
Wunderbar, dass sich hier alles von selber erledigt :)
Hm, das FALSE da ist wirklich überflüssig... da kommt man ja garnicht 
hin.
Wird geändert.

Viele Grüße

Daniel

Hallo max,
Du musst im Makefile bei

# MCU name
MCU = atmega162

eintragen.

Dann noch in der mmc.h die Pins der Hardware SPI Schnittstelle 
eintragen.

1

  #if defined (__AVR_ATmega162__)

2

  #define SPI_MISO        6  //Port Pin an dem Data Output der MMC/SD-Karte angeschlossen ist

3

  #define SPI_MOSI        5  //Port Pin an dem Data Input der MMC/SD-Karte angeschlossen ist

4

  #define SPI_Clock       7  //Port Pin an dem die Clock der MMC/SD-Karte angeschlossen ist (clk)

5

  #define MMC_Chip_Select   0  //Port Pin an dem Chip Select der MMC/SD-Karte angeschlossen ist

6

  #define SPI_SS          4  //Nicht Benutz muß aber definiert werden

7

  #endif

Viele Grüße

Daniel

das problem hab ich auch manchmal. versuch mal ne andere SD-Karte.
Wenn ich mal ausversehen die SD-Karte im Slot habe, wenn der ISP dran 
is, dann kriegt sie wohl einen "Schaden". In anderen Geräten geht sie 
dann noch, aber am µC nich mehr. Ich weiß auch nicht, woran das liegt. 
Is halt mein "Word-Around"... Nich schön, weil auf dauer teuer, aber was 
will man machen ;)

Hmm... habe mich wohl geirrt! Sorry!
Ich hatte ja das selbe Problem: mals liefs und mal nicht. Ich habe immer 
mit WinAVR compiliert und bin gestern einfach mal spaßeshalber in das 
AVR Studio gewechselt und habe da den selben Code compiliert - jetzt 
geht alles und zwar immer... also, wenn du mit dem WinAVR arbeitest: 
wechseln ;)

Hallo,
kann mir eigentlich nur vorstellen, dass es mit Kompiler Optionen zu tun 
hat oder etwas in dieser Richtung. Vielleicht ist es aber auch wenn das 
nur bei einer Karte auftritt eine extrem langsame. Habe hier auch eine 
16MB Karte die extrem langsam ist.

Grüße

Daniel

Naja, ich habe am Versuchsaufbau nichts geändert! Sogar die selbe Karte 
benutzt. Mit dem ARV Studio geht es nun aber flüssig und vor allem 
immer.
Is komisch, ist aber so.

Hallo,
stimmen diese Daten?

>SD-Formel1 256Mb (hab ich irgendwo ausgegraben):
>2,6s für die 1.Datei
>2,4s für die 100. Datei

>NONAME SD-micro 2Gb (aus meinem Handy)
>3.6s für die 1.Datei
>3.4s für die 100. Datei

Die werden schneller bei 100 Dateien?!?
Zeig mal den Benchmark Code !

Ja MMC Karten sind deutlich schneller, keine Ahnung wieso.

Fat16 zu Fat32 macht bei mir keinen so großen Unterschied. Ist im 
einstelligen KB Bereich.
Ob ich Multiblock ein/aus schalte macht deutliche Unterschiede.

Deine maximale SPI Geschwindigkeit ist f_cpu / 2 also 7,3728 MHz / 2 = 
3,6864 MHz. Das ist jetzt nicht so wahnsinnig schnell. Die Karten sind 
für 25 MHz ausgelegt.

Was willst Du denn eigentlich speichern? Muss das so schnell sein?

Viele Grüße

Daniel

Hi,

ich habe eine Frage zu deinem Benchmark.
Kannst du mir mal bitte die Zeite

1

c = c==254 ? 0 : c;

 erklären. Ich kenne weder ein "?" noch ein ":" in einer Zeile. Nur 
interesse halbe (ich lerne immer wieder was dazu ;)

Liebe Grüße,
Matze

Hallo,

das ist eine verkürzte Schreibweise für eine Abfrage. Wenn C=254 wird c 
der Wert hinter dem Fragezeichenzugewiesen. Wenn nicht der Wert hinter 
dem : Allerdings bin ich der Meinung, dass es am Ende :c++ heissen 
müsste. Ich kenne das Programm nicht, aber das soll wohl eine 
Zählvariable sein. Kann aber auch sein, dass sie woanders im Programm 
verändert wird. Dann macht diese Art der Abfrage allerdings weniger 
Sinn...

Gruß
Bad Urban

Cool! Wieder was gelernt!!!
Ich habe mal in der Quelltext geschaut, das müsste wirklich ":c++;" 
heißen.

Danke aber fürs übersetzen!!
Gruß,
Matze

Freut mich wenn ich helfen kann. Bin da das erste mal auch mit großen 
Augen davor gesessen :-)

Ok, das "ffwrite(c++);" hab ich übersehen. Mein Fehler.

Aber warum sollte ein "c = c==254 ? 0 : c;" nicht in ein c-Programm? 
Vorallem die Begründung, daß es kryptisch sei halte ich für arg 
schwammig. Ich denke, ich werde es zu meinem Standart für solche Fälle 
erklären. Warum sollte ich das nicht dürfen?! Ich finds kurz und 
prägnant.

Hallo.

@little man (Gast)

Die interessanten Teile hast Du weggelassen :)
Wie sehen folgende defines bei Dir aus?

1

#define TOP_OCR 0xF9

2

#define START_TCNT 0x06

3

#define PRESCALER 0x03

Hallo,
also mein Timer Rechner sagt mit einer Frequenz von 7.3728 MHZ müssen 
die Werte bei einem Überlauf von 1 ms:

1

#define TOP_OCR 0x72

2

#define START_TCNT 0x8D

3

#define PRESCALER 0x03

sein. Der Fehler ist dann 0.174%

Ich benutze dazu diesen Rechner:

http://www.b9.com/elect/avr/kavrcalc/index.html

welcher auch unter Linux mit Wine läuft.

Zur Not könnte man auch die Tick Zeit mal mit einem sleep vergleichen...

Viele Grüße

Daniel

Hm, seltsam.
Ich hab nur ein paar total alte Karten bei denen das nicht geht.
Neuere SD sollten das auf jeden Fall haben.

Viele Grüße

Daniel

*abo

Hallo,
sehe ich das richtig, dass der Atmeg644p 4k Ram hat? Weil eigentlich 
würde ich auf Ram Probleme tippen.
Läuft das Programm ohne schreiben auf die SD Karte normal durch?
Versuch mal die Datei einfach geöffnet zu lassen.
Du legst nicht alle 5 Minuten eine neue Datei an oder?

Hab grad nicht die Zeit mir das Programm im Detail anzuschauen, mach ich 
aber am Wochenende.

Viele Grüße

Daniel

Hallo,
also so nochmal auf die schnelle...
Bist Du Dir sicher, dass nur wirkliche Strings mit ffwrites geschrieben 
werden? Wenn da irgendwo das '\0' fehlt geht das schief.

Grüße

Daniel

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

Hallo.

@obi (Gast)
Nee das sollte kein Problem sein.

@Peter (Gast)
Hm, Du versuchst das nicht Batterie betrieben oder?
Beim schreiben zieht so eine Karte mal gut strom...

Über welche Datenmenge sprechen wir denn da bei den 2 Stunden?

Viele Grüße

Daniel

Hallo.

@Peter (Gast)
Bist Du da noch dran an dem Problem?

Nur der Vollständigkeit halber, wenn man viel Strom aus einer schwächer 
werdenden Batterie zieht, bricht die Spannung ein -> Kontroller Reset...

Guten Abend,
erstmal: Absolut genial was hier für eine Lib entstanden ist. Da muss 
man schon mal den Hut ziehen !

Ich hab allerdings noch ein Problem mit dem Schreiben. Lesen 
funktioniert einwandfrei.
Wenn ich ein einzelnes Byte schreiben will (die Datei ist vorhanden und 
in ihr war vorher auch nur ein Byte):

1

if(TRUE == fat_loadFatData()){

2

  unsigned char file_name_offset[]="OFFS    KOM";

3

  if(MMC_FILE_EXISTS == ffopen(file_name_offset)){

4

    ffwrite(0x99);

5

    ffwrite(0x99);

6

    ffclose();

7

    }

8

  }

muss ich, wie ihr seht, den Befehl dazu zwei Mal geben. Wenn das zweite 
ffwrite auskommentiert ist, tut sich in der Datei gar nichts.

Das Anhängen an die Datei per vorgeschobenem

1

 ffseek(file.length)

funktioniert weder mit einem noch mit zwei Befehlen.

Meine Config habe ich mal angehängt.
Bin über jeden Hinweis dankbar.
Grüße Paul

MoinMoin,

es wäre gut, wenn du mal einige Konstellationen von Defines in config.h 
ausprobierst! Ich wollte gerade deine Lib mit "readonly" übersetzen und 
bekam einige Fehler um die Ohren gehauen. Z.B., wenn man

#define MMC_WRITE FALSE

setzt, kommt:

/home/x/work/x/sd_card/file.c:626: undefined reference to 
`fat_setClusterChain'
/home/x/work/x/sd_card/file.c:627: undefined reference to 
`fat_getFreeClustersInRow'

Grüße & Danke Uwe

...Zusatz:

wenn man

#define MMC_LFN_SUPPORT  FALSE

setzt, stürzt das Beispielprogramm beim Schreiben der Testdatei 
reproduzierbar ab...

Du solltest wirklich mal dringenst ein Codereview machen!

Grüße Uwe

Hallo,
bin gerade etwas eng mit der Zeit die ich fürs Hobby zur Verfügung habe.

Das mit dem "readonly" Fehler ist reingekommen, weil ich da die defines 
umgebaut hatte.

#define MMC_LFN_SUPPORT  FALSE
Das schau ich mir morgen oder die Tage mal an. Glaub ich so nicht 
richtig. Läuft bei mir nämlich in anderen Projekten problemlos.

Nur bei schnellen Prozessoren kann es Probleme mit den low level mmc 
Funktionen geben hab ich bemerkt. Aber das sind dann auch keine AVR 
mehr...

Grüße

Daniel

MoinMoin,

meine Testumgebung ist ein Mega168 mit 16MHz getaktet, also eigentlich 
deine Default-Konfiguration...

Daniel R. schrieb:
> #define MMC_LFN_SUPPORT  FALSE
> Das schau ich mir morgen oder die Tage mal an. Glaub ich so nicht
> richtig. Läuft bei mir nämlich in anderen Projekten problemlos.
>
Das Fehlerbild sieht wie folgt aus: es kommen genau zwei Zeilen des 
Dateiinhaltes, auch wenn mehr drin steht.

Grüße Uwe

PS.: für mich wäre es wichtig, wenn die "readonly"-Geschichte 
funktioniert. Ich könnte auch selbst am Code rummachen, aber habe keine 
Berechtigung, das Zeugs wieder ins SVN zurück zu laden... Deshalb würde 
ich es gerne dir überlassen!

MoinMoin,

ein weiterer Fehler:

file.c --> ffls() --> lsRowsOfClust()

Ein Dateiname ist mindestens 11 Zeichen lang. Du deklarierst temp als 
Array mit 11 Byte und schreibst an die 11.Stelle eine \0, als 
Stringende. Damit geht das letzte Zeichen des Dateinamen verloren...

Grüße Uwe

PS.: sorry, dass ich so penetrant bin. Ich wollte eigentlich deine Lib 
zum Einlesen von Basic-Programmen 
(http://www.mikrocontroller.net/articles/AVR_BASIC) von einer SD-Karte 
benutzen, stolpere aber derzeit leider über die Fehler in der Lib.

MoinMoin,

...siehe 
Beitrag "Re: Basic-Interpreter auf einem AVR"

Grüße Uwe

PS.: eine Funktion ffeof() wäre auch ganz nett...

PPS.: aber auch Lob für deine Lib, ich bin trotz einige Ungereimtheiten 
relativ schnell zum Ziel gekommen!

Tach auch.

Zuerst einmal: Eine super Bibliothek, die auf Anhieb funktioniert hat. 
Top!

Allerdings bin ich nun auf ein Problem gestoßen: Wenn ich eine Datei 
(zum Lesen) öffne und sie von Anfang bis Ende mit ffread() auslese, ist 
es mir danach nicht mehr möglich eine neue Datei zu öffnen. Egal ob ich 
die datei schließe oder nicht. Waron könnte das liegen?

Gruß Sven

Hallo,
da müsstest Du mal den Code zeigen. Kann ich so nicht viel zu sagen.



Grüße

Daniel

Hier kommt er:

1

unsigned char file_name[6]=" .mp3";

2

  unsigned char file_handle;

3

  for(uint8_t file_no=0; file_no<10; file_no++){

4

    file_name[0] = file_no + '0';

5

6

    printf("loop #%u, trying to open %s\n", file_no, file_name);

7

8

    file_handle = ffopen(file_name);

9

    if(MMC_FILE_EXISTS != file_handle)

10

      printf("Error opening file: %s (%u)\n", file_name, file_handle);

11

    else{

12

      printf("%s opened. Size: %lu Bytes\n", file_name, file.length);

13

14

      for(uint32_t b=0; b<file.length/512+1; b++) {

15

        // Regler per UART stellen

16

        input_1 = uart_getc();

17

        input_2 = uart_getc();

18

        if ( !(input_1 & UART_NO_DATA)  && !(input_2 & UART_NO_DATA) ){

19

          switch(input_1){

20

            case 1: sta015_set_atten(input_2); break;

21

            case 2: sta015_set_bass((int8_t)input_2); break;

22

            case 3: sta015_set_treble((int8_t)input_2); break;

23

          }      

24

        }

25

26

        // alle 128kB nenn bissel Info lesen

27

        if((b & (0x000000FF)) == 0xFF){

28

          printf("%u Kbit/s ", sta015_read_reg(STA015_REG_AVERAGE_BITRATE)<<1);

29

          printf("Head: 0x%02X%02X%02X ", sta015_read_reg(STA015_REG_HEAD_H), sta015_read_reg(STA015_REG_HEAD_M), sta015_read_reg(STA015_REG_HEAD_L));

30

          printf("Error: 0x%02X ", sta015_read_reg(STA015_REG_ERROR_CODE)&0x3F);

31

          //printf("Ancillary Data bits: 0x%02X%02X ", sta015_read_reg(STA015_REG_ANCCOUNT_H), sta015_read_reg(STA015_REG_ANCCOUNT_L));

32

          //printf("Ancillary Data 1: 0x%02X ", sta015_read_reg(STA015_REG_ANC_DATA_1));

33

          uart_putc('\n');

34

        }

35

36

        // Noch zu lesende Bytes ermitteln

37

        int16_t max = 512;

38

        if(b==file.length/512)

39

          max = file.length%512;

40

41

        // 512 Bytes von der SD-Karte lesen

42

        SPCR &= ~(1<<CPHA);

43

        for(uint16_t byte=0; byte<max; byte++)

44

          buffer[byte] = ffread();

45

        SPCR |= (1<<CPHA);

46

47

48

        // BIT_EN auf High

49

        SPI_CS_STA_PORT |= (1<<SPI_CS_STA);

50

51

        int16_t i = 0;

52

        // Block an den Decoder senden

53

        while(i < max){

54

          // Auf Data Request warten

55

          while(!(STA015_DATAREQ_PIN & (1<<STA015_DATAREQ)));

56

57

          // So lange wie Data Request an ist, Daten senden

58

          while((STA015_DATAREQ_PIN & (1<<STA015_DATAREQ)) && i < max){

59

            // Zeichen an den Decoder senden

60

            SPDR = buffer[i++]; num_bytes++;

61

            // auf SPI Übertragung warten

62

            while(!(SPSR & (1<<SPIF)));

63

          }

64

        }

65

66

        // BIT_EN auf LOW

67

        SPI_CS_STA_PORT &= ~(1<<SPI_CS_STA);

68

      }

69

70

      ffclose();

71

      printf("Track over\n");

72

    }

73

  }

74

  printf("%lu Bytes gelesen/uebertragen\n", num_bytes);

75

  printf("Fertig!\n");

Hallo,
wie äußert sich das denn. Bleibt er beim öffnen hängen oder wie?
Versuch mal testweise die Karte vor dem erneuten öffnen neu zu 
initialisieren. Wie sieht die config.h aus und die Initialisierung der 
FAT/Karte?

Viele Grüße

Daniel

Moin Daniel. Wenn ich die SD-Karte und die FAT neu initialisiere, 
funktionierts. Er hatte zuvor gemeldet, die Datei würde nicht 
existieren.

An der Initialisierung der SD habe ich nichts geschraubt und so von dir 
übernommen. Hier meine config.h:

1

  //#####################################################################################

2

  // BOOL DEFINITIONEN

3

4

  #define TRUE   1

5

  #define FALSE   0

6

7

  //#####################################################################################

8

  // FLAGS

9

10

  // flags fuer ffopen (sind die rueckgabewerte von ffopen, auf diese wird geprueft..)

11

  #define MMC_FILE_NEW       0  // datei existierte nicht, wurde gerade angelegt !

12

  #define MMC_FILE_EXISTS     1  // datei existiert, es kann gelesen werden !

13

  #define MMC_FILE_NOT_EXISTS     2  // datei existiert nicht, wird nur bei read-only zurueckgegeben, wenn die datei nicht gefunden wurde !

14

15

16

  //#####################################################################################

17

  // WICHTIGE SCHALTER

18

19

  // schalter die den funktionsumfang aendern bzw, den funktionsumfang einiger funktionen :)

20

  #define MMC_WRITE           FALSE  // TRUE, dann mit write unterstuetzung, wenn FALSE dann read only !

21

  #define MMC_OVER_WRITE       FALSE  // TRUE und MMC_WRITE TRUE, dann kann ffwrite dateien überschreiben, wenn FALSE dann nur normales schreiben. um an eine datei anzuhaengen ist MMC_OVER_WRITE TRUE nicht noetig!

22

  #define MMC_MULTI_BLOCK     FALSE  // TRUE und MMC_OVER_WRITE FALSE, dann werden multiblock schreib/lese funktionen benutzt. ist schneller, wird aber möglicherweise nicht von allen karten unterstützt. wenn FALSE ist normale operation

23

  #define MMC_SDHC_SUPPORT    FALSE  // TRUE, dann mit sdhc unterstuetzung, wenn FALSE, dann nur mmc/sd karten. siehe : http://de.wikipedia.org/wiki/SD_Memory_Card#SDHC_.28SD_2.0.29

24

  #define MMC_ENDIANNESS_LITTLE    TRUE  // TRUE, dann ist der code auf littleendian ausgelegt. AVR ist littleendian. code ist auf littleendian optimiert!! siehe: http://de.wikipedia.org/wiki/Endianness

25

  #define MMC_LFN_SUPPORT      TRUE  // TRUE, dann mit unterstuetzung fuer lange dateinamen. kostet wenn read und write benutzt wird um die 800 bytes flash...

26

  #define MMC_RM_FILES_ONLY    TRUE  // TRUE ,MMC_WRITE TRUE und MMC_RM TRUE, dann wird die funktion ffrm so mit kompiliert, dass sie nur dateien loeschen kann. wenn FALSE und MMC_WRITE TRUE, dann kann die funktion dateien und ordner rekursiv loeschen !

27

28

  // schalter die explizit funktionen mit kompilieren oder nicht!

29

  #define MMC_TIME_STAMP       FALSE   // TRUE, dann werden die funktionen fat_getTime und fat_getFreeBytes mit kompiliert. siehe auch abschnitt: ZEIT FUNKTIONEN, weiter unten

30

  #define MMC_RM               FALSE  // TRUE und MMC_WRITE TRUE, dann wird die funktion ffrm mit kompiliert.

31

  #define MMC_SEEK            TRUE  // TRUE,dann wird die funktion ffseek mit kompiliert. mit dieser funktion kann man in einer geoeffneten datei vor und zurueck spulen. nur in kombination mit MMC_OVER_WRITE TRUE kann in einer datei ueberschrieben werden.

32

  #define MMC_MKDIR            FALSE  // TRUE und MMC_WRITE TRUE, dann wird die funktion ffmkdir mit kompiliert. mit dieser funktion kann man ordner anlegen.

33

  #define MMC_GET_FREE_BYTES  TRUE  // TRUE, dann wird die funkton fat_getFreeBytes mit kompiliert. mit dieser funktion kann der freie platzt auf der karte ermittelt werden

34

  #define MMC_LS              TRUE  // TRUE, dann wird die funktion ffls mit kompiliert. mit dieser funkion kann man die dateien auf der karte anzeigen lassen

35

  #define MMC_CD              TRUE  // TRUE, dann werden die funktionen ffcd und ffcdLower mit kompiliert. mit diesen funktionen kann man in ein verzeichnis wechseln oder aus einem verzeichnis ein verzeichnis hoeher wechseln.

36

  #define MMC_FILE_EXSISTS    TRUE  // TRUE, dann wird die funktion ffileExsists mit kompiliert. mit dieser funktion kann geprueft werden, ob es die datei im aktuellen verzeinis gibt !

37

  #define MMC_WRITE_STRING    TRUE  // TRUE und MMC_WRITE TRUE, dann wird die funktion ffwrites mit kompiliert. mit dieser funktion koennen strings auf die karte geschrieben werden.

38

39

  // vorsicht, da die variable die die sektoren zählt ein short ist (MMC_MAX_CLUSTERS_IN_ROW*fat.secPerClust) !!

40

  #define MMC_MAX_CLUSTERS_IN_ROW 256   // gibt an wie viele cluster am stück ohne fat-lookup geschrieben bzw gelesen werden können, wenn die fat nicht fragmentiert ist !

41

42

  // wenn "#define INLINE inline" dann werden die statischen funktionen inline kompiliert. macht code groeßer, aber auch schneller!

43

  //#define INLINE inline

44

  #define INLINE

45

46

47

  //#####################################################################################

48

  // SPI EINSTELLUNGEN

49

50

  // wenn MAX_SPEED FALSE dann wird die SPI bus geschwindigkeit nicht hoch gesetzt. ist zum testen von hardware die nicht richtig läuft

51

  #define MMC_MAX_SPEED     TRUE

52

  #define MMC_STATUS_INFO   FALSE

53

54

  // software spi? wenn TRUE muessen in der mmc.h noch die pins eingestellt werden über die die spi kommunikation laufen soll

55

  // es werden nur pins an einem port unterstuetzt !

56

  #define MMC_SOFT_SPI   FALSE

Schönen Gruß!

Hast du eine Idee, woran mein Problem liegen könnte, Daniel?


Gruß Sven

Hallo.

Leider habe ich momentan keine Zeit wegen dem blöden Weihnachten.
Werde aber kommende Woche dazu kommen mir das alles anzuschauen und die 
Probleme zu beheben.

Viele Grüße

Daniel

docean schrieb:
> Version 0.5.9 tut!

Interessant, ich habe aber in der zwischenzeit schon einen Workaround 
gefunden. Mit der Funktion ffwrites() läuft es weil fat.bufferDirty = 
TRUE gesetzt wird. Als habe ich mir eine kleine Funktion hingepfuscht 
die das auch nach dem normalen ffwrite() erledigt. Aber mir schwant es 
schon, so elegant ist das nicht ;)
Vielleicht hilft es ja bei der Fehlersuche. Schönen Feiertag noch

Hallo Daniel,
mir ist etwas merkwürdiges aufgefallen:

Ich schreibe zuerst 10kB in die Datei. Dann schließe ich sie, öffne sie 
erneut und hänge nochmal 10kB hintendran.

Win XP zeigt dann auch den richtigen Inhalt mit 20kB an. Wenn ich chkdsk 
laufen lasse werden aber Fehler korrigiert und die Datei hat danach 
24kB!

Mega32 @ 8MHz, 5V

Guten Rutsch!

Mfg,
Kurt

Teste gerade die Lib mit verschiedenen Karten.
Bis jetzt funktionieren:
- Sandisk Sd-Card 2 GB
- Kingston SD-Card 256 MB
- Hama SD-Card 256 MB
- Sandisk Mikro-SD 2GB
- Sandisk Mobile Ultra Micro-SDHC 4GB

Mit Verzeichnisse anlegen habe ich noch nichts gemacht. Mir ging es erst 
einmal um das Speichern und Lesen von Daten.

Gruß Gerd

Hallo,
erstmal Danke für die gute Arbeit. Ich teste seit ein paar Tagen die 
Version 0.6.1 mit einem mega644. Leider läuft die main_simple.c nur dann 
durch, wenn ich den µC resete.
Schaltet man VCC aus und wieder ein bleibt das Programm in der 
fat_loadFatData(); hängen und zwar beim ersten Aufruf von 
loop_until_bit_is_set(SPSR,SPIF);" in der mmc_write_byte Funktion 
(mmc.c).
Was ich schon getestet habe:
- Verzögerung mit  _delay_ms --> ohne Erfolg
- Verschiedene 1 GB sd-Karten --> ohne Erfolg
- Brummspannung auf VCC < 20 mV (Die ganze Schaltung inkl. µC läuft mit 
3,3 V)
Ich glaube nicht, dass es ein Hardwareproblem ist.
Komisch ist, dass vor "fat_loadFatData();" noch die mmc_init(); 
problemlos aufgerufen wird, ohne das das Programm in mmc_write_byte fest 
hängt?!

Vielleicht könnt Ihr mir einen Tipp geben, was ich noch versuchen kann, 
damit die main_simple.c direkt durchläuft.
Danke.
Gruß
Andi

Hallo zusammen,
ich bin da gerade immer mal wenn ich etwas Zeit habe dran am arbeiten.

Ich habe jetzt einen stm32 mit jtag Debugger, damit arbeitet sich 
wesentlich leichter als mit einem avr und Debug Ausgaben über die 
Konsole :)

Was wohl auf jeden Fall geändert werden wird, sind die Delay schleifen 
in der mmc.c, die werden auf einen Timer umgestellt werden müssen.

Die Initialisierung der Karten wird auch geändert sowie der Ablauf von 
den schreibe und lese Funktionen. Also quasi der ganze Unterbau wird 
geändert. Zudem noch die Datei öffnen Funktion.

Bitte um etwas Geduld...habe bald Semesterferien, die letzten :) da wird 
das wohl spätestens was werden....

Viele Grüße

Daniel

Hallo.

>wenn Du das Timing auf einen Timer umstellst

Genau da ist beispielsweise einer der Bugs. So eine Karte genehmigt sich 
schon mal bis zu 200 ms um Daten zu speichern oder um einen Block zu 
lesen. Da rasselt man dann einfach aus den warte Schleifen raus, 
zumindest so wie die momentan sind.

Ich hab mir das so vorgestellt, dass man einfach eine bestimmte Funktion 
im 10 ms Takt aufrufen muss.
Im Beispielcode würde ich dann ein Timer Beispiel machen, wie das dann 
letztendlich in einem eigenen Projekt umgesetzt wird muss dann jeder 
selber schauen...

Grüße

Daniel

Hallo,
es wird die Tage die AVR Version geben.
Jo, das ist für einen STM32 momentan.
Sollte jetzt keine finale Version sein.

Viele Grüße

Daniel