Mastering Verilog: Part 7- Understanding Looping Statements.

Welcome back to our series on mastering Verilog! So far, we’ve covered essential topics like modules, operators, data types, assign statements, initial and always blocks, and conditional statements. Now, let’s dive into the world of looping statements in Verilog.

Looping statements in Verilog allow you to repeat a block of code multiple times, making your designs more efficient and scalable. Verilog provides several looping constructs, including for, while, repeat, and forever loops, each serving specific purposes. All looping statements can only be written inside procedural (initial and always) blocks.

Let us consider each looping statement one by one:

1. For Loop

The for loop in Verilog is used to execute a block of code a specified number of times. It follows this syntax:

for (initialization; condition; increment) begin
// code to execute in each iteration
end

Here’s an example of a for loop in Verilog:

module ForLoopExample (
input wire [7:0] data_in,
output wire [7:0] data_out
);

reg [7:0] sum;

always @(*) begin
sum = 8'b00000000;
for (int i = 0; i < 8; i = i + 1) begin
sum = sum + data_in[i];
end
end

assign data_out = sum;
endmodule

Explanation:
In this code:

1. data_in is an 8-bit input.
2. sum is an 8-bit register initialized to all zeros.
3. The always @(*) block indicates that the block should execute whenever there is a change in the inputs (data_in in this case).
4. The for loop iterates from i = 0 to i < 8, incrementing i by 1 in each iteration.
5. In each iteration of the loop, sum is updated by adding the value of data_in[i] to it.
6. Initially, sum is set to 00000000 (in binary) or 0 in decimal.
7. In the first iteration of the loop (i = 0), data_in[0] is added to sum.
8. In the second iteration (i = 1), data_in[1] is added to sum, and so on until the loop completes all 8 iterations (i = 7).
9. At the end of the loop, sum will contain the sum of all elements in data_in. The output data_out will be the sum of all elements in data_in.

2. While Loop

The while loop in Verilog repeats a block of code as long as a specified condition remains true. Its syntax is as follows:

while (condition) begin
// code to execute as long as condition is true
end

Here’s an example of a while loop in Verilog:

module WhileLoopExample (
input wire [7:0] data_in,
output wire [7:0] data_out
);

reg [7:0] inverted_data;

always @(*) begin
int i = 0;
while (i < 8) begin
inverted_data[i] = ~data_in[i];
i = i + 1;
end
end

assign data_out = inverted_data;
endmodule

Explanation:
In this code:

1. data_in is an 8-bit input.
2. inverted_data is an 8-bit register used to store the inverted bits of data_in.
3. The always @(*) block indicates that the block should execute whenever there is a change in the inputs (data_in in this case).
4. The while loop iterates as long as i is less than 8 (i.e., while i is in the range 0 to 7).
5. In each iteration of the loop, the bit at position i in data_in is inverted using the ~ operator and stored in the corresponding position in inverted_data.
6. The loop increments i by 1 in each iteration until i reaches 8, at which point the loop exits.
7. The output data_out will be the value of inverted_data, which contains the inverted bits of data_in. For example, if data_in is 10101010 (in binary), data_out will be 01010101, where each bit is inverted.

3. Repeat Loop

The repeat loop in Verilog repeats a block of code a specified number of times. Its syntax is as follows:

repeat (count) begin
// code to repeat count times
end

Here’s an example of a repeat loop in Verilog:

module RepeatLoopExample (
input wire [3:0] count,
output wire [3:0] result
);

reg [3:0] temp_result;

always @(*) begin
temp_result = 4'b0000;
repeat (count) begin
temp_result = temp_result + 1;
end
end

assign result = temp_result;
endmodule

Explanation:
In this code:

1. count is a 4-bit input representing the number of times the loop should repeat.
2. result is a 4-bit output that will store the final result after the loop.
   temp_result is a 4-bit register used to accumulate the result within the loop.
3. The always @(*) block indicates that the block should execute whenever there is a change in the inputs (count in this case).
4. The repeat loop is used to repeat a block of code a specified number of times, which is determined by the value of count. Here’s how the loop works in this example:
5. temp_result is initialized to 0000.
6. The repeat loop executes count times.
7. In each iteration of the loop, temp_result is incremented by 1 (temp_result = temp_result + 1).
8. After the loop completes all repetitions, the final value of temp_result is assigned to result.
9. For instance, if count is 5 (binary 0101), the repeat loop will execute 5 times, and result will be 0101 (binary) or 5 (decimal), as temp_result is incremented by 1 in each iteration.

4. Forever Loop

The forever loop in Verilog executes a block of code indefinitely. Its syntax is as follows:

forever begin
// code to execute indefinitely
end

Here’s an example of a while loop in Verilog:

module ForeverLoopExample (
input wire clk,
input wire start,
output wire [3:0] counter_out
);

reg [3:0] counter;

always @(posedge clk) begin
if (start) begin
counter <= 4'b0000;
forever begin
counter <= counter + 1;
end
end
end

assign counter_out = counter;
endmodule

Explanation:
In this code:

1. clk is a clock input.
2. start is a control input that triggers the beginning of the counting process.
3. counter_out is a 4-bit output that will store the counter’s value.
4. The forever loop is used to continuously execute a block of code indefinitely, which is useful for tasks that need to run continuously without a predefined end. Here’s how the forever loop works in this example:
5. The always @(posedge clk) block triggers on the positive edge of the clock (clk), indicating synchronous behavior.
6. When the start signal is asserted (start == 1), the counting process begins.
7. Inside the forever loop, counter is continuously incremented by 1 (counter <= counter + 1).
8. This example demonstrates a simple counter that starts counting when the start signal is asserted. The counter_out output continuously reflects the value of the counter register, incrementing by 1 on each clock cycle after the start signal is asserted. The forever loop ensures that the counting operation continues indefinitely until there is a change in the design or a specific condition to stop the counting process.

Conclusion

Looping statements such as for, while, repeat, and forever are indispensable tools in Verilog for executing repetitive tasks efficiently and effectively. By mastering these looping constructs, you can enhance the functionality and performance of your Verilog designs. Stay tuned for more insights and examples in our ongoing journey to master Verilog programming!

Like, share and follow me if you like my content.
Thank You!