Penjelasan Gerbang Logika: Tabel Kebenaran AND, OR, NOT, XOR dan Arduino

Gerbang logika adalah batu bata dasar rangkaian digital: masing-masing melihat satu atau lebih input digital dan menghasilkan satu output digital menurut aturan yang tetap. Input hanya bisa bernilai 0 (LOW) atau 1 (HIGH), begitu juga output-nya. Ada tujuh gerbang dasar: AND, OR, NOT, NAND, NOR, XOR, dan XNOR. Dari prosesor di ponselmu sampai board kendali mesin cuci, dari ATmega328P di dalam Arduino sampai kalkulator saku, setiap perangkat digital bekerja dengan menggabungkan jutaan gerbang logika mungil.

Di panduan ini kamu akan mempelajari simbol dan tabel kebenaran setiap gerbang, chip sungguhan seperti 74HC08, 74HC32, dan 74HC00, percobaan breadboard yang kamu rakit dengan dua push button, cara membuat semua gerbang lain hanya dari NAND, dan rangkaian half adder yang menjumlahkan dua bit. Di bagian terakhir kita akan mengubah logika yang sama menjadi kode di Arduino dengan operator &&, || dan ! serta dengan operasi bitwise, lalu melanjutkan dengan contoh ESP32 dan Raspberry Pi Pico (MicroPython).

Apa itu gerbang logika, dan bagaimana cara kerjanya?

Di elektronika digital, setiap sinyal berada di salah satu dari dua keadaan: 1 (HIGH, benar) atau 0 (LOW, salah). Matematika untuk bekerja dengan dua nilai ini disebut aljabar Boolean; dalam buku yang terbit pada 1854, George Boole menyatakan penalaran logis sebagai aljabar persis dengan cara ini. Pada 1937 Claude Shannon menunjukkan bahwa aljabar ini cocok satu-satu dengan rangkaian saklar yang dibuat dari relay, sehingga meletakkan dasar desain rangkaian digital. Sekarang sebuah gerbang logika hanya berisi segelintir transistor: dalam teknologi CMOS, gerbang NOT terbuat dari 2 MOSFET dan gerbang NAND dari 4. Kami menjelaskan cara transistor bekerja sebagai saklar di Apa Itu Transistor?.

Lalu tegangan berapa yang dianggap 1 oleh sebuah rangkaian, dan berapa yang 0? Itu bergantung pada tegangan catu board dan keluarga chip-nya. Tabel di bawah menunjukkan batas di mana sebuah input dijamin dihitung sebagai 1 atau 0. Daerah di antara kedua batas itu adalah daerah tidak terdefinisi; jika sebuah input tetap di sana, output-nya bisa berperilaku acak. Input yang tidak tersambung ke apa pun, yaitu input yang mengambang, berkeliaran tepat di daerah tidak terdefinisi ini. Karena itu setiap input harus disambung ke sinyal, atau lewat resistor ke GND atau VCC.

7 gerbang logika dasar dan simbolnya

Skema rangkaian menggambar gerbang memakai dua standar berbeda. Di standar Amerika (ANSI/IEEE), setiap gerbang punya bentuknya sendiri: AND seperti huruf D, OR seperti perisai runcing, dan NOT seperti segitiga. Lingkaran kecil (bubble) di output berarti “dibalik”; NAND sebenarnya adalah AND dengan bubble di ujungnya. Yang membedakan XOR dari OR adalah garis lengkung kedua di sisi input. Di standar Eropa (IEC), semua gerbang berbentuk persegi panjang, dibedakan oleh tanda yang ditulis di dalamnya: & untuk AND, ≥1 untuk OR, =1 untuk XOR, dan 1 untuk NOT. Di buku pelajaran kamu juga akan melihat NAND ditulis sebagai NOT-AND, NOR sebagai NOT-OR, XOR sebagai exclusive OR, dan XNOR sebagai exclusive NOR.

Tabel kebenaran gerbang logika

Tabel kebenaran mencantumkan output yang diberikan sebuah gerbang untuk setiap kombinasi input-nya. Gerbang dengan n input punya 2ⁿ baris: 4 baris untuk dua input, 8 untuk tiga, dan 16 untuk empat. Jika kamu menulis baris-barisnya dengan urutan hitungan biner (00, 01, 10, 11), kamu tidak akan pernah melewatkan satu kombinasi pun. Berikut keenam gerbang dua input dalam satu tabel:

Karena gerbang NOT hanya punya satu input, tabelnya berisi dua baris: ketika A = 0 output-nya 1, dan ketika A = 1 output-nya 0. Perhatikan tabelnya baik-baik dan kamu akan melihat polanya: kolom NAND kebalikan persis dari AND, NOR kebalikan dari OR, dan XNOR kebalikan dari XOR. Untuk menghafalnya, pakai aturan singkat ini: AND bertanya “apakah semuanya 1?”, OR bertanya “apakah minimal satu bernilai 1?”, XOR bertanya “apakah input-nya berbeda?”; gerbang yang namanya diawali N memberi jawaban kebalikan untuk pertanyaan yang sama. Untuk mencoba gerbang-gerbang ini sendiri dan melihat simbolnya secara langsung, cukup ketuk input A dan B di alat Gerbang logika.

• AND: Dua saklar seri. Lampu hanya menyala ketika kedua saklar tertutup; brankas bank yang terbuka dengan dua kunci terpisah juga mengikuti aturan AND.
• OR: Dua push button paralel. Bel yang sama berbunyi entah seseorang menekan tombol di pintu depan atau di pintu belakang.
• NOT: Lampu kulkas. Selama pintu tertutup saklarnya tertekan dan lampunya mati; ketika pintu terbuka saklarnya terlepas dan lampunya menyala.
• NAND: Aturan “beri peringatan kecuali semuanya beres”. Jika salah satu saja dari dua pelindung keamanan mesin terbuka, lampu peringatan menyala.
• NOR: Aturan “tidak ada yang terjadi”. Lampu hijau “aman” yang hanya menyala ketika tidak terdeteksi asap maupun gas.
• XOR: Saklar lampu dua arah di tangga. Membalik saklar bawah atau saklar atas mengubah keadaan lampu; lampu menyala ketika kedua saklar berada di posisi berbeda dan mati ketika posisinya sama.
• XNOR: Pengecekan kesamaan. Output-nya 1 ketika dua bit sama; dipakai di komparator digital dan rangkaian pengecekan error.

IC gerbang logika: 74HC08, 74HC32, 74HC00

Alih-alih membuat gerbang logika dari transistor satuan, kamu memakai chip siap pakai. Keluarga yang paling umum di elektronika hobi adalah seri 74HC: satu kemasan DIP 14 pin berisi empat gerbang dua input, daya selalu ke pin 14 (VCC) dan ground ke pin 7 (GND). Chip 74HC bekerja dari 2 sampai 6 V, input-nya hampir tidak menarik arus, dan pada 5 V satu gerbang punya tunda sekitar 10 nanodetik, ratusan kali lebih cepat daripada satu pemanggilan digitalWrite di Arduino. Setiap output menjaga level tegangan yang dijamin pada beban 4 mA; batas mutlaknya 25 mA per output dan 50 mA untuk seluruh chip.

74HC08, 74HC32, 74HC00, dan 74HC86 punya pinout yang persis sama; hanya jenis gerbang di dalamnya yang berubah. Takik atau titik di bagian atas chip menandai pin 1. Dengan chip dilihat dari atas dan takik di kiri, pin dinomori berlawanan arah jarum jam: baris bawah 1–7 dari kiri ke kanan dan baris atas 8–14 dari kanan ke kiri. A dan B adalah input, Y adalah output, dan angka di depannya adalah nomor gerbang.

Chip yang melakukan tugas yang sama tersedia dalam keluarga yang berbeda. Seri 74LS adalah teknologi TTL yang lebih lama: hanya bekerja di 4,75–5,25 V, menarik arus lebih besar, dan biasanya membaca input yang mengambang sebagai 1. Seri 74HCT adalah 74HC dengan input yang kompatibel TTL; bekerja di 5 V tapi menerima apa pun mulai 2 V ke atas sebagai 1 yang dijamin, jadi bisa membaca sinyal 3,3 V dari ESP32 atau Pico tanpa masalah. Seri CD4000 (CD4081, CD4011, dan seterusnya) bekerja di rentang lebar 3–18 V tapi lebih lambat, dan pinout-nya berbeda dari 74HC: CD4011 tidak bisa begitu saja menggantikan 74HC00.

Percobaan breadboard dengan push button: gerbang AND dengan 74HC08

Cara terbaik memahami gerbang logika adalah mencobanya sendiri dengan dua push button. Tidak ada mikrokontroler di percobaan ini; kamu hanya butuh 74HC08, dua push button, dua resistor 10 kΩ, satu resistor 1 kΩ, satu LED, dan kapasitor 100 nF. Untuk daya, pin 5V dan GND Arduino, modul daya breadboard, atau tiga baterai AA (4,5 V) semuanya bisa. Jika kamu belum yakin bagaimana breadboard tersambung di dalam, baca dulu Apa Itu Breadboard?.

1. Pasang 74HC08 melintasi celah di tengah breadboard agar pin-pinnya berada di kedua sisi, dengan takik menghadap ke kiri.
2. Sambungkan pin 14 ke jalur + (5 V) dan pin 7 ke jalur − (GND), lalu pasang kapasitor 100 nF di antara kedua pin ini.
3. Sambungkan satu sisi tombol A ke jalur + dan sisi lainnya ke pin 1. Tambahkan resistor 10 kΩ dari pin yang sama ke GND: resistor pull-down ini menahan input tetap di 0 selama tombol tidak ditekan.
4. Sambungkan tombol B ke pin 2 dengan cara yang sama dan beri resistor pull-down 10 kΩ-nya sendiri.
5. Dari pin 3, yaitu output, lewat resistor 1 kΩ ke kaki panjang LED (anoda); sambungkan kaki pendek LED (katoda) ke GND.
6. Sambungkan input yang tidak dipakai, pin 4, 5, 9, 10, 12, dan 13, ke GND; biarkan output 6, 8, dan 11 terbuka.
7. Nyalakan dayanya dan coba keempat kombinasi bergantian: LED seharusnya hanya menyala ketika kamu menekan kedua tombol bersamaan. Bandingkan hasilnya dengan tabel kebenaran.

Membuat setiap gerbang dari NAND: gerbang universal

NAND disebut gerbang universal karena kamu bisa membuat semua gerbang lain hanya dengan gerbang NAND. Ini juga punya sisi praktis: dalam teknologi CMOS, NAND adalah salah satu gerbang paling sederhana, hanya butuh 4 transistor, sedangkan AND sebenarnya adalah NAND yang diikuti NOT dan butuh 6. Karena itulah perancang chip menyukai NAND. NAND flash di flashdisk juga mendapat namanya dari cara sel-sel memorinya tersambung seri, seperti transistor di gerbang NAND. NOR juga universal: Apollo Guidance Computer yang terbang ke Bulan dibuat dari sekitar 2.800 chip, masing-masing berisi dua gerbang NOR tiga input.

Baris OR di tabel bergantung pada hukum De Morgan: (A' · B')' = A + B. Dengan kata lain, jika kamu membalik kedua input dulu lalu memasukkannya ke NAND, kamu mendapat OR. Hukum De Morgan kedua adalah (A + B)' = A' · B'. Kedua hukum ini juga membantumu menyederhanakan kondisi di kode: di Arduino, !(a && b) selalu memberi hasil yang sama dengan (!a || !b), dan !(a || b) sama dengan (!a && !b).

Membuat XOR dari empat gerbang NAND adalah latihan klasik di ujian dan laboratorium, dan empat gerbang di satu 74HC00 pas sekali jumlahnya. Pertama dihitung N1 = A NAND B. Lalu dicari N2 = A NAND N1 dan N3 = B NAND N1, dan output gerbang terakhir, Y = N2 NAND N3, memberi XOR. Dengan pengkabelan di bawah kamu bisa mengubah percobaan breadboard-mu menjadi XOR empat NAND:

Mari melangkah lebih jauh: jika kamu menyambungkan silang output dua gerbang NAND ke input satu sama lain, kamu mendapat memori 1 bit yang disebut SR latch. Rangkaian ini mengingat keadaan terakhirnya bahkan setelah kamu melepas tombol. Register di prosesor, penghitung, dan chip seperti shift register 74HC595 dibuat dengan merangkai sel-sel memori seperti ini, yang tersusun dari gerbang.

Half adder: menjumlahkan dua bit dengan gerbang

Hal paling mengesankan yang bisa dilakukan gerbang logika adalah menjumlahkan angka. Dalam biner, 0 + 0 = 0, 0 + 1 = 1, 1 + 0 = 1, dan 1 + 1 = 10 (2 dalam desimal). Digit kanan hasilnya disebut sum (jumlah) dan digit yang meluap ke kiri adalah carry (simpanan). Melihat tabel di bawah, kamu akan melihat bahwa sum persis XOR dan carry persis AND. Jadi gerbang XOR dan gerbang AND yang berdampingan membentuk half adder yang menjumlahkan dua angka satu bit.

Untuk merakitnya di breadboard, sambungkan tombol A dan B ke pin 1 dan 2 dari 74HC86 sekaligus 74HC08. Pin 3 74HC86 mengendalikan LED sum dan pin 3 74HC08 mengendalikan LED carry. Ketika kamu menekan kedua tombol, LED sum padam dan LED carry menyala: LED-LED itu menampilkan biner 10, yaitu 2. Jika kamu hanya ingin memakai 74HC00, kamu butuh empat NAND untuk XOR dan NAND kelima yang membalik N1 untuk mendapat carry; dengan kata lain, half adder butuh 5 gerbang NAND.

Half adder tidak bisa memperhitungkan carry yang datang dari digit di bawahnya; untuk itu kamu butuh full adder. Rumusnya S = A ⊕ B ⊕ Cin dan Cout = (A · B) + (Cin · (A ⊕ B)), artinya dua half adder ditambah satu gerbang OR. Rangkai empat full adder agar masing-masing meneruskan carry-nya ke yang berikutnya, dan kamu punya penjumlah 4 bit; chip siap pakai 74HC283 melakukan penjumlahan 4 bit yang sama, tapi menghitung carry-nya dengan rangkaian internal yang cepat (carry look-ahead) alih-alih menunggunya merambat sepanjang rantai. Unit aritmetika prosesor di komputermu adalah versi 64 bit yang jauh lebih cepat dari ide yang sama.

Gerbang logika di Arduino: &&, ||, ! dan operasi bitwise

Di kode Arduino setiap gerbang logika punya dua padanan. Operator logika (&&, ||, !) menggabungkan kondisi dan memberi hasil true atau false; kamu memakainya di pernyataan if dan while. Operator bitwise (&, |, ^, ~) diterapkan ke semua bit sebuah angka sekaligus, kolom per kolom; bekerja pada satu byte sama seperti menjalankan delapan gerbang pada waktu yang sama. Contoh di tabel memakai angka 0b1100 dan 0b1010:

Perbedaan kedua jenis ini terlihat kecil tapi menimbulkan bug yang licik. && dan || memakai evaluasi short-circuit: pada a && b, jika a bernilai false maka b tidak pernah dievaluasi. & selalu mengevaluasi kedua sisi dan melihat bit-bit angkanya: 2 && 1 bernilai true, tapi 2 & 1 bernilai 0, karena 0b10 dan 0b01 tidak punya bit yang sama. C++ tidak punya operator XOR logika tersendiri; untuk dua bool, menulis a != b adalah cara yang paling mudah dibaca. Untuk lebih banyak tentang operasi bitwise, pergeseran << dan >>, serta sistem bilangan biner, lihat Sistem Bilangan dan Operasi Bit.

Sekarang mari pindahkan percobaan breadboard ke Arduino Uno. Dua push button ke pin 2 dan 3, dan tujuh LED (masing-masing dengan resistor 330 Ω) ke pin 4–10. Satu sisi setiap tombol ke pin dan sisi lainnya ke GND; karena resistor pull-up internal diaktifkan, tidak perlu resistor tambahan. Satu sketch menghidupkan ketujuh gerbang sekaligus:

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}

Dengan INPUT_PULLUP, tombol yang ditekan terbaca LOW, jadi kode membalik pembacaannya dengan ! dan tombol yang ditekan menjadi 1. Setiap LED lalu menampilkan hasil gerbangnya sendiri: 4 AND, 5 OR, 6 NOT A, 7 NAND, 8 NOR, 9 XOR, dan 10 XNOR. Jika kamu membuka Serial Monitor di 9600 baud, seluruh baris dicetak setiap kali sebuah tombol berubah; begitu kamu mencoba keempat kombinasi, kamu sudah menghasilkan tabel kebenaran dengan tanganmu sendiri. Detail pull-up ada di Cara Menghubungkan Push Button ke Arduino.

Untuk melihat kekuatan operasi bitwise, contoh kedua menghitung seluruh tabel kebenaran dalam beberapa baris. Triknya: jika kamu menulis kolom A sebagai angka 0b1100 dan kolom B sebagai 0b1010, setiap bit sesuai dengan satu baris tabel, dan satu & saja memberimu keempat baris kolom AND sekaligus. Paruh kedua sketch menjumlahkan dua angka 4 bit bit demi bit memakai rumus full adder, meniru rangkaian penjumlah prosesor lewat software. Sketch ini tidak butuh hardware; cukup buka 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}

Penguji chip 74HC dengan Arduino

Jika tulisan di sebuah chip sudah pudar, atau kamu ingin tahu apakah chip itu masih bekerja, kamu bisa mengubah Arduino menjadi penguji. Sketch ini memberikan keempat kombinasi input bergantian ke keempat gerbang 74HC00, 74HC08, 74HC32, atau 74HC86 (chip dengan pinout standar), membaca output-nya, dan membandingkan hasilnya dengan pola yang sudah diketahui. Sambungkan pin 14 chip ke 5V, pin 7 ke GND, dan pin lainnya ke pin Arduino yang tercantum di tabel kode.

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}

Gerbang logika yang bisa diprogram dengan ESP32

Operator yang sama bekerja tanpa perubahan di ESP32. Di contoh ini tombol ketiga berpindah di antara jenis-jenis gerbang, dan satu LED menampilkan output gerbang yang dipilih. Dengan begitu kamu bisa memperagakan enam gerbang dengan satu rangkaian di kelas atau presentasi. Tombol-tombolnya ke GPIO 25, 26, dan 27 (sisi lainnya ke GND), dan LED ke GPIO 23 lewat resistor 220 Ω; nama gerbang yang dipilih muncul di Serial Monitor pada 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}

Gerbang logika dengan Raspberry Pi Pico dan MicroPython

Di MicroPython operator logika ditulis sebagai kata bahasa Inggris: and, or, not. Operator bitwise-nya sama dengan C++: &, |, ^, dan ~. Kode di bawah membaca dua push button di GP14 dan GP15 dan menampilkan hasil AND, OR, NAND, NOR, XOR, dan XNOR di enam LED di GP16–GP21. Sisi lain setiap tombol ke GND, dan setiap LED disambung lewat resistor 220–330 Ω. Jika kamu menyimpan kodenya di Thonny sebagai main.py, kode berjalan setiap kali Pico menyala; jika kamu baru mengenal Pico, mulailah dari Apa Itu 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 punya jebakan serupa: ~True memberi -2, karena bool sebenarnya adalah bilangan bulat. Untuk membalik sebuah bit, pakai not x, 1 - x, atau x ^ 1. Selain itu, operator and dan or di Python tidak selalu mengembalikan True atau False; keduanya mengembalikan nilai terakhir yang dievaluasi, jadi 0 or 5 memberi 5. Karena itu kodenya memakai konversi int(), agar LED hanya pernah menerima 0 atau 1.

Ide proyek dengan gerbang logika

• Lampu tidur pintar (AND): Nyalakan lampu ketika gelap DAN gerakan terdeteksi; gabungkan LDR dan sensor PIR dalam satu kondisi &&.
• Lampu tangga (XOR): Kendalikan satu lampu dengan dua tombol di bawah dan di atas tangga; hitung keadaan lampu dengan XOR dan saklarkan lampu listrik PLN dengan modul relay.
• Alarm rumah (AND + OR): Selama sistem aktif, bunyikan sirene jika pintu ATAU jendela terbuka. Deteksi pintu dan jendela dengan reed switch; lihat panduan sistem alarm Arduino untuk detailnya.
• Brankas dua kunci (AND): Jangan biarkan kunci terbuka kecuali dua orang berbeda menekan tombolnya pada waktu yang sama, atau sampai kode keypad terverifikasi.
• Kalkulator 4 bit: Jumlahkan dua angka yang dimasukkan dengan saklar memakai logika full adder dan tampilkan hasilnya di display 7-segmen.
• Bel cerdas cermat: Kunci LED peserta pertama yang menekan dan blokir yang lain; ini versi software dari latch berbasis NAND.
• Pengecekan paritas: XOR-kan semua bit sebuah byte; jika hasilnya 1, jumlah angka 1 ganjil. Bit paritas di komunikasi serial dihitung persis dengan cara ini.

Kesalahan umum dan cara memperbaikinya

Gerbang logika adalah alfabet seluruh dunia digital, dari menyalakan LED sampai prosesor yang menjumlahkan angka. Begitu kamu memahami AND, OR, dan NOT, membaca kondisi if, aturan alarm, atau shift register menjadi jauh lebih mudah. Di aplikasi BlueGrays kamu akan menemukan proyek LED dengan push button, proyek tombol untuk ESP32 dan Raspberry Pi Pico, Lampu Tangga dan Koridor Pintar, serta Lampu Pintar ESP32 (PIR + LDR + Relay + OLED) yang menggabungkan PIR dan LDR, masing-masing dengan skema rangkaian dan kode langkah demi langkah, sehingga kamu bisa menerapkan logika gerbang dari artikel ini di proyek sungguhan.