initial versionHEADmaster

1 files changed, 1134 insertions, 0 deletions

diff --git a/dt-automaten.tex b/dt-automaten.tex
new file mode 100644
index 0000000..219393c
--- /dev/null
+++ b/dt-automaten.tex
@@ -0,0 +1,1134 @@
+% !TEX root = dt-slides-dt.tex
+
+\section{Automaten}
+
+\begin{frame}
+\frametitle{Automaten}
+\center
+\Huge Automaten
+\end{frame}
+
+\begin{frame}
+\frametitle{Automatentypen Moore / Mealy / Medwedew}
+\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[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) -- ++(left:1) node[anchor = east] (pi) {pi};
+\draw (al.east) -- ++(right:1) node[anchor = west] (po) {po};
+\draw (c1) -- ++(up:2) -| (zfl.north);
+
+%Mealy
+\draw (pi.east) ++(right:0.5) node[contact, draw=blue, fill=blue] (c2) {};
+\draw[draw=blue] (c2) -- ++(down:1.25) -| (al.south);
+
+\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 Moore: d = f(q,pi), po = f(q)
+\item \textcolor{blue}{Mealy: d = f(q,pi), po = f(q,pi)}
+\item Medwedew: d = f(q,pi), po = q
+\item Alle synchronen Schaltungen lassen sich als Mealyautomat auffassen
+\end{itemize}
+
+\end{frame}
+
+\subsection{Mooreautomaten}
+
+\begin{frame}
+\frametitle{Automaten - Darstellung als Graph - Moore}
+\begin{tikzpicture}[state/.style=state with output,>=latex, auto]
+\node[state,initial] (sA)  {Idle \nodepart{lower} 001};
+\node[state] (sB)  [right = 3 cm of sA] {Data \nodepart{lower} 010};
+\node[state] (sC)  [below  = 2 cm of sB] {Turn \nodepart{lower} 101};
+\path[->]
+          (sA) edge[bend left]    node[above] {$x=1$} (sB)
+          (sA) edge[loop above]   node[above]  {$x=0$} (sC)
+          (sB) edge[bend left]   node[below] {$0$} (sA)
+          (sB) edge[bend right]   node[left] {$1$} (sC)
+          (sC) edge[bend right]   node[right] {$1$} (sB)
+          (sC) edge[bend left]    node[left]  {$0$} (sA)
+          ;
+\node[state] [right  = 3cm of sB] (example) {Zustand \nodepart{lower} $y_2y_1y_0$};
+\path[->] (example) edge node{$x$} ++(45:2cm);
+\end{tikzpicture}
+
+\begin{itemize}
+\item Die Zustände (q) werden durch Kreise symbolisiert
+\item Beim Mooreautomaten hängen die Ausgangswerte nur vom Zustand ab: po=y=f(q)
+\item Die Ausgangswerte werden deshalb in den unteren Halbkreis der Zustände geschrieben
+\item Der Folgezustand hängt vom aktuellen Zustand und den Werten am Eingang ab: d=f(q,pi)=f(q,x)
+\item Deshalb werden die Zustandswechsel mit Pfeilen mit Bedingungen für die Eingänge dargestellt
+\item Der Resetwert der Flipflops stellt den Startzustand dar. Er wird mit \glqq Start\grqq\ markiert
+\item Ein Automat kann zu einem Zeitpunkt immer nur in einem Zustand sein
+\item Der Zustandswechsel erfolgt immer zu einer Taktflanke - außer bei einem asynchronen Reset
+\end{itemize}
+\end{frame}
+
+\begin{frame}
+\frametitle{Modulo 4 Zähler als Graph}
+
+\begin{tikzpicture}[state/.style=state with output,>=latex, auto]
+\node[state,initial] (sA)  {A \nodepart{lower} 00};
+\node[state] (sB)  [below right = 1 of sA] {B \nodepart{lower} 01};
+\node[state] (sC)  [below left = 1 cm of sB] {C \nodepart{lower} 10};
+\node[state] (sD)  [above left = 1 cm of sC] {D \nodepart{lower} 11};
+\path[->]
+          (sA) edge[bend left] (sB)
+          (sB) edge[bend left] (sC)
+          (sC) edge[bend left] (sD)
+          (sD) edge[bend left] (sA)
+          ;
+\node[state] [above right  = 2cm of sB] (example) {Zustand \nodepart{lower} $y_1y_0$};
+\path[->] (example) edge  ++(45:2cm);
+\end{tikzpicture}
+\vspace{1cm};
+
+\begin{tikztimingtable}
+clk & 2L25{CC}\\
+rst\_n & 7L42H \\
+y &  8D{0}2D{1}2D{2}2D{3}2D{0}2D{1}2D{2}2D{3}2D{0}2D{1}2D{2}2D{3}2D{0}2D{1}2D{...} \\
+state &  8D{A}2D{B}2D{C}2D{D}2D{A}2D{B}2D{C}2D{D}2D{A}2D{B}2D{C}2D{D}2D{A}2D{B}2D{...} \\
+\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{Enablegenerator}
+
+\begin{tikzpicture}[state/.style=state with output,>=latex, auto]
+\node[state,initial] (sA)  {A \nodepart{lower} 0};
+\node[state] (sB)  [below right = 1 of sA] {B \nodepart{lower} 0};
+\node[state] (sC)  [below left = 1 cm of sB] {C \nodepart{lower} 0};
+\node[state] (sD)  [above left = 1 cm of sC] {D \nodepart{lower} 1};
+\path[->]
+          (sA) edge[bend left] (sB)
+          (sB) edge[bend left] (sC)
+          (sC) edge[bend left] (sD)
+          (sD) edge[bend left] (sA)
+          ;
+\node[state] [above right  = 2cm of sB] (example) {Zustand \nodepart{lower} $y$};
+\path[->] (example) edge  ++(45:2cm);
+\end{tikzpicture}
+\vspace{1cm};
+
+\begin{tikztimingtable}
+clk & 2L25{CC}\\
+rst\_n & 7L42H \\
+y &  12L2H6L2H6L2H2L \\
+state &  8D{A}2D{B}2D{C}2D{D}2D{A}2D{B}2D{C}2D{D}2D{A}2D{B}2D{C}2D{D}2D{A}2D{B}2D{...} \\
+\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{Wiederholung - Enablegeneratorschaltungen Modulo 4 / Ringzähler}
+\center
+\Huge Wiederholung: Enablegeneratorschaltung
+\end{frame}
+
+
+
+\begin{frame}
+\frametitle{Enablegenerator - Basis Modulo 4 Zähler}
+\center
+\begin{tikzpicture}[circuit logic IEC, circuit ee IEC]
+
+\draw (0,0) rectangle (1.2,2.5);
+\draw (0,0.5) node [anchor=west] (b) {b};
+\draw (0,2) node [anchor=west] (a) {a};
+\draw (1.2,1.25) node [anchor=east] (y) {y};
+\draw (0.6,1.25) node {+};
+\draw (y.east) -- node[above] {d[1..0]} ++(right:1) node[shape=ff, anchor=D] (r0) {};
+\draw (r0.Q) -- node[above] {q[1..0]} ++(right:1)  node[contact] (c0) {};
+\draw (a.west) -- ++(left:1) -- ++(up:1) -| (c0);
+\draw (c0) -- ++(right:0.2) node[anchor=west, draw, inner sep = 3] (cmp) {=3};
+\draw (cmp.east) -- ++(right:0.5) node[anchor=west] {y};
+\draw (b.west) -- ++(left:1) node [anchor=east] {$1_D$};
+\draw (r0.R) -- ++(down:1) node[anchor=north] {rst\_n};
+\draw (r0.CLK) -- ++(left:0.25) -- ++(down:1) node[anchor=north] {clk};
+
+\end{tikzpicture} 
+
+\begin{exampleblock}{Enablegenerator auf Basis Modulo 4 Zähler}
+Am Ausgang des Modulo 4 Zählers testet ein Vergleicher den Zählerstand. Der Ausgang y ist 1, wenn der Zähler den Wert 3 hat. Dann geht der Ausgang jeden vierten Takt auf 1.
+\end{exampleblock}
+
+\begin{tikztimingtable}
+clk & 2L25{CC}\\
+rst\_n & 7L42H \\
+y &  12L2H6L2H6L2H2L \\
+state &  8D{A}2D{B}2D{C}2D{D}2D{A}2D{B}2D{C}2D{D}2D{A}2D{B}2D{C}2D{D}2D{A}2D{B}2D{...} \\
+q[1..0] & 8D{0}2D{1}2D{2}2D{3}2D{0}2D{1}2D{2}2D{3}2D{0}2D{1}2D{2}2D{3}2D{0}2D{1}2D{...} \\
+\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{Enablegenerator - Basis Ringzähler}
+\begin{circuitikz}
+\ctikzset{flipflops/scale=0.5}
+%\ctikzset{tripoles/european not symbol=ieee circle}
+\draw (0,0) node[flipflop D, flipflop def={tu=S, nu=1}] (ff0) {};
+\draw (2,0) node[flipflop D, flipflop def={td=R, nd=1}] (ff1) {};
+\draw (4,0) node[flipflop D, flipflop def={td=R, nd=1}] (ff2) {};
+\draw (6,0) node[flipflop D, flipflop def={td=R, nd=1}] (ff3) {};
+
+\draw (ff0.pin 6) -- node[above] {q3} (ff1.pin 1);
+\draw (ff1.pin 6) -- node[above] {q2} (ff2.pin 1);
+\draw (ff2.pin 6) -- node[above] {q1} (ff3.pin 1);
+\draw (ff3.pin 6) -- node[above] {q0} ++(right:0.5) node[circ] (cres) {} -- ++(up:1) -| (ff0.pin 1);
+\draw (cres) -- ++(right:0.5) node[anchor=west] {y};
+
+
+\draw (ff0.pin 3) -- ++(down:1) node[circ] (c0) {} -- ++(left:1) node[anchor=east] (clk) {clk};
+\draw (ff3.pin 3) |- (c0);
+\draw (ff1.pin 3) -- (ff1.pin 3 |- c0) node[circ] {};
+\draw (ff2.pin 3) -- (ff2.pin 3 |- c0) node[circ] {};
+
+\draw (clk.east) ++(down:0.5) node[anchor=east] (rst) {rst\_n};
+\draw (ff3.down) |- (rst.east);
+\draw (ff1.down) -- (ff1.down |- rst.east) node[circ] {};
+\draw (ff2.down) -- (ff2.down |- rst.east) node[circ] {};
+\draw (ff0.up) -- ++(up:0.2) -- ++(right:0.7) coordinate (s0) {} -- (s0 |- rst.east) node[circ] {};
+
+\end{circuitikz}
+
+\begin{exampleblock}{Enablegenerator auf Basis eines Ringzählers}
+Der Ausgang q0 des Ringzählers ist gleichzeitig der Ausgang der Gesamtschaltung. Auch hier wird der Ausgang in jedem vierten Takt 1.
+\end{exampleblock}
+
+\begin{tikztimingtable}
+clk & 12{2C2C} \\
+rst\_n & 7L40H \\
+y & 18L4H12L4H5L \\
+state &  10D{A}4D{B}4D{C}4D{D}4D{A}4D{B}4D{C}4D{D}4D{A}4D{...} \\
+q[3..0] & 10D{1000}4D{0100}4D{0010}4D{0001}4D{1000}4D{0100}4D{0010}4D{0001}4D{1000}4D{...}  \\
+\extracode
+\begin{pgfonlayer}{background}
+\begin{scope}[semitransparent ,semithick]
+\vertlines[black]{2,4,...,48}
+\horlines{2,3,...,4}
+\end{scope}
+\end{pgfonlayer}
+\end{tikztimingtable}
+
+\end{frame}
+
+\begin{frame}
+\frametitle{Enablegenerator}
+\center
+\Huge Wir haben einen Graphen für den Enablegenerator und zwei Schaltungen. Was unterscheidet die beiden Schaltungen?
+\end{frame}
+
+\begin{frame}
+\frametitle{Enablegenerator}
+\center
+\Huge siehe: Zustandskodierung (später)
+\end{frame}
+
+\begin{frame}
+\frametitle{Automaten}
+\center
+\Huge Beispiele für Automaten mit Eingängen
+\end{frame}
+
+\begin{frame}
+\frametitle{Modulo 4 Zähler mit Enable als Graph}
+
+\begin{tikzpicture}[state/.style=state with output,>=latex, auto]
+\node[state,initial] (sA)  {A \nodepart{lower} 00};
+\node[state] (sB)  [below right = 1 of sA] {B \nodepart{lower} 01};
+\node[state] (sC)  [below left = 1 cm of sB] {C \nodepart{lower} 10};
+\node[state] (sD)  [above left = 1 cm of sC] {D \nodepart{lower} 11};
+\path[->]
+          (sA) edge[bend left] node {1} (sB)
+          (sB) edge[bend left] node {1} (sC)
+          (sC) edge[bend left] node {1} (sD)
+          (sD) edge[bend left] node {1} (sA)
+          (sA) edge[loop above] node {0} (sB)
+          (sB) edge[loop right] node {0} (sB)
+          (sC) edge[loop below] node {0} (sC)
+          (sD) edge[loop left] node {0} (sD)
+          ;
+\node[state] [above right  = 2cm of sB] (example) {Zustand \nodepart{lower} $y_1y_0$};
+\path[->] (example)  edge node {EN} ++(45:2cm);
+\end{tikzpicture}
+
+\begin{tikztimingtable}
+clk & 2L25{CC}\\
+rst\_n & 7L42H \\
+EN & 12H6L32H \\
+y &  8D{0}2D{1}2D{2}8D{3}2D{0}2D{1}2D{2}2D{3}2D{0}2D{1}2D{2}2D{3}2D{0}2D{1}2D{...} \\
+state &  8D{A}2D{B}2D{C}8D{D}2D{A}2D{B}2D{C}2D{D}2D{A}2D{B}2D{C}2D{D}2D{A}2D{B}2D{...} \\
+\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{Modulo 4 Vorwärts/Rückwärts Zähler mit Enable als Graph}
+
+\begin{tikzpicture}[state/.style=state with output,>=latex, auto]
+\node[state,initial] (sA)  {A \nodepart{lower} 00};
+\node[state] (sB)  [below right = 1.5 of sA] {B \nodepart{lower} 01};
+\node[state] (sC)  [below left = 1.5 cm of sB] {C \nodepart{lower} 10};
+\node[state] (sD)  [above left = 1.5 cm of sC] {D \nodepart{lower} 11};
+\path[->]
+          (sA) edge[bend left] node {EN=1, D=1} (sB)
+          (sB) edge[bend left] node {11} (sC)
+          (sC) edge[bend left] node {11} (sD)
+          (sD) edge[bend left] node {11} (sA)
+          (sB) edge[bend left] node {10} (sA)
+          (sC) edge[bend left] node {10} (sB)
+          (sD) edge[bend left] node {10} (sC)
+          (sA) edge[bend left] node {10} (sD)
+          (sA) edge[loop above] node {EN=0, D=-} (sB)
+          (sB) edge[loop right] node {0-} (sB)
+          (sC) edge[loop below] node {EN=0, D=0,1} (sC)
+          (sD) edge[loop left] node {0-} (sD)
+          ;
+\node[state] [above right  = 2cm of sB] (example) {Zustand \nodepart{lower} $y_1y_0$};
+\path[->] (example)  edge node {EN, D} ++(45:2cm);
+\end{tikzpicture}
+
+\begin{exampleblock}{Vorwärts-/Rückwärtszähler mit Enable}
+Die Schaltung hat zwei Eingänge EN und D. Wenn EN den Wert 0 hat, dann soll der Zähler stehenbleiben. Wenn EN den Wert 1 hat, dann zählt der Zähler vorwärts, wenn D den Wert 1 hat. Wenn D Null ist, dann zählt der Zähler rückwärts. Ein "-" bedeutet "don't care", d.h. der Wert ist unerheblich.
+\end{exampleblock}
+
+\end{frame}
+
+
+\begin{frame}
+\frametitle{101 Erkennung}
+
+\begin{tikztimingtable}
+clk & 2L25{CC}\\
+rst\_n & 7L42H \\
+x & 12L4H6L2H2L2H8L2H4L2H6L \\
+y & 28L2H20L  \\
+\extracode
+\begin{pgfonlayer}{background}
+\begin{scope}[semitransparent ,semithick]
+\vertlines[black]{2,4,...,48}
+\horlines{2,3,...,3}
+\end{scope}
+\end{pgfonlayer}
+\end{tikztimingtable}
+
+\begin{itemize}
+\item Am Eingang x ist ein serieller Datenstrom, der in jedem Takt den Wert ändern kann
+\item Die Schaltung soll die Folge "101" erkennen
+\item Wenn am Eingang x die Folge 101 auftritt, dann wird der Ausgang y auf den Wert 1 gesetzt
+\end{itemize}
+
+\begin{exampleblock}{101 Erkennung - Beispiel für eine Sequenzerkennungsschaltung}
+Alle bisherigen Automatengraphen beschreiben Schaltungen, die sie schon kennen. Die 101 Schaltung ist eine typische Schaltung, bei der eine Sequenz erkannt werden muss. Hier ist es nicht ganz so einfach, die Schaltung aus den bisher bekannten Schaltungstypen wie Zähler oder Schieberegister aufzubauen. Bei Sequenzerkennungsschaltungen startet man bei der Konstruktion häufig mit dem Automatengraphen.
+\end{exampleblock}
+
+\begin{exampleblock}{101 Erkennung - Feinheiten}
+\begin{itemize}
+\item Darf die letzte 1 auch schon die erste 1 einer neuen 101 Folge sein? Ist in der Folge 00010101000 die 101 zweimal oder einmal?
+\end{itemize}
+\end{exampleblock}
+
+\vspace{4cm}
+\end{frame}
+
+\begin{frame}
+\frametitle{101 Erkennung Graph}
+
+\begin{tikzpicture}[state/.style=state with output,>=latex, auto]
+\node[state,initial] (sA)  {idle \nodepart{lower} 0};
+\node[state] (sB)  [below right = 1 of sA] {e1 \nodepart{lower} 0};
+\node[state] (sC)  [below left = 1 cm of sB] {zero \nodepart{lower} 0};
+\node[state] (sD)  [above left = 1 cm of sC] {z1 \nodepart{lower} 1};
+\path[->]
+          (sA) edge[bend left] node {1} (sB)
+          (sB) edge[bend left] node {0} (sC)
+          (sC) edge[bend left] node {1} (sD)
+          (sD) edge node[pos=.3] {1} (sB)
+          (sA) edge[loop above] node {0} (sA)
+          (sB) edge[loop right] node {1} (sB)
+          (sC) edge node[pos=.3] {0} (sA)
+          (sD) edge[bend left] node {0} (sA)
+          ;
+\node[state] [above right  = 2cm 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 & 12L4H6L2H2L2H8L2H4L2H6L \\
+state & 14D{idle}4D{e1}2D{zero}4D{idle}2D{e1}2D{zero}2D{z1}8D{idle}2D{e1}2D{zero}2D{idle}2D{e1}2D{zero}2D{idle} \\
+y & 28L2H20L  \\
+\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}
+
+\subsection{Zustandskodierung}
+
+\begin{frame}
+\frametitle{Automaten}
+\center
+\Huge Wie kann man aus einem Mooregraphen eine Schaltung bauen?
+\end{frame}
+
+
+\begin{frame}
+\frametitle{101 - Zustandsfolgetabelle / Ausgangstabelle / Zustandskodierung}
+\begin{minipage}{0.3\textwidth}
+\begin{tikzpicture}[state/.style=state with output,>=latex, auto]
+\node[state,initial] (sA)  {idle \nodepart{lower} 0};
+\node[state] (sB)  [below right = 1 of sA] {e1 \nodepart{lower} 0};
+\node[state] (sC)  [below left = 1 cm of sB] {zero \nodepart{lower} 0};
+\node[state] (sD)  [above left = 1 cm of sC] {z1 \nodepart{lower} 1};
+\path[->]
+          (sA) edge[bend left] node {1} (sB)
+          (sB) edge[bend left] node {0} (sC)
+          (sC) edge[bend left] node {1} (sD)
+          (sD) edge node[pos=.3] {1} (sB)
+          (sA) edge[loop above] node {0} (sA)
+          (sB) edge[out=85,in=45,looseness=4 ] node {1} (sB)
+          (sC) edge node[pos=.3] {0} (sA)
+          (sD) edge[bend left] node {0} (sA)
+          ;
+\end{tikzpicture}
+\end{minipage}
+\begin{minipage}{0.4\textwidth}
+\begin{tabular}{cc|c}
+Eingänge & akt. ZS & Folgezustand \\\hline
+x & Name & Name \\\hline
+0 & idle & idle \\
+0 & e1 & zero \\
+0 & zero & idle \\
+0 & z1 & idle \\
+1 & idle & e1 \\
+1 & e1 & e1 \\
+1 & zero & z1 \\
+1 & z1 & e1 \\
+\end{tabular}
+\end{minipage}
+\begin{minipage}{0.25\textwidth}
+\begin{tabular}{c|c}
+akt. ZS & Ausgänge \\\hline
+Name & y \\\hline
+idle & 0 \\
+e1 & 0 \\
+zero & 0 \\
+z1 & 1 \\
+\end{tabular}
+\end{minipage}
+
+\vspace{1cm}
+\begin{tabular}{c|ccc}
+akt. ZS (symbolisch) & Binärkodierung & One-Hot Kodierung & irgendwie \\\hline
+Name & $q_1q_0$ & $q_3q_2q_1q_0$ & $q_2q_1q_0$  \\\hline
+idle &  00      &    0001        &  100 \\
+e1   &  01      &    0010        &  010 \\
+zero &  10      &    0100        &  110 \\
+z1   &  11      &    1000        &  111 \\
+\end{tabular}
+
+\end{frame}
+
+\begin{frame}
+\frametitle{Kodierte Zustandsfolge- und Ausgangstabelle (Binärkodierung)}
+\begin{tabular}{c|ccc}
+akt. ZS (symbolisch) & Binärkodierung & One-Hot Kodierung & irgendwie \\\hline
+Name & $q_1q_0$ & $q_3q_2q_1q_0$ & $q_2q_1q_0$  \\\hline
+idle &  00      &    0001        &  100 \\
+e1   &  01      &    0010        &  010 \\
+zero &  10      &    0100        &  110 \\
+z1   &  11      &    1000        &  111 \\
+\end{tabular}
+
+\vspace{0.5cm}
+
+\begin{minipage}{0.35\textwidth}
+\begin{tabular}{cc|c}
+Eing. & akt.ZS & FolgeZS \\\hline
+x & Name & Name \\\hline
+0 & idle & idle \\
+0 & e1 & zero \\
+0 & zero & idle \\
+0 & z1 & idle \\
+1 & idle & e1 \\
+1 & e1 & e1 \\
+1 & zero & z1 \\
+1 & z1 & e1 \\
+\end{tabular}
+\end{minipage}
+\begin{minipage}{0.35\textwidth}
+\begin{tabular}{cc|c}
+Eing. & akt.ZS & FolgeZS \\\hline
+x & $q_1q_0$ & $d_1d_0$ \\\hline
+0 & 00 & 00 \\
+0 & 01 & 10 \\
+0 & 10 & 00 \\
+0 & 11 & 00 \\
+1 & 00 & 01 \\
+1 & 01 & 01 \\
+1 & 10 & 11 \\
+1 & 11 & 01 \\
+\end{tabular}
+\end{minipage}
+\begin{minipage}{0.25\textwidth}
+\begin{align}
+d_1 &= \overline{x} \cdot \overline{q_1} \cdot q_0 + x \cdot q_1 \cdot \overline{q_0} \nonumber \\
+d_0 &= x \nonumber
+\end{align}
+\end{minipage}
+
+\vspace{0.5cm}
+
+\begin{minipage}{0.35\textwidth}
+\begin{tabular}{c|c}
+akt. ZS & Ausgänge \\\hline
+Name & y \\\hline
+idle & 0 \\
+e1 & 0 \\
+zero & 0 \\
+z1 & 1 \\
+\end{tabular}
+\end{minipage}
+\begin{minipage}{0.35\textwidth}
+\begin{tabular}{c|c}
+akt. ZS & Ausgänge \\\hline
+$q_1q_0$ & y \\\hline
+00 & 0 \\
+01 & 0 \\
+10 & 0 \\
+11 & 1 \\
+\end{tabular}
+\end{minipage}
+\begin{minipage}{0.25\textwidth}
+\begin{align}
+y &= q_1\cdot q_0 \nonumber
+\end{align}
+\end{minipage}
+
+\end{frame}
+
+
+\begin{frame}
+\frametitle{101 Erkennung Schaltung}
+
+\begin{tikzpicture}[circuit logic IEC, circuit ee IEC, scale = 1.3]
+% Flipflop 0
+\draw (0,0) node[shape=ff] (r0) {};
+\draw (0,2) node[shape=ff] (r1) {};
+% Clock/Reset
+\draw (r0.CLK) -- ++(left:2mm) node[contact] (c0) {} -- ++(left:5mm) node[anchor=east] {clk};
+\draw (r1.CLK) -| (c0);
+\draw (r0.R) -- ++(down:1) node[contact] (c2) {} -- ++(left:1) node[anchor=east] {rst\_n};
+\draw (r1.R) -- ++(down:0.2) -- ++(right:0.5) |- (c2) ;
+% Gatter
+\draw (r1.Q) -- node[above] {$q_1$} ++(right:1) node[and gate, anchor=input 1] (a1) {};
+\draw (r0.Q) -- node[above] {$q_0$} ++(right:0.8) |- (a1.input 2);
+\draw (a1.output) -- ++(right:1) node[anchor=west] {y};
+\draw (r0.D) -- node[above] {$d_0$} ++(left:2) node[anchor=east] {x};
+\draw (r1.D) -- node[above] {$d_1$} ++(left:1) node[or gate, anchor=output] (or0) {};
+\draw (or0.input 1) -- ++(left:1) -- ++(up:1) -- ++(left:1) node[and gate, inputs = iin, anchor=output] (and2) {};
+\draw (or0.input 2) -- ++(left:1) -- ++(down:1) -- ++(left:1) node[and gate, inputs = nni, anchor=output] (and3) {};
+\draw (and2.input 1) -- ++(left:1) node[anchor=east] {x};
+\draw (and2.input 2) -- ++(left:1) node[anchor=east] {$q_1$};
+\draw (and2.input 3) -- ++(left:1) node[anchor=east] {$q_0$};
+\draw (and3.input 1) -- ++(left:1) node[anchor=east] {x};
+\draw (and3.input 2) -- ++(left:1) node[anchor=east] {$q_1$};
+\draw (and3.input 3) -- ++(left:1) node[anchor=east] {$q_0$};
+
+
+\end{tikzpicture}
+
+\end{frame}
+
+
+
+\begin{frame}
+\frametitle{One-Hot Kodierung}
+\begin{tabular}{c|ccc}
+akt. ZS (symbolisch) & Binärkodierung & One-Hot Kodierung & irgendwie \\\hline
+Name & $q_1q_0$ & $q_3q_2q_1q_0$ & $q_2q_1q_0$  \\\hline
+idle &  00      &    0001        &  100 \\
+e1   &  01      &    0010        &  010 \\
+zero &  10      &    0100        &  110 \\
+z1   &  11      &    1000        &  111 \\
+\end{tabular}
+
+\vspace{0.1cm}
+
+\begin{minipage}{0.35\textwidth}
+\begin{tabular}{cc|c}
+Eing. & akt.ZS & FolgeZS \\\hline
+x & Name & Name \\\hline
+0 & idle & idle \\
+0 & e1 & zero \\
+0 & zero & idle \\
+0 & z1 & idle \\
+1 & idle & e1 \\
+1 & e1 & e1 \\
+1 & zero & z1 \\
+1 & z1 & e1 \\
+\end{tabular}
+\end{minipage}
+\begin{minipage}{0.35\textwidth}
+\begin{tabular}{cc|c}
+Eing. & akt.ZS & FolgeZS \\\hline
+x & $q_3q_2q_1q_0$ & $d_3d_2d_1d_0$ \\\hline
+0 & 0001 & 0001 \\
+0 & 0010 & 0100 \\
+0 & 0100 & 0001 \\
+0 & 1000 & 0001 \\
+1 & 0001 & 0010 \\
+1 & 0010 & 0010 \\
+1 & 0100 & 1000 \\
+1 & 1000 & 0010 \\
+0 & 1111 & \\
+0 & 1101 & ??? \\
+0 & 0000 & \\
+ & ... & \\
+\end{tabular}
+\end{minipage}
+\begin{minipage}{0.25\textwidth}
+Was tun mit den anderen Zuständen?
+\end{minipage}
+
+\vspace{0.1cm}
+
+\begin{minipage}{0.35\textwidth}
+\begin{tabular}{c|c}
+akt. ZS & Ausgänge \\\hline
+Name & y \\\hline
+idle & 0 \\
+e1 & 0 \\
+zero & 0 \\
+z1 & 1 \\
+\end{tabular}
+\end{minipage}
+\begin{minipage}{0.35\textwidth}
+\begin{tabular}{c|c}
+akt. ZS & Ausgänge \\\hline
+$q_3q_2q_1q_0$ & y \\\hline
+0001 & 0 \\
+0010 & 0 \\
+0100 & 0 \\
+1000 & 1 \\
+1111 & ? \\
+\end{tabular}
+\end{minipage}
+\begin{minipage}{0.25\textwidth}
+\end{minipage}
+\end{frame}
+
+\begin{frame}
+\frametitle{101 Erkennung - One-Hot Kodierung mit don't care}
+
+\begin{minipage}{0.35\textwidth}
+\begin{tabular}{cc|c}
+Eing. & akt.ZS & FolgeZS \\\hline
+x & Name & Name \\\hline
+0 & idle & idle \\
+0 & e1 & zero \\
+0 & zero & idle \\
+0 & z1 & idle \\
+1 & idle & e1 \\
+1 & e1 & e1 \\
+1 & zero & z1 \\
+1 & z1 & e1 \\
+\end{tabular}
+\end{minipage}
+\begin{minipage}{0.35\textwidth}
+\begin{tabular}{cc|c}
+Eing. & akt.ZS & FolgeZS \\\hline
+x & $q_3q_2q_1q_0$ & $d_3d_2d_1d_0$ \\\hline
+0 & 0001 & 0001 \\
+0 & 0010 & 0100 \\
+0 & 0100 & 0001 \\
+0 & 1000 & 0001 \\
+1 & 0001 & 0010 \\
+1 & 0010 & 0010 \\
+1 & 0100 & 1000 \\
+1 & 1000 & 0010 \\
+0 & 1111 & {-}\;{-}\;{-}\;{-} \\
+0 & 1101 & {-}\;{-}\;{-}\;{-} \\
+0 & 0000 & {-}\;{-}\;{-}\;{-} \\
+  & ...  & {-}\;{-}\;{-}\;{-}\\
+\end{tabular}
+\end{minipage}
+\begin{minipage}{0.25\textwidth}
+\begin{align}
+d_3 &= x \cdot q_2 \nonumber  \\
+d_2 &= \overline{x} \cdot q_1 \nonumber  \\
+d_1 &= x \cdot \overline{q_3}  \nonumber \\
+d_0 &= \overline{x} \cdot \overline{q_1}\nonumber
+\end{align}
+\end{minipage}
+
+\vspace{0.1cm}
+
+\begin{minipage}{0.35\textwidth}
+\begin{tabular}{c|c}
+akt. ZS & Ausgänge \\\hline
+Name & y \\\hline
+idle & 0 \\
+e1 & 0 \\
+zero & 0 \\
+z1 & 1 \\
+\end{tabular}
+\end{minipage}
+\begin{minipage}{0.35\textwidth}
+\begin{tabular}{c|c}
+akt. ZS & Ausgänge \\\hline
+$q_3q_2q_1q_0$ & y \\\hline
+0001 & 0 \\
+0010 & 0 \\
+0100 & 0 \\
+1000 & 1 \\
+1111 & - \\
+0000 & - \\
+... & - \\
+\end{tabular}
+\end{minipage}
+\begin{minipage}{0.25\textwidth}
+\begin{align}
+y &= q_3 \nonumber
+\end{align}
+\end{minipage}
+\end{frame}
+
+
+\begin{frame}
+\frametitle{101 Erkennung - One Hot Kodierung - Schaltung}
+\begin{circuitikz}
+\ctikzset{flipflops/scale=0.5}
+\ctikzset{logic ports/scale=0.7}
+%\ctikzset{tripoles/european not symbol=ieee circle}
+\draw (0,0) node[flipflop D, flipflop def={tu=S, nu=1}] (ff0) {};
+\draw (3.5,0) node[flipflop D, flipflop def={td=R, nd=1}] (ff1) {};
+\draw (7,0) node[flipflop D, flipflop def={td=R, nd=1}] (ff2) {};
+\draw (10.5,0) node[flipflop D, flipflop def={td=R, nd=1}] (ff3) {};
+
+\draw (ff0.pin 1) --  node[above] {d0} ++(left:0.1) node[european and port, anchor=out] (a0) {};
+\draw (a0.bin 1) node[notcirc, left] {};
+\draw (a0.in 1) node[anchor=east] {x};
+\draw (a0.bin 2) node[notcirc, left] {};
+\draw (a0.in 2) node[anchor=east] {q1};
+
+\draw (ff1.pin 1) --  node[above] {d1} ++(left:0.1) node[european and port, anchor=out] (a1) {};
+\draw (a1.in 1) node[anchor=east] {x};
+\draw (a1.bin 2) node[notcirc, left] {};
+\draw (a1.in 2) node[anchor=east] {q3};
+
+\draw (ff2.pin 1) --  node[above] {d2} ++(left:0.1) node[european and port, anchor=out] (a2) {};
+\draw (a2.bin 1) node[notcirc, left] {};
+\draw (a2.in 1) node[anchor=east] {x};
+\draw (a2.in 2) node[anchor=east] {q1};
+
+\draw (ff3.pin 1) --  node[above] {d3} ++(left:0.1) node[european and port, anchor=out] (a3) {};
+\draw (a3.in 1) node[anchor=east] {x};
+\draw (a3.in 2) node[anchor=east] {q2};
+
+\draw (ff0.pin 6) -- node[above] {q0} ++(right:0.3);
+\draw (ff1.pin 6) -- node[above] {q1} ++(right:0.3);
+\draw (ff2.pin 6) -- node[above] {q2} ++(right:0.3);
+\draw (ff3.pin 6) -- node[above] {q3} ++(right:0.5) node[anchor=west] {y};
+
+
+
+\draw (ff0.pin 3) -- ++(down:1) node[circ] (c0) {} -- ++(left:1) node[anchor=east] (clk) {clk};
+\draw (ff3.pin 3) |- (c0);
+\draw (ff1.pin 3) -- (ff1.pin 3 |- c0) node[circ] {};
+\draw (ff2.pin 3) -- (ff2.pin 3 |- c0) node[circ] {};
+
+\draw (clk.east) ++(down:0.5) node[anchor=east] (rst) {rst\_n};
+\draw (ff3.down) |- (rst.east);
+\draw (ff1.down) -- (ff1.down |- rst.east) node[circ] {};
+\draw (ff2.down) -- (ff2.down |- rst.east) node[circ] {};
+\draw (ff0.up) -- ++(up:0.2) -- ++(right:0.7) coordinate (s0) {} -- (s0 |- rst.east) node[circ] {};
+
+\end{circuitikz}
+
+\begin{exampleblock}{101 Erkennung mit One Hot Kodierung}
+Bei der One Hot Kodierung wird häufig die Schaltungstiefe der Zustandsfolgelogik und die Ausgangslogik kleiner im Vergleich zur Binärkodierung. Dafür ist die Anzahl der benötigten Flipflops größer. Für jeden Zustand wird ein Flipflop benötigt. In diesem Beispiel sind es vier Zustände, also vier Flipflops. Aber die Schaltungstiefe der Zustandsfolgelogik ist 1. Die Schaltungstiefe der Ausgangslogik is 0, denn der Ausgang y ist direkt mit dem Ausgang eines Flipflops verbunden.
+\end{exampleblock}
+
+
+\end{frame}
+
+
+\begin{frame}
+\frametitle{101 Erkennung - Zustandskodierung "irgendwie"}
+\begin{tabular}{c|ccc}
+akt. ZS (symbolisch) & Binärkodierung & One-Hot Kodierung & irgendwie \\\hline
+Name & $q_1q_0$ & $q_3q_2q_1q_0$ & $q_2q_1q_0$  \\\hline
+idle &  00      &    0001        &  100 \\
+e1   &  01      &    0010        &  010 \\
+zero &  10      &    0100        &  110 \\
+z1   &  11      &    1000        &  111 \\
+\end{tabular}
+
+\vspace{0.5cm}
+
+\begin{minipage}{0.35\textwidth}
+\begin{tabular}{cc|c}
+Eing. & akt.ZS & FolgeZS \\\hline
+x & Name & Name \\\hline
+0 & idle & idle \\
+0 & e1 & zero \\
+0 & zero & idle \\
+0 & z1 & idle \\
+1 & idle & e1 \\
+1 & e1 & e1 \\
+1 & zero & z1 \\
+1 & z1 & e1 \\
+\end{tabular}
+\end{minipage}
+\begin{minipage}{0.35\textwidth}
+\begin{tabular}{cc|c}
+Eing. & akt.ZS & FolgeZS \\\hline
+x & $q_2q_1q_0$ & $d_2d_1d_0$ \\\hline
+0 & 100 & 100 \\
+0 & 010 & 110 \\
+0 & 110 & 100 \\
+0 & 111 & 100 \\
+1 & 100 & 010 \\
+1 & 010 & 010 \\
+1 & 110 & 111 \\
+1 & 111 & 010 \\
+\end{tabular}
+\end{minipage}
+\begin{minipage}{0.25\textwidth}
+\begin{align*}
+d_2 &= \overline{x} + q_2 q_1 \overline{q_0}\\
+d_1 &= x + \overline{q_2} q_1 \overline{q_0}\\
+d_0 &= x q_2 q_1 \overline{q_0}
+\end{align*}
+\end{minipage}
+
+\vspace{0.5cm}
+
+\begin{minipage}{0.35\textwidth}
+\begin{tabular}{c|c}
+akt. ZS & Ausgänge \\\hline
+Name & y \\\hline
+idle & 0 \\
+e1 & 0 \\
+zero & 0 \\
+z1 & 1 \\
+\end{tabular}
+\end{minipage}
+\begin{minipage}{0.35\textwidth}
+\begin{tabular}{c|c}
+akt. ZS & Ausgänge \\\hline
+$q_2q_1q_0$ & y \\\hline
+100 & 0 \\
+010 & 0 \\
+110 & 0 \\
+111 & 1 \\
+\end{tabular}
+\end{minipage}
+\begin{minipage}{0.25\textwidth}
+\begin{align*}
+y &= q_0
+\end{align*}
+\end{minipage}
+\end{frame}
+
+\begin{frame}
+\frametitle{101 - Zusammenfassung}
+\begin{block}{Ein Graph - verschiedene sequentielle Schaltungen}
+Wir haben drei sehr unterschiedliche sequentielle Schaltungen gesehen, die von außen nicht unterscheidbar sind. Der Zustandsgraph mit den symbolischen Zuständen legt das Verhalten fest. Es gibt den Freiheitsgrad der Wahl der Zustandskodierung.
+\end{block}
+
+\begin{block}{Kombinatorische Logik - auch mit Wahlfreiheit}
+Abhängig von der Wahl der Zustandskodierung bekommt man unterschiedliche boolesche Funktionen für die Zustandsfolgelogik und die Ausgangslogik. Eine boolesche Funktion kann durch unendliche viele unterschiedliche Schaltungen realisiert werden. Man hat also Freiheitsgrade auf zwei Ebenen. Die Wahl der Kodierung führt zu booleschen Funktionen. Jede boolesche Funktion kann auf unterschiedliche Arten gebaut werden.
+\end{block}
+
+\begin{block}{Welche Zustandskodierung wählen?}
+Binär: Minimale Anzahl Flipflops\\
+One-Hot: Häufig eine kleine Zustandsfolgelogik\\
+Irgendwie: Beim 101 Beispiel führt es zu einem Medwedewautomaten, d.h. keine Gatter in der Ausgangslogik
+\end{block}
+
+\end{frame}
+
+\begin{frame}
+\frametitle{Flankenerkennung}
+\begin{tikztimingtable}
+clk & 2L25{CC}\\
+rst\_n & 7L42H \\
+x & 12L8H20L \\
+y & 14L2H30L \\
+state &   \\
+\extracode
+\begin{pgfonlayer}{background}
+\begin{scope}[semitransparent ,semithick]
+\vertlines[black]{2,4,...,48}
+\horlines{2,3,...,3}
+\end{scope}
+\end{pgfonlayer}
+\end{tikztimingtable}
+
+
+
+\begin{itemize}
+\item Am Eingang x ist ein serieller Datenstrom, der in jedem Takt den Wert ändern kann
+\item Bei einem Wechsel von 0 nach 1 am Eingang x soll der Ausgang y für einen Takt auf 1 gehen
+\end{itemize}
+\vspace{6cm}
+
+
+\end{frame}
+
+\begin{frame}
+\frametitle{Flankenerkennung - don't care vs safe state}
+\begin{minipage}{0.35\textwidth}
+\begin{tikzpicture}[state/.style=state with output,>=latex, auto]
+\node[state,initial] (sA)  {idle \nodepart{lower} 0};
+\node[state] (sB)  [below right = 1 of sA] {edge \nodepart{lower} 1};
+\node[state] (sC)  [below left = 1 cm of sB] {wait \nodepart{lower} 0};
+\path[->]
+          (sA) edge[bend left] node {1} (sB)
+          (sA) edge[loop above] node {0} (sA)
+          (sB) edge[bend left] node {1} (sC)
+          (sB) edge[bend left] node {0} (sA)
+          (sC) edge[bend left] node {0} (sA)
+          (sC) edge[loop below] node {1} (sC)
+          ;
+\end{tikzpicture}
+\end{minipage}
+\begin{minipage}{0.35\textwidth}
+\begin{tabular}{cc|c}
+Eing. & akt.ZS & FolgeZS \\\hline
+x & $q_1q_0$ & $d_1d_0$ \\\hline
+0 & 00 & 00 \\
+0 & 01 & 00 \\
+0 & 10 & 00 \\
+0 & 11 & ?? \\
+1 & 00 & 01 \\
+1 & 01 & 10 \\
+1 & 10 & 10 \\
+1 & 11 & ?? \\
+\end{tabular}
+\end{minipage}
+\begin{minipage}{0.25\textwidth}
+\begin{align}
+d_1 &= x \cdot (q_1 \oplus q_0) \nonumber \\
+d_0 &= x \cdot \overline {q_1 \oplus q_0}  \nonumber
+\end{align}
+
+\begin{align}
+d_1 &= x \cdot (q_1 \oplus q_0) \nonumber \\
+d_0 &= x \cdot \overline{q_1} \cdot \overline{q_0} \nonumber
+\end{align}
+\end{minipage}
+\end{frame}
+
+\begin{frame}
+\frametitle{Flankenerkennung - Schaltung}
+
+\end{frame}
+
+\begin{frame}
+\frametitle{Weihnachtsblinklicht}
+
+\begin{tikzpicture}[>=latex, auto]
+\foreach \angle in {0,30,60,...,330}
+{
+	\draw (0,0) ++(\angle:2) node[state,fill=red]  {};
+}
+;
+\foreach \angle in {0,50,100,...,310}
+{
+	\draw (0,0) ++(\angle:1) node[state,fill=green]  {};
+}
+;
+
+\draw (0,0) node[state,fill=blue] {};
+
+\end{tikzpicture}
+
+\vspace{2cm}
+
+\begin{itemize}
+\item Ein Weihnachtsblinklicht hat rote, grüne und blaue Lampen
+\item Abhängig von einem Schalter S sollen die Lampen mit verschiedenen Blinkfolgen leuchten
+\item S=0: rot $\rightarrow$  grün $\rightarrow$ blau $\rightarrow$ rot $\rightarrow$ grün ...
+\item S=1: rot $\rightarrow$ grün/blau $\rightarrow$ rot $\rightarrow$ grün/blau $\rightarrow$ rot ...
+\end{itemize}
+
+\end{frame}
+
+\begin{frame}
+\frametitle{Arbiter}
+\begin{tikztimingtable}
+clk & 2L25{CC}\\
+rst\_n & 7L42H \\
+ra & 24H6L2H16L \\
+rb & 16L16H16L \\
+ga & 8L10H2L2H2L2H6L2H14L \\
+gb & 18L2H2L2H2L6H16L \\
+state &   \\
+\extracode
+\begin{pgfonlayer}{background}
+\begin{scope}[semitransparent ,semithick]
+\vertlines[black]{2,4,...,48}
+\horlines{2,3,...,3}
+\end{scope}
+\end{pgfonlayer}
+\end{tikztimingtable}
+
+\begin{itemize}
+\item Ein Arbiter teilt eine Ressource, beispielsweise Speicher, unter mehreren Bewerbern auf
+\item In diesem Beispiel gibt es die beiden Anwärter A und B
+\item A und B signalisieren den Bedarf mit dem ra b.z.w. rb Signal
+\item Der Arbiter teilt entweder A oder B die Ressource mit den Grant Signalen ga oder gb zu
+\item Wenn beide Zugang wollen, dann wird abwechselnd zugeteilt (Round Robin Scheduling)
+\end{itemize}
+\vspace{4cm}
+\end{frame}
+
+\begin{frame}
+\frametitle{Tunnelzugang}
+
+\end{frame}
+
+\subsection{Mealyautomaten}
+\begin{frame}
+\frametitle{Mealyautomaten}
+\center
+\Huge Mealyautomaten
+\end{frame}
+
+
+\begin{frame}
+\frametitle{Automatentypen Moore / Mealy / Medwedew}
+\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[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) -- ++(left:1) node[anchor = east] (pi) {pi};
+\draw (al.east) -- ++(right:1) node[anchor = west] (po) {po};
+\draw (c1) -- ++(up:2) -| (zfl.north);
+
+%Mealy
+\draw (pi.east) ++(right:0.5) node[contact, draw=blue, fill=blue] (c2) {};
+\draw[draw=blue] (c2) -- ++(down:1.25) -| (al.south);
+
+\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 Moore: d = f(q,pi), po = f(q)
+\item \textcolor{blue}{Mealy: d = f(q,pi), po = f(q,pi)}
+\item Medwedew: d = f(q,pi), po = q
+\end{itemize}
+
+\end{frame}
+
+
+\begin{frame}[fragile]
+\frametitle{Mealy Automaten - Graph}
+
+\begin{block}{Kombinatorischer Pfad vom Eingang zu den Ausgängen}
+Weil es einen kombinatorischen Pfad von den Eingängen zu den Ausgängen gibt, können sich die Ausgänge im gleichen Takt ändern wenn sich die Eingänge ändern. Weil die Ausgänge kombinatorisch vom Zustand und von den Eingängen abhängen, werden die Ausgangswerte an die Zustandsübergangspfeile annotiert.
+\end{block}
+
+\begin{center}
+\begin{tikzpicture}[auto]
+\node[state,initial]  (idle) {idle};
+\node[state] (yes) [right= 3cm of idle ] {yes};
+
+\path[->] (idle) edge[bend left]             node {in\_i=1/y\_o=1} (yes)
+          (idle) edge[loop above] node {0/0} ()
+          (yes) edge[bend left]             node {0/0} (idle)
+          (yes) edge[loop above] node {1/0} ();
+\end{tikzpicture}
+\scalebox{1.2}{
+\begin{tikztimingtable}
+clk & 10{CC}\\
+res\_n & 2L12H \\
+in\_i & 4L2H4L8H2L\\
+state & 5D{idle}2D{yes}4D{idle}8D{yes}2D{idle}\\
+y\_o & 4L1H5L1H10L\\
+\\
+\extracode
+\begin{pgfonlayer}{background} 
+\begin{scope}[semitransparent ,semithick]
+\vertlines[black]{1,3,...,19}
+%\horlines{1,2,...,4}
+\end{scope}
+\end{pgfonlayer}
+\end{tikztimingtable}
+}%scalebox
+
+\end{center}
+
+\begin{block}{Schnell, aber möglicher \glqq Snakepath\grqq\,}
+Wie hier am Beispiel eines Flankendetektors kann im gleichen Takt am Ausgang auf eine Änderung des Eingangssignals reagiert werden. Mit einem Mooreautomaten kann der Ausgang nur im nächsten Takt geändert werden. Man verwendet Mealyautomaten nur zurückhaltend, weil es einen kombinatorischen Pfad von den Eingängen zu den Ausgängen gibt. Mehrere Automaten zusammen können einen sehr langen Pfad \glqq Snakepath\grqq\, bilden, der zu einer begrenzten Taktfrequenz führen kann.
+\end{block}
+
+\end{frame}
+
+
+
+