vhdl array / tabelle

[R. M. (rma)]

Hallo zusammen

Meine Aufgabe ist mit einem Altera Ausgänge auf Eingänge 
zurückzuschalten.
Meine Idee ist nun die Soll Ausgänge und die Soll Eingänge in einer 
array / tabelle abzuspeichern, in einer dritten spalte möchte ich noch 
erwähnen wenn der ausgang nicht auf den eingang geschaltet wird. Und 
diese tabelle wird in einer schleife immer wieder aufgerufen.

Kann ich meine Idee einfach mit VHDL realisieren? Und wie?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

R. M. schrieb:
> in einer dritten spalte möchte ich noch
> erwähnen wenn der ausgang nicht auf den eingang geschaltet wird.
Gegenüber wem?

> Und diese tabelle wird in einer schleife immer wieder aufgerufen.
Schleife? Aufgerufen?
Hoppala, da hat aber noch jemand eine sehr softwarelastige Denkweise...

Zeichne doch einfach mal einen Schaltplan, wie du das mit ICs machen 
würdest. Und dann machst du eine VHDL-Beschreibung, bei der das selbe 
rauskommt. Denn für VHDL musst du in Hardware denken...

> mit einem Altera
Ach so, mit dem Altera. Zum Glück gibts nur einen...

> Ausgänge auf Eingänge zurückzuschalten.
Ich sehe einen (bzw. viele) Multiplexer vor mir. Was siehst du?

[R. M. (rma)]

Ich sehe vor mir leider gar keine Hardware nur ein bischen Software 
code. Aber ich werde mir es mal mit Harware überlegen.

Aber es gibt doch möglich keiten eine Array / Tabelle mit VHDL zu machen 
oder nicht?

[Vi (Gast)]

Es gibt Arrays. Aber beachte das nur eindimensionale (in Ausnahmefällen 
auch zweidimensionale) Arrays synthetisierbar sind (zumindest nicht ohne 
kleine Tricks).

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Vi schrieb:
> Aber beachte das nur eindimensionale (in Ausnahmefällen auch
> zweidimensionale) Arrays synthetisierbar sind (zumindest nicht ohne
> kleine Tricks).
Schon ein std_logic_vector ist ein eindimensionales Array...
Und ein Array von std_logic_vectoren (das kann jeder Synthesizer) ist 
ein zweidimensionales Array. Aber auch höhere Dimensionen gehen 
inzwischen problemlos: 
http://www.lothar-miller.de/s9y/categories/32-Arrays

[vI (Gast)]

Wie gesagt nicht ohne Trick (synthetisierbar!). Du musst den Umweg über 
eine Typdeklaration gehen sonst macht dir dein Synthesewerkzeug einen 
Strich durch die Milchmädchenrechnung.

[R. M. (rma)]

Ok ich werde es mal ausprobieren, danke für eure hilfe

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

vI schrieb:
> Du musst den Umweg über eine Typdeklaration gehen
Welchen Umweg? Und natürlich "muss" ich über eine Typdefinition gehen. 
Das ist VHDL. Zeig doch mal an einem Beispiel, wie du direkter zum Ziel 
kommst...

[Vi (Gast)]

Der Umweg über eine Typdeklaratation. Der direkte wäre dieser:

type foobar is array (0 to 7, 0 to 3) of std_logic;

Das nimmt dir aber in der Regel der Synthetisierer nicht.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Vi schrieb:
> Das nimmt dir aber in der Regel der Synthetisierer nicht.
Ich nehm dann mal XST und diesen Code:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity array_test is
    Port ( x : in  STD_LOGIC_VECTOR (1 downto 0);
           y : in  STD_LOGIC_VECTOR (1 downto 0);
           o : out  STD_LOGIC_VECTOR (7 downto 0));
end array_test;

architecture Behavioral of array_test is

type foobar is array (0 to 3, 0 to 3) of std_logic_vector(7 downto 0);
signal foo : foobar := ((x"11",x"12",x"13",x"14"),
                        (x"21",x"22",x"23",x"24"),
                        (x"31",x"32",x"33",x"34"),
                        (x"41",x"42",x"43",x"44"));
begin                 
  o <= foo(to_integer(unsigned(x)),to_integer(unsigned(y))); 
end Behavioral;

Ergebnis:

HDL Synthesis Report
Macro Statistics
# RAMs                                                 : 4
 4x8-bit single-port Read Only RAM                     : 4

Kurz: das RAM/ROM wird wie gewünscht realisiert...

[Vi (Gast)]

Ausnahmen bestätigen die Regel :)

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Vi schrieb:
> Ausnahmen bestätigen die Regel :)
Die nächste Ausnahme wäre dann offenbar auch Synplify (Lattice).
Auch das Ding setzt die obenstehende Beschreibung um und meldet:

Done: completed successfully

[user (Gast)]

Altera QuartusII mag die Datei auch:

Info: Implemented 16 device resources after synthesis - the final 
resource count might be different
    Info: Implemented 4 input pins
    Info: Implemented 8 output pins
    Info: Implemented 4 logic cells
Info: Quartus II Analysis & Synthesis was successful. 0 errors, 4 
warnings

[R.M. (Gast)]

@ Lothar Miller

Verstehe ich das richtig, das man in das o die Konstanden Zahlen aus dem 
Array ausliest?

Wie kann ich jetzt den den Array Wert eingeben? (dies müsste ich nach 
mir mit dem x und dem y machen.) Aber diesen Variablen kann ich ja nur 0 
oder 1 zuweisen oder nicht?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

R.M. schrieb:
> Verstehe ich das richtig, das man in das o die Konstanden Zahlen aus dem
> Array ausliest?
Richtig, abgesehen davon, dass es konstan-t-e Werte sind...

> Wie kann ich jetzt den den Array Wert eingeben? (dies müsste ich nach
> mir mit dem x und dem y machen.)
Wie meinst du das? Du willst Werte nicht nur auslesen (=ROM), sondern 
auch welche reinschreiben (=RAM)?
Das geht so:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity array_test is
    Port ( x : in  STD_LOGIC_VECTOR (1 downto 0);
           y : in  STD_LOGIC_VECTOR (1 downto 0);
           o : out  STD_LOGIC_VECTOR (7 downto 0)
           a : in  STD_LOGIC_VECTOR (1 downto 0);
           b : in  STD_LOGIC_VECTOR (1 downto 0);
           i : in  STD_LOGIC_VECTOR (7 downto 0));
end array_test;

architecture Behavioral of array_test is

type ramtyp is array (0 to 3, 0 to 3) of std_logic_vector(7 downto 0);
signal ram : ramtyp := (others=>(other=>'0'));
begin                 
  o <= ram(to_integer(unsigned(x)),to_integer(unsigned(y))); 
  ram(to_integer(unsigned(a)),to_integer(unsigned(b))) <= i; 
end Behavioral;

Das ist ein Dual-Port-RAM. Für die praktische Umsetzung in einm FPGA 
wäre jetzt aber noch ein Takt angeraten, damit das Ganze auf einen 
RAM-Block abgebildet werden kann.

> Aber diesen Variablen kann ich ja nur 0 oder 1 zuweisen oder nicht?
Naja, am Ende werden das immer nur Nullen und Einsen sein.
Nur eben nicht nur eine einzelne. Mach 8 nebeneinander dann hast du ein 
Byte, mach 16 nebeneinander dann hast du ein Wort, mach 32 nebeneinander 
dann hast du ein Doppelwort...

[R.M. (Gast)]

type foobar is array (0 to 3, 0 to 3) of std_logic_vector(7 downto 0);
signal foo : foobar := ((x"11",x"12",x"13",x"14"),
                        (x"21",x"22",x"23",x"24"),
                        (x"31",x"32",x"33",x"34"),
                        (x"41",x"42",x"43",x"44"));

Wie kann ich jetzt z.B. genau die Zelle auslesen in welcher die hex Zahl 
23 steht?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

R.M. schrieb:
> Wie kann ich jetzt z.B. genau die Zelle auslesen in welcher die hex Zahl
> 23 steht?
Ich würde sagen, es gibt 2 Möglichkeiten: foo(2,1) oder foo(1,2)
Und nur eine davon ist richtig. Auf welche würdest du tippen?
Mein Tipp: erst nachdenken und dann ausprobieren...

[R.M. (Gast)]

Gibt es eine Möglichkeit, die Ausgänge direkt in das Array zu schreiben?
Oder könnte man den Ausgang indirekt aus dem Array ansprechen?

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

R.M. schrieb:
> Gibt es eine Möglichkeit, die Ausgänge direkt in das Array zu schreiben?
Nicht, wenn es ein RAM ist, sieh dir ein RAM einfach mal an: das hat 
nach aussen nur Adress-, Daten und ein paar Steuerleitungen.

Du könntest as natürlich trotzdem machen, dann wird im FPGA aber kein 
RAM mehr verwendet, sondern viele einzelne Flipflops...  :-o