array in VHDL

Nachfolgend habe ich dir den Code eines DPRAMs angefügt, welches auf 
einer Seite geschrieben und auf der anderen gelesen wird. Die RAM 
Arbitration ist   nicht implementiert (im verwendeten Fall nicht nötig).
Vielleicht hilft dir das weiter.

------------------------------------
library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.std_logic_unsigned.all;

entity ReadThroughRAM is
    port (
        -- system
        INT_CLK                             : in    STD_LOGIC;
        -- Port A - OMR write
        CSA                                 : in    STD_LOGIC;
        WEA                                 : in    STD_LOGIC;
        AA                                  : in    STD_LOGIC_VECTOR(9 
downto 1);
        DA                                  : in    STD_LOGIC_VECTOR(15 
downto 0);
        WAITA                               : out   STD_LOGIC;
        -- Port B - uC read
        -- Steuerung Lesevorgang
        INT_REG_A                           : in    STD_LOGIC_VECTOR(9 
downto 2);
        INT_D                               : inout STD_LOGIC_VECTOR(31 
downto 0);
        INT_CYCLE_access                    : in    STD_LOGIC;
        INT_CYCLE_dir                       : in    STD_LOGIC;
        CSB                                 : in    STD_LOGIC;
        WAITB                               : out   STD_LOGIC
   );
end ReadThroughRAM;

architecture ReadThroughRAM_arch of ReadThroughRAM is

    -- RAM Definition
    type ram_type is array (255 downto 0) of STD_LOGIC_VECTOR(15 downto 
0);
    signal RAM_H                            : ram_type;
    signal RAM_L                            : ram_type;
    signal AB                               : STD_LOGIC_VECTOR(9 downto 
2);
    signal DB                               : STD_LOGIC_VECTOR(31 downto 
0);

    -- wait Signale
    signal WAITA_sig                        : STD_LOGIC;
    signal WAITB_sig                        : STD_LOGIC;

begin
    process (INT_CLK)
    begin
        if rising_edge(INT_CLK) then
            if WEA = '1' then
                if AA(1) = '0' then
                    RAM_L(conv_integer(AA(9 downto 2))) <= DA(15 downto 
0);
                else
                    RAM_H(conv_integer(AA(9 downto 2))) <= DA(15 downto 
0);
                end if;
              end if;
            AB(9 downto 2) <= INT_REG_A(9 downto 2);
        end if;
    end process;

    -- RAM Daten auslesen
    DB(15 downto 0)  <= RAM_L(conv_integer(AB(9 downto 2)));
    DB(31 downto 16) <= RAM_H(conv_integer(AB(9 downto 2)));

    -- RAM Daten ausgeben wenn Read-Zugriff
    INT_D(31 downto 0) <= DB(31 downto 0) when INT_CYCLE_access = '1' 
and INT_CYCLE_dir = '0' else (others => 'Z');

    -- wait Signal auf die andere Seite weitergeben
    WAITA_sig       <=  CSB;
    WAITA           <=  WAITA_sig;
    WAITB_sig       <=  CSA;
    WAITB           <=  WAITB_sig;

end ReadThroughRAM_arch;

Das ist viel zu kompliziert. Du öffnest die Bibliothek, nimmst ein 
Block-RAM-Modul und plazierst es auf Deinem Schaltplan. Dann schreibst 
Du Dir das Programm, das den Inhalt in den SRAM schreibt. Am besten 
fängst Du an mit Adresse 0, diese zählst Du nach dem Durchlauf um 1 
hoch.

Den RAM kann man ganz einfach ansteuern. Du Legst mit einem Prozess die 
Daten an. Mit einen 2. Prozess kannst Du gleichzeitig die Adresse 
anlegen und mit dem 3. Prozess legst Du die Schreibleitung (WR) auf 
schreiben dies ist logisch '1' oder logisch '0' da musst Du im 
Datenblatt nachschauen. Mit dem 4. Prozess schaltest Du die 
Enable-Leitung auf '0' und mit dem nächsten Takt wieder auf 1 zurück. 
Dadurch werden die Daten in den RAM geschrieben. Ganz einfach :-) Am 
besten ist wenn du danach den ganzen Eingänge auf Tristate schaltest. 
Damit Du dann auch durch andere Prozesse auf den RAM zugreifen kannst.