ST26 16MBit Flash <.> XMEGA256A3BU

[Fabian D. (Gast)]

Moin Moin,

ich werde noch Wahnsinnig. Versuche einfach schon zu lange ein Byte in 
das Flash zu schreiben.. Leider erfolglos. Was übersehe ich? Was mache 
ich falsch?!

SPI läuft! Kann Informationen die im Datenblatt (wie die Informationen 
vom Chip auslesen..) Also das kann nicht das Problem sein.

Hier ist mein Hauptprogramm, wo ich versuche ein Byte zu schreiben und 
das wieder zurück zu lesen.

int main(void){
  
  PORTR.DIR    =  (1<<0|1<<1); // state_leds_output
  PORTR.OUTSET  =  (1<<0|1<<1); // state_leds_off
  LED_OFF

  Spi_Master_USARTD0_Init(FlashSPI,5000,0,0);
  
   sst26_reset(DataFlash,FlashSPI);

//   sst26_read_jedec(DataFlash,FlashSPI);
//   if (DataFlash->JEDEC_ID[0]==0xBF)
//   {
//     if (DataFlash->JEDEC_ID[1]==0x26)
//     {
//       if (DataFlash->JEDEC_ID[2]==0x41)
//       {
//         sst26_ONLINE
//       }else{
//         sst26_OFFLINE
//       }
//     }
//   }

  DataFlash->TxBuffer[0]= 5;
  sst26_write_start(DataFlash,FlashSPI);
  sst26_write_page(DataFlash,FlashSPI,0x00000000,1);
  sst26_write_stop(DataFlash,FlashSPI);

    while (1){  
    
    sst26_read(DataFlash,FlashSPI,0x00000000,1);

    if (DataFlash->RxBuffer[0]==5)
    {
      LED_ON
      }else{
      LED_OFF
    }  
    }
}

Funktion zum Page schreiben..

void sst26_write_page(sst26_t *DataFlash, spi_usart_t *FlashSPI, uint32_t addr, uint8_t leng){
  
  sst26_wait_is_busy(DataFlash,FlashSPI);    

  do
  {
    sst26_read_state(DataFlash,FlashSPI);
  } while (!DataFlash->StateFlags.Wel);  
  
  Spi_USARTD0_Slave_Select_Low(FlashSPI);
  
  Spi_USARTD0_Rx_Tx(0x02);
  Spi_USARTD0_Rx_Tx((uint8_t)(addr>>16)&0xFF);
  Spi_USARTD0_Rx_Tx((uint8_t)(addr>>8 )&0xFF);
  Spi_USARTD0_Rx_Tx((uint8_t)addr&0xFF);
  
  
  for (uint8_t byte=0;byte<leng;byte++)
  {
    Spi_USARTD0_Rx_Tx(DataFlash->TxBuffer[byte]);    
  }
    
  
  Spi_USARTD0_Slave_Select_High(FlashSPI);
}

Funktion zum lesen

void sst26_read(sst26_t *DataFlash, spi_usart_t *FlashSPI, uint32_t addr, uint8_t leng){
  
   sst26_wait_is_busy(DataFlash,FlashSPI);
       
  Spi_USARTD0_Slave_Select_Low(FlashSPI);
  
  Spi_USARTD0_Rx_Tx(0x03);
  Spi_USARTD0_Rx_Tx((addr>>16)&0xFF);
  Spi_USARTD0_Rx_Tx((addr>>8)&0xFF);
  Spi_USARTD0_Rx_Tx((addr&0xFF));
  
  for (uint8_t byte=0;byte<leng;byte++)
  {
    DataFlash->RxBuffer[byte]=Spi_USARTD0_Rx_Tx(0x00);    
  }
  

  Spi_USARTD0_Slave_Select_High(FlashSPI);
}

[Fabian D. (Gast)]

Warten so lange der Flash beschäftigt ist..

void sst26_wait_is_busy(sst26_t *DataFlash, spi_usart_t *FlashSPI){
  
  while(DataFlash->StateFlags.Busy==1){
    sst26_read_state(DataFlash, FlashSPI);
  }
}

Status Register auslesen..

void sst26_read_state(sst26_t *DataFlash, spi_usart_t *FlashSPI){
  
  Spi_USARTD0_Slave_Select_Low(FlashSPI);
  Spi_USARTD0_Rx_Tx(0x05);
  DataFlash->StateReg = Spi_USARTD0_Rx_Tx(0x00);
  Spi_USARTD0_Slave_Select_High(FlashSPI);
  
  /* clear all flags */
  DataFlash->StateFlags.Busy  =0;
  DataFlash->StateFlags.Sec  =0;
  DataFlash->StateFlags.Wel  =0;
  DataFlash->StateFlags.Wpld  =0;
  DataFlash->StateFlags.Wse  =0;
  DataFlash->StateFlags.Wsp  =0;
  
  if (DataFlash->StateReg&(1<<0))
  DataFlash->StateFlags.Busy=1;

  if (DataFlash->StateReg&(1<<1))
  DataFlash->StateFlags.Wel=1;
  
  if (DataFlash->StateReg&(1<<2))
  DataFlash->StateFlags.Wse=1;

  if (DataFlash->StateReg&(1<<3))
  DataFlash->StateFlags.Wsp=1;
  
  if (DataFlash->StateReg&(1<<4))
  DataFlash->StateFlags.Wpld=1;
  
  if (DataFlash->StateReg&(1<<5))
  DataFlash->StateFlags.Sec=1;
}

[Bastian W. (jackfrost)]

Linke mal das DB vom SPI Flash , hat das ein WREN Bit das du vor dem 
Schreiben setzen musst ? Der SS vom SPID ist auch ein Ausgang ?

Kannst du eine ganze Page lesen ?

Gruß JackFrost

[Fabian D. (Gast)]

Moin,

das WREN setze ich und kann ich erfolgreich zurück lesen. Damit 
funktioniert der SPI.

Hier der Link zum DB

ww1.microchip.com/downloads/en/DeviceDoc/20005262A.pdf

[A. B. (Gast)]

Was heißt denn "Leider erfolglos"???

Wie schon angedeutet wurde: SST25VF016B hat wie üblich ein WEL Bit, dass 
gesetzt werden muss. Oben habe ich aber nur eine Abfrage auf "gesetzt" 
gesehen, aber nicht, dass es irgendwo auch tatsächlich gesetzt wird.

Außerdem wäre es hilfreich, das Status-Register an dieversen Stellen 
auszulesen und auszugeben. Irgendwelche Block Protection???

[Fabian D. (Gast)]

Ich habe keine Block Protection gesetzt.
Das WEL habe ich geprüft und es ist auf 1 gesetzt.

[Pete K. (pete77)]

Aus dem DB:

5.17 Sector-Erase
The Sector-Erase instruction clears all bits in the
selected 4 KByte sector to ‘1,’ but it does not change a
protected memory area. Prior to any write operation,
the Write-Enable (WREN) instruction must be executed.


Außerdem kannst Du nur ein leere (d.h. vorher gelöschte) page 
beschreiben.

[A. B. (Gast)]

Fabian D. schrieb:
> Ich habe keine Block Protection gesetzt.

Die Frage war aber, ob event. eine Block Protection gesetzt IST, nicht 
wann oder von wem sie ggf. gesetzt wurde.

> Das WEL habe ich geprüft und es ist auf 1 gesetzt.

Das Setzen ist aber nirgends zu sehen.

Das Ding hat noch ein Configuration Reg., da würde sich ein Block 
lohnen.
Und wie sieht's mit der Beschaltung von WP und HOLD aus?

Und die wichtigste Frage überhaupt ist immer noch offen: Was heißt 
"Leider erfolglos"?
Z. B.: Geht nach Deaktivieren vom CS am Ende des Page Write das Busy Bit 
auf 1 und bleibt auch 'ne Weile so? Und das WEL automatisch wieder auf 
0.
Was stand vorher in der betreffenden Page, was steht hinterher drin ...

Ein einfaches "geht nicht" ist ein ziemlich leere Aussage ...

[Fabian D. (Gast)]

A. B. schrieb:
> Die Frage war aber, ob event. eine Block Protection gesetzt IST, nicht
> wann oder von wem sie ggf. gesetzt wurde.

Ich deaktiviere diese Funktion mit

void sst26_block_protection_unlock(sst26_t *DataFlash, spi_usart_t *FlashSPI){
  
  sst26_wait_is_busy(DataFlash,FlashSPI);
  sst26_spi_send(DataFlash,FlashSPI,0x98,1);
}

A. B. schrieb:
> Das Setzen ist aber nirgends zu sehen.

Wo kann ich dieses Bit bitte setzen?

A. B. schrieb:
> Das Ding hat noch ein Configuration Reg., da würde sich ein Block
> lohnen.
> Und wie sieht's mit der Beschaltung von WP und HOLD aus?

Das ist ein Dev. Board. Die Pins sind so verschaltet, dass man zugriff 
drauf hat. Das Board ist ein XPlainedA3BU.

A. B. schrieb:
> Und die wichtigste Frage überhaupt ist immer noch offen: Was heißt
> "Leider erfolglos"?
> Z. B.: Geht nach Deaktivieren vom CS am Ende des Page Write das Busy Bit
> auf 1 und bleibt auch 'ne Weile so? Und das WEL automatisch wieder auf
> 0.
> Was stand vorher in der betreffenden Page, was steht hinterher drin ...
>
> Ein einfaches "geht nicht" ist ein ziemlich leere Aussage ...

Das kann ich noch mal prüfen, ob das sich das Busy Bit überhaupt nach 
schreiben der Page ändert. Würde das der Fall sein, würdes es bedeuten 
das er was gespeichert hat bzw. was verarbeitet.

[A. B. (Gast)]

Fabian D. schrieb:
> A. B. schrieb:
>> Die Frage war aber, ob event. eine Block Protection gesetzt IST, nicht
>> wann oder von wem sie ggf. gesetzt wurde.
>
> Ich deaktiviere diese Funktion mit
>

> void sst26_block_protection_unlock(sst26_t *DataFlash, spi_usart_t 
> *FlashSPI){
> 
>   sst26_wait_is_busy(DataFlash,FlashSPI);
>   sst26_spi_send(DataFlash,FlashSPI,0x98,1);
> }
>

"The Global Block-Protection Unlock (ULBPR) instruc-
tion clears all write-protection bits in the Block-Protec-
tion register, except for those bits that have been
locked down with the nVWLDR command."

Die Block Protection könnte (versehentlich) permanent gesetzt sein. 
Deshalb Kontrolle im Status und Configuration Reg. nötig.

> A. B. schrieb:
>> Das Setzen ist aber nirgends zu sehen.
>
> Wo kann ich dieses Bit bitte setzen?

"The Write Enable (WREN) instruction sets the Write-
Enable-Latch bit in the Status register to ‘1, ..."

Ist ja vielleicht im sst26_write_start drin, aber ...

>> Und wie sieht's mit der Beschaltung von WP und HOLD aus?

> Das ist ein Dev. Board. Die Pins sind so verschaltet, dass man zugriff
> drauf hat. Das Board ist ein XPlainedA3BU.

Die Frage ist, welche Pegel tatsächlich anliegen. Insbesondere dürfen 
die nicht "floaten", sondern müssen auf definiertem Pegel liegen (und 
halt dem richtigem).

> Das kann ich noch mal prüfen, ob das sich das Busy Bit überhaupt nach
> schreiben der Page ändert. Würde das der Fall sein, würdes es bedeuten
> das er was gespeichert hat bzw. was verarbeitet.

Richtig, und auch das WEL Bit muss danach automatisch wieder auf '0' 
gehen.

[Fabian D. (Gast)]

A. B. schrieb:
> "The Global Block-Protection Unlock (ULBPR) instruc-
> tion clears all write-protection bits in the Block-Protec-
> tion register, except for those bits that have been
> locked down with the nVWLDR command."
>
> Die Block Protection könnte (versehentlich) permanent gesetzt sein.
> Deshalb Kontrolle im Status und Configuration Reg. nötig.

Das werde ich direkt mal checken.

A. B. schrieb:
> "The Write Enable (WREN) instruction sets the Write-
> Enable-Latch bit in the Status register to ‘1, ..."
>
> Ist ja vielleicht im sst26_write_start drin, aber ...


Aber? Das ist da mit drin, damit setze ich das Bit und eine Funktion für 
das löschen gibt es auch.

A. B. schrieb:
> Die Frage ist, welche Pegel tatsächlich anliegen. Insbesondere dürfen
> die nicht "floaten", sondern müssen auf definiertem Pegel liegen (und
> halt dem richtigem).

Habe ich kontrolliert, liegen beide auf High.

[Bastian W. (jackfrost)]

Setzt du WREN bevor du die Block Protection deaktivierst , wenn dann ist 
WREN wieder deaktiviert. WREN muss immer dann gesetzt werden, wenn du 
schreiben willst. Unter 4.5.1 steht wann WREN immer deaktiviert wird.

Gruß JackFrost

[Fabian D. (Gast)]

Also wenn ich block_protection_unlock aufrufe, Empfange ich auf einmal 
was auf MISO. Nur leider nicht das was ich vorher geschrieben habe.

[Bastian W. (jackfrost)]

Was sendest du und was ließt du wieder aus ? Hast du vorher WREN erneut 
gesetzt ? Was ließt du aus wenn du die ersten 256 Bytes ausliest ?

Gruß JackFrost

[Fabian D. (Gast)]

Bastian W. schrieb:
> Was sendest du und was ließt du wieder aus ? Hast du vorher WREN
> erneut
> gesetzt ? Was ließt du aus wenn du die ersten 256 Bytes ausliest ?
>
> Gruß JackFrost

void sst26_block_protection_unlock(sst26_t *DataFlash, spi_usart_t *FlashSPI){
  
  sst26_write_start(DataFlash,FlashSPI);
  sst26_wait_is_busy(DataFlash,FlashSPI);
  sst26_spi_send(DataFlash,FlashSPI,0x98,1);
}

Muss ich jedes mal 255 Bytes schreiben und auch lesen?

[Bastian W. (jackfrost)]

Schreiben kannst maximal eine ganze Page und lesen den ganzen Flash am 
Stück.

Ich meinte was willst du speichern , z.B. 0x55 und was bekommst du beim 
Auslesen raus z.B 0xFF. Die ersten 256 Bytes sind Interessant um zu 
sehen ob die alle noch auf 0xFF stehen. Nur wenn die auf 0xFF stehen 
kannst du sie beschreiben.

Gruß JackFrost

[Fabian D. (Gast)]

Verstehe ich es richtig, dass die erste lese und schreib Adresse auf 
0x000000 liegt?

[Fabian D. (Gast)]

Bastian W. schrieb:
> Was sendest du und was ließt du wieder aus ? Hast du vorher WREN
> erneut
> gesetzt ? Was ließt du aus wenn du die ersten 256 Bytes ausliest ?
>
> Gruß JackFrost

Ich bekomme von jeder Adresse die ich lesen will eine 0x02

[Bastian W. (jackfrost)]

Bekommst du das auch wenn du einen Chiperrase machst ?

Normal kannst du ab 0x000000 schreiben und lesen. Wenn die Zellen aber 
0x02 enthalten kannst du maximal noch das Bit 1 in den Zellen 
beschreiben. So lange du kein 0xFF bekommst kannst du die Zellen nicht 
beschreiben.

Ließ mal 256 Zellen ab 0x00FFFF aus. War der Flash neu ?

Nach dem Abfragen der Stati geht CS kurz auf High , oder ?

Gruß JackFrost

[Fabian D. (Gast)]

Bastian W. schrieb:
> Bekommst du das auch wenn du einen Chiperrase machst ?
> Normal kannst du ab 0x000000 schreiben und lesen. Wenn die Zellen aber
> 0x02 enthalten kannst du maximal noch das Bit 1 in den Zellen
> beschreiben. So lange du kein 0xFF bekommst kannst du die Zellen nicht
> beschreiben.
>
> Ließ mal 256 Zellen ab 0x00FFFF aus. War der Flash neu ?
> Nach dem Abfragen der Stati geht CS kurz auf High , oder ?
> Gruß JackFrost

Bastian W. schrieb:
> Bekommst du das auch wenn du einen Chiperrase machst ?
> Normal kannst du ab 0x000000 schreiben und lesen. Wenn die Zellen aber
> 0x02 enthalten kannst du maximal noch das Bit 1 in den Zellen
> beschreiben. So lange du kein 0xFF bekommst kannst du die Zellen nicht
> beschreiben.
>
> Ließ mal 256 Zellen ab 0x00FFFF aus. War der Flash neu ?
> Nach dem Abfragen der Stati geht CS kurz auf High , oder ?
> Gruß JackFrost

Der Flash ist neu. Meinst du CS oder das Busy Flag?

[Bastian W. (jackfrost)]

Ich mein CS. Aber in deinem Code hab ich gesehen du setzt das immer kurz 
auf High.

Ließt du immer noch 0x02 aus wenn du einen Chiperase machst ?

Gruß JackFrost

[Fabian D. (Gast)]

Das muss ich noch mal nach schauen. Hast du Skype?

[Fabian D. (Gast)]

Bastian W. schrieb:
> Ich mein CS. Aber in deinem Code hab ich gesehen du setzt das
> immer kurz auf High.
> Ließt du immer noch 0x02 aus wenn du einen Chiperase machst ?
> Gruß JackFrost

Ich habe die SPI Signale alle mit dem Oszilloskop angeschaut, die 
funktionieren soweit.

[Bastian W. (jackfrost)]

Ich hab Skype, bin aber atm nicht im Land.

Hast du de Flash mal komplett mit 0xC7 gelöscht. Nimm mal im
Program den Teil raus der WREN setzt, wenn du dann 0x00 ausließt ist es 
mit großer Sicherheit immer das Status Byte. Du kannst zur Sicherheit 
auch mal das Block Protected Register mit 0x72 Auslesen. Laut DB ist das 
ja nach dem Power on Reset auf 0x5555FFFFFFFF und damit ist alles a 
Rhein geschützt.

Gruß JackFrost

[Fabian D. (Gast)]

Bastian W. schrieb:
> Ich hab Skype, bin aber atm nicht im Land.
> Hast du de Flash mal komplett mit 0xC7 gelöscht


Es wäre mal richtig toll, wenn der Chip was antworten würde, dass er das 
Commando verstanden hat. Werde es gleich mal testen.

[Fabian D. (Gast)]

Es ist alles andere aber nicht 0x5555FFFFFFFF

    while (1)
  {  
    char Read[7];
    sst26_spi_send(DataFlash,FlashSPI,0x72,0);
    Read[0] = sst26_spi_receive(DataFlash,FlashSPI,0);
    Read[1] = sst26_spi_receive(DataFlash,FlashSPI,0);
    Read[2] = sst26_spi_receive(DataFlash,FlashSPI,0);
    Read[3] = sst26_spi_receive(DataFlash,FlashSPI,0);
    Read[4] = sst26_spi_receive(DataFlash,FlashSPI,0);
    Read[5] = sst26_spi_receive(DataFlash,FlashSPI,1);
    
    if (Read[0]==0x55)
    {
      LED_ON
    }else{
      LED_OFF
    }
    }

[Bastian W. (jackfrost)]

Du hast in spi read und Sent immer ein Kommando drinnen , u d bedienst 
den CS , oder bei 0x72 darf ja CS nicht auf High gehen, da sonst das 
erste Byte wieder als KOMMANDO interpretiert.

Am besten schreibst du dir eine Funktion die die Daten direkt abholt , 
also CS low -> 0x72 senden , 7 Bytes holen und dann CS High.

Das gleiche für den Chip erase. Blos mit 0xC7 und dann statt Daten holen 
ein CS auf High und dann Delay von 50 ms. Danach liest du die ersten 256 
Bytes aus die müssen dann 0xFF sein. Kannst du das oszillographieren und 
die Bilder hier einstellen ?

Gruß JackFrost

[Fabian D. (Gast)]

Bastian W. schrieb:
> Am besten schreibst du dir eine Funktion die die Daten direkt abholt ,
> also CS low -> 0x72 senden , 7 Bytes holen und dann CS High.


Sind es nicht 6 Bytes?

[Fabian D. (Gast)]

Das lese ich aus..

    while (1)
  {  

    char Read[7];
    Spi_USARTD0_Slave_Select_Low(FlashSPI);
    Spi_USARTD0_Rx_Tx(0x72);
    Read[0] = Spi_USARTD0_Rx_Tx(0x00);
    Read[1] = Spi_USARTD0_Rx_Tx(0x00);
    Read[2] = Spi_USARTD0_Rx_Tx(0x00);
    Read[3] = Spi_USARTD0_Rx_Tx(0x00);
    Read[4] = Spi_USARTD0_Rx_Tx(0x00);
    Read[5] = Spi_USARTD0_Rx_Tx(0x00);
    Read[6] = Spi_USARTD0_Rx_Tx(0x00);
    Spi_USARTD0_Slave_Select_High(FlashSPI);
    
    char Buffer[20];
    sprintf(Buffer,"Read[0] 0x%02x",Read[0]);
    Send_UART(Buffer);
    
    sprintf(Buffer,"Read[1] 0x%02x",Read[1]);
    Send_UART(Buffer);

    sprintf(Buffer,"Read[2] 0x%02x",Read[2]);
    Send_UART(Buffer);
    
    sprintf(Buffer,"Read[3] 0x%02x",Read[3]);
    Send_UART(Buffer);
    
    sprintf(Buffer,"Read[4] 0x%02x",Read[4]);
    Send_UART(Buffer);
    
    sprintf(Buffer,"Read[5] 0x%02x\n\r",Read[5]);
    Send_UART(Buffer);
    
    _delay_ms(2500);

    }
}

Anbei ein Mitschnitt..

[Fabian D. (Gast)]

Das kommt ab Speicheradresse "0" raus..(siehe Bild).

    while (1)
  {    
    char Read[255];
    char Buffer[20];
    
    Spi_USARTD0_Slave_Select_Low(FlashSPI);
    Spi_USARTD0_Rx_Tx(0x03); // CMD_READ_DATA
    Spi_USARTD0_Rx_Tx(0x00); // CMD_ADDR_MSB
    Spi_USARTD0_Rx_Tx(0x00); // CMD_ADDR
    Spi_USARTD0_Rx_Tx(0x00); // CMD_ADDR_LSB
    for(uint8_t x = 0 ; x < 255 ; x++)
    {
      Read[x] = Spi_USARTD0_Rx_Tx(0x00);  
    }
    Spi_USARTD0_Slave_Select_High(FlashSPI);
    
    for (uint8_t x = 0 ; x < 255 ; x++)
    {
      sprintf(Buffer,"Read[%d] 0x%02x",x,Read[x]);
      Send_UART(Buffer);      
    }
    _delay_ms(2500);
    }
}

[Fabian D. (Gast)]

Um den SFDP Header: 2nd DWORD aus zu lesen, sende ich folgendes..

    while (1)
  {    
    char Buffer[20];
    sst26_spi_send(DataFlash,FlashSPI,0x5A,0); // CMD_SFDP_READ
  
    sst26_spi_send(DataFlash,FlashSPI,0x00,0); // CMD_ADDR
    sst26_spi_send(DataFlash,FlashSPI,0x00,0); // CMD_ADDR  
    sst26_spi_send(DataFlash,FlashSPI,0x04,0); // CMD_ADDR
  
    sst26_spi_send(DataFlash,FlashSPI,0x00,0); // DUMMY_BYTE
    
    uint8_t x[4];
    x[0] = sst26_spi_receive(DataFlash,FlashSPI,0);
    x[1] = sst26_spi_receive(DataFlash,FlashSPI,0);
    x[2] = sst26_spi_receive(DataFlash,FlashSPI,0);
    x[3] = sst26_spi_receive(DataFlash,FlashSPI,1);    
        
    sprintf(Buffer,"x[0] 0x%02x\n\n",x[0]);
    Send_UART(Buffer);  

    sprintf(Buffer,"x[1] 0x%02x\n\n",x[1]);
    Send_UART(Buffer);
    
    sprintf(Buffer,"x[2] 0x%02x\n\n",x[2]);
    Send_UART(Buffer);
    
    sprintf(Buffer,"x[3] 0x%02x\n\n",x[3]);
    Send_UART(Buffer);    

    _delay_ms(2500);
    }

bekomme jedoch nicht zurück was da in der Tabelle steht.
Zurück kommen müsste doch..

Byte1 = 0x06
Byte2 = 0x01
Byte3 = 0x02
Byte4 = 0xFF

oder? Boah ich bin mega verwirrt.

[Bastian W. (jackfrost)]

Ist dein Board ein Xplain von Atmel oder ein eigenes ? An welchen Pin 
ist der CS vom Flash dran am PD4 wenn nein ist PD4 trotzdem zusätzlich 
als Ausgang gesetzt ?

Die Werte die kommen sind komisch vorallem wiederholen sich die Daten. 
Auch das vom Protection Block

Gruß JackFrost

[Fabian D. (Gast)]

Bastian W. schrieb:
> Ist dein Board ein Xplain von Atmel oder ein eigenes ? An welchen Pin
> ist der CS vom Flash dran am PD4 wenn nein ist PD4 trotzdem zusätzlich
> als Ausgang gesetzt ?
>
> Die Werte die kommen sind komisch vorallem wiederholen sich die Daten.
> Auch das vom Protection Block
>
> Gruß JackFrost


Ja ist ein XPlained A3BU..
Mein CS ist an PF4 angeschlossen.

[Fabian D. (Gast)]

Ich glaube du hattest Recht.
Es kam manchmal kein CS Signal..

Was ist daran falsch?

void Spi_USARTD0_Slave_Select_High(spi_usart_t *usart_spi){
  usart_spi->SS_PORT->OUTSET = (1<<usart_spi->SS);
}

[Bastian W. (jackfrost)]

Ich hatte ein ähnliches Problem bei dem CS nicht geändert wurde wenn das 
Port.outclr und Port.outset in der Funkzion waren. Ich hatte das damals 
direkt in der Main gemacht dann ging es. Ich hab keine Ahnung warum der 
gcc da was anderes gemacht hat.

Aktuell nutze ich SPI FRAM und CAN Controller , für die muss ich ein 
Delay von 80 ns setzten damit die Timings passen. Da hatte ich dann 
keine Probleme mehr.

Versuche das mal das du nach einer Funktion ein Delay von 100 ns setzt 
und ob es dann besser wird.

Gruß JackFrost

[A. B. (Gast)]

Die sich fortlaufend wiederholenden Bytes bei Read 0x03 und RBPR 0x72 
sind  0xbf, 0x26, 0x41, und das ist genau die ID ...

Das kann nur heißen, dass die SPI-Kommunikation überhaupt nicht richtig 
funktioniert. Also hat das Problem erst einmal rein gar nichts mit dem 
Flash zu tun (oder das Ding ist einfach kaputt, aber das es gerade 
kaputt ist, dass es ausgerechnet immer seine ID schickt, ist doch recht 
unwahrscheinlich).

Da läuft in Spi_USARTD0_* und/oder sst26_spi_* wohl etwas grundsätzlich 
falsch!

[A. B. (Gast)]

Fabian D. schrieb:
> Was ist daran falsch?
>
>

> void Spi_USARTD0_Slave_Select_High(spi_usart_t *usart_spi){
>   usart_spi->SS_PORT->OUTSET = (1<<usart_spi->SS);
> }
>

Assembler-Output ansehen, vielleicht wird da einfach etwas wegoptimiert 
... "volatile"???

[A. B. (Gast)]

Bastian W. schrieb:

> Ich hatte ein ähnliches Problem bei dem CS nicht geändert wurde wenn das
> Port.outclr und Port.outset in der Funkzion waren. Ich hatte das damals
> direkt in der Main gemacht dann ging es. Ich hab keine Ahnung warum der
> gcc da was anderes gemacht hat.

Das ist keine gute Idee. Man sollte dem Problem auf den Grund gehen, und 
nicht nur so lange herumwurschteln, bis es irgendwie geht. Sonst tappt 
man früher oder später wieder in etwas vergleichbares hinein.

Problem verstanden => Problem für die Zukunft erledigt.

(Aber das ist natürlich meine private Meinung)

[Fabian D. (Gast)]

Das heißt im Endeffekt, möchte ich etwas neues an einem Bereich 
schreiben, wo schon etwas drin steht, muss ich erst mal den Bereich 
löschen?

[A. B. (Gast)]

Fabian D. schrieb:
> Das heißt im Endeffekt, möchte ich etwas neues an einem Bereich
> schreiben, wo schon etwas drin steht, muss ich erst mal den Bereich
> löschen?

Ist heute denn schon wieder der 01. April???

[Bastian W. (jackfrost)]

Fabian D. schrieb:
> Das heißt im Endeffekt, möchte ich etwas neues an einem Bereich
> schreiben, wo schon etwas drin steht, muss ich erst mal den Bereich
> löschen?

Im Gegensatz zum EEPROM kannst du den Flash nur beschreiben wenn in der 
Zelle 0xFF steht. Löschen kannst du nur ganze Sektoren , Blöcke oder den 
ganzen Chip.

Wenn du also nur ein Byte von einem Sektor ändern willst musst du das 
woanders zwischen Speichern.

Gruß JackFrost

[Fabian D. (Gast)]

A. B. schrieb:
> Fabian D. schrieb:
>> Das heißt im Endeffekt, möchte ich etwas neues an einem Bereich
>> schreiben, wo schon etwas drin steht, muss ich erst mal den Bereich
>> löschen?
>
> Ist heute denn schon wieder der 01. April???

Warst du in der Schule auch so ein Klugsch*****?

[A. B. (Gast)]

Fabian D. schrieb:

> Warst du in der Schule auch so ein Klugsch*****?

Zumindest habe ich in der Schule Lesen gelernt. ;-)
Aus dem Datenblatt:

"5.20
Page-Program

... The data for the selected page address must be in the erased state 
(FFH) before initiating the Page-Program operation. ..."

Der Chip kennt ganze zwei(!) Instruktionen, die zum Programmieren 
dienen, und davon verwendet wurde ohnehin nur das "Page-Program". Dessen 
Beschreibung besteht aus drei kleinen Absätzen. Aber die zu lesen, ist 
offenbar schon zuviel der Mühe?

Irgendwie setze ich auch stillschweigend voraus, das man zumindest eine 
ungefähre Ahnung haben sollte, was man so macht. Wenn man einen 
Flash-Chip programmieren will, wäre es deswegen vielleicht hilfreich, zu 
wissen (oder sich zu informieren?!), was so ein Flash-EEPROM eigentlich 
ist ...

Statt großspurig zu verkünden "SPI läuft" (haha!), aber andererseits 
nicht mal beschreiben zu können, was denn nun eigentlich konkret nicht 
funktioniert. Erst nach der dritten Nachfrage kommt dann überhaupt mal 
substanzielle Information rüber ...