Verbinden eines n-Bit-Busses von einer Komponente zur anderen

Ich glaube, ich habe mich nicht richtig erklärt. Lass es mich dir genauer sagen.

Ich habe 64 Blöcke: A, B, C, D ..... Jeder dieser Blöcke ist ein Parallel-in-Parallel-Out-Schieberegister mit n Bits. Die Aufgabe dieser Blöcke besteht darin, ihren Inhalt von A nach B, B nach C, C nach D usw. zu verschieben.

Ich habe Probleme beim Senden des Datentyps std_logic_vector von einem Block zum anderen.

Mein Code ist unten angegeben. Ich habe Kommentare zu den Zeilen gesetzt, die den Fehler enthalten.

library ieee;
use ieee.std_logic_1164.all;

entity Shift is

generic (
  Block_Size         : integer := 64;    
  Entry_length       : integer := 32     
);


port(
  new_entry:      in std_logic_vector(Entry_length-1 downto 0);         
  clk:            in std_logic;          
  reset:          in std_logic;          
  done:           out std_logic                             
 );

end Shift;

architecture Synchronous of Shift is
component ShiftReg
      generic (
           Entry_length  : integer := 32   
          );

      port(
          clk:            in std_logic; 
          reset:          in std_logic; 
          enable:         in std_logic;                                   
          data_in:        in std_logic_vector(Entry_length-1 downto 0);   
          data_out:       out std_logic_vector(Entry_length-1 downto 0)   
          );

end component;  

signal data_Shift_i : std_logic_vector(Entry_length-1 downto 0);
signal enable : std_logic; 

begin  
  Reg_i: for i in 0 to Block_Size-1 generate 
            i_Reg: ShiftReg
            generic map ( Entry_length => Entry_length
                ) 
            port map (  
                clk              => clk,
                reset            => reset,
                enable           => enable,
                data_in          => data_Shift_i(i-1),  -- error: cannot put (i-1)
                data_out         => data_Shift_i(i)     --error: cannot put (i)
              );
  end generate Reg_i;

end synchronous;

Antworten (3)

Sie können die Komponenten A und B in eine neue Komponente (z. B. AB) einfügen und diese neue Komponente n-mal mit einem Generate instanziieren.

gen: for i in 1 to 64 generate

   i_ab: entity work.ab
      port map(
          ....
          ); 

end generate gen;
Ich glaube, ich habe mich nicht richtig erklärt. Lass es mich dir genauer sagen.

Es gibt ein Problem mit der Bindung Ihrer Ports an das Signal. Die Ports sind 32 Bit breit. Ihr Signal auf der obersten Ebene, das zB A mit B verbindet, ist ebenfalls 32 Bit, aber Sie verwenden nur ein Bit für die Verbindung!

Ich würde einen neuen Typ erstellen:

type t_interconnect is array (0 to Block_Size) of std_logic_vector(Entry_length-1 downto 0); -- the new type
signal interconnect of t_interconnect; -- the signal of the new type to be used 

Sie können den Eingang des Topmoduls dem ersten Index von 'interconnect' zuweisen. Und verbinden Sie weiter 'data_in' und 'data_out' wie im Beispiel. Der letzte Index des Arrays ist dann der Ausgang des letzten Moduls in der Kette und sollte dem Ausgang der obersten Ebene zugewiesen werden.

Danke Vermaete! Das war wirklich hilfreich. Ich habe noch eine Frage dazu: Wenn ich alle Blöcke mit einem Wert initialisieren möchte, erhält data_in von jedem von ihnen einen eindeutigen Entry_lenngth-Bit-Wert. Ich habe ein anderes Programm, das bei jedem Taktzyklus Zufallszahlen generiert (es muss sich also in einem Prozess befinden). Wie kann ich alle Komponenten bei jedem Taktzyklus durchschleifen und mit den Werten initialisieren?

data_Shift_iist nur 32 Bit breit. Ihre forSchleife geht von 0 bis 63, also versuchen Sie, auf Bits von data_Shift_i zuzugreifen, die nicht existieren. Ich denke jedoch, dass dies nur das erste Ihrer Probleme ist.