Logikgatter: UND, ODER, NICHT, XOR, Wahrheitstabelle und Arduino

Logikgatter sind die Grundbausteine digitaler Schaltungen: Jedes Gatter wertet einen oder mehrere digitale Eingänge aus und liefert nach einer festen Regel einen einzigen digitalen Ausgang. Die Eingänge können nur 0 (LOW) oder 1 (HIGH) sein, der Ausgang ebenfalls. Es gibt sieben Grundgatter: UND (AND), ODER (OR), NICHT (NOT), NAND, NOR, XOR und XNOR. Vom Prozessor in deinem Handy über die Steuerplatine einer Waschmaschine bis zum ATmega328P im Arduino und zum Taschenrechner: Jedes digitale Gerät funktioniert, weil Millionen winziger Logikgatter zusammenarbeiten.

In dieser Anleitung lernst du das Symbol und die Wahrheitstabelle jedes Gatters kennen, echte Bausteine wie 74HC08, 74HC32 und 74HC00, ein Experiment mit zwei Tastern auf dem Steckbrett, wie du alle anderen Gatter nur aus NAND-Gattern aufbaust, und den Halbaddierer, der zwei Bits addiert. In den letzten Abschnitten setzen wir dieselbe Logik auf dem Arduino mit den Operatoren &&, || und ! sowie mit Bitoperationen in Code um und machen dann mit Beispielen für ESP32 und Raspberry Pi Pico (MicroPython) weiter.

Was ist ein Logikgatter und wie funktioniert es?

In der Digitaltechnik befindet sich jedes Signal in einem von zwei Zuständen: 1 (HIGH, wahr) oder 0 (LOW, falsch). Die Mathematik dieser beiden Werte heißt boolesche Algebra; George Boole beschrieb 1854 in seinem Buch logisches Denken genau auf diese Weise als Algebra. 1937 zeigte Claude Shannon, dass diese Algebra eins zu eins auf Schaltkreise aus Relais passt, und legte damit den Grundstein für den Entwurf digitaler Schaltungen. Heute stecken in einem Logikgatter nur wenige Transistoren: In CMOS-Technik besteht ein NICHT-Gatter aus 2 und ein NAND-Gatter aus 4 MOSFETs. Wie ein Transistor als Schalter arbeitet, erklären wir im Artikel Was ist ein Transistor?.

Welche Spannung erkennt eine Schaltung nun als 1 und welche als 0? Das hängt von der Versorgungsspannung des Boards und von der Bausteinfamilie ab. Die Tabelle unten zeigt die Grenzen, ab denen ein Eingang sicher als 1 oder sicher als 0 gilt. Der Bereich zwischen beiden Grenzen ist der undefinierte Bereich; bleibt ein Eingang dort, kann sich der Ausgang zufällig verhalten. Ein Eingang, der nirgendwo angeschlossen ist, also ein offener (floatender) Eingang, schwankt genau in diesem Bereich. Deshalb muss jeder Eingang an einem Signal hängen oder über einen Widerstand mit GND oder VCC verbunden sein.

Die 7 grundlegenden Logikgatter und ihre Symbole

In Schaltplänen werden Gatter nach zwei verschiedenen Normen gezeichnet. In der amerikanischen Norm (ANSI/IEEE) hat jedes Gatter eine eigene Form: UND sieht aus wie ein D, ODER wie ein spitzer Schild und NICHT wie ein Dreieck. Der kleine Kreis am Ausgang bedeutet "invertieren"; ein NAND ist also ein UND mit einem Kreis an der Spitze. XOR unterscheidet sich von ODER durch die zweite gebogene Linie auf der Eingangsseite. In der europäischen Norm (IEC, DIN EN 60617), die in deutschen Schulbüchern üblich ist, sind alle Gatter Rechtecke mit einem Zeichen darin: & für UND, ≥1 für ODER, =1 für XOR und 1 für NICHT. XOR heißt auf Deutsch auch Exklusiv-ODER oder Antivalenz, XNOR auch Äquivalenz.

Wahrheitstabellen der Logikgatter

Eine Wahrheitstabelle listet auf, welchen Ausgang ein Gatter bei jeder Kombination seiner Eingänge liefert. Ein Gatter mit n Eingängen hat 2ⁿ Zeilen: 4 Zeilen bei zwei Eingängen, 8 bei drei und 16 bei vier. Schreibst du die Zeilen in binärer Zählreihenfolge (00, 01, 10, 11), übersiehst du keine Kombination. Hier sind alle sechs Gatter mit zwei Eingängen in einer Tabelle:

Da das NICHT-Gatter nur einen Eingang hat, besteht seine Tabelle aus zwei Zeilen: Bei A = 0 ist der Ausgang 1, bei A = 1 ist er 0. Schaust du genau hin, erkennst du ein Muster: Die NAND-Spalte ist das genaue Gegenteil von UND, NOR das Gegenteil von ODER und XNOR das Gegenteil von XOR. Zum Merken helfen diese kurzen Regeln: UND fragt "sind alle 1?", ODER fragt "ist mindestens einer 1?", XOR fragt "sind die Eingänge verschieden?"; ein Gatter, dessen Name mit N beginnt, gibt auf dieselbe Frage die umgekehrte Antwort. Um die Gatter selbst auszuprobieren und die Symbole live zu sehen, tippst du im Werkzeug Logikgatter einfach auf die Eingänge A und B.

• UND: Zwei Schalter in Reihe. Die Lampe leuchtet nur, wenn beide Schalter geschlossen sind; auch ein Banktresor, der sich nur mit zwei getrennten Schlüsseln öffnen lässt, folgt der UND-Regel.
• ODER: Zwei Taster parallel. Dieselbe Klingel läutet, egal ob jemand an der Vorder- oder an der Hintertür drückt.
• NICHT: Die Kühlschranklampe. Ist die Tür zu, wird der Schalter gedrückt und die Lampe ist aus; öffnet sich die Tür, wird der Schalter losgelassen und die Lampe geht an.
• NAND: Die Regel "warnen, wenn nicht alles in Ordnung ist". Ist auch nur eine der beiden Schutzhauben einer Maschine offen, leuchtet die Warnlampe.
• NOR: Die Regel "nichts davon ist passiert". Eine grüne "Alles in Ordnung"-Lampe, die nur leuchtet, wenn weder Rauch noch Gas erkannt wird.
• XOR: Die Wechselschaltung im Treppenhaus. Wer unten oder oben den Schalter umlegt, ändert den Zustand der Lampe; sie leuchtet, wenn die beiden Schalter unterschiedlich stehen, und ist aus, wenn sie gleich stehen.
• XNOR: Ein Gleichheitstest. Es liefert 1, wenn zwei Bits gleich sind; man findet es in digitalen Vergleichern und in Schaltungen zur Fehlerprüfung.

Logikgatter-ICs: 74HC08, 74HC32, 74HC00

Statt Logikgatter einzeln aus Transistoren aufzubauen, verwendest du fertige Bausteine. Am weitesten verbreitet ist im Hobbybereich die 74HC-Serie: Ein DIP-Gehäuse mit 14 Pins enthält vier Gatter mit je zwei Eingängen, die Versorgung kommt immer an Pin 14 (VCC) und Masse an Pin 7 (GND). 74HC-Bausteine arbeiten von 2 bis 6 V, ihre Eingänge ziehen fast keinen Strom, und bei 5 V hat ein Gatter eine Verzögerung von etwa 10 Nanosekunden; das ist hunderte Male schneller als ein einzelner digitalWrite-Befehl auf dem Arduino. Jeder Ausgang hält bei 4 mA Last seine garantierten Spannungspegel; die absolute Grenze liegt bei 25 mA pro Ausgang und 50 mA für den ganzen Baustein.

74HC08, 74HC32, 74HC00 und 74HC86 haben exakt dieselbe Pinbelegung; nur die Art des Gatters im Inneren ändert sich. Die Kerbe oder der Punkt auf dem Gehäuse markiert Pin 1. Schaust du von oben auf den Baustein, die Kerbe links, werden die Pins gegen den Uhrzeigersinn gezählt: untere Reihe von links nach rechts 1–7, obere Reihe von rechts nach links 8–14. A und B sind Eingänge, Y ist der Ausgang, und die vorangestellte Ziffer ist die Nummer des Gatters.

Bausteine mit derselben Funktion gibt es in verschiedenen Familien. Die 74LS-Serie ist ältere TTL-Technik: Sie läuft nur mit 4,75–5,25 V, braucht mehr Strom und liest einen offenen Eingang meist als 1. Die 74HCT-Serie ist ein 74HC mit TTL-kompatiblen Eingängen; sie wird mit 5 V versorgt, erkennt aber schon 2 V sicher als 1 und liest deshalb 3,3-V-Signale von ESP32 und Pico problemlos. Die CD4000-Serie (CD4081, CD4011 usw.) arbeitet in einem weiten Bereich von 3–18 V, ist aber langsamer und anders belegt als die 74HC: Ein CD4011 kann einen 74HC00 nicht einfach ersetzen.

Experiment mit Tastern auf dem Steckbrett: UND-Gatter mit dem 74HC08

Am besten verstehst du ein Logikgatter, wenn du es selbst mit zwei Tastern ausprobierst. In diesem Experiment gibt es keinen Mikrocontroller; du brauchst nur einen 74HC08, zwei Taster, zwei 10-kΩ-Widerstände, einen 1-kΩ-Widerstand, eine LED und einen 100-nF-Kondensator. Zur Versorgung reichen die Pins 5V und GND eines Arduino, ein Steckbrett-Netzteilmodul oder drei AA-Batterien (4,5 V). Wenn du dir bei den inneren Verbindungen des Steckbretts unsicher bist, lies zuerst Was ist ein Breadboard?.

1. Setze den 74HC08 so über den Mittelkanal des Steckbretts, dass die Pins auf beiden Seiten liegen; die Kerbe zeigt nach links.
2. Verbinde Pin 14 mit der Plus-Schiene (5 V) und Pin 7 mit der Minus-Schiene (GND) und setze den 100-nF-Kondensator zwischen diese beiden Pins.
3. Verbinde eine Seite von Taster A mit der Plus-Schiene und die andere mit Pin 1. Setze vom selben Pin einen 10-kΩ-Widerstand nach GND: Dieser Pull-down-Widerstand hält den Eingang sicher auf 0, solange der Taster nicht gedrückt ist.
4. Schließe Taster B genauso an Pin 2 an und gib ihm ebenfalls einen eigenen 10-kΩ-Pull-down-Widerstand.
5. Führe vom Ausgang an Pin 3 über einen 1-kΩ-Widerstand zum langen Bein der LED (Anode); das kurze Bein (Kathode) kommt an GND.
6. Lege die ungenutzten Eingänge 4, 5, 9, 10, 12 und 13 an GND; die Ausgänge 6, 8 und 11 bleiben offen.
7. Schalte die Versorgung ein und probiere die vier Kombinationen nacheinander aus: Die LED darf nur leuchten, wenn du beide Taster gleichzeitig drückst. Vergleiche die Ergebnisse mit der Wahrheitstabelle.

Jedes Gatter aus NAND bauen: das universelle Gatter

NAND heißt universelles Gatter, weil du allein mit NAND-Gattern jedes andere Gatter aufbauen kannst. Das hat auch einen praktischen Hintergrund: In CMOS-Technik gehört NAND mit nur 4 Transistoren zu den einfachsten Gattern, während ein UND eigentlich ein NAND mit nachgeschaltetem NICHT ist und 6 Transistoren braucht. Deshalb lieben Chipentwickler NAND. Auch der NAND-Flash in USB-Sticks hat seinen Namen daher, dass seine Speicherzellen wie die Transistoren eines NAND-Gatters in Reihe geschaltet sind. NOR ist ebenfalls universell: Der Apollo Guidance Computer, der zum Mond flog, bestand aus rund 2.800 Bausteinen mit je zwei NOR-Gattern mit drei Eingängen.

Die ODER-Zeile der Tabelle beruht auf dem De-Morganschen Gesetz: (A' · B')' = A + B. Invertierst du also zuerst beide Eingänge und gibst sie dann auf ein NAND, erhältst du ein ODER. Das zweite De-Morgansche Gesetz lautet (A + B)' = A' · B'. Beide Gesetze helfen dir auch, Bedingungen im Code zu vereinfachen: Auf dem Arduino liefert !(a && b) immer dasselbe wie (!a || !b), und !(a || b) dasselbe wie (!a && !b).

Ein XOR aus vier NAND-Gattern zu bauen, ist eine klassische Prüfungs- und Laboraufgabe, und die vier Gatter eines einzigen 74HC00 reichen genau dafür. Zuerst wird N1 = A NAND B gebildet. Dann folgen N2 = A NAND N1 und N3 = B NAND N1, und der Ausgang des letzten Gatters, Y = N2 NAND N3, ergibt XOR. Mit der folgenden Verdrahtung machst du aus deinem Steckbrett-Experiment ein XOR aus vier NANDs:

Gehen wir noch einen Schritt weiter: Verbindest du die Ausgänge zweier NAND-Gatter über Kreuz mit dem jeweils anderen Eingang, erhältst du einen 1-Bit-Speicher, das RS-Flipflop (SR-Latch). Diese Schaltung merkt sich ihren letzten Zustand, auch wenn du den Taster loslässt. Register in Prozessoren, Zähler und Bausteine wie das Schieberegister 74HC595 entstehen, indem solche aus Gattern gebauten Speicherzellen aneinandergereiht werden.

Der Halbaddierer: zwei Bits mit Gattern addieren

Das Beeindruckendste, was Logikgatter können, ist Rechnen. Im Binärsystem gilt 0 + 0 = 0, 0 + 1 = 1, 1 + 0 = 1 und 1 + 1 = 10 (dezimal 2). Die rechte Stelle des Ergebnisses heißt Summe, die Stelle, die nach links überläuft, Übertrag (Carry). Ein Blick auf die Tabelle unten zeigt: Die Summe ist genau XOR, der Übertrag genau UND. Ein XOR- und ein UND-Gatter nebeneinander bilden also einen Halbaddierer, der zwei einstellige Binärzahlen addiert.

Für den Aufbau auf dem Steckbrett verbindest du die Taster A und B mit den Pins 1 und 2 sowohl eines 74HC86 als auch eines 74HC08. Pin 3 des 74HC86 treibt die Summen-LED, Pin 3 des 74HC08 die Übertrags-LED. Drückst du beide Taster, geht die Summen-LED aus und die Übertrags-LED an: Die LEDs zeigen binär 10, also 2. Willst du nur einen 74HC00 verwenden, brauchst du vier NANDs für das XOR und ein fünftes NAND, das N1 invertiert und so den Übertrag liefert; ein Halbaddierer braucht also 5 NAND-Gatter.

Ein Halbaddierer kann keinen Übertrag aus der niedrigeren Stelle berücksichtigen; dafür brauchst du einen Volladdierer. Seine Formeln lauten S = A ⊕ B ⊕ Cin und Cout = (A · B) + (Cin · (A ⊕ B)), also zwei Halbaddierer und ein ODER-Gatter. Schaltest du vier Volladdierer so hintereinander, dass jeder seinen Übertrag an den nächsten weitergibt, erhältst du einen 4-Bit-Addierer; der fertige Baustein 74HC283 erledigt dieselbe 4-Bit-Addition, bildet die Überträge aber mit einer schnellen internen Schaltung (Carry-Look-Ahead), statt zu warten, bis sie durch die Kette gelaufen sind. Das Rechenwerk des Prozessors in deinem Computer ist eine 64-Bit-Version derselben Idee, nur viel schneller.

Logikgatter auf dem Arduino: &&, ||, ! und Bitoperationen

Im Arduino-Code hat jedes Logikgatter zwei Entsprechungen. Logische Operatoren (&&, ||, !) verknüpfen Bedingungen und liefern true oder false; du nutzt sie in if- und while-Anweisungen. Bitweise Operatoren (&, |, ^, ~) wirken dagegen gleichzeitig auf alle Bits einer Zahl, Spalte für Spalte; mit einem Byte zu arbeiten ist, als würdest du acht Gatter auf einmal betreiben. Die Beispiele in der Tabelle verwenden die Zahlen 0b1100 und 0b1010:

Der Unterschied zwischen beiden Arten wirkt klein, führt aber zu tückischen Fehlern. && und || werten nach dem Kurzschlussprinzip aus: Ist in a && b schon a falsch, wird b gar nicht mehr berechnet. & wertet dagegen immer beide Seiten aus und betrachtet die Bits der Zahlen: 2 && 1 ergibt true, 2 & 1 aber 0, weil 0b10 und 0b01 kein gemeinsames Bit haben. C++ kennt keinen eigenen logischen XOR-Operator; für zwei bool-Werte ist a != b die lesbarste Lösung. Mehr zu Bitoperationen, den Verschiebungen << und >> und dem Binärsystem findest du im Artikel Zahlensysteme und Bitoperationen.

Jetzt übertragen wir das Steckbrett-Experiment auf einen Arduino Uno. Zwei Taster kommen an die Pins 2 und 3, sieben LEDs (jede mit 330-Ω-Widerstand) an die Pins 4–10. Jeder Taster liegt mit einer Seite am Pin und mit der anderen an GND; da der interne Pull-up-Widerstand aktiviert ist, brauchst du keinen zusätzlichen Widerstand. Ein einziger Sketch erweckt alle sieben Gatter gleichzeitig zum Leben:

1// Mantık kapısı simülatörü: 2 buton, 7 LED / Logic gate simulator: 2 buttons, 7 LEDs
2const byte PIN_A = 2;   // A butonu, diğer ucu GND / button A, other leg to GND
3const byte PIN_B = 3;   // B butonu, diğer ucu GND / button B, other leg to GND
4
5// Sıra: AND, OR, NOT A, NAND, NOR, XOR, XNOR / Order: AND, OR, NOT A, NAND, NOR, XOR, XNOR
6const byte LED_PINS[7] = {4, 5, 6, 7, 8, 9, 10};
7const char* const GATE_NAMES[7] = {"AND", "OR", "NOT A", "NAND", "NOR", "XOR", "XNOR"};
8
9byte lastInputs = 0xFF;   // ilk turda yazdırmayı zorlar / forces a print on the first pass
10
11void setup() {
12  pinMode(PIN_A, INPUT_PULLUP);
13  pinMode(PIN_B, INPUT_PULLUP);
14  for (byte i = 0; i < 7; i++) {
15    pinMode(LED_PINS[i], OUTPUT);
16  }
17  Serial.begin(9600);
18}
19
20void loop() {
21  // Basılı buton LOW okunur, ! ile 1 yapılır / A pressed button reads LOW, ! turns it into 1
22  bool a = !digitalRead(PIN_A);
23  bool b = !digitalRead(PIN_B);
24
25  bool out[7];
26  out[0] = a && b;      // AND
27  out[1] = a || b;      // OR
28  out[2] = !a;          // NOT A
29  out[3] = !(a && b);   // NAND
30  out[4] = !(a || b);   // NOR
31  out[5] = a != b;      // XOR: girişler farklı mı? / are the inputs different?
32  out[6] = a == b;      // XNOR: girişler aynı mı? / are the inputs equal?
33
34  for (byte i = 0; i < 7; i++) {
35    digitalWrite(LED_PINS[i], out[i] ? HIGH : LOW);
36  }
37
38  // Yalnız girişler değişince yaz / Print only when the inputs change
39  byte inputs = (a << 1) | b;
40  if (inputs != lastInputs) {
41    Serial.print("A=");
42    Serial.print(a);
43    Serial.print(" B=");
44    Serial.print(b);
45    for (byte i = 0; i < 7; i++) {
46      Serial.print("  ");
47      Serial.print(GATE_NAMES[i]);
48      Serial.print('=');
49      Serial.print(out[i]);
50    }
51    Serial.println();
52    lastInputs = inputs;
53  }
54  delay(20);   // basit sıçrama önleme / simple debounce
55}

Mit INPUT_PULLUP liest ein gedrückter Taster LOW, deshalb invertiert der Code den gelesenen Wert mit ! und ein gedrückter Taster wird zur 1. Danach zeigt jede LED das Ergebnis ihres Gatters: 4 UND, 5 ODER, 6 NICHT A, 7 NAND, 8 NOR, 9 XOR und 10 XNOR. Öffnest du den seriellen Monitor mit 9600 Baud, wird bei jeder Tasteränderung die ganze Zeile ausgegeben; hast du alle vier Kombinationen probiert, hast du die Wahrheitstabelle mit eigenen Händen erstellt. Details zur Pull-up-Logik findest du im Artikel Taster am Arduino anschließen.

Wie mächtig Bitoperationen sind, zeigt das zweite Beispiel: Es berechnet die ganze Wahrheitstabelle in wenigen Zeilen. Der Trick: Schreibst du die Spalte A als Zahl 0b1100 und die Spalte B als 0b1010, entspricht jedes Bit einer Zeile der Tabelle, und ein einziges & liefert alle vier Zeilen der UND-Spalte auf einmal. Die zweite Hälfte des Sketches addiert zwei 4-Bit-Zahlen Bit für Bit mit den Formeln des Volladdierers und ahmt so das Addierwerk eines Prozessors in Software nach. Dieser Sketch braucht keine Hardware; öffne einfach den seriellen Monitor.

1// Bit işlemleriyle doğruluk tablosu ve 4 bitlik toplayıcı / Truth tables with bitwise ops and a 4-bit adder
2// Her bit bir satırdır: bit 0 = (A=0, B=0) ... bit 3 = (A=1, B=1) / Each bit is one row: bit 0 = (A=0, B=0) ... bit 3 = (A=1, B=1)
3const byte COL_A = 0b1100;
4const byte COL_B = 0b1010;
5const byte MASK  = 0b1111;   // yalnız 4 satır / only 4 rows
6
7void printRow(const char* name, byte column) {
8  Serial.print(name);
9  Serial.print('\t');
10  for (byte row = 0; row < 4; row++) {
11    Serial.print(bitRead(column, row));   // satır satır yaz / print row by row
12    Serial.print("  ");
13  }
14  Serial.println();
15}
16
17// Tam toplayıcı: iki bit + gelen elde / Full adder: two bits + carry in
18void fullAdder(byte a, byte b, byte carryIn, byte &sum, byte &carryOut) {
19  sum = a ^ b ^ carryIn;                         // XOR'lar toplamı verir / XORs give the sum
20  carryOut = (a & b) | (carryIn & (a ^ b));      // AND + OR eldeyi verir / AND + OR give the carry
21}
22
23// 4 tam toplayıcı zincirlenir (ripple carry) / 4 full adders chained (ripple carry)
24byte add4(byte x, byte y, byte &carryOut) {
25  byte result = 0;
26  byte carry = 0;
27  for (byte i = 0; i < 4; i++) {
28    byte s, c;
29    fullAdder(bitRead(x, i), bitRead(y, i), carry, s, c);
30    bitWrite(result, i, s);
31    carry = c;
32  }
33  carryOut = carry;
34  return result;
35}
36
37void setup() {
38  Serial.begin(9600);
39  Serial.println(F("AB:\t00 01 10 11"));
40  printRow("AND",  COL_A & COL_B);
41  printRow("OR",   COL_A | COL_B);
42  printRow("NAND", ~(COL_A & COL_B) & MASK);   // ~ sonrası maske şart / mask is required after ~
43  printRow("NOR",  ~(COL_A | COL_B) & MASK);
44  printRow("XOR",  COL_A ^ COL_B);
45  printRow("XNOR", ~(COL_A ^ COL_B) & MASK);
46
47  byte carry;
48  byte s = add4(9, 12, carry);   // 1001 + 1100
49  Serial.print(F("9 + 12 = "));
50  Serial.print(s + carry * 16);  // elde 16'lar basamağıdır / the carry is the 16s place
51  Serial.print(F("  (toplam / sum = "));
52  Serial.print(s, BIN);
53  Serial.print(F(", elde / carry = "));
54  Serial.print(carry);
55  Serial.println(')');
56}
57
58void loop() {
59}

Ein 74HC-Testgerät mit dem Arduino

Ist die Beschriftung eines Bausteins abgerieben oder willst du wissen, ob er noch funktioniert, kannst du den Arduino in ein Testgerät verwandeln. Dieser Sketch legt die vier Eingangskombinationen nacheinander an alle vier Gatter eines 74HC00, 74HC08, 74HC32 oder 74HC86 (der Bausteine mit Standardbelegung), liest die Ausgänge und vergleicht das Ergebnis mit bekannten Mustern. Verbinde Pin 14 des Bausteins mit 5V, Pin 7 mit GND und die übrigen Pins gemäß der Tabelle im Code mit den Arduino-Pins.

1// 74HC00 / 08 / 32 / 86 tanıyıcı ve test cihazı / 74HC00 / 08 / 32 / 86 identifier and tester
2// Entegre: bacak 14 -> 5V, bacak 7 -> GND / Chip: pin 14 -> 5V, pin 7 -> GND
3// Her kapı: {A, B, Y} Arduino pinleri / Each gate: {A, B, Y} Arduino pins
4const byte GATES[4][3] = {
5  {2, 3, 4},      // kapı 1: entegre 1, 2 -> 3 / gate 1: chip 1, 2 -> 3
6  {5, 6, 7},      // kapı 2: entegre 4, 5 -> 6 / gate 2: chip 4, 5 -> 6
7  {8, 9, 10},     // kapı 3: entegre 9, 10 -> 8 / gate 3: chip 9, 10 -> 8
8  {11, 12, A0}    // kapı 4: entegre 12, 13 -> 11 / gate 4: chip 12, 13 -> 11
9};
10
11// Desenin bit sırası: bit 0 = (0,0), bit 3 = (1,1) / Pattern bit order: bit 0 = (0,0), bit 3 = (1,1)
12const char* nameOf(byte pattern) {
13  switch (pattern) {
14    case 0b1000: return "AND (74HC08)";
15    case 0b1110: return "OR (74HC32)";
16    case 0b0111: return "NAND (74HC00)";
17    case 0b0110: return "XOR (74HC86)";
18    default:     return "?";
19  }
20}
21
22byte testGate(byte g) {
23  byte pattern = 0;
24  for (byte row = 0; row < 4; row++) {
25    digitalWrite(GATES[g][0], bitRead(row, 1));   // A = satırın üst biti / A = high bit of the row
26    digitalWrite(GATES[g][1], bitRead(row, 0));   // B = satırın alt biti / B = low bit of the row
27    delayMicroseconds(10);                        // kapı ~10 ns gecikir, bol pay / the gate needs ~10 ns, plenty of margin
28    bitWrite(pattern, row, digitalRead(GATES[g][2]));
29  }
30  return pattern;
31}
32
33void setup() {
34  Serial.begin(9600);
35  for (byte g = 0; g < 4; g++) {
36    pinMode(GATES[g][0], OUTPUT);
37    pinMode(GATES[g][1], OUTPUT);
38    pinMode(GATES[g][2], INPUT);
39  }
40
41  byte first = testGate(0);
42  bool allSame = true;
43  for (byte g = 0; g < 4; g++) {
44    byte p = testGate(g);
45    Serial.print(F("Kapi / Gate "));
46    Serial.print(g + 1);
47    Serial.print(F(": "));
48    Serial.print(nameOf(p));
49    Serial.print(F("  desen / pattern 0b"));
50    Serial.println(p, BIN);
51    if (p != first) allSame = false;
52  }
53
54  if (allSame && nameOf(first)[0] != '?') {
55    Serial.println(F("Sonuc / Result: entegre saglam / chip OK"));
56  } else {
57    Serial.println(F("Sonuc / Result: bozuk kapi ya da baglanti hatasi / faulty gate or wiring error"));
58  }
59}
60
61void loop() {
62}

Ein programmierbares Logikgatter mit dem ESP32

Auf dem ESP32 funktionieren dieselben Operatoren unverändert. In diesem Beispiel schaltet ein dritter Taster der Reihe nach durch die Gattertypen, und eine einzige LED zeigt den Ausgang des gewählten Gatters. So kannst du im Unterricht oder bei einer Präsentation sechs Gatter mit einer einzigen Schaltung vorführen. Die Taster kommen an GPIO 25, 26 und 27 (die andere Seite an GND), die LED über einen 220-Ω-Widerstand an GPIO 23; der Name des gewählten Gatters erscheint im seriellen Monitor mit 115200 Baud.

1// ESP32 programlanabilir mantık kapısı / ESP32 programmable logic gate
2const int PIN_A = 25;      // A butonu, diğer ucu GND / button A, other leg to GND
3const int PIN_B = 26;      // B butonu / button B
4const int PIN_MODE = 27;   // kapı seçme butonu / gate select button
5const int PIN_LED = 23;    // çıkış LED'i (220 ohm) / output LED (220 ohm)
6
7const char* const NAMES[] = {"AND", "OR", "NAND", "NOR", "XOR", "XNOR"};
8const int GATE_COUNT = 6;
9const unsigned long DEBOUNCE_MS = 30;   // sıçrama süresi / bounce time
10
11int gate = 0;
12int modeStable = HIGH;            // kararlı buton durumu / stable button state
13int modeRaw = HIGH;               // son ham okuma / last raw reading
14unsigned long modeChangedAt = 0;  // ham değerin son değiştiği an / when the raw value last changed
15
16bool evaluate(int g, bool a, bool b) {
17  switch (g) {
18    case 0:  return a && b;
19    case 1:  return a || b;
20    case 2:  return !(a && b);
21    case 3:  return !(a || b);
22    case 4:  return a != b;     // XOR
23    default: return a == b;     // XNOR
24  }
25}
26
27void setup() {
28  Serial.begin(115200);
29  pinMode(PIN_A, INPUT_PULLUP);
30  pinMode(PIN_B, INPUT_PULLUP);
31  pinMode(PIN_MODE, INPUT_PULLUP);
32  pinMode(PIN_LED, OUTPUT);
33  Serial.printf("Kapi / Gate: %s\n", NAMES[gate]);
34}
35
36void loop() {
37  int reading = digitalRead(PIN_MODE);
38  if (reading != modeRaw) {          // ham değer değişti, süreyi yeniden başlat / raw value changed, restart the timer
39    modeRaw = reading;
40    modeChangedAt = millis();
41  }
42  // 30 ms boyunca sabit kaldıysa gerçek değişimdir / steady for 30 ms means a real change
43  if (millis() - modeChangedAt > DEBOUNCE_MS && reading != modeStable) {
44    modeStable = reading;
45    if (modeStable == LOW) {         // yeni basış (bırakma sayılmaz) / new press (release is ignored)
46      gate = (gate + 1) % GATE_COUNT;
47      Serial.printf("Kapi / Gate: %s\n", NAMES[gate]);
48    }
49  }
50
51  bool a = !digitalRead(PIN_A);   // basılı = 1 / pressed = 1
52  bool b = !digitalRead(PIN_B);
53  digitalWrite(PIN_LED, evaluate(gate, a, b) ? HIGH : LOW);
54}

Logikgatter mit dem Raspberry Pi Pico und MicroPython

In MicroPython schreibt man die logischen Operatoren als englische Wörter: and, or, not. Die bitweisen Operatoren sind dieselben wie in C++: &, |, ^ und ~. Der folgende Code liest zwei Taster an GP14 und GP15 und zeigt die Ergebnisse von UND, ODER, NAND, NOR, XOR und XNOR auf sechs LEDs an GP16–GP21. Die andere Seite jedes Tasters kommt an GND, jede LED wird über einen Widerstand von 220–330 Ω angeschlossen. Speicherst du den Code in Thonny als main.py, startet er bei jedem Einschalten des Pico; bist du neu beim Pico, beginne mit Was ist der Raspberry Pi Pico?.

1# Pico ile 6 mantık kapısı / 6 logic gates on the Pico
2from machine import Pin
3import time
4
5btn_a = Pin(14, Pin.IN, Pin.PULL_UP)   # A butonu, diğer ucu GND / button A, other leg to GND
6btn_b = Pin(15, Pin.IN, Pin.PULL_UP)   # B butonu / button B
7
8# GP16..GP21: AND, OR, NAND, NOR, XOR, XNOR
9leds = [Pin(n, Pin.OUT) for n in range(16, 22)]
10gates = [
11    ("AND",  lambda a, b: a and b),
12    ("OR",   lambda a, b: a or b),
13    ("NAND", lambda a, b: not (a and b)),
14    ("NOR",  lambda a, b: not (a or b)),
15    ("XOR",  lambda a, b: a != b),
16    ("XNOR", lambda a, b: a == b),
17]
18
19last = None
20while True:
21    a = int(not btn_a.value())   # basılı = 1 / pressed = 1
22    b = int(not btn_b.value())
23    results = [int(f(a, b)) for _, f in gates]
24    for led, r in zip(leds, results):
25        led.value(r)
26    if (a, b) != last:           # yalnız değişince yaz / print only on change
27        line = " ".join("%s=%d" % (g[0], r) for g, r in zip(gates, results))
28        print("A=%d B=%d  %s" % (a, b, line))
29        last = (a, b)
30    time.sleep_ms(20)

Auch Python hat eine ähnliche Falle: ~True ergibt -2, weil bool eigentlich eine Ganzzahl ist. Um ein Bit umzudrehen, nimm not x, 1 - x oder x ^ 1. Außerdem geben die Python-Operatoren and und or nicht immer True oder False zurück, sondern den zuletzt ausgewerteten Wert: 0 or 5 ergibt 5. Deshalb verwendet der Code int()-Umwandlungen, damit die LEDs immer nur 0 oder 1 erhalten.

Projektideen mit Logikgattern

• Intelligentes Nachtlicht (UND): Schalte das Licht ein, wenn es dunkel ist UND eine Bewegung erkannt wird; verknüpfe einen LDR und einen PIR-Sensor in einer einzigen &&-Bedingung.
• Treppenlicht (XOR): Steuere eine Lampe mit zwei Tastern unten und oben an der Treppe; berechne den Lampenzustand mit XOR und schalte die 230-V-Lampe über ein Relaismodul.
• Alarmanlage (UND + ODER): Ist die Anlage scharf, löst die Sirene aus, wenn die Tür ODER das Fenster geöffnet wird. Erkenne Tür und Fenster mit einem Reedkontakt; Details findest du in der Anleitung Arduino-Alarmanlage.
• Tresor mit zwei Schlüsseln (UND): Das Schloss öffnet nur, wenn zwei verschiedene Personen gleichzeitig ihren Taster drücken oder der Code am Keypad bestätigt ist.
• 4-Bit-Rechner: Addiere zwei mit Schaltern eingegebene Zahlen mit der Logik des Volladdierers und zeige das Ergebnis auf einer 7-Segment-Anzeige.
• Quiz-Buzzer: Halte die LED des Teilnehmers fest, der zuerst drückt, und sperre die anderen; das ist die Softwareversion eines Latches aus NAND-Gattern.
• Paritätsprüfung: Verknüpfe alle Bits eines Bytes mit XOR; ist das Ergebnis 1, ist die Anzahl der Einsen ungerade. Das Paritätsbit bei der seriellen Übertragung wird genau so berechnet.

Häufige Fehler und ihre Lösungen

Logikgatter sind das Alphabet der gesamten Digitalwelt, vom Einschalten einer LED bis zur Addition im Prozessor. Hast du UND, ODER und NICHT verstanden, kannst du eine if-Bedingung, eine Alarmregel oder ein Schieberegister viel leichter lesen. In der BlueGrays-App findest du Projekte zum Schalten einer LED per Taster, Tasterprojekte für ESP32 und Raspberry Pi Pico, eine intelligente Treppenhausbeleuchtung und eine Lichtsteuerung, die PIR und LDR kombiniert, jeweils mit Schaltplänen und Code Schritt für Schritt, damit du die Gatterlogik aus diesem Artikel in echten Projekten einsetzen kannst.