We gonna see a complete Verilog Code for full adder. A Full Adder is a digital circuit that adds three binary numbers. It takes two inputs, A and B, and a Carry-In (Cin) bit. The Full Adder produces two outputs: Sum (S) and Carry-Out (Cout). It’s a crucial component for performing binary addition, especially when an extra carry bit is required from a previous addition.

Full Adder in Verilog HDL

In this guide, we will design a Full Adder using Verilog HDL. We will cover the design step-by-step, including the truth table, Verilog code, and how to test the implementation using a testbench.

Problem Statement: Design a Full Adder in Verilog HDL

The goal is to write Verilog code for a Full Adder circuit. Here’s a detailed approach to achieve this:


Step 1: Concept of Full Adder

A Full Adder has three inputs: A, B, and Cin, and two outputs: Sum and Cout. The Full Adder performs binary addition and calculates the sum and carry out.

Below is the Truth Table for the Full Adder:

ABCinSumCout
00000
00110
01010
01101
10010
10101
11001
11111

The truth table shows how the Sum and Carry-Out (Cout) are calculated based on the inputs A, B, and Cin.


Step 2: Verilog Code for Full Adder

The Verilog code for a Full Adder consists of two modules: a Full Adder and a Half Adder.

Full Adder Verilog Code

module FullAdder(
    input A,           // First input bit
    input B,           // Second input bit
    input Cin,         // Carry-in bit
    output Sum,        // Sum output
    output Cout        // Carry-out bit
);

    // Sum is the XOR of A, B, and Cin
    assign Sum = A ^ B ^ Cin;

    // Carry-out is generated when at least two of A, B, or Cin are 1
    assign Cout = (A & B) | (B & Cin) | (A & Cin);

endmodule

Explanation:

  • Sum: The sum is calculated as the XOR of inputs A, B, and Cin.
    • Sum = A ^ B ^ Cin
    • XOR is used here because the sum of two bits is true if exactly one of them is true, which is exactly what XOR represents.
  • Carry-out (Cout): The carry-out bit is generated if at least two of the inputs are 1. This is calculated using OR operations of ANDed inputs:
    • Cout = (A & B) | (B & Cin) | (A & Cin)
    • The carry-out is 1 if two or more of the inputs are 1.

This implementation of a full adder is a direct, simple approach and avoids using a half adder by computing both the sum and carry-out directly from the inputs.

Full Adder Verilog Code Using Half Adder

module full_adder(
  input a, b, cin,
  output sum, cout
);
  wire x, y, z;

  // Instantiate Half Adders to create Full Adder
  half_adder h1(.a(a), .b(b), .s(x), .c(y));
  half_adder h2(.a(x), .b(cin), .s(sum), .c(z));
  
  // Calculate the final Carry-Out
  or o1(cout, y, z);
endmodule

// Half Adder module
module half_adder(
  input a, b,
  output s, c
);
  // Half Adder logic: XOR for sum, AND for carry
  xor x1(s, a, b);
  and a1(c, a, b);
endmodule

Explanation:

  • The Full Adder module uses two Half Adders: the first adds A and B, and the second adds the result with Cin.
  • The final Carry-Out (Cout) is calculated using an OR gate.

Step 3: Testbench for Full Adder

To verify the functionality of the Full Adder, we use a testbench to simulate its behavior.

module full_adder_tb;
  reg a, b, cin;
  wire sum, cout;

  // Instantiate the Full Adder (DUT)
  full_adder f1(.a(a), .b(b), .cin(cin), .sum(sum), .cout(cout));

  // Dump waveform to visualize output
  initial begin 
    $dumpfile("full_adder_tb.vcd"); 
    $dumpvars();
  end

  // Test input combinations
  initial begin 
    a = 1'b1; #4; a = 1'b0; #10 $stop;
  end
  initial begin 
    b = 1'b1; forever #2 b = ~b;
  end
  initial begin 
    cin = 1'b1; forever #1 cin = ~cin; #10 $stop;
  end

  // Monitor inputs and outputs
  initial begin
    $monitor("Time=%0d A=%b B=%b Cin=%b Sum=%b Cout=%b", $time, a, b, cin, sum, cout);
  end
endmodule

Explanation:

  • The testbench generates all possible input combinations and monitors the output.
  • The $monitor command displays the results at each time step, showing how Sum and Cout change based on the inputs.

Step 4: Expected Output of Full Adder

After running the testbench, we expect the following outputs:

TimeABCinSumCout
011111
111001
210101
310010
401101
501010
600110
700000

Advantages of Implementing a Full Adder in Verilog HDL

  1. High-Level Representation: Verilog allows for a clear description of circuit behavior, making it easy to design and simulate complex digital circuits like the Full Adder.
  2. Reusability: The use of Verilog enables circuit designs to be reused across different platforms, promoting portability.
  3. Faster Development: Verilog simplifies the design and testing process, reducing the development time compared to other methods.
  4. Simulation Support: Verilog provides robust simulation tools to verify the design before physical implementation, ensuring accuracy.
  5. Scalability: The design can be easily modified or expanded without starting from scratch, making Verilog a flexible choice for digital circuit design.

Applications of a Full Adder in Digital Systems

1. Arithmetic Operations: Full Adders are fundamental components in arithmetic circuits, used in devices like processors and calculators.

2. Data Encryption: Full Adders are part of cryptographic algorithms for performing binary addition during encryption and decryption.

3. Memory Systems: Full Adders are used in address generation for accessing memory locations and devices in microcontrollers and digital systems.


Conclusion

The Verilog implementation of a Full Adder demonstrates how binary addition works by combining two input bits and a carry bit. The code provided models the Full Adder circuit, ensuring accurate addition operations in digital circuits. With Verilog, it becomes easier to implement, simulate, and test such fundamental digital components.

Scroll to Top