Verständnisfrage Einsynchronisieren

[Michael F. (mifi)]

Hallo zusammen,

zu dem Thema Einsynchronisieren habe ich folgende Threads gefunden:

Beitrag "Einsynchronisieren mit hörerer Taktrate sinnvoll?"
Beitrag "Einsynchronisieren von Spikes"
Beitrag "Einsynchronisieren von STD_LOGIC_VECTORen"
Beitrag "Einsynchronsieren mit 2 FFs"

Ich beziehe mich jetzt mal auf den letzten Thread "Einsynchronsieren mit 
2 FFs". Dieser Thread gibt nun den Hinweis das man zum 
Einsynchronisieren von asynchronen Signalen 2 FFs verwendet sollte.

Wobei mir jetzt noch nicht klar geworden ist ob man besser die FF 
Schreibweise benutzt oder die mit dem Schieberegister, oder ist das 
egal?

signal sig_tmp1 : STD_LOGIC;
signal sig_tmp2 : STD_LOGIC_VECTOR(1 downto 0);

----------------------------------------
-- 2 FFs
----------------------------------------
process(CLK)
begin
   if rising_edge(CLK) then
      sig_tmp1 <=sig_async1;
      sig_sync1<=sig_tmp1;
   end if;
end process;


----------------------------------------
-- Schieberegister
----------------------------------------
process(CLK)
begin
   if rising_edge(CLK) then
      sig_tmp2 <= sig_tmp2(0) & sig_async2;
   end if;
end process;
sig_sync2 <= sig_tmp2(1);


Weiterhin braucht man bei einem Bus nicht die Daten über die FFs zu
schicken, sondern das Steuersignal, z.B. write. Wie das geht hat Lothar
hier gezeigt: Beitrag "Re: Einsynchronsieren mit 2 FFs"

Wobei ich nicht verstehe warum Lothar in seinem Beispiel die Daten
das erste mal bei der fallenden Flanke von write (dasync <= daten)
und später diese das zweite mal "durch das Schieberegister" übernimmt
(dsync <= dasync).

Würde es nicht ausreichen dies nur bei dem Schieberegister zu machen:

   process begin
      -- gespeicherte Daten synchron weitergeben.
      wait until rising_edge(clk);
      wrsr <= wrsr(1 downto 0) & write; -- Schieberegister
      if(wrsr="100") then -- fallende Flanke
         dsync <= daten;
      end if;
   end process;

Der Hintergrund meiner Fragen ist das ich mal versuchen wollte einen 
UART im FPGA zu realisieren. Ja es gibt einige Beispiele bei OpenCores, 
aber vielleicht lernt man beim selber machen mehr?!

Der UART soll dann mit dem externen Bus einer CPU verbunden werden, als
CPU Schnittstelle gibt es dann folgende Signale:

CPU_ADR, CPU_DATA, CPU_CS, CPU_WR, CPU_RD

Und auf der UART Seite:

UART_TX, UART_RX

Zusätzlich noch ein RESET und CLK für das FPGA.

Nach den Infos aus den Threads würde ich nun folgende Signale 
einsynchronisieren:

RESET, CPU_WR, UART_RX

Wobei mir noch nicht ganz klar ist wann und wie ich die CPU Daten
über das "CPU_WR_SYNC" Signale mitnehmen soll.

Viele Grüße,
Michael

[Jan M. (mueschel)]

Michael Fischer schrieb:
> Wobei mir jetzt noch nicht klar geworden ist ob man besser die FF
> Schreibweise benutzt oder die mit dem Schieberegister, oder ist das
> egal?
Die beiden Schreibweisen sind identisch, ob dort nun ein Vektor und eine 
Anweisung oder zwei einzelne Signale verwendet werden ist der Synthese 
egal.

> Weiterhin braucht man bei einem Bus nicht die Daten über die FFs zu
> schicken, sondern das Steuersignal, z.B. write. Wie das geht hat Lothar
> hier gezeigt: Beitrag "Re: Einsynchronsieren mit 2 FFs"
> Wobei ich nicht verstehe warum Lothar in seinem Beispiel die Daten
> das erste mal bei der fallenden Flanke von write (dasync <= daten)
> und später diese das zweite mal "durch das Schieberegister" übernimmt
> (dsync <= dasync).
Das Speichern synchron zur fallenden Flanke des write Signals stellt 
sicher, dass die Daten genau dann übernommen werden, wenn sie auch 
wirklich valide sind.
Das Schieberegister verzögert die fallende Flanke etwas, so dass die 
Werte im ersten Register sicher stabil sind wenn das zweite Register sie 
mit dem Systemtakt übernimmt und zur restlichen Logik synchronisiert.

> Würde es nicht ausreichen dies nur bei dem Schieberegister zu machen:
Das geht nur, wenn sichergestellt ist, dass die Daten zu diesem 
Zeitpunkt immer noch am Bus stabil anliegen. Das ist jedoch im 
allgemeinen nicht gegeben, bzw. hängt von den genauen Spezifikationen 
des Busses ab.

> Der Hintergrund meiner Fragen ist das ich mal versuchen wollte einen
> UART im FPGA zu realisieren. Ja es gibt einige Beispiele bei OpenCores,
> aber vielleicht lernt man beim selber machen mehr?!
Da würde ich zuerst noch einen Blick auf Lothars Webseite werfen, dort 
hat er auch eine sehr einfache UART vorgestellt. Die nächstbessere 
Version wäre dann eine, die mit Überabtastung arbeitet und somit kurze 
Störungen herausfiltern kann.

> Nach den Infos aus den Threads würde ich nun folgende Signale
> einsynchronisieren:
> RESET, CPU_WR, UART_RX
Reset - ja wenn er denn wirklich nötig ist.
CPU_WR - ja, muss.
Uart_RX - ja, hier reicht aber sicher der minimalistische 1-FF Ansatz, 
da das Signal sich ja zum einen nur sehr selten ändert und zum anderen 
auch zuverlässig nur in der Mitte der Bits gelesen wird.

> Wobei mir noch nicht ganz klar ist wann und wie ich die CPU Daten
> über das "CPU_WR_SYNC" Signale mitnehmen soll.
Das kommt vor allem darauf an, wie der Bus genau spezifiziert ist. Der 
Ansatz den du oben gezeigt hast ist dafür in jedem Fall gut geeignet.

[Michael F. (mifi)]

Hallo Jan,

>> Wobei mir noch nicht ganz klar ist wann und wie ich die CPU Daten
>> über das "CPU_WR_SYNC" Signale mitnehmen soll.
>Das kommt vor allem darauf an, wie der Bus genau spezifiziert ist. Der
>Ansatz den du oben gezeigt hast ist dafür in jedem Fall gut geeignet.

Danke für die Erklärungen. Im Bezug auf den externen Bus
ist es sichergestellt das die Daten kurz vor, während,
und auch nach dem aktiven WRITE Signal noch anliegen.
Somit kann ich hier die etwas einfachere Version verwenden.

Ja, die Seite von Lothar mit dem UART kenne ich. Ich will erst mal
das Businterface und den Baudrate Generator erstellen. Danach
kommen dann die anderen Teile.

Viele Grüße,
Michael

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

Jan M. schrieb:
> Die beiden Schreibweisen sind identisch, ob dort nun ein Vektor und eine
> Anweisung oder zwei einzelne Signale verwendet werden ist der Synthese
> egal.
Das kann man sich z.B. auch ganz hübsch im RTL-Schaltplan (der von der 
Synthese ausgespuckt wird) ansehen.