Learn Verilog in One Day: A Beginner-Friendly Easy Free Guide to Digital Design

Are you ready to learn Verilog in just one day? Verilog is a powerful hardware description language (HDL) that enables you to design and simulate digital circuits like those in computers, smartphones, and modern electronics. This 16-hour step-by-step guide will walk you through the basics to advanced concepts, making it ideal for beginners or anyone looking to enhance their hardware design skills.

Prerequisite: Basic knowledge on digital circuit and C programming language.

Introduction: What is Verilog? (30 Minutes)

What You’ll Learn

In this section, you’ll explore the fundamentals of Verilog, its importance in digital design, and the tools you need to get started. This foundation is essential for progressing through the rest of the guide.

Let’s Learn

• What is Verilog?:
  • Verilog is a hardware description language used to design and simulate digital systems. It works by describing how a circuit should behave, and then tools can translate this into a real physical design. Think of it like writing blueprints for how a machine or gadget should work.
• Why Use Verilog?:
  • Verilog is essential for creating and testing digital systems. Whether it’s a computer processor, a smartphone chip, or even a smart gadget, Verilog helps engineers turn ideas into real, working technology. It allows designers to create complex systems efficiently, saving time and reducing errors.
• Tools You Need:
  • To work with Verilog, you’ll need software tools like ModelSim, Vivado, or Quartus. These programs allow you to write Verilog code, simulate how your designs behave, and even prepare them for implementation in hardware. They’re like the ultimate toolkit for digital designers!
• Want to know more?: Visit What Is Verilog: A Comprehensive Guide – Skill Seminary

Hour 1-2: Verilog Basics: Syntax, Data Types, and Logic (2 Hours)

What You’ll Learn

This section introduces you to the structure of Verilog code, including syntax, data types, and basic operators. By the end of these two hours, you’ll be able to write your first Verilog program and understand how hardware logic is described in code.

Let’s Learn

• Building Blocks:
  • Verilog designs revolve around modules and ports. Modules are like “containers” that hold the logic of your design, while ports are the interfaces that allow the module to connect with the outside world. For example, inputs bring signals into the module, and outputs send signals out.
  • Think of a module as a function in programming and the ports as the function’s parameters. These building blocks are what you will use to create circuits.
• Data Types and Symbols:
  • Verilog uses special data types like wire and reg. A wire is used to represent a connection, and it constantly carries a value. A reg is used for storing data and can be updated at specific times, like in a flip-flop.
  • Operators such as & (AND), | (OR), and ~ (NOT) are used to describe how signals interact. These operators make it easy to build logic circuits directly in code.
• Write Your First Program:
  • The first program demonstrates a simple AND gate. This gate takes two inputs, a and b, and outputs c, which is true only when both a and b are true. Writing this program will help you see how Verilog translates logic into hardware representation.

• Example: Simple AND Gate

module AND_Gate (input a, input b, output c);
    assign c = a & b;
endmodule

• Explanation of the Example
  • What It Does: This program creates a simple AND gate using Verilog. The module keyword defines the circuit, and assign connects the output c to the logic operation a & b. This means c will be 1 (true) only if both a and b are 1.
  • Inputs and Outputs: The input keyword defines the input signals a and b, while the output keyword defines the result signal c.
  • Logic Operation: The & symbol represents the AND operation, just like in logic gates. When you run this code in a simulation, you’ll see how c changes based on a and b.

Hour 3-4: Simulate Verilog Designs: Tools and Testbenches (2 Hours)

What You’ll Learn

Simulation is a crucial part of hardware design. In this section, you’ll install simulation tools, learn how to write testbenches, and analyze the behavior of your circuits through waveforms.

Let’s Learn

• Install Simulation Tools: Learn how to download and install tools like ModelSim, Vivado, or Quartus. These tools are essential for verifying that your Verilog code behaves as expected. Follow these links for step-by-step installation guides:
  • ModelSim Installation Guide
  • Vivado Installation Guide
  • Quartus Prime Installation Guide
• Using Simulation Tools: After installation, familiarize yourself with these tools by exploring their official documentation and tutorials. These resources will guide you through creating projects, running simulations, and analyzing results:
  • Getting Started with ModelSim
  • Vivado Beginner Tutorial
  • Quartus Prime Tutorial
• Write a Simple Testbench: A testbench is a piece of code that checks if your design works. It provides inputs to your design and verifies the outputs.

Example Testbench for AND Gate

module Test_AND_Gate;
    reg a, b;
    wire c;

    // Instantiate the module to be tested
    AND_Gate uut (.a(a), .b(b), .c(c));

    initial begin
        // Test cases
        a = 0; b = 0; #10;
        a = 0; b = 1; #10;
        a = 1; b = 0; #10;
        a = 1; b = 1; #10;
    end
endmodule

Explanation of the Testbench

• What It Does: This testbench checks if the AND gate works correctly. It sends all possible combinations of a and b to the AND gate and observes the output c.
• Key Parts:
  • reg and wire: a and b are declared as reg because they are test inputs, and c is declared as wire because it is connected to the module output.
  • Instantiation: The AND_Gate module is instantiated and connected to the test inputs and output using .a(a), .b(b), and .c(c).
  • Test Cases: The initial block defines the input values (a and b) and the simulation time (#10). For each combination of a and b, the output c is observed to ensure it matches the AND gate’s truth table.
• Expected Output: In the simulation, c will be 1 only when both a and b are 1, which is the behavior of an AND gate.
• Run Your Simulation: Open your simulation tool and load the testbench. Simulate the design to see the waveforms and verify that the outputs match your expectations.

Hour 5-6: Build Circuits with Modules (2 Hours)

What You’ll Learn

Learn how to design and build circuits using modules, ports, and other Verilog features. Understand how these parts interact to create a complete system.

Let’s Learn

Parts of a Module:

• Ports (input, output):
  • Define the inputs and outputs of a module. Inputs receive data, and outputs send results. Ports allow communication between modules and the outside environment.

Example 1:

module Example_Module(input a, input b, output c);
    assign c = a & b;
endmodule

Example 2:

module Example_Module;
    input a, b;
    output c;
    assign c = a & b;
endmodule

• Declarations (wire, reg):
  • Inside a module, use wire for connections and reg for storing values. wire carries data continuously, while reg holds data until explicitly updated in sequential logic.
  • Example:

module Declarations_Example;
    wire a, b, c;
    reg d;
    assign c = a & b; // 'wire' for continuous assignment
    always @(posedge d)
        d < = a | b;  // 'reg' for storing value
endmodule

• Assign Statements:
  • Use assign to create continuous assignments that directly connect inputs to outputs or define simple logic operations. This is typically used for combinational logic.
  • Example:

module Assign_Example(input a, input b, output c);
    assign c = a | b; // Continuous assignment for OR operation
endmodule

• Operators:
  • Use logic operators like & (AND), | (OR), ~ (NOT), and ^ (XOR) to build logic expressions. These operators mimic the behavior of logic gates in hardware. Example is as follows:

module Operators_Example(input a, input b, output not_a, output and_ab, output xor_ab);

  assign not_a = ~a;
  assign and_ab = a & b;
  assign xor_ab = a ^ b;

endmodule

• Instantiation:
  • Modules can call or instantiate other modules to reuse logic. For example, a 4-bit adder reuses a 1-bit adder multiple times to build a larger design. Example is as follows:

module Instantiation_Example;

  wire a, b, cin, sum, cout;
  Full_Adder FA0 (.a(a), .b(b), .cin(cin), .sum(sum), .cout(cout));

endmodule

Design Example: 

Example: 1-Bit Full Adder

A 1-Bit Full Adder is a basic building block used to add three binary inputs: two data bits and a carry-in bit. It produces a sum bit and a carry-out bit as outputs. It’s the foundation for constructing larger adders like a 4-bit Ripple Carry Adder.

module Full_Adder (input a, input b, input cin, output sum, output cout);
    assign sum = a ^ b ^ cin; // XOR operation for the sum bit
    assign cout = (a & b) | (b & cin) | (a & cin); // Carry-out calculation
endmodule

Explanation of the Code

• Inputs:
  • a and b are the two binary bits to be added.
  • cin is the carry-in from a previous stage, used in multi-bit addition.
• Outputs:
  • sum is the result of the addition for the current bit.
  • cout is the carry-out, passed to the next higher bit in multi-bit addition.
• Logic Operations:
  • The XOR operator (^) is used for the sum bit. It ensures the sum is 1 only when an odd number of inputs are 1.
  • The carry-out is calculated using a combination of AND (&) and OR (|) operations to handle cases where two or more inputs are 1.

How It Works

When a, b, and cin are inputs, the Full Adder:

1. Calculates the sum using XOR logic: sum = a XOR b XOR cin.
2. Computes the cout using the formula: cout = (a & b) | (b & cin) | (a & cin).
3. These outputs can then be passed to the next stage of addition in multi-bit systems like the 4-bit Ripple Carry Adder.

Example: 4-Bit Ripple Carry Adder

The 4-bit Ripple Carry Adder is a circuit that adds two 4-bit binary numbers and produces a 4-bit sum and a carry-out. It uses multiple 1-bit Full Adders connected in sequence. The carry-out of one Full Adder becomes the carry-in of the next.

This adder is called “ripple carry” because the carry signal ripples through each adder sequentially, potentially causing a delay.

module Ripple_Carry_Adder_4bit (
    input [3:0] a, b,      // 4-bit inputs a and b
    input cin,             // Input carry-in
    output [3:0] sum,      // 4-bit sum output
    output cout            // Carry-out of the final adder
);
    wire c1, c2, c3;        // Internal wires for carry signals

    // Instantiate four 1-bit Full Adders
    Full_Adder FA0 (.a(a[0]), .b(b[0]), .cin(cin), .sum(sum[0]), .cout(c1));  // Add LSBs
    Full_Adder FA1 (.a(a[1]), .b(b[1]), .cin(c1), .sum(sum[1]), .cout(c2));   // Add next bits
    Full_Adder FA2 (.a(a[2]), .b(b[2]), .cin(c2), .sum(sum[2]), .cout(c3));   // Add next bits
    Full_Adder FA3 (.a(a[3]), .b(b[3]), .cin(c3), .sum(sum[3]), .cout(cout)); // Add MSBs
endmodule

Explanation of the Code

• Inputs and Outputs:
  • a and b are the two 4-bit binary numbers to be added.
  • cin is the initial carry-in, typically set to 0 for addition.
  • sum is the 4-bit result of the addition.
  • cout is the carry-out of the final Full Adder.
• Internal Wires:
  • c1, c2, and c3 are intermediate carry signals that connect the carry-out of one Full Adder to the carry-in of the next.
• Instantiating Full Adders:
  • Four Full Adders (FA0, FA1, FA2, FA3) are instantiated.
  • Each Full Adder takes one bit from a and b, along with the carry-in, and produces a sum bit and carry-out.
• Sequential Operation:
  • The carry-out of FA0 becomes the carry-in for FA1, and so on. This ripple effect continues until the final carry-out is generated by FA3.

How It Works

When you input two 4-bit numbers (a and b) and a carry-in (cin), the Ripple Carry Adder adds the corresponding bits of a and b starting from the least significant bit (LSB). It produces a sum bit for each position and generates a carry-out that is passed to the next higher bit. Finally, the most significant carry-out (cout) indicates an overflow if the sum exceeds 4 bits.

Hour 6-8: Master Initial and Always Blocks (3 Hours)

What You’ll Learn

In this section, you’ll dive into two fundamental blocks in Verilog: the initial and always blocks. These blocks are essential for defining how and when certain parts of your circuit behave.

Let’s Learn

Initial Block:

• Used for defining test scenarios and one-time execution tasks.Executes statements sequentially at the start of a simulation.

• Example:

initial begin
  $display("Simulation Start");
  a = 0; b = 1; // Assign initial values 
  #10 a = 1; // Change value of a after 10 time units 
  #20 b = 0; // Change value of b after 20 time units 
  $finish; // End simulation 
end

• Explanation: The $display statement prints a message to the console. #10 and #20 introduce delays in simulation, allowing you to observe changes over time.

Always Block:

• Used for defining repetitive or event-driven behavior.
• Executes whenever a specified event (e.g., a signal change) occurs.
• Example:

always @(posedge clk or posedge reset) begin
    if (reset)
        count <= 0; // Reset the counter to 0
    else
        count <= count + 1; // Increment counter on clock edge
end

• Explanation: @(posedge clk or posedge reset) specifies that the block triggers on the rising edge of clk or reset. The if condition ensures the counter resets when reset is high; otherwise, it increments on each clock cycle.

Combining Initial and Always Blocks:

• Use initial blocks for testbenches and always blocks for modeling hardware behavior.

• Example

module Test_Module;
    reg clk, reset;
    reg [3:0] count;

    // Clock generation
    initial begin
        clk = 0;
        forever #5 clk = ~clk; // Toggle clock every 5 time units
    end

    // Reset signal
    initial begin
        reset = 1;
        #15 reset = 0; // De-assert reset after 15 time units
    end

    // Counter behavior
    always @(posedge clk or posedge reset) begin
        if (reset)
            count <= 0;
        else
            count <= count + 1;
    end
endmodule

• Explanation:

The first initial block generates a clock signal that toggles every 5 time units.

The second initial block controls the reset signal, asserting it at the start and de-asserting it after 15 time units.

The always block defines the counter’s behavior, ensuring it resets or increments as required.

Hour 8-9: Tasks and Functions (1 Hour)

What You’ll Learn

This section introduces you to tasks and functions, which are reusable blocks of code in Verilog. These constructs help organize your design by separating repetitive or complex operations into smaller, manageable units.

Let’s Learn

• Tasks:
  • Tasks allow you to perform sequential operations and can contain timing delays.
  • They are useful for testbenches or simulation purposes where delays and complex operations are required.

Example:

task add;
  input [3:0] a, b;
  output [4:0] sum;
  begin
    sum = a + b; // Add the two inputs
  end
endtask

module Task_Example;
  reg [3:0] a, b;
  wire [4:0] sum;

  initial begin
    a = 4'b0101; // 5
    b = 4'b0011; // 3
    add(a, b, sum); // Call the task
    $display("Sum = %b", sum);
  end
endmodule

Explanation:

• The task named add performs addition of two 4-bit inputs and stores the result in a 5-bit output.
• The initial block demonstrates how the task is called.
• Functions:
  • Functions are similar to tasks but cannot include delays.
  • They return a single value and are used for combinational logic.

Example:

function [3:0] multiply;
  input [1:0] a, b;
  begin
    multiply = a * b; // Multiply the two inputs
  end
endfunction

module Function_Example;
  reg [1:0] a, b;
  wire [3:0] result;

  assign result = multiply(a, b); // Call the function

  initial begin
    a = 2'b10; // 2
    b = 2'b11; // 3
    #10;
    $display("Result = %b", result);
  end
endmodule

Explanation:

• The function named multiply calculates the product of two 2-bit inputs and returns a 4-bit result.
• The assign statement demonstrates how the function is used in the module.

Hour 9-10: Operators and Programming Statements (1 Hour)

What You’ll Learn

In this section, you’ll learn about the various operators and programming statements available in Verilog. These are fundamental to building complex designs and simulating them effectively.

Let’s Learn

• Operators:
  • Arithmetic Operators:
    • + (Addition), - (Subtraction), * (Multiplication), / (Division), % (Modulus).
    • Used for mathematical operations in your designs.

Example:

module Arithmetic_Operators;
  reg [3:0] a = 4'b1010; // 10
  reg [3:0] b = 4'b0011; // 3
  wire [3:0] sum;
  assign sum = a + b; // sum = 13
endmodule

• Logical Operators:
  • && (Logical AND), || (Logical OR), ! (Logical NOT).
  • Evaluate conditions in behavioral blocks.

Example:

always @(posedge clk) begin
   if (enable && ready)
      data_out <= data_in;
end

• Bitwise Operators:
  • & (Bitwise AND), | (Bitwise OR), ^ (Bitwise XOR), ~ (Bitwise NOT).
  • Perform operations on individual bits of a vector.

Example:

assign result = a & b; // Bitwise AND of a and b

• Shift Operators:
  • << (Left Shift), >> (Right Shift).
  • Shift bits to the left or right, often used for scaling.

Example:

assign shifted = a << 2; // Shift a left by 2 bits

• Programming Statements:
  • Conditional Statements:
    • if, else, and case statements are used for decision-making in behavioral models.

Example:

always @(a or b) begin
  if (a > b)
    max = a;
  else
  max = b;
end

• Looping Statements:
  • for, while, and repeat loops enable iteration over operations.

Example:

always @(posedge clk) begin
   for (i = 0; i < 4; i = i + 1)
      sum[i] <= a[i] + b[i];
end

• Blocking and Non-blocking Assignments:
  • = (Blocking) and <= (Non-blocking) are used in procedural blocks to control assignment timing.

Example:

always @(posedge clk) begin
   a = b;  // Blocking
   c <= a; // Non-blocking
end

Hour 10-11: Add Memory to Circuits (2 Hours)

What You’ll Learn

Design circuits that remember data. Memory elements are critical for enabling circuits to store information, process sequential operations, and create state-based systems. 

By the end of this section, you’ll know how to:

• Use flip-flops and registers to store and process data.
• Design state machines for sequential operations and control systems.
• Understand how memory elements enable sequential circuit behavior.

Let’s Learn

• Flip-Flops:

Store a single bit of data and operate based on clock signals. Trigger on clock edges (positive or negative).

Example: D Flip-Flop

module D_FlipFlop (input clk, input d, output reg q);
   always @(posedge clk) begin
       q <= d; // Store input d at the rising edge of the clock
   end
endmodule

Explanation:

The always block is triggered on the positive edge of clk. The value of d is assigned to q at each clock pulse.

• Registers:

Group of flip-flops used to store multi-bit data. Operate as an extension of single flip-flops for larger data storage.

Example: 4-Bit Register

module Register (input clk, input [3:0] d, output reg [3:0] q);
   always @(posedge clk) begin
      q <= d; // Store 4-bit input d at the rising edge of the clock
   end
endmodule

Explanation:

d is a 4-bit input, and q is the 4-bit output. The always block ensures that the input d is stored in q at every rising edge of the clock.

• State Machines:

A circuit that transitions between defined states based on inputs and current states. Widely used in control systems, such as traffic light controllers or vending machines.

Example: Simple 2-State Machine

module State_Machine (input clk, input reset, output reg state);
   parameter STATE_0 = 1'b0, STATE_1 = 1'b1;

   always @(posedge clk or posedge reset) begin
       if (reset)
          state <= STATE_0; // Reset to initial state
       else
          state <= ~state; // Toggle state on every clock pulse
   end
endmodule

Explanation:

This module toggles between two states (STATE_0 and STATE_1) on each clock pulse unless reset is active.

Hour 11-12: Timing and Simulation (2 Hours)

Let’s Learn

Understand how to handle timing in circuits. Timing ensures that your designs operate correctly and efficiently.

By the end of this section, you’ll be able to:

• Introduce delays into your simulations to test behavior over time.
• Understand and respect setup and hold timing requirements for reliable circuit design.
• Use waveform viewers in simulation tools to debug and analyze circuit performance.

Topics

• Delays:
  • Use the # operator to introduce timing delays in simulations. This is useful for testing the behavior of your circuits over time.

Example: Simulating a Signal Delay

module Signal_Delay;
  reg a;
  initial begin
    a = 0;        // Initialize signal
    #10 a = 1;    // Change value after 10 time units
    #20 a = 0;    // Change back after 20 time units
  end
endmodule

Explanation:

• The # operator introduces delays of 10 and 20 time units to simulate the behavior of the signal a over time.
• Timing Rules:
  • Setup and hold times define how data is stabilized before and after a clock edge.
  • Violating these rules can lead to unreliable circuit behavior.

Example: Flip-Flop with Setup and Hold Timing

module Setup_Hold_Timing (input clk, input d, output reg q);
   always @(posedge clk) begin
      q <= d; // Data must meet setup and hold time requirements
   end
endmodule

Explanation:

• The module simulates a scenario where the input d must be stable before the clock edge to ensure proper operation.
• Waveforms:
  • Use waveform analysis tools in simulators to visualize signal changes and ensure proper timing.

Example: Generating a Clock Signal

module Clock_Generator;
  reg clk;
  initial begin
    clk = 0;
    forever #5 clk = ~clk; // Toggle clock every 5 time units
  end
endmodule

Explanation:

• This module generates a clock signal that toggles every 5 time units, which can be visualized in a waveform viewer during simulation.

Additional Example: Testing Signal Timing with Waveforms

module Waveform_Test;
  reg a, b;
  wire c;

  assign c = a & b; // AND operation

  initial begin
    a = 0; b = 0;
    #10 a = 1; // Change signal a after 10 time units
    #20 b = 1; // Change signal b after 20 time units
  end
endmodule

Explanation:

• The waveform for signals a, b, and c can be analyzed to ensure proper propagation delays and behavior.

Hour 13-14: What Works in Hardware (1 Hour)

What You’ll Learn

Understand which parts of your code can be synthesized into hardware and which are purely for simulation. This section clarifies the difference and provides examples to help you write hardware-compatible designs.

By the end of this section, you’ll be able to:

• Write Verilog code that is compatible with hardware synthesis.
• Identify non-synthesizable constructs and use them effectively in simulations.
• Separate your hardware design from testing environments for better clarity and results.

Let’s Learn

• Synthesizable Code:
  • Synthesizable code can be converted into physical hardware on FPGAs or ASICs.
  • Includes constructs like always blocks for combinational and sequential logic, assign statements, and instantiations.

Example: Simple Combinational Circuit

module Synthesizable_Circuit (input a, b, output c);
   assign c = a & b; // Logical AND operation
endmodule

Explanation:

• The assign statement generates hardware logic for the AND operation.

Example: Sequential Logic with Flip-Flop

module Synthesizable_FF (input clk, reset, d, output reg q);
   always @(posedge clk or posedge reset) begin
      if (reset)
        q <= 0; // Reset output to 0
      else
        q <= d; // Store input on clock edge
   end
endmodule

Explanation:

• This code creates a D flip-flop triggered by the rising edge of the clock or reset signal.
• Non-Synthesizable Code:
  • Non-synthesizable code is used only for simulation and cannot be converted into hardware.
  • Includes constructs like delays (#), initial blocks, and testbenches.

Example: Delays in Testbench

initial begin
  a = 0; b = 0;
  #10 a = 1; // Change a after 10 time units
  #20 b = 1; // Change b after 20 time units
end

Explanation:

• The initial block and # delays are for simulation purposes and help test circuit behavior.
• Combining Synthesizable and Non-Synthesizable Code:
  • Use synthesizable code for hardware design and non-synthesizable code for testing.
  • Keep testing constructs separate from the design modules.

Example: Synthesizable Design with Non-Synthesizable Testbench

module AND_Gate (input a, b, output c);
  assign c = a & b; // Synthesizable logic
endmodule

module Testbench;
  reg a, b;
  wire c;

  // Instantiate the design
  AND_Gate uut (.a(a), .b(b), .c(c));

  initial begin
    a = 0; b = 0; #10;
    a = 1; b = 0; #10;
    a = 1; b = 1; #10;
  end
endmodule

Explanation:

• The AND_Gate module is synthesizable, while the Testbench module is used for simulation.

Hour 15: Mini Project: Build a 4-Bit ALU (1 Hour)

What You’ll Do

Apply your knowledge to design and test a 4-bit Arithmetic Logic Unit (ALU). This mini project combines concepts like modules, operators, and sequential logic to build a practical and reusable digital circuit.

Let’s Learn

• Operations: Add, subtract, AND, OR.
• Inputs: Two 4-bit numbers and a 2-bit selector for the operation.
• Output: The 4-bit result.

Code Example: 4-Bit ALU

module ALU_4bit (
    input [3:0] a, b,         // 4-bit inputs a and b
    input [1:0] sel,          // 2-bit selector
    output reg [3:0] result,  // 4-bit result
    output reg carry_out      // Carry-out for addition/subtraction
);
    always @(*) begin
        case (sel)
            2'b00: {carry_out, result} = a + b;      // Addition
            2'b01: {carry_out, result} = a - b;      // Subtraction
            2'b10: result = a & b;                  // AND
            2'b11: result = a | b;                  // OR
            default: result = 4'b0000;              // Default case
        endcase
    end
endmodule

Explanation of the Code

• Inputs and Outputs:
  • a and b are the two 4-bit inputs.
  • sel is a 2-bit selector that determines the operation.
  • result stores the 4-bit output of the operation.
  • carry_out indicates an overflow in addition or subtraction.
• Operation Selection:
  • sel controls the operation via a case statement:
    • 00: Perform addition with carry-out.
    • 01: Perform subtraction with carry-out.
    • 10: Perform bitwise AND.
    • 11: Perform bitwise OR.
• Behavior:
  • The always @(*) block ensures that the logic reacts to any change in inputs or selector values.

Testing the ALU

To verify the ALU, you can write a simple testbench:

module Test_ALU_4bit;
    reg [3:0] a, b;
    reg [1:0] sel;
    wire [3:0] result;
    wire carry_out;

    // Instantiate the ALU
    ALU_4bit uut (.a(a), .b(b), .sel(sel), .result(result), .carry_out(carry_out));

    initial begin
        // Test addition
        a = 4'b0101; b = 4'b0011; sel = 2'b00; #10;
        $display("Addition: a=%b, b=%b, result=%b, carry_out=%b", a, b, result, carry_out);

        // Test subtraction
        a = 4'b0101; b = 4'b0010; sel = 2'b01; #10;
        $display("Subtraction: a=%b, b=%b, result=%b, carry_out=%b", a, b, result, carry_out);

        // Test AND
        a = 4'b1100; b = 4'b1010; sel = 2'b10; #10;
        $display("AND: a=%b, b=%b, result=%b", a, b, result);

        // Test OR
        a = 4'b1100; b = 4'b1010; sel = 2'b11; #10;
        $display("OR: a=%b, b=%b, result=%b", a, b, result);
    end
endmodule

Explanation of the Testbench

• Inputs:
  • Sets a and b to different values and cycles through the operations using sel.
• Verification:
  • Outputs results to the console using $display for easy debugging.

Hour 16: Review and Next Steps (1 Hour)

Let’s Learn

Go over what you’ve learned and plan what’s next.

Steps

• Review: Look at the key ideas from today and make sure you understand them.
• Debug: Fix any issues with your project to make it perfect.
• Learn More: Explore books like “Digital Design and Verilog HDL Fundamentals” by J. Bhasker or online tutorials to continue your journey.

Conclusion

This 16-hour guide is a great way to start learning Verilog. By following this plan, you’ll understand the basics and be ready for bigger challenges. Each step builds on the last, making it easy to see your progress.

Want to learn more? Check out advanced Verilog tutorials and projects on SkillSeminary.com to keep growing your skills!

FAQ