Digital Electronics Lab Manual: Logic Gates on Breadboard

A digital electronics lab manual for logic gates on breadboard is an essential resource for engineering students across India. Whether you’re studying at an IIT, NIT, or affiliated engineering college, your Electronics Lab curriculum will include truth table verification, logic gate implementation, and combination circuit design. This practical guide covers everything from basic AND/OR/NOT gates using 7400-series ICs to complex combinational circuits — all implemented on breadboard with step-by-step instructions and complete observations tables.

Table of Contents

• Introduction to 7400-Series TTL Logic ICs
• Experiment 1: Basic Logic Gates
• Experiment 2: Universal Gates (NAND and NOR)
• Experiment 3: Combination Logic Circuits
• Experiment 4: Half and Full Adder
• Logic Gates Using Arduino
• Frequently Asked Questions

Introduction to 7400-Series TTL Logic ICs

The 7400 series (also called TTL — Transistor-Transistor Logic) are the standard digital logic ICs used in electronics labs worldwide. Key characteristics for Indian students to note:

• Supply voltage: 5V DC (use a regulated power supply or Arduino’s 5V output)
• Logic HIGH: 2.4V – 5V
• Logic LOW: 0V – 0.8V
• Power dissipation: Low — safe for extended student use
• Speed: Gate propagation delay ~10ns (adequate for lab frequencies)

Essential IC List for a Complete Logic Gates Lab

Experiment 1: Basic Logic Gates

Aim

To verify the truth tables of basic logic gates (AND, OR, NOT, NAND, NOR, XOR) using TTL ICs.

Components Required

• IC 7408 (AND), IC 7432 (OR), IC 7404 (NOT), IC 7400 (NAND), IC 7402 (NOR), IC 7486 (XOR)
• Breadboard, 5V power supply or Arduino
• 2 SPDT switches or push buttons (for inputs A and B)
• 2 LEDs with 330Ω resistors (for output indicator)
• Jumper wires

IC Pin Diagrams (7408 AND gate example)

7408 Quad 2-Input AND Gate - Pin Layout:

       +--v--+
 1A  --|1  14|-- Vcc (5V)
 1B  --|2  13|-- 4B
 1Y  --|3  12|-- 4A
 2A  --|4  11|-- 4Y
 2B  --|5  10|-- 3B
 2Y  --|6   9|-- 3A
GND --|7   8|-- 3Y
       +-----+

Vcc = Pin 14 → 5V
GND = Pin 7 → 0V (Ground)
Gate 1: Inputs = pins 1,2; Output = pin 3
Gate 2: Inputs = pins 4,5; Output = pin 6

AND Gate Truth Table Verification

Experiment 2: Universal Gates (NAND and NOR)

NAND and NOR gates are called “universal gates” because any logic function can be implemented using only NAND gates or only NOR gates. This is a critical concept in digital electronics and is frequently tested in Indian university examinations.

Implementing NOT, AND, OR using NAND gates only (7400)

NOT from NAND: Connect both NAND inputs together
  Output = (A·A)' = A' (NOT A)

AND from NAND: NAND followed by NOT (NAND inversion)
  Step 1: NAND(A,B) → intermediate
  Step 2: NOT(intermediate) → AND output

OR from NAND: De Morgan's theorem: (A+B) = (A'·B')'
  Step 1: NOT(A) using NAND
  Step 2: NOT(B) using NAND
  Step 3: NAND(NOT_A, NOT_B) → OR output

Experiment 3: Combination Logic Circuits

Boolean Expression Implementation

Implement the Boolean expression: Y = AB + BC’

Implementation steps:
1. Calculate A AND B → intermediate1 (using 7408, gate 1)
2. Calculate NOT C → C' (using 7404, gate 1)
3. Calculate B AND C' → intermediate2 (using 7408, gate 2)
4. Calculate intermediate1 OR intermediate2 → Y (using 7432, gate 1)

Truth table for Y = AB + BC':
A  B  C  | AB | C' | BC' | Y=AB+BC'
0  0  0  |  0 |  1 |  0  |  0
0  0  1  |  0 |  0 |  0  |  0
0  1  0  |  0 |  1 |  1  |  1
0  1  1  |  0 |  0 |  0  |  0
1  0  0  |  0 |  1 |  0  |  0
1  0  1  |  0 |  0 |  0  |  0
1  1  0  |  1 |  1 |  1  |  1  (AB=1 dominates)
1  1  1  |  1 |  0 |  0  |  1  (AB=1 dominates)

Experiment 4: Half and Full Adder

Half Adder

A half adder adds two 1-bit binary numbers, producing a Sum and Carry:

• Sum = A XOR B (use 7486)
• Carry = A AND B (use 7408)

Logic Gates Using Arduino

An alternative approach for schools without TTL ICs is to implement logic gates in Arduino code and verify truth tables using LED outputs:

// Implementing AND gate in Arduino
// Inputs: Buttons at pins 2, 3
// Output: LED at pin 13
void loop() {
  bool A = digitalRead(2);
  bool B = digitalRead(3);
  
  bool Y_AND  = A && B;
  bool Y_OR   = A || B;
  bool Y_NAND = !(A && B);
  bool Y_NOR  = !(A || B);
  bool Y_XOR  = A ^ B;
  
  // Display AND result
  digitalWrite(13, Y_AND);
  
  Serial.print("A:"); Serial.print(A);
  Serial.print(" B:"); Serial.print(B);
  Serial.print(" AND:"); Serial.print(Y_AND);
  Serial.print(" OR:"); Serial.print(Y_OR);
  Serial.print(" XOR:"); Serial.println(Y_XOR);
}

Frequently Asked Questions

What is the difference between 74LS and 74HC series ICs?

74LS (Low-power Schottky TTL) operates at 5V, with faster switching but slightly higher power consumption. 74HC (High-speed CMOS) operates at 2–6V, with very low power consumption. For lab experiments, both work — 74LS is more common in Indian lab stocks, while 74HC is more modern. Don’t mix them in the same circuit without proper interfacing, as output levels differ slightly.

Why does my logic gate output not match the truth table?

Common causes: Incorrect Vcc/GND connection (always connect power pins first), floating input (unconnected inputs float — connect unused inputs to GND for 0 or to 5V for 1), incorrect IC identification (read the IC number carefully, 7408 vs 7402 look identical), damaged IC (test with a known working IC). Use a multimeter to verify voltage levels at each pin.

Can I verify logic gate truth tables using Arduino without TTL ICs?

Yes — Arduino’s digitalRead() and digital output pins can implement and verify all logic gate truth tables in software. While this doesn’t provide experience with actual TTL ICs, it’s a valid approach for schools without dedicated electronics lab components and demonstrates the same logical concepts.

How do I implement a 3-input logic gate using 2-input IC gates?

Chain two 2-input gates: For 3-input AND: AND(A,B) → result1, then AND(result1, C) → final output. Uses 2 gate units from a quad 2-input AND IC. Same approach works for OR, NAND, NOR. XOR with 3 inputs requires 2 XOR gates: XOR(A,B) → result1, then XOR(result1, C) → final output.

Shop Digital Electronics Lab Components at Zbotic →