CLK ür SD-Karte festlegen.

//Routine zur Initialisierung der SD-Karte (SPI-MODE)

uint8_t sd_init(void)

{

  uint16_t sd_timeout = 0;

  uint16_t i;

  //Konfiguration des Ports, an den die SD-Karte angeschlossen wurde

    /*

     D6  (do) SS    = SD_Chip_Select

     B5  (do) MOSI  = SPI_DO

     B6  (di) MISO  = SPI_DI

     B7  (do) SCK   = SPI_Clock

    */

  DDRB |= (1<<7) | (1<<5) | (1<<4);              //SPI konfigurieren

  DDRD |= (1<<6);

  PORTD |= (1<<6);                  //Disable

  for(i = 0; i < 200; i++)

  {

    __asm__ __volatile__ ("nop" ::);               //Wartet eine kurze Zeit

  }

  //Aktivieren des SPI - Bus, Clock = Idle LOW

  //SPI Clock teilen durch 128 (Wir werden erst nach der Initialisierung richtig schnell)

  SPCR = (1<<SPE) | (1<<MSTR) | (1<<SPR0) | (1<<SPR1);          //Enable SPI, SPI im Master Mode  

  SPSR = (0<<SPI2X);

  //Bringe SD-Karte in den SPI-Mode

  for (i = 0; i<10; i++)

  {                       //Sendet 20*8 Clocks an die SD-Karte

    sd_writeByte(0xff);

  }

  //Sendet Kommando CMD0 an SD-Karte

  uint8_t CMD[] = {0x40,0x00,0x00,0x00,0x00,0x95};          //CMD0

  while(sd_writeCommand(CMD) != 1)

  {

    if (sd_timeout++ > 300) return 1;              //Abbruch bei CMD0

  }

  for (i = 0; i<10; i++)

  {                       //Sendet 20*8 Clocks an die SD-Karte

    sd_writeByte(0xff);

  }

  //Sendet Kommando CMD1 an SD-Karte

  sd_timeout = 0;

  CMD[0] = 0x41;                  //CMD1

  CMD[5] = 0xFF;

  while(sd_writeCommand(CMD) != 0)

  {

    if (sd_timeout++ > 600)

    {

      sd_timeout = 0;

      CMD[0] = 0x77;                  //ACMD

      CMD[5] = 0x01;

      while(sd_writeCommand(CMD) != 0)

      {

      if (sd_timeout++ > 600) return 2;             //Abbruch bei CMD1 und ACMD

      }

    }

  }

  //SPI Bus auf maximale Geschwindigkeit  (Clk/2)

  SPCR &= ~((1<<SPR0) | (1<<SPR1));              //Clear SPR0+SPR1

  SPSR = SPSR|(1<<SPI2X);                //Set SPI2X

  PORTD |= (1<<6);                  //Disable

  return(0);                    //OK

}

//Sendet ein Kommando an die SD-Karte

uint8_t sd_writeCommand(uint8_t *cmd)

{

  uint8_t tmp = 0xff;

  uint16_t sd_timeout = 0;

  uint8_t i;

  //SD_Chip_Select high (SD-Karte Inaktiv) 

  PORTD |= (1<<6);                  //Disable

  //sendet 8 Clock Impulse

  sd_writeByte(0xFF);

  //SD_Chip_Select low (SD-Karte Aktiv)

  PORTD &= ~(1<<6);                  //Enable

  //sendet 6 Byte Commando

  for (i = 0; i<0x06; i++)                //sendet 6 Byte Kommando zur MMC/SD-Karte

  {

    sd_writeByte(*cmd++);

  }

  //Wartet auf ein gueltige Antwort von der MMC/SD-Karte

  while (tmp == 0xff)

  {

    tmp = sd_readByte();

    if (sd_timeout++ > 500)

    {

      break;                    //Abbruch da die MMC/SD-Karte nicht Antwortet

    }

  }

  return tmp ;

}

//Routine zum Empfangen eines Bytes von der SD-Karte 

uint8_t sd_readByte(void)

{

  uint8_t sd_Byte = 0;

  SPDR = 0xff;

  while(!(SPSR & (1<<SPIF)))

  {

    ;

  }

  sd_Byte = SPDR;

  return sd_Byte;

}

//Routine zum Senden eines Bytes zur SD-Karte

void sd_writeByte(uint8_t Byte)

{

  SPDR = Byte;   //Sendet ein Byte

  while(!(SPSR & (1<<SPIF)))                //Wartet bis Byte gesendet wurde

  ;

}

//Routine zum Schreiben eines Sektors

uint8_t sd_writeSektor(void)

{

  uint8_t cmd[6];

  uint32_t sd_l_sektor_index = sd_sektor_index * 512;  //die Adressierung der SD-Karte wird in Bytes angegeben, Sektor wird von Blocks in Bytes umgerechnet

  cmd[0] = 0x58;

  cmd[1] = ((sd_l_sektor_index & 0xFF000000) >>24 );

  cmd[2] = ((sd_l_sektor_index & 0x00FF0000) >>16 );

  cmd[3] = ((sd_l_sektor_index & 0x0000FF00) >>8 );

  cmd[4] = 0;

  cmd[5] = 0xFF;

  //Sende Kommando cmd24 an SD-Karte (Write 1 Block/512 Bytes)

  uint8_t sd_error = sd_writeCommand(cmd);

  if (sd_error != 0)

  {

    return(sd_error);

  }

  //einen Moment warten und Clock senden

  for(uint8_t i = 0; i < 100; i++)

  {

    sd_readByte();

  }

  //Sende Start Byte an SD-Karte

  sd_writeByte(0xFE);

  //Schreiben des Blocks (512Bytes) auf SD-Karte

  for(sd_data_index = 0; sd_data_index < 512; sd_data_index++)

  {

    //sd_writeByte(sd_data_buffer[sd_data_index]);      //Daten senden

    sd_writeByte(123);              //Der Einfachheit wegen testweise nur 123 als Muster schreiben

  }

  //Block schliessen:

  //CRC-Byte schreiben

  sd_writeByte(0xFF); //Schreibe Dummy CRC

  sd_writeByte(0xFF); //CRC Code wird nicht benutzt

  //Fehler beim schreiben? (Data Response XXX00101 = OK)

  sd_error = sd_readByte();

  if((sd_error & 0x1F) != 0x05)

  {

    PORTD |= (1<<6);                  //Disable

    return(sd_error);

  } 

  //Warte auf SD-Karte busy

  while (sd_readByte() != 0xff)

    ;

  //SD-Karte Inaktiv schalten (Chip Select auf high)

  PORTD |= (1<<6);                  //Disable

  //Wenn wir hier angekommen sind ist die Welt in Ordnung!

  return 0;

}

//Routine zum Lesen eines Sektors

uint8_t sd_readSektor(void)

{

  uint8_t cmd[6];

  uint32_t sd_l_sektor_index = sd_sektor_index * 512;  //die Adressierung der SD-Karte wird in Bytes angegeben, Sektor wird von Blocks in Bytes umgerechnet

  cmd[0] = 0x51;          //Sektoren Byteweise angeben

  cmd[1] = ((sd_l_sektor_index & 0xFF000000) >> 24);  //MSB isolieren und in Position rücken

  cmd[2] = ((sd_l_sektor_index & 0x00FF0000) >> 16);  //...   "

  cmd[3] = ((sd_l_sektor_index & 0x0000FF00) >> 8);  //LSB   "

  cmd[4] = 0;

  cmd[5] = 0xFF;

  //Sende Kommando an SD-Karte (Read 1 Block/512 Bytes)

  uint8_t sd_error = sd_writeCommand(cmd);

  if (sd_error) return sd_error;

  //Wartet auf Start Byte (0xFE) von der SD-Karte 

  uint16_t sd_timeout = 500;

  while ((sd_readByte() != 0xfe) && (sd_timeout))

  {

      if(sd_timeout-- == 0) return 2;              //War wohl nix...

  }      

  //Hole die Daten

  for(sd_data_index = 0; sd_data_index < 512; sd_data_index++)

  {

    sd_data_buffer[sd_data_index] = sd_readByte();

  }

  //CRC-Byte auslesen

  sd_readByte();  //CRC - Byte wird nicht ausgewertet

  sd_readByte();  //CRC - Byte wird nicht ausgewertet

  PORTD |= (1<<6);                  //Disable

  //Wenn wir hier angekommen sind ist die Welt in Ordnung!

  return 0;

}