Array Dynamisch erzeugen

[Michael T. (elr0n)]

Hallo,

ich such nach einer Möglichkeit folgendes Array mit VHDL zu erzeugen.

Es handelt um ein Array das weitere Arrays enthält.

Die Anzahl der Plätze der inneren Arrays soll sich dabei immer 
halbieren.

Beispiel:

Ich erzeuge ein Array der größe 3.

Array[0] soll dann ein array der größe 6 enthalten. Array[1] ein Array 
mit größe 3 und so weiter.

Das ganze soll dynamisch erzeugt werden. Ich gebe also die größe für das 
äußere Array und das erste innere Array an und daraus soll dann der rest 
erzeugt werden.

[Pako (Gast)]

for loop?

[Michael T. (elr0n)]

Fest programmiert sieht das ganze z.B. so aus:

 constant array_aussen        : natural := 9;
  
 type array_def1 is array (0 to (array_aussen-1)/2) of unsigned(9 downto 0);
 type array_def2 is array (0 to (array_aussen-1)/4) of unsigned(9 downto 0);
 type array_def3 is array (0 to (array_aussen-1)/8) of unsigned(9 downto 0);
  
 type array_record is
  record
     a : array_def1;
     b : array_def2;
     c : array_def3;
     d : unsigned(0 downto 9);
   
  end record;

Kann man eine for loop überhaupt zum erzeugen von typen verwenden?

[Stachele (Gast)]

Nein.


Wozu brauchst du das?

[Stachele (Gast)]

>d : unsigned(0 downto 9);

0 to 9

[Michael T. (elr0n)]

Die Idee war einen Tree-Adder, der nur für eine feste Anzahl an 
Eingangswerten funktioniert, so für eine variable Anzahl an 
Eingangswerten umzuschreiben.

[Stachele (Gast)]

Kannst du den Tree-Adder für eine feste Anzahl an Eingängen mal zeigen?

[Michael T. (elr0n)]

Hier für 9 Eingangswerte:

  type arr_add1_result is array (0 to (ArrayElements-1)/2) of unsigned(31 downto 0);
  type arr_add2_result is array (0 to (ArrayElements-1)/4) of unsigned(31 downto 0);
  type arr_add3_result is array (0 to (ArrayElements-1)/8) of unsigned(31 downto 0);
    

    
  signal add1_result     : arr_add1_result := ((others => (others => '0')));
  signal add2_result     : arr_add2_result := ((others => (others => '0')));
  signal add3_result     : arr_add3_result := ((others => (others => '0')));
  signal add4_result     : unsigned(31 downto 0) :=(others => '0');


      for i in 0 to (ArrayElements-1)/2-1 loop
        add1_result(i) <= array_in(i*2) + array_in((i*2)+1);
      end loop;
      add1_result((ArrayElements-1)/4) <= add1_result((FilterMaskElements-1)/2);
      
      for i in 0 to (ArrayElements-1)/4-1 loop
        add2_result(i) <= add1_result(i*2) + add1_result((i*2)+1);
      end loop;
      add2_result((ArrayElements-1)/4) <= add1_result((FilterMaskElements-1)/2);
      
      
      for i in 0 to (ArrayElements-1)/8-1 loop
        add3_result(i) <= add2_result(i*2) + add2_result((i*2)+1);
      end loop;
      add3_result((ArrayElements-1)/8) <= add2_result((FilterMaskElements-1)/4);
        
      add4_result <= add3_result(0) + add3_result(1);
        
      add4_result <= add3_result(0) + add3_result(1);

Im array_in sind 9 Werte(ArrayElements) die paarweise addiert werden 
sollen.
In add4_result ist dann das Ergebnis.

Um es dynamisch zu machen habe ich  add1_result-addX_result zu einem 
array gemacht. Das ganze funktioniert auch nur hab ich jetzt halt in 
allen arrays die gleiche Anzahl an Plätzen, obwohl von Stufe zu Stufe ja 
immer weniger benötigt werden. Das möchte ich halt eleganter und 
resourcenschonender lösen.