powered by 
Du baust Schaltungen selbst, direkt auf der Seite: Gatter setzen, Leitungen ziehen, Schalter umlegen und zusehen, wie die Signale Runde für Runde durchlaufen. Aus deinem Halbaddierer wird ein Baustein, aus zwei Bausteinen ein Volladdierer und aus vier Volladdierern ein Addierer für 4 Bit, so wie Hardware in Schichten gebaut wird. Zum Schluss baust du ein Flipflop, das sich ein Bit merkt.
In Vom Gatter zum Rechenwerk hast du fertige Schaltungen durchgeklickt und jede danach als Funktion geschrieben. Hier zeichnest du sie selbst. So entwerfen auch Leute, die Chips bauen, ihre Schaltungen: in einem Simulator, der zeigt, was auf jeder Leitung liegt, lange bevor etwas aus Silizium entsteht.
Die Gatter sehen aus wie dort, als Rechtecke nach DIN EN 60617: & für UND, ≥1 für ODER, =1 für XOR, 1 mit Kreis für NICHT, und ein Kreis am Ausgang dreht das Ergebnis um. Eine Leitung mit einer 1 ist gelb, eine mit einer 0 grau.
Einrichten musst du nichts, und der Workspace muss nicht laufen. Jede Aufgabe hat ihren eigenen Editor in der Karte; »Prüfen« schickt deine Schaltung an den Server, der sie Zeile für Zeile durchrechnet.
Neben der Fläche steht die Wahrheitstabelle deiner Schaltung, bis zu fünf Schaltern; ein Klick auf eine Zeile stellt die Schalter so ein. Auf einem Handy kannst du Schaltungen ansehen und die Schalter umlegen. Zum Bauen brauchst du einen größeren Bildschirm, ein Tablet oder einen Computer.
Hier ist ein Editor zum freien Bauen, mit Schaltern und Lampen in der Leiste. Einen Schalter oder eine Lampe benennst du mit »Umbenennen«.
Was du in einem Editor baust, merkt sich dein Browser, nach jedem Schritt, auch über das Neuladen der Seite hinweg, für jedes Konto getrennt. Prüfst du eine Schaltung, speichert der Workspace sie außerdem als deine Antwort zu der Aufgabe; an einem anderen Computer lädt die Karte diese geprüfte Schaltung, wenn du angemeldet bist. Was du danach nur im Browser geändert und nicht mehr geprüft hast, bleibt auf dem ersten Computer.
Eine Schaltung, deren Lampen nur davon abhängen, wie die Schalter gerade stehen, heißt Schaltnetz. In jeder Karte stehen die Schalter und Lampen der Aufgabe schon bereit; verschieben kannst du sie, löschen nicht. Die Prüfung schaltet jede Zeile der Wahrheitstabelle ein, wartet, bis die Schaltung zur Ruhe gekommen ist, und vergleicht die Lampen. Stimmt eine Zeile nicht, nennt sie die erste.
Fang mit einer Schaltung an, die du kennst: dem Halbaddierer, der zwei Bits addiert.
Bau einen Halbaddierer: Er addiert die Bits a und b und zeigt an der Lampe s die Summe und an der Lampe c den Übertrag.
| a | b | s | c |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 0 | 1 | 1 | 0 |
| 1 | 0 | 1 | 0 |
| 1 | 1 | 0 | 1 |
Zwei Gatter reichen. Die Prüfung schaltet alle vier Zeilen ein und vergleicht die Lampen.
Lies die Tabelle Spalte für Spalte: In welchen Zeilen ist c gleich 1? Und welches Gatter liefert genau dann eine 1?
s ist 1, wenn genau einer der beiden Eingänge 1 ist. Das Gatter dafür hat =1 im Rechteck.
Hier geht es weiter, sobald du deine Antwort oben abgegeben hast.
Dein Halbaddierer wird gleich ein Baustein. Klick in seiner Karte auf Als Baustein speichern und nenne ihn HA. Aus seinen Schaltern werden die Eingänge des Bausteins, aus seinen Lampen die Ausgänge, von oben nach unten in der Reihenfolge, in der sie stehen: links a und b, rechts s und c. Danach steht HA in der Leiste jedes Editors auf der Seite, wie ein Gatter.
Ein Baustein ist eine gespeicherte Schaltung mit eigenen Anschlüssen. Setzt du ihn ein, siehst du nur seinen Kasten; innen rechnen seine Gatter, als stünden sie da. Genauso wird Hardware gebaut: aus Transistoren Gatter, aus Gattern Addierer, aus Addierern ein Rechenwerk, und auf jeder Stufe muss man nur noch wissen, was ein Kasten tut, nicht mehr, wie.
HA ein und schließ an beide dieselben zwei Schalter an. Beide rechnen dasselbe, jeder mit seinen eigenen zwei Gattern: Der Zähler unter der Fläche sagt »4 Gatter, 4 davon in Bausteinen«.
Aus NAND allein lässt sich jedes Gatter bauen. Auf der Seite davor hast du das in Ruby oder Python gezeigt, hier baust du es mit Leitungen.
Bau ein XOR, nur aus NAND-Gattern: Die Lampe y leuchtet, wenn genau einer der Schalter a und b auf 1 steht. Vier NAND reichen; mehr lässt die Prüfung nicht gelten.
Fang mit einem NAND aus a und b an; nenne seinen Ausgang für dich x. Wann ist x gleich 0?
Ein NAND aus a und x ist 0 nur bei a = 1 und b = 0, eins aus x und b nur bei a = 0 und b = 1. Was brauchst du dahinter, damit y in genau diesen Zeilen 1 wird?
Das letzte NAND bekommt die Ausgänge der beiden mittleren. Ein NAND liefert 1, sobald einer seiner Eingänge 0 ist.
Hier geht es weiter, sobald du deine Antwort oben abgegeben hast.
So sieht ein XOR aus vier NAND aus: Das erste NAND liefert x, und nur dort, wo genau einer der Eingänge 1 ist, gibt eines der beiden mittleren eine 0 an das letzte weiter.
Das Rechenwerk der Seite davor rechnet jedes Ergebnis gleichzeitig aus, die Summe, das UND, das ODER und das XOR, und ein Block MUX gibt das weiter, das der Befehl verlangt. Dieser Multiplexer wählt mit einer Leitung sel (select) zwischen zwei Eingängen.
Ein Multiplexer wählt aus: Steht der Schalter sel auf 0, zeigt die Lampe y, was an a anliegt; steht er auf 1, was an b anliegt. Bau ihn aus höchstens vier Gattern.
| sel | y |
|---|---|
| 0 | a |
| 1 | b |
Die Prüfung schaltet alle acht Kombinationen von a, b und sel ein.
Teil die Aufgabe in zwei Hälften: eine Leitung, die a ist, wenn sel 0 ist, und sonst 0; und eine, die b ist, wenn sel 1 ist, und sonst 0.
Ein UND lässt b durch, wenn sein anderer Eingang 1 ist, und liefert sonst 0. Für die Hälfte mit a braucht das UND ein umgedrehtes sel.
Höchstens eine der beiden Hälften ist 1. Ein ODER fasst sie zusammen.
Hier geht es weiter, sobald du deine Antwort oben abgegeben hast.
Ein Multiplexer für vier Eingänge braucht zwei Leitungen zum Auswählen, eine für acht drei. Du kannst ihn aus drei Multiplexern für zwei Eingänge bauen: zwei wählen aus je zwei aus, und der dritte wählt zwischen ihren Ergebnissen.
Ein Volladdierer addiert drei Bits: a, b und den Übertrag c_in aus der Spalte rechts. Bau ihn aus deinen beiden Halbaddierern: Du findest HA in der Leiste seiner Karte.
Bau einen Volladdierer aus zwei Bausteinen HA und einem ODER: Er addiert a, b und den Übertrag c_in und zeigt die Summe an s und den Übertrag an c_out. Die Prüfung schaltet alle acht Zeilen ein und zählt die Bausteine und die Gatter darin: zwei Halbaddierer mit je zwei Gattern und das ODER, fünf zusammen.
Der erste HA bekommt a und b. Seine Summe s ist die Summe der beiden Bits, sein c ihr Übertrag.
Der zweite HA addiert zur Summe des ersten den Übertrag c_in. Seine Summe ist schon das s des Volladdierers.
Bleiben die beiden Überträge der Halbaddierer. Ein Übertrag nach links entsteht, wenn einer von beiden 1 ist.
Hier geht es weiter, sobald du deine Antwort oben abgegeben hast.
Speichere auch ihn als Baustein, als VA. In seinem Kasten stecken jetzt zwei Kästen HA, und in jedem von ihnen zwei Gatter: drei Schichten. Ändert sich später dein HA (du speicherst ihn noch einmal unter demselben Namen), nimmt VA beim nächsten Einsetzen den neuen.
Vier Volladdierer nebeneinander addieren zwei Zahlen mit 4 Bit, eine Spalte jeder, wie beim schriftlichen Addieren. Der Übertrag jeder Spalte geht in die links daneben.
Bau aus vier Bausteinen VA einen Addierer für zwei Zahlen mit 4 Bit, a = a3 a2 a1 a0 und b = b3 b2 b1 b0, dazu einen Übertrag c_in von rechts. Die Summe kommt an die Lampen s3 s2 s1 s0, der Übertrag aus der linken Spalte an c_out. Die Prüfung schaltet alle 512 Kombinationen ein, von 0000 + 0000 bis 1111 + 1111 + 1.
Jeder VA rechnet eine Spalte der schriftlichen Addition: der rechte a0, b0 und c_in.
Der Übertrag c_out eines VA ist der Übertrag c_in seines linken Nachbarn. Fang rechts an und arbeite dich nach links.
Stell an deinem Addierer a = 0111 und b = 0000 ein, c_in auf 0. Gleich legst du b0 auf 1 um, und 0111 + 0001 = 1000. Welche der Lampen s3 s2 s1 s0 ändert sich als letzte?
Ein VA weiß seine Summe erst, wenn sein Übertrag von rechts da ist.
Hier geht es weiter, sobald du deine Antwort oben abgegeben hast.
Die Summe der linken Spalte ändert sich zuletzt: Der Übertrag läuft von rechts nach links durch alle vier Volladdierer, und jeder kann erst rechnen, wenn der rechts von ihm fertig ist. Darum heißt diese Schaltung Ripple-Carry-Addierer. In jedem Volladdierer braucht der Übertrag zwei Runden, ein UND und ein ODER.
b0 auf 1. Schau auf die Leitungen zwischen den Volladdierern: Der Übertrag wandert gelb von rechts nach links, und erst danach springen s3 und c_out. Probier dasselbe mit a = 1111: Jetzt läuft er bis zu c_out.
CMP A, B in der CPU Sandbox vergleicht, indem es subtrahiert und nur die Flags behält. Ein Vergleicher lässt sich aber auch direkt bauen, Bit für Bit, vom höchsten an.
Die Schalter a1 a0 sind eine Zahl a mit zwei Bits, b1 b0 eine Zahl b, das höhere Bit vorn: a1 = 1, a0 = 0 ist 10, also 2. Bau einen Vergleicher: Die Lampe eq (equal) leuchtet, wenn a und b gleich sind, die Lampe gt (greater than), wenn a größer als b ist. Die Prüfung schaltet alle 16 Paare von a und b ein.
Gleich sind zwei Zahlen, wenn jedes Bit gleich ist. Welches Gatter liefert 1, wenn zwei Bits verschieden sind? Dreh sein Ergebnis um, dann hast du »gleich«.
Größer ist a, wenn schon das höhere Bit entscheidet (a1 = 1 und b1 = 0), oder wenn die höheren Bits gleich sind und das niedrigere entscheidet (a0 = 1 und b0 = 0).
Ein Gerüst für gt: ein UND aus a1 und nicht b1; ein UND aus »a1 gleich b1«, a0 und nicht b0 (ein UND mit drei Eingängen); ein ODER aus beiden. Die Gleichheit der höheren Bits hast du für eq schon gebaut.
Hier geht es weiter, sobald du deine Antwort oben abgegeben hast.
Dein Vergleicher entscheidet wie du, wenn du zwei Zahlen vergleichst: Das höchste Bit, in dem sie sich unterscheiden, sagt, welche größer ist. Für 8 Bit kommen nur weitere Stufen dazu; jede fragt, ob alle Bits davor gleich waren.
Bis hierher hingen die Lampen nur davon ab, wie die Schalter gerade stehen. Führt eine Leitung vom Ausgang eines Gatters zurück zu einem Gatter davor, hat die Schaltung einen Zustand: Sie heißt dann Schaltwerk und kann sich etwas merken. Die Wahrheitstabelle neben dem Editor verschwindet dann, denn welche Lampen leuchten, hängt auch davon ab, was vorher war.
Auf der Seite davor hast du das RS-Flipflop aus zwei NOR und das D-Flipflop mit Takt durchgeklickt. Jetzt baust du das D-Flipflop selbst. In deinem Editor fangen alle Gatter mit 0 an. Die beiden NOR des Flipflops schalten dann im Gleichtakt hin und her, bis ein Eingang sie aus dem Takt bringt: Leg den Takt einmal auf 1, dann kommt es zur Ruhe.
Bau ein D-Flipflop mit Takt (ein D-Latch): Solange takt auf 1 steht, zeigt die Lampe q, was am Schalter d anliegt. Steht takt auf 0, behält q das Bit, egal was an d geschieht. Die Prüfung legt die Schalter Schritt für Schritt um: d = 1 und takt = 1, dann takt = 0, dann d = 0 (q muss 1 bleiben), dann takt = 1 (q folgt), und so weiter, sieben Schritte. Jedes Gatter steht am Anfang auf 0.
Der Speicher ist das RS-Flipflop aus zwei NOR, deren Ausgänge über Kreuz zurückführen: S = 1 setzt Q auf 1, R = 1 setzt es auf 0, sind beide 0, hält es.
Vor das Flipflop kommen zwei UND: S soll 1 sein, wenn takt und d 1 sind, R, wenn takt 1 und d 0 ist.
R braucht ein umgedrehtes d: ein NICHT vor dem einen UND. Achte darauf, welches NOR an R und welches an S hängt: Die Lampe q gehört an das NOR, an dem R anliegt.
Hier geht es weiter, sobald du deine Antwort oben abgegeben hast.
So sieht eines aus, das RS-Flipflop mit den beiden UND davor. Ein Register mit 8 Bit, wie A in der CPU Sandbox, besteht aus acht solchen Flipflops mit einem gemeinsamen Takt.
DL und setz im freien Editor zwei davon ein, beide mit demselben Schalter als Takt und je einem eigenen Schalter als d: ein Register für 2 Bit. Achte darauf, was die Lampen tun, während der Takt auf 0 steht und du die beiden d umlegst.
Aus Gattern, Addierern, Multiplexern und Flipflops besteht jeder Prozessor. In der CPU Sandbox programmierst du einen, mit Registern, einem Rechenwerk und Speicher, erst in Assembler und später in C: vom Gatter zum Prozessor.
Wer weiterbauen will, findet dieselben Schaltzeichen im Simulator Digital, der an Hochschulen in Deutschland viel benutzt wird, und in Logisim-evolution. Beide können, was dieser Editor kann, und noch viel mehr: Busse, Zähler, Speicher, ganze Prozessoren.
The Elements of Computing Systems, Noam Nisan und Shimon Schocken, MIT Press. Der Kurs »From Nand to Tetris« baut genau so in Schichten: aus einem NAND die Gatter, daraus Addierer, ein Rechenwerk, Register und Speicher und schließlich einen ganzen Computer, für den man dann einen Assembler und einen Compiler schreibt. Der Kurs mit allen Projekten und dem Simulator ist frei: nand2tetris.org.