Anfängerfrage Submodule einbinden

[Marco (Gast)]

Hallo,
ich habe eine Frage, die mich die letzten Studen echt verzweifeln ließ. 
Ich habe eine Aufgabe, die ich nach Vorgaben lösen muss. Ich soll zwei 
VHDL Module erstellen die je einen 8 Bit Vector um eine Stelle nach 
links bzw, nach rechts shiften. Soweit so gut. Das war kein Problem. 
Jetzt soll ich ein Hauptmodul erstellen, das je nach Schalter an oder 
aus einen Vector zyklisch an eins der Module übergibt. Ich weiß einfach 
nicht wie ich das anstellen soll. Ich habe versucht mit einer case 
struktur sozusagen bedingtes portmapping zu betreiben mit if else gings 
auch nicht.
Ich hoffe ihr könnt an der Uhrzeit den Grad meiner Verzweiflung erkennen 
und helft mir weiter

[Bernd S. (Gast)]

Hi,

deine Module sind als COMPONENT eingebunden in das Hauptmodul?

Ich nehme an deine Module haben einen Eingangsvector und einen 
Ausgangsvector? Außerdem wirst du ein Startsignal oder so was benötigen.

Im Hauptmodul machst du natürlich statische Mappings für die Signale, 
das geht imo auch nicht dynamisch.
Den Eingangsvector beider Module kannst du ja auf ein Signal im 
Hauptmodul mappen, weil 1 Treiber kann mehrere Empfänger treiben, sollte 
also kein Problem sein.

Die Ausgangsvectoren deiner beiden Module kannst du natürlich nicht 
statisch auf dasselbe Signal mappen.

Hier würde ich einen PROCESS machen im Hauptmodul der je nach deinem 
Schalter entweder den Ausgangsvector des einen Moduls oder den 
Ausgangsvector des anderen Moduls auf dein gewünschtes Signal mappt.

So fertig...

[pongo (Gast)]

um die aufgabe formell zu erfüllen, könnte man da das signal tatsächlich 
nur einem modul zuführen und dem anderen nullen verpassen

[Marco (Gast)]

Ist das geil da schreibt man hier nachts was herein bovor man voll 
frustriert pennen geht und am nächsten morgen hat man die Antwort.

vielen Dank!!

Ich muss sagen ich habe mich echt etwas dumm angestellt... Naja das mit 
den Submodulen habe ich jetzt glöst wie von Bernd beschrieben. Ich setze 
einfach Flags, die an die Submodule übergeben werden und dort als clock 
den jeweiligen Process auslösen.
Mein nächstes Problem bei dem ich scho wieder auf dem schlauch stehe ist 
das zyklische verschieben. wenn ich meinen vector atmp im Hauptmodul 
verändere also den geshifteten Vector darin abspeichern will, mekert der 
Compiler:

.
.
.
Xst:528 - Multi-source in Unit <Hauptmod_Aufgabe1> on signal <a<7>>; 
this signal is connected to multiple drivers.
.
.
.

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


entity Hauptmod_Aufgabe1 is
    --Vektorgröße kann eingestellt werden
    generic ( N: integer := 8);
    Port ( 
          lr_dir: in std_logic;
          clock : in STD_LOGIC;
        yout: out std_logic_vector (N-1 downto 0);
        a : in std_logic_vector (N-1 downto 0);
        init: in std_logic);

end Hauptmod_Aufgabe1;

architecture Behavioral of Hauptmod_Aufgabe1 is
signal yr ,yl ,atmp : std_logic_vector (N-1 downto 0);
signal leftflag, rightflag:std_logic;

begin

--Portmapping 
--das Flag aktiviert jeweils den shiftprocess in den Submodulen
left: entity work.shiftleft(Behavioral)
port map (a=> atmp , clock => leftflag, y=>yl);
right: entity work.shiftright(Behavioral) 
port map (a=> atmp , clock => rightflag , y=>yr);

--Vektor laden
process(init)
begin
atmp<=a;
end process;

process(clock)

begin
--flags loeschen
rightflag<='0';
leftflag <= '0';
--nach links
if lr_dir = '0' then
rightflag<='0';
leftflag <= '1';
yout<=yl;
atmp <=yl;
else 
--nach rechts
rightflag<='1';
leftflag <= '0';
yout<=yr;
atmp<= yr ;
end if;


end process;

end Behavioral;

beim Initialisierungsprocess darf ich atmp doch auch ändern

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

Marco schrieb:
> Jetzt soll ich ein Hauptmodul erstellen, das je nach Schalter an oder
> aus einen Vector zyklisch an eins der Module übergibt.
Ich würde das Eingangssignal immer an beide geben, und das Ergebnis 
der Schieber multiplexen. Und prompt kommt das Ergebnis:

Marco schrieb:
> Xst:528 - Multi-source in Unit <Hauptmod_Aufgabe1> on signal <a<7>>;
> this signal is connected to multiple drivers.
Da werden beide beide Ausgänge (a ist doch ein Ausgang, oder?) auf 1 
Signal geroutet:

  a=> atmp

Wie gesagt: du musst die Ausgänge multiplexen, nicht die Eingänge...

Hmm, seltsam, das mit dem a...
Zeig doch mal deine Schiebemodule auch noch.

Wofür ist der Takt im Prozess?

process(clock)
begin
--flags loeschen
rightflag<='0';
leftflag <= '0';
--nach links
if lr_dir = '0' then
rightflag<='0';
leftflag <= '1';
yout<=yl;
atmp <=yl;
else 
--nach rechts
rightflag<='1';
leftflag <= '0';
yout<=yr;
atmp<= yr ;
end if;

end process;

Im gesamten Prozess (der übrigens auch eingerückt werden könnte) wird 
der Takt nicht verwendet. Dafür fehlt lr_dir in der Sensitivliste. 
Fazit: die Simulation ist falsch.



BTW: was ist das für eine kuriose Aufgabe? Das ist in VHDL eigentlich 
ein Dreizeiler...

 yout <= a(6 downto 0) & '0' when lr_dir='1' else '0' & a(7 downto 1);

[Marco (Gast)]

a ist der Vektor, der anliegt. Also ein Eingang

ich hatte mir das so gedacht:
-außen liegt ein 8 bit vector an. Diesen weise ich dem Signal atmp zu 
(wenn   das bit init gesetzt ist).
-atmp müsste jetzt ein Abbild von dem außen anligendem a enthalten ?
-atmp mappe ich wie von Bernd beschrieben auf die Eingänge der beiden 
Submodule
- kommt jetzt ein tackt (clock) wird der process stimuliert
- lr_dir bestimmt die Richtung in die geschoben werden soll. Je nach 
Zustand von lr _dir wird entweder das left oder das right flg gesetzt 
welche wiederum den process in dem jeweiligem Submodul stimulieren
(dort steht übrigens auch nichts anderes drin als das was du 
beschreibst)

ich habe die Initialisierung jetzt mit in den Process genommen und der 
fehler ist weg, alledings ist sieht mein Vector yout in der Simulation 
jetzt immer so aus: UUUUUUUU ....  0UUUUUUU oder UUUUUUOO . Das klappt 
also noch nicht so ganz mit der zuweisung von a auf atmp

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


entity Hauptmod_Aufgabe1 is
    --Vektorgröße kann eingestellt werden
    generic ( N: integer := 8);
    Port ( 
          lr_dir: in std_logic;
          clock : in STD_LOGIC;
        yout: out std_logic_vector (N-1 downto 0);
        a : in std_logic_vector (N-1 downto 0);
        init: in std_logic);

end Hauptmod_Aufgabe1;

architecture Behavioral of Hauptmod_Aufgabe1 is
signal yr ,yl ,atmp : std_logic_vector (N-1 downto 0);
signal leftflag, rightflag:std_logic;

begin

--Portmapping 
--das Flag aktiviert jeweils den shiftprocess in den Submodulen
left: entity work.shiftleft(Behavioral)
port map (a=> atmp , clock => leftflag, y=>yl);
right: entity work.shiftright(Behavioral) 
port map (a=> atmp , clock => rightflag , y=>yr);




process(clock)

  begin

  if init = '1' then
    atmp<=a;
  end if;
  
  --flags loeschen
  rightflag<='0';
  leftflag <= '0';
  --nach links
  if lr_dir = '0' then
    leftflag <= '1';
    yout<=yl;
    atmp <= yl;
  else 
  --nach rechts
    rightflag<='1';
    yout<=yr;
    atmp<= yr ;
  end if;



end process;

end Behavioral;

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

Marco schrieb:
> - kommt jetzt ein tackt (clock) wird der process stimuliert
Stimuliert? Naja, das kann man sich schön bildlich vorstellen...
Aber wichtiger ist doch: was muss wirklich rein in die Sensitivliste? 
Dort muss das rein, was eine Neuberechung nötig macht, nicht das was 
nicht wünschenswert und angenehm wäre. Un das sind alle 
Eingangssignale, deren Änderung das Ergebnis ändern können. Denn 
spätestens der Synthesizer schert sich einen feuchten Kehrricht um deine 
"Wunschsensitivliste". Den kümmert auch nicht, dass du eine Woche lang 
nur Käse zusammensimuliert hast...

Marco schrieb:

  begin

  if init = '1' then
    atmp<=a;            -- kann man ja mal ausprobieren
  end if;
  
  --flags loeschen
  rightflag<='0';
  leftflag <= '0';
  --nach links
  if lr_dir = '0' then
    leftflag <= '1';
    yout<=yl;
    atmp <= yl;         -- wird aber sofort von dem hier ....
  else 
  --nach rechts 
    rightflag<='1';
    yout<=yr;
    atmp<= yr ;         -- oder dem hier überschrieben
  end if;

port map (a=> atmp , clock => rightflag , y=>yr);

Was macht da ein clock?
Ist das wirklich ein Takt?
Was sollen denn diese left und right Flags?
Ich glaube nicht, dass deine bis dato unbekannten Module shiftleft und 
shiftright wirklich funktionieren...

[Marco (Gast)]

clock soll ein externes Signal sein, dass den Process stimuliert 
(zyklisch shiften)

die right und left flags sind das clock Signal um die Processe der 
beiden anderen Module zu stimulieren.

Ich weiß, dass das alles von hinten durch die Brust ins Auge ist. So war 
aber die Aufgabenstellung

Hier mal exemplarisch eins der Submodule

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

use IEEE.NUMERIC_STD.ALL;

entity shiftleft is
generic(  N : integer := 8); --Bitbreite für den Ein- und Ausgang
    Port ( a : in  STD_LOGIC_VECTOR (N-1 downto 0);
           y : out  STD_LOGIC_VECTOR (N-1 downto 0);
        clock:in std_logic);
end shiftleft;

architecture Behavioral of shiftleft is

begin
-- es wird eine 0 an das Ende gesetzt und die Elemente 
-- von a um eine stelle nach links verschoben davor gesetzt
process(clock)
begin
y<= a(N-2 downto 0)& '0';
end process;
end Behavioral;

Ich bin für jede Anregung offen. Habe gerade meine zweite Vorlesung 
hinter mir und bin desshalb wie man sieht noch sehr unerfahren

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

Marco schrieb:
> clock soll ein externes Signal sein, dass den Process stimuliert
> (zyklisch shiften)
Das eine hat mit dem Anderen nichts zu tun. So wie du es beschrieben 
hast, ist in deinem Design kein Takt nötig. Das wird komplett 
kombinatorisch aufgebaut.

> Hier mal exemplarisch eins der Submodule
Wenn ichs mal direkt sagen darf: genauso ein Murks.

> Ich bin für jede Anregung offen. Habe gerade meine zweite Vorlesung
> hinter mir und bin desshalb wie man sieht noch sehr unerfahren
Leih dir das Buch "VHDL-Synthese" von Reichardt&Schwarz aus. Dir wird 
ein Licht aufgehen...

> process(clock)
Wenn ein Prozess so anfängt, dann folgt in der Praxis zwingend sowas:

  begin
     if rising_edge(clock) then ...

Oder wenigstens das:

  begin
     if clock'event and clock='1' then ...

Das gibt dann ein getaktetes Bauteil: ein Flipflop.

[Marco (Gast)]

Wie gesagt ich stehe noch ziemlich am Anfang. Das Buch werde ich mir 
ausleihen.

Um ehrlich zu sein bin ich gerade nur noch viel mehr verwirrt.
Die Anforderung war es ja eine zyklische Verschiebung durchzuführen. Ich 
könnte jetzt mal einen kleinen Wink mit dem Zaunpfal vertragen wie das 
denn aussehen müsste.

[Duke Scarring (Gast)]

Marco schrieb:
> use IEEE.NUMERIC_STD.ALL;
Nur für die Schönheit: Solange wie Du keine 'echten' Berechnungen 
machst, kannst Du diese Bibliothek weglassen.

Duke

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

Marco schrieb:
> Die Anforderung war es ja eine zyklische Verschiebung durchzuführen.
Was bedeutet "zyklisch"?
Eine "zyklische" Verschiebung könnte auch ein einfaches "Rotieren sein". 
Oder es könnte sein, dass um 1 Stelle pro Takt weitergeschoben wird, ob 
im Kreis oder geradeaus...

> Ich könnte jetzt mal einen kleinen Wink mit dem Zaunpfal vertragen
> wie das denn aussehen müsste.
Bisher ist nur die durch dich vorgefilterte Aufgabe zu sehen. Wie sieht 
die Originalaufgabe aus?

[Marco (Gast)]

Ich glaube der Wink war genau das was du gerade als erstes geschrieben 
hast.
Nachdem ich mal nach zyklischer verschiebung gegooglet hatte, ist mir 
das auch aufgefallen

Zyklisch bedeutet wahrscheinlich, dass der Vektor rotiert bzw das 
abgeschnittene Bit wieder drankommt.

Ich gebe die Aufgabe mal sinngemäß wieder, weil ich nicht weiß was mein 
Prof. davon halten würde wenn ich sie reinkopiere oder hochlade. Auf 
wunsch könnte ich sie dir auch per Mail schicken.

Aufgabe
Allg.
Es soll ein Barrelshifter implementiert werden, der einen N-Stelligen 
Eingansbus um S Stellen !!!ZYKLISCH verschiebt!!!. Dabei soll man die 
Verschieberichtung angeben können

Aufgabe 1

1.1 Erstellen sie 2 VHDL Module die je eine rechts bzw Linksseitige 
Verschiebung durchführen
1.2 Erstellen Sie ein Hauptmodule, welches die Module um die zyklisch 
durchzuführen
(hier war mein Fehler..ich sollte die Aufgaben richtig lesen!!!)
1.3 Testbench
1.4 Isim
1.5 aufs Board

2. Erweiterung um S (Anzahl der zu versch. Stellen)
wieder aufs Board mit LCD

3.Erweiterung auf 32 Bit


ich würde jetzt aber rein aus Interesse trotzdem mal ganz gerne wissen, 
wie das auszusehen hätte, wäre mit zyklisch getacktet gemeint

Ich habe alleine heut ganze 5 Stunden meines Lebens daran verbracht :D


Meine Lösung jetzt:

Hauptmodul:

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




entity Hauptmod_Aufgabe1 is
    --Vektorgröße kann eingestellt werden
    generic ( N: integer := 8);
    Port ( 
          lr_dir: in std_logic;
        yout: out std_logic_vector (N-1 downto 0);
        a : in std_logic_vector (N-1 downto 0));

end Hauptmod_Aufgabe1;

architecture Behavioral of Hauptmod_Aufgabe1 is
signal yr ,yl  : std_logic_vector (N-1 downto 0);


begin

--Portmapping 
--das Flag aktiviert jeweils den shiftprocess in den Submodulen
left: entity work.shiftleft(Behavioral)
port map (a=> a , y=>yl);
right: entity work.shiftright(Behavioral) 
port map (a=> a  , y=>yr);

with lr_dir select 
yout<=yl when '0',
yr when others;

end Behavioral;

exemplarisch Submodul links:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;

use IEEE.NUMERIC_STD.ALL;

entity shiftleft is
generic(  N : integer := 8); --Bitbreite für den Ein- und Ausgang
    Port ( a : in  STD_LOGIC_VECTOR (N-1 downto 0);
           y : out  STD_LOGIC_VECTOR (N-1 downto 0));
end shiftleft;

architecture Behavioral of shiftleft is

begin

y<= a(N-2 downto 0)& a(N-1);

end Behavioral;

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

Soweit, so gut...
Jetzt ist aber ein Barrelshifter etwas, das nicht nur um 1 Position, 
sondern um beliebig viele Positionen verschieben kann. Also müsste man 
jetzt neben der Richtung noch die Anzahl der zu rotierenden Positionen 
mit angeben. Und eigentlich ist bei einer Rotation die Richtung egal, 
denn egal, ob du ein Karussell links oder rechts rum drehst, du kannst 
beides mal das selbe erreichen. Man könnte also abhängig von der Länge 
des Vektors das Richtungsbit einfach als Vorzeichen für die Rotation 
sehen...

Als Basis für so einen Rotierer käme man dann z.B. auf sowas wie im 
Beitrag "Re: Rotate BitVector"

Etwas vereinfacht sähe dein Links-Rotierer also so aus:

 process (inp, n) 
 variable i : integer;
 begin
    -- um wieviel soll rotiert werden?
    i := to_integer(unsigned(n));  
    -- los gehts: nach links rotieren
    outp <= inp(inp'left-i downto 0) & inp(inp'left downto inp'left+1-i);        
 end process;

Und mit einer kleinen Korrektur wird er bidirektional:

 process (inp, n, rechts) 
 variable i : integer;
 begin
    -- um wieviel soll rotiert werden?
    i := to_integer(unsigned(n));  
    -- bei richtungsumkehr korrigieren
    if (rechts=1) then 
       i:=inp'length-i; 
    end if;
    -- los gehts: rotieren
    outp <= inp(inp'left-i downto 0) & inp(inp'left downto inp'left+1-i);        
 end process;

Marco schrieb:
> ich würde jetzt aber rein aus Interesse trotzdem mal ganz gerne wissen,
> wie das auszusehen hätte, wäre mit zyklisch getacktet gemeint
Ja, eben genau gleich. Nur wäre noch ein Register (oder ein paar davon) 
mit drin...

[Marco (Gast)]

Lothar Miller schrieb:
> Jetzt ist aber ein Barrelshifter etwas, das nicht nur um 1 Position,
> sondern um beliebig viele Positionen verschieben kann. Also müsste man
> jetzt neben der Richtung noch die Anzahl der zu rotierenden Positionen
> mit angeben

genau! Das, was ich gepostet habe war Aufgabenteil 1. Bei 2 sollte man 
das denn erweitern, sodass die Anzahl der zu verschibenen Bit angeben 
konnte. Hab das so ähnlich gemacht wie du beschreibst. Es war gefordert, 
dass man die die Anzahl mit 4 Dip Schaltern (0-7) einstellen kann.

Vielen Dank für die Hilfe

PS: Das Buch, welches du mir empfolen hattes war nicht verfügbar. Habe 
es mir vorgemerkt ;)