Auslesen einer SD-Karte mit AVR

[Daniel K. (daniel_k80)]

Hallo zusammen,

ich schreibe mir gerade eine Bibliothek um mit einem AVR SD-Karten zu 
Schreiben und zu Lesen. Dazu habe ich zwei Fragen...

1)
Die Initialisierung der SD-Karte funktioniert auch soweit bei meinen 
beiden 4 GB Karten. Bei meiner alten 512 MB Karte klappt die 
Initialisierung nicht. Da würde ich gerne wissen warum (auch wenn es 
nicht wirklich wichtig ist...). Und zwar bekomme ich bei der Funktion 
"SD_SoftwareReset" immer ein "NO_RESPONSE" zurück, sprich die Karte 
reagiert nicht auf das Commando 0.

2)
Nachdem die Karte (jetzt meine 4 GB Karte) initialisiert worden ist, 
möchte ich gerne Sektor 0 auslesen. Dazu habe ich mir mit HxD den Sektor 
mal angeschaut (siehe Bild SD.png). Wenn ich die Karte nun mit dem AVR 
lese steht in meinem Buffer überall 0 drin und das obwohl die Karte 
problemlos durchläuft (ich erhalte nach dem Lesebefehl erst ein 0x00 und 
dann ein 0xFE).

Mein Code sieht so aus:

SD.c

SD_Error_t Status = SD_InitInterface(Config);
SD_ReadSingleBlock(0x00);  
  
return Status;

SD_Interface.c

static SD_CardType_t CardType = SD_VER_UNKNOWN;

SD_Error_t SD_InitInterface(SPI_Config_t* Config)
{  
  SD_Error_t ErrorCode = SD_SUCCESSFULL;
  
  // Set SD card CS as output in high state
  GPIO_SetDirection(SD_SS_PORT, SD_SS_PIN, GPIO_DIRECTION_OUT);
  GPIO_Set(SD_SS_PORT, SD_SS_PIN);
  
  if(Config != NULL)
  {
    SD_SPI_INIT(Config);
  }

  // Reset the SD card
  ErrorCode = SD_SoftwareReset();
  if(ErrorCode != SD_SUCCESSFULL)
  {
    return ErrorCode;
  }
  
  // Initialize the SD card
  ErrorCode = SD_InitializeCard();
  if(ErrorCode != SD_SUCCESSFULL)
  {
    return ErrorCode;
  }
  
  // Set the block length to 512 (only necessary if the card is not a SDXC or SDHX card) 
  if((CardType != SD_VER_2_HI) & (CardType != SD_VER_2_STD))
  {
    ErrorCode = SD_SetBlockLength(SD_BLOCK_SIZE);
    if(ErrorCode != SD_SUCCESSFULL)
    {
      return ErrorCode;
    }
  }
    
  return ErrorCode;
}

uint8_t SD_Command(uint8_t Command, uint32_t Arg, uint8_t Checksum, uint32_t Count, uint8_t* Buffer)
{
  // Create 8 clock pulse before activating the card
  SD_SPI_TRANSMIT(0xFF);
  SD_SPI_CHIP_SELECT(SD_SS_PORT, SD_SS_PIN);
  SD_SPI_TRANSMIT(Command);
  SD_SPI_TRANSMIT(Arg >> 0x18);
  SD_SPI_TRANSMIT(Arg >> 0x10);
  SD_SPI_TRANSMIT(Arg >> 0x08);
  SD_SPI_TRANSMIT(Arg);
  SD_SPI_TRANSMIT(Checksum);
  
  /*  
  Wait for the response (0 - 8 bytes for SD cards and 1 - 8 bytes for MMC)
  The spec also say that you have to wait 8 clock cycles after the last bus
  transaction.
  */      
  for(uint8_t i = 0; i < 0x08; i++)
  {
    uint8_t DataIn = SD_SPI_TRANSMIT(0xFF);
    if(DataIn != 0xFF)
    {
      // Read all additional data
      if(Count > 0)
      {
        for(uint32_t j = 0x01; j < Count; j++)
        {
          *Buffer++ = SD_SPI_TRANSMIT(0xFF);
        }
      }
      
      // Send a dummy byte and deselect the card after it
      SD_SPI_TRANSMIT(0xFF);
      SD_SPI_CHIP_DESELECT(SD_SS_PORT, SD_SS_PIN);

      return DataIn;
    }
  }
  
  SD_SPI_CHIP_DESELECT(SD_SS_PORT, SD_SS_PIN);
  
  return SD_NO_RESPONSE;
}

SD_Error_t SD_SoftwareReset(void)
{
  uint8_t Repeat = 0x00;
  
  SD_SPI_CHIP_SELECT(SD_SS_PORT, SD_SS_PIN);
  
  for(uint8_t i = 0x00; i < 0x0A; i++)
  {
    SD_SPI_TRANSMIT(0xFF);
  }
  
  SD_SPI_CHIP_DESELECT(SD_SS_PORT, SD_SS_PIN);
  
  while(SD_Command(SD_ID_TO_CMD(0), 0x00000000, 0x95, 0, 0) != SD_STATE_IDLE)
  {
    // Initialization failed
    if(Repeat++ == 10)
    {
      return SD_NO_RESPONSE;
    }
  }
  
  return SD_SUCCESSFULL;
}

SD_Error_t SD_InitializeCard(void)
{
  uint16_t Wait = 0x00;
  uint32_t R3 = 0x00;
  uint8_t R1 = 0xFF;
  uint8_t Buffer[4];
  
  R1 = SD_Command(SD_ID_TO_CMD(8), 0x000001AA, 0x87, 4, Buffer);
  if(R1 == SD_STATE_IDLE)
  {
    /*
      Version 2 SD card
    */

    R3 = ((uint32_t)Buffer[3]) << 0x18;
    R3 |= ((uint32_t)Buffer[2]) << 0x10;
    R3 |= ((uint32_t)Buffer[1]) << 0x08;
    R3 |= ((uint32_t)Buffer[0]);
    /*
    if(R3 != 0x000001AA)
    {
      return SD_UNSUPPORTED_CARD;
    }*/
    
    // Send ACMD41 and check for ready
    R1 = 0xFF;
    while((++Wait < 0x2710) & (R1 != SD_STATE_SUCCESSFULL))
    {
      SD_Command(SD_ID_TO_CMD(55), 0x00000000, 0x00, 0, 0);
      R1 = SD_Command(SD_ID_TO_CMD(41), 0x40000000, 0x00, 0, 0);
    }
    
    if((Wait >= 0x2710) | (R1 != SD_STATE_SUCCESSFULL))
    {
      return SD_TIMEOUT;
    }
    
    // Send CMD58 to read OCR
    R1 = SD_Command(SD_ID_TO_CMD(58), 0x00000000, 0x00, 4, Buffer);
    if(R1 == SD_STATE_SUCCESSFULL)
    {
      R3 = ((uint32_t)Buffer[3]) << 0x18;
      R3 |= ((uint32_t)Buffer[2]) << 0x10;
      R3 |= ((uint32_t)Buffer[1]) << 0x08;
      R3 |= ((uint32_t)Buffer[0]);
    }
    else
    {
      CardType = SD_VER_UNKNOWN;
    }
    
    // Check if the CCS bit is set
    if(R3 & 0x40000000)
    {
      CardType = SD_VER_2_HI;
    }
    else
    {
      CardType = SD_VER_2_STD;
    }
  }
  else
  {
    /*
      Version 1 SD card or MMC
    */
    
    // Check for version 1 SD card
    Wait = 0x00;
    while(++Wait < 0xFF) 
    {
      SD_Command(SD_ID_TO_CMD(55), 0x00000000, 0, 0, 0);
      R1 = SD_Command(SD_ID_TO_CMD(41), 0x00000000, 0, 0, 0);
      if(R1 == SD_STATE_SUCCESSFULL)
      {
        CardType = SD_VER_1_STD;
        break;
      }
    }
    
    // Check for multimedia card
    Wait = 0x00;
    if(R1 & SD_STATE_ILLEGAL_COMMAND)
    {
      while(++Wait < 0xFF)
      {
        R1 = SD_Command(SD_ID_TO_CMD(1), 0x00000000, 0, 0, 0);
        if(R1 == SD_STATE_SUCCESSFULL) 
        {
          CardType = SD_MMC;
          break;
        }
      }
    }
  }
  
  return SD_SUCCESSFULL;
}

uint8_t SD_SetBlockLength(uint32_t BlockLength)
{
  return SD_Command(SD_ID_TO_CMD(16), 0x00000200, 0xFF, 0, 0);
}

uint8_t SD_ReadSingleBlock(uint32_t Address)
{
  uint8_t R1 = 0x00;
  uint16_t Wait = 0x00;
  uint32_t Offset = 0x00;
  uint32_t Len = 10;
  uint8_t Buffer[512];
  uint8_t Sector = 0x00;

  SD_SPI_TRANSMIT(0xFF);
  SD_SPI_CHIP_SELECT(SD_SS_PORT, SD_SS_PIN);
  SD_SPI_TRANSMIT(SD_ID_TO_CMD(17));
  SD_SPI_TRANSMIT(Sector >> 15);
  SD_SPI_TRANSMIT(Sector >> 7);
  SD_SPI_TRANSMIT(Sector << 1);
  SD_SPI_TRANSMIT(0x00);
  SD_SPI_TRANSMIT(0xFF);
    
  // Wait for 0x00
  R1 = 0xFF;
  while((++Wait < 0x2710) & (R1 != SD_STATE_SUCCESSFULL))
  {
    R1 = SD_SPI_TRANSMIT(0xFF);
  }
  
  if((Wait >= 0x2710) | (R1 != SD_STATE_SUCCESSFULL))
  {
    return SD_TIMEOUT;
  }

  // Wait for 0xFE
  Wait = 0x00;
  R1 = 0xFF;
  while((++Wait < 0x2710) & (R1 != SD_STATE_BEGIN_TRANSMISSION))
  {
    R1 = SD_SPI_TRANSMIT(0xFF);
  }
  
  if((Wait >= 0x2710) | (R1 != SD_STATE_BEGIN_TRANSMISSION))
  {
    return SD_TIMEOUT;
  }

    for(uint32_t i = 0x00; i < Offset; i++)
  {
    SD_SPI_TRANSMIT(0xFF);
  }
        
  for(uint32_t i = 0x00; i < Len; i++)
  {
    Buffer[i] = SD_SPI_TRANSMIT(0xFF);
  }

     for(uint32_t i = 0x00; i < 512 - Offset; i++)
  {
    SD_SPI_TRANSMIT(0xFF);
  }
        
    SD_SPI_TRANSMIT(0xFF);
    SD_SPI_TRANSMIT(0xFF);    

    SD_SPI_CHIP_DESELECT(SD_SS_PORT, SD_SS_PIN);;
  
  uint8_t T = 0x00;
  
  return T;
}

Vielen Dank :)

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Daniel K. schrieb:
> Mein Code sieht so aus:
Zwei Tipps dazu aus der Anleitung, die über jeder Texteingabebox steht:
1.

Antwort schreiben
Wichtige Regeln - erst lesen, dann posten!
    Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

2.

Formatierung (mehr Informationen...)
    [c]C-Code[/c]

Den zweiten habe ich jetzt mal umgesetzt...

[S. Landolt (Gast)]

zu 1): 512 MB ist SDC, 4 GB ist SDHC; die Initialisierung ist 
unterschiedlich, ebenso die Adressierung

zu 2): kann/will ich nichts sagen, ist mir zuviel Programm; sollte ich 
eine Vermutung äußern, würde ich auf falsche Adressierung tippen

[Dr. Sommer (Gast)]

Sehe ich da mkdosfs? SD-Karten darf man nur mit dem Tool von sdcard.org 
formatieren, da dies die spezifischen Anforderungen von SD-Karten beim 
Layout beachtet

Daniel K. schrieb:
> Die Initialisierung der SD-Karte funktioniert auch soweit bei meinen
> beiden 4 GB Karten. Bei meiner alten 512 MB Karte klappt die
> Initialisierung nicht.

Dass diese beiden Karten eine komplett andere Initialisierung sowie 
Adressierung benutzen ist dir klar (SDSC vs. SDHC)?

[Daniel K. (daniel_k80)]

Lothar M. schrieb:
> Daniel K. schrieb:
>> Mein Code sieht so aus:
> Zwei Tipps dazu aus der Anleitung, die über jeder Texteingabebox steht:
> 1.
>

> Antwort schreiben
> Wichtige Regeln - erst lesen, dann posten!
>     Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang
>

> 2.
>

> Formatierung (mehr Informationen...)
>     [c]C-Code[/c]
>

> Den zweiten habe ich jetzt mal umgesetzt...

Mmh ich wollte gerade den Beitrag ändern, aber es gab ein Fehler. 
Vermutlich ist die Zeit zum ändern abgelaufen. Ich hänge die Dateien mal 
hier an die Antwort. Vielleicht kann ein Moderator die verschieben?

Dr. Sommer schrieb:
> Sehe ich da mkdosfs? SD-Karten darf man nur mit dem Tool von sdcard.org
> formatieren, da dies die spezifischen Anforderungen von SD-Karten beim
> Layout beachtet
>
> Daniel K. schrieb:
>> Die Initialisierung der SD-Karte funktioniert auch soweit bei meinen
>> beiden 4 GB Karten. Bei meiner alten 512 MB Karte klappt die
>> Initialisierung nicht.
>
> Dass diese beiden Karten eine komplett andere Initialisierung sowie
> Adressierung benutzen ist dir klar (SDSC vs. SDHC)?

Die SD-Karte stammt aus einem anderen Projekt. Ich glaube da ist noch 
ein u-boot Bootloader drauf. Ich habe die vor den Versuchen nicht 
formatiert, da ich die nur lesen wollte und es mir gerade recht kam, 
wenn da noch was drauf ist.

Das die Initialisierung bei beiden Karten anders ist, ist mir durchaus 
klar. Aber betrifft dies auch den Reset, den man ganz am Anfang macht, 
sprich 80 Taktzyklen erzeugen und dann das Commando 0 senden? Ich bin 
bisher davon ausgegangen, dass das bei allen Kartentypen gleich ist 
(siehe hier 
https://electronics.stackexchange.com/questions/77417/what-is-the-correct-command-sequence-for-microsd-card-initialization-in-spi)

Die 512 MB Karte antwortet schon gar nicht auf diesen Block

ErrorCode = SD_SoftwareReset();
if(ErrorCode != SD_SUCCESSFULL)
{
  return ErrorCode;
}

Soweit ich verstanden habe adressiere ich bei SDHC-Karten ganze Blöcke. 
Dafür verwende ich den Befehl 17 und adressiere den Sektor 0. Oder habe 
ich da was falsch verstanden?

[S. Landolt (Gast)]

'SD_SoftwareReset': Bei diesen Dummy-FFs zu Beginn muss die SDC doch 
deselektiert sein, oder habe ich das falsch in Erinnerung?

'SD_ReadSingleBlock': Sector als uint8_t?

[Daniel K. (daniel_k80)]

S. Landolt schrieb:
> 'SD_SoftwareReset': Bei diesen Dummy-FFs zu Beginn muss die SDC doch
> deselektiert sein, oder habe ich das falsch in Erinnerung?
>
> 'SD_ReadSingleBlock': Sector als uint8_t?

Stimmt. Du hast recht. Hab beides korrigiert, aber das Problem ist nach 
wie vor vorhanden.

[S. Landolt (Gast)]

Nicht mal am 512 MB-Kartenproblem hat sich etwas geändert? Schlecht.

Nochmal zu 'SD_ReadSingleBlock', auch wenn es mit dem Sektor-0-Problem 
nicht direkt etwas zu tun hat: mir ist, als Assemblerprogrammierer, die 
ganze Konstruktion unklar, da wird 'Adresse' übergeben, aber nicht 
weiterverwendet, 'Sector' ist 0 und wird dann in einer Weise 
rechts/links verschoben, die ich auch nicht verstehe, sieht irgendwie so 
aus, als wäre es für eine SDC, nicht für eine SDHC gedacht.

[Daniel K. (daniel_k80)]

S. Landolt schrieb:
> Nicht mal am 512 MB-Kartenproblem hat sich etwas geändert? Schlecht.
>
> Nochmal zu 'SD_ReadSingleBlock', auch wenn es mit dem Sektor-0-Problem
> nicht direkt etwas zu tun hat: mir ist, als Assemblerprogrammierer, die
> ganze Konstruktion unklar, da wird 'Adresse' übergeben, aber nicht
> weiterverwendet, 'Sector' ist 0 und wird dann in einer Weise
> rechts/links verschoben, die ich auch nicht verstehe, sieht irgendwie so
> aus, als wäre es für eine SDC, nicht für eine SDHC gedacht.

Hallo,

mit der 512 MB Karte habe ich es nicht getestet. Das mache ich im Laufe 
des Tages mal. Ggf. hat sich das Problem dann gelöst...
Die Sektoren habe ich erst einmal fest kodiert, da ich das Lesen erst 
einmal ausprobieren wollte. Daher habe ich die Werte erst nur in der 
Funktion definiert. Die Übergabeparameter sollen später anders aussehen. 
Aber ich schaue mir gleich noch mal das Schieben an. Ggf. habe ich mich 
da vertan...

[S. Landolt (Gast)]

Jetzt bin ich irritiert: wenn ich das c-Programm richtig verstehe, lesen 
Sie im Sektor 0 ab Adresse 0x1BF in den Buffer 10 Bytes ein - woher 
sollen wir wissen, was dort  steht, das eingangs gezeigte SD.png reicht 
nicht so weit.

[Daniel K. (daniel_k80)]

S. Landolt schrieb:
> Jetzt bin ich irritiert: wenn ich das c-Programm richtig verstehe, lesen
> Sie im Sektor 0 ab Adresse 0x1BF in den Buffer 10 Bytes ein - woher
> sollen wir wissen, was dort  steht, das eingangs gezeigte SD.png reicht
> nicht so weit.

Hallo,

den Code hatte ich nach dem ersten Beitrag noch modifiziert und vor dem 
Upload auf die ursprüngliche Version zurück geändert. Dieser Wert ist 
mir leider durchgegangen. Selbstverständlich muss der Wert 0x00 sein, 
damit es zum gezeigten Screenshot passt (tatsächlich ist auf der 
SD-Karte an der Stelle 0x1BF 0x00...).

[S. Landolt (Gast)]

Und wie sieht nun unsere derzeitige gemeinsame Basis, sprich das 
aktuelle Programm, aus?

[S. Landolt (Gast)]

PS:
Wie und wo nehmen Sie Einblick in diesen Buffer?

[Daniel K. (daniel_k80)]

S. Landolt schrieb:
> Und wie sieht nun unsere derzeitige gemeinsame Basis, sprich das
> aktuelle Programm, aus?

Hallo,

ich habe den aktuellen Code mit einem neuen Bild angehängt.
Stand ist der, dass mit dem aktuellen Code und der gezeigten SD-Karte
nichts in der lokalen Variable "Buffer" der "SD_ReadSingleBlock"
Funktion steht.
Die SD-Karte hat zwei Partitionen - eine FAT (siehe Screenshot) und eine
Ext3, wobei die FAT-Partition den Bootbefehl enthält, daher dürfte diese
Partition ja den Anfang des Speichers der Karte darstellen.

Ausgelesen habe ich den Buffer mittels JTAG (siehe Bild "JTAG.png"). Die
Funktion "SD_InitInterface()" gibt ein Successfull zurück und auch das
0x00 und 0xFE nach dem Kommando 17 wird empfangen.

Edit: Alten Beitrag gelöscht, da ich dort eine Datei mehrfach 
hochgeladen hatte und das falsch war.

[Kartenkurt (Gast)]

Wie sieht der komplette Sektor 0 aus?

[Daniel K. (daniel_k80)]

Kartenkurt schrieb:
> Wie sieht der komplette Sektor 0 aus?

Siehe Bild.

[Jim M. (turboj)]

Daniel K. schrieb:
> Siehe Bild.

Meep, falsch.
Das ist der Sektor 0 der ersten Partition ("Laufwerksbuchstabe G:") in 
Windoof. Sieht man an dem ganzen FAT16 gelumpe.

Der echte Sektor 0 hat in der Tat eine Menge Nullen am Anfang, und 
erst ziemlich weit hinten die eigentliche Partitionstabelle drin. Schau 
Dir mal die letzten 100 Byte an.

Den Sektor kann man unter Windows aber nur mit Admin-Rechten von der 
"physichen Disk" lesen. HXD muss dafür "als Administrator" ausgeführt 
werden IIRC.

[S. Landolt (Gast)]

Sollte man nicht, um hier klare Verhältnisse zu schaffen, eine Karte 
'raw', also z.B. mit Win32DiskImager eine reine Textdatei, beschreiben? 
Die Karte lässt sich ja später wieder problemlos formatieren zur 
normalen Verwendung.

[Daniel K. (daniel_k80)]

Jim M. schrieb:
> Daniel K. schrieb:
>> Siehe Bild.
>
> Meep, falsch.
> Das ist der Sektor 0 der ersten Partition ("Laufwerksbuchstabe G:") in
> Windoof. Sieht man an dem ganzen FAT16 gelumpe.
>
> Der echte Sektor 0 hat in der Tat eine Menge Nullen am Anfang, und
> erst ziemlich weit hinten die eigentliche Partitionstabelle drin. Schau
> Dir mal die letzten 100 Byte an.
>
> Den Sektor kann man unter Windows aber nur mit Admin-Rechten von der
> "physichen Disk" lesen. HXD muss dafür "als Administrator" ausgeführt
> werden IIRC.

Ahhhhhhh okay. Dann habe ich da wohl was ganz gewaltig missverstanden. 
Ich probier das nachher mal an einem anderen PC aus, weil ich an diesem 
PC selbst mit Adminrechte nicht genug Rechte habe um mir das in HxD 
anzuschauen (Windows halt ^^).

[Dr. Sommer (Gast)]

Daniel K. schrieb:
> weil ich an diesem
> PC selbst mit Adminrechte nicht genug Rechte habe um mir das in HxD
> anzuschauen (Windows halt ^^).

Starte HxD als Admin. Bei mir hat das selbst unter Win10 immer 
funktioniert.

[Daniel K. (daniel_k80)]

Dr. Sommer schrieb:
> Daniel K. schrieb:
>> weil ich an diesem
>> PC selbst mit Adminrechte nicht genug Rechte habe um mir das in HxD
>> anzuschauen (Windows halt ^^).
>
> Starte HxD als Admin. Bei mir hat das selbst unter Win10 immer
> funktioniert.

Hier geht das leider nicht (FH-PC) :(
Muss ich gleich Zuhause machen...

[Daniel K. (daniel_k80)]

Hallo zusammen,

so ich habe mir mal den physischen Datenträger angeschaut und einen 
Ausschnitt davon hochgeladen.
Zudem habe ich den Offset auf 0x1B8 geändert. Allerdings lese ich 
immernoch nur 0x00 aus -.-

Und zudem funktioniert die 512 MB Karte mit dem gezeigten Code noch 
nicht, aber das Problem ist erst einmal sekundär. Die Anmerkung war nur 
als Update zur vorherigen Antwort.

[holger (Gast)]

>Allerdings lese ich
>immernoch nur 0x00 aus -.-

Ich sehe mehr als nur Nullen. Ab 1B8 könnte eine Partitionstabelle sein 
und das 55AA am Ende sieht auch gut aus für Sektor 0.

[holger (Gast)]

>Allerdings lese ich
>immernoch nur 0x00 aus -.-

Ach verdammt, du meinst mit dem AVR;)

>Zudem habe ich den Offset auf 0x1B8 geändert.

Lass das, nimm Null.

[Daniel K. (daniel_k80)]

Hab den Offset nun mal raus geworfen und den Code für die Funktion 
geändert

  uint8_t R1 = 0x00;
  uint16_t Wait = 0x00;
  uint16_t Len = 512;
  uint8_t Buffer[512];

  SD_SPI_TRANSMIT(0xFF);
  SD_SPI_CHIP_SELECT(SD_SS_PORT, SD_SS_PIN);
  SD_SPI_TRANSMIT(SD_ID_TO_CMD(17));
  SD_SPI_TRANSMIT(0);
  SD_SPI_TRANSMIT(0);
  SD_SPI_TRANSMIT(0);
  SD_SPI_TRANSMIT(0x00);
  SD_SPI_TRANSMIT(0xFF);
    
  // Wait for 0x00
  R1 = 0xFF;
  while((++Wait < 0x2710) & (R1 != SD_STATE_SUCCESSFULL))
  {
    R1 = SD_SPI_TRANSMIT(0xFF);
  }
  
  if((Wait >= 0x2710) | (R1 != SD_STATE_SUCCESSFULL))
  {
    return SD_TIMEOUT;
  }

  // Wait for 0xFE
  Wait = 0x00;
  R1 = 0xFF;
  while((++Wait < 0x2710) & (R1 != SD_STATE_BEGIN_TRANSMISSION))
  {
    R1 = SD_SPI_TRANSMIT(0xFF);
  }
  
  if((Wait >= 0x2710) | (R1 != SD_STATE_BEGIN_TRANSMISSION))
  {
    return SD_TIMEOUT;
  }
        
  for(uint16_t i = 0x00; i < Len; i++)
  {
    Buffer[i] = SD_SPI_TRANSMIT(0xFF);
  }
        
    // skip checksum
    SD_SPI_TRANSMIT(0xFF);
    SD_SPI_TRANSMIT(0xFF);    

    SD_SPI_CHIP_UNSELECT(SD_SS_PORT, SD_SS_PIN);
  
  return;

Das komplette Array ist mit 0 gefüllt. :/
Ich verstehe nicht wo das Problem ist -.-

[S. Landolt (Gast)]

SD_Error_t SD_SoftwareReset(void)
{
  uint8_t Repeat = 0x00;
  
  //SD_SPI_CHIP_SELECT(SD_SS_PORT, SD_SS_PIN);
  
  for(uint8_t i = 0x00; i < 0x0A; i++)
  {
    SD_SPI_TRANSMIT(0xFF);
  }
  
  SD_SPI_CHIP_UNSELECT(SD_SS_PORT, SD_SS_PIN);
  
  while(SD_Command(SD_ID_TO_CMD(0), 0x00000000, 0x95, 0, 0) != SD_STATE_IDLE)

Vor dem CMD0 ein 'UNSELECT'? Verstehe ich nicht.

[Daniel K. (daniel_k80)]

S. Landolt schrieb:
> Vor dem CMD0 ein 'UNSELECT'? Verstehe ich nicht.

Das ist noch übrig geblieben, weil ich vorher das Select davor hatte 
(das Auskommentierte). Das ist im Grunde zu viel, macht aber auch nicht 
mehr als den Pin auf High zu lassen...

[S. Landolt (Gast)]

Das heißt, das CMD0 geht an der Karte vorbei?

[S. Landolt (Gast)]

Also falls Ihnen eine Vorlage fehlt, mit meiner Assembler-Bibliothek 
können Sie sicher nichts anfangen, aber hier habe ich etwas zu 
Vergleichszwecken, vor langer Zeit irgendwo aufgegabelt, ist wohl auch 
nur für SDC, nicht SDHC, aber vielleicht hilft es etwas.

[Daniel K. (daniel_k80)]

Nein. Der Pin ist High und wird noch einmal auf High gesetzt, bleibt 
also High, da er vorher nicht mehr auf Low gezogen wird. Die 
Initialisierung der 4 GB Karte funktioniert auch problemlos, es ist nur 
die 512 MB Karte die zickt.
Aber wie gesagt, ich würde gerne erst das Problem mit dem Lesen lösen. 
Die 512 MB Karte schaue ich mir dann mal im Detail an.

[S. Landolt (Gast)]

> Die Initialisierung der 4 GB Karte funktioniert auch problemlos

Pardon, mittlerweile habe ich da meine Zweifel. Z.B. wird ohne gesetztes 
SS das CMD0 von der Karte doch gar nicht gesehen.

[Daniel K. (daniel_k80)]

S. Landolt schrieb:
>> Die Initialisierung der 4 GB Karte funktioniert auch problemlos
>
> Pardon, mittlerweile habe ich da meine Zweifel. Z.B. wird ohne gesetztes
> SS das CMD0 von der Karte doch gar nicht gesehen.

Das SS wird in der Funktion "SD_Command(SD_ID_TO_CMD(0), 0x00000000, 
0x95, 0, 0)" gesetzt.
Das was überflüssig war, war das Selektieren und Deselektieren der 
SD-Karte bei den ersten 80 Taktzyklen nach einem Power-On Reset :)

uint8_t SD_Command(uint8_t Command, uint32_t Arg, uint8_t Checksum, uint32_t Count, uint8_t* Buffer)
{
  // Create 8 clock pulse before activating the card
  SD_SPI_TRANSMIT(0xFF);
  SD_SPI_CHIP_SELECT(SD_SS_PORT, SD_SS_PIN);
  SD_SPI_TRANSMIT(Command);
  SD_SPI_TRANSMIT(Arg >> 0x18);
  SD_SPI_TRANSMIT(Arg >> 0x10);
  SD_SPI_TRANSMIT(Arg >> 0x08);
  SD_SPI_TRANSMIT(Arg);
  SD_SPI_TRANSMIT(Checksum);
  
  /*  
  Wait for the response (0 - 8 bytes for SD cards and 1 - 8 bytes for MMC)
  The spec also say that you have to wait 8 clock cycles after the last bus
  transaction.
  */      
  for(uint8_t i = 0; i < 0x08; i++)
  {
    uint8_t DataIn = SD_SPI_TRANSMIT(0xFF);
    if(DataIn != 0xFF)
    {
      // Read all additional data
      if(Count > 0)
      {
        for(uint32_t j = 0x01; j < Count; j++)
        {
          *Buffer++ = SD_SPI_TRANSMIT(0xFF);
        }
      }
      
      // Send a dummy byte and deselect the card after it
      SD_SPI_TRANSMIT(0xFF);
      SD_SPI_CHIP_UNSELECT(SD_SS_PORT, SD_SS_PIN);

      return DataIn;
    }
  }
  
  SD_SPI_CHIP_UNSELECT(SD_SS_PORT, SD_SS_PIN);
  
  return SD_NO_RESPONSE;
}

[S. Landolt (Gast)]

Okay, ich bin am Ende; ein anderer muss weiterhelfen.
Einen schönen Abend noch.

[Daniel K. (daniel_k80)]

Hallo,

ich glaube ich habe das Problem ausmachen können.
Ich betreibe die SD-Karte an einem XPlained, welches über USB versorgt 
wird. das Board wurde die ganze Zeit von einem Hub in einer Tastatur 
versorgt. Das Auslesen hat wunderbar funktioniert, als ich das Board an 
einen USB-Port am Rechner gesteckt habe.
Wahrscheinlich hat der Hub in der Tastatur einfach zu wenig Leistung 
bereitstellen können (die Tastatur wird ja auch nur über USB 
betrieben...) und daher hat sich die SD-Karte nicht korrekt verhalten.