SPI - 16MBit Flash-Speicher lässt sich nicht beschreiben bzw. auslesen

[H. G. (ledi)]

Hallo,

ich versuche einen 16MBit Flash-Speicher von ST (SST25VF016B)über die 
SPI-Schnittstelle meines ATMega88 zu beschreiben bzw. auszulesen.

Datenblatt: http://www.farnell.com/datasheets/1669413.pdf

Das Statusregister auszulesen funktioniert! Das geschriebene Byte (wenn 
es denn geschrieben wurde) kann ich nicht auslesen!


Meine vorgehensweise beim Schreiben und Lesen eines Datenbytes ist 
folgende:

1.) Ein Byte auf Adresse 000000h schreiben:

CE auf low
  command 06h senden (write enable)
CE auf high

CE auf low
  command 02h senden (program one data byte)
  send addressbyte 00h (1. Adressbyte senden)
  send addressbyte 00h (2. Adressbyte senden)
  send addressbyte 00h (3. Adressbyte senden)
  send databyte AAh (datenbyte AAh senden)
CE auf high

CE auf low
  command 04h senden (write disable)
CE auf high


2.) Den Inhalt von Adresse 000000h auslesen:

CE auf low
  command 03h senden (read memory)
  send addressbyte 00h (1. Adressbyte senden)
  send addressbyte 00h (2. Adressbyte senden)
  send addressbyte 00h (3. Adressbyte senden)
  send dummybyte 00h (dummybyte 00h senden)
CE auf high

data = SPI_Receive();


hier der zugehörige Code:

#include <avr/io.h>
#include <util/delay.h>

#define WP    (1<<PC5)  // Write Protect disable @PC5
#define HOLD  (1<<PC4)  // Stop serial communication disable @PC4
#define CE    (1<<PB2)  // Chip Enable @PB2
#define MOSI  (1<<PB3)  // Master Out Slave In @PB3
#define MISO  (1<<PB4)  // Master In Slave Out @PB4
#define SCK    (1<<PB5)  // Clock @PB5

uint8_t data, status_register=0;

void SPI_MasterInit(void)
{
  DDRB = MOSI|SCK|CE;            // Set MOSI, SCK, CE output
  SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR1);  // Enable SPI, Master, set clock rate fck/64
}
void SPI_MasterTransmit(uint8_t data)
{
  SPDR = data;              // Start transmission
  while(!(SPSR & (1<<SPIF)));        // Wait for transmission complete
}

uint8_t SPI_SlaveReceive(void)
{
  while(!(SPSR & (1<<SPIF)));        // Wait for reception complete
  return SPDR;              // Return SPI-Dataregister
}

int main(void)
{
  DDRC |= WP | HOLD;            // Set WP, HOLD output
  PORTC |= WP|HOLD;            // Set WP, HOLD high 
  
    while(1)
    {
        SPI_MasterInit();            // Init SPI Master
    PORTB &= ~CE;              // CE = low (start communication)
    SPI_MasterTransmit(0x05);        // Send command 0x05 (Read the status register)
    SPI_MasterTransmit(0x00);        // Send one dummy byte             
    status_register = SPI_SlaveReceive();  // Store the value of the status register
    PORTB |= CE;              // CE = high (end of communication)
    status_register=0;            // set the variable to 0  
    _delay_us(10);
    
    PORTB &= ~CE;              // CE = low (start communication)
    SPI_MasterTransmit(0x06);        // Send command 0x06 (Set write enable WREN)
    PORTB |= CE;              // CE = high (end of communication)
    _delay_us(10);
    
    PORTB &= ~CE;              // CE = low (start communication)
    SPI_MasterTransmit(0x02);        // Send command 0x02 (program one data byte)
    SPI_MasterTransmit(0x00);        // Send 1. Addressbyte (MSB first)  
    SPI_MasterTransmit(0x00);        // Send 2. Addressbyte   
    SPI_MasterTransmit(0x00);        // Send 3. Addressbyte 
    SPI_MasterTransmit(0xAA);        // Send Databyte        
    PORTB |= CE;              // CE = high (end of communication)
    _delay_us(10);
    
    PORTB &= ~CE;              // CE = low (start communication)
    SPI_MasterTransmit(0x04);        // WRDI (write disable) Send command 0x04       
    PORTB |= CE;              // CE = high (end of communication)
    _delay_us(10);
    
    PORTB &= ~CE;              // CE = low (start communication)
    SPI_MasterTransmit(0x03);        // Send command 0x03 Read
    SPI_MasterTransmit(0x00);        // Send 1. Addressbyte (MSB first)  
    SPI_MasterTransmit(0x00);        // Send 2. Addressbyte   
    SPI_MasterTransmit(0x00);        // Send 3. Addressbyte 
    SPI_MasterTransmit(0x00);        // Send Dummybyte      
    PORTB |= CE;              // CE = high (end of communication)
    data = SPI_SlaveReceive();
    data = 0;
    }
}

[Takao K. (takao_k)]

/CE eingeschaltet lassen

[H. G. (ledi)]

Takao K. schrieb:
> /CE eingeschaltet lassen

Das sollte ich aber lt. Beschreibung im Datenblatt NICHT tun!

*** Write-Enable (WREN)***
The Write-Enable (WREN) instruction sets the Write-Enable-Latch bit in 
the Status Register to 1 allowing Write operations to occur. The WREN 
instruction must be executed prior to any Write (Program/Erase) 
operation.

Oder verstehe ich da etwas falsch?

[Takao K. (takao_k)]

Zufaellig habe ich diese chips hier und auch mal verwendet.

Ich schau mir jetzt mal das Datenblatt an.

Aber grundsaetzlich, solange du mit dem chip arbeitest, /CE = 0.

Wenn du mit dem Schreiben fertig bist, wieder auf 1, oder einfach auf 0 
lassen. Das wird hauptsaechlich beutzt, wenn du mehr als einen seriellen 
chip parallel an den gleichen Leitungen hast, und teilweise auch, um 
Strom zu sparen.

[Takao K. (takao_k)]

Ja teilweise ist es richtig, /CE wird wieder auf 1 gesetzt, wenn ein 
neues Kommando uebertragen werden soll.

du musst auch noch "End of Write" abfragen, also ob der chip mit dem 
Schreiben fertig ist. Oder du verlaesst dich auf die 10uS Angabe aus dem 
Datenblatt...

PORTC wuerde ich auch erstmal auf 0 setzen, dann den Tristate bus 
einschalten.

vielleicht erst einmal mit "Bitbang" versuchen, wenn es fuktionert, den 
Hardware serial port verwenden.

Anstatt 10uS 100uS versuchen.
PORTC auf 0 setzen.
Bitbang verwenden zum Testen.

[Arc N. (arc)]

Da müssen einige Sachen vorher passieren, damit das klappt.
Hier ist es bspw. so implementiert:
(Pseudocode)

ProgStart
  /CE = 0 
  Transmit(EWSR)
  /CE = 1
  /CE = 0
  Transmit(WRSR)
  // WEL = 1, BPx = 0, da das Flash nach dem PowerOn/Reset 
  // alle Speicherblöcke vor Schreibzugriffen schützt (Table 3 und 4 im DB)
  Transmit(0b00000010); 
  /CE = 1
  ...

MemWrite
  /CE = 0
  Transmit(WREN)
  /CE = 1

  /CE = 0
  // jetzt der eigentliche Schreibvorgang
  /CE = 1

[Dominic A. (neo123)]

Mit den Speichertypen habe ich auch lange gekämpft. Bis ich 
herausgefunden habe das bei jedem Start der Flash zuerst unlockt werden 
muss.
Probier also mal vor dem Schreiben eine Unlock Sequenz durchzuführen.

[Bastler (Gast)]

Hallo ich hänge am gleichen Problem.

Ich habe das Beispiel von ST verwendet.
Die CHIP-ID kann ich auslesen, von daher steht meine SPI Verbindung.
Aber ich kann nichts schreiben oder lesen.
Sogenau weiß ich es nicht, da ich beim lesenn immer 0xFF empfange.
Der leere Baustein ist ja mit 0xFF gefüllt.

Ich vermute ein Fehler im Schreibvorgang.

Ist im Beispiel ein Fehler?