Nach Recherche im Netz und Ausprobieren habe ich einen Text über Arrays
in VHDL geschrieben. Der Text stellt meinen aktuellen Kenntnisstand dar,
ich erhebe keinen Anspruch auf Vollständigkeit oder Richtigkeit. Bitte
schreibt wenn etwas nicht stimmt oder Ihr etwas ergänzen möchtet. Z.B.
habe ich nur mit einem Simulator und Synthese Programm Erfahrung.
Ich hoffe es hilft anderen in meiner Situation.
VHDL-Implementationen erlauben meist bis zu dreidimensionale Arrays von
Basetypen wie Enumerationstypen wie std_logic. Der eindimensionale Typ
std_logic_vector ist bereits in ieee.std_logic_1164 definiert.
Synthetisierbar sind meist nur Arrays die mit zwei Dimensionen
deklariert wurden.
Die Deklaration von Arrays kann auf zwei Arten erfolgen:
Entweder es wird ein eindimensionales Array von einem Array deklariert
um eine Dimension hinzuzufügen oder es wird direkt ein zweidimensionales
Array deklariert. Wurde ein eindimensionales Array von einem Array
deklariert so ist das unter Array nicht indizierbar, sondern muss erst
einem Signal seines Typs zugewiesen werden bevor seine Elemente einzeln
angesprochen werden können.
Wurden direkt zwei Dimensionen deklariert so bezeichnet ein Element
namevonarray2D(index2, index1) wobei index2 das obere\äußere 1D Array
indiziert und index1 das untere\innere.
Für Arrays die mehrdimensional deklariert wurden, ist es für keine
Dimension, auch nicht die unterste \ rechtsstehende, möglich slices,
also zusammenhängende Ausschnitte, anzusprechen, sondern nur einzelne
Elemente.
Eine Möglichkeit Beschränkungen zu umgehen ist es sich sprachlich auf
eine Dimension zu begrenzen und den Index als Linearkombination
anzugeben namevonarray2D((index1'HIGH + 1)*index2 + 1*index1), dies
entspricht namevonarray2D(index2, index1) wenn der kleinste Index
jeweils 0 ist. Diese Variante ist flexibler, aufwändiger und
fehleranfälliger. Soll z.B. aus einer Matrix(1. und 2. Dim.) von Werten
(3.Dim) eine Matrix von Listen von Stellen einer bestimmten Wertigkeit
der Werte einer Richtung der Matrix erstellt werden, so muss auf drei
Dimensionen zugegriffen werden können.
Was simulierbar oder synthetisierbar ist, hängt vom genutzten Produkt
ab.
Hier noch zwei Varianten um ein als 2D missbrauchten 1D Array
umzuordnen, um andere slices nehmen zu können:
1 | sMvonNvon1 ist array (M-1 downto 0) von std_logic_vector (N-1 downto 0)
|
2 | sNvonMvon1 ist array (N-1 downto 0) von std_logic_vector (M-1 downto 0)
|
3 |
|
4 | l_umordnen : process (MvonNvon1)
|
5 | variable v1vonNvon1 : std_logic_vector(N-1 downto 0);
|
6 | variable vNmalMvon1 : std_logic_vector(N*M-1 downto 0);
|
7 | begin
|
8 | for n in N-1 downto 0 loop
|
9 | for m in M-1 downto 0 loop
|
10 | v1vonNvon1 := sMvonNvon1(m);
|
11 | vNmalMvon1(M*n + m) := v1vonNvon1(n);
|
12 | end loop;-- M
|
13 | sNvonMvon1(n) <= vNmalMvon1(M*n+M-1 downto M*n);
|
14 | end loop;-- N
|
15 | end process l_umordnen;
|
16 |
|
17 | Dies ist einfacher als mit generate:
|
18 |
|
19 | l_gen_kopieren_i : for i in M-1 downto 0 generate
|
20 | sMmalNvon1(N*i+N-1 downto N*i) <= sMvonNvon1(i);
|
21 | end generate l_gen_kopieren_i;
|
22 | l_gen_drehenundgruppieren_aussen : for i in N-1 downto 0 generate
|
23 | l_gen_drehen_innen : for j in M-1 downto 0 generate
|
24 | sNmalMvon1(N*j * 1*i) <= sMmalNvon1(1*j + M*i);
|
25 | end generate;
|
26 | sNvonMvon1(i) <= sNmalMvon1(M*i+M-1 downto M*i);
|
27 | end generate;
|
Mit generate waren zwei Zwischensignale voller größe nötig. Durch einem
Process mit Variable werden die Signale automatisch generiert.
Es waren nur zwei for-loop nötig, aber drei generate.
[ multidimensional mehrdimensionale ]
Thread beobachten
Seitenaufteilung abschalten