SD - Card antwortet nicht

[Klaus P. (phoenix89)]

Hallo Leute,

ich versuche eine SD-Karte über SPI anzusteuern. uC (Atmega32) hängt an 
einem 4Mhz Quarz. SPI Clock liegt bei 250kHz. Für den Fall, dass die 
SD-Card nicht mit dem antwortet, was ich erwarte bzw. garnicht 
antwortet, schreibt der uC mir den Response mit einer 1 als MSB auf mein 
LCD (MSB sollte eigentlich immer 0 sein). Auf dem LCD landet eine 128, 
also gibt SD_Command eine 0 zurück. Das sollte nur passieren, wenn die 
SD Karte garnicht antwortet.

- Pegel an der SD-Card stimmen (3,3V und 0V)
- Anschluss des SPI über kleine Kabel ~17cm (schon zu lang?)
- x-Mal richtigen Anschluss geprüft.
- /SS Pin als Output
- keine Warnungen / Fehler des Compilers (avr-gcc mit Atmel Studio 4)

Hat jemand eine gute Idee (ich nehm auch ne blöde - wenns klappt ;) ), 
woran es liegen könnte?

Hier der Code (eigentlich schön in Header und C-Files ausgegliedert)

#include <stdint.h>
#include <avr/io.h> 
#include <string.h>  
#include <avr/interrupt.h>
#include <util/delay.h> 

uint8_t Flags;
unsigned char SD_Buffer[16];
uint8_t Temp; 

// PINS
#define CS          (1<<PD7)  
#define CS_DDR       DDRD
#define CS_ENABLE()   (PORTD &= ~CS)
#define CS_DISABLE()   (PORTD |= CS)

// SD-CARD Commands       0b01xxxxxx
#define _SD_IDLE       0x40  //0b01000000 - GO-IDLE-STATE
#define _SD_Init       0x41  //0b01000001 - Initialize
#define _SD_Set_Blocklenght  0x50  //0b01010000 - Set Block lenght
#define _SD_Read_Block    0x51  //0b01010001 - Read one Block

#define SS      (1<<PB4)
#define MOSI       (1<<PB5)
#define MISO       (1<<PB6)
#define SCK       (1<<PB7)  
#define SPI_DDR      DDRB

void SPI_Init(){
  // MOSI, /SS and SCK -> Output; MISO -> Input
  SPI_DDR = (1<<MOSI)|(1<<SCK)|(1<<SS);
  SPI_DDR &= ~(1<<MISO);

  // Enable SPI, Master, set clock rate
  SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR1);
}

unsigned char SPI_Write(unsigned char ch){
  // write on SPI
    SPDR = ch;
  // wait for Flag
    while(!(SPSR & (1<<SPIF)))  
  // return DataRegister    
    return SPDR;
}

uint8_t SD_Init(){
  uint8_t i, a;
  a=0;

  // Deselect SD-Card
  CS_DISABLE();
  // Give the SD-Card some time to initialize
  for (i=0; i<10; i++)
    SPI_Write(0xFF);

  // GO-IDLE-STATE - Try 10 Times
  for (i=0; i<10 && (a = SD_Command(_SD_IDLE, 0x00000000, 0x95, 8)) != 1; i++)
    _delay_ms(100);
  if (i==10)  // Card did not response
    return a + 0x80;

  // Initialize!
  for (i=0; i<10 && (a = SD_Command(_SD_Init, 0x00000000, 0xFF, 8)) != 1; i++)
    _delay_ms(100);
  if (i==10)  // Card did not come out of idle
    return a;

  // Set Block length 512
  SD_Command(_SD_Set_Blocklenght, 0x00000200, 0xFF, 8);
        
    SD_sector = SD_pos = 0;
        
    return 0;
}

uint8_t SD_Command(uint8_t cmd, uint32_t arg, uint8_t crc, uint8_t read){
  //
  uint8_t i, buffer[32], resp = 0;

  // Be my Slave! :D
  CS_ENABLE();
  _delay_ms(1);


  SPI_Write(cmd);
  SPI_Write(arg>>24);
  SPI_Write(arg>>16);
  SPI_Write(arg>>8);
  SPI_Write(arg);
  SPI_Write(crc);

  for(i=0; i<read; i++)
        buffer[i] = SPI_Write(0xFF);

  // Bye!
  CS_DISABLE();

  // response isnt 0xFF, so wait until something else is send
  for(i=0; i<read; i++) {
    if(buffer[i] != 0xFF)
      resp = buffer[i];
  }

  // Return the response
  return resp;
}

int main (void){
  // Zeit zum starten geben
  _delay_ms(10);
  // PORTS  
  // DDRx = 0 -> I, = 1 -> O        
  DDRD   =   (1<<PD7);
  // PORTx= 1 -> Pull-Up bzw. Output high  
  
  // I2C, SPI, SD
  I2C_Init();
  SPI_Init();

  // LCD
  LCD_Init();
  LCD_Light(1);    
  // Menu
  //gt_Main();

  // Systemzeit initialisieren
  Timer0_Sys_Clock();

  // globale Interrupts aktivieren
  sei();

  // Test der SD Karte
  
  Temp = SD_Init();
  my_utoi(Temp, 4, SD_Buffer);
  LCD_Cursor(8, 2);
  lcd_string(&SD_Buffer);

  // Hauptschleife
  while(1){
     }
     return 0;
}

[S. Landolt (Gast)]

> #define SS      (1<<PB4)
> #define MOSI       (1<<PB5)
> #define MISO       (1<<PB6)
> #define SCK       (1<<PB7)
> #define SPI_DDR      DDRB
>  SPI_DDR = (1<<MOSI)|(1<<SCK)|(1<<SS);
>  SPI_DDR &= ~(1<<MISO);

Diese Konstruktion verstehe ich nicht, da wird doch doppelt geschoben, 
oder?

[Klaus P. (phoenix89)]

Das sind genau die Antworten die ich haben will :D
Ist wie mit Rechtschreibfehlern in seinem eigenem Text - man sieht die 
offensichtlichen Sachen nicht.. Keine Ahnung was ich da wollte ;)
Ich probiers mal aus! Danke

[Klaus P. (phoenix89)]

Klappt mit

void SPI_Init(){
  // MOSI, /SS and SCK -> Output; MISO -> Input
  SPI_DDR = MOSI|SCK|SS;
  SPI_DDR &= ~(MISO);

  // Enable SPI, Master, set clock rate
  SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR1);
}

leider immer noch nicht :(

[Falk B. (falk)]

@  Klaus Peter (phoenix89)


>leider immer noch nicht :(

Betreibe eine systematische Fehlersuche. Erstmal muss deine SPI 
Daten, Takt, und SS ausspucken, egal ob die Karte reagiert oder nicht. 
Prüfe das mit einem Oszi oder Logic Analyzer. Dann geht es weiter.

>Hier der Code (eigentlich schön in Header und C-Files ausgegliedert)

Warum kopierst du das dann zusammen anstatt sinnvollerweise die 
einzelnen Dateien als Anhang zu senden? Siehe Netiquette.

[Jim M. (turboj)]

Versuche mal eine der vorhandenen Libs für SD Karten an Deine 
Pinbelegung anzupassen, das wird einfacher sein. Die Ansteuerung ist 
nicht ganz trivial,
und Deine Kommandos funktionieren spätestens bei SDHC Karten so nicht 
mehr.

Deine SD_Command() Funktion würde IMHO im Zweifelsfalle wichtige 
Antwortbytes verschlucken, z.B. beim Lesen von Registern.

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

 
for(i=0; i<read; i++)
        buffer[i] = SPI_Write(0xFF);

  // Bye!
  CS_DISABLE();

  // response isnt 0xFF, so wait until something else is send
  for(i=0; i<read; i++) {
    if(buffer[i] != 0xFF)
      resp = buffer[i];
  }

Der part ist wohl Fehlerhaft. Die Karte muss die Response nicht sofort 
nach dem Command schicken. Es wird aber direkt angefangen die Anzahl 
bytes von "read" zu lesen, ohne zu prüfen ob die Karte tatsächlich Daten 
schickt. Danach wird die Karte unselektiert, der untere Code bewirkt 
also nichts mehr.

Ein korrektes CMD 0 sollte indes ausreichen.

Nachtrag: Habs nochmal angeguckt und jetzt kapiert was hier passieren 
soll.
Bei welchem Command bekommst du denn die Response 0, wo genau bleibt es 
hängen? Response 0 bedeutet eigentlich "OK".
a = SD_Command(_SD_Init, 0x00000000, 0xFF, 8)) != 1

SD_Init bzw. CMD1 SEND_OP_CMD wird dir eine response 01 zurück liefern 
solange die Karte beschäftigt ist, sobald sie bereit für weitere 
Commands ist wird sie eine Response 00 Antworten.
Gruss

[Klaus P. (phoenix89)]

Danke für die Antworten.

Habs nun in

...
  // GO-IDLE-STATE - Try 10 Times
  for (i=0; i<10 && (a = SD_Command(_SD_IDLE, 0x00000000, 0x95, 8)) != 1; i++)
    _delay_ms(100);
  if (i==10)  // Card did not response
    return a;

  // Initialize!
  for (i=0; i<10 && (a = SD_Command(_SD_Init, 0x00000000, 0xFF, 8)) != 0; i++)
    _delay_ms(100);
  if (i==10)  // Card did not come out of idle
    return a;
...

und resp = 0xFF initialisiert.

Auf dem LCD erscheint nun "255". Heißt, auf dem BUS liegt ständig 
"high".(?)

Hab blöderweise grade kein Logic Analyzer zur Hand und komme auch erst 
nächste Woche an einen ran...

[Klaus P. (phoenix89)]

Fehler (mit Logic Analyzer :D ) gefunden.

unsigned char SPI_Write(unsigned char ch){
  // write on SPI
    SPDR = ch;
  // wait for Flag
    while(!(SPSR & (1<<SPIF)))  
  // return DataRegister    
    return SPDR;
}

... da fehlt doch was! (; am Ende von while..)

[Falk B. (falk)]

@  Klaus Peter (phoenix89)


>... da fehlt doch was! (; am Ende von while..)

Eine der bösen Stolperfallen von C, die man der Sprache zu recht 
anlastet!

[Daniel A. (daniel-a)]

Falk B. schrieb:
> @  Klaus Peter (phoenix89)
>
>> ... da fehlt doch was! (; am Ende von while..)
>
> Eine der bösen Stolperfallen von C, die man der Sprache zu recht
> anlastet!

Das sehe ich anders. Viele moderne Sprachen wie Java, Javascript, PHP, 
glsl, etc. ermöglichen genau das auch. Nur in alten sprachen wie z.B. 
bash, wo es ein "done" oder basic mit end while, oder die Andersartigen 
wie Python mit Einrückung haben dass nicht. Ich persönlich will die 
Sonderzeichen nicht missen.

[Klaus P. (phoenix89)]

Werde mir dann wohl ein {} bei "leeren" Schleifen angewöhnen..

Nun hängts beim Read-Befehl:

void SD_read(unsigned long sector, unsigned short offset, unsigned char * buffer, unsigned short length){
    uint8_t i;
    
    CS_ENABLE();
    SPI_Write(0x51);
    SPI_Write(sector>>15); // sector*512 >> 24
    SPI_Write(sector>>7);  // sector*512 >> 16
    SPI_Write(sector<<1);  // sector*512 >> 8
    SPI_Write(0);          // sector*512
    SPI_Write(0xFF);

  
    
    for(i=0; i<10 && SPI_Write(0xFF) != 0x00; i++);   // wait for 0
    for(i=0; i<10 && SPI_Write(0xFF) != 0xFE; i++);   // wait for data
    
    for(i=0; i<offset; i++)               // "skip" bytes
        SPI_Write(0xFF);
        
    for(i=0; i<length; i++)                 // read length bytes
        buffer[i] = SPI_Write(0xFF);
        
    for(i+=offset; i<512; i++)               // "skip" again
        SPI_Write(0xFF);
        
    // skip checksum
    SPI_Write(0xFF);
    SPI_Write(0xFF);    

    CS_DISABLE();    
}

In der Main aufgerufen mit:

SD_read(0, 3, &SD_Buffer, 8);

In der angehängten Datei gibts den Verlauf + den ersten Sektor der 
SD-Card.
Was mich verwundert ist, dass das "Gerümpel" immer das gleiche ist, 
jedoch nicht auf der SD-Card zu finden (muss ja aber irgendwo sein?). 
Die letzten 2 Bytes sind CRC und die davor stimmen mit dem was drauf 
sein soll überein..

[Falk B. (falk)]

@  Daniel Abrecht (daniel-a)

>> Eine der bösen Stolperfallen von C, die man der Sprache zu recht
>> anlastet!

>Das sehe ich anders. Viele moderne Sprachen wie Java, Javascript, PHP,
>glsl, etc. ermöglichen genau das auch.

Das macht es nicht besser.

> Nur in alten sprachen wie z.B.
>bash, wo es ein "done" oder basic mit end while, oder die Andersartigen
>wie Python mit Einrückung haben dass nicht. Ich persönlich will die
>Sonderzeichen nicht missen.

Welche Sonderzeichen? Das ;?

In Pascal wäre das nicht passiert, denn dort gibt es IMMER ein begin und 
end; Wenn es in C wengigstens immer die Klammern zwingend gäbe, würde so 
ein (Tipp)fehler nicht passieren. Was gewinnt man effektiv durch das 
Weglassen von ZWEI Klammern?