ISE Webpack + Block RaM

[Thomas R. (Gast)]

Servus!

Ist es möglich mit meiner Webpack ISE 7.1 von xilinx, block ram Module
zu erzeugen, oder geht das nur mit der Vollversion?

mfg
Thomas R.

[FPGAküchle (Gast)]

Du meinst ob der Coregen der 7.1 beiliegt? Zumindest in meiner 7.1 Linux
version vom Webpack hat ihn.

Block rams als instanzierte Primitive sollten immer gehen.

[Klaus F. (kfalser)]

Unter Windows ist der Coregen erst seit der aktuelle Version 8.1 im
Webpack enthalten, vorher nicht.

[Thomas R. (Gast)]

Danke bis her!

Habe mir nun Webpack Foundation installiert (60 Tage trial die beim
Spartan 3 Starter Kit dabei ist)

Habe aber noch folgendes (für mich momentan großes) Problem:

Ich lege wie immer mein ISE Projekt an.
-> add new Source IP(CoureGem Architecture Wizard)
Danach wähle ich Single Port Block Memory v6.1 aus

Dann erzeuge ich mir mein Block Ram mit dem Wizzard
8 bit breit, Tiefe 5000, nur Lesen modus
Danach erzeuge ich mir mit dem Memory Tool aus dem CoreGenerator ein
cgf
File mit den DAten des Ram's
-> Generate - ereuge ich mir ein coe File
-> Wieder zurück im ISE öffne ich nochmal den Wizzard und sage dann
load File(also das Ram mit daten beschreiben)
-> Generate

So und nun instantiere ich in meiner Toplevel vhdl Datei das Ram
folgendermaßen:

###################################################################
....
....
....
 component vgaram
    port (
      addr : in  std_logic_vector(12 downto 0);
      clk  : in  std_logic;
      dout : out std_logic_vector(7 downto 0));
  end component;
....
....
....
....
begin
....
....
....
BLOCK_RAM_SPARTAN3 : vgaram
    port map (
      addr => ram_addr_13bit,
      clk  => clock,
      dout => ram_data_8bit);
....
....
####################################################################
Ist das noch korrekt, oder habe ich da schon was falsch gemacht?
Übrigends vgaram, diesen Namen habe ich beim Wizzard angegeben.

So wenn ich jetzt Synthetisiere kommen folgende Warnings:

WARNING:Xst:766 - "C:/SOFTWARE/DIS/Spartan3/vgatiming_top.vhd" line
62: Generating a Black Box for component <vgaram>.

WARNING:HDLParsers:3498 - No primary, secondary unit in the file
"C:/SOFTWARE/DIS/Spartan3/vgaram.vhd. Ignore this file from project
file "vgatiming_top_vhdl.prj".

Laut einigen spärlichen Informationen aus div Xilinx help files sollte
dies aber keine Probleme machen.

Doch leider funktioniert mein Design auf dem Board nicht. (Habe den
selben Code verwendet, den ich schon mal mit einen anderen Board
verwendet habe, allerding dort war es ein  FlashRam. Dies habe ich auf
dieses BlockRam angepasst, sollte also funktionieren.

Mein Problem ist aber dass ich keine Möglichkeit gefunden habe dieses
BlockRam zu simulieren, also ich kann im Moment nicht verifizieren, ob
- mein Design fehlerhaft ist,
- das erstellen des Block rams nicht funkioniert hat (glaube ich aber
nicht da beim DesignSummary ausgegeben wird dass 3 von 12 Block Rams
verwendet werden...)
- oder das BlockRam nicht mit daten beschrieben wurde

Würde mich riesig über Antworten, Hilfestellungen freuen, da ich mich
schon ca. 5 Stunden kein bisschen weiter gekommen bin..... :(

Meine Hauptproblem ist dass ich nicht weiß ob ich bis jetzt noch alles
richtig gemacht habe und wie ich dieses BlockRam simulieren kann
(Möglichst schon mit Inhalt drinnen)

mfg & Besten Dank im Voraus
Thomas R.

[T.M. (Gast)]

Ich würde sagen du kommst besser, wenn du die Language Templates für den
BlockRAM nimmst. nicht benötigte Pins lässt du dort einfach offen mit
den Keyword open.

Also, im Webpack / ISE unter edit findet man die Templates.
Dann unter VHDL->Device Primitive Instantiation->...->BlockRAM->..
Dann nimmst du den RAM, der deinen Vorstellungen entspricht. Wenn du
einen größeren brauchst, kannst du mehrere RAMs über enable Signale
parallel schalten.
Ich habe das in einem Projekt gemacht, indem ich 16 RAM 256x16 parallel
geschaltet habe, um einen 4096x16 RAM zu erreichen.

Aber mit dem Coregenerator müsste auch es auch gehen...damit hab ich
aber noch nicht gearbeitet, weil der in der 7.1 noch ni bei war.

[T.M. (Gast)]

So sieht übrigends der Template für einen 256x16 BlockRAM aus.
Man kann den RAM also auch für die Simulation mit Werten
initialisieren...

   RAMB4_S16_inst : RAMB4_S16
   generic map (
      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")
   port map (
      DO => DO,     -- 16-bit data output
      ADDR => ADDR, -- 8-bit address input
      CLK => CLK,   -- Clock input
      DI => DI,     -- 16-bit data input
      EN => EN,     -- RAM enable input
      RST => RST,   -- Synchronous reset input
      WE => WE      -- RAM write enable input
   );

[Thomas R. (Gast)]

AHA - ein erster Lichtblick - danke.

Und damit kann ich Simulieren&Synthetisieren? Wenn ich dann das Design
auf den Spartan implementiere wird das Ram dann auch mit den Werten die
ich beim INIT_XX angegeben habe befüllt, oder geht das nur für die
Simulation?

Vielen Dank im Voraus
Thomas R.

[T.M. (Gast)]

Also Simulieren auf jeden Fall. Du musst nur die unisim Bibliothek von
Xilinx einbinden. Ob der RAM bei der Synthese mit dem Inhalt befüllt
wird, weiss ich nicht, kann ich mir aber nicht vorstellen. Am besten
mal in die Application Note zu dem Thema reinschauen bei Xilinx.
z.B. die  "XAPP463 - Using Block RAM in Spartan-3 Generation FPGAs"

[Thomas R. (Gast)]

10000 Dank für die Templates Hinweise

Habe mein Design nun simuliert, da funktioniert das beschreiben mit
Werten wunderbar.  :)

Welche Möglichkeit gbt es, um schon beim Programmieren des Spartans das
BlockRam mit Daten zu beschreiben?

Nochmals vielen Dank im Voraus
Thomas R.

[Thomas R. (Gast)]

Hoffentlich ist das aus meinem voherigen Post richtig hevorgegangen:
Ich kann das Blockram bei der Simulation mit Werten beschreiben.
Aber es klappt mit dieser MEthode nicht wenn man das Design
implementiert.

Im appl.Note ist die Rede von einem Tool namens Data2BRAM - doch wo
finde ich das?

Welche Möglichkeiten gibt es da?


besten dank im voraus
thomas r.

[Xenu (Gast)]

Mit "INIT_xx" geht das.
Wenn das bei Dir nicht geht, machst Du irgendwas falsch.

Data2BRAM ist nur dafür da, in der Bitstream-Datei die
BlockRAM-INIT-Werte zu ändern, ohne das ganze Design neu kompilieren zu
müssen.

>namens Data2BRAM - doch wo finde ich das?

Das heisst jetzt data2mem und ist im Ordner xilinx\bin\nt

[Thomas R. (Gast)]

Habe jetzt nochmals sythetisiert, und es scheint nun so als würder er
nur das niederwertigste Bit der jeweiligen Speicherzelle aus dem
speicher liest -- Bzw kommt es mir so vor als würden die Daten seriell
ausgegeben??

Wie kann das sein?
Was mache ich dabei falsch?....

Hier ist nun mein aktueller Code:
Die AusgelesenenDatan ramout werden auf LED's ausgegeben. fpgaup ist
nur eine statusled, ansonsten hat dieses Signal keine Funktion.


library ieee;
use ieee.std_logic_1164.all;
use ieee.std_logic_unsigned.all;
Library UNISIM;
use UNISIM.vcomponents.all;

entity blockRamInterface is

  port (
    clock  : in  std_logic;             -- 50 MHZ
    reset  : in  std_logic;             -- reset active high
    fpgaup : out std_logic;    -- FPGA - running LED
    ramout : out std_logic_vector(3 downto 0));

end blockRamInterface;

architecture rtl  of blockRamInterface is

signal s_prescaler : std_logic_vector(24 downto 0);
constant C_PRESCALE : std_logic_vector(24 downto 0) := (24 => '1',
others => '0');
signal s_ce :std_logic;
signal s_addresscounter: std_logic_vector(11 downto 0);
signal s_data : std_logic_vector(3 downto 0);
signal s_ram_en : std_logic;

begin  -- rtl

ramout <= s_data;

fpgaup <= '1';

s_ram_en <= '1';

  -- purpose: reduces the clock input frequency
  -- type   : sequential
  -- inputs : clock, reset
  -- outputs: reduces the clock input frequency
  PRESCALER: process (clock, reset)
  begin  -- process PRESCALER
    if reset = '1' then            -- asynchronous reset (active
low)
      s_ce <= '1';
      s_prescaler <= (others => '0');
    elsif clock'event and clock = '1' then  -- rising clock edge
      s_prescaler <= s_prescaler + 1;
      s_ce <= '0';
      if s_prescaler = C_PRESCALE then
        s_ce <= '1';
        s_prescaler <= (others => '0');
      end if;
    end if;
  end process PRESCALER;

ADDESSCOUNTER: process (clock, reset)
begin  -- process ADDESSCOUNTER
  if reset = '1' then               -- asynchronous reset (active
low)
s_addresscounter <= (others => '0');
  elsif clock'event and clock = '1' then  -- rising clock edge
    if(s_ce = '1')then
      s_addresscounter <= s_addresscounter + 1;
    end if;
  end if;
end process ADDESSCOUNTER;


  -- RAMB16_S4: Virtex-II/II-Pro, Spartan-3/3E 4k x 4 Single-Port RAM
   RAMB16_S4_inst : RAMB16_S4
   generic map (
      INIT => X"0", --  Value of output RAM registers at startup
      SRVAL => X"0", --  Ouput value upon SSR assertion
      WRITE_MODE => "WRITE_FIRST", --  WRITE_FIRST, READ_FIRST or
NO_CHANGE
      INIT_00 =>
X"0000000000000000000000000000000000000000000000000000000000000000",
      INIT_01 =>
X"0000000000000000000000000000000000000000000000000000000000000000",
      INIT_02 =>
X"0000000000000000000000000000000000000000000000000000000000000000",
      INIT_03 =>
X"0000000000000000000000000000000000000000000000000000000000000000",
      INIT_04 =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_05 =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_06 =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_07 =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_08 =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_09 =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_0A =>
X"1111111111111111111111111111111111111111111111111111111111111111",
      INIT_0B =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_0C =>
X"1111111111111111111111111111111111111111111111111111111111111111",
      INIT_0D =>
X"1111111111111111111111111111111111111111111111111111111111111111",
      INIT_0E =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_0F =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_10 =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_11 =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_12 =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_13 =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_14 =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_15 =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_16 =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_17 =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_18 =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_19 =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_1A =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_1B =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_1C =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_1D =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      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"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_26 =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_27 =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_28 =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_29 =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_2A =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_2B =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_2C =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_2D =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_2E =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_2F =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_30 =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_31 =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_32 =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_33 =>
X"0000000000000000000000000000000000000000000000000000000000000000",
      INIT_34 =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      INIT_35 =>
X"1010101010101010101010101010101010101010101010101010101010101010",
      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")
   port map (
      DO => s_data,    -- 4-bit Data Output
      ADDR => s_addresscounter,  -- 12-bit Address Input
      CLK => clock,    -- Clock
      DI => "0000",   -- 4-bit Data Input
      EN => s_ram_en,       -- RAM Enable Input
      SSR => '0', -- Synchronous Set/Reset Input
      WE => '0'   -- Write Enable Input
   );

end rtl;

Besten Dank im Voraus
Thomas R.

[Thomas B. (paraglider)]

Hallo,
schau mal in meinem Quellcode zum Digitalen Funktionsgenerator etwa 10
Beiträge weiter unten im selben Forum. Im Modul "sinus_generator.vhd"
wird Block-RAM "instanziiert" (instantiated), im Modul
"user_interface.vhd" wird Block-RAM "inferiert" (inferred). Beide
Methoden sind letztlich sowohl für Synthese als auch Simulation
identisch, und bei beiden Methoden kann auch der komplette RAM-Inhalt
für Simulation und Synthese initiiert werden.
Gruß,
Thomas

[Thomas R. (Gast)]

Danke an alle die hier gepostet haben.

Problem gelöst - Habe gestern nur leider übersehen, dass ich die Datan
ja im Hex Format ins BRAM geschrieben habe - erwartet habe ich binary,
daher also die abweichung von simulation und synthese.....


Besten Dank nochmals
Thomas R.