Carnegie Mellon

Verilog for Sequential Circuits

Design of Digital Circuits 2014

Srdjan Capkun
Frank K. Grkaynak

http://www.syssec.ethz.ch/education/Digitaltechnik_14

1
Adapted from Digital Design and Computer Architecture, David Money Harris & Sarah L. Harris 2007 Elsevier
 Carnegie Mellon

What will we learn?

Short summary of Verilog Basics

Sequential Logic in Verilog

Using Sequential Constructs for Combinational Design

Finite State Machines

2
 Carnegie Mellon

Summary: Defining a module

A module is the main building block in Verilog

We first need to declare:

Name of the module
Types of its connections (input, output)
Names of its connections

a
Verilog
b y
Module
c

3
 Carnegie Mellon

Summary: Defining a module

a
Verilog
b y
Module
c

module example (a, b, c, y);

input a;
input b;
input c;
output y;

// here comes the circuit description

endmodule
4
 Carnegie Mellon

Summary: What if we have busses ?

You can also define multi-bit busses.
[ range_start : range_end ]

input [31:0] a; // a[31], a[30] .. a[0]

output [15:8] b1; // b1[15], b1[14] .. b1[8]
output [7:0] b2; // b2[7], b2[6] .. b1[0]
input clk;

5
 Carnegie Mellon

Structural HDL Example

Short Instantiation
module top (A, SEL, C, Y);
input A, SEL, C;
output Y;
wire n1;

// alternative
small i_first ( A, SEL, n1 );

/* Shorter instantiation,
pin order very important */ module small (A, B, Y);
input A;
// any pin order, safer choice input B;
small i2 ( .B(C), output Y;
.Y(Y),
.A(n1) ); // description of small

endmodule endmodule

6
 Carnegie Mellon

Summary: Bitwise Operators

module gates(input [3:0] a, b,
output [3:0] y1, y2, y3, y4, y5);

/* Five different two-input logic

gates acting on 4 bit busses */

assign y1 = a & b; // AND

assign y2 = a | b; // OR
assign y3 = a ^ b; // XOR
assign y4 = ~(a & b); // NAND
assign y5 = ~(a | b); // NOR

endmodule

7
 Carnegie Mellon

Summary: Conditional Assignment

? : is also called a ternary operator because it operates on
3 inputs:
s
d1
d0.

module mux2(input [3:0] d0, d1,

input s,
output [3:0] y);

assign y = s ? d1 : d0;
// if (s) then y=d1 else y=d0;

endmodule
8
 Carnegie Mellon

Summary: How to Express numbers ?

NBxx
8b0000_0001

(N) Number of bits

Expresses how many bits will be used to store the value

(B) Base
Can be b (binary), h (hexadecimal), d (decimal), o (octal)

(xx) Number
The value expressed in base, apart from numbers it can also have X and Z
as values.
Underscore _ can be used to improve readability
9
 Carnegie Mellon

Summary: Verilog Number Representation

Verilog Stored Number Verilog Stored Number

4b1001 1001 4d5 0101

8b1001 0000 1001 12hFA3 1111 1001 0011

8b0000_1001 0000 1001 8o12 00 001 010

8bxX0X1zZ1 XX0X 1ZZ1 4h7 0111

b01 0000 .. 0001 12h0 0000 0000 0000

10
 Carnegie Mellon

Precedence of Operations in Verilog

Highest ~ NOT
*, /, % mult, div, mod
+, - add,sub
<<, >> shift

<<<, >>> arithmetic shift

<, <=, >, >= comparison
==, != equal, not equal
&, ~& AND, NAND
^, ~^ XOR, XNOR
|, ~| OR, NOR
Lowest ?: ternary operator

11
 Carnegie Mellon

Sequential Logic in Verilog

Define blocks that have memory
Flip-Flops, Latches, Finite State Machines

Sequential Logic is triggered by a CLOCK event

Latches are sensitive to level of the signal
Flip-flops are sensitive to the transitioning of clock

Combinational constructs are not sufficient

We need new constructs:
always
initial

12
 Carnegie Mellon

always Statement, Defining Processes

always @ (sensitivity list)
statement;

Whenever the event in the sensitivity list occurs, the

statement is executed

13
 Carnegie Mellon

Example: D Flip-Flop
module flop(input clk,
input [3:0] d,
output reg [3:0] q);

always @ (posedge clk)

q <= d; // pronounced q gets d

endmodule

14
 Carnegie Mellon

Example: D Flip-Flop
module flop(input clk,
input [3:0] d,
output reg [3:0] q);

always @ (posedge clk)

q <= d; // pronounced q gets d

endmodule
The posedge defines a rising edge (transition from 0 to 1).

This process will trigger only if the clk signal rises.

Once the clk signal rises: the value of d will be copied to q

15
 Carnegie Mellon

Example: D Flip-Flop
module flop(input clk,
input [3:0] d,
output reg [3:0] q);

always @ (posedge clk)

q <= d; // pronounced q gets d

endmodule
assign statement is not used within always block

The <= describes a non-blocking assignment

We will see the difference between blocking assignment and
non-blocking assignment in a while

16
 Carnegie Mellon

Example: D Flip-Flop
module flop(input clk,
input [3:0] d,
output reg [3:0] q);

always @ (posedge clk)

q <= d; // pronounced q gets d

endmodule
Assigned variables need to be declared as reg

The name reg does not necessarily mean that the value is
a register. (It could be, it does not have to be).

We will see examples later

17
 Carnegie Mellon

D Flip-Flop with Asynchronous Reset

module flop_ar (input clk,
input reset,
input [3:0] d,
output reg [3:0] q);

always @ (posedge clk, negedge reset)

begin
if (reset == 0) q <= 0; // when reset
else q <= d; // when clk
end
endmodule

In this example: two events can trigger the process:

A rising edge on clk
A falling edge on reset

18
 Carnegie Mellon

D Flip-Flop with Asynchronous Reset

module flop_ar (input clk,
input reset,
input [3:0] d,
output reg [3:0] q);

always @ (posedge clk, negedge reset)

begin
if (reset == 0) q <= 0; // when reset
else q <= d; // when clk
end
endmodule

For longer statements a begin end pair can be used

In this example it was not necessary

The always block is highlighted

19
 Carnegie Mellon

D Flip-Flop with Asynchronous Reset

module flop_ar (input clk,
input reset,
input [3:0] d,
output reg [3:0] q);

always @ (posedge clk, negedge reset)

begin
if (reset == 0) q <= 0; // when reset
else q <= d; // when clk
end
endmodule

First reset is checked, if reset is 0, q is set to 0.

This is an asynchronous reset as the reset does not care what
happens with the clock

If there is no reset then normal assignment is made

20
 Carnegie Mellon

D Flip-Flop with Synchronous Reset

module flop_sr (input clk,
input reset,
input [3:0] d,
output reg [3:0] q);

always @ (posedge clk)

begin
if (reset == 0) q <= 0; // when reset
else q <= d; // when clk
end
endmodule

The process is only sensitive to clock

Reset only happens when the clock rises. This is a synchronous
reset

A small change, has a large impact on the outcome

21
 Carnegie Mellon

D Flip-Flop with Enable and Reset

module flop_ar (input clk,
input reset,
input en,
input [3:0] d,
output reg [3:0] q);

always @ (posedge clk. negedge reset)

begin
if (reset == 0) q <= 0; // when reset
else if (en) q <= d; // when en AND clk
end
endmodule

A flip-flop with enable and reset

Note that the en signal is not in the sensitivity list

Only when clk is rising AND en is 1 data is stored

22
 Carnegie Mellon

Example: D Latch
module latch (input clk,
input [3:0] d,
output reg [3:0] q);

always @ (clk, d)
if (clk) q <= d; // latch is transparent when
// clock is 1
endmodule

lat
[3:0] [3:0]
d[3:0] D[3:0] [3:0] [3:0]
Q[3:0] q[3:0]
clk C

q[3:0]

23
 Carnegie Mellon

Summary: Sequential Statements so far

Sequential statements are within an always block

The sequential block is triggered with a change in the

sensitivity list

Signals assigned within an always must be declared as

reg

We use <= for (non-blocking) assignments and do not use

assign within the always block.

24
 Carnegie Mellon

Summary: Basics of always Statements

module example (input clk,
input [3:0] d,
output reg [3:0] q);

wire [3:0] normal; // standard wire

reg [3:0] special; // assigned in always

always @ (posedge clk)

special <= d; // first FF array

assign normal = ~ special; // simple assignment

always @ (posedge clk)

q <= normal; // second FF array
endmodule

You can have many always blocks

25
 Carnegie Mellon

Summary: Basics of always Statements

module example (input clk,
input [3:0] d,
output reg [3:0] q);

wire [3:0] normal; // standard wire

reg [3:0] special; // assigned in always

always @ (posedge clk)

special <= d; // first FF array

assign normal = ~ special; // simple assignment

always @ (posedge clk)

q <= normal; // second FF array
endmodule

Assignments are different within always blocks

26
 Carnegie Mellon

Why does an always Statement Memorize?

module flop (input clk,
input [3:0] d,
output reg [3:0] q);

always @ (posedge clk)

begin
q <= d; // when clk rises copy d to q
end
endmodule

This statement describes what happens to signal q

but what happens when clock is not rising?

27
 Carnegie Mellon

Why does an always Statement Memorize?

module flop (input clk,
input [3:0] d,
output reg [3:0] q);

always @ (posedge clk)

begin
q <= d; // when clk rises copy d to q
end
endmodule

This statement describes what happens to signal q

but what happens when clock is not rising?

The value of q is preserved (memorized)

28
 Carnegie Mellon

Why does an always Statement Memorize?

module comb (input inv,
input [3:0] data,
output reg [3:0] result);

always @ (inv, data) // trigger with inv, data

if (inv) result <= ~data;// result is inverted data
else result <= data; // result is data

endmodule

This statement describes what happens to signal result

When inv is 1, result is ~data
What happens when inv is not 1 ?

29
 Carnegie Mellon

Why does an always Statement Memorize?

module comb (input inv,
input [3:0] data,
output reg [3:0] result);

always @ (inv, data) // trigger with inv, data

if (inv) result <= ~data;// result is inverted data
else result <= data; // result is data

endmodule

This statement describes what happens to signal result

When inv is 1, result is ~data
When inv is not 1, result is data

Circuit is combinational (no memory)

The output (result) is defined for all possible inputs (inv data)
30
 Carnegie Mellon

always Blocks for Combinational Circuits

If the statements define the signals completely, nothing is
memorized, block becomes combinational.
Care must be taken, it is easy to make mistakes and unintentionally
describe memorizing elements (latches).

Always blocks allow powerful statements

if .. then .. else
case

Use always blocks only if it makes your job easier

31
 Carnegie Mellon

Always Statement is not Always Practical

reg [31:0] result;
wire [31:0] a, b, comb;
wire sel,

always @ (a, b, sel) // trigger with a, b, sel

if (sel) result <= a; // result is a
else result <= b; // result is b

assign comb = sel ? a : b;

endmodule

Both statements describe the same multiplexer

In this case, the always block is more work

32
 Carnegie Mellon

Sometimes Always Statements are Great

module sevensegment (input [3:0] data,
output reg [6:0] segments);

always @ ( * ) // * is short for all signals

case (data) // case statement
0: segments = 7'b111_1110; // when data is 0
1: segments = 7'b011_0000; // when data is 1
2: segments = 7'b110_1101;
3: segments = 7'b111_1001;
4: segments = 7'b011_0011;
5: segments = 7'b101_1011;
// etc etc
default: segments = 7'b000_0000; // required
endcase

endmodule

33
 Carnegie Mellon

The case Statement

Like if .. then .. else can only be used in always
blocks

The result is combinational only if the output is defined for

all cases
Did we mention this before ?

Always use a default case to make sure you did not

forget a case (which would infer a latch)

Use casez statement to be able to check for dont cares

See book page 202, example 4.28

34
 Carnegie Mellon

Non-blocking and Blocking Statements

Non-blocking Blocking
always @ (a) always @ (a)
begin begin
a <= 2b01; a = 2b01;
b <= a; // a is 2b01
// all assignments are made here b = a;
// b is not (yet) 2b01 // b is now 2b01 as well
end end

Values are assigned at the Value is assigned

end of the block. immediately.

All assignments are made Process waits until the first

in parallel, process flow is assignment is complete, it
not-blocked. blocks progress.
35
 Carnegie Mellon

Why use (Non)-Blocking Statements

There are technical reasons why both are required
It is out of the scope of this course to discuss these

Blocking statements allow sequential descriptions

More like a programming language

If the sensitivity list is correct, blocks with non-blocking

statements will always evaluate to the same result
It may require some additional iterations

36
 Carnegie Mellon

Example: Blocking Statements

Assume all inputs are initially 0
always @ ( * )
begin
p = a ^ b ; // p = 0
g = a & b ; // g = 0
s = p ^ cin ; // s = 0
cout = g | (p & cin) ; // cout = 0
end

37
 Carnegie Mellon

Example: Blocking Statements

Now a changes to 1
always @ ( * )
begin
p = a ^ b ; // p = 1
g = a & b ; // g = 0
s = p ^ cin ; // s = 1
cout = g | (p & cin) ; // cout = 0
end

The process triggers

All values are updated in order

At the end, s = 1

38
 Carnegie Mellon

Same Example: Non-Blocking Statements

Assume all inputs are initially 0
always @ ( * )
begin
p <= a ^ b ; // p = 0
g <= a & b ; // g = 0
s <= p ^ cin ; // s = 0
cout <= g | (p & cin) ; // cout = 0
end

39
 Carnegie Mellon

Same Example: Non-Blocking Statements

Now a changes to 1
always @ ( * )
begin
p <= a ^ b ; // p = 1
g <= a & b ; // g = 0
s <= p ^ cin ; // s = 0
cout <= g | (p & cin) ; // cout = 0
end

The process triggers

All assignments are concurrent

When s is being assigned, p is still 0, result is still 0

40
 Carnegie Mellon

Same Example: Non-Blocking Statements

After the first iteration p has changed to 1 as well
always @ ( * )
begin
p <= a ^ b ; // p = 1
g <= a & b ; // g = 0
s <= p ^ cin ; // s = 1
cout <= g | (p & cin) ; // cout = 0
end

Since there is a change in p, process triggers again

This time s is calculated with p=1

The result is correct after the second iteration

41
 Carnegie Mellon

Rules for Signal Assignment

Use always @(posedge clk) and non-blocking
assignments (<=) to model synchronous sequential logic
always @ (posedge clk)
q <= d; // nonblocking

Use continuous assignments (assign )to model simple

combinational logic.
assign y = a & b;

42
 Carnegie Mellon

Rules for Signal Assignment (cont)

Use always @ (*) and blocking assignments (=) to
model more complicated combinational logic where the
always statement is helpful.

Do not make assignments to the same signal in more than

one always statement or continuous assignment
statement

43
 Carnegie Mellon

Finite State Machines (FSMs)

Each FSM consists of three separate parts:
next state logic
state register
output logic

CLK
M next
next k state k state output N
inputs state outputs
logic
logic

44
 Carnegie Mellon

FSM Example: Divide by 3

S2

S0

S1

45
 Carnegie Mellon

FSM in Verilog, Definitions

module divideby3FSM (input clk,
input reset,
output q);

reg [1:0] state, nextstate;

parameter S0 = 2'b00;
parameter S1 = 2'b01;
parameter S2 = 2'b10;

We define state and nextstate as 2-bit reg

The parameter descriptions are optional, it makes reading

easier

46
 Carnegie Mellon

FSM in Verilog, State Register

// state register
always @ (posedge clk, posedge reset)
if (reset) state <= S0;
else state <= nextstate;

This part defines the state register (memorizing process)

Sensitive to only clk, reset

In this example reset is active when 1

47
 Carnegie Mellon

FSM in Verilog, Next State Calculation

// next state logic
always @ (*)
case (state)
S0: nextstate = S1;
S1: nextstate = S2;
S2: nextstate = S0;
default: nextstate = S0;
endcase

Based on the value of state we determine the value of

nextstate

An always .. case statement is used for simplicity.

48
 Carnegie Mellon

FSM in Verilog, Output Assignments

// output logic
assign q = (state == S0);

In this example, output depends only on state

Moore type FSM

We used a simple combinational assign

49
 Carnegie Mellon

FSM in Verilog, Whole Code

module divideby3FSM (input clk, input reset, output q);
reg [1:0] state, nextstate;

parameter S0 = 2'b00;
parameter S1 = 2'b01;
parameter S2 = 2'b10;

always @ (posedge clk, posedge reset) // state register

if (reset) state <= S0;
else state <= nextstate;
always @ (*) // next state logic
case (state)
S0: nextstate = S1;
S1: nextstate = S2;
S2: nextstate = S0;
default: nextstate = S0;
endcase
assign q = (state == S0); // output logic
endmodule

50
 Carnegie Mellon

What Did We Learn?

Basics of Defining Sequential Circuits in Verilog

Always statement
Is needed for defining memorizing elements (flip-flops, latches)
Can also be used to define combinational circuits

Blocking vs Non-blocking statements

= assigns the value immediately
<= assigns the value at the end of the block

Writing FSMs
Next state calculation
Determining outputs
State assignment
51