adding new files

Schaltlogik/doc/Hinweise-Speicher.md

+# Hinweise für den Versuch Schaltlogik
+
+## Reset-Set-Flipflop
+
+Bei der [bistabilen Kippstufe](https://de.wikipedia.org/wiki/Flipflop) (Fliflop genannt) handelt es sich um eine Klasse von elektronischen Schaltung zum Speichern von einem [Bit](https://de.wikipedia.org/wiki/Bit) über unbegrenzte Zeit. Das **Reset-Set-Flipflop (RS-FF)** ist die einfachste Schaltung aus dieser Familie. Das entsprechende Schaltsymbol ist in **Abbildung 1a** gezeigt:
+
+---
+
+<img src="../figures/Symbole-Flipflops.png" width="1000" style="zoom:100%;" />
+
+**Abbildung 1**: (Schaltsymbole des (a) RS-FF, (b) RST-FF, (c) D-FF und (d) JK-FF)
+
+---
+
+Das RS-FF besitzt zwei Eingänge S und R und zwei Ausgänge Q und $\mathrm{\overline{Q}}$. Der Zustand des Ausgangs hängt nicht nur vom Eingangszustand sondern auch vom vorherigen Zustand des Ausgangs ab. 
+
+Die Funktionstabelle für das **RS-FF** ist
+$$
+\begin{equation*}
+\begin{array}{cc|cc|l}
+ \mathrm{S} & \mathrm{R} & \mathrm{Q}_n & \mathrm{\overline{Q}}_n & \text{Aktion}\\
+\hline
+0 & 0 & \mathrm{Q}_{n-1} & \mathrm{\overline{Q}}_{n-1} & \text{Keine Änderung (speichern)}\\
+0 & 1 & 0 & 1 & \text{Setze 0}\\
+1 & 0 & 1 & 0 & \text{Setze 1}\\
+1 & 1 & 1 & 1 & \mathrm{Q = \overline{Q}} \text{ (verboten)}
+\end{array}
+\end{equation*}
+$$
+- S bezeichnet man als **Setz-Eingang (Set)** und R als **Rücksetz-Eingang (Reset)**. 
+- $\mathrm{\overline{Q}}$ ist der invertierte Zustand zu $\mathrm{Q}$. 
+- Im Zustand $\mathrm{S=1,\ R=0}$ stellt sich der Zustand $\mathrm{(Q=1,\ \overline{Q}=0)}$ ein. 
+- Im Zustand $\mathrm{S=0,\ R=1}$ stellt sich der Zustand $\mathrm{(Q=0,\ \overline{Q}=1)}$ ein. 
+- Im Ruhezustand $\mathrm{S=0,\ R=0}$ passiert nichts. Der vorherige Zustand $(\mathrm{Q}_{n-1},\ \mathrm{\overline{Q}}_{n-1})$ bleibt erhalten. 
+- Der Zustand $\mathrm{S=1,\ R=1}$ kann zwar  realisiert werden, er ist logisch jedoch nicht definiert und kann zu nicht vorhersagbaren Folgezuständen führen. Man bezeichnet diesen Zustand daher als **verboten**. 
+
+Das RS-FF kann mit Hilfe von zwei sich wechselseitig beeinflussenden NOR- oder NAND-Gattern realisiert werden. 
+
+### Realisierung durch zwei NOR-Gatter
+
+Die Realisierung des RS-FF mit Hilfe von zwei NOR-Gattern ist in **Abbildung 1a** gezeigt:
+
+---
+
+<img src="../figures/RS-FF.png" width="1000" style="zoom:100%;" />
+
+**Abbildung 1**: (Realisierung des RS-FF mit Hilfe von zwei sich gegenseitig beeinflussenden (a) NOR- oder (b) NAND-Gattern)
+
+---
+
+Die Wahrheitstabelle des **NOR-Gatters** ist 
+$$
+\begin{equation*}
+\begin{array}{cc|c}
+    \mathrm{A} &   \mathrm{B} &   \mathrm{Y = \overline{A \lor B}} \\
+    \hline
+    0 &   0 &   1 \\
+    0 &   1 &   0 \\
+    1 &   0 &   0 \\
+    1 &   1 &   0 \\
+\end{array}
+\end{equation*}
+$$
+
+Daraus lassen sich die folgenden Konfigurationen ableiten:
+
+- **Setzen:** Für $\mathrm{S=1}$ ist $\mathrm{\overline{Q}=0}$ **unabhängig davon** welcher Wert am anderen Eingang des unteren NOR-Gatters anliegt. Ist gleichzeitig $\mathrm{R=0}$ nimmt Q der Wert 1 an.  
+- **Rücksetzen:** Das gleiche gilt für $\mathrm{R=1,\ S=0}$, wofür der Zustand $(\mathrm{Q=0,\ \overline{Q}=1})$ angenommen wird.
+- **Speichern:** Für $(\mathrm{S=0,\ R=0})$ hängt der Zustand des Ausgangs von dessen vorherigem Zustand ab: Für $\mathrm{Q=0}$ ist $\mathrm{\overline{Q}}=1$ und der vorherige Zustand bleibt bestehen. Das gleiche gilt für $\mathrm{Q=1}$ wofür $\mathrm{\overline{Q}}=0$ ist, d.h. in diesem Eingangszustand gilt für den Ausgangszustand $\mathrm{Q}_{n}=\mathrm{Q}_{n-1},\ \mathrm{\overline{Q}}_{n}=\mathrm{\overline{Q}}_{n-1}$.
+- **Verbotener Zustand:** Für $(\mathrm{S=1,\ R=1})$ stellt sich der Zustand $\mathrm{Q=\overline{Q}=0}$ ein. Da es sich dabei um ein **unmögliches Ereignis** handelt gilt dieser Zustand als verboten. 
+
+### Realisierung durch zwei NAND-Gatter
+
+Die Realisierung des RS-FF mit Hilfe von zwei NAND-Gattern ist in **Abbildung 1b** gezeigt. In diesem Fall liegen die Signale am Setz- und Rücksetz-Eingang invertiert vor. Die Wahrheitstabelle für das **NAND-Gatter** hatten wir bereits [hier](https://gitlab.kit.edu/kit/etp-lehre/p1-praktikum/students/-/blob/main/Schaltlogik/doc/Hinweise-Gatter.md) eingeführt. Sie ist hier zur besseren Übersicht nochmal angegeben:
+$$
+\begin{equation*}
+\begin{array}{cc|c}
+    \mathrm{A} &   \mathrm{B} &   \mathrm{Y = \overline{A \land B}} \\
+    \hline
+    0 &   0 &   1 \\
+    0 &   1 &   1 \\
+    1 &   0 &   1 \\
+    1 &   1 &   0 \\
+\end{array}
+\end{equation*}
+$$
+Im Vergleich zur Realisierung mit zwei NOR-Gattern sind die Schlussfolgerungen leicht andere:
+
+- **Setzen:** Für $\mathrm{S=1}\ (\mathrm{\overline{S}=0})$, nimmt $\mathrm{Q}$ **unabhängig davon** welcher Wert am anderen Eingang des oberen NAND-Gatters anliegt den Wert 1 an. Ist gleichzeitig $\mathrm{R=0}\ (\mathrm{\overline{R}=1})$ nimmt $\mathrm{\overline{Q}}$ der Wert 0 an. 
+- **Rücksetzen:** Das gleiche gilt für $\mathrm{R=1,\ S=0}$, wofür der Zustand $(\mathrm{Q=0,\ \overline{Q}=1})$ angenommen wird.
+- **Speichern:** Für $(\mathrm{\overline{S}=1,\ \overline{R}=1})$ hängt der Zustand des Ausgangs von dessen vorherigem Zustand ab: Für $\mathrm{\overline{Q}=1}$ ist $\mathrm{Q}=0$ und der vorherige Zustand bleibt bestehen. Das gleiche gilt für $\mathrm{\overline{Q}=1}$ wofür $\mathrm{Q}=0$ ist, d.h. in diesem Eingangszustand gilt für den Ausgangszustand $\mathrm{Q}_{n}=\mathrm{Q}_{n-1},\ \mathrm{\overline{Q}}_{n}=\mathrm{\overline{Q}}_{n-1}$.
+- **Verbotener Zustand:** Für $(\mathrm{\overline{S}=0,\ \overline{R}=0})$ stellt sich der Zustand $\mathrm{Q=\overline{Q}=1}$ ein.
+
+Bei industriellen Anwendungen zur Systemsteuerung müssen durch den Hersteller Vorkehrungen getroffen werden, wie z.B. bei Betriebsstörungen mit dem verbotenen Zustand umgegangen werden soll. Konventionell gilt:
+
+- Beim Flipflop aus NOR-Gattern hat $\mathrm{Q=0}$ Rücksetzvorrang.
+- Beim Flipflop aus NAND-Gattern hat $\mathrm{Q=1}$ Setzvorrang. 
+
+In beiden Fällen wird durch diese Konvention ein wohldefinierter Ausgangszustand erreicht.
+
+## Taktpegelgesteuertes RS-FF 
+
+Die Schaltung für ein **taktpegelgesteuertes RS-FF (RST-FF)** ist in **Abbildung 2** gezeigt:
+
+---
+
+<img src="../figures/RST-FF.png" width="1000" style="zoom:100%;" />
+
+**Abbildung 2**: (Realisierung des RST-FF)
+
+---
+
+Darin ist das ursprüngliche RS-FF um den zusätzlichen Takteingang C, erweitert. Das Symbol C steht dabei für den englischen Begriff "clock". S und R sind jeweils über ein NAND-Gatter mit C verknüpft, so dass überhaupt nur für $\mathrm{C=1}$ der Ausgang des RS-FF beeinflusst werden kann. Das RST-FF ist damit **taktzustandsgesteuert**. Das RS-FF bezeichnet man im Gegensatz dazu als **ungetaktet**. 
+
+Das Schaltsymbol des RST-FF ist in **Abbildung 1b** gezeigt. Im Vergleich zum RS-FF besitzt es den zusätzlichen Eingang für C. Die entsprechende Funktionstabelle ist
+$$
+\begin{equation*}
+\begin{array}{ccc|cc|l}
+\mathrm{C} & \mathrm{S} & \mathrm{R} & \mathrm{Q}_{n} & \mathrm{\overline{Q}}_{n}& \text{Aktion}\\
+\hline
+0 & 0 & 0 & \mathrm{Q}_{n-1} & \mathrm{\overline{Q}}_{n-1} & \text{Kein Takt }\to\text{ keine Änderung} \\
+0 & 0 & 1 & \mathrm{Q}_{n-1} & \mathrm{\overline{Q}}_{n-1} & \text{Kein Takt }\to\text{ keine Änderung} \\
+0 & 1 & 0 & \mathrm{Q}_{n-1} & \mathrm{\overline{Q}}_{n-1} & \text{Kein Takt }\to\text{ keine Änderung} \\
+0 & 1 & 1 & \mathrm{Q}_{n-1} & \mathrm{\overline{Q}}_{n-1} & \text{Kein Takt }\to\text{ keine Änderung} \\
+1 & 0 & 0 & \mathrm{Q}_{n-1} & \mathrm{\overline{Q}}_{n-1} & \text{Keine Änderung (speichern)} \\
+1 & 0 & 1 & 0 & 1 & \text{Setze 0}\\
+1 & 1 & 0 & 1 & 0 & \text{Setze 1}\\
+1 & 1 & 1 & 1 & 1 & \mathrm{Q = \overline{Q}}\text{ (verboten)}
+\end{array}
+\end{equation*}
+$$
+Im folgenden werden wir zwei Modifikationen des RST-FF einführen, die das Problem des verbotenen Zustands umgehen: 
+
+- Das Data-Flipflop (D-FF)
+- Das Jack-Kilby-Flipflop (JK-FF), auch unter dem Namen "Jump-and-Kill-Flopflop" bekannt. 
+
+## Data-Flipflop
+
+Das **Data-Flipflop (D-FF)** erhält man, indem man den Rücksetz-Eingang des RST-FF mit dem invertierten Setz-Eingang kurzschließt, wie in **Abbildung 3** gezeigt:
+
+---
+
+<img src="../figures/D-FF.png" width="1000" style="zoom:100%;" />
+
+**Abbildung 3**: (Realisierung des D-FF)
+
+---
+
+Das entsprechende Schaltsymbol ist in **Abbildung 1b** gezeigt. Man bezeichnet in diesem Fall den Setz-Eingang mit D, für "data". 
+
+- Das D-FF setzt ein Signal für $\mathrm{C=1,\ D=1}$; 
+- für $\mathrm{C=1,\ D=0}$ wird das Signal zurückgesetzt; 
+- für $\mathrm{C=0}$ wird das Signal gespeichert. 
+
+Der verbotene Zustand $\mathrm{S=1,\,R=1}$ ebenso wie der ursprüngliche Speicherzustand des RS-FF  ($\mathrm{S=0,\,R=0}$) kommt aufgrund der Bedingung 
+$$
+\begin{equation*}
+\mathrm{R=\overline{S}}
+\end{equation*}
+$$
+nicht vor. Die entsprechende Funktionstafel ist
+$$
+\begin{equation*}
+\begin{array}{cc|cc|l}
+\mathrm{C} & \mathrm{D} & \mathrm{Q}_{n} & \mathrm{\overline{Q}}_{n}& \text{Aktion}\\
+\hline
+0 & 0 & \mathrm{Q}_{n-1} & \mathrm{\overline{Q}}_{n-1} & \text{Kein Takt }\to\text{ keine Änderung (speichern)} \\
+0 & 1 & \mathrm{Q}_{n-1} & \mathrm{\overline{Q}}_{n-1} & \text{Kein Takt }\to\text{ keine Änderung (speichern)} \\
+1 & 0 & 0 & 1 & \text{Setze 0} \\
+1 & 1 & 1 & 0 & \text{Setze 1}\\
+\end{array}
+\end{equation*}
+$$
+
+## Jack-Kilby-Flipflop
+
+Das **Jack-Kilby-Flipflop (JK-FF)** erhält man, indem man den Setz-Eingang über ein AND-Gatter mit $\mathrm{\overline{Q}}$ und den Rücksetz-Eingang ebenfalls über ein AND-Gatter mit $\mathrm{Q}$ koppelt, wie in **Abbildung 4** gezeigt:
+
+---
+
+<img src="../figures/JK-FF.png" width="1000" style="zoom:100%;" />
+
+**Abbildung 4**: (Zoom in die Realisierung des JK-FF)
+
+---
+
+Das Schaltsymbol des JK-FF ist in **Abbildung 1d** gezeigt. Der Setz-Eingang wird in diesem Fall mit J (für "jump") und der Rücksetz-Eingang mit K (für "kill") bezeichnet. Die Funktionstafel des JK-FF (einschließlich Takt) ist
+$$
+\begin{equation*}
+\begin{array}{ccc|cc|l}
+\mathrm{C} & \mathrm{J} & \mathrm{K} & \mathrm{Q}_{n} & \mathrm{\overline{Q}}_{n}& \text{Aktion}\\
+\hline
+0 & 0 & 0 & \mathrm{Q}_{n-1} & \mathrm{\overline{Q}}_{n-1} & \text{Kein Takt }\to\text{ keine Änderung (speichern)} \\
+0 & 0 & 1 & \mathrm{Q}_{n-1} & \mathrm{\overline{Q}}_{n-1} & \text{Kein Takt }\to\text{ keine Änderung (speichern)} \\
+0 & 1 & 0 & \mathrm{Q}_{n-1} & \mathrm{\overline{Q}}_{n-1} & \text{Kein Takt }\to\text{ keine Änderung (speichern)} \\
+0 & 1 & 1 & \mathrm{Q}_{n-1} & \mathrm{\overline{Q}}_{n-1} & \text{Kein Takt }\to\text{ keine Änderung (speichern)} \\
+1 & 0 & 0 & \mathrm{Q}_{n-1} & \mathrm{\overline{Q}}_{n-1} & \text{Keine Änderung (speichern)} \\
+1 & 0 & 1 & 0 & 1 & \text{Setze 0} \\
+1 & 1 & 0 & 1 & 0 & \text{Setze 1} \\
+1 & 1 & 1 & \mathrm{\overline{Q}}_{n-1} & \mathrm{Q}_{n-1} &\text{Swap state (toggle)} \\
+\end{array}
+\end{equation*}
+$$
+
+Durch die Rückkopplung des Ausgangszustands auf den Eingangszustand sind nun die Reaktion der Schaltung bei gegebenem Eingangssignal sowohl für $(\mathrm{Q=1,\,\overline{Q}=0})$, also auch für $(\mathrm{Q=0,\,\overline{Q}=1})$ zu überprüfen. Wir tun dies exemplarisch für zwei Fälle:
+
+$\mathbf{J=1,\,K=0}$
+$$
+\begin{equation*}
+\begin{split}
+&\mathrm{Q=1,\,\overline{Q}=0}: \hphantom{cccccccccc} 
+\mathrm{Q=0,\,\overline{Q}=1}:\\
+&\\
+&
+\begin{array}{lcclc}
+\mathrm{S:} & \mathrm{J\,\land\,\overline{Q}} = 0 
+& \qquad &
+\mathrm{S:} & \mathrm{J\,\land\,\overline{Q}} = 1 \\
+\mathrm{R:} & \mathrm{K\,\land\,Q} = 0 
+& \qquad &
+\mathrm{R:} & \mathrm{J\,\land\,\overline{Q}} = 0 \\
+
+\end{array} \\
+&\Rightarrow \text{Speichern} 
+\hphantom{cccccccccccc}
+\Rightarrow \text{Setze 1}
+\end{split}
+\end{equation*}
+$$
+ d.h. für $\mathrm{Q=1}$ wird der Zustand gehalten, für $\mathrm{Q=0}$ wird Q auf 1 gesetzt. 
+
+$\mathbf{J=1,\,K=1}$
+$$
+\begin{equation*}
+\begin{split}
+&\mathrm{Q=1,\,\overline{Q}=0}: \hphantom{cccccccccc} 
+\mathrm{Q=0,\,\overline{Q}=1}:\\
+&\\
+&
+\begin{array}{lcclc}
+\mathrm{S:} & \mathrm{J\,\land\,\overline{Q}} = 0 
+& \qquad &
+\mathrm{S:} & \mathrm{J\,\land\,\overline{Q}} = 1 \\
+\mathrm{R:} & \mathrm{K\,\land\,Q} = 1 
+& \qquad &
+\mathrm{R:} & \mathrm{J\,\land\,\overline{Q}} = 0 \\
+
+\end{array} \\
+&\Rightarrow \text{Setze 0} 
+\hphantom{ccccccccccccccc}
+\Rightarrow \text{Setze 1}
+\end{split}
+\end{equation*}
+$$
+d.h. der Ausgangszustand wird tatsächlich vertauscht. Man bezeichnet diesen Vorgang als **Toggle**.
+
+Da $\mathrm{Q,\,\overline{Q}}$ durch die Rückkopplung auch Einfluss auf den finalen Ausgangszustand nehmen erfolgt eine potentielle Änderung des Ausgangszustands sofort beim Auftreten von $\mathrm{C=1}$. Man bezeichnet das JK-FF daher als **taktflankengesteuert**. Gibt C ($\mathrm{\overline{C}}$) den Takt an die Schaltung weiter erfolgt die Steuerung auf die positive (negative) Flanke. 
+
+### Check
+
+- TBD
+
+### Frage:
+
+- **Welchen Zustand erhält man**, wenn man vom verbotenen Zustand des RS-FF in den Zustand $\mathrm{S=0,\ R=0}$ wechselt?
+- Wie würde eine mögliche Erweiterung der Schaltungen in **Abbildung 1a** mit Rücksetzvorrang aussehen? 
+
+# Navigation
+
+[Main](https://gitlab.kit.edu/kit/etp-lehre/p1-praktikum/students/-/tree/main/Schaltlogik)
+