FRAM via SPI

[Torsten A. (torsten_a)]

Hallo,

ich möchte mit einen atmega2560 einen F-RAM (FM25H20 mit 2Mb Serial 3V) 
via SPI betreiben. Bisher sind meine Versuche nicht gerade von Erfolg 
gekrönt.

Der Atmega wird mit einen externen 8 MHz Quarz betrieben.

Der FRAM FM25H20 unterstützt: Very Fast Serial Peripheral Interface - 
SPI
• Up to 40 MHz Frequency
• Direct Hardware Replacement for Serial Flash
• SPI Mode 0 & 3 (CPOL, CPHA=0,0 & 1,1)

[http://www.ramtron.com/files/datasheets/FM25H20_ds.pdf]

-kurze Pinbelegung am Atmega:

PB3(MISO),
PB2(MOSI),
PB1(SCK),
PB6(/CS) vom FRAM (low active)



Meine SPI Initialisierung lautet:

/********************************************************************************************
*               FRAM_SPI_INIT_START FUNCTION
*
* Description : This function initialize the SPI communication.
*               data rate 4 MHz (Double SPI Speed)
* Arguments   : None
* Returns     : None
* Note        : Internal Function
*********************************************************************************************/
//SPI2X SPR1 SPR0 (SPR[2:0])
//SPR[2:0]       Divisor     Frequency ( E=8 MHz )
//000              2           4.0 MHz
void fram_spi_init_start(void)
{  
  // MISO=input, etc.=output
  DDRB &= ~(1 << PB3);
  DDRB |= (1 << PB2) | (1 << PB1) | (1 << PB6);
  
  
  // PB3(MISO), PB2(MOSI), PB1(SCK), PB6(/CS)
  PORTB |= (1 << PB6); // CS=1, waiting for SPI start    
  PORTB &= ~((1 << PB3) | (1 << PB2) | (1 << PB1)); 
  
  
  /* set SPI Control Register */
  /* SPIE | SPE | DORD | MSTR | CPOL | CPHA | SPR1 | SPR0 */
  /*    0     1    0     1    0     0   0      0   */
  SPCR = 0x00;
  SPCR = (1<<SPE) | (1<<MSTR); // SPI enable / Mode 0 / fosc/2 
  
  /* set SPI Status Register */
  /* SPIF | WCOL | - | - | - | - | - | SPI2X */
  SPSR = 0x01;                // SPI2X = 1 = Double SPI Speed Bit (fosc/2)
}

Mit der nachfolgenden Funktion sollen Daten geschrieben oder gelesen 
werden:

/********************************************************************************************
*               FRAM_SPI_IO_BYTE FUNCTION
*
* Description : This function writes/reads one byte into/from FRAM.
* Arguments   : 16 bit address, 8 bit data, data direction (wr=1; rd=0)
* Returns     : 8 bit data
* Note        : Internal Function
*********************************************************************************************/
unsigned char fram_spi_io_byte(unsigned int addr, unsigned char data_out, unsigned char data_direction)
{
  unsigned char data = 0;    

  /* SPI MODE I/F initialization */
  fram_spi_init(data_direction);

  /* set address */
  fram_spi_set_addr(addr);
  
  if(data_direction)
  {
    SPDR = data_out;  // write data
  } else
  {
    SPDR = 0x00;    // dummy value for shift register
  }
  while((SPSR&0x80)==0x00);
   
  if(!(data_direction))
  {
    data = SPDR;     // read data
  } 

  /* terminate spi data transfer */
  fram_spi_end();  

  if(data_direction)
  {
    return 1;
  } else
  {
    return data;
  }  
}

hier noch die Funktionen: fram_spi_init() + fram_spi_set_addr() + 
fram_spi_end()

/********************************************************************************************
*               FRAM_SPI_INIT FUNCTION
*
* Description : This function initialize the SPI communication.
* Arguments   : data direction (write=1; read=0)
* Returns     : None
* Note        : Internal Function
*********************************************************************************************/
void fram_spi_init(unsigned char data_direction)
{  
  PORTB &= ~((1 << PB3) | (1 << PB2) | (1 << PB1) | (1 << PB6)); // CS=0, SPI start
  
  if(data_direction)
  {
    SPDR = 0x02;    // write (Op-code Command Write Memory Data 0000 0010b)
  } else
  {
    SPDR = 0x03;    // read (Op-code Command Read Memory Data 0000 0011b)
  }  
  while((SPSR&0x80)==0x00);
}


/********************************************************************************************
*               FRAM_SPI_SET_ADDR FUNCTION
*
* Description : This function sets the address of the FRAM registers.
* Arguments   : 16 bit address
* Returns     : None
* Note        : Internal Function
*********************************************************************************************/
void fram_spi_set_addr(unsigned int addr)
{  
  SPDR = 0x00;
  while((SPSR&0x80)==0x00);
  
  SPDR = (unsigned char)((addr & 0xFF00) >> 8);
  while((SPSR&0x80)==0x00);
  
  SPDR = (unsigned char)(addr & 0x00FF);
  while((SPSR&0x80)==0x00);
}


/********************************************************************************************
*               FRAM_SPI_END FUNCTION
*
* Description : This function terminate the spi data transfer.
* Arguments   : None
* Returns     : None
* Note        : Internal Function
*********************************************************************************************/
void fram_spi_end(void)
{
  PORTB |= (1 << PB6);
  PORTB &= ~((1 << PB3) | (1 << PB2) | (1 << PB1)); // SPI end  
}

Mit diesen Code-Zeilen kann ich an Adresse 0 und 1 Daten auslesen --> 
also muss bei meinen anfänglichen Versuchen ein "Code-Geschnipsel" 
erfolgreich gewesen sein. Demnach würde jetzt das Schreiben nicht mehr 
funktionieren.

Hat Jemand eine Idee was hier falsch ist oder vergessen wurde? Hat 
jemand Erfahrungen mit diesen FRAM - vielleicht habe ich im Datenblatt 
irgendwas überlesen???

Gruß Torsten

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

WREN - Set Write Enable Latch
The FM25H20 will power up with writes disabled. 
The WREN command must be issued prior to any write operation.

Such mal nach dem Kommando im Datenblatt. Das kann ich in deinem Code 
nicht finden...

[Torsten A. (torsten_a)]

Guter Hinweis!

ich habe jetzt folgende Funktion nach fram_spi_init_start() eingebunden:

/********************************************************************************************
*               FRAM_SPI_WRITE_ENA FUNCTION
*
* Description : This function sets Write Enable Latch
* Arguments   : none
* Returns     : none
* Note        : Internal Function
*********************************************************************************************/
void fram_spi_write_ena()
{    

  /* SPI MODE I/F initialization */
  PORTB &= ~((1 << PB3) | (1 << PB2) | (1 << PB1) | (1 << PB6)); // CS=0, SPI start
  
  SPDR = 0x06; // set write ena (Op-code Command: Set Write Enable Latch 0000 0110b)              
  while((SPSR&0x80)==0x00);
  
  /* terminate spi data transfer */
  fram_spi_end();  
}

brachte aber keine Veränderung :(

[Frank K. (fchk)]

Du musst das WREN vor jedem(!) Schreibzugriff senden. Das Flag wird nach 
einem Schreibzugriff automatisch zurückgesetzt. Das machen alle 
SPI-EEPROMS und Flashes so.

fchk

[Torsten A. (torsten_a)]

Vor jedem Schreiben schicke ich jetzt das WREN commando....

/********************************************************************************************
*               FRAM_SPI_IO_BYTE FUNCTION
*
* Description : This function writes/reads one byte into/from FRAM.
* Arguments   : 16 bit address, 8 bit data, data direction (wr=1; rd=0)
* Returns     :  8 bit data
* Note        : Internal Function
*********************************************************************************************/
unsigned char fram_spi_io_byte(unsigned int addr, unsigned char data_out, unsigned char data_direction)
{
  unsigned char data = 0;    


  if(data_direction)
  {
    fram_spi_write_ena();
  }
  
  /* SPI MODE I/F initialization */
  fram_spi_init(data_direction);

  /* set address */
  fram_spi_set_addr(addr);
  
  if(data_direction)
  {
    SPDR = data_out;        // write data
  } else
  {
    SPDR = 0x00;    // dummy value for shift register
  }
  while((SPSR&0x80)==0x00);
   
  if(!(data_direction))
  {
    data = SPDR;     // read data
  } 

  /* terminate spi data transfer */
  fram_spi_end();  

  if(data_direction)
  {
    return 1;
  } else
  {
    return data;
  }  
}

ohne Erfolg......

[Torsten A. (torsten_a)]

werde wohl weiter herumexperimentieren müssen....

[(prx) A. K. (prx)]

Probier mal Mode 3. Ich war bei einem AVR, der ein Atmel Dataflash, ein 
FRAM und ein ENC28J60 an seinem SPI hängen hat, über SPI-Probleme 
gestolpert. Zwar konnten alle offiziell den SPI Mode 0, aber eines davon 
bewies eine etwas andere Ansicht dazu, indem die Bits dabei um eine 
Position verrutschten. Ich weiss nur grad nicht mehr, welches der 3 
SPI-Devices das war.

[Torsten A. (torsten_a)]

habe jetzt auch SPI-Mode 3 ausprobiert:

SPCR = (1<<SPE) | (1<<MSTR) | (1<<CPOL) | (1<<CPHA); // SPI Mode 3

das Auslesen scheint zu funktionieren - aber nicht das Schreiben....

Habe leider keine Ahnung mit welchen Code-Zeilen bzw. mit welcher 
Prozedur das Schreiben funktioniert hat. Wahrscheinlich hat da das 
Auslesen nicht funktioniert und deshalb wurde der Code von mir 
verworfen.

Ich werde mal die Frequenz verringern......

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Frank K. schrieb:
> Du musst das WREN vor jedem(!) Schreibzugriff senden.
Das ist ein weit verbreiteter Irrtum. Hierzu das Datenblatt:

Sending the WREN op-code causes the internal Write 
Enable Latch to be set. A flag bit in the Status 
Register, called WEL, indicates the state of the latch. 
WEL=1 indicates that writes are permitted.

Fazit: einmal gesetzt bleibt das Write Enable gesetzt, bis die Spannung 
weg geht oder ein WRDI - Write Disable gesendet wird.

A. K. schrieb:
> Probier mal Mode 3.
Ich würde jetzt auch mal das Bit-Timing nochmal genau anschauen. Nicht 
alle SPI-Devices Schieben auf der einen und Latchen auf der anderen 
Flanke...
Insbesondere würde ich mich auf solche expliziten Angaben (CPOL, 
CPHA=0,0 & 1,1) nicht verlassen. Nicht alle Hersteller haben diese Bits 
gleich implementiert. Da hilft nur das Vergleichen der Timing-Diagramme 
der beiden betroffenen Komponenten (uC und FRAM)...

EDIT:
> Ich werde mal die Frequenz verringern......
Das wird nicht nötig sein, denn 4MHz << 40MHz.
Wenn es aber eine Änderung bringt, dann zurück zum Bittiming...

[Arc N. (arc)]

Ein paar Punkte:
- das Verändern der Pin-Zustände (SCK, MISO, MOSI) zusammen mit CS 
sollte man grundsätzlich vermeiden d.h. erst /CS auf High dann die Ports 
initialisieren, dann SPI initialisieren, dann irgendwann die 
Kommunikation mit dem externen Baustein.
- beim Lesen wird ein Byte zuviel gelesen bzw. das erste wird verworfen

SPITransceive(uint8_t value) {
    SPDR = value;
    while((SPSR&0x80)==0x00);
    return SPDR;
}

void FRAMSelect(void) {
   ...
}

void FRAMDeselect(void) {
   ...
}

// dann können die anderen Befehle einfach zusammengesetzt werden
void FRAMWREN(void) {
   FRAMSelect();
   SPITransceive(6);
   FRAMDeselect();
}

void FRAMRead(uint_8* destP, uint16_t addr, uint16_t count) {
    uint16_t i;

    if (!destP) return;
    
    FRAMSelect();
    // command
    SPITransceive(3);
    // address
    SPITransceive(0);
    SPITransceive((addr >> 8) & 0xff);
    SPITransceive(addr & 0xff);
    // data
    for (i = 0; i < count; i++) {
        *destP++ = SPITransceive(0);
    }

    FRAMDeselect();
}

void FRAMWrite(uint8_t* srcP, uint16_t addr, uint16_t count) {
    uint16_t i;

    if (!srcP) return;

    FRAMWREN();
    
    FRAMSelect();
    // command
    SPITransceive(2);
    // address
    SPITransceive(0);
    SPITransceive((addr >> 8) & 0xff);
    SPITransceive(addr & 0xff);
    // data
    for (i = 0; i < count; i++) {
        SPITransceive(*srcP++);
    }

    FRAMDeselect();
}
// nichts getestet, sollte aber passen

[Frank K. (fchk)]

Lothar Miller schrieb:
> Frank K. schrieb:
>> Du musst das WREN vor jedem(!) Schreibzugriff senden.
> Das ist ein weit verbreiteter Irrtum. Hierzu das Datenblatt:
>

> Sending the WREN op-code causes the internal Write
> Enable Latch to be set. A flag bit in the Status
> Register, called WEL, indicates the state of the latch.
> WEL=1 indicates that writes are permitted.
>

> Fazit: einmal gesetzt bleibt das Write Enable gesetzt, bis die Spannung
> weg geht oder ein WRDI - Write Disable gesendet wird.

Ich lese aber auch:

Write Operation
All writes to the memory array begin with a WREN
op-code. The next op-code is the WRITE instruction.
This op-code is followed by a three-byte address
value, which specifies the 18-bit address of the first
data byte of the write operation.

fchk

[Torsten A. (torsten_a)]

Frank K. schrieb:
> Write Operation
> All writes to the memory array begin with a WREN
> op-code. The next op-code is the WRITE instruction.
> This op-code is followed by a three-byte address
> value, which specifies the 18-bit address of the first
> data byte of the write operation.

werde ich gleich ausprobieren.....habe danach die Start-addresse nicht 
gesendet

[Torsten A. (torsten_a)]

Arc Net schrieb:
> Ein paar Punkte:
> - das Verändern der Pin-Zustände (SCK, MISO, MOSI) zusammen mit CS
> sollte man grundsätzlich vermeiden d.h. erst /CS auf High dann die Ports
> initialisieren, dann SPI initialisieren, dann irgendwann die
> Kommunikation mit dem externen Baustein.
> - beim Lesen wird ein Byte zuviel gelesen bzw. das erste wird verworfen


Ich habe jetzt mal diesen Code ausprobiert und erhalte das Gleiche 
Ergebnis - ich kann an Addr 0 und 1 die Werte auslesen aber nicht 
schreiben. Trotzdem Danke!!!

unsigned char SPITransceive(unsigned char value) {
    SPDR = value;
    while((SPSR&0x80)==0x00);
    return SPDR;
}

void FRAMSelect(void) {
    PORTB &= ~(1 << PB6); 
}

void FRAMDeselect(void) {
    PORTB |= (1 << PB6); 
}

// dann können die anderen Befehle einfach zusammengesetzt werden
void FRAMWREN(void) {
   FRAMSelect();
   SPITransceive(6);
   FRAMDeselect();
}

unsigned char FRAMRead(unsigned int addr) {
    unsigned char data;
    
    FRAMSelect();
    // command
    SPITransceive(3);
    // address
    SPITransceive(0);
    SPITransceive((addr >> 8) & 0xff);
    SPITransceive(addr & 0xff);
    // data
    data = SPITransceive(0);

    FRAMDeselect();
}

void FRAMWrite(unsigned int addr, unsigned char data) {

    //FRAMWREN();
    
    FRAMSelect();
    // command
    SPITransceive(2);
    // address
    SPITransceive(0);
    SPITransceive((addr >> 8) & 0xff);
    SPITransceive(addr & 0xff);
    // data
    SPITransceive(data);

    FRAMDeselect();
}

[♪Geist (Gast)]

>werde wohl weiter herumexperimentieren müssen....
Wie wäre es lieber mit nachdenken?

>void fram_spi_init(unsigned char data_direction)
>{
>  PORTB &= ~((1 << PB3) | (1 << PB2) | (1 << PB1) | (1 << PB6));
Warum löschst du PB3, wenn es MISO ist?  Wozu überhaupt die Zeile? Du 
nutzt doch Hardware SPI, also lass die Pins in Ruhe das machen, was die 
Hardware machen muss.

>Write Operation
>All writes to the memory array begin with a WREN
>op-code.
Das ist falsch. Ein Mal setzen reicht.

[Arc N. (arc)]

Frank K. schrieb:
> Lothar Miller schrieb:
>> Frank K. schrieb:
>>> Du musst das WREN vor jedem(!) Schreibzugriff senden.
>> Das ist ein weit verbreiteter Irrtum. Hierzu das Datenblatt:
>> Fazit: einmal gesetzt bleibt das Write Enable gesetzt, bis die Spannung
>> weg geht oder ein WRDI - Write Disable gesendet wird.
>
> Ich lese aber auch:

> fchk

oder den gesamten Abschnitt lesen (scnr)

"WREN - Set Write Enable Latch
Sending the WREN op-code causes the internal Write
Enable Latch to be set. A flag bit in the Status
Register, called WEL, indicates the state of the latch.
WEL=1 indicates that writes are permitted.
Attempting to write the WEL bit in the Status
Register has no effect on the state of this bit – only
the WREN op-code can set this bit.

The WEL bit will be automatically cleared on the rising edge of /S
following a WRDI, a WRSR, or a WRITE operation.
This prevents further writes to the Status Register or
the F-RAM array without another WREN command.
Figure 5 below illustrates the WREN command bus
configuration."

Kurz gesagt: Alle Write-Befehle nach einem WREN setzen den Schreibschutz 
wieder, alle Read-Befehle lassen ihn unangetastet.
Ähnliches gilt z.B. für M25P, M25PX, SST25 (da muss nach dem Power-On 
auch der Schreibschutz für die Blöcke aufgehoben werden), AT25, 25AA/LC

[Torsten A. (torsten_a)]

Frank K. schrieb:
> Write Operation
> All writes to the memory array begin with a WREN
> op-code. The next op-code is the WRITE instruction.
> This op-code is followed by a three-byte address
> value, which specifies the 18-bit address of the first
> data byte of the write operation.

geht immer noch nicht

[Frank K. (fchk)]

void FRAMWrite(unsigned int addr, unsigned char data) {

    FRAMSelect();
    //FRAMWREN();
    SPITransceive(6);
    FRAMDeselect();
    FRAMSelect();
    // command
    SPITransceive(2);
    // address
    SPITransceive(0);
    SPITransceive((addr >> 8) & 0xff);
    SPITransceive(addr & 0xff);
    // data
    SPITransceive(data);
    FRAMDeselect();

[Torsten A. (torsten_a)]

Frank K. schrieb:
> void FRAMWrite(unsigned int addr, unsigned char data) {
>
>     FRAMSelect();
>     //FRAMWREN();
>     SPITransceive(6);
>     FRAMDeselect();
>     FRAMSelect();
>     // command
>     SPITransceive(2);
>     // address
>     SPITransceive(0);
>     SPITransceive((addr >> 8) & 0xff);
>     SPITransceive(addr & 0xff);
>     // data
>     SPITransceive(data);
>     FRAMDeselect();


ist das gleiche in grün....

[Andreas (Gast)]

Hast du schon mal das Statusregister ausgelesen, ob WEL auch gesetzt 
ist?
Der Chip hat auch eine Schreibschutzfunktion (BP0, BP1)...

[Torsten A. (torsten_a)]

Danke für Eure Hilfe!! Ich melde mich wenn ich das Rätsel gelöst 
habe.....

[(prx) A. K. (prx)]

Mal nachgesehen - das FRAM läuft in Mode 0, es ist das Dataflash was 
partout Mode 3 wollte.

#define FM_WREN  0x06  // set write enable latch
#define FM_WRDI  0x04  // write disable
#define FM_RDSR  0x05  // read status register
#define FM_WRSR  0x01  // write status register
#define FM_READ  0x03  // read memory data
#define FM_WRITE 0x02  // write memory data

#define SPI_MODE 0

#define select()   FRAM_SEL_PORT &= ~(1<<FRAM_SEL_BIT)
#define deselect() FRAM_SEL_PORT |=  (1<<FRAM_SEL_BIT)

void
spi_init(uint8_t mode)
{
    SPI_DDR |= 1<<SPI_MOSI_BIT | 1<<SPI_SCK_BIT;
    SPCR = 1<<SPE | 0<<DORD | 1<<MSTR | 0<<SPR1|0<<SPR0 | mode<<CPHA;
    SPSR = 1<<SPI2X;
}

uint8_t
spi(uint8_t data)
{
    SPDR = data;
    while (!(SPSR & 1<<SPIF))
        ;
    return SPDR;
}

void
fram_init(void)
{
    FRAM_SEL_PORT |= 1<<FRAM_SEL_BIT;
    FRAM_SEL_DDR  |= 1<<FRAM_SEL_BIT;
}

void
fram_read(unsigned addr, uint8_t *data, unsigned size)
{
    spi_init(SPI_MODE);
    
    select();
    spi(FM_READ);
    spi(addr >> 8);
    spi(addr);
    while (size--)
        *data++ = spi(0);
    deselect();
}

void
fram_write(unsigned addr, uint8_t *data1, unsigned size1, uint8_t *data2, unsigned size2)
{
    spi_init(SPI_MODE);
    
    select();
    spi(FM_WREN);
    deselect();
    
    select();
    spi(FM_WRITE);
    spi(addr >> 8);
    spi(addr);
    for (; size1; --size1)
        spi(*data1++);
    for (; size2; --size2)
        spi(*data2++);
    deselect();
}

[Torsten A. (torsten_a)]

Andreas schrieb:
> Hast du schon mal das Statusregister ausgelesen, ob WEL auch gesetzt
> ist?
> Der Chip hat auch eine Schreibschutzfunktion (BP0, BP1)...

Habe vergessen Deine Frage zu beantworten...

Das Status Register hat immer den Inhalt 1100 0000b auch wenn ich es 
nach einem Schreibversuch auslese, sogar nach dem power-up!??


----------------------------------------
Table 2. Status Register
Bit    7  6 5 4  3   2   1  0
Name WPEN 1 0 0 BP1 BP0 WEL 0

[Torsten A. (torsten_a)]

Nach dem Senden des OP-Code "Set Write Enable Latch" steht das Status 
Register auf 1100 0010b.

[Frank B. (f-baer)]

Torsten Albrecht schrieb:
> ----------------------------------------
> Table 2. Status Register
> Bit    7  6 5 4  3   2   1  0
> Name WPEN 1 0 0 BP1 BP0 WEL 0

WPEN = Write Protect Enable

Im Statusregister ist Bit7 gesetzt. Noch Fragen? Erstmal solltest du den 
FRAM aus dem Write Protect rausholen, danach kannst du auch schreiben.

[Torsten A. (torsten_a)]

Frank Bär schrieb:
> WPEN = Write Protect Enable
>
> Im Statusregister ist Bit7 gesetzt. Noch Fragen? Erstmal solltest du den
> FRAM aus dem Write Protect rausholen, danach kannst du auch schreiben.

Habe mich falsch ausgedrückt, nachdem ich einmalig den OP-Code WREN 
gesendet habe, steht im Register 1100 0010. siehe Tabelle

Table 4. Write Protection
WEL WPEN /W Protected Blocks Unprotected Blocks Status Register
1   1    1      Protected       Unprotected      Unprotected

demnach sollte das Schreiben möglich sein! Geht aber nicht!!!

[Torsten A. (torsten_a)]

habe noch eine application note gefunden

http://www.ramtron.com/files/application_notes/AN304.pdf

im Beispiel wird vor jedem Schreibvorgang der OP-CODE WREN gesendet!

Das hatte ich ja auch schon ausprobiert - ohne Erfolg!?

[Torsten A. (torsten_a)]

Werde mir wohl mal die Signale anschauen müssen.