Mantık Kapıları: AND, OR, NOT, XOR Doğruluk Tabloları ve Arduino

Mantık kapıları (lojik kapılar), bir ya da daha fazla dijital girişe bakıp belirli bir kurala göre tek bir dijital çıkış üreten temel devre elemanlarıdır. Girişler yalnızca 0 (LOW) ya da 1 (HIGH) olabilir, çıkış da öyle. Yedi temel kapı vardır: AND (VE), OR (VEYA), NOT (DEĞİL), NAND, NOR, XOR ve XNOR. Telefonundaki işlemciden çamaşır makinesinin kartına, Arduino'nun içindeki ATmega328P'den cep hesap makinesine kadar bütün dijital cihazlar, milyonlarca küçük mantık kapısının bir araya gelmesiyle çalışır.

Bu rehberde her kapının sembolünü ve doğruluk tablosunu, 74HC08, 74HC32 ve 74HC00 gibi gerçek entegreleri, iki butonla breadboard üzerinde kuracağın deneyi, yalnızca NAND kapısıyla diğer bütün kapıları kurmayı ve iki biti toplayan yarım toplayıcı devresini öğreneceksin. Son bölümlerde aynı mantığı Arduino'da &&, || ve ! operatörleriyle ve bit işlemleriyle koda dökecek, ardından ESP32 ve Raspberry Pi Pico (MicroPython) örnekleriyle devam edeceğiz.

Mantık kapısı nedir, nasıl çalışır?

Dijital elektronikte her sinyal iki durumdan birindedir: 1 (HIGH, doğru) ya da 0 (LOW, yanlış). Bu iki değerle yapılan işlemlerin matematiğine Boole cebri denir; George Boole 1854'te yayımladığı kitabında mantıksal düşünceyi bu şekilde cebirle ifade etti. 1937'de Claude Shannon, bu cebrin rölelerle kurulan anahtarlama devrelerine birebir uyduğunu gösterdi ve dijital devre tasarımının temeli atıldı. Bugün bir mantık kapısının içinde yalnızca birkaç transistör bulunur: CMOS teknolojisinde bir NOT kapısı 2, bir NAND kapısı 4 MOSFET'ten oluşur. Transistörün anahtar gibi nasıl çalıştığını Transistör Nedir? yazısında anlattık.

Peki devre hangi gerilime 1, hangisine 0 der? Bu, kartın besleme gerilimine ve yonga ailesine bağlıdır. Aşağıdaki tabloda bir girişin kesin olarak 1 ya da kesin olarak 0 sayıldığı sınırları görüyorsun. İki sınır arasındaki bölge belirsiz bölgedir; giriş bu aralıkta kalırsa çıkış rastgele davranabilir. Hiçbir yere bağlı olmayan, yani boşta kalan bir giriş de tam olarak bu belirsiz bölgede dolaşır. Bu yüzden her girişin mutlaka bir sinyale, bir dirençle GND'ye ya da VCC'ye bağlı olması gerekir.

7 temel mantık kapısı ve sembolleri

Devre şemalarında kapılar iki farklı standartla çizilir. Amerikan standardında (ANSI/IEEE) her kapının kendine özgü bir şekli vardır: AND bir D harfine, OR ucu sivri bir kalkana, NOT ise bir üçgene benzer. Çıkıştaki küçük daire (balon) "tersini al" demektir; NAND aslında ucuna balon eklenmiş bir AND'dir. XOR'u OR'dan ayıran şey, giriş tarafındaki ikinci kavisli çizgidir. Avrupa standardında (IEC) ise bütün kapılar dikdörtgendir ve içine yazılan işaretle ayrılır: AND için &, OR için ≥1, XOR için =1, NOT için 1. Türkçe ders kitaplarında bu kapılar VE, VEYA, DEĞİL, VE DEĞİL, VEYA DEĞİL, ÖZEL VEYA ve ÖZEL VEYA DEĞİL adlarıyla da geçer.

Mantık kapıları doğruluk tabloları

Doğruluk tablosu, bir kapının bütün giriş kombinasyonlarında hangi çıkışı verdiğini gösteren listedir. n girişli bir kapının 2ⁿ satırı olur: iki girişte 4, üç girişte 8, dört girişte 16 satır. Satırları ikilik sayma sırasıyla yazarsan (00, 01, 10, 11) hiçbir kombinasyonu atlamazsın. İki girişli altı kapının hepsi tek tabloda:

NOT kapısının tek girişi olduğu için tablosu iki satırdır: A = 0 iken çıkış 1, A = 1 iken çıkış 0. Tabloya dikkatle bakınca bir düzen görürsün: NAND sütunu AND'in, NOR sütunu OR'un, XNOR sütunu da XOR'un tam tersidir. Ezberlemek için şu kısa kuralları kullanabilirsin: AND "hepsi 1 mi?", OR "en az biri 1 mi?", XOR "girişler farklı mı?" sorusunu sorar; adının başında N olan kapı aynı soruya ters cevap verir. Kapıları kendin denemek ve sembolleri canlı görmek için Mantık Kapıları aracında A ve B girişlerine dokunman yeter.

• AND (VE): Seri bağlı iki anahtar. Lamba yalnızca iki anahtar da kapalıyken yanar; iki ayrı anahtarla açılan bir banka kasası da AND kuralıyla çalışır.
• OR (VEYA): Paralel bağlı iki buton. Ön kapıdaki ya da arka kapıdaki butona basıldığında aynı zil çalar.
• NOT (DEĞİL): Buzdolabı lambası. Kapı kapalıyken anahtar basılı kalır ve lamba söner; kapı açılınca anahtar bırakılır ve lamba yanar.
• NAND: "Hepsi tamam değilse uyar" kuralı. Bir makinenin iki emniyet kapağından biri bile açıksa uyarı lambası yanar.
• NOR: "Hiçbiri olmadıysa" kuralı. Ne duman ne de gaz algılandığında yanan yeşil "her şey yolunda" lambası.
• XOR: Merdivenlerdeki vavien anahtar. Alttaki ya da üstteki anahtarı çevirmek lambanın durumunu değiştirir; lamba iki anahtarın konumu farklıyken yanar, aynıyken söner.
• XNOR: Eşitlik kontrolü. İki bit aynıysa 1 verir; sayı karşılaştırıcılarda ve hata denetimi devrelerinde kullanılır.

Mantık kapısı entegreleri: 74HC08, 74HC32, 74HC00

Mantık kapılarını tek tek transistörle kurmak yerine hazır entegreler kullanırsın. Hobi elektroniğinde en yaygını 74HC serisidir: 14 bacaklı DIP kılıfın içinde dört adet iki girişli kapı bulunur, besleme her zaman 14 numaralı bacağa (VCC), toprak 7 numaralı bacağa (GND) bağlanır. 74HC entegreleri 2 ile 6 V arasında çalışır, girişleri neredeyse hiç akım çekmez ve 5 V'ta bir kapının gecikmesi yaklaşık 10 nanosaniyedir; yani Arduino'nun tek bir digitalWrite komutundan yüzlerce kat hızlıdır. Her çıkış 4 mA yükte garanti edilen gerilim seviyelerini korur; mutlak sınır ise çıkış başına 25 mA, bütün entegre için 50 mA'dir.

74HC08, 74HC32, 74HC00 ve 74HC86'nın bacak dizilişi birebir aynıdır; yalnızca içteki kapının türü değişir. Entegrenin üstündeki çentik ya da nokta 1 numaralı bacağın yerini gösterir. Entegreye üstten, çentik solda olacak şekilde baktığında bacaklar saat yönünün tersine numaralanır: alt sıra soldan sağa 1–7, üst sıra sağdan sola 8–14. A ve B girişleri, Y ise çıkıştır; başlarındaki rakam kapının numarasıdır.

Aynı işi yapan entegrelerin farklı aileleri vardır. 74LS serisi eski TTL teknolojisidir: yalnızca 4,75–5,25 V ile çalışır, daha fazla akım çeker ve boşta kalan girişi genellikle 1 gibi okur. 74HCT serisi, 74HC'nin TTL uyumlu girişli hâlidir; 5 V ile beslenir ama 2 V'u bile kesin 1 kabul ettiği için 3,3 V'luk ESP32 ve Pico sinyallerini sorunsuz okur. CD4000 serisi (CD4081, CD4011 gibi) 3–18 V gibi geniş bir aralıkta çalışır ama daha yavaştır ve bacak dizilişi 74HC'den farklıdır: CD4011, 74HC00'ın yerine doğrudan takılamaz.

Butonlu breadboard deneyi: 74HC08 ile AND kapısı

Mantık kapısını anlamanın en iyi yolu, onu iki butonla kendin denemektir. Bu deneyde mikrodenetleyici yok; yalnızca bir 74HC08, iki buton, iki adet 10 kΩ direnç, bir 1 kΩ direnç, bir LED ve 100 nF kondansatör kullanacaksın. Besleme için Arduino'nun 5V ve GND pinleri, bir breadboard güç modülü ya da üç adet AA pil (4,5 V) yeterlidir. Breadboard'un iç bağlantılarından emin değilsen önce Breadboard Nedir? yazısına göz at.

1. 74HC08'i breadboard'un ortasındaki kanalın üzerine, bacaklar iki yana gelecek şekilde yerleştir; çentik sola baksın.
2. 14 numaralı bacağı + hattına (5 V), 7 numaralı bacağı − hattına (GND) bağla ve bu iki bacak arasına 100 nF kondansatörü koy.
3. A butonunun bir ucunu + hattına, diğer ucunu 1 numaralı bacağa bağla. Aynı bacaktan GND'ye 10 kΩ direnç ekle: bu pull-down direnci, butona basılmadığında girişi kesin olarak 0'da tutar.
4. B butonunu aynı şekilde 2 numaralı bacağa bağla ve onun için de 10 kΩ pull-down direnci ekle.
5. Çıkış olan 3 numaralı bacaktan 1 kΩ direnç üzerinden LED'in uzun bacağına (anot) git; LED'in kısa bacağını (katot) GND'ye bağla.
6. Kullanmadığın 4, 5, 9, 10, 12 ve 13 numaralı girişleri GND'ye bağla; 6, 8 ve 11 numaralı çıkışları boş bırak.
7. Beslemeyi ver ve dört kombinasyonu sırayla dene: LED yalnızca iki butona birlikte bastığında yanmalı. Sonuçları doğruluk tablosuyla karşılaştır.

NAND ile her kapıyı kurmak: evrensel kapı

NAND kapısına evrensel kapı denir, çünkü yalnızca NAND kullanarak diğer bütün kapıları kurabilirsin. Bunun pratik bir anlamı var: CMOS teknolojisinde NAND, 4 transistörle kurulan en basit kapılardan biridir; AND ise aslında bir NAND ile arkasına eklenmiş bir NOT'tan oluşur ve 6 transistör ister. Bu yüzden yonga tasarımcıları NAND'ı çok sever. USB belleklerdeki NAND flash da adını, bellek hücrelerinin bir NAND kapısındaki transistörler gibi seri bağlanmasından alır. NOR kapısı da evrenseldir: Ay'a giden Apollo rehberlik bilgisayarı, her birinde iki adet üç girişli NOR kapısı bulunan yaklaşık 2.800 entegreyle yapılmıştı.

Tablodaki OR satırı De Morgan kuralına dayanır: (A' · B')' = A + B. Yani iki girişi önce ayrı ayrı ters çevirip sonra NAND'a sokarsan OR elde edersin. De Morgan'ın ikinci kuralı da (A + B)' = A' · B' şeklindedir. Bu iki kural koddaki koşulları sadeleştirirken de işine yarar: Arduino'da !(a && b) ile (!a || !b) her zaman aynı sonucu verir, !(a || b) ile (!a && !b) de öyle.

XOR'u dört NAND ile kurmak klasik bir sınav ve laboratuvar sorusudur; tek bir 74HC00'daki dört kapı tam olarak buna yeter. Önce N1 = A NAND B hesaplanır. Sonra N2 = A NAND N1 ve N3 = B NAND N1 bulunur, son kapıdaki Y = N2 NAND N3 çıkışı da XOR'u verir. Aşağıdaki bağlantıyla breadboard deneyini dört NAND'lı bir XOR'a çevirebilirsin:

Bir adım daha ileri gidelim: iki NAND kapısının çıkışlarını çapraz olarak birbirinin girişine bağlarsan SR latch denen 1 bitlik bir bellek elde edersin. Bu devre, butondan elini çeksen bile son durumu hatırlar. İşlemcilerdeki kaydediciler, sayaçlar ve 74HC595 kaydırmalı kaydedici gibi entegreler, bu tür kapı tabanlı bellek hücrelerinin art arda dizilmesiyle oluşur.

Yarım toplayıcı (half adder): kapılarla iki biti toplamak

Mantık kapılarının en etkileyici becerisi toplama yapabilmeleridir. İkilik sistemde 0 + 0 = 0, 0 + 1 = 1, 1 + 0 = 1 ve 1 + 1 = 10'dur (ondalıkta 2). Sonucun sağdaki basamağına toplam (Sum), sola taşan basamağa elde (Carry) denir. Aşağıdaki tabloya bakınca toplamın tam olarak XOR, eldenin de tam olarak AND olduğunu görürsün. Yani bir XOR ve bir AND kapısı yan yana geldiğinde, iki tek bitlik sayıyı toplayan bir yarım toplayıcı olur.

Breadboard'da kurmak için A ve B butonlarını hem 74HC86'nın hem de 74HC08'in 1 ve 2 numaralı bacaklarına bağla. 74HC86'nın 3 numaralı bacağı toplam LED'ini, 74HC08'in 3 numaralı bacağı da elde LED'ini sürer. İki butona birlikte bastığında toplam LED'i söner, elde LED'i yanar: LED'ler ikilik 10, yani 2 yazıyor demektir. Yalnızca 74HC00 kullanmak istersen XOR için dört NAND'a, eldeyi bulmak için de N1'i ters çeviren beşinci bir NAND'a ihtiyacın olur; yani yarım toplayıcı 5 NAND ile kurulur.

Yarım toplayıcı alt basamaktan gelen eldeyi hesaba katamaz; bunun için tam toplayıcı (full adder) gerekir. Tam toplayıcının formülleri şunlardır: S = A ⊕ B ⊕ Cin ve Cout = (A · B) + (Cin · (A ⊕ B)). Bu da iki yarım toplayıcı ile bir OR kapısı demektir. Dört tam toplayıcıyı her birinin eldesini bir sonrakine verecek şekilde zincirlersen 4 bitlik bir toplayıcı elde edersin; hazır 74HC283 entegresi aynı 4 bitlik toplamayı yapar, eldeyi ise zincirde beklemeden hesaplayan hızlı bir iç devreyle (carry look-ahead) bulur. Bilgisayarındaki işlemcinin aritmetik birimi de aynı fikrin 64 bitlik ve çok daha hızlı bir sürümüdür.

Arduino'da mantık kapıları: &&, ||, ! ve bit işlemleri

Arduino kodunda her mantık kapısının iki karşılığı vardır. Mantıksal operatörler (&&, ||, !) koşulları birleştirir ve sonucu true ya da false olarak verir; bunları if ve while satırlarında kullanırsın. Bit düzeyindeki operatörler (&, |, ^, ~) ise bir sayının bütün bitlerine aynı anda, sütun sütun uygulanır; bir bayt üzerinde çalışmak, sekiz kapıyı birden çalıştırmak gibidir. Tablodaki örneklerde 0b1100 ve 0b1010 sayıları kullanıldı:

İki tür arasındaki fark küçük görünür ama sinsi hatalara yol açar. && ve || kısa devre değerlendirmesi yapar: a && b ifadesinde a yanlışsa b hiç hesaplanmaz. & ise iki tarafı da her zaman hesaplar ve sayıların bitlerine bakar: 2 && 1 sonucu true iken 2 & 1 sonucu 0'dır, çünkü 0b10 ile 0b01'in ortak biti yoktur. C++'ta ayrı bir mantıksal XOR operatörü yoktur; iki bool için a != b yazmak en okunaklı yoldur. Bit işlemlerinin ayrıntıları, << ve >> kaydırmaları ve ikilik sayı sistemi için Sayı Sistemleri ve Bit İşlemleri yazısına bakabilirsin.

Şimdi breadboard deneyini Arduino Uno'ya taşıyalım. İki buton 2 ve 3 numaralı pinlere, yedi LED (her biri 330 Ω dirençle) 4–10 numaralı pinlere bağlanır. Butonların bir ucu pine, diğer ucu GND'ye gider; dahili pull-up direnci açıldığı için ayrıca direnç gerekmez. Tek bir kod, yedi kapının hepsini aynı anda canlandırır:

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}

INPUT_PULLUP kullanıldığında butona basılınca pin LOW okunur, bu yüzden kod okunan değeri ! ile ters çevirir ve basılı buton 1 olur. Sonra her LED kendi kapısının sonucunu gösterir: 4 AND, 5 OR, 6 NOT A, 7 NAND, 8 NOR, 9 XOR ve 10 XNOR. Seri Monitör'ü 9600 baud'da açarsan her buton değişiminde o satırın tamamı yazılır; dört kombinasyonu denediğinde doğruluk tablosunu kendi elinle çıkarmış olursun. Pull-up mantığının ayrıntıları Arduino'ya Buton Nasıl Bağlanır? yazısında.

Bit işlemlerinin gücünü görmek için ikinci örnek, bütün doğruluk tablosunu birkaç satırda hesaplar. Püf noktası şu: A sütununu 0b1100, B sütununu 0b1010 sayısı olarak yazarsan her bit tablonun bir satırına karşılık gelir ve tek bir & işlemi AND sütununun dört satırını birden verir. Kodun ikinci yarısı tam toplayıcı formüllerini kullanarak iki 4 bitlik sayıyı bit bit toplar; yani işlemcinin toplama devresini yazılımla taklit eder. Bu kod donanım istemez, yalnızca Seri Monitör'ü açman yeterli.

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}

Arduino ile 74HC entegre test cihazı

Elindeki entegrenin üzerindeki yazı silinmişse ya da sağlam olup olmadığını merak ediyorsan Arduino'yu bir test cihazına çevirebilirsin. Bu kod, standart bacak dizilişine sahip 74HC00, 74HC08, 74HC32 ve 74HC86'nın dört kapısına da dört giriş kombinasyonunu sırayla uygular, çıkışları okur ve sonucu bilinen desenlerle karşılaştırır. Entegrenin 14 numaralı bacağını 5V'a, 7 numaralı bacağını GND'ye, diğer bacaklarını koddaki tabloya göre Arduino pinlerine bağla.

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}

ESP32 ile programlanabilir mantık kapısı

ESP32'de aynı operatörler değişmeden çalışır. Bu örnekte üçüncü bir buton kapı türünü sırayla değiştirir, tek bir LED de seçilen kapının çıkışını gösterir. Böylece sınıfta ya da bir sunumda tek devreyle altı kapıyı gösterebilirsin. Butonlar GPIO 25, 26 ve 27'ye (diğer uçları GND'ye), LED ise 220 Ω dirençle GPIO 23'e bağlanır; seçilen kapının adı Seri Monitör'de 115200 baud'da görünür.

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}

Raspberry Pi Pico ve MicroPython ile mantık kapıları

MicroPython'da mantıksal operatörler İngilizce kelimelerle yazılır: and, or, not. Bit düzeyindeki operatörler ise C++ ile aynıdır: &, |, ^ ve ~. Aşağıdaki kod GP14 ve GP15'e bağlı iki butonu okur, GP16–GP21 arasındaki altı LED'de de AND, OR, NAND, NOR, XOR ve XNOR sonuçlarını gösterir. Butonların diğer ucu GND'ye gider, LED'lerin her biri 220–330 Ω dirençle bağlanır. Kodu Thonny ile main.py adıyla kaydedersen Pico her açıldığında çalışır; Pico'ya yeni başlıyorsan Raspberry Pi Pico Nedir? yazısından başlayabilirsin.

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'da da benzer bir tuzak var: ~True ifadesi -2 verir, çünkü bool aslında bir tam sayıdır. Bir biti ters çevirmek için not x, 1 - x ya da x ^ 1 kullan. Ayrıca Python'un and ve or operatörleri her zaman True ya da False döndürmez, son değerlendirdikleri değeri döndürür: 0 or 5 ifadesinin sonucu 5'tir. Koddaki int() dönüşümleri bu yüzden var; böylece LED'lere her zaman yalnızca 0 ya da 1 gönderilir.

Mantık kapılarıyla proje fikirleri

• Akıllı gece lambası (AND): Ortam karanlıkken VE hareket algılandığında ışığı yak; LDR ile PIR sensörünü tek bir && koşulunda birleştir.
• Merdiven otomatiği (XOR): Merdivenin altındaki ve üstündeki iki butonla aynı lambayı yönet; lambanın durumunu XOR ile hesapla ve 220 V lambayı bir röle modülüyle sür.
• Ev alarmı (AND + OR): Sistem kuruluyken kapı VEYA pencere açılırsa sireni çalıştır. Kapıyı ve pencereyi reed röle ile algıla; ayrıntılar için Arduino alarm sistemi rehberine bak.
• İki anahtarlı kasa (AND): İki ayrı kişi aynı anda butona basmadan ya da keypad şifresi doğrulanmadan kilit açılmasın.
• 4 bitlik hesap makinesi: Anahtarlarla girdiğin iki sayıyı tam toplayıcı mantığıyla topla ve sonucu bir 7 segment display üzerinde göster.
• Bilgi yarışması butonu: İlk basan yarışmacının LED'ini kilitle, diğerlerini engelle; bu, NAND tabanlı latch devresinin yazılımdaki karşılığıdır.
• Parite (eşlik) denetimi: Bir bayttaki bütün bitleri XOR'la; sonuç 1 ise içindeki 1'lerin sayısı tektir. Seri haberleşmedeki eşlik biti tam olarak böyle hesaplanır.

Sık yapılan hatalar ve çözümleri

Mantık kapıları, bir LED'i yakmaktan işlemcinin toplama yapmasına kadar bütün dijital dünyanın alfabesidir. AND, OR ve NOT'u kavradıktan sonra bir if koşulunu, bir alarm kuralını ya da bir kaydırmalı kaydediciyi okumak çok kolaylaşır. BlueGrays uygulamasında buton ile LED yakma, ESP32 ve Raspberry Pi Pico buton projeleri, akıllı merdiven aydınlatması ve PIR ile LDR'yi birleştiren akıllı aydınlatma projelerini adım adım devre şemaları ve kodlarıyla bulabilir, bu yazıda öğrendiğin kapı mantığını gerçek projelerde uygulayabilirsin.