Mehrdimensionale Arrays

Will man in VHDL ein zweidimensionales C-Array wie z.B.

short Feld[2][6] ={
{0x0400,0x3400,0x4000,0x0001,0x3000,0x0001},
{0x2340,0x0013,0x0000,0x1200,0x8000,0x0000} 
};

dann artet das gleich in ein dreidimensionales Feld aus, weil die Variable (z.B. vom Typ short) erst mal aus einzelnen Bits zusammengestellt werden muß.

Mehrdimensionale Felder lassen sich in VHDL genauso leicht beschreiben und initialisieren wie zweidimensionale Arrays. Hier können mehrere Schreibweisen angewandt werden:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity MultidimArray is
    Port ( clk : in  STD_LOGIC;
           output0 : out std_logic_vector(3 downto 0);
           output1 : out std_logic_vector(3 downto 0)
         );
end MultidimArray;

architecture Behavioral of MultidimArray is

type Feldelement is array (0 to 3) of std_logic_vector(3 downto 0); 
type FeldTyp0 is array (0 to 7) of Feldelement; 
signal FeldA : FeldTyp0 := ((x"0",x"1",x"2",x"3"),
                            (x"4",x"5",x"6",x"7"),
                            (x"8",x"9",x"A",x"B"),
                            (x"C",x"D",x"E",x"F"),
                            (x"B",x"A",x"D",x"C"),
                            (x"A",x"B",x"1",x"E"),
                            (x"D",x"E",x"A",x"D"),
                            (x"B",x"E",x"E",x"F"));

type FeldTyp1 is array (0 to 7, 0 to 3) of std_logic_vector(3 downto 0); 
signal FeldB : FeldTyp1 := ((x"0",x"1",x"2",x"3"),
                            (x"4",x"5",x"6",x"7"),
                            (x"8",x"9",x"A",x"B"),
                            (x"C",x"D",x"E",x"F"),
                            (x"B",x"A",x"D",x"C"),
                            (x"A",x"B",x"1",x"E"),
                            (x"D",x"E",x"A",x"D"),
                            (x"B",x"E",x"E",x"F"));

signal cnt : unsigned (4 downto 0) := (others=>'0');
signal cntlo : integer range 0 to 3 := 0;
signal cnthi : integer range 0 to 7 := 0;

begin
 process (clk) begin
    if rising_edge (clk) then
       if(cnt<31) then cnt <=cnt+1; 
       else            cnt <= (others => '0'); 
       end if;
    end if;
  end process;

  cntlo <= to_integer(cnt(1 downto 0));
  cnthi <= to_integer(cnt(4 downto 2));

  output0 <= FeldA(cnthi)(cntlo);
  output1 <= FeldB(cnthi, cntlo);
end Behavioral;

Der Zugriff auf die Arrays erfolgt wie bei zweidimensionalen Feldern mit einem Integer.

Soll ein mehrdimensionales Feld auf einen festen Wert gesetzt (bzw. initialisiert) werden, geht das mit

type array_type is array (0 to VECTOR_SIZE-1) of signed(WIDTH downto 0);
signal array : array_type := (others => (others => '0'));  -- Initialisierung
: 
   if (...) then
      array  <= (others => (others => '1')); -- Alles Setzen
   end if;

Leider kann die Xilinx-Synthese nur Arrays bis max. 2 Dimensionen. Der Xilinx SXT User Guide dazu: XST supports multi-dimensional array types of up to two dimensions. Damit sind zweidimensionale Matrizen von std_logic_vector gemeint, was wiederum eigentlich 3 Dimensionen sind...
Seis drum: diese Einschränkung ist lästig, wenn ich z.B. eine Laufschrift mit unterschiedlich hellen Pixeln machen will, dann brauche ich:
1. Dimension: die Helligkeit
2. Dimension: die Pixel X-Position
3. Dimension: die Pixel Y-Position
4. Dimension: das Zeichen selber.
Das geht mit nur 3 unterstützten Dimensionen schon mal nicht

Aber: Glück gehabt. Mit dem "neuen" Parser in der Xilinx-Synthese geht das, und noch einiges mehr. Mehr dazu im Eintrag -use_new_parser YES