ADDER MEANING

• An adder is a digital circuit that performs addition of numbers.

• In processor it is used to calculate addresses, table indices, and similar operations.

• It can be constructed for many numerical representations, such as binary-coded decimal or excess-
3, the most common adders operate on binary numbers.
TYPES

Half Adder

Full Adder

Ripple Adder

Look ahead carry unit

Carry-save adders
HALF ADDER

The half adder adds two single binary digits A and B.

It has two outputs, sum (S) and carry (C).

Sum = AB'+A'B.
Carry=A*B.
For half-adder design, an XOR gate & an AND gate
#
A half adder is a basic building block in digital circuits that performs the addition of two single binary
digits (bits). It can be thought of as performing half of a complete addition operation.
Inputs: The half adder has two input bits, labeled A and B.
Outputs: It produces two outputs:
Sum (S): This represents the least significant bit (LSB) of the result after adding the two input bits.
Carry (C): This indicates whether there was a carry-over from the addition. It outputs a 1 if both input
bits were 1, otherwise it outputs a 0.
Implementation: A half adder is typically constructed using two logic gates:

XOR Gate: This gate performs an exclusive OR operation on the input bits A and B. The XOR outputs a
1 if the inputs are different (either 0 and 1 or 1 and 0), and a 0 if the inputs are the same (both 0 or
both 1). This determines the Sum output (S).
AND Gate: This gate outputs a 1 only if both of its inputs (A and B) are 1. This signifies a carry situation
and sets the Carry output (C) to 1.
Limitations:

The half adder can only add two single-bit binary numbers.
It cannot handle a carry-in from a previous addition, which is necessary for adding multi-bit binary
numbers.
Applications:

Half adders are fundamental components in building full adders, which can add two bits and account
for a carry-in.
They are used in Arithmetic Logic Units (ALUs) of processors for performing basic arithmetic
operations.
They find applications in calculators, address generation circuits, and various digital logic functions.

FULL ADDER
A combinational circuit that adds 3 input bits to generate a Sum bit and a Carry bit
Where X,Y,Z are inputs and C & S are outputs.
Sum= X+Y+Z.
Cout= XY'+YZ'+ZX'.
A full adder is the next step up from a half adder, designed to address the limitations of its
predecessor. It's a digital circuit that performs the complete addition of three one-bit binary numbers:

Two binary digits (bits): These are the primary inputs, usually labeled A and B.
Carry-in (Cin): This represents a carry bit from the previous lower-order addition (if any).
The full adder produces two outputs:

Sum (S): This represents the least significant bit (LSB) of the result after adding the three inputs.
Carry-out (Cout): This indicates whether there was a carry-over from the addition.
Key Differences from Half Adder:

Handles Carry-in: Unlike a half adder, a full adder can incorporate a carry bit from a previous addition
through the Cin input.
Complete Addition: It performs the entire addition operation, including handling potential carry-
overs.
Implementation:

A full adder can be built using a combination of logic gates:

XOR Gates: Typically two XOR gates are used. One is used to compute the Sum (S) by taking the XOR
of all three inputs (A, B, and Cin).
AND Gates: One or two AND gates are used along with an OR gate to determine the Carry-out (Cout).
The specific configuration depends on the desired logic implementation.
Truth Table:

The full adder's operation can be summarized by a truth table showing all possible input combinations
and the corresponding outputs:

A B Cin Sum (S) Carry-out (Cout)

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
Applications:

Full adders are essential components in building multi-bit adders. By cascading full adders, we can add
binary numbers of any length. This forms the core functionality of arithmetic logic units (ALUs) in
processors for performing addition, subtraction, and other arithmetic operations. Full adders are also
crucial in various digital circuits like calculators, memory address generation units, and other logic
functions requiring binary addition.

RIPPLE CARRY ADDER

It is possible to create a logical circuit using multiple full adders to add N-bit numbers.
Each full adder inputs a Cin, which is the Cout of the previous adder.
This kind of adder is called a ripple-carry adder, since each carry bit "ripples" to the next full adder.
A ripple carry adder is a digital circuit designed to add two n-bit binary numbers. It's built using a
chain of simpler circuits called full adders. Here's a breakdown of how it works:

Components:
Full Adders: The ripple carry adder utilizes multiple full adders, typically one for each bit position of
the binary numbers.
Carry Propagation: Each full adder can add three one-bit binary inputs: two bits from the input
numbers (A and B) and a carry-in (Cin) from the previous less significant bit position.
Operation:

Least Significant Bit (LSB): The first full adder handles the least significant bits (A0 and B0) of the input
numbers along with a carry-in of 0 (assuming no carry from a previous operation). It generates the
Sum (S0) for the LSB position and a Carry-out (Cout).
Ripple Effect: This Carry-out (Cout) from the first full adder becomes the Carry-in (Cin) for the next full
adder in the chain. This process ripples through the remaining full adders, where each adder
considers its corresponding input bits and the Carry-in from the previous stage.
Sum and Carry Outputs: Each full adder in the chain produces a Sum bit for its corresponding bit
position and a Carry-out that propagates to the next stage. The final Carry-out from the most
significant bit adder represents the overall carry for the addition.
Why "Ripple"?

The name "ripple carry" arises because the carry bit from each addition stage needs to propagate
through subsequent adders before the final sum can be determined. This sequential propagation
creates a slight delay compared to adders that can determine carries ahead of time.

Advantages:

Simple design concept using well-understood full adders.

Easy to implement and understand.
Suitable for low-cost and low-power applications where speed is not critical.
Disadvantages:

Slower operation due to the sequential carry propagation.

Not ideal for high-performance applications requiring fast addition.
Applications:

Ripple carry adders are commonly used in low-speed applications like microcontrollers, simple
calculators, and educational circuits.
They serve as a foundational concept for understanding more advanced adder designs like carry-look
ahead adders that optimize speed.
LOOK AHEAD CARRY UNIT
• By combining multiple carry lookahead adders even larger adders can be created.
• This can be used at multiple levels to make even larger adders.

A lookahead carry unit (LCU) is a specialized circuit used in conjunction with carry-look ahead adders
(CLAs) to improve the speed of addition in digital circuits. Here's how it works:

Problem with Ripple Carry Adders:

Traditional ripple carry adders calculate the carry bit for each bit position sequentially, one after the
other. This creates a delay because each adder needs to wait for the carry from the previous stage
before it can determine its own sum and carry.
LCU to the Rescue:

A lookahead carry unit aims to overcome this limitation by anticipating the carry bits ahead of time. It
analyzes the input bits and calculates whether a carry will occur in a particular group of bits, without
waiting for the ripple effect from prior stages.
LCU Functionality:

An LCU typically operates on a small group of bits (e.g., 4 bits) from the binary numbers to be added.
It processes these input bits and generates two key outputs for each group:
Carry Propagate (P): This signal indicates whether a carry will be propagated through this group
regardless of the carry-in from the previous group.
Carry Generate (G): This signal indicates whether a carry will be generated within this group,
irrespective of the input carry.
Benefits of LCU:

By calculating these propagate and generate signals beforehand, the CLA can determine the carry for
each bit position much faster than waiting for the ripple effect.
This significantly reduces the overall addition time, making CLAs using LCUs more efficient for high-
performance applications.
Implementation:

The internal design of an LCU involves logic gates like OR gates and XOR gates to analyze the input bits
and generate the propagate and generate signals.
The specific logic depends on the number of bits processed by the LCU.
Applications:

Lookahead carry units are essential components in carry-look ahead adders, which are used in high-
speed processors, ALUs (Arithmetic Logic Units), and other digital circuits where fast arithmetic
operations are crucial.
In essence, LCUs act as intelligent building blocks within CLAs, pre-calculating carry information to
streamline the addition process and achieve faster results.