Initialisierung einer SD-Karte im SPI Mode

[Holger (Gast)]

Hallo,

ich bin dabei eine 1GB MicroSD Karte mit einem STM32 zu initialisieren.
CMD0 antwortet mit 0x01, also erreiche ich den IDLE state.

Auf CMD8 kommt keine Antwort also nur 0xff. Daher gehe ich von SD Vers. 
1 aus.

Ich sende ACMD41, doch bereits beim CMD55 kommt als Antwort nur 0xff, 
also keine Antwort. Ich denke nicht, dass die MicroSD Karte als MMC Vers 
3 erkannt werden möchte.

Welche potentiellen Fehler könnte ich gemacht haben?

Vielen Dank!

[Jim M. (turboj)]

Zeig mal den Code. Du musst übrigens bei CMD8 die korrekte CRC7 
Checksumme angeben.

Ansonsten: Ein R1 Antwort-Byte mit gesetztem 0x80 Bit ist keine 
Antwort, sondern die Info dass sich die Antwort verzögert und man noch 
ein (dummy) Byte senden muss.

[Holger (Gast)]

Ich werde mal versuchen ein dummybyte zu senden, wenn ein 0xff kommt. 
Ich bin aber eigentlich davon ausgegangen, dass einfach keine Antwort 
gekommen ist, wenn der MISO Pin nicht irgendwann mal nach unten gezogen 
worden ist.

Die CRC Checksumme übergebe ich als 0x87 für CMD8

Hier mal die Initialisierung:

  SD_CS_H;
  SD_WRITE_H;
  SD_SCLK_L;

  delay_us(2000); // TODO vielleicht mehr als 1000

  SD_toggle(148);

  sendArray[0] = CMD0;
  sendArray[1] = 0x00;
  sendArray[2] = 0x00;
  sendArray[3] = 0x00;
  sendArray[4] = 0x00;
  SD_CS_L; // start
  SD_Command_Write(&(sendArray[0]));
  SD_Receive(1);
  SD_WRITE_L;
  SD_toggle(8); // TODO Pruefen ob notwendig
  SD_CS_H; // stop
  if (SD_readArray[0] == 0x01) // JA
  {
    sendArray[0] = CMD8;
    sendArray[1] = 0x00;
    sendArray[2] = 0x00;
    sendArray[3] = 0x01;
    sendArray[4] = 0xAA;
    SD_CS_L; // start
    SD_Command_Write(&(sendArray[0]));
    if (!SD_Receive(5))
    {
      SD_WRITE_L;
      SD_toggle(8); // TODO Pruefen ob notwendig
      SD_CS_H; // stop
      SD_Version = 1;
    }
    else
    {
      SD_WRITE_L;
      SD_toggle(8); // TODO Pruefen ob notwendig
      SD_CS_H; // stop
      if (SD_readArray[0] & 0x7F)
      {
        SD_Version = 1;
      }
      if (SD_readArray[3] != 0x01 || (SD_readArray[4] != 0xAA))
      {
        SD_Version = 0;
        // power off card
        return;
      }
    }
    int errCounter = 0;
    SD_CS_L; // start
    do
    {
      sendArray[0] = CMD55;
      sendArray[1] = 0x00;
      sendArray[2] = 0x00;
      sendArray[3] = 0x00;
      sendArray[4] = 0x00;
      SD_Command_Write(&(sendArray[0]));
      SD_Receive(1);


      sendArray[0] = ACMD41;
      sendArray[1] = 0x40;
      sendArray[2] = 0x00;
      sendArray[3] = 0x00;
      sendArray[4] = 0x00;
      SD_Command_Write(&(sendArray[0]));
      SD_Receive(1);
      delay_us(1000);
      errCounter++;
    } while ((SD_readArray[0] == 0x01) && (errCounter <= 1000));
    SD_CS_H; // stop
    // TODO hier muesste eigentlich eine 00 statt einer 0xff stehen
    if ((SD_readArray[0] == 0x00) && (errCounter <= 1000))
    {
      if (SD_Version == 2)
      {
        SD_toggle(8);
        sendArray[0] = CMD58;
        sendArray[1] = 0x40;
        sendArray[2] = 0x00;
        sendArray[3] = 0x00;
        sendArray[4] = 0x00;
        SD_Command_Write(&(sendArray[0]));
        SD_Receive(4);
        if (SD_readArray[1] & 0x40)
        {
          SDHC = 1;
          return;
        }
      }
      if (!SDHC)
      {
        // Blocksize 512 Bytes
        SD_toggle(8);
        sendArray[0] = CMD16;
        sendArray[1] = 0x00;
        sendArray[2] = 0x00;
        sendArray[3] = 0x02;
        sendArray[4] = 0x00;
        SD_Command_Write(&(sendArray[0]));
        SD_Receive(1);
      }
    }
    else
    {
      SD_Version = 0;
      // power off
      return;
    }
  }
  else
  {
    SD_Version = 0;
    // power off
  }

[Holger (Gast)]

Also insgesamt sende ich 64 dummybits wo ich darauf warte, dass die 
MicroSD mir den MISO-Pin mal nach unten zieht. Tut sie aber nicht. --> 
keine Antwort

Außerdem habe ich ein paar SD_WRITE_L durch SD_WRITE_H vor dem Toggeln 
ausgetauscht, weil ich ja 0xFF senden muss und nicht 0x00. Beim Toggeln 
werden jetzt also Einsen an de MOSI rausgeschickt.

Dennoch läuft es nicht. Nachdem ich 0x01 vom CMD0 bekommen habe bekomme 
ich weder von CMD8 noch von ACMD41 (schon beim CMD55) keine Antwort.

CMD8 ist bei mir: 0x48 0x00 0x00 0x01 0xAA 0x87

[Jim M. (turboj)]

Holger schrieb:
> Also insgesamt sende ich 64 dummybits wo ich darauf warte, dass die
> MicroSD mir den MISO-Pin mal nach unten zieht. Tut sie aber nicht. -->
> keine Antwort

Bei welchem SPI Takt? Initial darf der maximal 400 kHz sein.
In meiner SD Kommandofunktion wartet er bis zu 1000 Zeichen ab, ob das 
0x80 Bit mal gelöscht wird. Das gilt auch für CMD0, das außerdem noch 
bis zu 16 Mal wiederholt wird.



Nochwas:

  SD_WRITE_L;
  SD_toggle(8); // TODO Pruefen ob notwendig
  SD_CS_H; // stop

Falsch herhum. "SD_CS_H;" muss vor dem Toggle stattfinden, also erst 
deselktieren und dann 0xFF Byte schreiben.

[Holger (Gast)]

Also der Takt liegt momentan bei 66 kHz. Also weit unter den 400kHz.

Ich warte momentan nur 128 Bit. Ich habe das auf 8000 Bit (also 1000) 
Zeichen erhöht. Macht keinen Unterschied, nur dass man jetzt merkt, dass 
das Programm wartet.

Da CMD0 bei mir richtig läuft lasse ich das dort erstmal mit dem einmal 
aufrufen. Idle reicht doch oder muss ich dann nochmal resetten?

SD_CS_H steht jetzt vor dem toggeln, funktioniert aber auch nicht.

Weder CMD8 noch CMD55 oder ACMD41 liefert mir irgendwann ein 0x00;

[Reto W. (Firma: Swissbit.com) (swissbit)]

Hast du möglicherweise einen Logik Trace von der Initialisierung?

Gruss

[Jim M. (turboj)]

Holger schrieb:
> Weder CMD8 noch CMD55 oder ACMD41 liefert mir irgendwann ein 0x00;

Die dürfen aber auch 0x01 als Ergebnis liefern. Dass die Karte im Idle 
State ist, das ist ja korrekt so.

Bei meinem Code (Quelle is EFSL) wird das CMD8 auf "1" als Ergebniscode 
geprüft.

[Holger (Gast)]

Einen LogicTrace habe ich leider nicht.

Wenn ich ein 0x01 erhalten würde wäre ich ja schon mal zufrieden. Leider 
antwortet die Karte gar nicht auf CMD8 und CMD55 oder ACMD41.

Ich habe das Projekt jetzt erst einmal zurückgestellt und werde es 
später noch einmal versuchen.

Vielen Dank aber bis jetzt!

[Markus M. (adrock)]

Was für ein STM32 ist es denn?

Ich hatte mir beim STM32F0 (fast) die Karten gelegt, weil das 
SPI-Register standardmäßig als 16-Bit Wert gelesen/geschrieben wird, 
d.h. es werden dann auch 16 Bits übertragen/gelesen.

Außerdem hat der STM32F0 auch einen FIFO im SPI.

Stimmt natürlich alles nur wenn man ohne die periphals lib programmiert.

[Holger (Gast)]

Es ist ein STM32F407VGT6 auf einem Discovery Board. SPI habe ich nicht 
konfiguriert. Das mache ich momentan über Software.

Also ganz simples Bit setzen, Takt hoch, 3us warten, Takt runter und 
nächstes Bit...
Die Übertragung scheint auch zu klappten. Ich bekomme eine richtige 
Antwort auf CMD0.

[Holger (Gast)]

Ich habe mich mal durchgesteppt.
Sowohl der CMD55 als auch der ACMD41 antworten beide genau einmal mit 
0x01.
Und das beim ersten Durchlauf. Danach kommen nur noch 0xFF, also keine 
Antwort.

Der Fehler muss also demnach im folgenden Codestück liegen.

    SD_CS_L; // start
    int position = 0;
    do
    {
      sendArray[0] = CMD55;
      sendArray[1] = 0x00;
      sendArray[2] = 0x00;
      sendArray[3] = 0x00;
      sendArray[4] = 0x00;
      SD_Command_Write(&(sendArray[0]));
      if (SD_Receive(1))
      {
        position = 1;
      }

//      SD_CS_H; // stop
//      SD_toggle(8); // TODO Pruefen ob notwendig
//      SD_CS_L;

      sendArray[0] = ACMD41;
      sendArray[1] = 0x40;
      sendArray[2] = 0x00;
      sendArray[3] = 0x00;
      sendArray[4] = 0x00;
      SD_Command_Write(&(sendArray[0]));
      if (SD_Receive(1))
      {
        position = 2;
      }

      SD_CS_H; // stop
      SD_toggle(8); // TODO Pruefen ob notwendig
      SD_CS_L;

      delay_us(1000);
      errCounter++;
    } while ((SD_readArray[0] != 0x00) && (errCounter <= 1000));
    SD_CS_H; // stop

[grundschüler (Gast)]

Holger schrieb:
> Also ganz simples Bit setzen,

dann vergleiche deinen Code mit dem bitbanging Code von Chan -avr 
foolproof. Oder noch besser, nimm gleich den code von chan. Beim F103 
hat der fast auf Anhieb geklappt.

[Holger (Gast)]

Praxis ist wenn es geht und weiß nicht warum.
Auf jeden Fall klappt es jetzt nach der Mittagspause die Karte als SDHC 
zu initialisieren.

Hier der fertige Initialisierungscode:

void SD_init(void)
{
  unsigned char sendArray[5];
  SD_Version = 2;
  SDHC = 0;

  // Konfiguration SCK, MISO, MOSI, CS
  // Pullips
  GPIOC -> PUPDR &= ~(1 << 25);
  GPIOC -> PUPDR |= (1 << 24);
  GPIOC -> PUPDR &= ~(1 << 23);
  GPIOC -> PUPDR |= (1 << 22);
  GPIOD -> PUPDR &= ~(1 << 5);
  GPIOD -> PUPDR |= (1 << 4);

  // Konfiguration des Eingangs (MISO PC8)
  GPIOC -> MODER &= ~((1 << 16) + (1 << 17));
  GPIOC -> PUPDR &= ~(1 << 17);
  GPIOC -> PUPDR |= (1 << 16);
//  GPIOC -> TYPER |= (1 << 8); // open drain

  // Konfiguration der Outputs
  GPIOC -> MODER |= (1 << 22) + (1 << 24);
  GPIOD -> MODER |= (1 << 4);

  SD_SCLK_L;

  delay_us(2000); // TODO vielleicht mehr als 1000

  SD_CS_H;
  SD_WRITE_H;

  SD_toggle(148); // TODO vielleicht mehr als 74

  sendArray[0] = CMD0;
  sendArray[1] = 0x00;
  sendArray[2] = 0x00;
  sendArray[3] = 0x00;
  sendArray[4] = 0x00;
  SD_CS_L; // start
  SD_Command_Write(&(sendArray[0]));
  SD_Receive(1);
  SD_CS_H; // stop
  SD_toggle(8); // TODO Pruefen ob notwendig
  if (SD_readArray[0] == 0x01) // JA
  {
    sendArray[0] = CMD8;
    sendArray[1] = 0x00;
    sendArray[2] = 0x00;
    sendArray[3] = 0x01;
    sendArray[4] = 0xAA;
    SD_CS_L; // start
    SD_Command_Write(&(sendArray[0]));
    if (SD_Receive(5) == 0)
    {
      SD_CS_H; // stop
      SD_toggle(8); // TODO Pruefen ob notwendig
      SD_Version = 1;
    }
    else
    {
      SD_CS_H; // stop
      SD_toggle(8); // TODO Pruefen ob notwendig
      if (SD_readArray[0] & 0x7E)
      {
        SD_Version = 1;
      }
      if (SD_readArray[3] != 0x01 || (SD_readArray[4] != 0xAA))
      {
        SD_Version = 0;
        // power off card
        return;
      }
    }
    int errCounter = 0;
    SD_CS_L; // start
    int position = 0;
    do
    {
      SD_CS_H;
      SD_toggle(16); // TODO Pruefen ob notwendig (16)
      SD_CS_L;

      sendArray[0] = CMD55;
      sendArray[1] = 0x00;
      sendArray[2] = 0x00;
      sendArray[3] = 0x00;
      sendArray[4] = 0x00;
      SD_Command_Write(&(sendArray[0]));
      if (SD_Receive(1))
      {
        position = 1;
      }

      SD_CS_H;
      SD_toggle(16); // TODO Pruefen ob notwendig (16)
      SD_CS_L;

      sendArray[0] = ACMD41;
      if (SD_Version == 2) sendArray[1] = 0x40;
      else sendArray[1] = 0x00;
      sendArray[2] = 0x00;
      sendArray[3] = 0x00;
      sendArray[4] = 0x00;
      SD_Command_Write(&(sendArray[0]));
      if (SD_Receive(1))
      {
        position = 2;
      }

      errCounter++;
    } while ((SD_readArray[0] != 0x00) && (errCounter <= 100));
    SD_CS_H; // stop
    // TODO hier muesste eigentlich eine 00 statt einer 0xff stehen
    int test = SD_readArray[0];
    if ((SD_readArray[0] == 0x00) && (errCounter <= 1000))
    {
      if (SD_Version == 2)
      {
        SD_CS_H; // stop
        SD_toggle(16); // TODO Pruefen ob notwendig
        sendArray[0] = CMD58;
        sendArray[1] = 0x40;
        sendArray[2] = 0x00;
        sendArray[3] = 0x00;
        sendArray[4] = 0x00;
        SD_Command_Write(&(sendArray[0]));
        SD_Receive(4);
        if (SD_readArray[1] & 0x40)
        {
          SDHC = 1;
          return;
        }
      }
      if (!SDHC)
      {
        // Blocksize 512 Bytes
        SD_CS_H; // stop
        SD_toggle(16); // TODO Pruefen ob notwendig
        sendArray[0] = CMD16;
        sendArray[1] = 0x00;
        sendArray[2] = 0x00;
        sendArray[3] = 0x02;
        sendArray[4] = 0x00;
        SD_Command_Write(&(sendArray[0]));
        SD_Receive(1);
      }
    }
    else
    {
      SD_Version = 0;
      // power off
      return;
    }
  }
  else
  {
    SD_Version = 0;
    // power off
  }
}