CLK ür SD-Karte festlegen.

[Peter B. (funkheld)]

Hallo, guten Tag.
Ich habe hier ein Timingplan für die SD-Karte.
Da müssen ja bestimmte Clocks eingehalten werden.

Ich habe 50Mhz beim DE1, welche CLK-Länge muss ich jetzt bitte beim FPGA 
für ein Clocks nehmen?

Danke.
Gruss

[TriHexagon (Gast)]

Du musst auch noch beachten, dass in der Initialisierung der SD Karte 
CLK max. 400 kHz betragen darf.

[Peter B. (funkheld)]

JUp, danke.

Wie weit bleibt man unter 400Khz?

Danke.
Gruss

[TriHexagon (Gast)]

400 kHz muss eigentlich funktionieren. Aber wenn du auf der sicheren 
Seite sein willst, nimmst du was darunter, z.B. 200 kHz oder 125kHz 
(habe ich mal verwendet).

[Peter B. (funkheld)]

Hmm.., danke.
Wie kann ich die 400Khz oder darunter jetzt wirksam erzeugen von 50Mhz.
Das verstehe ich noch nicht.

Danke. Gruss

[CLock (Gast)]

Teil halt durch 128 oder 256. Ist doch vollkommen egal, da Synchron.
Ob das nun 390kHz oder 195kHz sind...

[Peter B. (funkheld)]

Jup danke.
Also gibt es keinen Wert der genau vorgeschrieben ist, als da unter 
400KHz bleiben.

Danke.
Gruss

[Michael (Gast)]

Die Frage ist doch noch eine ganz andere. Was soll mit
der SD-Karte gemacht werden? Sollen hier etwas Daten
abgelegt werden die später auch noch mit dem PC gelesen
werden können?

Gruß,
Michael

[Peter B. (funkheld)]

Ich möchte die Daten am PC lesen.
Ich möchte nur in 512 Byte-Blöcke lesen und schreiben weiter nicht.

GRuss

So wie hier:

//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;
}

[CLock (Gast)]

Softcore oder pures VHDL?

Mit Softcore kein Thema, mit VHDL wird es schon sportlicher.
Die Init und das Protokoll der SD ist ja nicht so einfach 
zusammengestrickt in VHDL.

[Peter B. (funkheld)]

Hmm.., VHDL.

Gruss

[Michael (Gast)]

Und hast Du dir auch schon mal überlegt wie Du am PC an die SD-Karte,
bzw. an die einzelnen Sektoren (512 Bytes) kommst?

[Peter B. (funkheld)]

Ich habe den HXD-Editor, der kann die Datenblöcke lesen bzw sieht die 
SD-Karte auf der untersten Ebene.

Das hatte ich vor jahren mit einem Atmega32 und meinem Roboter gemacht.
Das Ding fuhr im Zimmer rum und habe mit einem Abstandssensor Daten 
eingescannt und am PC wieder ausgelesen mit HXD und einen Grafikumriss 
nach den Daten erstellt.

Gruss

[berndl (Gast)]

hmmmm,

schreib' doch einfach das C-Programm in ein VHDL-Programm um. Ist doch 
eh' alles das selbe...

[Peter B. (funkheld)]

Ja in NIOS wird es gehen.

Gruss

[Dirk (Gast)]

Die Dateiendung von .c in .vhd ändern müßte doch schon reichen.