Teil eines Signals dynamisch auswählen (VHDL)

Ein Array zu benutzen ist eine gute Idee, danke Andreas.

1

data_in :   in array (k-1 downto 0) of std_logic_vector(31 downto 0);

Dieses Konstrukt scheint zwar nicht ganz gültig zu sein, aber mit einer 
Typdeklaration in einem Package hat es funktioniert.

Danke für den Schubs in die richtige Richtung!
Harald

Ihr werkelt an einem einfachen Konstrukt herum, um es in HDL zu 
formulieren, der aber am Ende nichts anders wird, als ein umschaltbare 
MUX.

Den kann man auch gleich per Hand formulieren....

Male Dir einfach mal auf, wie die Schaltung aussieht, und schreibe die 
genau so hin.

Verstehe leider nicht was du meinst ...

Das ganze Projekt wird ein Vektor-Prozessor. Das Signal data_in stellt 
den Ausgang eines kompletten Vektor-Registers dar, dessen Länge frei 
konfigurierbar sein muss. Es kann also sein, dass da jemand k=100 oder 
mehr (jeweils 32 Bit) einstellt. Selectunit ist die Schnittstelle von 
der Vektor- zur Skalar-Einheit. Damit soll ein Wort aus dem 
Vektor-Register in eins der Register der Skalar-Einheit gelenkt werden 
(Move-Befehl).

Das von Hand hinschreiben ist meiner Meinung nach wegen der Abhängigkeit 
von der Größe k nicht möglich, oder täusche ich mich da?

Kommt drauf an: Wenn man es nich teintippen kann, paast es gfs garnicht 
ins FPGA (???)

Fakt ist: Am Ende sind die einzelnen Kombinationen, die paramettriert 
werden können, ALLESAMT parallel aufzubauen - egal wie Du es 
formulierst.

Du must also zumindest ein for-Schaleife definieren, die dies Fälle ALLE 
beschreibt. IM Prinzip hast du ja einen ganzen Baum an Fällen.

Man muss ich fragen, ob man das nicht logistisch / mathematisch, also 
mit Shift-Operationen (unter Verlust einiger Clock) realisieren sollte, 
statt 100% in die Fläche zu gehen.

Ist der Bus denn nicht immer von derselben Breite und schiebt sich 
nur????

Die 32 Bit für k_in ergeben sich daraus, dass der Wert aus einem 
32-Bit-Register des skalaren Teils des Prozessors kommt. Ich bin mir 
natürlich bewusst, dass niemand diese 32 Bit wirklich ausschöpfen will, 
aber ich wollte hier auch keine harten Grenzen ziehen. Das soll 
letztendlich derjenige entscheiden, der den Prozessor konfiguriert.

Hallo Harald,

lass Dich mal nicht von den Praktikern einschüchtern, von wegen nicht 
praktikabel... ;.) Hier wird manchmal etwas weit ausgeholt.
Natürlich wird ein 32bit x n zu 32bit MUX groß und langsam. Das sollte 
jedem
klar sein. Aber wenns das FPGA hergibt kann man das ruhig machen
- why not?
Das Beispiel von Andreas Schwarz ist OK.

Gibt es hier vielleicht statt einer Multiplexerschaltung Alternativen? 
Die einzelnen Wörter von data_in kommen ja aus jeweils einem eigenen 
Register. Ist es eventuell möglich die Ausgänge aller dieser Register 
auf eine gemeinsame Leitung zu legen, an allen Ausgängen 'Z' anzulegen 
und nur das Register k einen Wert auf diese Leitung schreiben lassen? 
(Die Ganze Vektor-Einheit ist in Scheiben aufgebaut, lediglich die 
Selectunit bzw. ein geplantes Schuffle müssen irgendwie übergreifend 
werden.)


(Register)
----------------------------------------
|  k=0    |  k=1    |   k=2   |  K=3   |<--- k_in
----------------------------------------
     |        |          |        |
     |        |          |        |
   Data       Z          Z        Z
     |        |          |        |
     |        |          |        |
----------------------------------------
(Datenbus)


Es handelt sich bei dem ganzen Projekt übrigens um meine Diplomarbeit 
und meine Erfahrungen in VDHL bestehen nur aus dem Inhalt einer 
Vorlesung bei der nur sehr einfache Schaltungen behandelt wurden. Von 
daher bin sehr dankbar über eure Hinweise, weil ich solche Probleme 
selbst noch nicht sehe.

In den meisten FPGAs kann man intern kein hochohmiges 'Z' nutzen, 
Treiber dadür haben nur die Pins.

Das ganze Projekt wird ein Prozessor der aus einer skalaren Einheit und 
einer Vektor Erweiterung besteht. (Ähnlich eines Pentiums mit MMX 
Erweiterung, nur viel einfacher).

Die Register sind Teil der Vektor-Einheit. Es sollen deren Länge (k) und 
deren Anzahl n konfiguriert werden können. Eine Zeile davon wird 
Vektor-Register genannt. Eine Spalte wird im VHDL Code als 
32-Bit-Scheibe beschrieben.

Hier ein Beispiel mit k=6 und n=3

    31    0
    -------------------------------------------
n=0 | k=0 | k=1 | k=2 | k=3 | k=3 | k=4 | k=5 |
    -------------------------------------------
    -------------------------------------------
n=1 | k=0 | k=1 | k=2 | k=3 | k=3 | k=4 | k=5 |
    -------------------------------------------
    -------------------------------------------
n=2 | k=0 | k=1 | k=2 | k=3 | k=3 | k=4 | k=5 |
    -------------------------------------------

Es werden jeweils 2 Vektor-Register in einer Alu (genau gesagt in k 
parallelen Alus) verknüpft und zurück geschrieben. Zusätzlich soll der 
Datenaustausch mit  dem skalaren Teil des Prozessors möglich sein. Dafür 
ist die oben beschriebene "Selectunit" gedacht. Es soll ein Wort aus 
einem
k Wörter breiten Vektor-Register ausgewählt und bereit gestellt werden 
können.

k=100 scheint von mir tatsächlich viel zu hoch gegriffen worden zu sein, 
damit würde ich die Kapazität meines FPGAs mehr als nur sprengen. 
Realistisch wäre vielleicht ein Wert von 10, da habe ich keine größeren 
Probleme mit den Signallaufzeiten, denke ich.

Die Idee mit den Tristate vergesse ich auch wieder :)

Ja, das Synthese-Tool versucht tatsächlich die Register im Block-RAM 
abzulegen. Von daher spare ich mir momentan noch die Arbeit das 
umzustellen, und mache das eventuell später, wenn der Prozessor läuft 
und ich noch etwas mehr Geschwindigkeit oder Fläche rausholen will.

Habe aber noch eine Frage zu Arrays: Mir wird bei der Synthese immer die 
Warnung ausgegeben, dass ich eventuell über die Array Grenzen hinweg 
darauf zugreife, was auch nachvollziehbar ist. Was würde auf dem FPGA 
passieren, wenn ich tatsächlich so zugreifen würde? Bei einer Simulation 
wird diese dann abgebrochen, aber ich kann mangels FPGA momentan leider 
nicht ausprobieren was tatsächlich passiert.

1

entity selectunit is

2

    port (

3

        data_in :   in  vectordata_type;

4

        k_in:       in  std_logic_vector(31 downto 0);

5

        data_out:   out std_logic_vector(31 downto 0)

6

    );

7

end selectunit;

8

9

architecture rtl of selectunit is

10

begin

11

   data_out <= data_in(conv_integer(k_in));

12

end rtl;

Die Variante mit der Definition von k_in

1

k_in: in integer range 0 to k-1;

klingt zwar logisch, aber ich muss k_in ja aus einem 32-Bit-Register 
füttern und weiss leider auch nicht was passieren würde, wenn der 
Registerinhalt größer als dieser Bereich wäre.

Viele Grüße,
Harald
[/vhdl]

Danke für die Antwort.

Was genau bedeutet undefiniert in diesem Zusammenhang? Könnte dann im 
Ergebnis etwas anderes als Einzen und Nullen stehen (sowas wie 'U', 'X' 
oder 'Z') oder ist das auf dem FPGA ausgeschlossen?

Für den Fall mit 'U', 'X', 'Z', wie würde man das am besten abfangen?

Hier wäre mein Vorschlag, gibt es da bessere Methoden?

1

architecture rtl of selectunit is

2

    signal index: natural;

3

begin

4

   index <= conv_integer(k_in) when (conv_integer(k_in) < k) else k-1;

5

   data_out <= data_in(index);

6

end rtl;

Danke euch beiden, das hilft mir echt weiter.

Hab das jetzt ohne extra Überprüfung gelassen und mir etwas Logik 
gespart.