Probleme mit SRAM 23LCV1024

[Anon A. (anon1234)]

Hallo..
ich versuche mich gerade daran mit einem AT89S52 testweise Daten auf den 
den seriellen Baustein 23LCV1024 zu schreiben und danach wieder 
auszulesen.
Folgender Ablauf sollte hierfür eigentlich richtig sein:

Ablauf Schreiben :

  - WRITE : MODE REGISTER INSTRUCTION (00000001_b)
     - WRITE : BYTE MODE (00000000_b)
  - WRITE : WRITE DATA INSTRUCTION (00000010_b)
  - WRITE : Address
     - AddressByte1
     - AddressByte2
     - AddressByte3
  - WRITE : Data (1Byte)

Ablauf Lesen:

  - WRITE : READ DATA INSTRUCTION (00000011_b)
  - WRITE : Address
     - AddressByte1
     - AddressByte2
     - AddressByte3
  - READ : Data (1Byte)

Vor jedem Schreibe und Lese-Zyklus muss CS auf LOW gezogen werden (bzw. 
auf HIGH da der Pin invertiert ist), danach entsprechen wieder auf HIGH 
(bzw. auf LOW). Die Daten werden beim Schreiben in den Speicher jeweils 
bei der steigende Taktflanke übernommen und beim Lesen aus dem Speicher 
bei der fallenden Taktflanke herausgegeben. Ansonsten ist eigentlich 
alles recht trivial.

Allerdings habe ich jetzt mehrere male getestet und der Speicher gibt 
einfach keine Daten zurück. Ich habe das ganze auch mal mit dem 
Logikanalysator untersucht und bin eigentlich der Meinung, dass alles 
soweit richtig läuft, bis auf dass der Speicher das Byte halt nicht 
wieder auf SO legt.

Mein Code sieht folgendermaßen aus:
Ich nutze hierbei testweise die Adresse 00000000 00000000 00000000 und 
das Datenbyte 55h (01010101_b)

$include(at89s53.inc)

; p1.0 = NOT(CS) 
; p1.1 = SCK
; p1.2 = SI
; p1.3 = SO
; r7 = Buffer

main:
  clr p1.0        ; pull CS high  
  setb p1.0
  ;mov p2,#55h
  call writeByteMode
  call writeDataByteMode
  call readDataByteMode
  jmp main
  
writeByteMode:
  mov r7,#00000001b ; WRITE MODE REGISTER INSTRUCTION
  call write      ;
  mov r7,#00000000b   ; 0 0 = Byte Mode
  call write      ;
  clr p1.0          ; pull CS HIGH
  ret

writeDataByteMode:
  mov r7,#00000010b ; WRITE DATA INSTRUCTION
  call write
  mov r7,#00000000b
  call write
  call write
  call write
  mov r7,#55h
  call write
  clr p1.0  ; pull CS HIGH
  ret
  
readDataByteMode:
  mov r7,#00000011b ; READ DATA INSTRUCTION
  call write
  mov r7,#00000000b
  call write
  call write
  call write
  call read
  clr p1.0
  mov a,r7
  mov p2,a
  ret

; pull cs high after write
write:
  setb p1.0        ; pull CS LOW  
  mov r1,#8  
  write8BitsLoop:
    clr p1.1  ; SCK LOW
    mov a,r7
    rl a      ; rotate msb to lsb
    mov r7,a
    anl a,#00000001b  ; get lsb
    jz low_1
    high_1:
      setb p1.2
      jmp write_
    low_1:
      clr p1.2
      jmp write_
    write_:
      setb p1.1 ; SCK HIGH
      djnz r1,write8BitsLoop
    ret
    
; pull cs high after read    
read:
  setb p1.0        ; pull CS LOW  
  setb p1.1  ; SCK HIGH
  mov r7,#0h
  mov r1,#8  
  read8BitsLoop:
    clr p1.1  ; SCK LOW
    mov a,r7
    rl a
    jb  p1.3, high_2
    jnb p1.3, low_2
    high_2:
      orl a,#00000001b
      jmp read_
    low_2:
      orl a,#00000000b
    read_:
      setb p1.1 ; SCK HIGH
      mov r7,a
      djnz r1,read8BitsLoop
      ret


end

Das Datenblatt und meine Messung mit dem Logikanalysator hab ich 
angehängt..
Über jede Hilfe würde ich mich sehr freuen :)

Gruß
Anon123

[Anon A. (anon1234)]

Momentan ist mein einziger Ansatz, dass der Pin SO beim Schreiben 
Hochohmig sein soll, laut Logikanalysator jedoch auf High liegt. (High 
ist der Default wert auf allen Pins beim AT89S52)
Allerdings habe ich keine Ahnung wie ich den Pin auf Hochohmig schalten 
kann..
ich glaube Sofwareseitig mit dem µC geht das garnich oder?

[Frank K. (fchk)]

1. !CS
!CS separat steuern und in read/write nicht anfassen.
!CS muss vor jedem Befehl auf Low gesetzt werden, und nach jedem Befehl 
wieder auf High, sonst wird der Befehl nicht ausgeführt.

2. SCK
SCK am Anfang des Programms auf low setzen. Sicherstellen, dass SCK low 
ist, wenn der Zustand von !CS geändert wird. Im Ruhezustand ist SCK low.

3. Datenbits
erst Bit senden, dann SCK High, dann SCK low. Nicht anders. Setup-Zeiten 
beachten.

[Anon A. (anon1234)]

Frank K. schrieb:
> !CS muss vor jedem Befehl auf Low gesetzt werden, und nach jedem Befehl
> wieder auf High, sonst wird der Befehl nicht ausgeführt.

Mit Befehl meinst du aber nicht jedes Schreiben und lesen eines 
einzelnen Bytes, sondern so wie im Bild, dass ich angehängt hab:
 - !CS LOW
 - Dann alles was mit dem Schreiben zu tun hat
 - danach !CS wieder HIGH oder ;)

Die anderen Sachen probiere ich mal aus :)
Danke für deine Antwort!

[Frank K. (fchk)]

Anon Anon schrieb:

> Mit Befehl meinst du aber nicht jedes Schreiben und lesen eines
> einzelnen Bytes, sondern so wie im Bild, dass ich angehängt hab:
>  - !CS LOW
>  - Dann alles was mit dem Schreiben zu tun hat
>  - danach !CS wieder HIGH oder ;)

"Befehl" umfasst das Befehlsbyte am Anfang und die dazugehörigen Daten.
Also:
!CS Low - Set Mode Command - Set Mode Data - !CS High -
!CS Low - Write Command - Write Address (3x) - Write Data - !CS High
...

[Anon A. (anon1234)]

jaa genau das wollte ich sagen :)
dankeschön

[Anon A. (anon1234)]

Frank K. schrieb:
> 3. Datenbits
> erst Bit senden, dann SCK High, dann SCK low. Nicht anders. Setup-Zeiten
> beachten.

bist du dir da sicher?
weil im Datenblatt etwas davon steht, dass die Daten beim Schreiben 
immer bei der steigenden Flanke übernommen werden.

3.2 Serial Output (SO)
The SO pin is used to transfer data out of the
23LCV1024. During a read cycle, data is shifted out on
this pin after the falling edge of the serial clock.

3.3 Serial Input (SI)
The SI pin is used to transfer data into the device. It
receives instructions, addresses, and data. Data is
latched on the rising edge of the serial clock.

[Frank K. (fchk)]

Anon Anon schrieb:
> Frank K. schrieb:
>> 3. Datenbits
>> erst Bit senden, dann SCK High, dann SCK low. Nicht anders. Setup-Zeiten
>> beachten.
>
> bist du dir da sicher?
> weil im Datenblatt etwas davon steht, dass die Daten beim Schreiben
> immer bei der steigenden Flanke übernommen werden.

Ja, passt doch:
neues Bit senden
SCK HIGH
SCK LOW

und beim Lesen:
SCK HIGH
SCK LOW
neues Bit lesen

fchk

[Dirk K. (dekoepi)]

Macht das "V" in der Typenbezeichnung etwas aus? Aus meinen Quellen:

// 23LC1024 SPI RAM instructions
#define RDMR  5  // Read Mode(Status) Register
#define WRMR  1  // Write Mode(Status) Register
#define READ  3  // Read Data
#define WRITE 2  // Write Data

// 23LC1024 modes
#define BYTE_MODE       0x00
#define PAGE_MODE       0x80
#define SEQUENTIAL_MODE 0x40

// 23LC1024 Instructions are sent this way: CS LOW, send command,
// (Read/write: send address,) send data, CS HIGH

// ...

  chip_select(RAM_bank);

  // Send WRITE MODE register command to chip
  spi1_tx(WRMR);
  spi1_tx(SEQUENTIAL_MODE);
  chip_deselect();

  chip_select(RAM_bank);

  // Send READ DATA command to chip
  spi1_tx(READ);

  // as default is sequential mode, address has to be sent only at start
  address = 0;
  spi1_tx((address>>16));   //send MSByte address first
  spi1_tx((address>>8));   //then send middle address uint8_t
  spi1_tx((address));      //send LSByte address

  // loop ....
  read_back=spi1_tx(0xFF);
  chip_deselect();

So klappt es bei mir.

[Anon A. (anon1234)]

Soo.. jetzt läuft es :)
Danke euch allen für eure Hilfe.
Ich habe noch mal eine neue Messung und den Programmcode angehängt.
Das einzige was mich noch stört, ist dass die LEDs, die die gelesenen 
Daten ausgeben gelegentlich falsche oder auch gar keine Werte anzeigen 
und das auch teilweise für ein zwei Sekunden am Stück..
Ich frage mich nun ob ich noch einen Programmierfehler gemacht habe, 
oder obs einfach an meinem Steckbrett und der relativ hohen Frequenz 
liegt (Wackelkontakt und co. ...)

Was meint ihr?

[Anon A. (anon1234)]

Achso Port 0 ist SCK
      Port 1 ist SI
      Port 2 ist SO
      Port 3 ist !CS

[Anon A. (anon1234)]

Ich hab gerade festgestellt, dass ich damals den falschen code 
hochgeladen hab.
!cs muss nämlich genau anders herum angesteuert werden.
also hier nochmal der richtige code und ein screenshot vom logik 
analysator

Pin 0 NOT(CS)
Pin 1 SO
Pin 2 SI
Pin 3 SCK

[Anon A. (anon1234)]

Es gab noch einen Fehler im Taktsignal.
Zu beachten ist nämlich, dass
  - Bits, die in den Chip geschrieben werden sollen, immer bei der 
STEIGENDEN Flanke übernommen werden
  - Nits, die aus dem Chig gelesen werden sollen, immer bei der 
FALLENDEN Flanke vom Chip ausgegeben werden.

Der angehängte Quellcode sollte nun stimmen.

[alexis-mch (Gast)]

Falls jemand den 23LC1024 mit BASCOM programmiert, muss er den CS des 
RAMs auf einen separaten Pin des uP legen, denn der SS-Ausgang, der mit 
config spi = hard definiert wird, ergibt beim Read-Befehl eine 
Fehlfunktion.

SPI_RAM:                                                    'schreibt 
Test-Daten in das RAM und liest diese wieder aus

spi_ram_cs = 0                                              'CS true des 
SPI_RAM ohne SS-Pin (SPI = hard)
sdc_cmd(1) = &B00000001                                     'Mode 
Register Instruction
sdc_cmd(2) = &B00000000                                     'Byte 
Operation Mode
Spiout sdc_cmd(1), 2                                        '2 Bytes 
ausgeben
spi_ram_cs = 1                                              'CS false 
des SPI_RAM ohne SS-Pin (SPI = hard)

spi_ram_cs = 0                                              'CS true des 
SPI_RAM ohne SS-Pin (SPI = hard)
sdc_cmd(1) = &B00000010                                     'Write Data 
Instruction
sdc_cmd(2) = &B00000000                                     '1. Adress 
Byte MSB, first 7 Bits don't care
sdc_cmd(3) = &B00000000                                     '2. Adress 
Byte
sdc_cmd(4) = &B00000000                                     '3. Adress 
Byte LSB
sdc_cmd(5) = &B01010101                                     'Test Data
Spiout sdc_cmd(1), 5                                        '5 Bytes 
ausgeben
spi_ram_cs = 1                                              'CS false 
des SPI_RAM ohne SS-Pin (SPI = hard)

spi_ram_cs = 0                                              'CS true des 
SPI_RAM ohne SS-Pin (SPI = hard)
sdc_cmd(1) = &B00000011                                     'Read Data 
Instruction
sdc_cmd(2) = &B00000000                                     '1. Adress 
Byte MSB, first 7 Bits don't care
sdc_cmd(3) = &B00000000                                     '2. Adress 
Byte
sdc_cmd(4) = &B00000000                                     '3. Adress 
Byte LSB
Spiout sdc_cmd(1), 4                                        '4 Bytes 
ausgeben
                                                             'Achtung: 
hier wuerde der SS-Pin den CS kurz high schalten, was verboten ist
                                                             'deswegen 
muss dafür spi_ram_cs eingesetzt werden
Spiin temp_byte, 1                                          '1 Byte 
lesen
spi_ram_cs = 1                                              'CS false 
des SPI_RAM ohne SS-Pin (SPI = hard)

Locate 1,1
LCD "          ";                                           'LCD löschen
Locate 1,1
LCD hex(temp_byte);                                         'Data
Return

Der EAGLE-Stromlauf zeigt die Kombination des 23LC1024 und anderer 
externer Speichermedien mit einem Atmel MEGA1284.

[Uwe D. (monkye)]

Ist zwar uralt, aber die Frage ist: In welchem Mode muss die Soft-SPI 
konfiguriert werden?

[Lukas J. (lukas_j838)]

Guten Abend,

leider muss ich das Thema mit dem SPI-RAM Baustein 23A1024/23LC1024 
nochmal aufgreifen. Folgendes Problem:

Für eine zeitkritische Anwendung möchte ich Daten, die ich zuvor in 
diesem RAM eingelegt habe möglichst schnell noch einmal auslesen. Dazu 
bietet sich der sequenzielle Auslesemodus an. Leider lese ich aber in 
diesem Modus immer nur das erste Byte, sprich das Byte der zuvor 
übermittelten Adresse aus, der Adresszeiger inkrementiert also nicht. 
Deswegen lese ich derzeit Byte für Byte nach der jeweiligen 
Adressübermittlung aus, was aber auf Dauer nicht die Lösung sein kann.

Anmerkung. Der SPI wird unter anderem auch für die Kommunikation mit 
einer SD-Karte genutzt, er funktioniert auch für das byteweise Schreiben 
in den RAM tadellos.

Hier der Code zur SPI-Konfiguration:

void init_SPI_1(){
    deSelectAllSlavesPeri();
    SPI1STATbits.SPIEN=0;
    SPI1CON1bits.DISSCK=0; // internal spi clock enabled
    SPI1CON1bits.DISSDO=0; // SDO pin used by SPI
    SPI1CON1bits.MODE16=0; // 8 bits communication
    
    SPI1CON1bits.MSTEN=1; // master mode
    
    SPI1CON1bits.CKP=0; // ruhezustand takt = LOW (ram) 
    SPI1CON1bits.SMP=0; // abtastung am Ende of data output time
    SPI1CON1bits.CKE=1; // steigende Flanke 
    
    // 20MHz 
    SPI1CON1bits.SPRE=0b101; // secondary 2:1
    SPI1CON1bits.PPRE=0b11; // primary 1:1
    
    SPI1CON2bits.FRMEN=0;
    SPI1CON2bits.SPIBEN=0; //enhanced mode disabled (Enhanced=1 : FIFO enable)
    SPI1BUF=0x00; // buffer to zero
    SPI1STATbits.SPITBF=0; // clear BF
    SPI1STATbits.SPIEN=1; // enable spi
    SPI1STATbits.SPITBF=0; // clear BF   
    
    transmit_SPI1(0xFF);
    
    waitus(10);
    SPI1STATbits.SPIEN=0;
    SPI1STATbits.SPIEN=1;  
}

Hier die Konfiguration des RAM-Bausteins:

void init_RAM(){  
    
    //POWER UP RULE
    CS_RAM=0;
    waitus(20);
    CS_RAM=1;
    
    // Set Mode to Sequential (default)
    CS_RAM=0;
    transmit_SPI1(RAM_MODE_WRITE); //0x01
    transmit_SPI1(0x00);// Set Byte-Mode

    CS_RAM=1;
    
    CS_RAM=0;
    transmit_SPI1(RAM_MODE_READ);//0x05
    transmit_SPI1(0x40); //Sequenzielles Lesen
   
    CS_RAM=1;
      
}

und die Auslesefunktion:

void Read_RAM(long adress, char data[], unsigned int n_bytes){
    long adresscut;
    char test[20];
    CS_RAM=0;
    transmit_SPI1(RAM_READ);
    
    //write Adress 3 bytes
    adresscut=((adress & 0xFF0000) >> 16);
    transmit_SPI1(adresscut);
    //
    adresscut=((adress & 0x00FF00) >> 8);
    transmit_SPI1(adresscut);
    //
    adresscut=((adress & 0x0000FF) >> 0);
    transmit_SPI1(adresscut); 
    
    int i;
    for(i=0;i<n_bytes;i++){
        data[i]=ExchangeSPI(0xFF);
        
        }  
    CS_RAM=1;
}

Wenn ihr noch mehr Code braucht, lasst es mich wissen. Das Projekt ist 
zu umfangreich um alles hochzuladen.

Vielen Dank für Eure Hilfe!

[foobar (Gast)]

    // Set Mode to Sequential (default)
    CS_RAM=0;
    transmit_SPI1(RAM_MODE_WRITE); //0x01
    transmit_SPI1(0x00);// Set Byte-Mode
    CS_RAM=1;
    
    CS_RAM=0;
    transmit_SPI1(RAM_MODE_READ);//0x05
    transmit_SPI1(0x40); //Sequenzielles Lesen
    CS_RAM=1;

Hast du dir mal angeschaut, was du da machst?  Schaltest auf Byte-Mode 
und liest dann das Mode-Register nochmal aus.

[Lukas J. (lukas_j838)]

Hallo foobar,

vielen Dank für deine schnelle Antwort.

Schande über mich! Du hast natürlich vollkommen Recht. Ich war der 
Meinung, dass ich ein Read-Mode und ein Write-Mode Register separat 
setzen muss. Ein genauerer Blick ins Datenblatt hätte das verhindern 
können.

Problem gelöst!:-)