Adder Circuits and Flip-Flops

This lesson covers two essential building blocks of digital systems: adder circuits (used for binary arithmetic) and flip-flops (used for memory and sequential logic). At A-Level you must be able to draw, analyse, and explain both.

---

Half Adder

A half adder adds two single-bit binary numbers and produces a sum (S) and a carry (C).

Truth Table

A	B	Sum (S)	Carry (C)
0	0	0	0
0	1	1	0
1	0	1	0
1	1	0	1

Boolean Expressions

• S = A ⊕ B (XOR)
• C = A . B (AND)

Circuit

A ──┬──→ [XOR] ──→ S (Sum)
    │      ↑
B ──┼──────┘
    │
    └──→ [AND] ──→ C (Carry)
         ↑
B ───────┘

The half adder is called "half" because it has no carry input — it cannot handle a carry from a previous stage.

---

Full Adder

A full adder adds two single-bit binary numbers and a carry input (C_in) from a previous stage. It produces a sum (S) and a carry output (C_out).

Truth Table

A	B	C_in	Sum (S)	C_out
0	0	0	0	0
0	0	1	1	0
0	1	0	1	0
0	1	1	0	1
1	0	0	1	0
1	0	1	0	1
1	1	0	0	1
1	1	1	1	1

Boolean Expressions

• S = A ⊕ B ⊕ C_in
• C_out = (A . B) + (C_in . (A ⊕ B))

Building a Full Adder from Half Adders

A full adder can be constructed from two half adders and an OR gate:

A ──→ [Half Adder 1] ──→ partial_sum ──→ [Half Adder 2] ──→ S (Sum)
B ──→                                     ↑
                                    C_in ──┘
      Carry1 ──→ [OR] ──→ C_out
      Carry2 ──→

1. Half Adder 1: adds A and B → partial_sum, Carry1
2. Half Adder 2: adds partial_sum and C_in → S, Carry2
3. OR gate: Carry1 OR Carry2 → C_out

---

Ripple-Carry Adder

To add multi-bit binary numbers, full adders are chained together. The carry output of each stage connects to the carry input of the next stage. This is called a ripple-carry adder.

For a 4-bit adder (adding A3A2A1A0 + B3B2B1B0):

         C_in=0
           │
A0, B0 → [FA0] → S0
           │ C_out
A1, B1 → [FA1] → S1
           │ C_out
A2, B2 → [FA2] → S2
           │ C_out
A3, B3 → [FA3] → S3
           │
         C_out (overflow)

Limitation: The carry must "ripple" through each stage sequentially. For an n-bit adder, the carry takes n stages to propagate, making the circuit slow for large n. This delay is called carry propagation delay.

Solution: Carry look-ahead adders calculate all carry bits in parallel using additional logic, greatly reducing delay at the cost of more complex hardware.

---

Flip-Flops

A flip-flop is a bistable circuit — it has two stable states and can store one bit of data. Flip-flops are the fundamental building blocks of registers, counters, and memory.

SR Flip-Flop (Set-Reset)