SRAM - IS61LV25616AL Ansteuerung

[Ramon F. (tronixx)]

Hallo zusammen,

ich habe ein Problem mit der Ansteuerung meines SRAMs, wobei ich eure 
Hilfe gebrauchen könnte. Hab mich schon durch alle Beiträge hierzu 
durchgebissen, hilft aber iwie nichts .

zu meiner Ausgangssituation:
- Spartan 3 Board (Digilent)
- SRAM IS61LV25616AL
- 16 Bit mit 8,8MHz einlesen/speichern
- 16 Bit mit 25MHz auslesen

Datenblatt zu SRAM : http://www.issi.com/pdf/61LV25616AL.pdf

Verhältnis Eingangstakt vs -Daten siehe Abbildung 1 (Gelb: 8,8MHz, Blau: 
Daten. Die Daten ändern sich ca. 10ns vor der steigenden Taktflanke.

Momentan lese ich die Daten gemäß Abbildung 2 ein (Eingangsdaten 
simuliert).
Timing dazu in Abb. 3


Ausgelesen werden diese siehe Abb. 4.  Die 50 MHz stehen noch drinn weil 
ich es vorher mit der READ-Variante Nr. 2 versucht habe, auch leider 
ohne erfolg. Wie man sehen kann sollen die daten auch nur alle 25ns 
ausgegeben werden.


Fazit: Mein Bild was ich an meinem Display sehe zeigt nur abwechselnd 
2-3 eine Farben an, jede Farbe aber über den Ganzen Schirm + 
"SChwarzflackern". Das Ursprungsbild besitzt unteranderem diese Farben, 
sodass ich zu der Annahme komme, das mein Ram iwie nicht jeden einzelnen 
Pixel speichert / ausgibt.
Was sagt Ihr denn zu meinem Timing. Iwo muss doch ein Fehler sein.
wäre euch sehr dankbar

MfG

[bko (Gast)]

Dieses ist laut Datenblatt ein asyncrones RAM und hat damit
keinen Takt Eingang. Das Signal "WE" gibt den Zeitbezug beim
Schreiben vor!. Wie lange liegt die Adresse vor der fallenden
"WE" flanke an, und wielange danach?

[Ramon F. (tronixx)]

Hallo,

>Dieses ist laut Datenblatt ein asyncrones RAM und hat damit
>keinen Takt Eingang.
der Takt spielt an sich auch keine Rolle. dieser soll nur zeigen (siehe 
Abb. 1) wie die Daten vorliegen.

>Das Signal "WE" gibt den Zeitbezug beim
>Schreiben vor!. Wie lange liegt die Adresse vor der fallenden
>"WE" flanke an, und wielange danach?
Mit der fallenden Flanke von WE ändert sich auch die Adresse,
da "tha" und "tsa" beide minumum 0ns haben (siehe Abb 3.)

MfG

[bko (Gast)]

Tsa >0ns ist wie sichergestellt?

Und auch mal mit dem Oszi am RAM-Chip oder auch am Stecker angesehen?

Und ist "We(not)" etwa vom Takt kombinatorisch abgeleitet?
(sieht auf der Waveform zumindest danach aus..)
Wenn ja, dann mal hier nachlesen:
Beitrag "Clk auf Portausgang"

[Ramon F. (tronixx)]

>Tsa >0ns ist wie sichergestellt?
ich versteh diese Frage leider nicht so ganz

>Und auch mal mit dem Oszi am RAM-Chip oder auch am Stecker angesehen?
Am RAM noch nicht -> folgt
Signale am Eingang liegen an, wurden auch schon separat getestet.
Pinbelegung mehrfach überprüft.
muss ich hinsichtlich der RAM-leitungen in der ucf-file was beachten?

>Und ist "We(not)" etwa vom Takt kombinatorisch abgeleitet?
ja, WE entspricht (not)clk. Da wir hier aber nur von 8,8 MHz sprechen 
brauch ich doch wohl kein extra buffer, DCM (geht ehh erst ab 25 MHz) 
etc.

was ist den generell mit dem Timing? Soweit ist doch alles so wie es das 
Datenblatt verlang, oder irre ich mich?

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

Ramon F. schrieb:
>>Und auch mal mit dem Oszi am RAM-Chip oder auch am Stecker angesehen?
> Am RAM noch nicht -> folgt
Dann klemm die Masse jedes einzelnen Tastkopfs auch direkt in der Nähe 
an. Dann klingelt es nicht so...

Ramon F. schrieb:
> - 16 Bit mit 8,8MHz einlesen/speichern
> - 16 Bit mit 25MHz auslesen
Das ist eigentlich recht entspannt...
Und du hast da zwei "Teilnehmer"?

Ramon F. schrieb:
> Iwo muss doch ein Fehler sein.
Ja, vermutlich aber nicht im zeitlichen Zugriff, sondern bei der 
Arbittrierung des RAMs. Wie schaltest du zeichen den beiden 
Teilnehmern/Clockdomänen um?

[Ramon F. (tronixx)]

Hallo,
da das ganze schon etwas unübersichtlicher wird, wollte ich einmal mit 
einem kleinen Code mein SRAM testen und es auch so besser zu verstehen.
wenn das hier klappt kann ich das ganze auch auf mein Prob. anwenden.
Nur leider will das ganze nicht so ganz.

Der Code soll einfach nur die RAM Adresse 3 abwechselnt lesen und neu 
beschreiben. Die Daten werden durch 3 switches vorgegeben. Ausgabe 
erfolgt dann über die LEDs.
Nun fängt das theater schon an .

bei der Synthese gibt er folgende Warnungen aus. (gilt für alle 
data_write Signale (0-15)

WARNING:Xst:1896 - Due to other FF/Latch trimming, FF/Latch 
<data_write_0> has a constant value of 0 in block <SRAM_Tester>. This 
FF/Latch will be trimmed during the optimization process.

und bei Place & Route:
WARNING:Par:100 - Design is not completely routed. There are 26 signals 
that are not completely routed in this design

finde / verstehn den Fehler nicht

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.STD_LOGIC_arith.ALL;
use IEEE.STD_LOGIC_unsigned.ALL;

library UNISIM; 
use UNISIM.vcomponents.all;


entity SRAM_Tester is
    Port ( clk : in   STD_LOGIC;
   
        led  :  out STD_Logic_vector (2 downto 0);
        
        switch   : in  STD_LOGIC_vector (2 downto 0);
   
        sram_a_out  : out STD_Logic_vector (17 downto 0);
        sram_io    : inout STD_Logic_vector (15 downto 0);
        ub     : out  STD_LOGIC;
        lb     : out  STD_LOGIC; 
        oe     : out  STD_LOGIC;
        ce     : out  STD_LOGIC;
        we     : out  STD_LOGIC);
        
end SRAM_Tester;




architecture Behavioral of SRAM_Tester is


signal zustand     :  STD_LOGIC_VECTOR (2 downto 0)   :=  "000";

signal data_read    :  STD_LOGIC_VECTOR (15 downto 0)   := "0000000000000000";
signal data_write    :  STD_LOGIC_VECTOR (15 downto 0)   := "0000000000000000";
signal read_write    :  STD_LOGIC                := '0';  --(read = '1', write ='0')


component IOBUF_LVCMOS33 
port  (
  O : out   std_logic;
  IO: inout std_logic;
  I : in   std_logic;
  T : in   std_logic
  );
end component;

-----------------------------------------------------------------------------
begin


loop1: For i IN sram_io'RANGE generate
IOB_1: IOBUF_LVCMOS33 port map
  (O   => data_read(i),
  IO  => sram_io(i),
  I   => data_write(i),
  T  => read_write);
 end generate loop1;

-----------------------------------------------------------------------------


ub     <= '0';
lb     <= '0';


write_data: process (clk)
begin
    if rising_edge (clk)
    then
      
    if (zustand = "000")        --INIT
    then
        sram_a_out <= "000000000000000000";
        oe          <= '0';
        ce        <= '1';
        we        <= '1';
        
        read_write  <= '0';
        data_write  <= "0000000000000000";
        
        zustand     <= "001";
    
    -- WE controlled write-------------------------------------------------
    elsif (zustand = "001")      
    then
        sram_a_out <= "000000000000000011";      --schreibe in Adresse 3
        oe          <= '0';
        ce        <= '0';
        we        <= '0';
        
        read_write  <= '0';
        data_write  <= "0000000000000" & switch;
        
        zustand     <= "010";
    
    
    --Clear----------------------------------------------------------------
    elsif (zustand = "010")
    then
        sram_a_out <= "000000000000000000";      
        oe          <= '0';
        ce        <= '1';
        we        <= '1';
        
        read_write  <= '0';
        data_write  <= "0000000000000000";
        
        zustand     <= "011";

    
    --Read Adress Controlled-----------------------------------------------
    elsif (zustand = "011")
    then
        sram_a_out <= "000000000000000011";      
        oe          <= '0';
        ce        <= '0';
        we        <= '1';      
        read_write  <= '1';  
        zustand     <= "100";
    -----------------------------------------------------------------------
    
    --Clear and read value-------------------------------------------------
    elsif (zustand = "100")
    then
        sram_a_out <= "000000000000000011";      
        oe          <= '0';
        ce        <= '1';
        we        <= '1';      
        read_write  <= '0';
        
        led(0)    <= data_read(0);
        led(1)    <= data_read(1);
        led(2)    <= data_read(2);
        
        zustand     <= "001";
    end if;
      
    end if;
end process;
end Behavioral;

und dazu folgende ucf:

NET "clk"           LOC = "T9";

NET "led(0)"        LOC = "K12";
NET "led(1)"        LOC = "P14";
NET "led(2)"        LOC = "L12";


NET "switch(0)"        LOC = "K13";
NET "switch(1)"        LOC = "K14";
NET "switch(2)"        LOC = "J13";

NET "we"              LOC = "G3";
NET "ce"              LOC = "P7";
NET "oe"              LOC = "K4";
NET "lb"              LOC = "P6";
NET "ub"              LOC = "T4";

NET "sram_io(0)"          LOC = "N7";
NET "sram_io(1)"          LOC = "T8";
NET "sram_io(2)"          LOC = "R6";
NET "sram_io(3)"          LOC = "T5";
NET "sram_io(4)"          LOC = "R5";
NET "sram_io(5)"          LOC = "C2";
NET "sram_io(6)"          LOC = "C1";
NET "sram_io(7)"          LOC = "B1";
NET "sram_io(8)"          LOC = "D3";
NET "sram_io(9)"          LOC = "P8";
NET "sram_io(10)"          LOC = "F2";
NET "sram_io(11)"          LOC = "H1";
NET "sram_io(12)"          LOC = "J2";
NET "sram_io(13)"          LOC = "L2";
NET "sram_io(14)"          LOC = "P1";
NET "sram_io(15)"          LOC = "R1";


NET "sram_a_out(0)"          LOC = "L5";
NET "sram_a_out(1)"          LOC = "N3";
NET "sram_a_out(2)"          LOC = "M4";
NET "sram_a_out(3)"          LOC = "M3";
NET "sram_a_out(4)"          LOC = "L4";
NET "sram_a_out(5)"          LOC = "G4";
NET "sram_a_out(6)"          LOC = "F3";
NET "sram_a_out(7)"          LOC = "F4";
NET "sram_a_out(8)"          LOC = "E3";
NET "sram_a_out(9)"          LOC = "E4";
NET "sram_a_out(10)"          LOC = "G5";
NET "sram_a_out(11)"          LOC = "H3";
NET "sram_a_out(12)"          LOC = "H4";
NET "sram_a_out(13)"          LOC = "J4";
NET "sram_a_out(14)"          LOC = "J3";
NET "sram_a_out(15)"          LOC = "K3";
NET "sram_a_out(16)"          LOC = "K5";
NET "sram_a_out(17)"          LOC = "L3";

[Ramon F. (tronixx)]

ok das mit der Synthese Warnung hab ich nun kapiert und ist auch 
nachvollziehbar, da ich nur die ersten 3 Bits verändere.

Aber ohne Warning implementieren und somit ein programming file 
erstellen kann ich nicht :(

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

Ramon F. schrieb:
> Aber ohne Warning implementieren und somit ein programming file
> erstellen kann ich nicht :(
Eine Warnung verhindert das Erstellen einen Bitfiles nicht! Du musst 
also noch irgendwo einen Fehler haben...


BTW:

loop1: For i IN sram_io'RANGE generate
IOB_1: IOBUF_LVCMOS33 port map
  (O   => data_read(i),
  IO  => sram_io(i),
  I   => data_write(i),
  T  => read_write);
 end generate loop1;

Einen Tristate-Bus kann man kompakter generisch beschreiben:

    sram_io   <= data_write when read_write='0' else (others=>'Z');
    data_read <= sram_io;

[Ramon F. (tronixx)]

vielen Dank Lothar,

so funktioniert es einwandfrei. Versteh zwar nicht so 100% warum aber 
das passt schon und ist simpler. Dann werd ich mich aufbauend dessen mal 
um mein eigentliches Problem kümmern.

[Duke Scarring (Gast)]

Ramon F. schrieb:
> use IEEE.STD_LOGIC_arith.ALL;
> use IEEE.STD_LOGIC_unsigned.ALL;

Auch wenn es etwas pedantisch ist, aber irgendwie muß man ja mal das 
Übel der std_logic_arith loswerden:

1. Du brauchst die beiden Biblitheken in Deinem Beispiel gar nicht, da 
Du den Typ unsigned nicht verwendest und auch sonst nicht gerechnet 
wird.

2. falls doch mal was mit Vektoren gerechnet werden soll, siehe:
Beitrag "Re: IEEE.STD_LOGIC_ARITH.ALL obsolete"

Duke