Mastering Verilog: Part 4 — Understanding ‘assign’, ‘always’ and ‘initial’ keywords.

 In our journey through Verilog, we’ve delved into various aspects like operators, modules, and data types. Now, let’s explore three fundamental keywords in Verilog that play crucial roles in describing behavior, initializing values, and creating continuous assignments: assign, always, and initial.

1. assign: Continuous Assignments

• The assign keyword in Verilog is used to create continuous assignments. These assignments describe combinational logic, where the output value is continuously updated based on the input values without any notion of time or sequence.
• Unlike procedural constructs like always and initial blocks, continuous assignments operate without a sensitivity list, specifically catering to the needs of combinational logic rather than sequential logic.
• Here’s how the assign keyword works:

Syntax:

assign <output_variable> = <expression>;

1. <output_variable>: The output or net that the assignment drives.
2. <expression>: The logic expression or value assigned to the output.

• Here’s a simple example to illustrate:

module ContinuousAssignmentExample(
input wire a,
input wire b,
output wire y
);
assign y = a & b; // Continuous assignment: y is the AND of a and b
endmodule

• In this example, y is assigned the result of the AND operation between inputs a and b continuously. Any change in a or b will immediately reflect in y.

Example:

module CombinationalLogicExamples(
input wire a, b, enable, sel,
input wire [3:0] inputs,
input wire data_in,
output reg y1, y2, y3, y4, y5, y6, y7, y8,
);

// Example 1: AND gate using assign
assign y1 = a & b;

// Example 2: Multiplexer using assign
assign y2 = (sel) ? b : a;

// Example 3: Bitwise XOR using assign
assign y3 = a ^ b;

// Example 4: Bitwise NOT using assign
assign y4 = ~a;

// Example 5: Conditional assignment using assign
assign y5 = (enable) ? data_in : 0;

// Example 6: OR gate using assign
assign y6 = a | b;

// Example 7: NAND gate using assign
assign y7 = ~(a & b);

// Example 8: Tri-state buffer using assign
assign y8 = (enable) ? data_in : 1'bz;

endmodule

This module CombinationalLogicExamples includes examples of various combinational logic circuits implemented using the assign keyword in Verilog. It showcases AND gates, multiplexers, bitwise operations, conditional assignments, logic gates, and a tri-state buffer, all driven by continuous assignments.

2. always: Procedural Continuous Behavior

• In Verilog, an always block is used to describe behavior that is sensitive to certain events or conditions.
• It is commonly used for modeling sequential logic elements such as flip-flops, registers, state machines, and other sequential circuits.
• These blocks describe behavior that occurs continuously in a simulation.
• There are different types of always blocks based on sensitivity lists:

1. always @(*): This is used for combinational logic, where the block is executed whenever any of its inputs change.
2. always @(posedge clk): This is used for sequential logic triggered by the positive edge of a clock signal.

• Here’s an example of how an always block is used in Verilog:

module SequentialLogicExample(
input wire clk, reset,
input wire [3:0] data_in,
output reg [3:0] data_out
);

// Register declaration
reg [3:0] reg_data;

// Sequential logic using always block
always @(posedge clk or posedge reset) begin
if (reset) begin
// Reset condition: initialize register to 0
reg_data <= 4'b0000;
end else begin
// Positive edge of clock: update register with input data
reg_data <= data_in;
end
end

// Output assignment
assign data_out = reg_data;

endmodule

Explanation:

• The always block is triggered by the positive edge of the clk signal or the positive edge of the reset signal.
• Inside the always block, there is an if-else statement that handles two conditions:
  1. When reset is high, the register reg_data is initialized to 4'b0000.
  2. When the positive edge of clk occurs (and reset is not high), the register reg_data is updated with the input data_in.
• The assign statement outside the always block assigns the value of reg_data to the output data_out.

This example demonstrates how an always block is used to model sequential logic in Verilog. The sensitivity list (posedge clk or posedge reset) specifies the events that trigger the execution of the block.

3. initial: Initializing Values

• In Verilog, an initial block is used to initialize variables, registers, or memory elements at the start of simulation. It executes only once when the simulation begins or when the module is instantiated.
• It is particularly useful for setting up initial conditions before simulation begins.
• Here’s an example showcasing the initial block:

module InitialExample(
input wire clk,
output reg q
);
reg [3:0] counter; // Declare a register for counting

initial
begin
counter = 4'b0000; // Initialize counter to 0 at simulation start
end

always @(posedge clk)
begin
if (counter == 4'b1010)
counter <= 4'b0000; // Reset counter at specific value
else
counter <= counter + 1; // Increment counter otherwise
end

always @(posedge clk)
q <= counter[2]; // Output the third bit of the counter
endmodule

Explanation:

• The module InitialExample has an input clock clk and an output q representing the third bit of a counter.
• Inside the module, a reg type variable counter of size 4 bits is declared to count from 0 to 9. The initial block is used to initialize counter to 4'b0000 (0) at the start of simulation.
• The first always block triggers on the positive edge of the clock clk. It checks if counter reaches the value 4'b1010 (10 in decimal) and resets counter to 4'b0000 if so. Otherwise, it increments counter by 1.
  The second always block also triggers on the positive edge of clk and assigns the value of the third bit (counter[2]) of the counter to the output q.

This example demonstrates the use of the initial block for setting initial values and always blocks for sequential logic and output generation in Verilog.

Conclusion:

In this journey through Verilog, we’ve explored essential keywords that form the backbone of behavioral modeling and initialization in Verilog HDL. The assign keyword enables continuous assignments, perfect for describing combinational logic without time dependencies. On the other hand, the always block embodies procedural continuous behavior, making it ideal for modeling sequential logic elements such as flip-flops and registers. Lastly, the initial block serves as the foundation for initializing variables, registers, or memory elements at the simulation’s outset, ensuring the system starts with the desired initial conditions.

Understanding these keywords not only enhances our Verilog coding skills but also equips us to design and simulate complex digital systems effectively. Whether it’s creating continuous logic, modeling sequential circuits, or setting up initial states, mastering these Verilog keywords is essential for FPGA design and digital circuit implementation.

Happy coding and exploring the vast world of Verilog!

Like, Share and Follow me if you like my content.
Thank You.