Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

--- introduction_to_digital_systems:storage_elements [2021/11/15 22:57]
tfischer
+++ introduction_to_digital_systems:storage_elements [2023/12/19 02:35] (aktuell)
mexleadmin [Exercises]
@@ Zeile 1: / Zeile 1: @@
-====== 5. Storage Elements ======
+====== 5 Storage Elements ======
-In the previous chapter we have had a look onto memory devices, which store data even when no voltage is applied. This is great for longterm storage, like measurement data, pictures or music. The clock frequency of the storage element are often much lower than the internal frequency of the processor / controller. By this, the processor has to wait for the stored information due to high access time.
+In the previous chapter, we had a look at memory devices, which store data even when no voltage is applied. This is great for long-term storage, like measurement data, pictures, or music. The clock frequency of the storage element is often much lower than the internal frequency of the processor/controller. By this, the processor has to wait for the stored information due to high access time.
-Therefore an controller-internal memory is advantageous. These are often called cache. Distinct storage elements have special properties, e.g. the written data changes the logic level of a pin ('foot') of the IC directly. We will now focus onto these controller-internal, fast memory, which consist of logic gates.
+Therefore a controller-internal memory is advantageous. These are often called cache. Distinct storage elements have special properties, e.g. the written data changes the logic level of a pin ('foot') of the IC directly. We will now focus on these controller-internal, fast memory, which consists of logic gates.
-The name flip-flop stems from the fact, that the smallest logic circuit for storing data has to store binary values. Therefore, it has to show one of two stable states, and can flip into the other one by an external interaction.
+The name flip-flop stems from the fact, that the smallest logic circuit for storing data has to store binary values. Therefore, it has to show one of two stable states and can flip into the other one by an external interaction.
+A good example of the usage of complex logic circuits can be seen in (part of) the {{https://www.falstad.com/pong/vonly.html|interactive circuit for the game pong}}. In this circuit are - besides a lot of known gates - also some components called "counter" and some with inputs named $D$ or $J$ and $K$. But what are these? This shall be explained in the following sub-chapters.
 ===== 5.1 Evolution of a Flip-Flop =====
@@ Zeile 15: / Zeile 17: @@
 ==== 5.1.1 Flip-Flop as a Blackbox ====
-In order to understand the wanted storage element, we will first look onto these element based on the IPO model (input–process–output).
+To understand the wanted storage element, we will first look at these elements based on the IPO model (input–process–output).
 The process of the storage element is to store two different states. This property can be implemented via two inverting gates which are interconnected in a feedback loop. The simple setup would be with NOT gates as shown in <imgref pic01>.
@@ Zeile 22: / Zeile 24: @@
 {{url>https://www.falstad.com/circuit/circuitjs.html?hideSidebar=true&ctz=CQAgjCAMB0mQrFWAmeyAcBmAnPX7IAWAdkIDZF5IRFDMaBTAWjDACgBJcMZcM6sMTJ9qo6JU7ghIZIQE8ZcqEkRhIbAO5ThYftsWjN3XrPm9dhrcmIml183vVbMmHXpfDTUSR4MybfmISXPYiIL4WyjCq6lysvJho+om8QTSS8SCEuvrZwmlqRpkpxuFk6N5agsJ5uXCVdWZlFU7JSdXNDR2uFZlylqX9gzmtoUNjI0a+Pf68Q63TSdPlDb7jATMLrlk5a-WjG0mhm5ITwmsjKukhhwnbJQXqAEYg6NjgyO-IalnwEM8yHDgTAQVzUQjwejqAAe3EQmCI4HQhHCkGIWUUIAANgB7ADmAEsAMYAHQAzjCZGR0Qi7ucEBjZNj8cTyewgA noborder}} </well></WRAP>
-Of course this simple elements misses inputs and outputs! Therefore we have to look into these now.
+Of course, these simple elements miss inputs and outputs! Therefore we have to look into these now.
 The input of this element needs at least two inputs. Often the following two are used:
@@ Zeile 31: / Zeile 33: @@
 For the output also often two pins are shown. The pin $Q$ outputs the stored data directly. The pin $/Q$ outputs the inverted value.
-Based on this simple requirements we can create the truth table.
+Based on these simple requirements we can create the truth table.
   * When $S=0$ and $R=0$, nothing changes and the outputs stay the same: $Q(n+1)=Q(n)$, $/Q(n+1)=/Q(n)$
@@ Zeile 38: / Zeile 40: @@
   * When $S=1$ and $R=1$, it is unclear what to do.
-<WRAP> <imgcaption pic02| truth table for the RS Flip-Flop> </imgcaption> {{drawio>TTflipflop}} </WRAP>
+<WRAP> <imgcaption pic02| truth table for the RS Flip-Flop> </imgcaption> {{drawio>TTflipflop.svg}} </WRAP>
-In <imgref pic02> the last input ($S=1$, $R=1$) reaches a not defined state. This state have to be investigated more later.
+In <imgref pic02> the last input ($S=1$, $R=1$) reaches a not defined state. This state has to be investigated later.
 ==== 5.1.2 RS Flip-Flop - Open the Blackbox ====
-First, the storage device have get some inputs in order to change the stored stage. For This, a "switchable" NOT-gate is needed. Looking back to the chapter [[:introduction_to_digital_systems:boolean_algebra#convertibility_of_gates|Boolean Algebra - Convertibility of Gates]], this can be achieved by NAND gates or NOR gates. \\
+First, the storage device has got some inputs to change the stored stage. For This, a "switchable" NOT-gate is needed. Looking back to the chapter [[:introduction_to_digital_systems:boolean_algebra#convertibility_of_gates|Boolean Algebra - Convertibility of Gates]], this can be achieved by NAND gates or NOR gates. \\
 In <imgref pic03> a first approach is shown.
 <WRAP><well> <imgcaption pic03|storage device based on NAND or NOR></imgcaption> \\ {{url>https://www.falstad.com/circuit/circuitjs.html?ctz=CQAgzCAMB0mQrFWBGZBOALGATGgbABzZ54Ds6eE8kIiWtApgLSoBQA7iNqdiMqXi48+aXpA7gwg7BgKTpMqBLBSui7r3Rjlq5IXkjtnFYK1De2ReM4a1Gc1ww1rDjOuEYnS46rCjXVjqCUnIm4P4uYW72tn5GBp6hqtHeDmACaRGsyPDIDnpJpvp5vIjw2fAQsfphIXxcULQVJcIyhY5yJY3lOVUesgkDXWWsADL5eDTYcHyTDXkAZgCGADYAzgy0SuO22PDSM3vS9cvrm4jiAEaONMie4JRcJEoAsgYFIE6d+hbQ5W9hNqfSByIG-coADz46T4pFuz34EBi9gAGuIoZZOmB7OlNDDkSAAHIAQUJABEADprAAmDAAbgBLADGDFYGJwkkQUjyKjkBMJAHkAEpU2mMlmsa4yGjYnGPDDPdHQmJ4TSPYh0RwgFHINmfMCIDWfPAqvlagCauqhWE6pCRZFhggJ5qVyGxxrV9s1ih1erdpHAcNmwTtny1aLGrn2XBmGGjYhApw2W3EO2EUimMwzDRoSfOSmtYFCoYVAfSTotSqwdDwNfsCrNiktrAByQGX0+A3BLYMdQ7dW7QA noborder}} </well></WRAP>
-But how are the inputs $X_0$ and $X_1$ related to $S$ and $R$, as well as the outputs $Q$ and $/Q$ to $Y_0$ and $Y_1$? \\ In this introduction, only flip-flops based on NOR gates are discussed - but flip-flops are can also be build up with NAND gates. In <imgref pic04> such a NOR flip-flop is shown. Compared to <imgref pic03> the outputs had to be rearranged in order to have the pins sorted as shown in the logic symbol (see <imgref pic05>)
+But how are the inputs $X_0$ and $X_1$ related to $S$ and $R$, as well as the outputs $Q$ and $/Q$ to $Y_0$ and $Y_1$? \\ In this introduction, only flip-flops based on NOR gates are discussed - but flip-flops can also be built up with NAND gates. In <imgref pic04> such a NOR flip-flop is shown. Compared to <imgref pic03> the outputs had to be rearranged to have the pins sorted as shown in the logic symbol (see <imgref pic05>)
 So let's analyze how this setup works! Therefore, the circuit in <imgref pic04> has to be analyzed:
-  - Initially, $Q=0$ and the both inputs are $0$. This is due to the facts, that:
+  - Initially, $Q=0$ and the both inputs are $0$. This is due to the following facts:
       - The upper NOR gate has also two $0$s as an input a outputs consequently $/Q=1$.
       - This $1$ is also an input to the lower NOR gate.
@@ Zeile 65: / Zeile 67: @@
       - The upper NOR gate still has one input set to $1$ and consequently still generates a $0$.
   - The only way to clear $Q$ (i.e. to set $Q=0$) is by setting $R=1$
-      - This this input the lower NOR gate has a $1$ as an input and outputs $Q=0$.
+      - This input the lower NOR gate has a $1$ as an input and outputs $Q=0$.
       - By $Q=0$ the inputs of the upper NOR gate also both get $0$.
       - This results in $/Q=1$
-The only problem (or better inconsistency) appears, when setting both inputs to $1$:
+The only problem (or better inconsistency) appears when setting both inputs to $1$:
-  * By this, both NOR gates generates $0$s
+  * By this, both NOR gates generate $0$s
   * This on the one hand creates $Q=1$ and $/Q=1$, which is not consistent.
 This will get even more problematic:
-  * Both gates show typically not the exact same behaviour in respect to setting their outputs on a sub-microsecond scale to the voltage comparable with the logic $1$ or $0$.
+  * Both gates show typically not the same behavior concerning setting their outputs on a sub-microsecond scale to the voltage comparable with the logic $1$ or $0$.
   * Therefore, once one will set the flip-flop back to the initial state $S=0$ and $R=0$ both NOR gates compete to set their output to $1$. The faster one will win.
-  * This results in an arbitrary behavior.
+  * This results in arbitrary behavior.
 <WRAP><well> <imgcaption pic04|The RS Flip-Flop (based on NOR gates)></imgcaption> \\ {{url>https://www.falstad.com/circuit/circuitjs.html?ctz=CQAgzCAMB0kKxVgRgCxMgTjGAHJA7JEmGnEiHJBSChHAKYC0SSAUAO4ioogBM+vLih68cOKBz6RxvFFW58BEzr2l8kANiky5y7YsELZVSJNUyMW8wb1HZQkbtNI4EI5v28P5QQjisXN2E+S09QnygKVgAPLjB5fBENLSR8fBo+HgA5AHkAJQAdAGcAMwAbAEsAB2LygHsq1gAjOJSMQV44DHBUCVj7eK00cEwM+zyYxXUeWnV0xxAAZVYAGQcRniV4kUiSgEMyovpqUzWjNSVrQSp9w+OEU1jsES9wOA77BYBFSbBOkYgYEoIyGmRAAHofgBZTIWLTbEJWPjQfww2QyDwIrxI3goswoOF8ezYvRXDy8YkeUwqAnqKzE0LUokiUJXRmsIA noborder}} </well></WRAP>
-<WRAP> <imgcaption pic05| The RS Flip-Flop> </imgcaption> {{drawio>RSflipflop}} </WRAP>
+<WRAP> <imgcaption pic05| The RS Flip-Flop> </imgcaption> {{drawio>RSflipflop.svg}} </WRAP>
 ==== 5.1.3 D-Latch - Solving the Inconsistencies ====
-In order to solve this undefined behavior one simple solution is to have the reset input $R$ be always the negation of $S$ ((Another easy way would be to have a **dominant** input, which overrules the other one, when both inputs are $1$)). The input name is now changed to $D$, which refers to the stored data.
+To solve this undefined behavior one simple solution is to have the reset input $R$ be always the negation of $S$ ((Another easy way would be to have a **dominant** input, which overrules the other one when both inputs are $1$)). The input name is now changed to $D$, which refers to the stored data.
-This single input solution is shown in <imgref pic06>. The upper ciruit in <imgref pic06> shows a common problem: when the ciruict is not prepared correctly, the output could show an intermediate inconsistent situation. This can be seen for the switch from $D=0$ to $D=1$. For a short time the outputs are $Q=/Q=0$. A solution is to use a **buffer**  (symbol "▷"). A buffer delays the signal for a similar timespan like a NOT-gate, but without negating the signal (shown in <imgref pic06> below).
+This single input solution is shown in <imgref pic06>. The upper circuit in <imgref pic06> shows a common problem: when the circuit is not prepared correctly, the output could show an intermediate inconsistent situation. This can be seen for the switch from $D=0$ to $D=1$. For a short time, the outputs are $Q=/Q=0$. A solution is to use a **buffer**  (symbol "▷"). A buffer delays the signal for a similar timespan like a NOT-gate, but without negating the signal (shown in <imgref pic06> below).
 <WRAP><well> <imgcaption pic06|The RS Flip-Flop (based on NOR gates)></imgcaption> \\ {{url>https://www.falstad.com/circuit/circuitjs.html?ctz=CQAgzCAMB0kKxVgRgCxMgTjGAHJA7JEmGnEiHJBSChHAKYC0SSAUAO4ioogBMKOLih68AbD0gc+kQbySihIgVCm8ZXDL2mz5KzmtnLufXZP3re+LQb7Kzi6VWNyFkpHAjGkm7Rq3ktKjhWd09hPitfS38+amCAIxonUVk4DD4MKkkADxBGOQ0qRh5vCCUQABFWABkQcS4cEoUkRtjyADMAQwAbAGd6ahzwEg18cDhrSCpygEVWXLBeBEt0sEo+HC1ygHo5gFlbWUiwSBFI62hgg-5Bby0Tkp8L4P1laL5+Pz1fO4-HwNURien3e9l4IPOFki9mceDqIjhkgAkvC-qjeIjEAgXujPvUWhIpEg1A0ePjWjCSQSHNTKVQ1v5wgzvjhBMz6szJChwSBWeN-CTOVA+JcKFIOT4ORMVCiJVp6sJBFlRTjjIrUeqwZ9hFQbDrvjdwKJddqUFlVOowMa0Vbza9BPrwTxbSprsoXQ8jbqRVdDjQzeBTv7vbxLvNwEt-WM1tN1js5gsRlaEMyrQ7bCA5rUpf4FMzAiAun0BgghvlyGtBMUjeRylVEgHsAolukUHAlSEPA5Hep9QFhcFQg4XTYXf3sUSmSlhxSLQ6A3rTHOaLpjLhCeY2dbR7PN+BWmql5xD81wrQAUA noborder}} </well></WRAP>
-However, this circuit rises a "small problem": now the state can be changed, but set and reset is based on one single input. Therefore, it is not a storage device, but more a kind of a delay: when the input data changes, the output changes after a constant short timespan, too. \\ In order to solve this next problem, another input $E$ for enable is introduced (see <imgref pic07>). Only for $E=1$ changes in the stored states are possible: For $E=1$ the circuit gets **transparent**. Once $E=0$, no changes in the state can be done. \\ The given circuitry is also called **D-Latch**  with the symbol shown in <imgref pic08>.
+However, this circuit rises a "small problem": now the state can be changed, but set and reset are based on one single input. Therefore, it is not a storage device, but more a kind of a delay: when the input data changes, the output changes after a constant short timespan, too. \\ In order to solve this next problem, another input $E$ for enable is introduced (see <imgref pic07>). Only for $E=1$ changes in the stored states are possible: For $E=1$ the circuit gets **transparent**. Once $E=0$, no changes in the state can be done. \\ The given circuitry is also called **D-Latch**  with the symbol shown in <imgref pic08>.
-Generally, the term latch is used, when there is a transparent time span. Otherwise the circuit is called flip-flop.
+Generally, the term latch is used, when there is a transparent period. Otherwise, the circuit is called a flip-flop.
 <WRAP><well> <imgcaption pic07|The D Latch></imgcaption> \\ {{url>https://www.falstad.com/circuit/circuitjs.html?ctz=CQAgzCAMB0lwjFa8Cs8BsAOAnOg7LmJpgEzxgogqRUgAsEKApgLTzwBQA7iPHXSBJ4SvfoOJRugyJkF0afAUJGQpJGYIzTZJeZJ7qdw0Ur2qDGkrm2Dj5k4N0PdNVagiLN6G2W+IRlCgc7s7WhoLW-lBUHABGILLw2DQkQuDqkgAeICwoEGQCLGDeZHj0ciAAIhzZYGBKZOAoIqkCpiAAijXplGCQEBQ0fd7tAPRdALJyOtZ9SmGC0EFTujpac16Ci0EGdDMlTr76Plqtm-arm2dW3heHYZbWqgCS6dNvGwoxPGAte2-hNzUBJrPwkUG8LY0IKoGgSG68cERPxQ77ODTwJGAqSYnQYrFaeyeDa48CQAREpEkrFPKS-MkCCSfKTwiTwswsnR6eFOVTZXL5OjeIplXTYcpOACiLJSGnhGlUdFSALlstkrm2MQASirZGwShiti5NSQltEYEEdeyaPq5F8WpRTY6za4lhwAPYA6J0eCQAJIOCQRApD5VD3gfLe33+mCByDYPDoFDoEiUEN1cAgaWe8ion1+2gwYOQro5lpRgtp5DRRDjDhAA noborder}} </well></WRAP>
-<WRAP> <imgcaption pic08| Symbol and truth table of the D-Latch> </imgcaption> {{drawio>DLatch}} </WRAP>
+<WRAP> <imgcaption pic08| Symbol and truth table of the D-Latch> </imgcaption> {{drawio>DLatch.svg}} </WRAP>
 ==== 5.1.4 Edge-Triggered D Flip-Flop - One at a time ====
-In digital systems the data processing is done clocked (i.e. once in a cycle). In the sub-chapter before, the input $C$ was introduced. Once this input changes to $C=0$, the data could be used in the next logic stage. \\ Digital systems often need to be power efficient, in order to save energy and avoid overheating. A disadvantage of the D-latch is, that in the transparent phase, the signal can change often until it gets stored at the end of the phase. For every transistion, a small additional current flow is needed. Therefore, the D-latch is not as power efficient, and would also pass on the transistions to the next logic stages.
+In digital systems, the data processing is done clocked (i.e. once in a cycle). In the sub-chapter before, the input $C$ was introduced. Once this input changes to $C=0$, the data could be used in the next logic stage. \\ Digital systems often need to be power efficient, to save energy and avoid overheating. A disadvantage of the D-latch is, that in the transparent phase, the signal can change often until it gets stored at the end of the phase. For every transition, a small additional current flow is needed. Therefore, the D-latch is not as power efficient, and would also pass on the transition to the next logic stages.
-In order to change the full transparency into a single change per cycle, a circuit based on two D-latches in series can be used. In <imgref pic09> the two latches can be seen in the upper part. The first latch is enabled with the negated **clock input**  $C$. Therefore, the first latch is only transparent for $C=0$. The second latch gets the double negated clock input, which means, it is only transparent for $C=1$. The output is changed (and $D$ is stored only for the switch from $C=0$ to $C=1$. By this, the state of $D$ is only stored, when switching $C$. When the switch from $C=0$ to $C=1$ is used, then this point in time is called **positive edge**.
+To change the full transparency into a single change per cycle, a circuit based on two D-latches in series can be used. In <imgref pic09> the two latches can be seen in the upper part. The first latch is enabled with the negated **clock input**  $C$. Therefore, the first latch is only transparent for $C=0$. The second latch gets the double negated clock input, which means, it is only transparent for $C=1$. The output is changed (and $D$ is stored only for the switch from $C=0$ to $C=1$. By this, the state of $D$ is only stored, when switching $C$. When the switch from $C=0$ to $C=1$ is used, then this point in time is called **positive edge**.
 The lower part in <imgref pic09> and <imgref pic10> shows the symbol of the D flip-flop.
@@ Zeile 111: / Zeile 113: @@
 <WRAP> <imgcaption pic10| The D Flip-Flop> </imgcaption>
-{{drawio>DFF}} </WRAP>
+{{drawio>DFF.svg}} </WRAP>
-There are some important timing issues of all the flip-flops and latches, which will discussed here. For this, the timing diagram of a positive edge triggered D flip-flop is shown in <imgref pic11>. The upper line depicts the clock $C$, the middle line dhe data $D$ and the lower one the output $Q$.
+There are some important timing issues with all the flip-flops and latches, which will be discussed here. For this, the timing diagram of a positive edge triggered D flip-flop is shown in <imgref pic11>. The upper line depicts the clock $C$, the middle line the data $D$, and the lower one the output $Q$.
   - The first positive edge, shows a delay between the triggering edge on $C$ and a resulting change in $Q$. This is called the **propagation delay time** $t_{PD}$. This delay reflects the time for the flip-flop to "process" the data.
-  - At the second positive edge the data line $D$ is long enough low in order to switch the state of the flip-flop to $0$
+  - At the second positive edge the data line $D$ is long enough low to switch the state of the flip-flop to $0$
-  - At the third edge, the **setup time** $t_{su}$ and the **hold time** $t_h$ is shown. When the change of the data input $D$ is not long enough the state of the flip-flop is likely not to be changed. The data on the third edge starts too late to be high. Therefore, the output $Q$ stays 0$
+  - At the third edge, the **setup time** $t_{su}$ and the **hold time** $t_h$ is shown. When the change of the data input $D$ is not long enough the state of the flip-flop is likely not to be changed. The data on the third edge starts too late to be high. Therefore, the output $Q$ stays $0$
-  - On rhe last edge the data input is not long enough at high to change the internal state of the flip-flop.
+  - On the last edge the data input is not long enough high to change the internal state of the flip-flop.
 <WRAP> <imgcaption pic11| timing of input, clock and output on a Flip-Flop> </imgcaption>
-{{drawio>FFtiming}} </WRAP>
+{{drawio>FFtiming.svg}} </WRAP>
 ==== 5.1.5 JK Flip-Flop - The Alternative to the undefined Behavior ====
-The D flip-flop was generated based on a circuit with a series connection of two latches. Another idea could be to try a similar logic cicruit based on two RS flip-flops. This can be seen in <imgref pic12>.
+The D flip-flop was generated based on a circuit with a series connection of two latches. Another idea could be to try a similar logic circuit based on two RS flip-flops. This can be seen in <imgref pic12>.
-It looks like a valid storage device: with $R=1$ and $S=0$ a rising edge clears the stored bit $Q=0$. Respectively, with $R=0$ and $S=1$ the stored bit is set and the output is $Q=1$. However, $S=1$ and $R=1$ still creates an undefined behavior.
+It looks like a valid storage device: with $R=1$ and $S=0$ a rising edge clears the stored bit $Q=0$. Respectively, with $R=0$ and $S=1$ the stored bit is set and the output is $Q=1$. However, $S=1$ and $R=1$ still create an undefined behavior.
 <WRAP><well> <imgcaption pic12|First trial of a different edge triggered Flip-Flop ></imgcaption> \\ {{url>https://www.falstad.com/circuit/circuitjs.html?ctz=CQAgzCAMB0lwjFa8Ds8Ac6BsBOATAKzp7o5glYgGRUgAsEBApgLTzwBQA7iPHXSDyR0vfoLwDI3QcN4pKfAUJFSey3gTwyRqSqu0HFcvdPV5yB9fqPwsNG-Kgd4BCDc2GPiLTQLPXokoWZhbetH4ARiA6eJR4eCiCBCYAHiAsAS40LGCJLhBKAgDKHACyVCSCFkRBWnXQfuWaOh41GnWCDaZ0OmLxtU5qElV1suY+-jSY7byVLlphvpPRIuOzq6GCUFTSNmLwc2LWhwIHLRM8RhL2ldeD64J0NxsX4HVPK480+tP9n-D4e7TAFaYF2JxpDIKHCJHI4GQ0QogADC0nQ9jEwKOHAASvR7IC2NCFlt4HBOgQKdsYH4eGBwUZ6b1JNImcZwFgdOD9Gy-mzdPcJKsPryPvonsLEWMLOLhncJV97gqjMqPLLTmJldishyXvi9Ysdjr+R5VSStJTaVRIAMenr9M0ZtQBuLga0bTMHbdqh75hCQHY6mB4VgEo8tEiAPQARQ4aSw7A0iVD8NsiMeIFjURIMUo1EShBM+XocosdpGvC2lv8BWGfvLfsNVrodfBLdOjldevLVmkPdk7fZXZmDc7feBjkHvZ4U4HcuGP1Ww1+KFeK6DdVX935jjAXjHdP3lD3m9eJ8EW5zF4mAEkKwk6uvqQ0dnePiD-oDvi+raFMRiWTpBk+h6QJBVkP0-j9fQoI8IVFSkSEAgkSgcjiOh4SRHEOAAGTeMCWGZLYaAAMwAQwAGwAZyYWgpDw4IPkIxUfBAcjqNoykpAAeySYj6DJC0kDgOAYSwZJCG2OpKQgVFeMTVi6EEujkG2RBY3kmhFOUmARMgeQ8DIHA6FcA4uNU+wQBjDggA noborder}} </well></WRAP>
-A nice tweak is to feedback the outputs $Q$ and $/Q$ to the input AND-gate (see <imgref pic13>). This prohibits the undefined behaviour. At the beginning the output $Q$ and $/Q$ is set correctly on the rightside RS flip-flop. Therefore, the feedback of $Q$ and $/Q$ only enables one AND-gate. With this start the undefined states cannot be reached anymore. The input $R=1$ and $S=1$ creates instead a toggling output for each edge on the clock $C$. This can also be seen in the truth table in <imgref pic14>.
+A nice tweak is to feedback on the outputs $Q$ and $/Q$ to the input AND-gate (see <imgref pic13>). This prohibits undefined behavior. In the beginning, the output $Q$ and $/Q$ are set correctly on the right-side RS flip-flop. Therefore, the feedback of $Q$ and $/Q$ only enables one AND-gate. With this start, the undefined states cannot be reached anymore. The input $R=1$ and $S=1$ create instead a toggling output for each edge on the clock $C$. This can also be seen in the truth table in <imgref pic14>.
 <WRAP><well> <imgcaption pic13|edge triggered JK Flip-Flop ></imgcaption> \\ {{url>https://www.falstad.com/circuit/circuitjs.html?ctz=CQAgzCAMB0lwjFa8Ds8Ac6BsBOATAKzp7o5glYgGRUgAsEBApgLTzwBQA7iPHXSDyR0vfoLwDI3QcN4pKfAUJFSey3gTwyRqSqu0HFcvdPV5yB9fqPwsNG-Kgd4BCDc2GPiLTQLPXokoWZhbetH4ARiA6eFqxKIJ2TgAeICwBLjQsdIguEEoCAFIcALJUJIIWREFxgtB+ZZo6HtUatXj1pnQ6YrE1TmoSlXGy5j7+NJhtvBUuWogQvhPRImMzq6HgUFTSNmLws2LWhwIHzeM8RhL2FdcD64J0NxsX4HEWU2v6KHFDP7z4e7-eCA4FJKSpdIKHAJFhgHAyGgFEAAYQ4ACVHgCtGxofNBLw4HUCMTtjA-DwwEkjFSepJpLTjOAsDpwQyWeIBIzdPcJKsnsz+TR9E8hfRRhYRUM7qLHsLpLKjIqPFLTmJFUdloy1rK1mElplBdNlfifDseNR+t0XvcmtNLcN7tb7ZBTirpHa1g65ikQHZ3gisHgEhItMiAPQARQ4qSw7A0CSDCNsSKx0aiJBilGoIYIJjy9GlFmdeoJJL8BboQx9zp9+vNhdOSSrp0cIs+xc+snbq1kLaZPeNUx5g55-asCulfelQ2+vwE-2Dr0Xi+C-303McYC8bYZO8o27i673R7in2PAElHUvBOezeSdlfq6D5oDhfUG6EPMP3ZTqb1ukCXlZB9Pppn0MDQMAu4ITSAIJEoOEQzoBFkQAaQ4AAZN5phYc4CRoAAzABDAAbABnJhaCkbDggsPDr22EiKKokl9E+P553uYckjBeUeGHMRhwObidBE70RP0CStG9X8VjleS8BwEwBNWZSqFdQR1KkzSlOzXTJX8Sg+XFGg9NM+gnExEyGBGERbN4Al4CJDoSVcslOlSKsEieEl+D8vs0xjegMHoNB6AYMKBAjaMyjAdUiSeJEXOJUpwHVLBosSzKCVcjghASL84lOKlLOKAqcJ1MzAIEDCKpsnKQTDHLavyyBkPsokmosooOAAeyxM0ckgGSkDgOAYSwPNCG2YqtjRAb4yG5zRpgRB7BAaNFrM7Zhp8WBxvkJT4ToVwDjY5BtkQKMOCAA noborder}} </well></WRAP>
 <WRAP> <imgcaption pic14| Symbol and Truth Table of the edge triggered JK Flip-Flop> </imgcaption>
-{{drawio>JKFFtiming}} </WRAP>
+{{drawio>JKFFtiming.svg}} </WRAP>
 ==== 5.1.6 T Flip-Flop - changeable, when wanted ====
-For the JK flip-flop one input value toggles the output. This can also be used to creat a nuew type of flipflop. For this the $J$ and $K$ inputs are combined to a $T$ (=toggle) input. This can also be seen in the truth table in <imgref pic16>.
+For the JK flip-flop, one input value toggles the output. This can also be used to create a new type of flipflop.
+For this, the $J$ and $K$ inputs are combined to a $T$ (=toggle) input. This can also be seen in the truth table in <imgref pic16>.
 <WRAP><well> <imgcaption pic15|edge triggered T flip flop ></imgcaption> \\ {{url>https://www.falstad.com/circuit/circuitjs.html?ctz=CQAgzCAMB0lwjFa8Ds8Ac6BsBOATAKzp7o5glYgGRUgAsEBApgLTzwBQA7iPHXSDyR0vfoLwDI3QcN4pKfAUJFSey3gTwyRqSqu0HFcvdPV5yB9fqPwsNG-Kgd4BCDc2GPiLTQLPXokoWZhbetH4ARiA6eFqxKIJ2TgAeICwBLjQsYDgaEEoCACocALJUJIIWREFxgtB+ZZo6HtUatXj1pnQ6YrE1TmoSlXGy5j7+NJhtvBUuWoiMVBPRImMzq6HgUEs8NmLws2LWhwIHzeO7vXT2FRI0x6vX68MDvJRrU2v6KHFDP7z4V7-eCA4FJKSpdIKHAJbK5IQ0AogADCHAASoJToC2ND5oJeHA6gQidsYH4eGAkkZKT1JNIacZwFgdOD6czxAIGbpXhJHjQGXdXtc+fRRhZ9HQhoLhZj7tIZUYFR4JUNFbIjFJMkyNloZWswr5llyPEq8T4dlRIP1ujrXk1ptR+hKpnNLadldJ7WtHdMISA7HEcv68AkJLrMSAAPQARQ4qSw7A0CSweFytkREdjURIMUo1FDBBMLnyUosNpeBqWxfoqpNLq8+OJ5JrpySktOjmdtvLVnln1k7cZXem5e5w+5g97PEnA6lQ2+vwE-xDFxAy+XwX++i5jjAXk79P3lD3cS3h9PcU+Z4Aki8V4Ir+ayUtb6rQfNAfd6hbbNN66vKXsK5aR5dUPD6X1TFrOJullJwABk3mmFhznxRAADMAEMABsAGcmFofRPj+RdXhdJIwTlHgXTEF0DjInR6J9dhV2YpirUg6iRU+HATC4wReLdAS+KE1M8w4r50UxEQGBGGTNnmQkOmJZTSU6VJJQSa5iX4HSB0zON6Aweg0HoBgTIEJEY1KcAxGuRFCXs-FlJssA7KwSzHI85zOiEBJf1dHRKXoEBij86TRXsQEnKKaQAq8d5xWcMgIqc8gHPuJYAHsI3NOh4EgLRiRgOA4BhLBC0IbYYK2VEcsTPKCqKpBEHsEBY3qmhGsKwjkG2RBrKAA noborder}} </well></WRAP>
 <WRAP> <imgcaption pic16| Symbol and Truth Table of the edge triggered T flip flop> </imgcaption>
-{{drawio>TFFtiming}} </WRAP>
+{{drawio>TFFtiming.svg}} </WRAP>
 ===== 5.2 Convertibility of Flip-Flops =====
-The precious chapter showed different flip-flops - but which are important to understand and remember? Mainly, this are:
+The previous chapter showed different flip-flops - but which are important to understand and remember? Mainly, these are:
   * the asynchronous RS flip-flop as a base of all the other flip--flops and its use in ICs like the timer 555
   * the edge triggered D flip-flop as a simple storage device of one bit.
   * the edge triggered T flip-flop as one building block for counter and other sequential logic
-Interestinnlgy, the flip-flops can be converted into each other with the tools of the previous chapters. For this the following "recipe" will be used:
+Interestingly, the flip-flops can be converted into each other with the tools of the previous chapters. For this the following "recipe" will be used:
-  - Look onto the problem
+  - Look at the problem
   - Reduce it down to the relevant part
   - Build up a detailed truth table
-  - Look onto the relevant outputs
+  - Look at the relevant outputs
   - Fill in and use a Karnaugh map
   - Create the logic circuit
-This strategy shall now be used in order to set up a JK flip-flop based on a D flip-flop.
+This strategy shall now be used to set up a JK flip-flop based on a D flip-flop.
 ==== 5.2.1 Look onto the problem + Reduce it down to the relevant part ====
-The first step is to take a deeper look onto the problem: The idea is to emulate (or mimic) a JF flip-flop by the use of a D flip-flop and some logic circuit (see <imgref pic18>).
+The first step is to take a deeper look at the problem: The idea is to emulate (or mimic) a JF flip-flop by the use of a D flip-flop and some logic circuit (see <imgref pic18>).
 So the main thing to find is the logic circuit.
 <WRAP> <imgcaption pic18| understanding the problem: JK flip-flop based on a D flip-flop> </imgcaption>
-{{drawio>JKFFbasedonDFFanalysis2}} </WRAP>
+{{drawio>JKFFbasedonDFFanalysis2.svg}} </WRAP>
-The truttables of the two flip-flops are shown in <imgref pic17>. The relevant (and different) part here is for the rising edge. The other part is similar and does not need further investigation. Since the output $/Q$ always have to be the negation of $Q$, it is only necessary to get the output $Q$ right.
+The truth tables of the two flip-flops are shown in <imgref pic17>. The relevant (and different) part here is for the rising edge.
+The other part is similar and does not need further investigation. Since the output $/Q$ always has to be the negation of $Q$, it is only necessary to get the output $Q$ right.
 <WRAP> <imgcaption pic17| understanding the problem: JK flip-flop based on a D flip-flop> </imgcaption>
-{{drawio>JKFFbasedonDFFanalysis}} </WRAP>
+{{drawio>JKFFbasedonDFFanalysis.svg}} </WRAP>
 ==== 5.2.2 Build up a detailed truth table + look onto the relevant outputs ====
-Now, a full truthtable of the problem has to be filled. In the chapters before, only the external inputs were related to the output. In this case here, the output is also related on the former internal state. For example, the output of JK flip-flop for $J=K=0$ only depends on what the internal state was before.
+Now, a full truth table of the problem has to be filled. In the chapters before, only the external inputs were related to the output.
+In this case here, the output is also related to the former internal state. For example, the output of the JK flip-flop for $J=K=0$ only depends on what the internal state was before.
-So now we have to consider the inputs AND the internal states in order to get the output values.
+So now we have to consider the inputs AND the internal states to get the output values.
-In the <imgref pic19> the truthtable for the JK flip-flop is shown on the left site. The each second line is marked darker for better understanding. On the right site a truthtable is shown, which includes the relation to the internal state.
+In the <imgref pic19> the truth table for the JK flip-flop is shown on the left side.
+Each second line is marked darker for better understanding. On the right site, a truth table is shown, which includes the relation to the internal state.
   * For $J=0$ and $K=1$ the output have to be $Q(n+1)=Q=0$ independent from the internal state
   * For $J=1$ and $K=0$ the output have to be $Q(n+1)=Q=1$ independent from the internal state
@@ Zeile 188: / Zeile 194: @@
 <WRAP> <imgcaption pic19| Creating the truthtable for the JK flip-flop with Q(n+1) as an input> </imgcaption>
-{{drawio>JKFFbasedonDFFtruthtable}} </WRAP>
+{{drawio>JKFFbasedonDFFtruthtable.svg}} </WRAP>
-When looking onto this table, one has now to recap, what the main goal is: What does the combinatorical logic in front of the D flip-flop look like? \\
+When looking at this table, one has now to recap, what the main goal is: What does the combinatorial logic in front of the D flip-flop look like? \\
-In <imgref pic20> the circuity of <imgref pic18> is redrawn but now with the input and output variables of the wanted combinatorical logic.
+In <imgref pic20> the circuity of <imgref pic18> is redrawn but now with the input and output variables of the wanted combinatorial logic.
-Based on the truthtable of the flip-flop (<imgref pic17>) it is clear, that the D flip flop simply delays the output for one cycle.
+Based on the truth table of the flip-flop (<imgref pic17>) it is clear, that the D flip-flop simply delays the output for one cycle.
 Therefore, the input $D$ for the D flip-flop is equal to $Q(n+1)$ in <imgref pic19>
 <WRAP> <imgcaption pic20| understanding the problem: JK flip-flop based on a D flip-flop> </imgcaption>
-{{drawio>JKFFbasedonDFFlogiccircuit}} </WRAP>
+{{drawio>JKFFbasedonDFFlogiccircuit.svg}} </WRAP>
 ==== 5.2.3 Fill in and use a Karnaugh map + Create the logic circuit ====
-Based on the truthtable in <imgref pic19> a Karnaugh map can be generated. This is shown in <imgref pic21>.
+Based on the truth table in <imgref pic19> a Karnaugh map can be generated. This is shown in <imgref pic21>.
-<WRAP> <imgcaption pic21| Karnaugh Map for output D based on inputs J, K and Q(n)> </imgcaption>
+<WRAP> <imgcaption pic21| Karnaugh Map for output D based on inputs J, K, and Q(n)> </imgcaption>
-{{drawio>JKFFbasedonDFFKmap}} </WRAP>
+{{drawio>JKFFbasedonDFFKmap.svg}} </WRAP>
 The boolean formula for $D$ is therefore: $D=J\cdot\overline{Q(n)} + Q(n)\cdot \overline{K}$. \\
 With this, the logic circuit can be generated (see <imgref pic022>).
-<WRAP><well> <imgcaption pic022|Simulation of a JK Flip-Flop based on a D Flip-Flop></imgcaption> \\ {{url>https://www.falstad.com/circuit/circuitjs.html?ctz=CQAgzCAMB0l3BGeyXwExVmArGgHAGwGR4IAs2eeZeAnCNpAyGRNgKYC0CCAUAtmwMA7ARACMBMkwlQo-bGJp4QnRQzRM1S+QCUQaKarRkDRztPEGWyA9CFp7cmNl4B3FlVXqyl7fI9lEBVfJhVIXk1hFj8fP0tTAClIyGjQ4JimExYQAGlefU0tbKLVSwRrJHg7BycwaDJaSAJKRjBaKhb6FxTo0s4SuDkk3oMwDAHTNHHhvIKxiZKZixlrIqHHWqEyezBhPEVIQQQDtGxonukIBFEQYQwwSFMETTk8AH0Ed8h3siQ0d7Yb6weC0USKM7fd4Aj5gd7JK7iW4vFSPZ63Ji0T5Qv6QAFAmDIMEtAiQn4ArFw-KIm5iE6mNELOQAr4-XH44Gs6HcuEAYQAMvlZIxnrgGL5xGKKhghK4BEwyEYUQwnuJ8FYZQwFAqlbcRUi6dYmK4AJIsBB0gghdQW8KYWXuFg2q0sJUuiIefW0lXPYgBH3iCVe9URKLgP228Myag5fJhsARhNRyUYEaBC3iF0JmTux2K55J7PiJMe8WimXIsWl850mM1gxDUv5tUKmgt-2+FQvVtd1VNttIUwEe7iPuO4cYNAZiej0ylmeyK1dqvjryye7LjDztdipcGNvblQmEJt48d09tzviGP9rsx5v0-0zqdiDcGDOlsAx0r10rVmP+AQGb+P+pgqEBYjhKMEHeGIMErDkACKfBhm+67qpGpiIWgvCIsIYqcHgYREaoMwKl8XJ-EggKclCAJ-O8cLIbhkAQPhGBeFQMgliwLI4jwPwEtAXL0QCTE4WGQSTCwyzZKYApxqk4DfkMRalPJgqjIYpjSdpswKbwABGNiYmIghdrQQgRMZX6mCOwjkAYwhMBEAAeJkgLQMrZJZOQnCAADO7AAI4AK7sAAdgALgAlgAhgANgAOgFCUAPYAOYxQAxrwQA noborder}} </well></WRAP>
+<WRAP><well> <imgcaption pic022|Simulation of a JK Flip-Flop based on a D Flip-Flop></imgcaption> \\ {{url>https://www.falstad.com/circuit/circuitjs.html?ctz=CQAgzCAMB0l3BGeyXwExVmArGgHAGwGR4IAs2eeZeAnCNpAyGRNgKYC0CCAUAtmwMA7ARACMBMkwlQo-bGJp4QnRQzRM1S+QCUQaKarRkDRztPEGWyA9CFp7cmNl4B3FlVXqyl7fI9lEBVfJhVIXk1hFj8fP0tTAClIyGjQ4JimExYQAGlefU0tbKLVSwRrJHg7BycwaDJaSAJKRjBaKhb6FxTo0s4SuDkk3oMwDAHTNHHhvIKxiZKZixlrIqHHWqEyezBhPEVIQQQDtGxonukIBFEQYQwwSFMETTk8AH0Ed8h3siQ0d7Yb6weC0USKM7fd4Aj5gd7JK7iW4vFSPZ63Ji0T5Qv6QAFAmDIMEtAiQn4ArFw-KIm5iE6mNELOQAr4-XH44Gs6HcuEAYQAMvlZIxnrgGL5xGKKhgmK4BEwyEYUQwnuJ8FYZQwFAqlbcRUi6dZZbwAJIsBB0gghdQW8KYISuQI2q0sJUuiIefW0lXPYgBH3iCVe9URKLgP228Myag5fJhsARhNRyUYEaBC3iF0JmTu9yu55J7PiJMe8WijDnOli0uV8Qx2ulUuK56vXwqF5MJs0NUK7tIUxd9uqgj3cSq0sjjBoDOTscDvOz2RW9vVhdeWT3FcytdbkDLgzdideEwhbsn-1tg+n9sxwd10zN+-+2fTsSbgwZ0tgGOlBtDGsxv4BAZv4AGmCowFiOEoyQd4YiwSsOQAIp8GG74buqkamEhaC8IiwhipweBhMRqgzAqXxcn8SCApyUIAn87xwiheGQBABEYF4VAyCWLAsjiPA-AS0BcgxALMbhYZBJMLDLNkpgCnGqTgD+QxFqUCmCqMhimDJOmzIpvAAEY2JiYiCO2tBCBEJnfqYo7COQBjCJ2vAAB6mSAtAVo0XnbHWIAAMYAPYALZGQAlgAdgAhgALsFABOEUxQANgAOgAzqlwUAOYRYFvBAA noborder}} </well></WRAP>
-===== 5.3 Application of Flip-Flops =====
+===== 5.3 Applications of Flip-Flops =====
+In the previous subchapter, a flip-flop was used to substitute a different flip-flop type. Well, that is nice, but what are the real applications of flip-flops?
-==== 5.3.1 4-Bit Register based on D Flip-Flops ====
+To approach this question, first the differences between microcontrollers and microprocessors shall be discussed:
-The D flip-flop enables to create a temporal storage.
+A **microprocessor** is mainly based on the central processing unit (CPU), which processes an incoming data flow. The CPU does this using:
+  * the **control unit** (CU), which decodes incoming commands.
+  * the **arithmetic logical unit** (ALU), which executes commands. Depending on the command sometimes loading and storing relevant data is also necessary.
+  * some registers. A register is a "specialized byte", which has a major impact on controlling a program. One register is the program counter, which shows the current position (=address) in the program memory.
+The program memory and further specialized logics are not part of the microprocessor.
-<WRAP><well> <imgcaption pic050|4-Bit Register based on D Flip-Flops></imgcaption> \\ {{url>https://www.falstad.com/circuit/circuitjs.html?ctz=CQAgjCCsCmC0YAYQIHQIEwDYDMkCcA7GNgBxhiQFYEFRKQgAs2Uc5AUBQyUnpuGHQg+yZJ0gN0jXv3RVh-JAnYBZcAX7YhYTEi0gh6FJHYAlcLKkh4lxuANMET50iOTjo1Ca5RdCqHhCIkriDNIyTPrBUOyMYHggWkiYJCSJkEIpaegIjGmM7Dm0YBqJhghp+nYAmsoA7uqa2qXB7A3Y2E2Jnf7KRd1dnZVCNWCqA2VleoYGxm1MIlUirf2Mi0IZw0wg1ejja1150w5u85iQXef8Kwi0V5NZkzXY4-f6mNKThnP9SSCP6FS-yBNT6tymIAIJDsgLSULsz0K4L+BAyBiBqJGOz2vxykLxsPxSFGsQQLDyEIIuUS0NE2AA+mB6Qh6XEMPTIMy0M5CFd0JyWeh6QyGQBhAAyAGl5joDFYeHK7PUQAr0PKkII0srVVYpK4rMq9eBAQZPmqlfNwsb8k5FWIGkbzY59RaGhcNSb3XblVanV6ndqIhTWg1g-wKfzFEjaBGLirXHG7AANQ2fEQ5NIh53+Ia9eZekSbPPipjZOP6SMOJAAMwAhgAbADO0CgYhLGYMcfihjjQhrDebrbBtA7lcdiZASbGDoq-lHceUJdzldwPdk9jrTZbDGHiRSnfDtsryb27X3i33lcXUBNlcgggPVZAm8HO+jN7L-H9E6TLzdJsLW8F1JckbSQKkEQpPQGSZFk2SFAVuScXkLn5ZlWWFEV6QIdCcIZFMABoAB1G1qEDSyYCkIKgB89DwRl0PgjkuVgjDsHomCWRZRBhXpKdiNIsZpFAmihGoyhFCYIVWKYxCZNZIUYIZbisKTdABN2ciKQkyFqQ+JQmE5GTEAQljGNZTkYMwdCdF438NJeUh-kSexEFtIiAAsSIAe2rEiACEAEsABdG3YIA noborder}} </well></WRAP>
+A **microcontroller** is based on more parts:
+  * it contains the **CPU**, like the microprocessor. Often the CPU of the microprocessor is more lightweight, i.e. it takes less electrical power and is more efficient, but also has less processing power.
+  * **peripherals**: Peripherals are dedicated logic that reduced the workload of the CPU. One example is an up-counter, which can be started by the CPU and runs with a given step width to a given number. Once started the CPU no further processing by the CPU is needed. Further examples are:
+    * **digital I/O** (digital input/output): To communicate with other ICs, the data to be transmitted has to be stored, to be sent/received bit by bit.
+    * **analog I/O** (analog input/output): To analyze analog values an analog-digital-converter (ADC) digitalizes the analog values into binary numbers. The other direction is also possible with a digital-to-analog converter.
+    * **interrupt controller**: Since the peripherals sometimes still need some interaction - e.g. when the ADC just finished processing an analog value - a response is needed. Most of the peripherals use interrupts, which can abruptly stop the CPU to jump to a particular code for handling this situation. The interrupt controller is managing these breaks.
+  * **memory**: The code is commonly stored internally within the microcontroller IC. Often another storage for data is used within the IC. This memory stores the data permanently and is not based on flip-flops.
-==== 5.3.2 Shift Register based on D Flip-Flops ====
+Nowadays, the microprocessors in computers and mobile devices evolved into "Systems on a Chip" (**SoC**) which more or less combines microprocessors and microcontrollers. So the still given differences in applications are that
+  * microprocessors are used for applications with complex human-machine interfaces like high-resolution graphical user interfaces (GUIs). They also consume more power, have a broad variety of complex commands, and often are based on multiple combined CPUs ("multicore").
+  * microcontrollers are used for smaller, simpler applications. Here, the price, the low consumption, and/or the simple programming are important. Microcontrollers are used in dedicated applications, like controlling the ignition in combustion engine cars, or the motor speed of an electric toothbrush. In a mobile device often multiple microcontrollers are included.
-<WRAP><well> <imgcaption pic051|4Shift Register based on D Flip-Flops></imgcaption> \\ {{url>https://www.falstad.com/circuit/circuitjs.html?ctz=CQAgjCCsCmC0YAYQIHQIEwDYDMkCcA7GNgBxhiQFYEFRKQgAs2Uc5AUBQyUnpuGHQg+yKJ0gN0jXv3RVh-euwCy4Av2xCwmJJpBD0KSOwBK4WVJDwLjcProJHT-UZcMkqY1yg6FUPEIiSt7SMkx6QWKMYHggmkiYJCRxkEKJyegIjMmM7Jm0YOpxBgjJerYAmgjsAO5qGlpFQbVx2A2t-M35HcVxib2VYCo9evG9BkYtjCLlIl0ItNPtqWVClejDSwM8424tmJDtB52KeQsgx73pAyAV2MOXepjSu4bG3WPX6EkXP5XVH0yIAIJFs32SINslXugKQBFS+h+8LWtw2sOBQPBGKQg3Y0hY2WKcKycVBomwAH0wBSEBTohgKZAaWgnIRjugmbT0BTKZSAMIAGQA0i1tPpLDt0JZqnVJRKkIJkjKQHKwS8pbZlVIFd99OrpVNHOBdaFxZqWtqzUwjRrkC1Djrkg6rcrTbbnbblTsRITmnVffxCRzTt0g4cVUhg0wQAARACSFpeIkKJzt-qNMzafmVzp9c1OAqYGXDeijWhAADMAIYAGwAztAoHb8UXrcSoYTdJTqbT6dzOSzHGzDhyaXSebyKQQx9PKQANBAAGgAOnWqniEAScoSCCTIIJRIgqWO+4zmT2Kdyj-OwCu10MW4T90Jd7ZKIpwN2T4h++ex1fJzndA7wqDZHydIpXwuF4FUwY9ex-M9UAvK84PnbAQPuUgLjiOxECNZcAAtVwAewrVcACEAEsABc63YIA noborder}} </well></WRAP>
+But where are flip-flops used there? They are widely used in microcontrollers and microprocessors to
+  * store data,
+  * delay data,
+  * count up and down,
+  * multiply and divide by two, and more specifically double and half a frequency.
-==== 5.3.3  Frequency Divider based on T Flip-Flops ====
+In combination with [combinatorial logic], even more, complex structures are possible: Virtually all possible outputs with or without an external trigger can be created.
+This will be looked at in detail in the following chapter [[sequential logic]].
-<imgcaption pic052|Asynchronous Shift Register based on T Flip-Flops></imgcaption> \\ {{url>https://www.falstad.com/circuit/circuitjs.html?ctz=CQAgjCCsCmC0YAYQIHQIOwBZ0LOyCCAzIpkQEyRRJVlRxhgBQA7uOgGzgCc5I5CABw8+CVvyEiJw8uUzJxAmXP6Yks+WLZEOy+WvUqtIHcLC8Tu-kfFEdU01LEBZaeHJmLYD-34pITABKIIKG+nrgvoiEMYR+VOT+yMj+4hyQXOZ8up6i4pA+GlAcYQpsBblQhTZsmNyZFhVOTJjmJgIg6VxEBZ0ZEpjCmEwC6G7eMmruQyAAmsZK0+MWxo4TlpVioxtLBrtzzK5rPj1863yJAeU+601ZCtt3PhlI6-Kz5EyuT8KQ3ksXVJsHJLEH3LYYTqCMw+dAdN5zIhfKEw4QcOEA+IjSEUJBdfjQvpcd4Qsa4kD4C6Eykgd5I7bkuHqakdd6fBkdEEeNGE97MNREWnCIgIeQ4eSnZLoAD6YGlCGlrUQ0sg8rQMW4nAylHl0vI0plRGlAGEADIAaRaxCFO3FtIoyTARrlCqVCtVqFimq6OoV+qd0qN8ytgsG9r4drqXFeHFlurdKrVXq1HF9etlsaD-OtYajFNFxSQr24cddjHdapd6fMgelHxDNpe+fkqc01lLivLic9GpTaf1slrsyR5kFoSkeAaogUppCxey8nuZxAADMAIYAGwAztAoApR6p5yZ7OCZ4epEUl5F19vd1QxLO9vciIJFxZlzed3uxAenxY86eD6FlIkCYG+FzXpuX73kwB5Nvc+KAUwL7uCYkTREgAA6AAWmFbgA9iueEAEIAJYAC5bkwQA noborder}}
+Here, the above-mentioned simpler applications will be investigated.
+==== 5.3.1 Data Register ====
+A data register can store data based on one or more bits for a distinct time within the microprocessor or microcontroller.
+Usually, the data is stored for multiple clock cycles.
+The <imgref pic050> shows a 4-bit data register based on parallel D flip-flops. It can hold the data for one clock cycle.
+In the shown logic the flip-flops are clocked synchronously: they change their states at the same time based on the clock as a trigger.
+In the simulation, the inputs $X0$...$X3$ can be changed by clicking on the binary numbers below the flip-flops.
+To store the data for a longer time, an additional input (e.g. an ENable pin) could deactivate the clock input, when the data has to be stored.
+Data registers are used to hold the input and output data of the CPU and peripherals.
+<panel type="info" title="Exercise 5.3.1.1 Data Register"> <WRAP group><WRAP column 2%>{{fa>pencil?32}}</WRAP><WRAP column 92%>
+Investigate the simulation in <imgref pic050> by toggling the inputs via click on the input value.
+  * Does the flip-flop act on a rising or falling edge?
+  * The given circuit can only store the data for a maximum of one step. An idea could be to implement another input $EN$ as an enable pin. \\ How is this to be connected with the other inputs ($CLK$, $X0$, $X1$, $X2$, $X3$) to facilitate an enable pin?
+</WRAP></WRAP></panel>
+<WRAP><well> <imgcaption pic050|4-Bit Register based on D Flip-Flops></imgcaption> \\ {{url>https://www.falstad.com/circuit/circuitjs.html?ctz=CQAgjCCsCmC0YAYQIHQIEwDYDMkCcA7GNgBxhiQFYEFRKQgAs2Uc5AUBQyUnpuGHQg+yKJ0gN0jXv3RVh-JAnYBZcAX7YhYTEi0gh6FJHYAlcLKkh4lxuANMET50iOTjo1Ca5RdCqHhCIvTiDNIyTPrByOyMYHjW5EKQ6CTWPFCpBgiMaYzs6Ai0YBog+oVp+nYAmsoA7uqa2qXB7A3Y2E1lnf7KhbQdXZ2VQjVgqt1DhWWGBsZtTCJVIq39i10pI0wg1egTjEujGeVzJg2YkF0X-KtFINcz9yRbNdgTD-qY0o+G82vwgkyaXgjDsm22tQKdwBQkwVhBdjhdleUNoMICQgRGIhe3+SV8SCxlyQY1iCBYuRmSAIOTKJDsegA+mBGQhGXEMIzIKy0M5CNd0Nz4Iz0IzsGLGQBhAAyAGkFjoDFYMugrPUQCrlUhBGl1Zq7FJXGqFobwFlTaqGQtwma8k4lVaGharDbLTEGsTbQSHe7HEawX43XqIpTWg1Q-xKYLFKimGloxrXJdtgANdWmkQVXrW+1LTBpMPekTg1rSuMGZPlZPaEAAMwAhgAbADO0CgMTLWYT8UM1dEDZbbYYfTuXer3wTdhT4ydCALsjnFZjZeGS7KKTXQiQA9b7ZHA3za9dyane3ah7z8eTyjL4ITkEBCZrO6HMTWd+TnsnIBTbw9WWLc1rzJCk7WpWlQV1bpmVZdlEFFblUBcflLkFRlhUYMVxXFAhYNw8U0wAGgAHWbSFpFAphKRpMFAT0PAYLZDlRSQ5wNHQPBsDwRhIGwQREJQFkMLFBjxUQWDxIIsASLI8YKPLB8hBoqBShJUUWSY+CeRcdjOO43j+J5ISWUwxhRTE8U2WICUU3QGTdhAhTSmUr4lCYbkNLgzkBOM9l2W5MTMAkoKCOwey3gAD0SDdBWBSBXEwCADTsABJAA7AAHABXAAXZtSNgWAAD52Ci+BKDKBJYGwWgzO2KwAHlcuyvKCuK2N0VIOwsS61NxjxQE4n4LEhtTXFoXxSDElBKi8h-N4BqEXBMTAGbltTZQ4iq-F1tgY4YpyPJSsScgZloTRsBJAxUsy3LSIANybLLoGOgE0niiAwHeiDrpAJqcpah6npe0h7hAAAxCAWE+5xEhAYiAAtSIAe1rUiACEAEs8vYIA noborder}} </well></WRAP>
+==== 5.3.2 Shift Register ====
+Another register is the shift register. This moves stored data (e.g. a byte like a=86=''0b0101 0110'') to the left (''0b0010 1011''=43) or to the right (''0b1010 1100''=172). This is used in the CPU to execute the shift C-commands like ''%%unsigned int a=b>>2%%'' or ''%%unsigned int a=c<<3%%''. Additionally, it enables multiplying or dividing by 2 and is also used with the full adder in multiplication algorithms. Furthermore, a shift register can be used for a bit-by-bit output of an 8-bit (or larger) value in communication.
+The <imgref pic051> shows a 4-bit shift register based on D flip-flops. In contrast to <imgref pic050> here the flip-flops are connected in serial. Therefore, the output of one flip-flop is the input of the next one and will be stored in the next clock cycle.
+<panel type="info" title="Exercise 5.3.2.1 Shift Register"> <WRAP group><WRAP column 2%>{{fa>pencil?32}}</WRAP><WRAP column 92%>
+  - Investigate the simulation in <imgref pic051> by toggling the input via click on the input values.
+  - What happens when one deletes the input pin and connects the rightmost $/Q$ output to the input?
+</WRAP></WRAP></panel>
+<WRAP><well> <imgcaption pic051|4Shift Register based on D Flip-Flops></imgcaption> \\ {{url>https://www.falstad.com/circuit/circuitjs.html?ctz=CQAgjCCsCmC0YAYQIHQIEwDYDMkCcA7GNgBxhiQFYEFRKQgAs2Uc5AUBQyUnpuGHQg+yZJ0gN0jXv3RVh-JAnYBZcAX7YhYTEi0gh6FJHYAlcLKkh4lxuAN0ET5weOuGS4+IaRdCqHhCIkreTE7+zEGKYoxgeNYikILWmHZJhgiMJEzs6Ai0YBog+nnZ+nYAmsoA7ur8qXX+ynm02NiaQu1lQpVgqsXtxZ15Qw5GJi1MIvqQ6N1MIBXo-YzTPTyjhl6TmL6jmCTzldj9ux0gqXqG7rn5Cfzp1oLZj5XNd7AiutnwcxcI2WOt1onweRV+LyKlWWk1BUEYdgh8LsvXY0hYWSGSAImWKJDsegA+mBCQhCbEMITIKS0M5CGd0NSyehCdhWYSAMIAGQA0uxajoDFYNugrDUQCLhUhnmJapK7FIkKKCfyDNJwH9FUKVbVpNK-nrtbK1UqrIblcbfPqXn4LeLzVYrUbxRsRJjgqr3fxMYzFMCmNlfRKlXs7AARACSqq1IkK-A9uvC00GCagfjdIg9XIDBj2JT22hAADMAIYAGwAztAoDEEBjAZicWlkrxiaTyYgWUyUCTmYS8OyKn10TnHk2oEVpSTex3Kd2ZyzyIPliPMZR+OPLqJiG2yRSuzSF8S2WyKidV4DwuOEdlsbvZ4uyahnAh6b5Ge3GISCOzsE-WWSp4IAANAAOhWkbsAAHk8pAGJgQiwD6uwLFYEYAHYAA4AK4AC7gbAsAAHzQbBZQ-GaEAKnYADy2E4bhFYEcRnAIY0DSlBcCogAAJtApbYWWuGwGW0A8fYSjIGgfQAOZGhxUqiOKcZcY0+jKAATgYAKqRaDTSk47BaV0qmkHY+ngIZtRtPUdg2aMyhyWZpn4sGSmsZ0gwNCZHG8fxJaCcJoniRAknPn01leXZKZ+lpszZA0kAIqpBn2l8KJrGIclJeZaTJRsIQ6D06VQH8vl8QJQkiWJElKdJnolas8axRchyqZuBKWeKZyqT16nsHJHUgOOBViEVFx7A0BwJdxFUBVVwW1Z4CARRNtlrU07BwZo9iIOEoEABbgQA9kW4EAEIAJaMewQA noborder}} </well></WRAP>
+One application for a shift register is a "short-term memory": In <imgref pic051a> the shift register stores the last 4 states of an incoming input bit stream. The logic circuit after the shift register compares the stored data with a given input $X3$...$X0$. Once the exact bit sequence is detected the output switches to $Y=1$.
+<WRAP><well> <imgcaption pic051a|4Shift Register in a Binary Sequence Detector></imgcaption> \\ {{url>https://www.falstad.com/circuit/circuitjs.html?ctz=CQAgzCCsCmC0CMAGEiB0SAsAmSGBsAnIpPABwEXyRTLUYQwLwBQV1pyBeI88WIXFClaRqWDJ25YA7P0G1mAWR7TuYfvDzJ1IfllSRmAJShTxujLvPxdPRPYf3dB59WRpDbU5KgE53BS8JH3p-IURmAHcVNQ1VAQDmCQYpDhBpPnAMS20AfXhcxFyMJCxcyELURwJVSDwcQtyysFyWgGEAGQBpKNMrSzSscwjowfM0vlJhUeQhy3FZ4d6FniwplbnpkGDVqZ3NkYtFy32l6LrkSe9+rdPLC5vDtMFYOoThLERpEFfuF7erpYACIASWWEne8Hi8l6O0EYDAf0S5y07wwghhyT6iOQGX4Eiml2k+UaJUQZQqaGqtXqlKa+WJLVBvShsRiP0wwjIUwQiAGyFgshAaQg5k+iDwSDwzE+3zem3lTksnR6so5fOFAvgiM12xAKpE80QPME4hN3Bs-GohhBFnNujSsHkNEcUBlXx+Qtgjoh3uQlgAGmBmB1PfxYDpvTydBoQAAzACGABsAM7QKAfD2C8N4SywX25vUBrAhsM-DA80g8iu2GyJ1Pptzu77Z8vVgU1wMsUOt2CFqM-Qv8ZD1tMZiI9r2Oqs-QY8ePJsdNtW9yO+nSBw7wPyzqbTwnLY3qyys49bRGVqYI7gDw5gSDhoWOoURW0E2f+31pWiOQK4cB4JW-pHn685Wm60TXuA-BQbevRQToUEwsoCEwZ80G2PohjKHgbw6Lm2h6K4vS4WypHvIc5H4W8vxcv+gHVlMsiMWBQg2ukaxtukqL5oSLoOBBIB4F6EI+u4JEzrR5G0YcD48kK6I3i+vQkOGbyOm8r6mDyhZaAKhY-q6nj-nJg73IBZmsdasLwviLzKdEikYU5yHbLZ2wikRWEiLiPEzhwAozjYOSCaoHZMTxDncYFyB6R+WxhT8gjZAKMKOb6yVfuJ0SJby8yOpyhxrFqGrFUliTKKQ5gDqQNEznoBhJIgECduYeIee4Ql4CSRRkhSlQFEUBQAJoSe2QkidlUCcbRqk-Jp8EWa296PsOh6XjwO5wdEcWgbtBnNrqA41sdIBBodGncCdbxdhdHb+uNm53WWJ0KWdJYAEYCOAe4ShYiRfX2eZXLAWAQE6wiA5owE-Oh8D4MIAAeHL3hykrpCjwUWCAH0AJYAC4ADopmmACOACu0AAHYAMbQMThOE1T+MAPbE0mLMswA1sTcYswATswyMILV4A2Ag1BgCc2O41TAAO5NEymeNKym+P89ACYALbE0LHIYXwBDgHQ2MpgAFrjcZKxrADmuNq9AgtfUbCBYEbHA3kbETIyQHL0Co4bw-62M0yzWtywm-MJqzgtqlVeb+dVvD4iAo2jNV-lOHBQA noborder}} </well></WRAP>
+==== 5.3.3 Frequency Divider ====
+For some applications, only a fraction of the internal clock cycle is necessary. For example, external memory can usually only work with much slower frequencies compared to the CPU. To get a fraction of a given clock frequency a frequency divider can be used.
+In <imgref pic052> a 4bit frequency divider based on 4 T flip-flops is shown. Each output of the previous flip-flop is the clock input for the next one. The leftmost flip-flop toggles its output for each rising edge from $0$ to $1$. This expands the $1$ state to the time between two rising edges, similarly with the $0$ state. By this, the time between rising edges is doubled and the frequency is halved.
+In contrast to the other two examples, here the flip-flops are clocked asynchronously, i.e. each flip-flop can only start its process when the previous flip-flop finished outputting its result $Q$. This adds up the delay given by the propagation delay time $t_{PD}$ step by step. In the <imgref pic052> this can be seen when pushing the ''Reset'' button: the rising edge of all flip-flops are not at the same time, but delayed by multiples of $0.5ns$. For slower applications, this is might be neglectable, but when multiple flip-flops are used asynchronously the delay will add up and can result in problematic retardation.
+When looking at the decimal output in <imgref pic052> it seems, that it mostly represents a down-counter. But in detail, every second step down and even more every 4th step down (e.g. from ''8'' to ''7'') a glitch shows a wrong value shortly. This is due to the above-mentioned delay by the asynchronous flip-flops.
+<panel type="info" title="Exercise 5.3.3.1 Frequency Divider"> <WRAP group><WRAP column 2%>{{fa>pencil?32}}</WRAP><WRAP column 92%>
+Investigate the simulation in <imgref pic052>.
+  - Have a look at what series the decimal number in the simulation proceeds.
+  - Change the simulation in the following way:
+    - double click on $CLK$ to edit the component and change the frequency to $10~\rm MHz$
+    - increase the ''simulation speed'' with the slider on the right side
+    - how does the series of the decimal output change? Does this solve the problem?
+</WRAP></WRAP></panel>
+<WRAP><well><imgcaption pic052|Asynchronous Shift Register based on T Flip-Flops></imgcaption> \\ {{url>https://www.falstad.com/circuit/circuitjs.html?ctz=CQAgjCCsCmC0YAYQIHQIOwBZ0LOyCCAzIpkQEyRRJVlRxhgBQA7uOgGzgCc5I5CABw8+CVvyEiJw8uUzJxAmXP6Yks+WLZEOy+WvUqtIHcLC8Tu-kfFEdU01LEBZaeHJmLYD-34pITABKIIKG+nrgvoiEMYR+VOT+yMj+4hyQXOZ8up6i4pA+GlAcYQpsBblQhTZsmNyZFhVOTJjmILAUIK1cSN0SmMKYTALobt4yau6DIACaxkpTYxbGjuOWlWIj64sGO7PMrqs+RAWLfIkB5T5rTVkKW7c+GUhr8jPkTK6PwpDeZ-FpQRmHw5ZpbUFrdACPYzIifEAQkFQ-4XYYYdqdPqwDj6MBcN6bdEdPi-PjY+SkrqzOFbYldULtHH03qzD60zEDRn6TlvZhqIjgP5EBDydD2E6iEDoAD6YGlCGlrUQ0sg8rQMW4nAylHl0vI0plRGlAGEADIAaRaxEFfEcYvxnReRrlCqVCtVqFimvSHB1Cv1YCNRrmVoFjD4ZD49q69WSeNlurdKrVXq1vo9etlHGlwb51vDMa40eece4CddjHdapdmfMOel71DNuKSGjvs01nLisryc9GrTfszsnrsKY5gFDLueAakrEppCLwsTLufAgADMAIYAGwAztAoApx6pF7b7HcaEx53IT9Z5CvIpvd-uqHOunE7kRBHeLKuQI+9weYhHrsdx1DOySviWdyQJg37nA+24AS+Y7cAKUFLhkThQEwn7uCYkTREgAA6AAWRE7gA9mu5EAEIAJYAC47kwQA noborder}}</well></WRAP>
+The T flip-flop can be emulated with the D flip-flops, by the feedback of $/Q$ to the own input. So, for each next clock cycle, the negated value will be used and therefore the value will toggle.
+Since the flip-flops are still asynchronously driven (i.e. the clock input is still not triggered with a similar signal) the problems of these frequency dividers as a down-counter stills remain the same.
+<WRAP><well><imgcaption pic052|Asynchronous Shift Register based on D Flip-Flops></imgcaption> \\ {{url>https://www.falstad.com/circuit/circuitjs.html?ctz=CQAgjCCsCmC0YAYQIHQIOwBZ0LOyCCAzIpkQEyRRJVlRxhgBQYkVAHEmAJznhh8efJAiYB3cOgBsISjKGzIM0RIVzwvcFJHiNg7SE5adEo2ANnNKyfM3lymPcl33Hah7I-XXnxw6Q+1kTsfh6YhL7OEsFumjGRQUS2fPEK3uHGshlpukSQ+gHZBkH5ijJ5BVEgREll1aXqoqxU-k7k6IJWzgCykQLssggD-bKyKJBMAEqGAWEDPhCChMvLYy3jyMjjLGxQBgqQmmlVUkp1Uh111hd86jeZ15fmNPvFukpcBh9O12cKOLFhO9MKFHN9AsDAVAQQldJhuMloVDrOFPkhUT93gJMhjnlVINj1ATKiiEXViVcdrQIgoyJ1hM5MDxquQkKdyqV2YNMANMExWeg+uR5n9hSBHABNbweEYLKy5ELgMWpeUC6qKkZM+RiyXMXqpZVSYZi27bCSQGEjC3I-kYJFKgaQaQO8UgCXkJi9a0u-LG+ZrXQAl1BnJqkNi9C1TVuoiekDhgZGv2jcjbNUUNlnYWJs6S0Tp1nxhrsAb4PiS2MFpAdAIl+OFyUeqsgJOyOut3VMcJEcUDIgIRxBiqbPAAfTAo4Qo6ZiFHkEnaGW3GkSkok9H5HH6FHRFHAGEADIAaS7xF71SN8YH4oomxq4-XM6n89QK2X7LXU83993UtPPZ5G8+CDeFlAvB8pyfOcFzfFcpE-DcdykHdRwlZhu3PUCrzBYpqm4CDp0YZ8FwnL8d3w38PQwwDviDeDHHRTdSMI2cX0XQh31XF9EMwb9UNjYIWWqcBwFWAAdAALMSAGcAHsADMZIAIQASwAF2kpggA noborder}}</well></WRAP>
+==== 5.3.4 Up-Counter ====
+Counters have multiple applications. One nice application is to get non-binary base fractions from frequencies and more particularly: get a choosable fraction from a frequency.
+To do so one has to combine the following components (see <imgref pic052>):
+  * an up-counter, which outputs an increasing binary number. This can additionally have a pin to reset the internal state asynchronously.
+  * a given maximum number in binary, here given by $B$.
+  * a comparator, which only outputs a $1$ when the inputs $A0$...$A3$ are bit by bit equal to $B0$...$B3$. The output of the comparator is set as an input of the up-counter.
+  * a toggle flip-flop that only toggles on the rising edge.
+In <imgref pic052> also the decimal representation of $A$ and $B$ is shown to visualize the process and output.
+Additionally, also the input $CLK$ and output $Y$ are depicted in a timing diagram.
+<panel type="info" title="Exercise 5.3.4.1 Up-Counter"> <WRAP group><WRAP column 2%>{{fa>pencil?32}}</WRAP><WRAP column 92%>
+Investigate the simulation in <imgref pic053>. \\
+How does the output $Y$ change, when one changes the input pins given by $B$? \\
+Look for the $Y$ in the timing diagram.
+</WRAP></WRAP></panel>
+<WRAP><well><imgcaption pic053|Variable Frequency Divider></imgcaption> \\ {{url>https://www.falstad.com/circuit/circuitjs.html?ctz=CQAgzCCMCmC0AcIAMA6ATGpB2bl6QFYA2JInAFiJAKWpHIgLkkgChMsR4w1wsr8VMPHL0QAITDtsXYnwHlaw0aPFppnAJxJRYfl3iJlY8Ug0Gl++EV0iTbADJce8570W1ekEADMAhgA2AM7QdGYoIACqAA4AwgD2AK4AdgAu0ABO5ABGAJapyCDuIFSxDgDSUFW8AIqehRA13lTejbyIvI0QmuC9AEoAogDKUN60tACCyQAmAOJ+6QMBALYAOkFo62Dr5KsZU3ML0EtrQUQ76wR7B-OLK+vwl+tYew7xAOa5AMYA8omp0X+J3Wmwyb0+v3+gNSwLOrw+3z+AKB9yCmnhEKR0NhjwyABUAGIBXLRInxaKw7YbdaQJA0mmQDHfACSyWxqO2+KJJLJFNRuzhQUgmyFDL2hOJpIC5NhVyCjyFVMZQsZXMlvNhLzRNIFypYUFWIMNQTpT1FRvWpqCcsZFpNxrlmxBKEdxrQLrt7tdzu99up9PW-mC0Adxrp-r9TsjYdY5FpICwYCoNgT5FEKe8MQSKXSWTyBWVIvDBAN1L9JcLlsuRR9NY2LrrXsbDaLdeVQZCZs81ZFJaLrAAhCBptB-IkAgVJkgADTrCaQWdBCZoRcTMCL0wbhfrNQbxogBLLaJ+DILeIZZBIK-XukAR0ZyWvtKvjPvq0fSGfn7vD5fz5Yqxvo+X7PoBv60hBn5ge+n7-rS0HASwsGvg+IHXghcEvhh36QdhLAQSh75IbBV4YQREFkeRP5EfhtEIQA-IxTGMYBdLJNIiCaJgJSiJoJA8YUI5jhOyCsE48ByHoAhyB4RRVB2oQlmYTjaLo+iqfQV5ybQClhGJFiuIYtCyV4viBCEekAO5QJ+yaiBBVBoKIZjWQ5RSiPwHTOaw1mee5CZEEYvBmH0CZJiAfElPAtCRd47Q3lpTZNuMLo+W4AlcbQKYuRF3GRdwvCRTlBVQGgnHccKiDFS4kD8ZlUD8TlGlSRFOhQFxonWRpkAdfVPXBWlRmGdFRROZ1BkYLx3GTeN9VoHIEmOXIxVyPN0lCPo1WdFYLhlVVg27YYuWeEdZhxj0tJHf1pXkIg12YLd9Cxj1NlHXIwqPatOiIOQ5iXXdHW0lgvCYMZEhmBwr0dGNQMgy4qhsJD-1FO92AgymqjqEjSBHXtNnA0UkWqFI2NXQQXhow1YNrn9ON3RVlOVWIy6029LSUxjIATBDMglSmJVHaI3PmCV+U1dxohzojvPi4gJWEMULOQ-L-Hy3YQtSD1EDCkTd1gOT9BVdQaVuTDTleeNH1y7QOsCOM+m24bpUE49pm6Upf1gB1j2QHGVCPaIACasZINrpC6GVUBJkYdg22AAD6kDx0g8dxrS8cEMnKBJ7ASdoInCcJ2U5Qh2HKZe140f0Mt9AJ0nKdpynmeoDneep4X8fB655tcDbPdjWY2QJsKXBcEQIOh6JAAew+cLAGBcGgPS5z0ohjYkcRJGkmSsEPfU25+uhID0Zgz9oiDzxTYCiCvYhjYex6nqk56sDPQMX2g3jCiPuc-f5ABquQgiJECLkAAXgsXI8R2JvyXhfPAUd4Bz0IHfUQeIPjvGJMkd4r9e7uGvhFA2DBOBr1UOsAAFMsPwU91j-0CIkaAABKXBLBFBFFqqMCS7DV7gCoOIQCLDIAEKwBdSAIjF5iHChMARpM5Z3UpkTEAUtWBAA noborder}}</well></WRAP>
+So the application is nice, but what does the counter internally look like? How can this counter be generated synchronously with flip-flops?
+For this, a 4bit up-counter based on T flip-flops shall be designed.
+<panel type="info" title="Exercise 5.3.4.2 Designing an Up-Counter"> <WRAP group><WRAP column 2%>{{fa>pencil?32}}</WRAP><WRAP column 92%>
+The circuit in <imgref pic054> is a non-functioning up-counter. The circuit <imgref pic055> has a functioning up-counter as a black box. \\
+Investigate the circuit in <imgref pic054>:
+  * Does some of the outputs $Yn$ already show the correct result? Which one?
+  * We have now to focus on the outputs $Yn$ which show the wrong results. These have to be corrected. To do so a different input has to be chosen for these flip-flops. \\ Start with the lowest incorrect output.
+    * For which outputs of its previous flip-flops should it toggle its value?
+    * How can this be implemented into a logic circuit?
+  * Try to implement the correct logic (only one basic gate is needed)!
+</WRAP></WRAP></panel>
+<WRAP><well><imgcaption pic054|Up-Counter based on T Flip-Flops (not working)></imgcaption> \\ {{url>https://www.falstad.com/circuit/circuitjs.html?ctz=CQAgjOCmC0CcIAYB0CBMA2AzAVlgdjEwA4wxs8M88RsEaQAWTGmUgKAFlw90RNVw6OvxADUSbGwBKg0agYhoYXqnnhRNBFu11x2URMSIJbBmHj866IkT7YB126gQNbDNs+pgefMQlsiCgCaCGwA7ty8It68sLyhEZiYUQJJsfEeCNRpvnzWucFgnHzJuZa5YiYRDHEFtbWhnoy1IvYBAsGoxTUpjETCYgaSEejYvaPpiJnUE7mOBSBBmMWzIugMAxp6075WNqL788GNWbsgeEQKqPsXCsHLTeV49ge2zx2LXY-O5z-Xbz9CqYEMxXGc8C4+JcjGAAPpwhCwsxoWHYWHIHT4CaoNGI1Dw2GYWEAYQAMgBpcKyVQKfpyBQJEB0mlMuhga5TCLMtTyXRqRm88AcwUsxkbNkc8X0zmiDbSqWiqljCW2ZXSsVaaVqxVcui1MENKkG3hgnEZJqmsas0RWhQAEQAklTBbUYiBDdVNS1Sh6aEJ3Sb6hlSX0bb0zRoIAAzACGABsAM6QeihDagtyaiF3MG6WAEonI-G4lDaLFjHHowlVxFEokhYHpxhgrM0dlGdAExGF1HopAI2H4jt1opp0PYNst8jxd2dpFgFHF-v4vN1rqjsFT86Q9Z0CWz7uLyv49lVpZsczMOmujkNKYX2V6lT7W+he9S-XGoyv2DMNW1IS2C+bDEBozAQPOmoADoABaQQmAD2UZwQAQgAlgALgmbBAA noborder}}</well></WRAP>
+<WRAP><well><imgcaption pic055|Up-Counter as Blackbox></imgcaption> \\ {{url>https://www.falstad.com/circuit/circuitjs.html?ctz=CQAgjOCmC0CcIAYB0CBMA2AzAVlgdjEwA4wxs8M88RsEaQAWTGmUgKAFlw90RNVw6OvxADUSbGwBKg8KiIhoYXmHnhRNBFu11x2URMSIJbBmHj866IgpwDrC1AgYKGbJ9TA8+YhLYEMIACaCGwA7ty8Il68sLyhEZiYUQJJKmqhHnzJPnzWuYFBYJzZKT7CYgaSEQxxBXXKdJkI1LVl2GoihaglbQVEFRp64SDo2GVjKrACzdSTuQ4FwZgl8yLoDINiJlmWozaiB4uFs+UgeESB8goXgYUru07nHYc3L93uLWcUugc-jMFiptmC5vs4+JcjGAAPowhDQsxoaHYaHIHT4SaoFHw1Cw6GYaEAYQAMgBpEbKOQKAZUxAjNK0mK0hKMBpCSKCJqmBAg1xac7ghig4R4+GI3HYlDaDHjLGo6G4gkEkLc3mMUF4cHYVRGdCihFgJGSuEK6F65VAnmMBTagSawLkeIgWD68WoqVaHioWCYWAMbCYVTG+W4l3KnrA600bz20abKG4k1utHaL0+v0BoPuk2JxXQoIrJAgACqAAdCQB7ACuADsAC6QABODAARgBLOtGAKjEAk0nqCACACKuiMzCHEBUfBAQ4EjmnQ+YFmnUgAogBlcAQJogACCNYAJgBxACGDdXABsALYAHQAzqh75h7wwb4398ez5BL7e7+gX-e2Bvh+p7nte95EIB954G+xIVgA5m2ADGADyVZ1qW6E-vej6NnBiGoehmF1thf6wQhyFoRhWHgXesDkQRVHEaRkGNgAKgAYheballxFalqRz4PvehoiSJYAMchACSNbMbRz7sVxPF8QJtGvmRd6qGJmkSYp3G8Re-GkUBd6QZpQkSTpb6cfpKmkTBdEieplmkOAN44e5d4IJ5JkSR597eVBmmeY+AU+f5D4SBFejRVFwk4XFoVeRFfl3gAZieF53pA4VhfFyX5d5hWmIaIA0nUBwNCW5bVvWTath2bnCQV+iWY+LVNe1RX6O1eiiAlPUDf1kWDV5w2WRlWU5XeJm6IBw1zV5IzzOYAhMqtdLEBozAQIa-I3gAFveFZpfeABCHZ3mwQA noborder}}</well></WRAP>
-<imgcaption pic052|Asynchronous Shift Register based on D Flip-Flops></imgcaption> \\ {{url>https://www.falstad.com/circuit/circuitjs.html?ctz=CQAgjCCsCmC0YAYQIHQIOwBZ0LOyCCAzIpkQEyRRJVlRxhgBQYkVAHEmAJznhh8efJAiYB3cOgBsISjKGzIM0RIVzwvcFJHiNg7SE5adEo2ANnNKyfM3lymPcl33Hah7I-XXnxw6Q+1kTsfh6YhL7OEsFumjGRQUS2fPEK3uHGshlpukSQ+gHZBkH5ijJ5BVEgREll1aXqoqxU-k7k6IJWzgCykQLssggD-bKyKJBMAEqGAWEDPhCChMvLYy3jyMjjLGxQBgqQmmlVUkp1Uh111hd86jeZ15fmNPvFukpcBh9O12cKOLFhO9MKFHN9AsDAVAQQldJhuMloVDrOFPkhUT93gJMhjnlVINj1ATKiiEXViVcdrQIgoyJ1hM5MDxquQkKdyqV2YNMANMExWeg+uR5n9hSBHABNbweEYLKy5ELgMWpeUC6qKkZM+RiyXMXqpZVSYZi27bCSQGEjC3I-kYJFKgaQaQO8UgCXkJi9a0u-LG+ZrXQAl1BnJqkNi9C1TVuoiekDhgZGv2jcjbNUUNlnYWJs6S0Tp1nxhrsAb4PiS2MFpAdAIl+OFyUeqsgJOyOut3VMcJEcUDIgIRxBiqbPAAfTAo4Qo6ZiFHkEnaGW3GkSkok9H5HH6FHRFHAGEADIAaS7xF71SN8YH4oomxq4-XM6n89QK2X7LXU83993UtPPZ5G8+CDeFlAvB8pyfOcFzfFcpE-DcdykHdRwlZhu3PUCrzBYpqm4CDp0YZ8FwnL8d3w38PQwwDviDeDHHRTdSMI2cX0XQh31XF9EMwb9UNjYIWWqcBwFWAAdAALMSAGcAHsADMZIAIQASwAF2kpggA noborder}}
 ====== Examples ======
-<WRAP><well> <imgcaption pic100|Shift Register with synchronous Load ></imgcaption> \\ {{url>http://www.falstad.com/circuit/circuitjs.html?hideSidebar=true&ctz=CQAgzCCMCmC0AcIAMA6ArAJgJwBYdaSTSRwHZCJiQ0QdK5JIAoAGVqUQx0Rw5A3hJ+UEADMAhgBsAztGrJWtXv25KhA9cjFTZ8pIuI4ViQ-0HChEmXJr62ZDMdqlHG4ZG3W9igGyEnfurmjh5Wura+YK6qPlFmmpY6NgpsaD6cqmmcwSJhyXbUYD5OaEXx7p7hCgCy7CbFvIiQxa7oTLV4QmlqUC38bbWm3abNwhgDzo7dDr1jE4HUxQujrWjtILFTS3Er-WuD6YuLTX3j+4XFw2W7Z0wASuCkxZAYQmB4UK8iIYS-6uh7LSoNZsMBPKCYcCQyCQxyJLwRUHgyDwIxgaGoiyVfJMFAgeAAIQAlgAXADKAAsiaISXdoABzInSEnQABOAHVSRSWAB7cQAEy0JigWBAAGEWABpWjfEC8gX4sYgMlEgB2G3AwgAGl1HKQRFqPGh9c8QFrHGBhR4tRA6DLrUYBJrrTQMBAQmbnjQPNb9aKhB4AJpCHDFfVCQMeMgaiMWqZaQMQMC2hNot4J72iuEgQPPH0J-XZoQAEQAYpIiQAHcs8ysAUUkAFsADrSSCtjCtsCtnDN1kAQVV-IA4uIWQ2W9I0K2fK3SH3ByOx9AJ634K2sK3IEg+wB5Vmj8dNrc76Tztt9gCSqoAbmyWazV9J11O9wfl0-IN2272252B0Oh4rsez5btObbdgBS5HpOzQdluvasmWFbVpItafp2bbtm256IchVY1vWIEolum7SK8PYLoBH4gRg2GMB2-6LkBT4vm6HaIfuLG0b+GCYSRrJcTRk4YLO5Hnhg05Qdxk5sWxs7ScJHZkZAZEYPOSHlgRaFESJ4FgKeYDYXhWmoehIHvF2mHopRikwV2YnJl2GnMUpoHSJaXaboJ772R5ZFgl2nG+cBk44MZmG8FR0GhWuPbfuF0UyT2v4GT2-74WZuk9oZCXgSZKGEU+3A9mJ+C2a5fnED255oO2dmxe5mCtqUb7JVO351T264+e1aDgWkLWIZVjUvsaLVSSNT5oC+UQtQpmVFSBaC-mQLVkYhvKMgAxruACuJKVgdT7eVtRK7QdR0kp+UlnRdh3HbRPV3ftD3XbRkEvZdj2TuNrJfW903-gDV1Pp5-08jtr2gyBdB9iDP1dp9kPndDiMecDKP3TDYUKQj71hRp+OfqdWNowTXY7hDUPfRTWHw2TtNPv+153qyD6sVuCms-ebKc+R9U8+zfMgS+eBXrevOPqLykS2zHMy1OPVCwrskOXLUv81Q7atqeOvkc2uuG6+F7wUbLVbsbnbmybO66+gxvgfr1vSHbJvO8bbtO1bnuO5bRum67-sGzb3tm0HFuBy7XvB9HftR77kce6Hwd677CcpxnEfuz7mfJ9nYchwXseJznAf62n4cx1n1f57XufFzX8d1836cu2c4cd0XXftw73d9734GD53A9W6PHbj+Rk892PQ+zyPc8T+BbvAvHK8O5H6-Tpvnsb7bu-b-v9uH8vB+O0w4VvOC8CIJaRiMB6hKkpS1K0gyTIPpyJLcnygrYQG8Eg5TigIA083pQEtWQMfSB2FMJgJAQbIB4DEHwP-gggBKCYEQOAbAgOyC4FYMwTg7ByCMEYIIcQoh+C8EIIodQpBtCaFoOYSQxhDDcHsNYRw1BXDdb8CXvwqeroBGYTOIIsRoiASSOEUI8RUiREKNkdIuRMiJECNPKvYBGi+62GgVovRujXY6KgUYgaJjNFrCAA noborder}} </well></WRAP>
+In <imgref> a more functional version of a register is shown below. \\ It has
+  * the input pins $X7$....$X0$ (pins below the register)
+  * the output pins $Y7$....$Y0$ (pins on top of the register)
+  * a clock pin $CLK$ to clock the circuit synchronously
+  * a pin called $LOAD$ which resets the shifting to loading the internal flip flops with the bits given by the inputs. As long as $LOAD=1$ no shifting is made
+  * a pin called $DIR$ to set the direction. $DIR=0$ leads to right shifting, $DIR=1$ to left shifting.
+  * a pin called $SIN$ for **S**erial **IN**put. When right shifting $Y0$ will be set to $SIN$, when left shifting, then $Y7=SIN$
+  * the output pin $SOUT$ for **S**erial **OUT**put
+To see the register in action set (or reset) $X7$....$X0$, $DIR$, and $SIN$ and then stop the loading by resetting $LOAD$ by $LOAD=0$.
+The <imgref pic101a> shows the interior of the register.
+<WRAP><well> <imgcaption pic101|Shift Register with synchronous Load, Direction Bit and Sout></imgcaption> \\ {{url>https://www.falstad.com/circuit/circuitjs.html?hideSidebar=true&ctz=CQAgzCCMCmC0AcIAMA6SAmMkBsnsBZN8B2JfATmJAFYkaR8Jq5JIAoAGQaUXXjvw9wGEOiggAZgEMANgGdo9JJwaDR-VXSxixdafMXVkK2vnV1TwnckmyFSlSR0anV0eP32jyrtiR0+Oj8tETFIWwMHXzBnIJi3XQivYy5qbF4NNMRtd3DPQxSaMGxzIpKcsKSC5QBZbkQ0+qgSnRRqNjr8NUauuhx3dDaOmjIaEst+1vbO4jEe2eaBobrgsZBVydFl9fjG7HjNwemxhvH0xanh6mK165LDoYAlcGJ79C0uqHfxMP8--y2RiONlQ7S4YFeUGoYjA0Kh1jydmqbBQIHgACEAJYAFwAygALTESbGPaAAc0xcmx0AATgB1DgAeykABMACKYmk2RAtcIAYQ4AGkGD8QGyAJLPcjgdwcADyAEE2fRrLjxQA5EBUMxiXFygCqABUXiKIAAND5a8Rm8JgILWnTja0QdBiMzhM3u7LWoybD33PrWqglQMATRCVroofC6GDNlDOiY8YgkGlZij7qoECjvpj8ZKiHCUaoiTobIAYjJMQAHSuM6sAURkAFsADpySDt9DtsDt-CtmlMikAYzlAFdsdWJ0223JsAOh5jRxOp9iZ12BzUxzJsTWZNAAB609dyYjt+dyeDn9vUdvkdudmlbnd7w-HlsbjtIB+dr83u8Pt2g6MiO46TtOH6XguIFLmBq4npA340hWVa1jI9YId2UEdr2cj9shlY1nWjaQZA-Ydr+kC3nh0GgSuEGzjgtGwfRa6kY+z67tW+5HjSJ5Xh2F6QGegn-nI94dvhnGvrxCGUQJqYPgJ1ESe8zHLuBbGMWewF0ZpCFXgRqHESeakdiJ6C-lJ25cTx77aV2WGYI5Ymqfhi4afBpH3rpLH6ZBroDihRHoSRs7oORilyOg1HWS+3Fvnx3ldhesYpa5XaGR5cEMV2va+Z5uXRfORkhRhAUCc50USXFtmJaZuF2j2v5NXIKk9kB2WsaZOldf5s5NaVaHlQNTkiWAuG1TJ9lduN5FzRlciwupOVac1K3dZBYD4cFw1hT21FYD2F5TQlslbS15FYRe7VLb1MGFWtS3uq27bftFr3RW0G5dt9HafVhnaft2v3USDX3UUDcjvVD73g0cP0Qw+API8DAN-fDf2w6jH0faDiMI-9b04056Ng2TOMwyjeNIzThPY0TuOY+T+OM1TaOg2w+CIS8BaIF0hY3OEGI4gSRIkuSlLUvSTKshyXK-kCoOiMrv5hF2KsQ5rwK-n0N7a20Bu+hratG2butQBrTmG9bxttZb0Vm7bDt2zoyvO4rDtu1rHtvV7RsqBC9zwGYsJhCH7h6EiDgrAQoj9OkvAPGCvPx+UcKWS0Nj5A4QA noborder}} </well></WRAP>
+<WRAP><well> <imgcaption pic101a|Interieur of a Shift Register with synchronous Load, Direction Bit and Sout></imgcaption> \\ {{url>http://www.falstad.com/circuit/circuitjs.html?hideSidebar=true&ctz=CQAgzCAMB0l3BWEBGGAmOaDsWyQBxoBsAnCViApJSACwQICmAtMsgFDIJIlEhZoUkWv0HIo7AO4giI5H1koi1SFJCswffPnXIsWnaum8Q2kCfkSAsrv2mdrOwJCC00BOxvISg598EIfK7u7BgUjgbqGDpmIgAaWKGQFP6iLmgiziIAmolh6oFpGnxZIADKAJIAcpz4IsyFzswZaeJoaibOOs6q+WBifP3qOiIAIhUASmpDljMIgr3JMnIK9SMgADIA8gCCo0kUFnwmzOsAwhsA0tNi88Mod0ZRK9SK8ipqDXyo9X7CEtJmH9fgNDJ9kJp7AVIk8vigMNCobCWlxBM0XgDni4mi00PgPoDChlqHDopjii4CIiybCiS0ga4WsiRHjXiz8Zihtg0TpuZzboIuT0Ot8fKYUGLVMg6ojUuiJWIXAcFSq0CixTkiMqIpSHGSyfEtV4xalTXZgh4bDqyTrUhaRbrzDDwZCbXoglSnm9lMsXBypdwnSqfsHyYU5eG7LTBsg0USTAGeDGxP8wLGUOSIYM8bZs2DjHmgzTPLnwDmdWnXC4QsbBem7SZ7fkK+Wyf11nEPPlUpX0iJezkPNL6oVe-Le20Hb2dL3o+BaCD5yJYVmyw5Rzm55oSRv8+pnGrF3i9wyl-vBLRPZ9CrQOXCFyfVw-Ec+57RFKf38uHfRBCMhlKMr3kM8q-hm7TdhqXItGBOS0Nq7p0LeURUs+8TwbWdAzBqlj2laiHPjqYH2gWSE6CY7aZpChEEchiZBmBIaMWGfBgfelheuybJ0HA-LYoKgqSjc4BiqcIkLJ8MG8Yol4EliYCiVJcmfh+zjzCehTKDufCBI+kK6YiBlzggQFqTKTwmNwf6UI8tQjjpdzylZ4HKqkzmHjZF4gNkYAIXYBnNFSBnxL5mHOW5rrVpapYBYh7lRQ6BkmK+Lo6UQDhxelEhcEmnlCCI4UsXlcIIJCnE8dx8xyUMCkCZQ6ZPEMCDpmJzUSYCLRVb6XXMvVaKdQisJmYusgaSUCJwulekKGYk1mHOWD-Kei3fqRRBdDIwrDoi639SIu0uZBggHR5B05BBSw6lNKE6Nd8TtJhB2pEQRIJfhdjXVdB4JWtZiWVlK6Qp9iHXfRJhPf8T1FQdk2FOVXWKLI1UBOmQxEABwnozyMgYx1+2Xr6SPki0WNYkTQ2+Etzj6GNpgE3C+LTaYVIM1ehJaPSXRMg6WBit0QnbXCvN7fwJpKkdouMpkGreRwzaIYzN3Mx2HCYcLKo4EEb2lorOrqyRQaK+D82pcrOtXjlQbqyG1tFerQtRmoiME4o+jIzjdVYLZ0hDF72N+8TmQ+q7Pq9QH8pu+SXOLtotO8Np5ibqbPjrscSekSQ6bkQ1dmIpnIv54dSypIXHmFzkizhIhKdKzX8SqJhhepPgjbazqNft+mBsmDXJiK4DacZXYNdg8c9b-E3RWFwzCZO0H3HaO7AdDPgwo+3+TQxGvWKL76u+9avIv75JIhkCLqC8b1F-cdffFn-c9+NRvdWP3P9g3-AmLvK0dzb6e8g6FREoPcQCAEPDEEJdmKA7Df0Qk8WBMCfTb2-n4MUyCFw-18O1JQ1BTR3FSBTP0gC7jHi-iQswQDZzXiCEcagaBZ7SG-vQ74PoCFqFgSaTh2DkAYLwRA7hPoJx3CoYCLIVIgGXhAXcSR4CsLYPYiw6gtAOLsJ9MoxR4Ac6MMEfWMUIiUAYKEXWARSi5gXlxueSgOYgHqTIQEaxdxnLGUhN-UqfB4E+jcTguRX81HYXMdwjBjFpEWNcfgxx3tLGjVkdE+BdxolAIOnOF6GiUm+NeOGTxkSwn8LyvAjB4UIkmM2gKEpUdfBZSATTOx-BKm-0gYiTW3imkeOoE07+STVGvFQcddB+0-DxOQUgk09T5FdAoXcWONSplAMLnOFuGiFnpNMLQyWyzrZoIaTw6WpT1atPMPWO4cyukHNyccxhGCm5HJzs2QoJAMEUnuSIEQlQaj5EAZALk4jPleTKFsAAqgAFTfrfN4sZ3b3xmGwbBUKWqAOhYHFA4LfTQuUiiBF8pUXZSAuGH5WJUAzCVNo3BkBLDf3ObKUlGjUAqKgQSuM3wqVUUZXeXF-o-IspJGSVAHJ4iJEBKuHlJJEJCuZflIejK6IlltMICVQguQJXljA2VSsfgdgHuKylUrbmMo-Ai1AMlvKJCAA noborder}} </well></WRAP>
+====== Exercises ======
+<panel type="info" title="Exercise 5.4.1.1 Flip Flops Timing Sequence"> <WRAP group><WRAP column 2%>{{fa>pencil?32}}</WRAP><WRAP column 92%>
+The <imgref pic501a> shows a series of flip-flops and the $RES$ pin set to 1. \\
+Write down the sequence of the output $Y0$...$Y3$ for each subsequent cycle of $CLK$, when $RES=0$.
+Be aware, that on the flip-flops are input pins $R$ (Reset) and $S$ (Set). Once $R=1$ the output of the flip-flop is set to $Q=0$ independent of $D$. When $R=0$, the output of the flip-flop is set to $Q=1$ independent of $D$.
+<WRAP><well> <imgcaption pic501a|Exercise for Flip Flops Timing Sequence></imgcaption> \\ {{url>https://www.falstad.com/circuit/circuitjs.html?hideSidebar=false&running=false&ctz=CQAgjCAMB0l3BWcMBMcUHYMGZIA4UA2ATmIxAUgpABZsKBTAWjDACgwEkqwNDa84PiH6QOXcMRRD+KGj2GjxSBMN79CcmSKjKQ2PDW11p6nWIBKIFmGm4jLGkfvgQpuG+hIUXqFC9sAO6S0miCZmG6wRH42i5i0cIuLPzxQfqEgi5macHYmW6x+VmQRgn6hoVZBZHlCIRULsX6pVEUDVXtja11wpH1VLXpKS0OrHY9w2CysSO5fpEjQ8HE-GZgUtrlKHiCkdhoneUHg0WHZsfnSZUX6TR4Cvyqa8JinEZyVKvgTiDfg34EOIjE5BN9sAhpP83ID0oQMKFYpk9rFysjOuiHm17o8BDxbNiseNaPdwATyqCQFjMVRjpCqYN5Ay2jtwn1dmTpNsOcTPpy2mBfliRljyiKqCNbsFJa8tulvmZvqTueECayBG0IdIsVq-kpgjj+YblXCEdp4dITQBZPUa8GhTxAtDkJXhHYaowATTEzv09PtX34XpobBt6tJ6oOMJ8QJtFo18ajoQCvvjpIwrVJXuwbF9xsECAJWZAnpQobxHp1Dpjucg5Bsdny1mJzSMFgAogBlNgAGWbBOwTcczibphAADMAIYAGwAzgxqOVGbT9E2l6v+A2N21GqOOYP9W593u9kyVduDCPD5eL5U+cdKgeKEk1+lntv3-fa+RBUYFQSlRLIFoiFHhfn+b8j0EUkTg9Et2CAA noborder}} </well></WRAP>
+<button size="xs" type="link" collapse="Solution_5_4_1_1_Solution">{{icon>eye}} Solution</button><collapse id="Solution_5_4_1_1_Solution" collapsed="true">
+{{drawio>introduction_to_digital_systems:Solution_5_4_1_1_1.svg}}
+</collapse>
+</WRAP></WRAP></panel>
-<WRAP><well> <imgcaption pic101|Shift Register with synchronous Load, Direction Bit and Sout></imgcaption> \\ {{url>http://www.falstad.com/circuit/circuitjs.html?hideSidebar=true&ctz=CQAgzCCMCmC0AcIAMA6SAmMkBsnsBZN8B2JfATmJAFYkaR8Jq5JIAoAGQaUXXjvw9wGEOiggAZgEMANgGdo9JJwaDR-VXSxixdafMXVkK2vnV1TwnckmyFSlSR0anV0eP32jyrtiR0+Oj8tETFIWwMHXzBnIJi3XQivYy5qbF4NNMRtd3DPQxSaMGxzIpKcsKSC5QBZbkQ0+qgSnRRqNjr8NUauuhx3dDaOmjIaEst+1vbO4jEe2eaBobrgsZBVydFl9fjG7HjNwemxhvH0xanh6mK165LDoYAlcGJ79C0uqHfxMP8--y2RiONlQ7S4YFeUGoYjA0Kh1jydmqbBQIHgACEAJYAFwAygALTESbGPaAAc0xcmx0AATgB1DgAeykABMACKYmk2RAtcIAYQ4AGkGD8QGyAJLPcjgdwcADyAEE2fRrLjxQA5EBUMxiXFygCqABUXiKIAAND5a8Rm8JgILWnTja0QdBiMzhM3u7LWoybD33PrWqglQMATRCVroofC6GDNlDOiY8YgkGlZij7qoECjvpj8ZKiHCUaoiTobIAYjJMQAHSuM6sAURkAFsADpySDt9DtsDt-CtmlMikAYzlAFdsdWJ0223JsAOh5jRxOp9iZ12BzUxzJsTWZNAAB609dyYjt+dyeDn9vUdvkdudmlbnd7w-HlsbjtIB+dr83u8Pt2g6MiO46TtOH6XguIFLmBq4npA340hWVa1jI9YId2UEdr2cj9shlY1nWjaQZA-Ydr+kC3nh0GgSuEGzjgtGwfRa6kY+z67tW+5HjSJ5Xh2F6QGegn-nI94dvhnGvrxCGUQJqYPgJ1ESe8zHLuBbGMWewF0ZpCFXgRqHESeakdiJ6C-lJ25cTx77aV2WGYI5Ymqfhi4afBpH3rpLH6ZBroDihRHoSRs7oORilyOg1HWS+3Fvnx3ldhesYpa5XaGR5cEMV2va+Z5uXRfORkhRhAUCc50USXFtmJaZuF2j2v5NXIKk9kB2WsaZOldf5s5NaVaHlQNTkiWAuG1TJ9lduN5FzRlciwupOVac1K3dZBYD4cFw1hT21FYD2F5TQlslbS15FYRe7VLb1MGFWtS3uq27bftFr3RW0G5dt9HafVhnaft2v3USDX3UUDcjvVD73g0cP0Qw+API8DAN-fDf2w6jH0faDiMI-9b04056Ng2TOMwyjeNIzThPY0TuOY+T+OM1TaOg2w+CIS8BaIF0hY3OEGI4gSRIkuSlLUvSTKshyXK-kCoOiMrv5hF2KsQ5rwK-n0N7a20Bu+hratG2butQBrTmG9bxttZb0Vm7bDt2zoyvO4rDtu1rHtvV7RsqBC9zwGYsJhCH7h6EiDgrAQoj9OkvAPGCvPx+UcKWS0Nj5A4QA noborder}} </well></WRAP>
 ====== further Links ======