Frage zum Block RAM

[Cihan K. (lazoboy61)]

Hallo,

habe mal eine kleine Frage zum Block RAM.

Ich möchte den Block Ram des Virtex 5 verwenden. Dabei gehe ich genauso 
vor, wie Lothar es auch auf seiner Homepage beschrieben hat. Das ein und 
auslesen funktioniert auch alles richig.

Nun zur Frage, ich möchte Bsp.weise einen Block Ram von 256 Words x 8 
Bit erstellen. Dabei will ich die Daten 8 Bit weise in den Block Ram 
rein schreiben, aber evtl. mit 16 Bit-Weise, 32Bit-Weise, etc. auslesen. 
Mit anderen Worten will ich verschiedene Datenbusgrößen haben. Mit dem 
Coregenerator kann man sowohl beim Fifo als auch beim Block Ram 
Generator diese Einstellungen machen, doch wie mache ich es per VHDL 
Code selber.

Hier mein jetztiger Stand:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

use ieee.numeric_std.all;
use IEEE.STD_LOGIC_UNSIGNED.ALL;

-- Uncomment the following library declaration if instantiating
-- any Xilinx primitives in this code.
--library UNISIM;
--use UNISIM.VComponents.all;

entity TOP is
  GENERIC(
      Addrbreite: integer:= 13;
      Wortbreite: integer:= 64
      );
  PORT (
      CLK: in std_logic;
      RST: in std_logic;
      BT: in std_logic;
      SW: in std_logic;
      Test: out std_logic
      );
end TOP;

architecture Behavioral of TOP is

type speicher is array(0 to (2**Addrbreite)-1) of STD_LOGIC_VECTOR(Wortbreite-1 downto 0);
signal memory : speicher;   

signal A, B: std_logic_vector(12 downto 0):= (others => '0');
signal Din, Dout: std_logic_vector(63 downto 0):= (others => '0');
signal entprell: natural range 0 to 1000000;
signal BT_v: std_logic;
signal Read_Ram, Write_Ram: std_logic:= '0';

begin

process(CLK)

begin

if rising_edge(CLK) then
  if RST = '1' then
    A <= (others => '0');
    B <= (others => '0');
    Din <= (others => '0');
    entprell <= 0;
    Test <= '0';
    Read_Ram <= '0';
  else
    if BT = '1' and BT_v = '0' and entprell = 0 then
      entprell <= 1000000;
    elsif entprell > 1 then
      entprell <= entprell - 1;
    elsif entprell = 1 then
      entprell <= entprell - 1;
      if BT = '1' and SW = '1' then
        Write_Ram <= '1';
        Din <= Din + 1;
        A <= A + 1;
      elsif BT = '1' and SW = '0' then
        Read_Ram <= '1';
        B <= B + 1;
      end if;
    end if;
    BT_v <= BT;
    if Dout = (Dout'range => '1') then
      Test <= '1';
    else
      Test <= '0';  
    end if;
  end if;
  if Write_Ram = '1' then
    Write_Ram <= '0';
    memory(to_integer(unsigned(A))) <= Din;
  end if;
  if Read_Ram = '1' then
    Read_Ram <= '0';
    Dout <= memory(to_integer(unsigned(B)));
  end if;
end if;

end process;

end Behavioral;

In diesem Programm wird per Button und Switch der Block Ram entweder 
beschrieben oder gelesen. Sowohl Din als auch Dout sind 64 Bit groß. Wie 
kann ich z.B. mit Din 64 Bit reinschreiben aber mit Dout 256 Bit 
auslesen in einem Takt. Geht das überhaupt? (Muss doch gehen oder?, 
zumindest wenn man es unter dem Coregenerator auch so erzeugen kann ?!)

Würde mich über jede Anregung sehr freuen.
Danke im Voraus
Cihan

[Christian R. (supachris)]

Im XST User Guide steht drin, wie man das macht. Und ich glaube in den 
Code Templates in ISE direkt auch.

[Cihan K. (lazoboy61)]

In den Code Templates habe ich schon gesucht, doch bin noch nicht findig 
geworden.

Im XST User Guide schaue ich gleich mal nach. Hoffe jemand kann mir 
evtl. ein Beispiel zu meinem Problem geben.

Danke
Gruß Cihan

[Cihan K. (lazoboy61)]

Im XST User Guide sind viele Beispiele zum Block Ram drin, aber keins 
mit unterschiedlichen Datenbusbreiten. Heisst das, dass es nicht möglich 
ist, Daten-Eingang und -Ausgang unterschiedlich zu machen.

In den Templates bin ich auch nicht findig geworden.

So schwer dürfte dies doch gar nicht sein eigentlich, denn wenn es im 
Coregenerator möglich ist, dann sollte man es auch per VHDL Code machen 
können, oder ?!

Cihan

[Cihan K. (lazoboy61)]

Bei dem Xst User Guide vom Spartan 6 oder Virtex 6 ist ein Code Beispiel 
da zum Block Ram mit unterschiedlicher Datenbusbreite, aber nicht im 
User Guide vom Virtex 5, also geht es vermutlich dann auf dem Virtex 5 
nicht. Schade

Cihan

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

Oh doch. Das geht garantiert. Lies einfach mal das Datenblatt des FPGAs 
durch. Und sieh dir die Language Templates in der ISE an...

[Cihan K. (lazoboy61)]

Ich suche schon die ganze Zeit wie ein wilder, aber immer noch nicht 
findig geworden. Habe auch schojn ins Datenblatt reingeschaut, auch in 
den XST User Guides, auch in die Templates von ISE vom Block RAM, doch 
bis jetzt nicht die richtige Lösung gefunden.

Das einzige was im User Guide vom Spartan 6 gefunden habe ist folgender 
Code auf Seite 218 und 219:
http://www.xilinx.com/support/documentation/sw_manuals/xilinx13_2/xst_v6s6.pdf
Das kommt meinem Fall am nähesten. Kann ich es nun genauso für den 
Virtex 5 anwenden?

Cihan

[namenlos (Gast)]

ISE 14.2:

Edit -> Language Templates -> VHDL -> Synthesis Constructs -> Coding 
Examples -> RAM -> BlockRAM -> Dual Port -> Asymetric Ports

kannst Du sogar noch aussuchen, ob Du "No Change", "Read First" oder 
"Write First" haben willst - einfacher geht's wohl kaum noch...

[Cihan K. (lazoboy61)]

Danke für die Hinweise, aber ich glaube das das mit dem Virtex 5 nicht 
geht.

Ich habe nun mir auch die Language Templates angesehen und in einem ISE 
Testprojekt synthesiert und das Ergebnis ist folgendes:

Sobald ich für das Projekt als Target den Virtex 5 nehme treten viele 
Fehler beim synthesieren der Example Codes auf, habe die Fehler meist 
auch wegbekommen, aber der Block Ram wird nicht mit unterschiedlichen 
Bussen angesteuert (aspect ratio). Das sah ich im Synthese Report.

Nun wenn ich aber als Target den Virtex 6 wähle, dann funktionieren die 
Beispiele zu 100%, ohne irgendwelche Fehler und vor allem wird der Block 
Ram richtig angesteuert (unterschiedliche Datenbusse, etc).

Ich habe mir die beiden XST User Guides vom Virtex 6 und Virtex 5 
angeschaut und nur beim Virtex 6 gab es Example Codes zu asymmetrischem 
Block Ram (unterschiedliche Datenbusse). Beim Virtex 5 im XST User Guide 
sind keine aufgeführt.

Liege ich nun mit der Erkenntnis richtig, dass ich mit dem Virtex 5 
keine unterschiedlichen Datenbusse beim Block Ram haben kann?

Cihan

[Thosch (Gast)]

Cihan Kalayci schrieb:
> Danke für die Hinweise, aber ich glaube das das mit dem Virtex 5 nicht
> geht.

Sorry, aber das ist völliger Unsinn!
Wie Lothar Miller bereits gesagt hat: Das geht garantiert.
Und zwar bei jedem Xilinx-FPGA mit BlockRams.

Ich nutze täglich BlockRams mit unterschiedlichen Wortbreiten, arbeite 
allerdings nicht mit VHDL, sondern mit Schematic Entry über 3rd party 
Software, die ISE bekommt dann nur ein EDIF als Quelle.

Hab Dir mal aus dem Virtex-5 Libraries Guide for HDL Designs
das Instanziierungs-Template für ein RAMB18 BlockRam reinkopiert:

Library UNISIM;
use UNISIM.vcomponents.all;
-- RAMB18: 16k+2k Parity Paramatizable True Dual-Port BlockRAM
-- Virtex-5
-- Xilinx HDL Libraries Guide, version 13.4
RAMB18_inst : RAMB18
generic map (
DOA_REG => 0, -- Optional output register on A port (0 or 1)
DOB_REG => 0, -- Optional output register on B port (0 or 1)
INIT_A => X"00000", -- Initial values on A output port
INIT_B => X"00000", -- Initial values on B output port
READ_WIDTH_A => 0, -- Valid values are 1, 2, 4, 9, or 18
READ_WIDTH_B => 0, -- Valid values are 1, 2, 4, 9, or 18
SIM_COLLISION_CHECK => "ALL", -- Collision check enable "ALL", "WARNING_ONLY",
-- "GENERATE_X_ONLY" or "NONE"
SIM_MODE => "SAFE", -- Simulation: "SAFE" vs "FAST", see "Synthesis and Simulation
-- Design Guide" for details
SRVAL_A => X"00000", -- Set/Reset value for A port output
SRVAL_B => X"00000", -- Set/Reset value for B port output
WRITE_MODE_A => "WRITE_FIRST", -- "WRITE_FIRST", "READ_FIRST" or "NO_CHANGE"
WRITE_MODE_B => "WRITE_FIRST", -- "WRITE_FIRST", "READ_FIRST" or "NO_CHANGE"
WRITE_WIDTH_A => 0, -- Valid values are 1, 2, 4, 9, or 18
WRITE_WIDTH_B => 0, -- Valid values are 1, 2, 4, 9, or 18
-- The following INIT_xx declarations specify the initial contents of the RAM
INIT_00 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_01 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_02 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_03 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_04 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_05 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_06 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_07 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_08 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_09 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_0A => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_0B => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_0C => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_0D => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_0E => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_0F => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_10 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_11 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_12 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_13 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_14 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_15 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_16 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_17 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_18 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_19 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_1A => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_1B => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_1C => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_1D => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_1E => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_1F => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_20 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_21 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_22 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_23 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_24 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_25 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_26 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_27 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_28 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_29 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_2A => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_2B => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_2C => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_2D => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_2E => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_2F => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_30 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_31 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_32 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_33 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_34 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_35 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_36 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_37 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_38 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_39 => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_3A => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_3B => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_3C => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_3D => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_3E => X"0000000000000000000000000000000000000000000000000000000000000000",
INIT_3F => X"0000000000000000000000000000000000000000000000000000000000000000",
-- The next set of INITP_xx are for the parity bits
INITP_00 => X"0000000000000000000000000000000000000000000000000000000000000000",
INITP_01 => X"0000000000000000000000000000000000000000000000000000000000000000",
INITP_02 => X"0000000000000000000000000000000000000000000000000000000000000000",
INITP_03 => X"0000000000000000000000000000000000000000000000000000000000000000",
INITP_04 => X"0000000000000000000000000000000000000000000000000000000000000000",
INITP_05 => X"0000000000000000000000000000000000000000000000000000000000000000",
INITP_06 => X"0000000000000000000000000000000000000000000000000000000000000000",
INITP_07 => X"0000000000000000000000000000000000000000000000000000000000000000")
port map (
DOA => DOA, -- 16-bit A port data output
DOB => DOB, -- 16-bit B port data output
DOPA => DOPA, -- 2-bit A port parity data output
DOPB => DOPB, -- 2-bit B port parity data output
ADDRA => ADDRA, -- 14-bit A port address input
ADDRB => ADDRB, -- 14-bit B port address input
CLKA => CLKA, -- 1-bit A port clock input
CLKB => CLKB, -- 1 bit B port clock input
DIA => DIA, -- 16-bit A port data input
DIB => DIB, -- 16-bit B port data input
DIPA => DIPA, -- 2-bit A port parity data input
DIPB => DIPB, -- 2-bit B port parity data input
ENA => ENA, -- 1-bit A port enable input
ENB => ENB, -- 1-bit B port enable input
REGCEA => REGCEA, -- 1-bit A port register enable input
REGCEB => REGCEB, -- 1-bit B port register enable input
SSRA => SSRA, -- 1-bit A port set/reset input
SSRB => SSRB, -- 1-bit B port set/reset input
WEA => WEA, -- 2-bit A port write enable input
WEB => WEB -- 2-bit B port write enable input
);
-- End of RAMB18_inst instantiation

Du kannst hier sogar (anders als bei anderen Xilinx-Familien)
die Read und Write Portbreite getrennt festlegen.
(siehe Parameter READ_WIDTH_A, READ_WIDTH_B, WRITE_WIDTH_A, 
WRITE_WIDTH_B)

also erzähl hier nicht, daß funktioniere nicht...

Gruß,
Thosch

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

Cihan Kalayci schrieb:
> Danke für die Hinweise, aber ich glaube das das mit dem Virtex 5 nicht
> geht.
Ich kann dir sicher sagen, dass das mit dem Virtex 5 (der ja immerhin 
lange Jahre die Oberliga von Xilinx war) geht. Und im UG160 steht auf 
Seite 120 ganz klar:

Independent Read and Write Port Width Selection
Each block RAM port has control over data width and address depth (aspect ratio). The 
true dual-port block RAM in Virtex-5 FPGAs extends this flexibility to Read and Write 
where each individual port can be configured with different data bit widths.

http://www.xilinx.com/support/documentation/user_guides/ug190.pdf

[Cihan K. (lazoboy61)]

Thosch schrieb:
> also erzähl hier nicht, daß funktioniere nicht...

Das war ja nur eine Frage und keine Behauptung, im ersten Satz steht ja 
auch "ich glaube".

Ich habe nur meine Erkenntnisse geschildert und versucht evtl. mit euren 
Antworten meine Fehler zu entdecken, die ich ggf. gemacht habe.

Natürlich denke ich, dass ein Virtex 5 dazu fähig sein muss, aber wie 
hier geschildert, habe ich Probleme gehabt:

Cihan Kalayci schrieb:
> Sobald ich für das Projekt als Target den Virtex 5 nehme treten viele
> Fehler beim synthesieren der Example Codes auf, habe die Fehler meist
> auch wegbekommen, aber der Block Ram wird nicht mit unterschiedlichen
> Bussen angesteuert (aspect ratio). Das sah ich im Synthese Report.
>
> Nun wenn ich aber als Target den Virtex 6 wähle, dann funktionieren die
> Beispiele zu 100%, ohne irgendwelche Fehler und vor allem wird der Block
> Ram richtig angesteuert (unterschiedliche Datenbusse, etc).

Thosch schrieb:
> Hab Dir mal aus dem Virtex-5 Libraries Guide for HDL Designs
> das Instanziierungs-Template für ein RAMB18 BlockRam reinkopiert:
Diese habe ich mir auch angeschaut, doch brauche viel mehr an Speicher 
(z.B. 15 Block Rams) und wusste nicht wie ich mehrere zusammenbringe.

Eigentlich bezieht sich meine Frage auf meinem ersten Beitrag ganz oben. 
Ich habe ja einen Beispiel oben angegeben und hatte gefragt wie ich den 
anpassen müsste um die Datenbusse unterschiedlich zu verwenden. Da würde 
ich ja jetzt ungern eine oder mehrere Ram-Instanzen instanziieren, 
sondern würde gerne es so haben, dass der Synthesierer das automatisch 
händelt, was für ihn ja normalerweise auch kein Problem sein kann. Oder 
liege ich da falsch?

Cihan

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

Cihan Kalayci schrieb:
> Diese habe ich mir auch angeschaut, doch brauche viel mehr an Speicher
> (z.B. 15 Block Rams) und wusste nicht wie ich mehrere zusammenbringe.
Also, die gute Nachricht: es geht.

> Da würde ich ja jetzt ungern eine oder mehrere Ram-Instanzen
> instanziieren
Die Schlechte: du musst es händisch machen...

> würde gerne es so haben, dass der Synthesierer das automatisch händelt
Zusammen mit Spartan6 und Virtex6 gab es natürlich auch eine gründliche 
Überarbeitung der Toolchain, so dass evtl. ein in VHDL generisch 
beschreibenes RAM jetzt reibungsloser übersetzt werden kann. Aber 
soooooo arg weit weg von "automatisch" ist der Weg über eine manuelle 
Instantiierung ja nun auch nicht...