From 1da5f4a88a84c3a6bd134be5ef244d0f3d14aab5 Mon Sep 17 00:00:00 2001
From: Friedrich Beckmann <friedrich.beckmann@tha.de>
Date: Tue, 8 Sep 2026 10:09:59 +0200
Subject: initial version

---
 dt-synchronisation.tex | 465 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 465 insertions(+)
 create mode 100644 dt-synchronisation.tex

(limited to 'dt-synchronisation.tex')

diff --git a/dt-synchronisation.tex b/dt-synchronisation.tex
new file mode 100644
index 0000000..44511e0
--- /dev/null
+++ b/dt-synchronisation.tex
@@ -0,0 +1,465 @@
+% !TEX root = dt-slides-dt.tex
+
+
+\section{Synchronisation}
+
+\begin{frame}
+\frametitle{Synchronisation}
+\center
+\Huge Synchronisation
+
+\vspace{1cm}
+
+\large Wie man asynchrone Signale einsynchronisiert
+\end{frame}
+
+\begin{frame}
+\frametitle{Synchronisation}
+\center
+\Huge Was passiert wenn die Eingänge einer synchronen Schaltung asynchron sind?
+
+\vspace{1cm}
+
+\large 
+\end{frame}
+
+\begin{frame}
+\frametitle{Synchrone Schaltung mit primären Eingängen}
+\hspace{2cm}
+\begin{tikzpicture}[circuit logic IEC, circuit ee IEC]
+
+\draw (0,0) node[shape=ff, anchor=D] (r0) {};
+\draw (r0.R) -- ++(down:1) node[anchor=north] {rst\_n};
+\draw (r0.CLK) -- ++(left:0.25) -- ++(down:1) node[contact] (cclk) {} -- ++(down:0.5) node[anchor=north] {clk};
+
+\draw (r0.D) -- node[above] (d) {d}++(left:1) node[cloud, anchor=east, draw=black, minimum width = 3 cm, minimum height = 2 cm] (zfl) {ZFL};
+\draw (r0.Q) -- node[above] (q) {q} ++(right:1)  node[contact] (c1) {} -- ++(right:1) node[cloud, anchor=west, draw=black, minimum width = 3 cm, minimum height = 2 cm] (al) {AL};
+\draw (zfl.west) -- node[above] {pi} ++(left:1) node[shape=ff,anchor = Q,draw=blue] (piff) {};
+\draw[draw=blue] (piff.CLK) -- ++(left:0.25) |- (cclk);
+
+\draw (al.east) -- ++(right:1) node[anchor = west] (po) {po};
+\draw (c1) -- ++(up:2) -| (zfl.north);
+
+
+\draw (zfl) -- ++(135:2) node[anchor=south] {Zustandsfolgelogik};
+\draw (al) -- ++(55:2) node[anchor=south] {Ausgangslogik};
+\draw (r0) -- ++(105:1) node[anchor=south] {Zustandsspeicher};
+\draw (q) -- ++(30:2) node[anchor=south] {aktueller Zustand};
+\draw (d) -- ++(-130:2.5) node[anchor=north] {Folgezustand};
+
+
+\end{tikzpicture} 
+\vspace{1cm}
+\begin{itemize}
+\item Bisher immer stillschweigend angenommen, dass die primären Eingänge pi auch aus einem Flipflop kommen
+
+\end{itemize}
+
+\end{frame}
+
+\begin{frame}
+\frametitle{Beispiel: Automat}
+\begin{tikzpicture}[state/.style=state with output,>=latex, auto]
+\node[state,initial] (sA)  {A (01)\nodepart{lower} 0};
+\node[state] (sB)  [right = 3 cm of sA] {B (10)\nodepart{lower} 1};
+\path[->]
+          (sA) edge[bend left]    node[above] {$x=1$} (sB)
+          (sA) edge[loop above]   node[above]  {$x=0$} (sA)
+          (sB) edge[bend left]   node[below] {} (sA)
+          ;
+\node[state] [right  = 3cm of sB] (example) {Zustand \nodepart{lower} y};
+\path[->] (example) edge node{$x$} ++(45:2cm);
+\end{tikzpicture}
+
+
+\begin{tikztimingtable}
+clk & 2L25{CC}\\
+rst\_n & 7L42H \\
+x & 12L10H10L \\
+state & 14D{A}2D{B}2D{A}2D{B}2D{A}2D{B}20D{A} \\
+y & 14L2H2L2H2L2H20L  \\
+\extracode
+\begin{pgfonlayer}{background}
+\begin{scope}[semitransparent ,semithick]
+\vertlines[black]{2,4,...,48}
+\horlines{2,3,...,3}
+\end{scope}
+\end{pgfonlayer}
+\end{tikztimingtable}
+
+\vspace{5mm}
+
+\begin{itemize}
+\item Als Beispiel für das Problem von asynchronen Signalen ein einfacher Automat.
+\item Der Automat hat zwei Zustände und einen Eingang x.
+\item Im Timingdiagramm oben ist das Eingangssignal x synchron.
+\item Wenn das Eingangssignal x = 0 ist, dann bleibt der Automat im Zustand A. Der Ausgang ist 0.
+\item Wenn das Eingangssignal x = 1 ist, dann wechselt der Automat mit jedem Takt zwischen den Zuständen A und B. Der Ausgang wechselt in jedem Takt zwischen 0 und 1.
+\item Der Automat wird als one-hot Maschine implementiert.
+\end{itemize}
+\end{frame}
+
+\begin{frame}
+\frametitle{Automat in One-Hot Kodierung}
+\begin{minipage}{0.45\textwidth}
+\scalebox{0.7}{
+\begin{tikzpicture}[state/.style=state with output,>=latex, auto]
+\node[state,initial] (sA)  {A (01)\nodepart{lower} 0};
+\node[state] (sB)  [right = 3 cm of sA] {B (10)\nodepart{lower} 1};
+\path[->]
+          (sA) edge[bend left]    node[above] {$x=1$} (sB)
+          (sA) edge[loop above]   node[above]  {$x=0$} (sA)
+          (sB) edge[bend left]   node[below] {} (sA)
+          ;
+\end{tikzpicture}}%scalebox
+\end{minipage}
+\begin{minipage}{0.45\textwidth}
+\scalebox{0.7}{
+\begin{tikzpicture}[state/.style=state with output,>=latex, auto]
+\node[state,initial] (sA)  {A (01)\nodepart{lower} 0};
+\node[state] (sB)  [right = 3 cm of sA] {B (10)\nodepart{lower} 1};
+\node[state] (s00) [below = 1 cm of sA] {00 \nodepart{lower} 0};
+\node[state] (s11) [right = 3 cm of s00] {11 \nodepart{lower} 1};
+\path[->]
+          (sA) edge[bend left]    node[above] {$x=1$} (sB)
+          (sA) edge[loop above]   node[above]  {$x=0$} (sA)
+          (sB) edge[bend left]   node[below] {} (sA)
+          (s00) edge[bend left]   (sA)
+          (s11) edge[bend left] node[above] {$x=0$}   (sA)
+          (s11) edge[loop above] node[above] {$x=1$}   (s11)
+          ;
+\end{tikzpicture}}%scalebox
+\end{minipage}
+
+\vspace{5mm}
+
+\begin{minipage}{0.35\textwidth}
+\begin{tabular}{cc|c}
+Eing. & akt.ZS & FolgeZS \\\hline
+x & $q_1q_0$ & $d_1d_0$ \\\hline
+0 & 01 & 01 \\
+0 & 10 & 01 \\
+1 & 01 & 10 \\
+1 & 10 & 01 \\
+\end{tabular}
+\end{minipage}
+\begin{minipage}{0.25\textwidth}
+\begin{align*}
+d_1 &= x \cdot q_0 \\
+d_0 &= \overline{x \cdot \overline{q_1} \cdot q_0} \\
+y &= q_1
+\end{align*}
+\end{minipage}
+\begin{minipage}{0.35\textwidth}
+
+Vollständige Zustandsfolgetabelle
+
+\begin{tabular}{cc|c}
+Eing. & akt.ZS & FolgeZS \\\hline
+x & $q_1q_0$ & $d_1d_0$ \\\hline
+0 & 00 & 01 \\
+0 & 01 & 01 \\
+0 & 10 & 01 \\
+0 & 11 & 01 \\
+1 & 00 & 01 \\
+1 & 01 & 10 \\
+1 & 10 & 01 \\
+1 & 11 & 11 \\
+\end{tabular}
+\end{minipage}
+\end{frame}
+
+
+\begin{frame}
+\frametitle{Schaltung mit Timing: Bei der Taktflanke: $d_1$ neu und $d_0$ noch alt!!!}
+\begin{minipage}{0.25\textwidth}
+\begin{align*}
+d_1 &= x \cdot q_0 \\
+d_0 &= \overline{x \cdot \overline{q_1} \cdot q_0} \\
+y &= q_1\\
+\\
+t_p &= 10 ns \\
+t_{CQ} &= 10 ns \\
+t_{per,clk} &= 100 ns \\
+\end{align*}
+\end{minipage}
+\begin{minipage}{0.7\textwidth}
+\scalebox{0.9}{
+\begin{circuitikz}
+\ctikzset{tripoles/european not symbol=ieee circle}
+\ctikzset{flipflops/scale=0.5}
+% Flipflops
+\draw (0,0) node[flipflop D,
+flipflop def={tu=S, nu=1}, anchor = pin 1] (r0) {r0};
+\draw (0,3) node[flipflop D,
+flipflop def={td=R, nd=1}, anchor = pin 1] (r1) {r1};
+% ZFL
+\draw (r0.pin 1) -- node[above] {$d_0$}++(left:0.5) node[european not port, anchor=out] (g2) {};
+\draw (g2.in 1) -- node[above] {a} ++(left:0.5) node[european and port,anchor=out] (g1) {};
+\draw (g1.bin 2) node[ocirc, left] {};
+\draw (g1.in 1 |- r1.pin 1) node[circ] (c0) {} -- node[above] {$d_1$}(r1.pin 1); 
+\draw (c0) -- ++(left:0.5) node[european and port, anchor=out] (g0) {};
+\draw (c0) -- (g1.in 1);
+\draw (g1.in 2) node[anchor=east] {$q_1$};
+\draw (g0.in 1) node[anchor=east] {x};
+\draw (g0.in 2) node[anchor=east] {$q_0$};
+%Ausgänge
+\draw (r0.pin 6) -- ++(right:1) node[anchor=west] {$q_0$};
+\draw (r1.pin 6) -- node[above] {$q_1$} ++(right:1) node[anchor=west] {y};
+%clk
+\draw (r0.pin 3) node[circ] (cclk) {} -- ++(down:1) node[anchor=north] (clk) {clk};
+\draw (r1.pin 3) -- (cclk);
+%reset
+\draw (r1.down) -- ++(down:1) node[circ] (creset) {} -- (r0.up);
+\draw (clk.north) ++(right:1.5) node[anchor=north] (rst) {rst\_n};
+\draw (creset) -| (rst);
+\end{circuitikz}}
+\end{minipage}
+
+\begin{tikztimingtable}
+clk & 3{10C10C}\\
+x & 26L34H \\
+$d_1$ & 28L32H\\
+a & 30L4H26L\\
+$d_0$ & 32H4L24H \\
+$q_1$ & 32L28H \\
+$q_0$ & 60H\\
+\extracode
+\begin{pgfonlayer}{background}
+\begin{scope}[semitransparent ,semithick]
+\vertlines[black]{2,4,...,48}
+\horlines{2,3,...,3}
+\end{scope}
+\end{pgfonlayer}
+\end{tikztimingtable}
+\end{frame}
+
+\begin{frame}
+\frametitle{Problem: x ist asynchron. Keine Relation zum Taktsignal. }
+\begin{block}{x ist asynchron und hat deshalb keine Relation zum Taktsignal}
+Das asynchrone Eingangssignal x kann sich irgendwann ändern. 
+\end{block}
+\begin{block}{Unterschiedliche Verzögerungszeiten vom Eingang x zu den D Eingängen}
+Durch unterschiedliche Verzögerungszeiten vom Eingang x zu den D Eingängen der Flipflops, kann es passieren, dass manche Eingänge noch den alten Wert der Zustandsfolgelogik sehen und einige schon den neuen Wert. 
+\end{block}
+\begin{block}{Zustandsfolgelogik als Wahrheitstabelle ist dann nicht gültig!!!}
+Jetzt muss also das Timing der Schaltung berücksichtigt werden und die Darstellung der Zustandsfolgelogik als Wahrheitstabelle funktioniert nicht mehr. Damit ist der ganze Automatengraph nicht mehr gültig.
+\end{block}
+\begin{alertblock}{Asynchrone Signale - Viel Freude damit...}
+Das Verhalten des asynchronen Signale kann im Simulator nicht simuliert werden. Das Timing der Schaltung ist bei der RTL Simulation nicht berücksichtigt und der Zeitpunkt der Änderung ist beliebig. Diese Schaltungskonstellation mit einem asynchronen Eingang, der durch kombinatorische Logik an mehrere D Eingänge geht muss vermieden werden.
+\end{alertblock}
+\end{frame}
+
+\begin{frame}
+\frametitle{Tritt ja nur selten auf }
+\begin{block}{Nur im Intervall von schnellen und langsamen Pfaden}
+Das Problem tritt nur auf, wenn die Taktflanke dann kommt, wenn schon mindestens ein D Eingang den neuen und mindestens ein Eingang noch den alten Wert von der Zustandsfolgelogik haben. Es kommt also auf die Unterschiede in der Verzögerungszeit an.
+\end{block}
+\begin{block}{Vielleicht kann man die Verzögerungszeiten ja ähnlich lang machen?}
+Angenommen man könnte die Verzögerungszeiten der unterschiedlichen Pfade fast gleich lang machen. Sagen wir 10 ns  Taktperiodendauer (= 100 MHz Taktfrequenz) und 1 ps Laufzeitunterschiede. Das Signal am Eingang soll sich im Durchschnitt alle 1000 Takte einmal ändern. 1 ps von 10 ns sind 1/10000 der Taktperiode.
+\end{block}
+\begin{block}{Statistik...}
+Wenn sich das Eingangssignal ändert, dann ist die Chance 1/10000, dass es zu einem Problem kommt, weil die Taktflanke sich genau in dem 1 ps Intervall ändert. Alle 1000 Takte ändert sich das Eingangssignal. Das sind dann also nur noch 100MHz/1000 = 100000 Versuche pro Sekunde, das Intervall zu treffen. Das Problem tritt also 10 mal pro Sekunde auf.
+\end{block}
+\begin{alertblock}{Asynchrone Signale - Viel Freude damit...}
+Nein. Geht nicht.
+\end{alertblock}
+\end{frame}
+
+\begin{frame}
+\frametitle{Gegenmaßnahmen: Synchronisationsflipflop}
+\begin{minipage}{0.7\textwidth}
+\scalebox{0.9}{
+\begin{circuitikz}
+\ctikzset{tripoles/european not symbol=ieee circle}
+\ctikzset{flipflops/scale=0.5}
+% Flipflops
+\draw (0,0) node[flipflop D,
+flipflop def={tu=S, nu=1}, anchor = pin 1] (r0) {r0};
+\draw (0,3) node[flipflop D,
+flipflop def={td=R, nd=1}, anchor = pin 1] (r1) {r1};
+% ZFL
+\draw (r0.pin 1) -- node[above] {$d_0$}++(left:0.5) node[european not port, anchor=out] (g2) {};
+\draw (g2.in 1) -- node[above] {a} ++(left:0.5) node[european and port,anchor=out] (g1) {};
+\draw (g1.bin 2) node[ocirc, left] {};
+\draw (g1.in 1 |- r1.pin 1) node[circ] (c0) {} -- node[above] {$d_1$}(r1.pin 1); 
+\draw (c0) -- ++(left:0.5) node[european and port, anchor=out] (g0) {};
+\draw (c0) -- (g1.in 1);
+% Eingänge
+\draw (g1.in 2) node[anchor=east] {$q_1$};
+\draw (g0.in 2) node[anchor=east] {$q_0$};
+% Synchflipflop
+\draw (g0.in 1) -- node[above] {x\_sync} ++(left:1) node[flipflop D,
+flipflop def={td=R, nd=1}, anchor = pin 6] (rs) {rs};
+\draw (rs.pin 1) -- ++(left:0.5) node[anchor=east] {x};
+\draw (rs.pin 3) |- (r0.pin 3);
+
+%Ausgänge
+\draw (r0.pin 6) -- ++(right:1) node[anchor=west] {$q_0$};
+\draw (r1.pin 6) -- node[above] {$q_1$} ++(right:1) node[anchor=west] {y};
+%clk
+\draw (r0.pin 3) node[circ] (cclk) {} -- ++(down:1) node[anchor=north] (clk) {clk};
+\draw (r1.pin 3) -- (cclk);
+%reset
+\draw (r1.down) -- ++(down:1) node[circ] (creset) {} -- (r0.up);
+\draw (clk.north) ++(right:1.5) node[anchor=north] (rst) {rst\_n};
+\draw (creset) -| (rst);
+\end{circuitikz}}
+\end{minipage}
+
+\begin{block}{Synchronisationsflipflop}
+Das Synchronisationsflipflop synchronisiert das asynchrone Eingangssignal x ein. Der Ausgang kann sich nur synchron ändern. Das asynchrone Signal darf nur zu einem einzigen Flipflop an den D Eingang gehen.
+\end{block}
+\begin{alertblock}{Setup- und Holdverletzungen}
+Das eine Flipflop ist schon eine Riesenverbesserung. Aber was passiert, wenn das Signal x sich um die Taktflanke ändert und es zu Setup-/Holdverletzungen kommt????
+\end{alertblock}
+\end{frame}
+
+
+\begin{frame}
+\frametitle{Setup- und Holdverletzungen}
+
+
+	\scalebox{1.3}{
+	\begin{tikztimingtable}
+		$clk$ & 2C9{4C}\\
+		$rst_n$ & 4L34H \\
+		$d$ & 13H9L5H5L6H \\
+	    $q$ & 11L8H8L13X \\
+	\extracode
+	\begin{pgfonlayer}{background} 
+		\draw[fill=red!30!white,draw=none] (7,2) rectangle (10,-7);
+		\draw[fill=orange!30!white,draw=none] (10,2) rectangle (12,-7);
+		\draw[fill=red!30!white,draw=none] (15,2) rectangle (18,-7);
+		\draw[fill=orange!30!white,draw=none] (18,2) rectangle (20,-7);
+		\draw[fill=red!30!white,draw=none] (23,2) rectangle (26,-7);
+		\draw[fill=orange!30!white,draw=none] (26,2) rectangle (28,-7);
+		\draw[fill=red!30!white,draw=none] (31,2) rectangle (34,-7);
+		\draw[fill=orange!30!white,draw=none] (34,2) rectangle (36,-7);
+		\begin{scope}[semitransparent,semithick]
+			\vertlines[gray]{1, 2, 3, ..., 38}
+			\horlines[lightgray]{1,2,3,4}
+		\end{scope}		
+		\draw (10, 2.2) node[anchor=south] {1};
+		\draw (18, 2.2) node[anchor=south] {2};
+		\draw (26, 2.2) node[anchor=south] {3};
+		\draw (34, 2.2) node[anchor=south] {4};
+		\draw[thin] (2, 1) -- (2,2.2);
+		\draw[thin] (10, 1) -- (10,2.2);
+		\draw[<->,thin] (15,2) -- (18,2) node[pos=0.5,above] {\tiny{$t_s$}};
+		\draw[thin] (15, 1) -- (15,2.2);
+		\draw[thin] (18, 1) -- (18,2.2);
+		\draw[<->,thin] (18,2) -- (20,2) node[pos=0.5,above] {\tiny{$t_h$}};
+		\draw[thin] (20, 1) -- (20,2.2);
+
+	\end{pgfonlayer}
+	\end{tikztimingtable}
+	}%Scalebox
+
+
+
+\begin{block}{Leichte Verletzungen}
+Leichte Setup- oder Holdverletzungen bedeuten, dass das Signal am D Eingang sich  zwar innerhalb der Setup- und Holdzeit ändert, aber noch nicht "sehr nah" an der Taktflanke. Bei leichten Timingverletzungen wird ein Flipflop langsamer, d.h. das Clock to Outputdelay $t_{CQ}$ wird größer als im Datenblatt angegeben und in der Timingverifikation angenommen. Dann stimmt die Timingverifikation nicht mehr und es kann Probleme bei den nachfolgenden Flipflops geben.
+\end{block}
+
+\begin{block}{Metastabiler Zustand}
+Wenn sich das Signal am D-Eingang in der Nähe der Taktflanke ändert, dann kann das Flipflop in einen "metastabilen Zustand" gehen. Das Ausgangssignal ist dann nicht mehr High oder Low, sondern nimmt einen Mittelwert ein. Irgendwann kippt das Flipflop dann nach High oder Low. Diese Zeit "irgendwann" lässt sich nicht genau bestimmen und ist wahrscheinlichkeitsverteilt, d.h. sehr selten dauert es sehr lange und häufig kippt das Flipflop schon nach kurzer Zeit zurück. 
+\end{block}
+
+\begin{alertblock}{Und jetzt?}
+
+\end{alertblock}
+\end{frame}
+
+
+\begin{frame}
+\frametitle{Metastabiler Zustand}
+
+\includegraphics[width=\textwidth]{sync/metastable}
+
+\begin{block}{Metastabiler Zustand}
+Messungen zum Metastabilen Zustand. Aus: Chaney and Molnar, Anomalous Behaviour of Synchronizer and Arbiter Circuits, IEEE Transactions on Computers, April 1973
+\end{block}
+
+\begin{alertblock}{Und jetzt?}
+
+\end{alertblock}
+\end{frame}
+
+
+\begin{frame}
+\frametitle{Synchronisationskette aus zwei bis drei Flipflops}
+
+\begin{minipage}{0.7\textwidth}
+\scalebox{0.9}{
+\begin{circuitikz}
+\ctikzset{tripoles/european not symbol=ieee circle}
+\ctikzset{flipflops/scale=0.5}
+% Flipflops
+\draw (0,0) node[flipflop D,
+flipflop def={tu=S, nu=1}, anchor = pin 1] (r0) {r0};
+\draw (0,3) node[flipflop D,
+flipflop def={td=R, nd=1}, anchor = pin 1] (r1) {r1};
+% ZFL
+\draw (r0.pin 1) -- node[above] {$d_0$}++(left:0.5) node[european not port, anchor=out] (g2) {};
+\draw (g2.in 1) -- node[above] {a} ++(left:0.5) node[european and port,anchor=out] (g1) {};
+\draw (g1.bin 2) node[ocirc, left] {};
+\draw (g1.in 1 |- r1.pin 1) node[circ] (c0) {} -- node[above] {$d_1$}(r1.pin 1); 
+\draw (c0) -- ++(left:0.5) node[european and port, anchor=out] (g0) {};
+\draw (c0) -- (g1.in 1);
+% Eingänge
+\draw (g1.in 2) node[anchor=east] {$q_1$};
+\draw (g0.in 2) node[anchor=east] {$q_0$};
+% Synchflipflop
+\draw (g0.in 1) -- node[above] {x\_sync} ++(left:1) node[flipflop D,
+flipflop def={td=R, nd=1}, anchor = pin 6] (rs) {rs};
+\draw (rs.pin 1) -- node[above] {x\_sync1} ++(left:1) node[flipflop D,
+flipflop def={td=R, nd=1}, anchor = pin 6] (rs1) {rs1};
+\draw (rs.pin 3) |- (r0.pin 3);
+
+\draw (rs1.pin 1) -- ++(left:0.5) node[anchor=east] {x};
+\draw (rs.pin 3 |- r0.pin 3) node[circ] (cclks) {};
+\draw (rs1.pin 3) |- (cclks);
+
+%Ausgänge
+\draw (r0.pin 6) -- ++(right:1) node[anchor=west] {$q_0$};
+\draw (r1.pin 6) -- node[above] {$q_1$} ++(right:1) node[anchor=west] {y};
+%clk
+\draw (r0.pin 3) node[circ] (cclk) {} -- ++(down:1) node[anchor=north] (clk) {clk};
+\draw (r1.pin 3) -- (cclk);
+%reset
+\draw (r1.down) -- ++(down:1) node[circ] (creset) {} -- (r0.up);
+\draw (clk.north) ++(right:1.5) node[anchor=north] (rst) {rst\_n};
+\draw (creset) -| (rst);
+\end{circuitikz}}
+\end{minipage}
+
+\begin{block}{Synchronisationskette aus zwei bis drei Flipflops}
+Setup- und Holdverletzungen lassen sich am ersten Flipflop der Kette nicht vermeiden. Die Wahrscheinlichkeit am zweiten Flipflop ist allerdings schon sehr viel geringen. Durch eine Kette von zwei bis drei Flipflops lassen sich Timingprobleme an den synchronen Flipflops in der Schaltung vermeiden.
+\end{block}
+
+\end{frame}
+
+
+\begin{frame}
+\frametitle{Synchronisation von parallelen Datenbussen}
+
+\vspace{6cm}
+
+\begin{block}{Bei parallelen Bussen nicht alle Datenleitungen einzeln synchronisieren}
+Bei parallelen Datenbussen darf man nicht alle Datenleitungen einzeln synchronisieren, da vielleicht eine Synchronisationskette einen alten und andere einen neuen Wert hat. Man braucht eine einzelne Leitung, die synchronisiert wird und die Datenleitung dürfen sich nicht ändern, bis die Synchronisation abgeschlossen ist.
+\end{block}
+
+\end{frame}
+
+
+
+
+
+
+
+
+
+
+
+
-- 
cgit v1.2.3

