RAM in component, Initialisierung bei Mehrfachnutzung

[berndl (Gast)]

Hallo allerseits,

ich habe in VHDL ein generisches RAM gebaut. Das will ich jetzt 2x 
verwenden. Allerdings sollen bei einer Instanz die Initdaten Null sein, 
bei der anderen Instanz sollen die mit sinnvollen Werten vorbelegt sein.

Generate (mit generic) zwischen architecture und begin also z.B.

architecture rtl of ram256x32 is
   type t_ram is array (0 to 255) of std_logic_vector (31 downto 0);
INIT0 : if RAM_INIT = 0 generate
   signal ram : t_ram := (0 => x"1234_5678",
                          5 => x"DEAD_BEEF",
                          others => x"0000_0000"
                         );
end generate;
INIT1 : if RAM_INIT = 1 generate
   signal ram : t_ram := (others => others => '0'));
end generate;
   ...
begin
   ...

funktioniert leider nicht. RAM_INIT ist einfach ein generic, der bei der 
Instantiierung gesetzt wird. Jetzt koennte ich natuerlich 256 generics 
definieren, aber dann mache ich lieber 'ne Kopie der Komponente...

Koennte das mit einer function in einem package klappen? Dieser halt 
RAM_INIT als parameter mitgeben?

Hat jemand nen Tipp?

Gruss,
- berndl

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

Ich würde da ein Package mit dem Ramtyp machen, und den Initvektor der 
Komponente als Generic übergeben. Das müsste gehen...

[berndl (Gast)]

Hi Lothar, danke, der Tipp war Gold wert!

also, falls es jemanden hier interessiert, ich habe jetzt folgendes:

Ein 'ram256x32_init_pkg.vhd' mit folgendem Inhalt:

library ieee;
use ieee.std_logic_1164.all;

package ram256x32_init_pkg is

   -- Define our RAM size and type
   type t_ram is array (0 to 255) of std_logic_vector (31 downto 0);
   
   -- Now let's just define some default values if we instantiate our RAM
   constant C_INIT_RAM_0 : t_ram := (           -- All data is 'zero'
                                     others => (others => '0')
                                    );
   constant C_INIT_RAM_1 : t_ram := (           -- Data for a particular instance
                                     0 => x"0A04_0001",
                                     1 => x"0003_0003",
                                     others => x"0000_0000"
                                    );
   constant C_INIT_RAM_2 : t_ram := (           -- Data for another particular instance
                                     0 => x"0123_0001",
                                     7 => x"0234_0003",
                                     others => x"0000_0000"
                                    );
   
end;

--package body ram256x32_init_pkg is

--end package body;

Dann ein in VHDL beschriebenes RAM mit einem Port read/write und einem 
anderen Port read:

library ieee;
use ieee.std_logic_1164.all;

use work.ram256x32_init_pkg.all;

entity ram256x32 is
   generic (
      INIT_RAM : t_ram := C_INIT_RAM_0
   );
   port (
      clk : in std_logic;                    -- FPGA clock
      rst : in std_logic;                    -- synchronous reset
      rea : in std_logic;                    -- read enable port A
      wea : in std_logic;                    -- write enable port A
      addra : in std_logic_vector (7 downto 0);      -- read/write address port A
      dia : in std_logic_vector (31 downto 0);      -- write data port A
      doa : out std_logic_vector (31 downto 0) := (others => '0');      -- read data port A
      reb : in std_logic;                    -- read enable port B
      web : in std_logic;                    -- write enable port B
      addrb : in std_logic_vector (7 downto 0);      -- read/write address port B
      dib : in std_logic_vector (31 downto 0);      -- write data port B
      dob : out std_logic_vector (31 downto 0) := (others => '0')       -- read data port B
  );
end ram256x32;

architecture rtl of ram256x32 is

   signal ram : t_ram := INIT_RAM;

begin

   --
   -- Port A is used as read/write port
   --
   proc_a : process (clk)
   begin
      if rising_edge (clk) then
         if wea = '1' then
            ram (to_integer (unsigned (addra))) <= dia;
         elsif rea = '1' then
            doa <= ram(to_integer (unsigned (addra)));
         end if;
      end if;
   end process;

   --
   -- Port B is used as read-only port
   --
   proc_b : process (clk)
   begin
      if rising_edge (clk) then
         if reb = '1' then
            dob <= ram (to_integer (unsigned (addrb)));
         end if;
      end if;
   end process;

end rtl;

Dann wird das ganze von irgendeinem Teil des Designs (package 
einbinden!) wie folgt aufgerufen:

   ram_inst : entity work.ram256x32
   generic map (
      INIT_RAM => C_INIT_RAM_0      -- init with 'zero' (or another defined INIT value...)
   )
   port map (
      clk => clk,
      rst => rst,
      -- Port A is connected to the r/w logic
      rea => '1',
      wea => w_ena_port_a,
      addra => w_addr_port_a,
      dia => w_data_port_a,
      doa => open,
      -- Port B is connected to the r logic
      reb => '1',
      web => '0',
      addrb => r_addr_port_b,
      dib => x"0000_0000",
      dob => r_data_port_b
   );

Muss ich noch testen, aber scheint zu funktionieren!

Vlt. kann das ja irgendjemand auch noch gebrauchen...

[Duke Scarring (Gast)]

berndl schrieb:
> funktioniert leider nicht. RAM_INIT ist einfach ein generic, der bei der
> Instantiierung gesetzt wird.
Was auch funktionieren müßte:
Den RAM mit einer 'Init'-Funktion füllen. In der Init-Funktion muss dann 
der generic ausgewertet werden.

Ich hab schon Init-Funktionen gebaut, die ein Intel-Hex-File eingelesen 
haben...

Duke

[berndl (Gast)]

Duke Scarring schrieb:
> Was auch funktionieren müßte:
> Den RAM mit einer 'Init'-Funktion füllen. In der Init-Funktion muss dann
> der generic ausgewertet werden.

probiere ich mal aus, das wuerde mir das package ersparen. Danke!