N-Stufiges Flip Flop erzeugen

[Daniel P. (daniel2345)]

Hallo zusammen,

ich würde gerne in VHDL ein n-Stufiges Flip Flop erzeugen, wobei ich den 
Parameter n über ein generic weitergeben wollte.

Ich habe mir zwei Codebeispiele überlegt, wobei beim ersten Codebespiel 
in der Simulation mit Vivado beim Ergebnis "X" auftauchen, also 
anscheinend mehrere Quellen für das Signal.

Kann bitte jemand die Codebeispiele bewerten oder hat evtl. noch einen 
besseren Vorschlag.

Vielen Dank im Voraus
Daniel

[Peter D. (peda)]

Daniel P. schrieb:
> ein n-Stufiges Flip Flop

Was soll das sein?
Mehrere FFs kann man als Schieberegister oder als Zähler kaskadieren.
Zähler können z.B. binär, dezimal, Gray-Code zählen.

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

Daniel P. schrieb:
> ich würde gerne in VHDL ein n-Stufiges Flip Flop erzeugen,
Du willst aus mehreren Flipflops ein n-stufiges Schieberegister 
erzeugen, oder? Und über dieses Schieberegister willst du ein Signal um 
n Takte verzögern.

> wobei ich den Parameter n über ein generic weitergeben wollte.
Das geht für 1 Bit einfach so:

:
generic n : integer range 2 to 16 := 2;
:
:
signal sr: std_logic_vector (n-1 downto 0)
:
sr <= sr(n-2 downto 2) & inbit  when rising_edge(clk); -- schiebt nach links
:
outbit <= sr(n-1);
:

Und für Vektoren geht es in etwa so:

:
generic n : integer := 2;
:
type slv16_array  is array (n-1 downto 0) of std_logic_vector(15 downto 0);
signal vsr : slv16_array := (others => (others => '0'));
:
vsr <= vsr(n-2 downto 2) & invect when rising_edge(clk); -- liest ein und schiebt nach links
outvect <= vsr(n-1);
:

Wenn die Länge des Schieberegisters zur Laufzeit umgeschaltet werden 
soll, dann sieht es für 1 Bit so aus:

:
signal n : integer range 2 to 16 := 2; -- min. 2 Bit, max. 16 Bit lang
signal sr: std_logic_vector (15 downto 0); -- muss für maximale Länge ausgelegt sein
:
sr <= sr(n-2 downto 2) & inbit  when rising_edge(clk); -- schiebt nach links
:
outbit <= sr(n-1);
:

Die Schieberegister-Zeile mit dem "when rising_edge()" kann man 
natürlich auch auf die lange Art mit einem Prozess schreiben:

process begin
   wait until rising_edge(clk);
   sr <= sr(n-2 downto 2) & inbit; -- schiebt nach links
end process;

Oder die traditionelle, ganz ausführliche Art aus dem letzten 
Jahrtausend:

process (clk)
begin
   if rising_edge(clk) then
      sr <= sr(n-2 downto 2) & inbit; -- schiebt nach links
   end if;
end process;

> also anscheinend mehrere Quellen für das Signal.
Für welches Signal?

[Rick D. (rickdangerus)]

Daniel P. schrieb:
> in der Simulation mit Vivado beim Ergebnis "X" auftauchen, also
> anscheinend mehrere Quellen für das Signal.
Nicht zwingend.

Manche Simulatoren machen bei der Zusammenfassung von Vektoren aus dem 
'U' ein 'X'...

[Daniel P. (daniel2345)]

Sorry für die Verwirrung:
Zum Hintergrund.
Ich bekomme als Eingangssignal einen 16Bit Zeitstempel.
In Abhängigkeit von einem Generic (in meinem Beispiel die Konstante 
c_clk_del) möchte ich den Zeitstempel um die Anzahl "c_clk_del" Takte 
verzögern.
Das ganze muss nicht zur Laufzeit umgeschaltet werden.

Lothar M. schrieb:
>> also anscheinend mehrere Quellen für das Signal.
> Für welches Signal?
time_stamp(0)

[Daniel P. (daniel2345)]

Danke für die Hilfe, habe mich für folgende Lösung entschieden:

type slv16_array  is array (n-1 downto 0) of std_logic_vector(15 downto 0);
signal vsr : slv16_array := (others => (others => '0'));
signal vsr_out : std_logic_vector(15 downto 0);
generic n : natural := 2;
vsr <= vsr(n-2 downto 0) & invec when rising_edge(clk);  
vsr_out <= vsr(n-1) when n > 0 else
           invec;