Probleme mit SPI - STM32F2

[EmbeddedUser (Gast)]

Hallo,

ich habe folgendes Problem mit der SPI Kommunikation auf dem STM32F2.
Um von einem Flashspeicher die ID auszulesen führe ich folgende 
Funktionen aus.

    // Read ID
    while (SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE)==RESET);
    SPI_I2S_SendData(SPIx, 0xAB);

    // Dummy byte
    while (SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE)==RESET);
    SPI_I2S_SendData(SPIx, 0x0);

    // Dummy byte
    while (SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE)==RESET);
    SPI_I2S_SendData(SPIx, 0x0);

    // Dummy byte
    while (SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE)==RESET);
    SPI_I2S_SendData(SPIx, 0x0);

    while (SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE)==RESET);
    SPI_I2S_SendData(SPIx, 0x0);

    // Read byte
    while ( SPI_I2S_GetFlagStatus( SPIx, SPI_I2S_FLAG_RXNE ) == RESET );
    ReadID = SPI_I2S_ReceiveData(SPIx);

Beim ersten mal erscheint nicht die gewünscht ID. Beim zweiten mal wird 
die korrekte ID in die Variable ReadID abgelegt.

Was müsste getan werden, damit beim ersten mal die ID in der Variable 
abgelegt wird ?

In der Initialisierungsroutine habe ich auch schon folgendes getestet.

    //Dummy-Read zum Entleeren des Rx-Buffers
    if(SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_RXNE) == SET)
      SPI_I2S_ReceiveData(SPIx);

Der Fehler tritt nach wie vor auf.

[EmbeddedUser (Gast)]

Hab schon alles ausprobiert. Es müsste doch dafür eine Lösung geben.

[wurst (Gast)]

Was für einen Flashspeicher benutzt du denn genau?
Braucht der vielleicht eine gewisse Zeit oder bestimmte Anzahl an Takten 
auf dem CLK-Signal zum Initialisieren?

[EmbeddedUser (Gast)]

Der STM32 Mikrocontroller soll mit dem EPCS Flash Controller via SPI 
kommunizieren.

[Tobias S. (tryan)]

Hallo EmbeddedUser,

ich habe das so gemacht:

uint8_t spi2_putc(uint16_t data) {
  FPGA_DESELECT();
  // make sure the transmit buffer is free
  while (SPI_I2S_GetFlagStatus(SPI2_PORT, SPI_I2S_FLAG_TXE) == RESET);
  SPI_I2S_SendData(SPI2, data);
  // and then be sure it has been sent over the wire
  while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_BSY) == SET);
  data=SPI_I2S_ReceiveData(SPI2);

  while (SPI_I2S_GetFlagStatus(SPI2_PORT, SPI_I2S_FLAG_TXE) == RESET);
  SPI_I2S_SendData(SPI2, 0);
  // and then be sure it has been sent over the wire
  while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_BSY) == SET);
  data=SPI_I2S_ReceiveData(SPI2);

  while (SPI_I2S_GetFlagStatus(SPI2_PORT, SPI_I2S_FLAG_TXE) == RESET);
  SPI_I2S_SendData(SPI2, 0);
  // and then be sure it has been sent over the wire
  while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_BSY) == SET);
  data=SPI_I2S_ReceiveData(SPI2);

  while (SPI_I2S_GetFlagStatus(SPI2_PORT, SPI_I2S_FLAG_TXE) == RESET);
  SPI_I2S_SendData(SPI2, 0);
  // and then be sure it has been sent over the wire
  while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_BSY) == SET);
  data=SPI_I2S_ReceiveData(SPI2);

  while (SPI_I2S_GetFlagStatus(SPI2_PORT, SPI_I2S_FLAG_TXE) == RESET);
  SPI_I2S_SendData(SPI2, 0);
  // and then be sure it has been sent over the wire
  while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_BSY) == SET);
  data=SPI_I2S_ReceiveData(SPI2);


  FPGA_SELECT();
  return data;

vielleicht hilft es dir weiter...

viele grüße Tobias

[Tobias S. (tryan)]

So... hab es nochmal ein wenig "hübscher" gestaltet.

uint8_t spi_Read_ID(uint8_t data) {
  EPCS_SELECT();

  // Send Operation Code
  // make sure the transmit buffer is free
  while (SPI_I2S_GetFlagStatus(SPI2_PORT, SPI_I2S_FLAG_TXE) == RESET);
  SPI_I2S_SendData(SPI2, data);
  // and then be sure it has been sent over the wire
  while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_BSY) == SET);
  data=SPI_I2S_ReceiveData(SPI2);

  // Send 3 Dummy bytes and 1 to Read the ID
  for (uint8_t i=0; i!=4; i++){
  // make sure the transmit buffer is free
  while (SPI_I2S_GetFlagStatus(SPI2_PORT, SPI_I2S_FLAG_TXE) == RESET);
  SPI_I2S_SendData(SPI2, 0);
  // and then be sure it has been sent over the wire
  while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_BSY) == SET);
  data=SPI_I2S_ReceiveData(SPI2);
  }

  EPCS_DESELECT();
  return data;
}

viele grüße

[EmbeddedUser (Gast)]

Guten Morgen Tobias S.,

vielen Dank für deine Beiträge.

Mit welcher Datei von Quartus || wird der EPCS Flash Controller 
beschrieben ? Ist es womöglich die Datei mit der Endung jic ?
Ab welcher Adresse soll der EPCS Flash Controller beschrieben werden ?

[Tobias S. (tryan)]

Hallo EmbeddedUser,

hmm... wenn du das EPCS wirklich seriell mit einen µC beschreiben 
möchtest. bleibt eigentlich "nur" das "Raw binare File". Dieses File 
muss 1:1 ab der Adresse 0x000000 in das EPCS geladen werden.

Das "jic"-File wäre JTag.

Viele Grüße Tobias

[EmbeddedUser (Gast)]

Hallo Tobias S.,

ich kann in dem Projekt kein Bin-File sehen. Muss ich dieses File mit 
einem zusätzlichen Tool erzeugen ?

Ich habe bezüglich dem EPCS Flash Controller noch eine weiteres Problem.
Wie beschreibst du die Sectoren ? Das seitenweise (256 Bytes) 
beschreiben des EPCS Flash Controller funktioniert soweit.

[EmbeddedUser (Gast)]

Ich muss in Quartus || das *.rbf File erzeugen. Der komplette Inhalt 
dieser Datei muss ab der Adresse 0 im EPCS Flash kopiert werden.

[EmbeddedUser (Gast)]

Oder muss vielleicht doch das *.rpd File benutzt werden ?

[Tobias S. (tryan)]

Ja genau das *.rpb meine ich...

[EmbeddedUser (Gast)]

Die Write_Page Funktion sieht bei mir so aus:

int Write_Page(char *data, int len, unsigned long addr)
{
    ChipSEL();

    SendOpCode(0x02); // Operation Code = 0x02

    while (SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE)==RESET);
    SPI_I2S_SendData(SPIx, (unsigned char)(addr>>16));

    while (SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE)==RESET);
    SPI_I2S_SendData(SPIx, (unsigned char)(addr>>8));

    while (SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE)==RESET);
    SPI_I2S_SendData(SPIx, (unsigned char)(addr));

    // Data
    for(int i=0; i<Length; i++)
    {
      while (SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE)==RESET);
      SPI_I2S_SendData(SPIx, *Data);
      Data++;
    }

    Sleep(7); // delay time = 7 ms

    ChipDESEL();

    return 1;
}

Bevor ich diese Funktion ausführe wird ein Write_Enable ausgeführt. Nach 
Write_Page wird ein Write_Disable durchgeführt. Sobald ich einen Sektor 
beschreiben möchte (256 Pages) wird das Debugging automatisch 
unterbrochen. Ich kann den Fehler nicht finden.

[EmbeddedUser (Gast)]

Ja meinst du nun das *.rpd oder das *.rbf File. Das *.rpd File kann so 
wie es aussieht nur mit dem Tool SRunner benutzt werden. Also ich meine 
es müsste das *.rbf (Raw binary file) File sein

[Tobias S. (tryan)]

hmm... was genau meinst du mit "Debugging automatisch
unterbrochen"

Hast du es schon geschafft ein beschriebenes EPCS auszulesen?

[Tobias S. (tryan)]

Ja sorry zu lange her. Ich meine das *.rbf

[Tobias S. (tryan)]

Du darfst max.256 Bytes pro Schreibzyklus schreiben. Danach muss die 
Adresse erhöht werden. Und dann darf ein neuer Schreibzyklus beginnen. 
Siehe Seite 25 im EPCS datasheet

[EmbeddedUser (Gast)]

Ja das mache ich ja bereits. Am Anfang lösche ich den ganzen Speicher 
mit Erase_Bulk.

[Tobias S. (tryan)]

Okay, aber er schreibt nur die ersten 256 Bytes?

[EmbeddedUser (Gast)]

Wie müsste der genauere Ablauf aussehen, wenn ein Sektor beschrieben 
werden soll ? Irgendwas stimmt ja bei mir nicht ganz. Der Debugger bzw. 
Mikrocontroller hängt sich bei mir auf.

[Tobias S. (tryan)]

Wenn sich der µC aufhängt klingt es eher, dass er in eine while scheife 
springt und nicht mehr raus kommt... Wartest du vielleicht auf einen 
bestimmten zustand von dem EPCS?

[EmbeddedUser (Gast)]

Ich warte bevor ich ein Byte versende ob das Flag "SPI_I2S_FLAG_TXE" 
wieder zurückgesetzt wird.

while (SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE)==RESET);

Wenn ich eine Page beschreibe dann habe ich keine Probleme.

[EmbeddedUser (Gast)]

Wie hast du das gelöst ?

[Tobias S. (tryan)]

Poste bitte den Code in dem du die Adresse hoch zählst

Viele Grüße Tobias

[EmbeddedUser (Gast)]

Hier ist ein Auszug aus meiner Applikation:

void main(void)
{  
  Time = Get_Time();

  id = ReadID();
  _delay();

  for(int i=0; i<256; i++)
  {
    EpcsData[i] = 0xAA;
  }
  
  Write_Enable();
  _delay();
  Erase_Bulk();
  _delay();
  Write_Disable();
  _delay();

  while (1)
  {
    if ( Time_Passed(&Time) )
    {
      for(int i = 256; i<256; i++)
      {
        Write_Enable();
        Sleep(5); // 5 ms
        Write_Page(EpcsData,256,i*0x00100); // 1. Paramter=Daten, 2. Paramter=Länge der Daten, 3. Parameter= Adresse
        Sleep(5); // 5 ms
        WriteDisable();
        _delay();
      }
      // 1. Paramter=Daten und 2. Parameter=Länge (werden noch nicht an die Applikation weitergereicht), 3. Parameter= Adresse
      Read_Page(0,0,0x00500);  
      _delay();
      
      Time = Get_Ahead_Time(1000); // 1 sec  
    }
  }
}

[EmbeddedUser (Gast)]

Folgendes habe ich festellen können. Wenn ich in der "Write_Page" 
Funktion die komplette for Schleife entferne, dann hängt sich der 
Mikrocontroller nicht auf.

Im Anhang befindet sich einen Auszug von der IAR JLink Debugger 
Fehlermeldung.

[Tobias S. (tryan)]

hmm die länge darf max. 255 sein. Das "0" Byte nicht vergessen mit zu 
zählen...

Warum fängst du erst an der Adresse 0x500 an auszulesen?

Wie groß ist deine "EpcsData"?

Viele grüße Tobias

[EmbeddedUser (Gast)]

Guten Morgen Tobias S.,

EpcsData ist 256 Byte groß. Die for Schleife ist natürlich falsch.
Die for Schleife sieht natürlich so aus:

for(int i = 0; i<256; i++)
{
 ....
}

[EmbeddedUser (Gast)]

Und mit der Funktion Read_Page möchte ich nur die Page ab der Adresse 
0x00500 auslesen.

Read_Page(0,0,0x00500);

[EmbeddedUser (Gast)]

Es muss an dieser for Schleife liegen. Wie kann mit dem STM32 256 Bytes 
per SPI versendet werden, ohne dass der Mikrocontroller sich aufhängt ? 
Es muss doch möglich sein. Ich habe soeben auch die Interrupt Variante 
ausprobiert. Da passiert es auch.

for(int i=0; i<256; i++)
{
  while (SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE)==RESET);
  SPI_I2S_SendData(SPIx, DATEN_BYTE);
}

[Tobias S. (tryan)]

Anbei mein Code, aber ich bin auch noch am Programmieren... Also keine 
Garantie ;)

void spi_Write_Page(char *data, uint32_t adr){
  char  Write_in_Prog = 3;

  spi_Write(1);
  EPCS_SELECT();
  spi_send_Bytes(0x02,0,0);
  spi_send_Bytes(adr>>16,0,0);
  spi_send_Bytes(adr>>8,0,0);
  spi_send_Bytes(adr,0,0);

  for(int i=0; i!=0x100; i++){
    // make sure the transmit buffer is free
       while (SPI_I2S_GetFlagStatus(SPI2_PORT, SPI_I2S_FLAG_TXE) == RESET);
       SPI_I2S_SendData(SPI2, *data);
       // and then be sure it has been sent over the wire
       while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_BSY) == SET);
       data++;
    }
  EPCS_DESELECT();

  while (Write_in_Prog==3){
    Write_in_Prog=spi_Read_Status();
    }
}

void spi_Write_Sektor(char *data, char len){
  for (uint16_t i=0; i!=len; i++){
    spi_Write_Page(data,i*0x00100);
    data=data+0x100;
    }
}

[Klaus (Gast)]

@EmbeddedUser

In deiner WritePage Funktion fehlt die Abfrage, ob das Flash ready ist. 
Dazu das Status-Register auslesen und das entsprechende Bit auswerten. 
Am einfachsten ist es, diese Abfrage vor jedem Löschen, Schreiben und 
Lesen zu machen, kostet nur so eine µs. Und die ganzen delays raus aus 
dem Programm.

MfG Klaus

[EmbeddedUser (Gast)]

Wo müsste genau müsste in der for Schleife die Abfrage erfolgen und 
welches Bit ? Damit auf den Speciher geschrieben werden kann, müsste 
laut Datenblatt das Bit 0 vom Status Register 0 sein.

[EmbeddedUser (Gast)]

Es hängt definitiv an dieser blöden for Schleife.

[Klaus (Gast)]

EmbeddedUser schrieb:
> Damit auf den Speciher geschrieben werden kann, müsste
> laut Datenblatt das Bit 0 vom Status Register 0 sein.

Ich benutze eine andere CPU, die Bedeutung deiner SPI Register kenne ich 
nicht.

Ich mache die Abläufe so:

Vor jedem Löschen, Schreiben oder Lesen warte ich, bis Bit 0 vom Status 
Register des Flashs 0 ist.

Das kann man so machen: READ STATUS Kommando senden und ein Byte 
zurücklesen. Dann CS wieder auf 1. Bit 0 von dem Byte auswerten und 
nochmal von vorne, wenn nicht 0;

Oder CS auf low, READ STATUS senden und solage Bytes lesen, bis Bit 0 
nicht mehr gesetzt ist. Dann CS wieder auf high.

Feiglinge setzen noch einen Loopcounter als Timeout darüber ;-) kann 
aber beim Löschen ganz schön lange dauern (500ms pro Sektor wenn ich 
mich recht erinnere)

Danach kann man alles machen, z.B. READ und Startadresse ausgeben (4 
Byte) und lesen bis der Flash zuende ist. Delays sind nirgenwo 
erforderlich, die Bits bekommt man auch mit 25 MHz ohne Pause.

So macht das das FPGA, 0x03 0x00 0x00 0x00 ausgeben und Bytes eintakten 
bis fertig.

MfG Klaus