Xilinx (Digilent Nexys4) mit Micron SRAM Ansteuerung

[Alex (Gast)]

Hallo
ich bin ein FPGA Neuling und habe mir ein Nexys4 zum rumbasteln gekauft.

Jetzt habe ich das Problem, dass bei meinem Project der interne BRAM 
nicht mehr ausreicht. Da das Board, wie auch das Nexys3, einen 128Mb 
großen Cellram (Pseudo Stratic RAM) hat, wollte ich darauf ausweichen. 
Das größte Problem ist, dass ich aus den Manuals nicht schlau werde bzw. 
nicht verstehe, wie ich so einen SRAM ansteuere. Ich habe mich schon 
durch verschiedene Tutorials und Vorlesungen gelesen doch nicht das 
richtige gefunden.

Mein jetziger code sieht so aus

module ram # ( parameter ADDRBITS=10 ) (
  address,
  clock,
  data,
  wren,
  q);

  input  [ADDRBITS-1:0]  address;
  input    clock;
  input  [255:0]  data;
  input    wren;
  output  [255:0]  q;

  //synthesis attribute ram_style of store is block
  reg [255:0] store [(2 << (ADDRBITS-1))-1:0];
  reg[ADDRBITS-1:0] raddr_reg;
  
  always @ (posedge clock)
  begin
    raddr_reg <= address;
    if (wren)
      store[address] <= data;
  end
  
  assign q = store[raddr_reg];
      
endmodule

und damit klappt auch alles nur dass der Speicherplatz dann nicht 
ausreicht.
So spreche ich das Modul an:

ram ram1 (ram_addr, ram_clk, ram1_din, ram_wren, ram1_dout);

Jetzt zu dem, was ich für sram gefunden habe:

module sram_model(
  input [9:0] addr,
  inout [7:0] data,
  input oe_n,
  input we_n
  );
  
  
  reg [7:0] sram[0:1023];
  
  always @ (posedge we_n)
    sram[addr] = data;
    
  assign data = (oe_n == 0) ? sram[addr] : 8'bz;
  
endmodule

Wie kann ich das ansprechen?

Jetzt zu meinem Problem:
wenn ich das jetzt richtig verstehe kann ich ja nur ein 8Bit wort über 
data einlesen bzw. herausbekommen. Aber eine Zelle von dem Ram soll 
8Mbit haben. Vielleicht verstehe ich auch die Grundlagen eines solchen 
RAM noch nicht.

Die komplizierten Sachen wie asynchrone/synchrone/burst Ansteuerung habe 
ich mir noch nicht angeschaut.

[Gustl B. (-gb-)]

Also Micron hat da ein hybsches Dokument zu.

www.micron.com/~/media/Documents/Products/Data%20Sheet/DRAM/Mobile%20DRA 
M/PSRAM/128mb_burst_cr1_5_p26z.pdf

Da ist für jeden Zugriff, also lesen, schreiben und die 
unterschiedlichen Arten ein Diagramm wie die Signale aussehen sollen, 
also so eine "Wellenform".

Das solltest du nachbilden, also mit den richtigen Timings die da auch 
dabei stehen. Async read/write ist noch das Einfachste aber nicht 
sonderlich schnell.

Ich habe das auf dem Nexys2 gemacht und kann dir bei Bedarf etwas Code 
geben.

[Alex (Gast)]

Das Micron Datenblatt habe ich mir schon durchgelesen. Doch leider kann 
ich damit nicht so viel anfangen.

Wäre super, wenn du den Code mal posten könntest, damit ich grob eine 
Ahnung davon bekomme, wie so etwas funktioniert.

[Gustl B. (-gb-)]

library ieee;
use ieee.std_logic_1164.all;
use IEEE.numeric_std.all;

entity sram is

port (clock: in std_logic;
    oe, wr, ce: out std_logic;
    addr: out std_logic_vector(23 downto 1);
    data: inout std_logic_vector(15 downto 0));
end sram;

architecture Behavioral of sram is


signal b: std_logic;
signal address: std_logic_vector(23 downto 1):= "00000000000000000000000";
signal sro: std_logic_vector(15 downto 0); --sram out
signal sri: std_logic_vector(15 downto 0); --sram in

begin

data <= sro when b = '0' else "ZZZZZZZZZZZZZZZZ";
sri <= data when b = '1';

process begin
   wait until rising_edge(clock);
  

    if counter_lesen < 5 then
      counter_lesen <= counter_lesen + 1;
    elsif counter_lesen = counter_lesen and START_LESEN = '1' then
      counter_lesen <= 0;
    end if;

     
    if counter_lesen = 0 then -- lesezugriff
      ce <= '1';
      oe <= '1';
      wr <= '1';
      b <= '1';
    elsif (counter_lesen = 1 or counter_lesen = 2) then
      ce <= '0';
      oe <= '1';
      wr <= '1';
      b <= '1';
      addr <= address;
    elsif (counter_lesen = 3 or counter_lesen = 4 or counter_lesen = 5) then
      ce <= '0';
      oe <= '0';
      wr <= '1';
      b <= '1';
      addr <= address;
        buff(15 downto 0) <= sri;
    end if;
       
    if counter_schreiben < 3 then
      counter_schreiben <= counter_schreiben + 1;
    elsif counter_schreiben = counter_schreiben and START_SCHREIBEN = '1' then
      counter_schreiben <= 0;
    end if;
     
    if counter_schreiben = 0 then -- schreibzugriff
      ce <= '1';
      oe <= '0';
      wr <= '0';
      b <= '1';
    elsif counter_schreiben = 1 then
      ce <= '0';
      oe <= '0';
      wr <= '1';
      b <= '1';
      addr <= ad1;
    elsif counter_schreiben = 2 then
      ce <= '0';
      oe <= '0';
      wr <= '0';
      b <= '0';
      addr <= address;
      sro <= buff(15 downto 0);
    elsif counter_schreiben = 3 then
      ce <= '1';
      oe <= '0';
      wr <= '0';
      b <= '0';
      addr <= address;
      sro <= buff(15 downto 0);
    end if;


end process;


end Behavioral;

Also das habe ich jetzt schnell "modifiziert", also alles Zusätzliche 
rausgeworfen.
Was mit den gelesenen Daten geschieht und woher die zu schreibenden 
kommen und wie die Addresse generiert wird ist hier noch komplett 
unvollständig. Es zeigt nur den sequentiellen Ablauf eines Asynchronen 
Schreib- und Lesezugriffs. Der Takt war bei mir 50MHz.

[Alexander F. (alexf91)]

Ich arbeite derzeit an einem kleinen Projekt mit dem Nexys2-Board.

Der RAM dient hierbei als Zwischenspeicher für Berechnungen und VGA 
Ausgabe, deshalb die vielen Signale in der Portdefinition.

Ich schreibe jeweils 32 Words in den Speicher und lese auch genau so 
viele aus (Konfiguration im 32 Words Burst-Mode).
Die Daten kommen aus dem CalcFifo und werden in den LineFifo 
geschrieben.

Als Eingangstakt werden 80MHz verwendet. Der RAM wird mit um 180° 
verschobenen 80MHz getaktet, damit ich die Setup- und Hold-Zeiten 
erfülle.

Der Code ist noch ungetestet, die Simulation sieht fürs erste ganz gut 
aus. Ich arbeite derzeit noch an einer Testbench mit dem von Micron 
bereitgestellten Simulationsmodell.