sd-Karten, Sektoren, Cluster

[Grundschüler (Gast)]

noch einige Fragen zu Elm chans Fat:

Ich habe eine Datei mit 300k Byte angelegt.
Anfangssektor ist 339792

Die link-table sagt 74 Cluster hintereinander + Startcluster 38669.

Ich gehe davon aus, dass der Sektor ohne Offset von Beginn der Karte 
zählt?

Wie ist das mit den Clustern? Ich nehme an, 8 Sektoren ergeben einen 
Cluster. Woher kommt dann der Offset von den Clustern gegenüber den 
Sektoren? Woher weiß man bei fragmentierten Dateien, mit welchem Sektor 
eines Clusters anzufangen ist?

sector ist bei Chan ein 32bit-Wert. Wie wird der 33bit-Bereich der Karte 
angesprochen?

[holger (Gast)]

Such nach fatgen103.pdf. Da steht alles drin was du wissen musst.

[c-hater (Gast)]

Grundschüler schrieb:

> noch einige Fragen zu Elm chans Fat:

Das ist schon das erste grundlegende Problem, was du hast: Es ist nicht 
Elm chans FAT. Sondern das von Microsoft. Elm hat's bloß implementiert. 
Zum tausendsten(?) Mal.

> Ich gehe davon aus, dass der Sektor ohne Offset von Beginn der Karte
> zählt?

Schon falsch. Gerechnet wird vom Beginn der Partition (sofern es eine 
gibt, was der Normalfall ist). Nur wenn die Karte als "Superfloppy" 
formatiert ist, stimmt der Nullpunkt der Kartenadresse mit dem Nullpunkt 
des Filesystems überein.

> Wie ist das mit den Clustern? Ich nehme an, 8 Sektoren ergeben einen
> Cluster.

Nur dann, wenn das entsprechende Feld des Headers das so sagt. Das ist 
ein variabler Wert. Nichtmal für eine Karte konstanter Größe zwingend 
konstant. Man kann es durch Neu"formatieren" ändern.

> Woher kommt dann der Offset von den Clustern gegenüber den
> Sektoren?

Partitionierung. Das Filesystem beginnt einfach nicht am physikalischen 
Beginn des Mediums.

> Woher weiß man bei fragmentierten Dateien, mit welchem Sektor
> eines Clusters anzufangen ist?

Immer beim ersten. Genau das ist doch die Idee des Clustering: 
Verwaltungseinheiten vergrößern, um Verwaltungsinformationen kleiner 
halten zu können.

Wie wäre es, wenn du erstmal lernst, wie FAT funktioniert, bevor du dich 
mit Code auseinandersetzt, der FAT implementiert?

[Grundschüler (Gast)]

Danke für die konstruktiven Antworten. Das Problem ist, dass ich einen 
großen Teil des Grundlagenwissens außen vor lassen muss, weil ich sonst 
mit meinem Code nicht weiterkomme. Es läuft viel über Versuch und 
Irrtum, aber es läuft dann meist auch irgendwie. Mein Programm schreibt 
inzwischen mittels DMA Blöcke an die richtige Stelle einer Datei, so 
dass man die Datei anschließend mit MS-Chan-Fat-Implementierung - oder 
wie auch immer das richtig bezeichnet wird - auslesen kann.

Damit ist meine Aufgabenstellung bzgl. SD+DMA im Prinzip gelöst, es muss 
nur noch in das Hauptprogramm eingebunden werden.

letzte dumme Frage hierzu: Ist die Anzahl der 512Byte-Blöcke, die mit 
einem cmd25 geschrieben werden können nach oben begrenzt?

[Falk B. (falk)]

@Grundschüler (Gast)

>Danke für die konstruktiven Antworten. Das Problem ist, dass ich einen
>großen Teil des Grundlagenwissens außen vor lassen muss, weil ich sonst
>mit meinem Code nicht weiterkomme.

:-)
Das ist der Brüller des Tages.

> Es läuft viel über Versuch und
>Irrtum, aber es läuft dann meist auch irgendwie.

Aber nie solide und stabil. Eben WEIL dein Grundlagenwissen viel zu dünn 
ist.

>Damit ist meine Aufgabenstellung bzgl. SD+DMA im Prinzip gelöst,

Nö. Deine Zielstellung war ja, parallel zum laufenden Programm die Daten 
per DMA und INterruptsteuerung zu schreiben. Das macht dein Programm 
Afaik NICHT. Was man tun muss habe ich mehrfach gesagt.

>es muss nur noch in das Hauptprogramm eingebunden werden.

Wo ist dann das Problem?

>letzte dumme Frage hierzu: Ist die Anzahl der 512Byte-Blöcke, die mit
>einem cmd25 geschrieben werden können nach oben begrenzt?

Keine Ahnung, AFAIK setzt FatFs eine Grenze bei 128 Sektoren. OB die 
SD-Karten mehr können weiß ich nicht.

[Grundschüler (Gast)]

Falk Brunner schrieb:
> Nö. Deine Zielstellung war ja, parallel zum laufenden Programm die Daten
> per DMA und INterruptsteuerung zu schreiben. Das macht dein Programm
> Afaik NICHT. Was man tun muss habe ich mehrfach gesagt.

???????

v u32 DMATCCount=0,DMAErrCount,DMA_STATUS,zl_bsy_rpt, blocks, cmd_token,speedtest;

void DMA_IRQHandler(void)
{
  uint32_t regVal, x=0,tmp;
  regVal = LPC_GPDMA->DMACIntStat;
  if ( regVal ){//not error
   DMATCCount++;
  LPC_GPDMA->DMACIntTCClear = regVal;

  switch(DMA_STATUS){
  case 0://ready abfrage
//    buf_rx[0]=xchg_spi(0xFF);        // Receive data resp 0xe5
/*    do
    {tmp=xchg_spi(0xFf);
    buf_rx[10+x]=tmp;
    x++;
    }
      while(tmp!=255);
    if(buf_rx[0]!=255){
      DMA3_transfer_from_SSP0_to_buffer(16);
      return;
    }else{//512 Databytes
      zl_bsy_rpt=DMATCCount;
//      xchg_spi(0xfc);//token_cmd25
      DMA_STATUS = 1;
      xchg_spi(cmd_token);//token_cmd24
      DMA0_512bytes_transfer_to_SSP0(0,512); //buffer_offset,Anzahl_bytes
//    }
*/  break;
  case 1://2xcrc
    DMA_STATUS = 2;
    DMA2_transfer_from_buffer_to_SSP0(3);//ohne 2 x crc keine response
    break;
  case 2://"fifo leeren + response"
    DMA_STATUS = 3;// Receive data resp (0xe5&0x1F)==0x05
    DMA3_transfer_from_SSP0_to_buffer(9);//8x rxfifo leeren + 1x Response abfragen
    break;
  case 3://busy-abfrage 8xtx
  tmp=buf_rx[8];

  do
  {tmp=xchg_spi(0xFf);
  buf_rx[10+x]=tmp;
  x++;
  }
    while(tmp!=255);
 /* DMA_STATUS = 4;
    DMA2_transfer_from_buffer_to_SSP0(8);
  case 4://busy-abfrage 8xRx
    DMA_STATUS = 5;
    DMA3_transfer_from_SSP0_to_buffer(8);
    break;
  case 5://busy-abfrage auswertung
    if(buf_rx[7]=!255){
    DMA_STATUS = 4;
    DMA2_transfer_from_buffer_to_SSP0(8);
    break;
    }else{
    DMA_STATUS = 6;
    }
  case 6://next
*/    if(cmd_token==0xfe)break;
    if(blocks--){
    DMA_STATUS = 1;
    xchg_spi(cmd_token);//token_cmd24
    DMA0_512bytes_transfer_to_SSP0(0,512); //buffer_offset,Anzahl_bytes
    }else{
    xchg_spi(0xFd);  //cmd25 stoptoken
    speedtest = TimeTick;
    }

    break;

  }//switch
  }else{

  regVal = LPC_GPDMA->DMACIntErrStat;
  if ( regVal )
  {
  DMAErrCount++;
  LPC_GPDMA->DMACIntErrClr = regVal;
  }
  }
  return;
}

macht es doch, Schreibvorgang läuft im Hintergrund, nur per DMA + 
Interrupt. Getestet mit 20k Daten. Problemlos und fehlerfrei. Ziel sind 
600k Daten.
  do
  {tmp=xchg_spi(0xFf);
  buf_rx[10+x]=tmp;
  x++;
  }
  while(tmp!=255);

Diesen Teil habe ich noch nicht auf DMA umgestellt, weil nennenswerte 
Wartezeiten bislang nicht aufgetreten sind.
Ein einzelner Aufruf von tmp=xchg_spi(0xFf) ist kürzer als der Aufruf 
der DMA

Sollte es hier zu mehreren Schleifendurchläufen kommen, wird auch dies 
durch per DMA ausgelagert.