SD-Karte kommt nicht aus dem Idle (8051)

[SD-Gestresster (Gast)]

Moin leute.

Eigentlich viel zu schönes Wetter um sich mit bockigen SD-Karten 
rumzuschlagen ^^. Aber naja.

Meine Aufgabe besteht immo darin, eine SD-Karte an einen AT89C51RE2 per 
SPI anzubinden. An sich scheint das auch in gewisser Weise zu 
funktionieren. Aber ich bin grad bei einem Punkt wo ich einfach nicht 
weiterkomme.

Der SPI-Bus des AT89C51RE2 läuft mit dem kleinsten einstellbaren Takt.
Cpol und CPha sind jeweils auf 1 gesetzt.

Mein Problem liegt in der Initialisierung der Karte. Laut des 
"Simplyfied_physical_layer_spec.pdf" von Sun, soll man zuerst ein CMD0 
senden und auf die Antwort von R1 warten welches idealerweise ein 0x01 
beinhaltet. Vorher hab ich 10x 0xff gesendet damit die Karte 80 Takte 
bekommt.
Dann schick ich ein CMD8 mit dem Parameter 0x1AA 
(Spannungsbereichsgedöns usw). Als Antwort erhalte ich im 1. und 2. Byte 
des OCR-registers ein 0x01 bzw ein 0xAA. (Also so wies sein soll).

Weil ja die Antworten von der SD_Karte (zumindest bei den ersten zwei 
Komandos) richtig ankommen, geh ich davon aus das die Kommunikation per 
SPI an sich funktioniert.

So. Jetzt soll man laut dem oben genannten PDF ja ein ACMD41 senden.
Ich geh also hin und schicke zuerst ein CMD55 und dann ein ACMD41.

Dieses ACMD41 gibt mir nun Rätsel auf.
CMD55 gibt ein 0x01 zurück. (In idle mode =1).

ACMD41 hab ich einmal mit HCS-Bit und einmal ohne versucht.
Mit dem 30. bit gesetzt erhalte ich die Antwort 0xe1. D.h. alle
Error-flags gesetzt und immer ncoh im idle. (Was mich wundert ist, das 
sogar das MSB auf 1 is, was laut PDF immer 0 sein soll ^^)
Schick ich aber ACMD41 mit allen Bits auf 0, bekomm ich ein 0xe0 zurück 
und bei dem nächsten, vom SPI-Master, gesendeten 0xff ein 0x7f. HÄÄÄ? ^^

An sich soll man ja so oft CMD55 + ACMD41 senden, bis irgendwann dieses 
idle-flag auf 0 ist. Nur passiert das bei mir auch nach 10000 
durchläufen nicht.
Irgendwas stimmt da nicht. Ich bin echt langsam ratlos. Ich hab auch 
schon die anderen Beiträge im Forum gelesen, aber das hat mir nciht 
geholfen.

Aso. Ich benutze eine etwas meinem µC angepasste Form der 
PetitFS-Bibliothek von ELM.


Wenn ich den CPOL und CPHA auf 0 setze, bekomm ich manchmal seltsamme 
Daten vond er SD-karte zurück.
Meine Pegelwandlung von 5V auf die 3,3 der karte hab ich mit einem 
schnellen Komperator realisiert. Die Signale sehen auf beiden Seiten gut 
aus (gemessen mit dem Oszi). Also da erwarte ich eher weniger Probleme.


Ich wär für eine Idee oder ein Tip echt dankbar. Mir geht die 
SD-Karten-geschichte langsam auf die nerven.

Aso ich hab hier 3 verschiedene SD-Karten liegen. Alle 3 funktionieren 
am PC ohne probleme.

[Filippé M. (Firma: Norris Vietnam-Reisen GmbH) (mcspeckfett)]

So hab mich mal angemeldet.

Ich hab jetzt noch vor dem ACMD41 ein CMD58 (Antwort des Befehls 0x01) 
gesendet (Wie im PDF angegeben).
Aus der Antwort (OCR-Register) bekomm ich folgendes:
0x80 0xff 0x80 0x00.

Laut PDF heißt das, dass die "Power-Up Routine" fertig is und die Karte 
alle Spannungsbereiche unterstützt.

Auch diese Antwort erscheint mir sinnvoll. Das Problem mit dem CMD55 und 
ACMD41 bleibt aber weiterhin bestehen.

[Filippé M. (Firma: Norris Vietnam-Reisen GmbH) (mcspeckfett)]

So ich hab das Ding ma an ein Oszi gestöpselt.

Zur Erklärung:
Das oberste Signal ist die CS-Leitung.
Das zweite Signal ist die Taktleitung vom SPI-Bus.
Das dritte Signal ist Mosi (also was der µC sendet) und das vierte 
Signal ist das was die SD-Karte zurückschickt.


Im 1. Bild (LeCroy1.jpg) sieht man CMD0 mit entsprechenden Antworten
Im 2. Bild (LeCroy3.jpg) sieht man CMD58 mit entsprechender Antwort der 
SD-karte.

Im 3. Bild (LeCroy2.jpg) sieht man nun den Gulasch den die SD-Karte bei 
CMD55 und ACMD41 zurückschickt.
Auf CMD55 antwortet die SD-Karte noch mit einem sinnvollen Byte (0x01).
Man sieht das nach dem ACMD41 die SD-Karte ein 0xE0 und dann ein 0xBF 
zurückschickt.

Was soll dasn mit diesem  0xE0?

[Schütze (Gast)]

Nach ein wenig Suchen bin ich nun auf die Frage gestoßen welches jetzt 
der Richtige ACMD41-Befehl ist?

ist      ACMD41 =  0x69 0x00 0x00 0x00 0x00 0x01   ?
oder ist ACMD41 =  0xe9 0x00 0x00 0x00 0x00 0x01   ?


dieses 0xe9 hab ich aus der PetitFat-Bibliothek und das 0x69 hab ich 
hier im Forum irgendwo gelesen.
Kann es sein das da der Fehler liegt? Werde das Morgen mal testen.

[Filippé M. (Firma: Norris Vietnam-Reisen GmbH) (mcspeckfett)]

upps vergessen mich einzuloggen.

[R. W. (quakeman)]

ACMD41 ist 0x69. So steht es auch in der simplified sd specification 
drin.

Ich poste dir mal meine Init Routine, womit ich bisher problemlos alle 
SD Karten initialisieren konnte (sd v1, sd v2, sdhc v2). Diese ist für 
einen LPC935 (8051er Familie) geschrieben.

// SD-Karte initialisieren
unsigned char uc_SD_init() {
  unsigned char ucTemp;
  unsigned int uiTimeout = 0;
  unsigned char aucCmd[6];
  bit btError;

  aucCmd[0] = CMD0_GO_IDLE_STATE;
  aucCmd[1] = 0x00;
  aucCmd[2] = 0x00;
  aucCmd[3] = 0x00;
  aucCmd[4] = 0x00;
  aucCmd[5] = 0x95;
  
  // Initialisiere SD-Karte in den SPI-Mode
  // Sendet min 74+ Clocks an die SD-Karte
  for (ucTemp = 0;ucTemp < 15; ucTemp++)
    v_SD_Write_Byte(0xFF);

  // Sendet Kommando CMD0 an SD-Karte um Reset auszulösen
  btError = bt_SD_Write_Command(1, aucCmd, 1);
  if (btError == SD_ERROR)
    // Die SD-Karte antwortet nicht
    return (SD_ERROR_NO_ANSWER);
  else if (aucCmd[0] != 1)
    // Irgend ein Fehler aufgetreten
    return (SD_ERROR_CMD0);

  // Sendet Kommando CMD8 an SD-Karte um Spezifikation zu ermitteln. (CRC benötigt)
  aucCmd[0] = CMD8_SEND_IF_COND;
  aucCmd[1] = 0x00;
  aucCmd[2] = 0x00;
  // VHS = 0001 (2,7V - 3,6V)
  aucCmd[3] = 0x01;
  // Check Pattern = 10101010
  aucCmd[4] = 0xAA;
  // CRC = 1000011 (0x43)
  // Danach folgt noch eine 1 als Stopbit wodurch 10000111 (0x87) zustandekommt
  aucCmd[5] = 0x87;
  
  // Auf CMD8 kommt eine R7 Antwort wenn SD Spezifikation v2 ansonsten nur eine R1 Antwort
  btError = bt_SD_Write_Command(1, aucCmd, 5);
  if (btError == SD_ERROR)
    // Die SD-Karte antwortet nicht
    return (SD_ERROR_CMD8);
  else if (aucCmd[0] == 5)
    // Unbekannter Befehl, also SD_Karte v1 (Idle-State Bit ist dabei noch gesetzt)
    btSD_V2 = 0;
  else if (aucCmd[0] == 1)
    // Alles ok, also SD-Karte v2 (Idle-State Bit ist dabei noch gesetzt)
    btSD_V2 = 1;
  else
    // Irgend ein Fehler aufgetreten
    return (SD_ERROR_CMD8);

  aucCmd[0] = 0xFF;

  if (!btSD_V2) {
    // Weitere Initialisierung für SD-Karte v1

    while (aucCmd[0] != 0 && uiTimeout < 10000) {
      // Sendet Kommando CMD55 an SD-Karte um ACMD einzuleiten
      aucCmd[0] = CMD55_APP_CMD;
      aucCmd[1] = 0x00;
      aucCmd[2] = 0x00;
      aucCmd[3] = 0x00;
      aucCmd[4] = 0x00;
      aucCmd[5] = 0xFF;
      btError = bt_SD_Write_Command(1, aucCmd, 1);
      if (btError == SD_ERROR || aucCmd[0] != 1)
        // Irgend ein Fehler aufgetreten
        return (SD_ERROR_CMD55);

      // Sendet Kommando ACMD41 an SD-Karte
      aucCmd[0] = ACMD41_SD_SEND_OP_CMD;
      aucCmd[1] = 0x00;
      aucCmd[2] = 0x00;
      aucCmd[3] = 0x00;
      aucCmd[4] = 0x00;
      aucCmd[5] = 0xFF;
      btError = bt_SD_Write_Command(1, aucCmd, 1);
      if (btError == SD_ERROR || (aucCmd[0] & 0xFE) != 0)
        // Irgend ein Fehler aufgetreten
        return (SD_ERROR_ACMD41);

      // Kurz warten
      v_Sleep_RTC(RTC_RELOAD_5MS);

      // Timeout Zähler erhöhen
      uiTimeout++;
    }
  }
  else {
    // Weitere Initialisierung für SD-Karte v2

    // VHS auslesen
    if ((aucCmd[3] & 0x0f) != 1)
      // VHS Wert ist ungültig
      return (SD_ERROR_CMD8_VHS);
    // Check Pattern auslesen
    if (aucCmd[4] != 0xAA)
      // Check Pattern wurde nicht korrekt zurückgeschickt
      return (SD_ERROR_CMD8_PATTERN);
    
    uiTimeout = 0;

    while (aucCmd[0] != 0 && uiTimeout < 10000) {
      // Sendet Kommando CMD55 an SD-Karte um ACMD einzuleiten
      aucCmd[0] = CMD55_APP_CMD;
      aucCmd[1] = 0x00;
      aucCmd[2] = 0x00;
      aucCmd[3] = 0x00;
      aucCmd[4] = 0x00;
      aucCmd[5] = 0xFF;
      btError = bt_SD_Write_Command(1, aucCmd, 1);
      if (btError == SD_ERROR || aucCmd[0] != 1)
        // Irgend ein Fehler aufgetreten
        return (SD_ERROR_CMD55);

      // Sendet Kommando ACMD41 an SD-Karte
      // HCS Bit ist 0 da der Host keine High-Capacity Karten unterstützt
      aucCmd[0] = ACMD41_SD_SEND_OP_CMD;
      aucCmd[1] = SDHC_HCS_INAKTIV;
      aucCmd[2] = 0x00;
      aucCmd[3] = 0x00;
      aucCmd[4] = 0x00;
      aucCmd[5] = 0xFF;
      btError = bt_SD_Write_Command(1, aucCmd, 1);
      if (btError == SD_ERROR || (aucCmd[0] & 0xFE) != 0)
        // Irgend ein Fehler aufgetreten
        return (SD_ERROR_ACMD41);
      
      // Kurz warten
      v_Sleep_RTC(RTC_RELOAD_5MS);

      // Timeout Zähler erhöhen
      uiTimeout++;
    }

    // Sendet Kommando CMD58 an SD-Karte um CCS Bit auszulesen (Bestimmt ob es eine SD oder SDHC Karte ist)
    aucCmd[0] = CMD58_READ_OCR;
    aucCmd[1] = 0x00;
    aucCmd[2] = 0x00;
    aucCmd[3] = 0x00;
    aucCmd[4] = 0x00;
    aucCmd[5] = 0xFF;
    btError = bt_SD_Write_Command(1, aucCmd, 5);

    if (btError == SD_ERROR || aucCmd[0] != 0)
      // Irgend ein Fehler aufgetreten
      return (SD_ERROR_CMD58);
    else if ((aucCmd[1] & 0x40) == 0)
      // Normale SD-Karte
      btSDHC = 0;
    else
      // SDHC-Karte
      btSDHC = 1;
  }

  // Karte erfolgreich initialisiert
  return (SD_OK);
}

Wenn du den gesamten Code sehen willst, dann kannst du in meinem SVN 
Repository drauf zugreifen:

https://quakeman.homelinux.net/viewvc/uVision/trunk/Library/SD_Karte_Funktionen.c?view=markup

und

https://quakeman.homelinux.net/viewvc/uVision/trunk/Library/SD_Karte_Funktionen.h?view=markup

Ciao,
     Rainer

[Filippé M. (Firma: Norris Vietnam-Reisen GmbH) (mcspeckfett)]

Moin

Nahcdem ich meine init-Routine mit deiner abgeglichen hab, funktionierts 
endlich. Es lassen sich alle SD-, SDHC- und MMC-Karten, die ich hier 
rumliegen hab, synchronisieren und unterscheiden.

Ich hänge jetzt allerdings an einem anderem Problem. Das hat aber nichts 
mehr mit der Kommunikation zwischen µC und Karte zu tun. Die macht genau 
was sie soll.

Bei der FAT-bibliothek von  ELM-Chan funktioniert anscheind die 
Weitergabe der Pointer nicht richtig. Beim Versuch den 1. Block 
auszulesen um festzustellen um welches FAT es sich handelt, läuft der µC 
irgendwo in eine Endlosschleife. Ich denke das der Compiler (Kile 
µVision 3)da irgendwie Mist baut mit den Pointern bzw der µC.
Werde dazu aber ggf einen neuen Thread beginnnen, falls ich das Problem 
nicht anders gelöst bekomme. (Wetter is aber zu gut :D )

[R. W. (quakeman)]

Ich habe auch mal etwas mit dem FAT32 Dateisystem herumexperimentiert. 
Dabei habe ich die Fat32 Routinen selber geschrieben, da ich lernen 
wollte, wie es funktioniert und nicht einfach fertigen Code benutzen 
wollte. Leider habe ich schon länger nicht mehr weiter gemacht dadran, 
aber die paar einfachen Funktionen funktionieren schon mal.

https://quakeman.homelinux.net/viewvc/uVision/trunk/Test_Fat32/FAT32_Funktionen.c?view=markup

https://quakeman.homelinux.net/viewvc/uVision/trunk/Test_Fat32/FAT32_Funktionen.h?view=markup

Der FAT32 Code ist allgemeingültig geschrieben, nur die Low-Level SD 
Funktionen sind speziell für den LPC935. Es werden dabei meine 
SD-Routinen verwendet, die ich vorher schon hier gepostet hatte. :)

Ciao,
     Rainer

[Abdul K. (ehydra)]

Vielleicht für den einen oder anderen interessant:
Es gibt eine SD-Karte mit WLAN. Man könnte also bequem galvanisch 
getrennt übers WLAN seine Daten transferieren.