Logische poorten uitgelegd: waarheidstabellen van AND, OR, NOT en XOR, en Arduino
Wat zijn logische poorten? Symbolen en waarheidstabellen van AND, OR, NOT, NAND, NOR, XOR en XNOR, de chips 74HC08 en 74HC00, een halve opteller en code voor Arduino, ESP32 en Pico.
Logische poorten zijn de basisbouwstenen van digitale schakelingen: elke poort kijkt naar een of meer digitale ingangen en geeft volgens een vaste regel één digitale uitgang. De ingangen kunnen alleen 0 (LOW) of 1 (HIGH) zijn, en de uitgang ook. Er zijn zeven basispoorten: AND, OR, NOT, NAND, NOR, XOR en XNOR. Van de processor in je telefoon tot het besturingsboard van een wasmachine, van de ATmega328P in een Arduino tot een zakrekenmachine: elk digitaal apparaat werkt door miljoenen kleine logische poorten te combineren.
In deze gids leer je het symbool en de waarheidstabel van elke poort, echte chips zoals de 74HC08, 74HC32 en 74HC00, een breadboardexperiment met twee drukknoppen, hoe je alle andere poorten alleen uit NAND bouwt en de schakeling van de halve opteller die twee bits optelt. In de laatste delen zetten we dezelfde logica om in code op de Arduino met de operatoren &&, || en ! en met bitsgewijze bewerkingen, en gaan we verder met voorbeelden voor ESP32 en Raspberry Pi Pico (MicroPython).

Wat is een logische poort en hoe werkt die?
In de digitale elektronica heeft elk signaal een van twee toestanden: 1 (HIGH, waar) of 0 (LOW, onwaar). De wiskunde voor het werken met deze twee waarden heet Booleaanse algebra; in een boek uit 1854 beschreef George Boole logisch redeneren op precies deze manier als algebra. In 1937 toonde Claude Shannon aan dat deze algebra één op één past op schakelingen van relais, waarmee hij de basis legde voor het ontwerpen van digitale schakelingen. Tegenwoordig bestaat een logische poort uit maar een handvol transistors: in CMOS-technologie bestaat een NOT-poort uit 2 MOSFET's en een NAND-poort uit 4. Hoe een transistor als schakelaar werkt, leggen we uit in Wat is een transistor?.
Welke spanning noemt een schakeling dan 1 en welke 0? Dat hangt af van de voedingsspanning van het board en de chipfamilie. De tabel hieronder toont de grenzen waarbij een ingang gegarandeerd als 1 of als 0 telt. Het gebied tussen de twee grenzen is het ongedefinieerde gebied; blijft een ingang daar hangen, dan kan de uitgang willekeurig reageren. Een ingang die nergens op is aangesloten, een zwevende (floating) ingang, dwaalt precies in dit ongedefinieerde gebied rond. Daarom moet elke ingang aan een signaal of via een weerstand aan GND of VCC worden gelegd.
| Board / familie | Voeding | Ingang telt gegarandeerd als 1 | Ingang telt gegarandeerd als 0 |
|---|---|---|---|
| Arduino Uno (ATmega328P) | 5 V | ≥ 3,0 V | ≤ 1,5 V |
| ESP32 | 3,3 V | ≥ 2,5 V | ≤ 0,8 V |
| Raspberry Pi Pico (RP2040) | 3,3 V | ≥ 2,0 V | ≤ 0,8 V |
| 74HC-chip | 5 V | ≥ 3,5 V | ≤ 1,5 V |
| 74HCT-chip | 5 V | ≥ 2,0 V | ≤ 0,8 V |
| CD4000-chip | 5 V | ≥ 3,5 V | ≤ 1,5 V |
De 7 basispoorten en hun symbolen
In schema's worden poorten volgens twee verschillende standaarden getekend. In de Amerikaanse standaard (ANSI/IEEE) heeft elke poort een eigen vorm: AND lijkt op de letter D, OR op een puntig schild en NOT op een driehoek. Het kleine cirkeltje (bubble) bij de uitgang betekent "inverteren"; een NAND is eigenlijk een AND met een cirkeltje aan de punt. Wat XOR van OR onderscheidt, is de tweede gebogen lijn aan de ingangszijde. In de Europese standaard (IEC) zijn alle poorten rechthoeken, die je herkent aan het teken erin: & voor AND, ≥1 voor OR, =1 voor XOR en 1 voor NOT. In leerboeken zie je NAND ook geschreven als NOT-AND, NOR als NOT-OR, XOR als exclusieve OR en XNOR als exclusieve NOR.
| Poort | Ook genoemd | ANSI-symbool | IEC-teken | Booleaanse uitdrukking | Wanneer is de uitgang 1? |
|---|---|---|---|---|---|
| AND | Conjunctie | D-vorm | & | Y = A · B | Beide ingangen zijn 1 |
| OR | Disjunctie | Puntig schild | ≥1 | Y = A + B | Minstens één ingang is 1 |
| NOT | Inverter | Driehoek + cirkeltje | 1 (cirkeltje bij de uitgang) | Y = A' | De ingang is 0 |
| NAND | NOT-AND | D-vorm + cirkeltje | & (cirkeltje bij de uitgang) | Y = (A · B)' | Minstens één ingang is 0 |
| NOR | NOT-OR | Schild + cirkeltje | ≥1 (cirkeltje bij de uitgang) | Y = (A + B)' | Beide ingangen zijn 0 |
| XOR | Exclusieve OR | Schild met dubbele boog | =1 | Y = A ⊕ B | De ingangen verschillen |
| XNOR | Exclusieve NOR | Dubbele boog + cirkeltje | =1 (cirkeltje bij de uitgang) | Y = (A ⊕ B)' | De ingangen zijn gelijk |
Waarheidstabellen van logische poorten
Een waarheidstabel toont de uitgang die een poort geeft bij elke combinatie van ingangen. Een poort met n ingangen heeft 2ⁿ rijen: 4 rijen bij twee ingangen, 8 bij drie en 16 bij vier. Als je de rijen in binaire telvolgorde schrijft (00, 01, 10, 11), sla je nooit een combinatie over. Hier zijn alle zes poorten met twee ingangen in één tabel:
| A | B | AND | OR | NAND | NOR | XOR | XNOR |
|---|---|---|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 1 | 1 | 0 | 1 |
| 0 | 1 | 0 | 1 | 1 | 0 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 | 0 | 1 | 0 |
| 1 | 1 | 1 | 1 | 0 | 0 | 0 | 1 |
Omdat de NOT-poort maar één ingang heeft, heeft zijn tabel twee rijen: bij A = 0 is de uitgang 1 en bij A = 1 is de uitgang 0. Kijk goed naar de tabel en je ziet een patroon: de NAND-kolom is het exacte tegenovergestelde van AND, NOR van OR en XNOR van XOR. Om ze te onthouden gebruik je deze korte regels: AND vraagt "zijn ze allemaal 1?", OR vraagt "is er minstens één 1?", XOR vraagt "verschillen de ingangen?"; een poort waarvan de naam met N begint, geeft het tegengestelde antwoord op dezelfde vraag. Wil je de poorten zelf uitproberen en de symbolen live zien, tik dan in de tool Logische poorten op de ingangen A en B.
- AND: Twee schakelaars in serie. De lamp brandt alleen als beide schakelaars gesloten zijn; een bankkluis die met twee aparte sleutels opengaat, volgt ook de AND-regel.
- OR: Twee drukknoppen parallel. Dezelfde bel gaat over, of iemand nu bij de voordeur of bij de achterdeur op de knop drukt.
- NOT: Een koelkastlampje. Zolang de deur dicht is, wordt de schakelaar ingedrukt gehouden en is de lamp uit; als de deur opengaat, komt de schakelaar los en gaat de lamp aan.
- NAND: De regel "waarschuw tenzij alles in orde is". Als zelfs maar één van de twee veiligheidskappen van een machine openstaat, gaat het waarschuwingslampje aan.
- NOR: De regel "geen van beide is gebeurd". Een groene "alles veilig"-lamp die alleen brandt als er geen rook en geen gas wordt gedetecteerd.
- XOR: Wisselschakelaars voor een trapverlichting. Door de onderste of de bovenste schakelaar om te zetten, verandert de toestand van de lamp; de lamp is aan als de twee schakelaars in verschillende standen staan en uit als ze gelijk staan.
- XNOR: Een gelijkheidscontrole. De uitgang is 1 als twee bits gelijk zijn; het wordt gebruikt in digitale comparatoren en schakelingen voor foutcontrole.
IC's met logische poorten: 74HC08, 74HC32, 74HC00
In plaats van logische poorten uit losse transistors te bouwen, gebruik je kant-en-klare chips. De meest gebruikte familie in de hobbyelektronica is de 74HC-serie: een DIP-behuizing met 14 pinnen bevat vier poorten met twee ingangen; de voeding gaat altijd naar pin 14 (VCC) en de massa naar pin 7 (GND). 74HC-chips werken op 2 tot 6 V, hun ingangen nemen bijna geen stroom op en bij 5 V heeft één poort een vertraging van ongeveer 10 nanoseconden, honderden keren sneller dan één digitalWrite-aanroep op de Arduino. Elke uitgang houdt zijn gegarandeerde spanningsniveaus aan bij een belasting van 4 mA; de absolute limiet is 25 mA per uitgang en 50 mA voor de hele chip.
| Chip | Poort | Bevat | Pinout | CMOS 4000-equivalent |
|---|---|---|---|---|
| 74HC08 | AND | 4 × 2 ingangen | Standaard (tabel hieronder) | CD4081 |
| 74HC32 | OR | 4 × 2 ingangen | Standaard | CD4071 |
| 74HC00 | NAND | 4 × 2 ingangen | Standaard | CD4011 |
| 74HC86 | XOR | 4 × 2 ingangen | Standaard | CD4070 |
| 74HC02 | NOR | 4 × 2 ingangen | Anders: uitgangen op 1, 4, 10, 13 | CD4001 |
| 74HC04 | NOT | 6 × 1 ingang | Ingangen op 1, 3, 5, 9, 11, 13 | CD4069 |
| 74HC14 | NOT (schmitttrigger) | 6 × 1 ingang | Zelfde als 74HC04 | CD40106 |
| CD4077 / 74HCS7266 | XNOR | 4 × 2 ingangen | Moeilijk te vinden; meestal 74HC86 + 74HC04 | CD4077 |
De 74HC08, 74HC32, 74HC00 en 74HC86 hebben precies dezelfde pinout; alleen het type poort erin verschilt. De inkeping of stip bovenop de chip markeert pin 1. Als je de chip van boven bekijkt met de inkeping links, zijn de pinnen tegen de klok in genummerd: de onderste rij loopt van links naar rechts van 1 tot 7 en de bovenste rij van rechts naar links van 8 tot 14. A en B zijn ingangen, Y is de uitgang en het cijfer ervoor is het nummer van de poort.
| Pin | Functie | Pin | Functie |
|---|---|---|---|
| 1 | 1A (ingang poort 1) | 14 | VCC (+2…6 V) |
| 2 | 1B (ingang poort 1) | 13 | 4B (ingang poort 4) |
| 3 | 1Y (uitgang poort 1) | 12 | 4A (ingang poort 4) |
| 4 | 2A (ingang poort 2) | 11 | 4Y (uitgang poort 4) |
| 5 | 2B (ingang poort 2) | 10 | 3B (ingang poort 3) |
| 6 | 2Y (uitgang poort 2) | 9 | 3A (ingang poort 3) |
| 7 | GND | 8 | 3Y (uitgang poort 3) |
Chips die hetzelfde werk doen, bestaan in verschillende families. De 74LS-serie is oudere TTL-technologie: die werkt alleen op 4,75–5,25 V, neemt meer stroom op en leest een zwevende ingang meestal als 1. De 74HCT-serie is een 74HC met TTL-compatibele ingangen; die werkt op 5 V maar accepteert alles vanaf 2 V als gegarandeerde 1, dus 3,3 V-signalen van een ESP32 of Pico leest hij zonder problemen. De CD4000-serie (CD4081, CD4011 enzovoort) werkt over een breed bereik van 3–18 V maar is langzamer en heeft een andere pinout dan de 74HC: een CD4011 kan niet zomaar een 74HC00 vervangen.
Breadboardexperiment met drukknoppen: een AND-poort met de 74HC08
De beste manier om een logische poort te begrijpen, is hem zelf uitproberen met twee drukknoppen. In dit experiment zit geen microcontroller; je hebt alleen een 74HC08, twee drukknoppen, twee weerstanden van 10 kΩ, een weerstand van 1 kΩ, een led en een condensator van 100 nF nodig. Voor de voeding zijn de 5V- en GND-pinnen van de Arduino, een voedingsmodule voor het breadboard of drie AA-batterijen (4,5 V) allemaal prima. Weet je niet zeker hoe een breadboard van binnen is doorverbonden, lees dan eerst Wat is een breadboard?

- Plaats de 74HC08 over de sleuf in het midden van het breadboard zodat de pinnen aan weerszijden zitten, met de inkeping naar links.
- Verbind pin 14 met de +-rail (5 V) en pin 7 met de −-rail (GND), en plaats de condensator van 100 nF tussen deze twee pinnen.
- Verbind één kant van knop A met de +-rail en de andere kant met pin 1. Voeg vanaf dezelfde pin een weerstand van 10 kΩ naar GND toe: deze pull-downweerstand houdt de ingang stevig op 0 zolang de knop niet is ingedrukt.
- Sluit knop B op dezelfde manier aan op pin 2 en geef hem een eigen pull-downweerstand van 10 kΩ.
- Ga vanaf pin 3, de uitgang, via een weerstand van 1 kΩ naar het lange pootje (anode) van de led; verbind het korte pootje (kathode) van de led met GND.
- Leg de ongebruikte ingangen, pinnen 4, 5, 9, 10, 12 en 13, aan GND; laat de uitgangen 6, 8 en 11 open.
- Zet de voeding aan en probeer de vier combinaties na elkaar: de led hoort alleen te branden als je beide knoppen tegelijk indrukt. Vergelijk de resultaten met de waarheidstabel.
| Verbinding | 74HC08-pin | Verbinden met |
|---|---|---|
| Voeding | 14 (VCC) | +-rail, 5 V |
| Massa | 7 (GND) | −-rail |
| Ontkoppelcondensator | Tussen 14 en 7 | 100 nF keramisch, dicht bij de chip |
| Ingang A | 1 | Knop A → 5 V, 10 kΩ → GND |
| Ingang B | 2 | Knop B → 5 V, 10 kΩ → GND |
| Uitgang | 3 | 1 kΩ → anode van de led, kathode van de led → GND |
| Ongebruikte ingangen | 4, 5, 9, 10, 12, 13 | GND |
| Ongebruikte uitgangen | 6, 8, 11 | Open |
Elke poort bouwen uit NAND: de universele poort
NAND heet een universele poort omdat je elke andere poort kunt bouwen met alleen NAND-poorten. Dit heeft ook een praktische kant: in CMOS-technologie is NAND een van de eenvoudigste poorten, met maar 4 transistors, terwijl een AND eigenlijk een NAND gevolgd door een NOT is en er 6 nodig heeft. Daarom houden chipontwerpers van NAND. NAND-flash in USB-sticks dankt zijn naam ook aan de manier waarop de geheugencellen in serie zijn geschakeld, net als de transistors in een NAND-poort. NOR is ook universeel: de Apollo Guidance Computer die naar de maan vloog, was gebouwd uit ongeveer 2.800 chips, elk met twee NOR-poorten met drie ingangen.
| Te bouwen poort | Hoe met NAND? | Benodigde NAND's |
|---|---|---|
| NOT | A NAND A (verbind beide ingangen met elkaar) | 1 |
| AND | Stuur de uitgang van (A NAND B) door een NOT | 2 |
| OR | (A NAND A) NAND (B NAND B) | 3 |
| NOR | OR + NOT | 4 |
| XOR | N1 = A NAND B; (A NAND N1) NAND (B NAND N1) | 4 |
| XNOR | XOR + NOT | 5 |
De OR-rij van de tabel berust op de wet van De Morgan: (A' · B')' = A + B. Met andere woorden: als je eerst beide ingangen inverteert en ze dan in een NAND voert, krijg je een OR. De tweede wet van De Morgan is (A + B)' = A' · B'. Beide wetten helpen ook om voorwaarden in code te vereenvoudigen: op de Arduino geeft !(a && b) altijd hetzelfde resultaat als (!a || !b), en !(a || b) hetzelfde als (!a && !b).
Een XOR bouwen uit vier NAND-poorten is een klassieke examen- en practicumopdracht, en de vier poorten in één 74HC00 zijn precies genoeg. Eerst wordt N1 = A NAND B berekend. Dan worden N2 = A NAND N1 en N3 = B NAND N1 bepaald, en de uitgang van de laatste poort, Y = N2 NAND N3, geeft XOR. Met de bedrading hieronder verander je je breadboardexperiment in een XOR van vier NAND's:
| 74HC00-pin | Verbinding | Functie |
|---|---|---|
| 1 en 4 | Knop A | Ingang A (poorten 1 en 2) |
| 2 en 10 | Knop B | Ingang B (poorten 1 en 3) |
| 3 → 5 en 9 | Jumperdraad | N1 = A NAND B |
| 6 → 12 | Jumperdraad | N2 = A NAND N1 |
| 8 → 13 | Jumperdraad | N3 = B NAND N1 |
| 11 | 1 kΩ + LED | Y = A XOR B |
| 14 / 7 | 5 V / GND | Voeding |
Laten we nog een stap verder gaan: als je de uitgangen van twee NAND-poorten kruiselings met elkaars ingangen verbindt, krijg je een geheugen van 1 bit, een SR-latch genoemd. Deze schakeling onthoudt haar laatste toestand ook nadat je de knop loslaat. De registers in processors, tellers en chips als het 74HC595-schuifregister worden gemaakt door zulke geheugencellen, opgebouwd uit poorten, aan elkaar te schakelen.
De halve opteller: twee bits optellen met poorten
Het indrukwekkendste wat logische poorten kunnen, is getallen optellen. In binair geldt 0 + 0 = 0, 0 + 1 = 1, 1 + 0 = 1 en 1 + 1 = 10 (2 in decimaal). Het rechtercijfer van het resultaat heet de som (sum) en het cijfer dat naar links overloopt de carry (overdracht). In de tabel hieronder zie je dat de som precies XOR is en de carry precies AND. Een XOR-poort en een AND-poort naast elkaar vormen dus een halve opteller die twee getallen van één bit optelt.
| A | B | Carry (C = A AND B) | Som (S = A XOR B) | Decimaal resultaat |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 0 | 0 | 1 | 1 |
| 1 | 1 | 1 | 0 | 2 (binair 10) |
Om hem op een breadboard te bouwen, verbind je de knoppen A en B met de pinnen 1 en 2 van zowel een 74HC86 als een 74HC08. Pin 3 van de 74HC86 stuurt de somled aan en pin 3 van de 74HC08 de carryled. Als je beide knoppen indrukt, gaat de somled uit en de carryled aan: de leds tonen binair 10, dat is 2. Wil je alleen een 74HC00 gebruiken, dan heb je vier NAND's nodig voor de XOR en een vijfde NAND die N1 inverteert voor de carry; een halve opteller kost dus 5 NAND-poorten.
Een halve opteller kan geen rekening houden met een carry van het cijfer eronder; daarvoor heb je een volledige opteller nodig. De formules zijn S = A ⊕ B ⊕ Cin en Cout = (A · B) + (Cin · (A ⊕ B)), dus twee halve optellers plus een OR-poort. Schakel vier volledige optellers achter elkaar zodat elk zijn carry aan de volgende doorgeeft, en je hebt een 4-bitsopteller; de kant-en-klare chip 74HC283 doet dezelfde 4-bitsoptelling, maar berekent de carry's met een snelle interne schakeling (carry look-ahead) in plaats van te wachten tot ze door de keten rollen. De rekeneenheid van de processor in je computer is een 64-bits, veel snellere versie van hetzelfde idee.
Logische poorten op de Arduino: &&, ||, ! en bitsgewijze bewerkingen
In Arduino-code heeft elke logische poort twee tegenhangers. Logische operatoren (&&, ||, !) combineren voorwaarden en geven true of false als resultaat; je gebruikt ze in if- en while-statements. Bitsgewijze operatoren (&, |, ^, ~) werken op alle bits van een getal tegelijk, kolom voor kolom; werken op een byte is als acht poorten tegelijk laten draaien. De voorbeelden in de tabel gebruiken de getallen 0b1100 en 0b1010:
| Poort | Logisch (bool) | Bitsgewijs | Voorbeeld | Resultaat |
|---|---|---|---|---|
| AND | a && b | x & y | 0b1100 & 0b1010 | 0b1000 |
| OR | a || b | x | y | 0b1100 | 0b1010 | 0b1110 |
| NOT | !a | ~x | ~0b00001100 (byte) | 0b11110011 |
| NAND | !(a && b) | ~(x & y) | ~(0b1100 & 0b1010) & 0x0F | 0b0111 |
| NOR | !(a || b) | ~(x | y) | ~(0b1100 | 0b1010) & 0x0F | 0b0001 |
| XOR | a != b | x ^ y | 0b1100 ^ 0b1010 | 0b0110 |
| XNOR | a == b | ~(x ^ y) | ~(0b1100 ^ 0b1010) & 0x0F | 0b1001 |
Het verschil tussen de twee soorten lijkt klein maar veroorzaakt venijnige bugs. && en || gebruiken verkorte evaluatie (short-circuit): bij a && b wordt b nooit geëvalueerd als a false is. & evalueert altijd beide kanten en kijkt naar de bits van de getallen: 2 && 1 is true, maar 2 & 1 is 0, omdat 0b10 en 0b01 geen bit gemeen hebben. C++ heeft geen aparte logische XOR-operator; voor twee bools is a != b schrijven de leesbaarste manier. Meer over bitsgewijze bewerkingen, de verschuivingen << en >> en het binaire talstelsel vind je in Talstelsels en bitsgewijze bewerkingen.
Laten we het breadboardexperiment nu naar een Arduino Uno verplaatsen. Twee drukknoppen gaan naar pin 2 en 3, en zeven leds (elk met een weerstand van 330 Ω) naar pin 4–10. Eén kant van elke knop gaat naar de pin en de andere naar GND; omdat de interne pull-upweerstand is ingeschakeld, is geen extra weerstand nodig. Eén sketch laat alle zeven poorten tegelijk tot leven komen:
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}Met INPUT_PULLUP leest een ingedrukte knop LOW, dus de code inverteert de meting met ! zodat een ingedrukte knop 1 wordt. Elke led toont dan het resultaat van zijn eigen poort: 4 AND, 5 OR, 6 NOT A, 7 NAND, 8 NOR, 9 XOR en 10 XNOR. Open je de Serial Monitor op 9600 baud, dan wordt de hele regel afgedrukt zodra een knop verandert; als je alle vier de combinaties hebt geprobeerd, heb je de waarheidstabel met je eigen handen gemaakt. De details over pull-up staan in Een drukknop aansluiten op Arduino.
Om de kracht van bitsgewijze bewerkingen te zien, rekent het tweede voorbeeld de hele waarheidstabel uit in een paar regels. De truc: als je kolom A schrijft als het getal 0b1100 en kolom B als 0b1010, hoort elke bit bij één rij van de tabel, en met één & krijg je alle vier de rijen van de AND-kolom tegelijk. In de tweede helft van de sketch worden twee 4-bitsgetallen bit voor bit opgeteld met de formules van de volledige opteller, waarmee de optelschakeling van een processor in software wordt nagebootst. Deze sketch heeft geen hardware nodig; open gewoon de Serial 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}Een 74HC-chiptester met Arduino
Als de opdruk op een chip is weggesleten, of je wilt weten of hij nog werkt, kun je de Arduino in een tester veranderen. Deze sketch legt de vier ingangscombinaties na elkaar aan alle vier de poorten van een 74HC00, 74HC08, 74HC32 of 74HC86 (de chips met de standaard pinout), leest de uitgangen en vergelijkt het resultaat met bekende patronen. Verbind pin 14 van de chip met 5V, pin 7 met GND en de andere pinnen met de Arduino-pinnen uit de tabel in de code.
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}Een programmeerbare logische poort met de ESP32
Dezelfde operatoren werken ongewijzigd op de ESP32. In dit voorbeeld stapt een derde knop door de poorttypen en toont één led de uitgang van de gekozen poort. Zo kun je in een klaslokaal of tijdens een presentatie zes poorten met één schakeling demonstreren. De knoppen gaan naar GPIO 25, 26 en 27 (hun andere kanten naar GND) en de led gaat via een weerstand van 220 Ω naar GPIO 23; de naam van de gekozen poort verschijnt in de Serial Monitor op 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}Logische poorten met de Raspberry Pi Pico en MicroPython
In MicroPython worden de logische operatoren als Engelse woorden geschreven: and, or, not. De bitsgewijze operatoren zijn hetzelfde als in C++: &, |, ^ en ~. De code hieronder leest twee drukknoppen op GP14 en GP15 en toont de resultaten van AND, OR, NAND, NOR, XOR en XNOR op zes leds op GP16–GP21. De andere kant van elke knop gaat naar GND en elke led is via een weerstand van 220–330 Ω aangesloten. Sla je de code in Thonny op als main.py, dan draait hij elke keer dat de Pico stroom krijgt; ben je nieuw met de Pico, begin dan met Wat is de 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)Python heeft een vergelijkbare valkuil: ~True geeft -2, omdat een bool eigenlijk een geheel getal is. Om een bit om te klappen gebruik je not x, 1 - x of x ^ 1. Ook geven de operatoren and en or van Python niet altijd True of False terug; ze geven de laatste waarde terug die ze hebben geëvalueerd, dus 0 or 5 geeft 5. Daarom gebruikt de code int()-conversies, zodat de leds alleen 0 of 1 ontvangen.
Projectideeën met logische poorten
- Slim nachtlampje (AND): Zet het licht aan als het donker is EN er beweging wordt gedetecteerd; combineer een LDR en een PIR-sensor in één &&-voorwaarde.
- Trapverlichting (XOR): Bedien één lamp met twee knoppen onderaan en bovenaan de trap; bepaal de toestand van de lamp met XOR en schakel de netlamp met een relaismodule.
- Huisalarm (AND + OR): Laat de sirene klinken als de deur OF het raam opengaat, zolang het systeem is ingeschakeld. Detecteer de deur en het raam met een reedschakelaar; zie de gids Arduino-alarmsysteem voor details.
- Kluis met twee sleutels (AND): Laat het slot pas opengaan als twee verschillende mensen tegelijk hun knoppen indrukken, of pas als de code van het toetsenbord is gecontroleerd.
- 4-bitsrekenmachine: Tel twee getallen op die met schakelaars zijn ingevoerd met de logica van de volledige opteller en toon het resultaat op een 7-segmentsdisplay.
- Quizbuzzer: Vergrendel de led van de deelnemer die als eerste indrukt en blokkeer de anderen; dit is de softwareversie van een latch op basis van NAND.
- Pariteitscontrole: Voer XOR uit op alle bits van een byte; is het resultaat 1, dan is het aantal enen oneven. De pariteitsbit in seriële communicatie wordt precies zo berekend.
Veelgemaakte fouten en hoe je ze oplost
| Symptoom | Waarschijnlijke oorzaak | Oplossing |
|---|---|---|
| De led knippert vanzelf en verandert als je je hand dichtbij brengt | Zwevende ingang, geen pull-downweerstand | Voeg een pull-down- of pull-upweerstand van 10 kΩ toe aan elke ingang |
| De chip wordt heet | VCC en GND verwisseld, of twee uitgangen aan elkaar verbonden | Pin 14 moet VCC zijn en 7 GND; verbind nooit uitgangen met elkaar |
| Geen enkele poort reageert | Geen voeding, of de chip zit niet over de sleuf | Meet met een multimeter tussen pin 14 en 7 en plaats de chip over de sleuf |
| Verkeerde resultaten met een 74HC02 of CD4011 | De pinout verschilt van die van de 74HC08 | Bedraad hem volgens de pintabel in de datasheet |
| De chip neemt meer stroom op dan hij zou moeten | Ongebruikte ingangen zijn blijven zweven | Leg alle ongebruikte ingangen aan GND |
| Onstabiele resultaten met een ESP32 of Pico | Een 3,3 V-signaal is niet genoeg voor een 74HC op 5 V | Voed de 74HC met 3,3 V of gebruik een 74HCT |
| if (a & b) is onverwacht false | & werkt bitsgewijs; 2 & 1 = 0 | Gebruik && in voorwaarden |
| if (x & 1 == 0) wordt nooit uitgevoerd | == wordt vóór & geëvalueerd | Gebruik haakjes: (x & 1) == 0 |
| Eén druk verandert de poort meerdere keren | Contactdender | Wacht 20–50 ms in software of gebruik een RC-filter + 74HC14 |
Logische poorten zijn het alfabet van de hele digitale wereld, van het laten branden van een led tot een processor die getallen optelt. Als je AND, OR en NOT begrijpt, wordt het lezen van een if-voorwaarde, een alarmregel of een schuifregister veel makkelijker. In de BlueGrays-app vind je ledprojecten met drukknoppen, knopprojecten voor ESP32 en Raspberry Pi Pico, een project voor slimme trapverlichting en een project voor slimme verlichting dat een PIR en een LDR combineert, elk met schakelschema's en code stap voor stap, zodat je de poortlogica uit dit artikel in echte projecten kunt inzetten.
Veelgestelde vragen
Welke soorten logische poorten zijn er en waarvoor worden ze gebruikt?
Er zijn zeven basispoorten: AND, OR, NOT, NAND, NOR, XOR en XNOR. Elke poort kijkt naar ingangen die 0 of 1 zijn en geeft volgens zijn eigen regel één uitgang. Elke digitale schakeling, waaronder processors, geheugens, tellers en rekenmachines, wordt gemaakt door deze poorten te combineren.
Hoe maak je een waarheidstabel?
Bepaal eerst het aantal rijen uit het aantal ingangen: n ingangen hebben 2ⁿ rijen nodig. Schrijf de ingangen in binaire telvolgorde (00, 01, 10, 11) en pas dan de regel van de poort toe op elke rij om de uitgangskolom in te vullen. Bij schakelingen met meerdere poorten maakt een aparte kolom voor elke tussenuitgang het werk makkelijker.
Waarom heet NAND een universele poort?
Omdat je NOT, AND, OR, NOR, XOR en XNOR kunt bouwen met alleen NAND-poorten. Als je bijvoorbeeld de twee ingangen van een NAND aan elkaar verbindt, krijg je NOT, twee NAND's achter elkaar geven AND en vier NAND's geven XOR. De NOR-poort heeft dezelfde eigenschap, dus die telt ook als universele poort.
Wat is het verschil tussen XOR en XNOR?
XOR geeft 1 als de ingangen verschillen, terwijl XNOR 1 geeft als de ingangen gelijk zijn. XNOR is het omgekeerde van XOR en wordt gebruikt om te controleren of twee bits gelijk zijn. XOR wordt gebruikt in optelschakelingen, pariteitscontroles en om een bit om te klappen.
Wat is het verschil tussen de 74HC08 en de 74LS08?
Beide bevatten vier AND-poorten met twee ingangen en hebben dezelfde pinout. De 74HC08 is gemaakt in CMOS-technologie, werkt op 2–6 V en neemt zeer weinig stroom op; de 74LS08 is TTL, werkt alleen rond 5 V en gebruikt meer stroom. Kies voor nieuwe projecten de 74HC, en de 74HCT als je 3,3 V-signalen op een 5V-schakeling aansluit.
Wat is het verschil tussen && en & in Arduino?
&& is de logische AND-operator; hij controleert of beide voorwaarden waar zijn en geeft true of false terug. & is de bitsgewijze AND en vergelijkt elke bit van twee getallen afzonderlijk. Daarom is 2 && 1 true maar 2 & 1 is 0; gebruik && in if-voorwaarden.
Projecten om hierna te bouwen
Alle projecten bekijken
LED aansturen met een drukknop (Push)
Net als een deurbel: het licht blijft aan zolang je indrukt en gaat uit als je loslaat.

LED schakelen met een knop (aan/uit)
Druk één keer op de knop en het licht gaat aan, druk nog een keer en het gaat uit, net als de lichtschakelaar in je kamer. De Arduino merkt elke druk op en zet de led in de tegenovergestelde toestand.

ESP32-ledbesturing met drukknop (Push)
De led brandt zolang je de knop indrukt en gaat uit als je loslaat. Laat zien hoe je de digitale ingangspin en de interne pull-upweerstand van de ESP32 gebruikt. Met de modus INPUT_PULLUP heb je geen externe weerstand nodig.

ESP32-ledbesturing met drukknop (Toggle)
Elke keer dat je op de knop drukt, verandert de led van stand: is hij aan, dan gaat hij uit; is hij uit, dan gaat hij aan. Het klassieke togglepatroon. Met debounce filteren we de mechanische ruis van de drukknop weg, zodat één druk precies één wisseling geeft.

Raspberry Pi Pico: led bedienen met een knop (indrukken)
Het eerste invoerproject met de Pico — een knop uitlezen! De led brandt zolang je de knop indrukt en gaat uit als je loslaat. Dit is de grote stap na de ledanimaties: signalen van buiten naar de Pico. Je leert Pin.IN (invoermodus), Pin.PULL_UP (interne pull-upweerstand — standaard voor knoppen) en button.value() uitlezen. GP14 led, GP2 knop (interne PULL_UP). Ingedrukt = LOW (0), losgelaten = HIGH (1) — die omgekeerde logica lijkt eerst verwarrend, maar is de industriestandaard.

Raspberry Pi Pico: 2 leds onafhankelijk bedienen met 2 knoppen
2 knoppen, 2 leds, volledig onafhankelijk van elkaar! Elke knop bedient zijn eigen led: druk op BTN1 en de rode led gaat branden, druk op BTN2 en de groene gaat branden. Druk je op beide tegelijk, dan branden beide leds (parallelle werking). Je leert meerdere Pin-objecten samen beheren, de ternaire operator, de compacte if-else van Python (1 if x else 0) en een GPIO-overzicht (GP12/13 led-uitgangen, GP4/5 knopingangen).

Slimme trap- en gangverlichting
Stap op de trap of in de gang en de lampjes gaan trede voor trede aan, in de richting waarin je loopt.

ESP32 slimme verlichting (PIR + LDR + relais + OLED)
Met een ESP32, een PIR-bewegingssensor, een LDR-lichtsensor en een relaismodule maak je van je gang, toilet of bijkeuken slimme verlichting. Is het al licht in de ruimte, dan blijft het licht uit, ook bij beweging, zodat overdag geen energie wordt verspild. Het licht blijft 30 seconden aan en de tijd verlengt automatisch zolang er beweging is.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

