Felder, Listen, Arrays

nospam@example.com (Lothar Miller) — Fri, 03 Apr 2009 07:40:00 +0200

In C sind Listen aus Variablen eindimensionale Arrays. Eine eindimensionales Feld (bzw. eine Liste) ist also so etwas:

unsigned char Feld[8] = {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07};

Das ist in VHDL allerdings schon ein zweidimensionales Feld, weil bereits der Schritt vom Bit zum Vektor eine Dimension ist. Erst wird ein std_logic_vector() gebildet, dann mehrere dieser Vektoren mit array() hintereinandergereiht:

type FeldTyp is array (0 to 7) of std_logic_vector(3 downto 0); 
signal Feld : FeldTyp := (x"0",x"1",x"2",x"3",x"4",x"5",x"6",x"7");

signal cnt : integer range 0 to 7 := 0;

begin
 process (clk) begin
    if rising_edge (clk) then
       if(cnt<7) then    cnt <=cnt+1; 
       else              cnt <=0;
       end if;
    end if;
  end process;

  output <= Feld(cnt);

end Behavioral;

Der Index auf ein Feldelement (hier cnt) muß ein Integer sein. Wie Felder in der Hardware implementiert werden, hängt von der Beschreibung ab. Ein überschaubar kleines Feld wie das obige wird in Logik aufgelöst, der nächste Schritt wäre dann z.B. bei Xilinx ein Distributed RAM. Wird dann die Lese-Adresse noch registriert, ergibt sich ein BRAM.

Mehrdimensionale Arrays

nospam@example.com (Lothar Miller) — Fri, 03 Apr 2009 06:57:25 +0200

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

Lothar Miller - Arrays

Felder, Listen, Arrays

Mehrdimensionale Arrays