Array Dynamisch erzeugen

Michael T. OP #2761353
Lesenswert?
• ▲
▼ 
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.
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Michael T. OP #2761395
Lesenswert?
• ▲
▼ 
Fest programmiert sieht das ganze z.B. so aus:

1
 constant array_aussen        : natural := 9;

2
  

3
 type array_def1 is array (0 to (array_aussen-1)/2) of unsigned(9 downto 0);

4
 type array_def2 is array (0 to (array_aussen-1)/4) of unsigned(9 downto 0);

5
 type array_def3 is array (0 to (array_aussen-1)/8) of unsigned(9 downto 0);

6
  

7
 type array_record is

8
  record

9
     a : array_def1;

10
     b : array_def2;

11
     c : array_def3;

12
     d : unsigned(0 downto 9);

13
   

14
  end record;



Kann man eine for loop überhaupt zum erzeugen von typen verwenden?
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Michael T. OP #2761575
Lesenswert?
• ▲
▼ 
Hier für 9 Eingangswerte:

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

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

3
  type arr_add3_result is array (0 to (ArrayElements-1)/8) of unsigned(31 downto 0);

4
    

5


6
    

7
  signal add1_result     : arr_add1_result := ((others => (others => '0')));

8
  signal add2_result     : arr_add2_result := ((others => (others => '0')));

9
  signal add3_result     : arr_add3_result := ((others => (others => '0')));

10
  signal add4_result     : unsigned(31 downto 0) :=(others => '0');

11


12


13
      for i in 0 to (ArrayElements-1)/2-1 loop

14
        add1_result(i) <= array_in(i*2) + array_in((i*2)+1);

15
      end loop;

16
      add1_result((ArrayElements-1)/4) <= add1_result((FilterMaskElements-1)/2);

17
      

18
      for i in 0 to (ArrayElements-1)/4-1 loop

19
        add2_result(i) <= add1_result(i*2) + add1_result((i*2)+1);

20
      end loop;

21
      add2_result((ArrayElements-1)/4) <= add1_result((FilterMaskElements-1)/2);

22
      

23
      

24
      for i in 0 to (ArrayElements-1)/8-1 loop

25
        add3_result(i) <= add2_result(i*2) + add2_result((i*2)+1);

26
      end loop;

27
      add3_result((ArrayElements-1)/8) <= add2_result((FilterMaskElements-1)/4);

28
        

29
      add4_result <= add3_result(0) + add3_result(1);

30
        

31
      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.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren