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;

[Bradward B. (Firma: Starfleet) (ltjg_boimler)]

>

 type slv16_array  is array (n-1 downto 0) of std_logic_vector(15 downto 0);
 signal vsr : slv16_array := (others => (others => '0'));
 --snip

Auf den default-wert in Zeile 2 ist nach der Synthese kein Verlass.

[Rick D. (rickdangerus)]

Bradward B. schrieb:
> Auf den default-wert in Zeile 2 ist nach der Synthese kein Verlass.
Prinzipiell ja, aber sowas prüft man einmal, ob das vom jeweiligen 
Synthesetool richtig umsetzt wird. Und das Synthesetool wechselt man 
nicht so oft wie die Socken...

Ich hatte den Fall bei Lattice Diamond neulich, wo ich meinen Code etwas 
umformulieren musste:

Ein

    type config_type is array( 0 to 15) of  std_ulogic_vector( 7 downto 0);
    constant default_config : config_type :=
    (
        0      => "11110000",
        others => ( others => '0')
    );

    constant default_config_array : config_array_t := ( others => ( default_config));

wird später partiell überschrieben, aber die default_config wurde nur 
komplett mit '0' initialisiert.

Nach ausformulieren:

    signal config_array : config_array_t := default_config_array;

begin

    -- needed for Lattice LSE
    -- otherwise byte 0 is not correct inialized
    --config_array( 0)    <= default_config; -- is used
    config_array( 1)    <= default_config;
    config_array( 2)    <= default_config;
    ...

    module_i0: entity work.module
    port map
    (
        clk          => clk,                    -- : in    std_ulogic;
        ...
        config       => config_array( 0),       -- : out   config_type;
        ...
    );

klappte es wie gewünscht...

[Bradward B. (Firma: Starfleet) (ltjg_boimler)]

>> Auf den default-wert in Zeile 2 ist nach der Synthese kein Verlass.
> Prinzipiell ja, aber sowas prüft man einmal, ob das vom jeweiligen
> Synthesetool richtig umsetzt wird. Und das Synthesetool wechselt man
> nicht so oft wie die Socken...

Hm, erzähl das mal einem Barfüßler ;-)

Ich seh hier eher das Problem der Architektur, gibt man einen 
Reset-Value an, nimmt das Synthesetool oft keine Schieberegister.Makros 
wie SRL16 (bspw. Xilinx Spartan) auch wenn es in der konkreten 
FPGA-Architektur möglich wäre. Aber der TO wollte ja lt. Headline 
ohnehin ("riesige") FF statt schlanke Schiebeketten.