Zu viele Signale zwischen zwei Komponenten?

[Peter (Gast)]

Hallo,

folgendes Problem.

Die erste Komponente errechnet mit einem Prozess 24 Werte a 64 Bit die 
an die zweite Komponente (24 Signale a 64 Bit) übergeben werden.

Der Prozess der zweiten Komponente benötigt die 24 Werte zur Berechnung.

Wie kann ich nun die Signalleitungen (1536) minimieren, a la Speicher.
Also sozusagen einen Adressbus für 24 Adressen und einen 64 Bit 
Datenbus.

Das Problem bei einem Prozess ist, dass er Signalleitungen nur am Ende 
des Prozesses aktualisiert, ich also während des Prozesses die einzelnen 
Werte nicht abftragen kann.

Besten Dank im Voraus

Gruß

Peter

[na sowas (Gast)]

Blockram?

[Frank (Gast)]

Hallo Blockram

a la

entity ram is

  port
  (
    clk        : in std_logic;
    wr         : in std_logic;
    write_addr : in std_logic_vector(4 downto 0);
    read_addr  : in std_logic_vector(4 downto 0);
    data_in    : in std_logic_vector(63 downto 0);
    data_out   : out std_logic_vector(63 downto 0)
  );

end ram;
------------------------------------------------------------------------ 
---
architecture ram_arch of ram is

  type ram_t is array (32 downto 0) of std_logic_vector(64 downto 0);
  signal ram : ram_t;

-------------------------------------------------
begin

process(clk)
begin

  if(clk'event and clk = '1') then

    if(wr = '1') then
      ram(conv_integer(write_addr)) <= data_in;
    end if;

    data_out <= reg(conv_integer(read_addr));

  end if;

end process;
------------------------------------------------------------------------ 
---
end ram_arch;

wirft bei mir zwei Probleme auf.

1. type ram_t is array (32 downto 0) of std_logic_vector(64 downto 0);

hatte ich als Lösung um ein Signal vom Typ ram_t zwischen den Komonenten 
zu erzeugen, ist aber nicht Synthetisierbar (nur eindimensionale 
Felder).

2. Wie oben schon erwähnt werden im Prozess erst am Ende die Signale 
aktualisiert, ich müsste aber schon im Prozess mehrere Adressen anlegen 
und auslesen.

Totzdem besten Dank, jeder Hinweis hilft weiter.

Gruß

Frank

[Jan M. (mueschel)]

Dann hast du das Prinzip eines Prozesses in VHDL nicht verstanden. Ein 
Prozess wird logisch von oben nach unten abgearbeitet, nicht aber 
zeitlich. Fuer zeitliche Abfolgen braucht es eine state machine.

[Achim (Gast)]

Hallo Jan

genau das meine ich ja.

Wenn ein Prozess logich abgearbeitet wird,
kann er in einem Durchlauf aus eine Blockram nicht mehrere Werte 
auslesen,
da die Signale erst mit Beendigung des Prozesses aktualisiert werden.

Ich müsste aber im Prozess Zugriff auf alle Werte bekommen.

Hoffe ich habe es verstanden :-)

Gruß

Frank

[na sowas (Gast)]

Am Besten du hängst mal ein Stück Code an oder sagst, was du genau 
machen willst. So ist es schwierig zu helfen. :)

[Thomas H. (mac4ever)]

Also wenn Du 24x64 Bit gleichzeitig anliegen haben musst, kommst Du wohl 
nicht drum herum alle Leitungen direkt an die Komponente zu legen. ist 
halt ein wenig Schreibarbeit oder vielleicht kannst Du das Ganze auch 
über Generics lösen ?

Kommt auf die Geschwindigkeit und Auslastung an ... wenn in jedem Takt 
neue Daten anliegen und berechnet werden, dann musst/köntest Du es so 
machen. Wenn Du Zeit zwischen den Berechnungen hast, dann kannst Du das 
ganze vielleicht "seriell" übertragen ?

[gast (Gast)]

Wie wäre es mit einem FIFO ?

[Frank (Gast)]

Hallo zusammen,

besten Dank für die Antworten.

Werde erst mal die Lösung mit den 24x64 Leitungen stehen lassen.

Hatte nur bedenken da ja 1536 Leitungen geroutet werden müssen.

Gruß

Frank

[Gabriel W. (gagosoft)]

>Hatte nur bedenken da ja 1536 Leitungen geroutet werden müssen.
na und? wenn Du das Zeug synthetisierst musst Du die 1536 Leitungen ja 
nicht von Hand routen ;-) Damit hat der synthesealgorithmus bestimmt 
keine Probleme, solange Du genug Platz im Baustein hast.